| /* |
| * Copyright 2017-2019 NXP |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License as published by the |
| * Free Software Foundation; either version 2 of the License, or (at your |
| * option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY |
| * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * for more details. |
| */ |
| |
| #include <drm/drmP.h> |
| #include <drm/drm_crtc.h> |
| #include <drm/drm_atomic_helper.h> |
| #include <drm/drm_fb_cma_helper.h> |
| #include <drm/drm_atomic.h> |
| #include <drm/drm_gem_cma_helper.h> |
| #include <linux/dma-buf.h> |
| #include <linux/reservation.h> |
| |
| #include "imx-drm.h" |
| #include "dcss-crtc.h" |
| |
| static void dcss_drm_output_poll_changed(struct drm_device *drm) |
| { |
| struct imx_drm_device *imxdrm = drm->dev_private; |
| |
| drm_fbdev_cma_hotplug_event(imxdrm->fbhelper); |
| } |
| |
| static int dcss_drm_atomic_check(struct drm_device *drm, |
| struct drm_atomic_state *state) |
| { |
| int ret; |
| |
| ret = drm_atomic_helper_check_modeset(drm, state); |
| if (ret) |
| return ret; |
| |
| ret = drm_atomic_helper_check_planes(drm, state); |
| if (ret) |
| return ret; |
| |
| /* |
| * Check modeset again in case crtc_state->mode_changed is |
| * updated in plane's ->atomic_check callback. |
| */ |
| return drm_atomic_helper_check_modeset(drm, state); |
| } |
| |
| static void dcss_kms_setup_output_pipe(struct drm_atomic_state *state) |
| { |
| struct drm_crtc *crtc; |
| struct drm_connector *connector; |
| struct drm_connector_state *conn_state; |
| struct drm_display_info *di; |
| int i; |
| |
| for_each_connector_in_state(state, connector, conn_state, i) { |
| if (!connector->state->best_encoder) |
| continue; |
| |
| if (!connector->state->crtc->state->active || |
| !drm_atomic_crtc_needs_modeset(connector->state->crtc->state)) |
| continue; |
| |
| crtc = connector->state->crtc; |
| di = &connector->display_info; |
| |
| dcss_crtc_setup_opipe(crtc, connector, di->hdmi.colorimetry, |
| di->hdmi.hdr_panel_metadata.eotf, |
| HDMI_QUANTIZATION_RANGE_FULL); |
| } |
| } |
| |
| struct dcss_drm_commit { |
| struct work_struct work; |
| struct drm_device *dev; |
| struct drm_atomic_state *state; |
| }; |
| |
| static void dcss_drm_atomic_commit_tail(struct dcss_drm_commit *commit) |
| { |
| struct drm_atomic_state *state = commit->state; |
| struct drm_device *dev = commit->dev; |
| struct imx_drm_device *imxdrm = dev->dev_private; |
| |
| drm_atomic_helper_wait_for_fences(dev, state, false); |
| |
| drm_atomic_helper_wait_for_dependencies(state); |
| |
| drm_atomic_helper_commit_modeset_disables(dev, state); |
| |
| dcss_kms_setup_output_pipe(state); |
| |
| drm_atomic_helper_commit_modeset_enables(dev, state); |
| |
| drm_atomic_helper_commit_planes(dev, state, |
| DRM_PLANE_COMMIT_ACTIVE_ONLY); |
| |
| drm_atomic_helper_commit_hw_done(state); |
| |
| drm_atomic_helper_wait_for_vblanks(dev, state); |
| |
| drm_atomic_helper_cleanup_planes(dev, state); |
| |
| drm_atomic_helper_commit_cleanup_done(state); |
| |
| drm_atomic_state_put(state); |
| |
| spin_lock(&imxdrm->commit.wait.lock); |
| imxdrm->commit.pending = false; |
| wake_up_all_locked(&imxdrm->commit.wait); |
| spin_unlock(&imxdrm->commit.wait.lock); |
| |
| kfree(commit); |
| } |
| |
| static void dcss_commit_work(struct work_struct *work) |
| { |
| struct dcss_drm_commit *commit = container_of(work, |
| struct dcss_drm_commit, |
| work); |
| |
| dcss_drm_atomic_commit_tail(commit); |
| } |
| |
| static int dcss_drm_atomic_commit(struct drm_device *dev, |
| struct drm_atomic_state *state, |
| bool nonblock) |
| { |
| int ret; |
| struct imx_drm_device *imxdrm = dev->dev_private; |
| struct dcss_drm_commit *commit; |
| |
| if (state->async_update) { |
| ret = drm_atomic_helper_prepare_planes(dev, state); |
| if (ret) |
| return ret; |
| |
| drm_atomic_helper_async_commit(dev, state); |
| drm_atomic_helper_cleanup_planes(dev, state); |
| |
| return 0; |
| } |
| |
| commit = kzalloc(sizeof(*commit), GFP_KERNEL); |
| if (!commit) |
| return -ENOMEM; |
| |
| commit->dev = dev; |
| commit->state = state; |
| |
| ret = drm_atomic_helper_setup_commit(state, nonblock); |
| if (ret) |
| goto err_free; |
| |
| INIT_WORK(&commit->work, dcss_commit_work); |
| |
| ret = drm_atomic_helper_prepare_planes(dev, state); |
| if (ret) |
| goto err_free; |
| |
| if (!nonblock) { |
| ret = drm_atomic_helper_wait_for_fences(dev, state, true); |
| if (ret) |
| goto err; |
| } |
| |
| spin_lock(&imxdrm->commit.wait.lock); |
| ret = wait_event_interruptible_locked(imxdrm->commit.wait, |
| !imxdrm->commit.pending); |
| if (ret == 0) |
| imxdrm->commit.pending = true; |
| spin_unlock(&imxdrm->commit.wait.lock); |
| |
| if (ret) |
| goto err; |
| |
| ret = drm_atomic_helper_swap_state(state, true); |
| if (ret) |
| goto err; |
| |
| drm_atomic_state_get(state); |
| if (nonblock) |
| queue_work(imxdrm->dcss_nonblock_commit_wq, &commit->work); |
| else |
| dcss_drm_atomic_commit_tail(commit); |
| |
| return 0; |
| |
| err: |
| drm_atomic_helper_cleanup_planes(dev, state); |
| |
| err_free: |
| kfree(commit); |
| return ret; |
| } |
| |
| const struct drm_mode_config_funcs dcss_drm_mode_config_funcs = { |
| .fb_create = drm_fb_cma_create, |
| .output_poll_changed = dcss_drm_output_poll_changed, |
| .atomic_check = dcss_drm_atomic_check, |
| .atomic_commit = dcss_drm_atomic_commit, |
| }; |