Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
james qian wang (Arm Technology China) | 5937 | 93.57% | 29 | 64.44% |
Lowry Li | 346 | 5.45% | 9 | 20.00% |
Carsten Haitzler | 25 | 0.39% | 2 | 4.44% |
baozhu.liu | 19 | 0.30% | 1 | 2.22% |
Matthew Wilcox | 12 | 0.19% | 1 | 2.22% |
Amjad Ouled-Ameur | 3 | 0.05% | 1 | 2.22% |
Mihail Atanassov | 2 | 0.03% | 1 | 2.22% |
pengfuyuan | 1 | 0.02% | 1 | 2.22% |
Total | 6345 | 45 |
// SPDX-License-Identifier: GPL-2.0 /* * (C) COPYRIGHT 2018 ARM Limited. All rights reserved. * Author: James.Qian.Wang <james.qian.wang@arm.com> * */ #include <drm/drm_print.h> #include <linux/clk.h> #include "komeda_dev.h" #include "komeda_kms.h" #include "komeda_pipeline.h" #include "komeda_framebuffer.h" static inline bool is_switching_user(void *old, void *new) { if (!old || !new) return false; return old != new; } static struct komeda_pipeline_state * komeda_pipeline_get_state(struct komeda_pipeline *pipe, struct drm_atomic_state *state) { struct drm_private_state *priv_st; priv_st = drm_atomic_get_private_obj_state(state, &pipe->obj); if (IS_ERR(priv_st)) return ERR_CAST(priv_st); return priv_to_pipe_st(priv_st); } struct komeda_pipeline_state * komeda_pipeline_get_old_state(struct komeda_pipeline *pipe, struct drm_atomic_state *state) { struct drm_private_state *priv_st; priv_st = drm_atomic_get_old_private_obj_state(state, &pipe->obj); if (priv_st) return priv_to_pipe_st(priv_st); return NULL; } static struct komeda_pipeline_state * komeda_pipeline_get_new_state(struct komeda_pipeline *pipe, struct drm_atomic_state *state) { struct drm_private_state *priv_st; priv_st = drm_atomic_get_new_private_obj_state(state, &pipe->obj); if (priv_st) return priv_to_pipe_st(priv_st); return NULL; } /* Assign pipeline for crtc */ static struct komeda_pipeline_state * komeda_pipeline_get_state_and_set_crtc(struct komeda_pipeline *pipe, struct drm_atomic_state *state, struct drm_crtc *crtc) { struct komeda_pipeline_state *st; st = komeda_pipeline_get_state(pipe, state); if (IS_ERR(st)) return st; if (is_switching_user(crtc, st->crtc)) { DRM_DEBUG_ATOMIC("CRTC%d required pipeline%d is busy.\n", drm_crtc_index(crtc), pipe->id); return ERR_PTR(-EBUSY); } /* pipeline only can be disabled when the it is free or unused */ if (!crtc && st->active_comps) { DRM_DEBUG_ATOMIC("Disabling a busy pipeline:%d.\n", pipe->id); return ERR_PTR(-EBUSY); } st->crtc = crtc; if (crtc) { struct komeda_crtc_state *kcrtc_st; kcrtc_st = to_kcrtc_st(drm_atomic_get_new_crtc_state(state, crtc)); kcrtc_st->active_pipes |= BIT(pipe->id); kcrtc_st->affected_pipes |= BIT(pipe->id); } return st; } static struct komeda_component_state * komeda_component_get_state(struct komeda_component *c, struct drm_atomic_state *state) { struct drm_private_state *priv_st; WARN_ON(!drm_modeset_is_locked(&c->pipeline->obj.lock)); priv_st = drm_atomic_get_private_obj_state(state, &c->obj); if (IS_ERR(priv_st)) return ERR_CAST(priv_st); return priv_to_comp_st(priv_st); } static struct komeda_component_state * komeda_component_get_old_state(struct komeda_component *c, struct drm_atomic_state *state) { struct drm_private_state *priv_st; priv_st = drm_atomic_get_old_private_obj_state(state, &c->obj); if (priv_st) return priv_to_comp_st(priv_st); return NULL; } /** * komeda_component_get_state_and_set_user() * * @c: component to get state and set user * @state: global atomic state * @user: direct user, the binding user * @crtc: the CRTC user, the big boss :) * * This function accepts two users: * - The direct user: can be plane/crtc/wb_connector depends on component * - The big boss (CRTC) * CRTC is the big boss (the final user), because all component resources * eventually will be assigned to CRTC, like the layer will be binding to * kms_plane, but kms plane will be binding to a CRTC eventually. * * The big boss (CRTC) is for pipeline assignment, since &komeda_component isn't * independent and can be assigned to CRTC freely, but belongs to a specific * pipeline, only pipeline can be shared between crtc, and pipeline as a whole * (include all the internal components) assigned to a specific CRTC. * * So when set a user to komeda_component, need first to check the status of * component->pipeline to see if the pipeline is available on this specific * CRTC. if the pipeline is busy (assigned to another CRTC), even the required * component is free, the component still cannot be assigned to the direct user. */ static struct komeda_component_state * komeda_component_get_state_and_set_user(struct komeda_component *c, struct drm_atomic_state *state, void *user, struct drm_crtc *crtc) { struct komeda_pipeline_state *pipe_st; struct komeda_component_state *st; /* First check if the pipeline is available */ pipe_st = komeda_pipeline_get_state_and_set_crtc(c->pipeline, state, crtc); if (IS_ERR(pipe_st)) return ERR_CAST(pipe_st); st = komeda_component_get_state(c, state); if (IS_ERR(st)) return st; /* check if the component has been occupied */ if (is_switching_user(user, st->binding_user)) { DRM_DEBUG_ATOMIC("required %s is busy.\n", c->name); return ERR_PTR(-EBUSY); } st->binding_user = user; /* mark the component as active if user is valid */ if (st->binding_user) pipe_st->active_comps |= BIT(c->id); return st; } static void komeda_component_add_input(struct komeda_component_state *state, struct komeda_component_output *input, int idx) { struct komeda_component *c = state->component; WARN_ON((idx < 0 || idx >= c->max_active_inputs)); /* since the inputs[i] is only valid when it is active. So if a input[i] * is a newly enabled input which switches from disable to enable, then * the old inputs[i] is undefined (NOT zeroed), we can not rely on * memcmp, but directly mark it changed */ if (!has_bit(idx, state->affected_inputs) || memcmp(&state->inputs[idx], input, sizeof(*input))) { memcpy(&state->inputs[idx], input, sizeof(*input)); state->changed_active_inputs |= BIT(idx); } state->active_inputs |= BIT(idx); state->affected_inputs |= BIT(idx); } static int komeda_component_check_input(struct komeda_component_state *state, struct komeda_component_output *input, int idx) { struct komeda_component *c = state->component; if ((idx < 0) || (idx >= c->max_active_inputs)) { DRM_DEBUG_ATOMIC("%s required an invalid %s-input[%d].\n", input->component->name, c->name, idx); return -EINVAL; } if (has_bit(idx, state->active_inputs)) { DRM_DEBUG_ATOMIC("%s required %s-input[%d] has been occupied already.\n", input->component->name, c->name, idx); return -EINVAL; } return 0; } static void komeda_component_set_output(struct komeda_component_output *output, struct komeda_component *comp, u8 output_port) { output->component = comp; output->output_port = output_port; } static int komeda_component_validate_private(struct komeda_component *c, struct komeda_component_state *st) { int err; if (!c->funcs->validate) return 0; err = c->funcs->validate(c, st); if (err) DRM_DEBUG_ATOMIC("%s validate private failed.\n", c->name); return err; } /* Get current available scaler from the component->supported_outputs */ static struct komeda_scaler * komeda_component_get_avail_scaler(struct komeda_component *c, struct drm_atomic_state *state) { struct komeda_pipeline_state *pipe_st; u32 avail_scalers; pipe_st = komeda_pipeline_get_state(c->pipeline, state); if (IS_ERR_OR_NULL(pipe_st)) return NULL; avail_scalers = (pipe_st->active_comps & KOMEDA_PIPELINE_SCALERS) ^ KOMEDA_PIPELINE_SCALERS; c = komeda_component_pickup_output(c, avail_scalers); return to_scaler(c); } static void komeda_rotate_data_flow(struct komeda_data_flow_cfg *dflow, u32 rot) { if (drm_rotation_90_or_270(rot)) { swap(dflow->in_h, dflow->in_w); swap(dflow->total_in_h, dflow->total_in_w); } } static int komeda_layer_check_cfg(struct komeda_layer *layer, struct komeda_fb *kfb, struct komeda_data_flow_cfg *dflow) { u32 src_x, src_y, src_w, src_h; u32 line_sz, max_line_sz; if (!komeda_fb_is_layer_supported(kfb, layer->layer_type, dflow->rot)) return -EINVAL; if (layer->base.id == KOMEDA_COMPONENT_WB_LAYER) { src_x = dflow->out_x; src_y = dflow->out_y; src_w = dflow->out_w; src_h = dflow->out_h; } else { src_x = dflow->in_x; src_y = dflow->in_y; src_w = dflow->in_w; src_h = dflow->in_h; } if (komeda_fb_check_src_coords(kfb, src_x, src_y, src_w, src_h)) return -EINVAL; if (!malidp_in_range(&layer->hsize_in, src_w)) { DRM_DEBUG_ATOMIC("invalidate src_w %d.\n", src_w); return -EINVAL; } if (!malidp_in_range(&layer->vsize_in, src_h)) { DRM_DEBUG_ATOMIC("invalidate src_h %d.\n", src_h); return -EINVAL; } if (drm_rotation_90_or_270(dflow->rot)) line_sz = dflow->in_h; else line_sz = dflow->in_w; if (kfb->base.format->hsub > 1) max_line_sz = layer->yuv_line_sz; else max_line_sz = layer->line_sz; if (line_sz > max_line_sz) { DRM_DEBUG_ATOMIC("Required line_sz: %d exceeds the max size %d\n", line_sz, max_line_sz); return -EINVAL; } return 0; } static int komeda_layer_validate(struct komeda_layer *layer, struct komeda_plane_state *kplane_st, struct komeda_data_flow_cfg *dflow) { struct drm_plane_state *plane_st = &kplane_st->base; struct drm_framebuffer *fb = plane_st->fb; struct komeda_fb *kfb = to_kfb(fb); struct komeda_component_state *c_st; struct komeda_layer_state *st; int i, err; err = komeda_layer_check_cfg(layer, kfb, dflow); if (err) return err; c_st = komeda_component_get_state_and_set_user(&layer->base, plane_st->state, plane_st->plane, plane_st->crtc); if (IS_ERR(c_st)) return PTR_ERR(c_st); st = to_layer_st(c_st); st->rot = dflow->rot; if (fb->modifier) { st->hsize = kfb->aligned_w; st->vsize = kfb->aligned_h; st->afbc_crop_l = dflow->in_x; st->afbc_crop_r = kfb->aligned_w - dflow->in_x - dflow->in_w; st->afbc_crop_t = dflow->in_y; st->afbc_crop_b = kfb->aligned_h - dflow->in_y - dflow->in_h; } else { st->hsize = dflow->in_w; st->vsize = dflow->in_h; st->afbc_crop_l = 0; st->afbc_crop_r = 0; st->afbc_crop_t = 0; st->afbc_crop_b = 0; } for (i = 0; i < fb->format->num_planes; i++) st->addr[i] = komeda_fb_get_pixel_addr(kfb, dflow->in_x, dflow->in_y, i); err = komeda_component_validate_private(&layer->base, c_st); if (err) return err; /* update the data flow for the next stage */ komeda_component_set_output(&dflow->input, &layer->base, 0); /* * The rotation has been handled by layer, so adjusted the data flow for * the next stage. */ komeda_rotate_data_flow(dflow, st->rot); return 0; } static int komeda_wb_layer_validate(struct komeda_layer *wb_layer, struct drm_connector_state *conn_st, struct komeda_data_flow_cfg *dflow) { struct komeda_fb *kfb = to_kfb(conn_st->writeback_job->fb); struct komeda_component_state *c_st; struct komeda_layer_state *st; int i, err; err = komeda_layer_check_cfg(wb_layer, kfb, dflow); if (err) return err; c_st = komeda_component_get_state_and_set_user(&wb_layer->base, conn_st->state, conn_st->connector, conn_st->crtc); if (IS_ERR(c_st)) return PTR_ERR(c_st); st = to_layer_st(c_st); st->hsize = dflow->out_w; st->vsize = dflow->out_h; for (i = 0; i < kfb->base.format->num_planes; i++) st->addr[i] = komeda_fb_get_pixel_addr(kfb, dflow->out_x, dflow->out_y, i); komeda_component_add_input(&st->base, &dflow->input, 0); komeda_component_set_output(&dflow->input, &wb_layer->base, 0); return 0; } static bool scaling_ratio_valid(u32 size_in, u32 size_out, u32 max_upscaling, u32 max_downscaling) { if (size_out > size_in * max_upscaling) return false; else if (size_in > size_out * max_downscaling) return false; return true; } static int komeda_scaler_check_cfg(struct komeda_scaler *scaler, struct komeda_crtc_state *kcrtc_st, struct komeda_data_flow_cfg *dflow) { u32 hsize_in, vsize_in, hsize_out, vsize_out; u32 max_upscaling; hsize_in = dflow->in_w; vsize_in = dflow->in_h; hsize_out = dflow->out_w; vsize_out = dflow->out_h; if (!malidp_in_range(&scaler->hsize, hsize_in) || !malidp_in_range(&scaler->hsize, hsize_out)) { DRM_DEBUG_ATOMIC("Invalid horizontal sizes"); return -EINVAL; } if (!malidp_in_range(&scaler->vsize, vsize_in) || !malidp_in_range(&scaler->vsize, vsize_out)) { DRM_DEBUG_ATOMIC("Invalid vertical sizes"); return -EINVAL; } /* If input comes from compiz that means the scaling is for writeback * and scaler can not do upscaling for writeback */ if (has_bit(dflow->input.component->id, KOMEDA_PIPELINE_COMPIZS)) max_upscaling = 1; else max_upscaling = scaler->max_upscaling; if (!scaling_ratio_valid(hsize_in, hsize_out, max_upscaling, scaler->max_downscaling)) { DRM_DEBUG_ATOMIC("Invalid horizontal scaling ratio"); return -EINVAL; } if (!scaling_ratio_valid(vsize_in, vsize_out, max_upscaling, scaler->max_downscaling)) { DRM_DEBUG_ATOMIC("Invalid vertical scaling ratio"); return -EINVAL; } if (hsize_in > hsize_out || vsize_in > vsize_out) { struct komeda_pipeline *pipe = scaler->base.pipeline; int err; err = pipe->funcs->downscaling_clk_check(pipe, &kcrtc_st->base.adjusted_mode, komeda_crtc_get_aclk(kcrtc_st), dflow); if (err) { DRM_DEBUG_ATOMIC("aclk can't satisfy the clock requirement of the downscaling\n"); return err; } } return 0; } static int komeda_scaler_validate(void *user, struct komeda_crtc_state *kcrtc_st, struct komeda_data_flow_cfg *dflow) { struct drm_atomic_state *drm_st = kcrtc_st->base.state; struct komeda_component_state *c_st; struct komeda_scaler_state *st; struct komeda_scaler *scaler; int err = 0; if (!(dflow->en_scaling || dflow->en_img_enhancement)) return 0; scaler = komeda_component_get_avail_scaler(dflow->input.component, drm_st); if (!scaler) { DRM_DEBUG_ATOMIC("No scaler available"); return -EINVAL; } err = komeda_scaler_check_cfg(scaler, kcrtc_st, dflow); if (err) return err; c_st = komeda_component_get_state_and_set_user(&scaler->base, drm_st, user, kcrtc_st->base.crtc); if (IS_ERR(c_st)) return PTR_ERR(c_st); st = to_scaler_st(c_st); st->hsize_in = dflow->in_w; st->vsize_in = dflow->in_h; st->hsize_out = dflow->out_w; st->vsize_out = dflow->out_h; st->right_crop = dflow->right_crop; st->left_crop = dflow->left_crop; st->total_vsize_in = dflow->total_in_h; st->total_hsize_in = dflow->total_in_w; st->total_hsize_out = dflow->total_out_w; /* Enable alpha processing if the next stage needs the pixel alpha */ st->en_alpha = dflow->pixel_blend_mode != DRM_MODE_BLEND_PIXEL_NONE; st->en_scaling = dflow->en_scaling; st->en_img_enhancement = dflow->en_img_enhancement; st->en_split = dflow->en_split; st->right_part = dflow->right_part; komeda_component_add_input(&st->base, &dflow->input, 0); komeda_component_set_output(&dflow->input, &scaler->base, 0); return err; } static void komeda_split_data_flow(struct komeda_scaler *scaler, struct komeda_data_flow_cfg *dflow, struct komeda_data_flow_cfg *l_dflow, struct komeda_data_flow_cfg *r_dflow); static int komeda_splitter_validate(struct komeda_splitter *splitter, struct drm_connector_state *conn_st, struct komeda_data_flow_cfg *dflow, struct komeda_data_flow_cfg *l_output, struct komeda_data_flow_cfg *r_output) { struct komeda_component_state *c_st; struct komeda_splitter_state *st; if (!splitter) { DRM_DEBUG_ATOMIC("Current HW doesn't support splitter.\n"); return -EINVAL; } if (!malidp_in_range(&splitter->hsize, dflow->in_w)) { DRM_DEBUG_ATOMIC("split in_w:%d is out of the acceptable range.\n", dflow->in_w); return -EINVAL; } if (!malidp_in_range(&splitter->vsize, dflow->in_h)) { DRM_DEBUG_ATOMIC("split in_h: %d exceeds the acceptable range.\n", dflow->in_h); return -EINVAL; } c_st = komeda_component_get_state_and_set_user(&splitter->base, conn_st->state, conn_st->connector, conn_st->crtc); if (IS_ERR(c_st)) return PTR_ERR(c_st); komeda_split_data_flow(splitter->base.pipeline->scalers[0], dflow, l_output, r_output); st = to_splitter_st(c_st); st->hsize = dflow->in_w; st->vsize = dflow->in_h; st->overlap = dflow->overlap; komeda_component_add_input(&st->base, &dflow->input, 0); komeda_component_set_output(&l_output->input, &splitter->base, 0); komeda_component_set_output(&r_output->input, &splitter->base, 1); return 0; } static int komeda_merger_validate(struct komeda_merger *merger, void *user, struct komeda_crtc_state *kcrtc_st, struct komeda_data_flow_cfg *left_input, struct komeda_data_flow_cfg *right_input, struct komeda_data_flow_cfg *output) { struct komeda_component_state *c_st; struct komeda_merger_state *st; int err = 0; if (!merger) { DRM_DEBUG_ATOMIC("No merger is available"); return -EINVAL; } if (!malidp_in_range(&merger->hsize_merged, output->out_w)) { DRM_DEBUG_ATOMIC("merged_w: %d is out of the accepted range.\n", output->out_w); return -EINVAL; } if (!malidp_in_range(&merger->vsize_merged, output->out_h)) { DRM_DEBUG_ATOMIC("merged_h: %d is out of the accepted range.\n", output->out_h); return -EINVAL; } c_st = komeda_component_get_state_and_set_user(&merger->base, kcrtc_st->base.state, kcrtc_st->base.crtc, kcrtc_st->base.crtc); if (IS_ERR(c_st)) return PTR_ERR(c_st); st = to_merger_st(c_st); st->hsize_merged = output->out_w; st->vsize_merged = output->out_h; komeda_component_add_input(c_st, &left_input->input, 0); komeda_component_add_input(c_st, &right_input->input, 1); komeda_component_set_output(&output->input, &merger->base, 0); return err; } void pipeline_composition_size(struct komeda_crtc_state *kcrtc_st, u16 *hsize, u16 *vsize) { struct drm_display_mode *m = &kcrtc_st->base.adjusted_mode; if (hsize) *hsize = m->hdisplay; if (vsize) *vsize = m->vdisplay; } static int komeda_compiz_set_input(struct komeda_compiz *compiz, struct komeda_crtc_state *kcrtc_st, struct komeda_data_flow_cfg *dflow) { struct drm_atomic_state *drm_st = kcrtc_st->base.state; struct komeda_component_state *c_st, *old_st; struct komeda_compiz_input_cfg *cin; u16 compiz_w, compiz_h; int idx = dflow->blending_zorder; pipeline_composition_size(kcrtc_st, &compiz_w, &compiz_h); /* check display rect */ if ((dflow->out_x + dflow->out_w > compiz_w) || (dflow->out_y + dflow->out_h > compiz_h) || dflow->out_w == 0 || dflow->out_h == 0) { DRM_DEBUG_ATOMIC("invalid disp rect [x=%d, y=%d, w=%d, h=%d]\n", dflow->out_x, dflow->out_y, dflow->out_w, dflow->out_h); return -EINVAL; } c_st = komeda_component_get_state_and_set_user(&compiz->base, drm_st, kcrtc_st->base.crtc, kcrtc_st->base.crtc); if (IS_ERR(c_st)) return PTR_ERR(c_st); if (komeda_component_check_input(c_st, &dflow->input, idx)) return -EINVAL; cin = &(to_compiz_st(c_st)->cins[idx]); cin->hsize = dflow->out_w; cin->vsize = dflow->out_h; cin->hoffset = dflow->out_x; cin->voffset = dflow->out_y; cin->pixel_blend_mode = dflow->pixel_blend_mode; cin->layer_alpha = dflow->layer_alpha; old_st = komeda_component_get_old_state(&compiz->base, drm_st); /* compare with old to check if this input has been changed */ if (WARN_ON(!old_st) || memcmp(&(to_compiz_st(old_st)->cins[idx]), cin, sizeof(*cin))) c_st->changed_active_inputs |= BIT(idx); komeda_component_add_input(c_st, &dflow->input, idx); komeda_component_set_output(&dflow->input, &compiz->base, 0); return 0; } static int komeda_compiz_validate(struct komeda_compiz *compiz, struct komeda_crtc_state *state, struct komeda_data_flow_cfg *dflow) { struct komeda_component_state *c_st; struct komeda_compiz_state *st; c_st = komeda_component_get_state_and_set_user(&compiz->base, state->base.state, state->base.crtc, state->base.crtc); if (IS_ERR(c_st)) return PTR_ERR(c_st); st = to_compiz_st(c_st); pipeline_composition_size(state, &st->hsize, &st->vsize); komeda_component_set_output(&dflow->input, &compiz->base, 0); /* compiz output dflow will be fed to the next pipeline stage, prepare * the data flow configuration for the next stage */ if (dflow) { dflow->in_w = st->hsize; dflow->in_h = st->vsize; dflow->out_w = dflow->in_w; dflow->out_h = dflow->in_h; /* the output data of compiz doesn't have alpha, it only can be * used as bottom layer when blend it with master layers */ dflow->pixel_blend_mode = DRM_MODE_BLEND_PIXEL_NONE; dflow->layer_alpha = 0xFF; dflow->blending_zorder = 0; } return 0; } static int komeda_improc_validate(struct komeda_improc *improc, struct komeda_crtc_state *kcrtc_st, struct komeda_data_flow_cfg *dflow) { struct drm_crtc *crtc = kcrtc_st->base.crtc; struct drm_crtc_state *crtc_st = &kcrtc_st->base; struct komeda_component_state *c_st; struct komeda_improc_state *st; c_st = komeda_component_get_state_and_set_user(&improc->base, kcrtc_st->base.state, crtc, crtc); if (IS_ERR(c_st)) return PTR_ERR(c_st); st = to_improc_st(c_st); st->hsize = dflow->in_w; st->vsize = dflow->in_h; if (drm_atomic_crtc_needs_modeset(crtc_st)) { u32 output_depths, output_formats; u32 avail_depths, avail_formats; komeda_crtc_get_color_config(crtc_st, &output_depths, &output_formats); avail_depths = output_depths & improc->supported_color_depths; if (avail_depths == 0) { DRM_DEBUG_ATOMIC("No available color depths, conn depths: 0x%x & display: 0x%x\n", output_depths, improc->supported_color_depths); return -EINVAL; } avail_formats = output_formats & improc->supported_color_formats; if (!avail_formats) { DRM_DEBUG_ATOMIC("No available color_formats, conn formats 0x%x & display: 0x%x\n", output_formats, improc->supported_color_formats); return -EINVAL; } st->color_depth = __fls(avail_depths); st->color_format = BIT(__ffs(avail_formats)); } if (kcrtc_st->base.color_mgmt_changed) { drm_lut_to_fgamma_coeffs(kcrtc_st->base.gamma_lut, st->fgamma_coeffs); drm_ctm_to_coeffs(kcrtc_st->base.ctm, st->ctm_coeffs); } komeda_component_add_input(&st->base, &dflow->input, 0); komeda_component_set_output(&dflow->input, &improc->base, 0); return 0; } static int komeda_timing_ctrlr_validate(struct komeda_timing_ctrlr *ctrlr, struct komeda_crtc_state *kcrtc_st, struct komeda_data_flow_cfg *dflow) { struct drm_crtc *crtc = kcrtc_st->base.crtc; struct komeda_timing_ctrlr_state *st; struct komeda_component_state *c_st; c_st = komeda_component_get_state_and_set_user(&ctrlr->base, kcrtc_st->base.state, crtc, crtc); if (IS_ERR(c_st)) return PTR_ERR(c_st); st = to_ctrlr_st(c_st); komeda_component_add_input(&st->base, &dflow->input, 0); komeda_component_set_output(&dflow->input, &ctrlr->base, 0); return 0; } void komeda_complete_data_flow_cfg(struct komeda_layer *layer, struct komeda_data_flow_cfg *dflow, struct drm_framebuffer *fb) { struct komeda_scaler *scaler = layer->base.pipeline->scalers[0]; u32 w = dflow->in_w; u32 h = dflow->in_h; dflow->total_in_w = dflow->in_w; dflow->total_in_h = dflow->in_h; dflow->total_out_w = dflow->out_w; /* if format doesn't have alpha, fix blend mode to PIXEL_NONE */ if (!fb->format->has_alpha) dflow->pixel_blend_mode = DRM_MODE_BLEND_PIXEL_NONE; if (drm_rotation_90_or_270(dflow->rot)) swap(w, h); dflow->en_scaling = (w != dflow->out_w) || (h != dflow->out_h); dflow->is_yuv = fb->format->is_yuv; /* try to enable image enhancer if data flow is a 2x+ upscaling */ dflow->en_img_enhancement = dflow->out_w >= 2 * w || dflow->out_h >= 2 * h; /* try to enable split if scaling exceed the scaler's acceptable * input/output range. */ if (dflow->en_scaling && scaler) dflow->en_split = !malidp_in_range(&scaler->hsize, dflow->in_w) || !malidp_in_range(&scaler->hsize, dflow->out_w); } static bool merger_is_available(struct komeda_pipeline *pipe, struct komeda_data_flow_cfg *dflow) { u32 avail_inputs = pipe->merger ? pipe->merger->base.supported_inputs : 0; return has_bit(dflow->input.component->id, avail_inputs); } 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) { struct drm_plane *plane = kplane_st->base.plane; struct komeda_pipeline *pipe = layer->base.pipeline; int err; 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]", layer->base.name, plane->base.id, plane->name, dflow->in_x, dflow->in_y, dflow->in_w, dflow->in_h, dflow->out_x, dflow->out_y, dflow->out_w, dflow->out_h); err = komeda_layer_validate(layer, kplane_st, dflow); if (err) return err; err = komeda_scaler_validate(plane, kcrtc_st, dflow); if (err) return err; /* if split, check if can put the data flow into merger */ if (dflow->en_split && merger_is_available(pipe, dflow)) return 0; err = komeda_compiz_set_input(pipe->compiz, kcrtc_st, dflow); return err; } /* * Split is introduced for workaround scaler's input/output size limitation. * The idea is simple, if one scaler can not fit the requirement, use two. * So split splits the big source image to two half parts (left/right) and do * the scaling by two scaler separately and independently. * But split also imports an edge problem in the middle of the image when * scaling, to avoid it, split isn't a simple half-and-half, but add an extra * pixels (overlap) to both side, after split the left/right will be: * - left: [0, src_length/2 + overlap] * - right: [src_length/2 - overlap, src_length] * The extra overlap do eliminate the edge problem, but which may also generates * unnecessary pixels when scaling, we need to crop them before scaler output * the result to the next stage. and for the how to crop, it depends on the * unneeded pixels, another words the position where overlay has been added. * - left: crop the right * - right: crop the left * * The diagram for how to do the split * * <---------------------left->out_w ----------------> * |--------------------------------|---right_crop-----| <- left after split * \ \ / * \ \<--overlap--->/ * |-----------------|-------------|(Middle)------|-----------------| <- src * /<---overlap--->\ \ * / \ \ * right after split->|-----left_crop---|--------------------------------| * ^<------------------- right->out_w --------------->^ * * NOTE: To consistent with HW the output_w always contains the crop size. */ static void komeda_split_data_flow(struct komeda_scaler *scaler, struct komeda_data_flow_cfg *dflow, struct komeda_data_flow_cfg *l_dflow, struct komeda_data_flow_cfg *r_dflow) { bool r90 = drm_rotation_90_or_270(dflow->rot); bool flip_h = has_flip_h(dflow->rot); u32 l_out, r_out, overlap; memcpy(l_dflow, dflow, sizeof(*dflow)); memcpy(r_dflow, dflow, sizeof(*dflow)); l_dflow->right_part = false; r_dflow->right_part = true; r_dflow->blending_zorder = dflow->blending_zorder + 1; overlap = 0; if (dflow->en_scaling && scaler) overlap += scaler->scaling_split_overlap; /* original dflow may fed into splitter, and which doesn't need * enhancement overlap */ dflow->overlap = overlap; if (dflow->en_img_enhancement && scaler) overlap += scaler->enh_split_overlap; l_dflow->overlap = overlap; r_dflow->overlap = overlap; /* split the origin content */ /* left/right here always means the left/right part of display image, * not the source Image */ /* DRM rotation is anti-clockwise */ if (r90) { if (dflow->en_scaling) { l_dflow->in_h = ALIGN(dflow->in_h, 2) / 2 + l_dflow->overlap; r_dflow->in_h = l_dflow->in_h; } else if (dflow->en_img_enhancement) { /* enhancer only */ l_dflow->in_h = ALIGN(dflow->in_h, 2) / 2 + l_dflow->overlap; r_dflow->in_h = dflow->in_h / 2 + r_dflow->overlap; } else { /* split without scaler, no overlap */ l_dflow->in_h = ALIGN(((dflow->in_h + 1) >> 1), 2); r_dflow->in_h = dflow->in_h - l_dflow->in_h; } /* Consider YUV format, after split, the split source w/h * may not aligned to 2. we have two choices for such case. * 1. scaler is enabled (overlap != 0), we can do a alignment * both left/right and crop the extra data by scaler. * 2. scaler is not enabled, only align the split left * src/disp, and the rest part assign to right */ if ((overlap != 0) && dflow->is_yuv) { l_dflow->in_h = ALIGN(l_dflow->in_h, 2); r_dflow->in_h = ALIGN(r_dflow->in_h, 2); } if (flip_h) l_dflow->in_y = dflow->in_y + dflow->in_h - l_dflow->in_h; else r_dflow->in_y = dflow->in_y + dflow->in_h - r_dflow->in_h; } else { if (dflow->en_scaling) { l_dflow->in_w = ALIGN(dflow->in_w, 2) / 2 + l_dflow->overlap; r_dflow->in_w = l_dflow->in_w; } else if (dflow->en_img_enhancement) { l_dflow->in_w = ALIGN(dflow->in_w, 2) / 2 + l_dflow->overlap; r_dflow->in_w = dflow->in_w / 2 + r_dflow->overlap; } else { l_dflow->in_w = ALIGN(((dflow->in_w + 1) >> 1), 2); r_dflow->in_w = dflow->in_w - l_dflow->in_w; } /* do YUV alignment when scaler enabled */ if ((overlap != 0) && dflow->is_yuv) { l_dflow->in_w = ALIGN(l_dflow->in_w, 2); r_dflow->in_w = ALIGN(r_dflow->in_w, 2); } /* on flip_h, the left display content from the right-source */ if (flip_h) l_dflow->in_x = dflow->in_w + dflow->in_x - l_dflow->in_w; else r_dflow->in_x = dflow->in_w + dflow->in_x - r_dflow->in_w; } /* split the disp_rect */ if (dflow->en_scaling || dflow->en_img_enhancement) l_dflow->out_w = ((dflow->out_w + 1) >> 1); else l_dflow->out_w = ALIGN(((dflow->out_w + 1) >> 1), 2); r_dflow->out_w = dflow->out_w - l_dflow->out_w; l_dflow->out_x = dflow->out_x; r_dflow->out_x = l_dflow->out_w + l_dflow->out_x; /* calculate the scaling crop */ /* left scaler output more data and do crop */ if (r90) { l_out = (dflow->out_w * l_dflow->in_h) / dflow->in_h; r_out = (dflow->out_w * r_dflow->in_h) / dflow->in_h; } else { l_out = (dflow->out_w * l_dflow->in_w) / dflow->in_w; r_out = (dflow->out_w * r_dflow->in_w) / dflow->in_w; } l_dflow->left_crop = 0; l_dflow->right_crop = l_out - l_dflow->out_w; r_dflow->left_crop = r_out - r_dflow->out_w; r_dflow->right_crop = 0; /* out_w includes the crop length */ l_dflow->out_w += l_dflow->right_crop + l_dflow->left_crop; r_dflow->out_w += r_dflow->right_crop + r_dflow->left_crop; } /* For layer split, a plane state will be split to two data flows and handled * by two separated komeda layer input pipelines. komeda supports two types of * layer split: * - none-scaling split: * / layer-left -> \ * plane_state compiz-> ... * \ layer-right-> / * * - scaling split: * / layer-left -> scaler->\ * plane_state merger -> compiz-> ... * \ layer-right-> scaler->/ * * Since merger only supports scaler as input, so for none-scaling split, two * layer data flows will be output to compiz directly. for scaling_split, two * data flow will be merged by merger firstly, then merger outputs one merged * data flow to compiz. */ 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) { struct drm_plane *plane = kplane_st->base.plane; struct komeda_pipeline *pipe = left->base.pipeline; struct komeda_layer *right = left->right; struct komeda_data_flow_cfg l_dflow, r_dflow; int err; komeda_split_data_flow(pipe->scalers[0], dflow, &l_dflow, &r_dflow); DRM_DEBUG_ATOMIC("Assign %s + %s to [PLANE:%d:%s]: " "src[x/y:%d/%d, w/h:%d/%d] disp[x/y:%d/%d, w/h:%d/%d]", left->base.name, right->base.name, plane->base.id, plane->name, dflow->in_x, dflow->in_y, dflow->in_w, dflow->in_h, dflow->out_x, dflow->out_y, dflow->out_w, dflow->out_h); err = komeda_build_layer_data_flow(left, kplane_st, kcrtc_st, &l_dflow); if (err) return err; err = komeda_build_layer_data_flow(right, kplane_st, kcrtc_st, &r_dflow); if (err) return err; /* The rotation has been handled by layer, so adjusted the data flow */ komeda_rotate_data_flow(dflow, dflow->rot); /* left and right dflow has been merged to compiz already, * no need merger to merge them anymore. */ if (r_dflow.input.component == l_dflow.input.component) return 0; /* line merger path */ err = komeda_merger_validate(pipe->merger, plane, kcrtc_st, &l_dflow, &r_dflow, dflow); if (err) return err; err = komeda_compiz_set_input(pipe->compiz, kcrtc_st, dflow); return err; } /* writeback data path: compiz -> scaler -> wb_layer -> memory */ 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) { struct drm_connector *conn = conn_st->connector; int err; err = komeda_scaler_validate(conn, kcrtc_st, dflow); if (err) return err; return komeda_wb_layer_validate(wb_layer, conn_st, dflow); } /* writeback scaling split data path: * /-> scaler ->\ * compiz -> splitter merger -> wb_layer -> memory * \-> scaler ->/ */ 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) { struct komeda_pipeline *pipe = wb_layer->base.pipeline; struct drm_connector *conn = conn_st->connector; struct komeda_data_flow_cfg l_dflow, r_dflow; int err; err = komeda_splitter_validate(pipe->splitter, conn_st, dflow, &l_dflow, &r_dflow); if (err) return err; err = komeda_scaler_validate(conn, kcrtc_st, &l_dflow); if (err) return err; err = komeda_scaler_validate(conn, kcrtc_st, &r_dflow); if (err) return err; err = komeda_merger_validate(pipe->merger, conn_st, kcrtc_st, &l_dflow, &r_dflow, dflow); if (err) return err; return komeda_wb_layer_validate(wb_layer, conn_st, dflow); } /* build display output data flow, the data path is: * compiz -> improc -> timing_ctrlr */ int komeda_build_display_data_flow(struct komeda_crtc *kcrtc, struct komeda_crtc_state *kcrtc_st) { struct komeda_pipeline *master = kcrtc->master; struct komeda_pipeline *slave = kcrtc->slave; struct komeda_data_flow_cfg m_dflow; /* master data flow */ struct komeda_data_flow_cfg s_dflow; /* slave data flow */ int err; memset(&m_dflow, 0, sizeof(m_dflow)); memset(&s_dflow, 0, sizeof(s_dflow)); if (slave && has_bit(slave->id, kcrtc_st->active_pipes)) { err = komeda_compiz_validate(slave->compiz, kcrtc_st, &s_dflow); if (err) return err; /* merge the slave dflow into master pipeline */ err = komeda_compiz_set_input(master->compiz, kcrtc_st, &s_dflow); if (err) return err; } err = komeda_compiz_validate(master->compiz, kcrtc_st, &m_dflow); if (err) return err; err = komeda_improc_validate(master->improc, kcrtc_st, &m_dflow); if (err) return err; err = komeda_timing_ctrlr_validate(master->ctrlr, kcrtc_st, &m_dflow); if (err) return err; return 0; } static int komeda_pipeline_unbound_components(struct komeda_pipeline *pipe, struct komeda_pipeline_state *new) { struct drm_atomic_state *drm_st = new->obj.state; struct komeda_pipeline_state *old = priv_to_pipe_st(pipe->obj.state); struct komeda_component_state *c_st; struct komeda_component *c; u32 id; unsigned long disabling_comps; WARN_ON(!old); disabling_comps = (~new->active_comps) & old->active_comps; /* unbound all disabling component */ for_each_set_bit(id, &disabling_comps, 32) { c = komeda_pipeline_get_component(pipe, id); c_st = komeda_component_get_state_and_set_user(c, drm_st, NULL, new->crtc); if (PTR_ERR(c_st) == -EDEADLK) return -EDEADLK; WARN_ON(IS_ERR(c_st)); } return 0; } /* release unclaimed pipeline resource */ int komeda_release_unclaimed_resources(struct komeda_pipeline *pipe, struct komeda_crtc_state *kcrtc_st) { struct drm_atomic_state *drm_st = kcrtc_st->base.state; struct komeda_pipeline_state *st; /* ignore the pipeline which is not affected */ if (!pipe || !has_bit(pipe->id, kcrtc_st->affected_pipes)) return 0; if (has_bit(pipe->id, kcrtc_st->active_pipes)) st = komeda_pipeline_get_new_state(pipe, drm_st); else st = komeda_pipeline_get_state_and_set_crtc(pipe, drm_st, NULL); if (WARN_ON(IS_ERR_OR_NULL(st))) return -EINVAL; return komeda_pipeline_unbound_components(pipe, st); } /* Since standalone disabled components must be disabled separately and in the * last, So a complete disable operation may needs to call pipeline_disable * twice (two phase disabling). * Phase 1: disable the common components, flush it. * Phase 2: disable the standalone disabled components, flush it. * * RETURNS: * true: disable is not complete, needs a phase 2 disable. * false: disable is complete. */ bool komeda_pipeline_disable(struct komeda_pipeline *pipe, struct drm_atomic_state *old_state) { struct komeda_pipeline_state *old; struct komeda_component *c; struct komeda_component_state *c_st; u32 id; unsigned long disabling_comps; old = komeda_pipeline_get_old_state(pipe, old_state); disabling_comps = old->active_comps & (~pipe->standalone_disabled_comps); if (!disabling_comps) disabling_comps = old->active_comps & pipe->standalone_disabled_comps; DRM_DEBUG_ATOMIC("PIPE%d: active_comps: 0x%x, disabling_comps: 0x%lx.\n", pipe->id, old->active_comps, disabling_comps); for_each_set_bit(id, &disabling_comps, 32) { c = komeda_pipeline_get_component(pipe, id); c_st = priv_to_comp_st(c->obj.state); /* * If we disabled a component then all active_inputs should be * put in the list of changed_active_inputs, so they get * re-enabled. * This usually happens during a modeset when the pipeline is * first disabled and then the actual state gets committed * again. */ c_st->changed_active_inputs |= c_st->active_inputs; c->funcs->disable(c); } /* Update the pipeline state, if there are components that are still * active, return true for calling the phase 2 disable. */ old->active_comps &= ~disabling_comps; return old->active_comps ? true : false; } void komeda_pipeline_update(struct komeda_pipeline *pipe, struct drm_atomic_state *old_state) { struct komeda_pipeline_state *new = priv_to_pipe_st(pipe->obj.state); struct komeda_pipeline_state *old; struct komeda_component *c; u32 id; unsigned long changed_comps; old = komeda_pipeline_get_old_state(pipe, old_state); changed_comps = new->active_comps | old->active_comps; DRM_DEBUG_ATOMIC("PIPE%d: active_comps: 0x%x, changed: 0x%lx.\n", pipe->id, new->active_comps, changed_comps); for_each_set_bit(id, &changed_comps, 32) { c = komeda_pipeline_get_component(pipe, id); if (new->active_comps & BIT(c->id)) c->funcs->update(c, priv_to_comp_st(c->obj.state)); else c->funcs->disable(c); } }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1