| /* |
| * Copyright 2015 Freescale Semiconductor, Inc. |
| * |
| * Freescale DCU drm device driver |
| * |
| * 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. |
| */ |
| |
| #include <linux/regmap.h> |
| |
| #include <drm/drmP.h> |
| #include <drm/drm_atomic_helper.h> |
| #include <drm/drm_crtc.h> |
| #include <drm/drm_crtc_helper.h> |
| #include <drm/drm_fb_cma_helper.h> |
| #include <drm/drm_gem_cma_helper.h> |
| #include <drm/drm_plane_helper.h> |
| |
| #include "fsl_dcu_drm_drv.h" |
| #include "fsl_dcu_drm_plane.h" |
| |
| static int fsl_dcu_drm_plane_index(struct drm_plane *plane) |
| { |
| struct fsl_dcu_drm_device *fsl_dev = plane->dev->dev_private; |
| unsigned int total_layer = fsl_dev->soc->total_layer; |
| unsigned int index; |
| |
| index = drm_plane_index(plane); |
| if (index < total_layer) |
| return total_layer - index - 1; |
| |
| dev_err(fsl_dev->dev, "No more layer left\n"); |
| return -EINVAL; |
| } |
| |
| static int fsl_dcu_drm_plane_atomic_check(struct drm_plane *plane, |
| struct drm_plane_state *state) |
| { |
| struct drm_framebuffer *fb = state->fb; |
| |
| switch (fb->pixel_format) { |
| case DRM_FORMAT_RGB565: |
| case DRM_FORMAT_RGB888: |
| case DRM_FORMAT_ARGB8888: |
| case DRM_FORMAT_BGRA4444: |
| case DRM_FORMAT_ARGB1555: |
| case DRM_FORMAT_YUV422: |
| return 0; |
| default: |
| return -EINVAL; |
| } |
| } |
| |
| static void fsl_dcu_drm_plane_atomic_disable(struct drm_plane *plane, |
| struct drm_plane_state *old_state) |
| { |
| struct fsl_dcu_drm_device *fsl_dev = plane->dev->dev_private; |
| unsigned int value; |
| int index, ret; |
| |
| index = fsl_dcu_drm_plane_index(plane); |
| if (index < 0) |
| return; |
| |
| ret = regmap_read(fsl_dev->regmap, DCU_CTRLDESCLN(index, 4), &value); |
| if (ret) |
| dev_err(fsl_dev->dev, "read DCU_INT_MASK failed\n"); |
| value &= ~DCU_LAYER_EN; |
| ret = regmap_write(fsl_dev->regmap, DCU_CTRLDESCLN(index, 4), value); |
| if (ret) |
| dev_err(fsl_dev->dev, "set DCU register failed\n"); |
| } |
| |
| static void fsl_dcu_drm_plane_atomic_update(struct drm_plane *plane, |
| struct drm_plane_state *old_state) |
| |
| { |
| struct fsl_dcu_drm_device *fsl_dev = plane->dev->dev_private; |
| struct drm_plane_state *state = plane->state; |
| struct drm_framebuffer *fb = plane->state->fb; |
| struct drm_gem_cma_object *gem; |
| unsigned int alpha, bpp; |
| int index, ret; |
| |
| if (!fb) |
| return; |
| |
| index = fsl_dcu_drm_plane_index(plane); |
| if (index < 0) |
| return; |
| |
| gem = drm_fb_cma_get_gem_obj(fb, 0); |
| |
| switch (fb->pixel_format) { |
| case DRM_FORMAT_RGB565: |
| bpp = FSL_DCU_RGB565; |
| alpha = 0xff; |
| break; |
| case DRM_FORMAT_RGB888: |
| bpp = FSL_DCU_RGB888; |
| alpha = 0xff; |
| break; |
| case DRM_FORMAT_ARGB8888: |
| bpp = FSL_DCU_ARGB8888; |
| alpha = 0xff; |
| break; |
| case DRM_FORMAT_BGRA4444: |
| bpp = FSL_DCU_ARGB4444; |
| alpha = 0xff; |
| break; |
| case DRM_FORMAT_ARGB1555: |
| bpp = FSL_DCU_ARGB1555; |
| alpha = 0xff; |
| break; |
| case DRM_FORMAT_YUV422: |
| bpp = FSL_DCU_YUV422; |
| alpha = 0xff; |
| break; |
| default: |
| return; |
| } |
| |
| ret = regmap_write(fsl_dev->regmap, DCU_CTRLDESCLN(index, 1), |
| DCU_LAYER_HEIGHT(state->crtc_h) | |
| DCU_LAYER_WIDTH(state->crtc_w)); |
| if (ret) |
| goto set_failed; |
| ret = regmap_write(fsl_dev->regmap, DCU_CTRLDESCLN(index, 2), |
| DCU_LAYER_POSY(state->crtc_y) | |
| DCU_LAYER_POSX(state->crtc_x)); |
| if (ret) |
| goto set_failed; |
| ret = regmap_write(fsl_dev->regmap, |
| DCU_CTRLDESCLN(index, 3), gem->paddr); |
| if (ret) |
| goto set_failed; |
| ret = regmap_write(fsl_dev->regmap, DCU_CTRLDESCLN(index, 4), |
| DCU_LAYER_EN | |
| DCU_LAYER_TRANS(alpha) | |
| DCU_LAYER_BPP(bpp) | |
| DCU_LAYER_AB(0)); |
| if (ret) |
| goto set_failed; |
| ret = regmap_write(fsl_dev->regmap, DCU_CTRLDESCLN(index, 5), |
| DCU_LAYER_CKMAX_R(0xFF) | |
| DCU_LAYER_CKMAX_G(0xFF) | |
| DCU_LAYER_CKMAX_B(0xFF)); |
| if (ret) |
| goto set_failed; |
| ret = regmap_write(fsl_dev->regmap, DCU_CTRLDESCLN(index, 6), |
| DCU_LAYER_CKMIN_R(0) | |
| DCU_LAYER_CKMIN_G(0) | |
| DCU_LAYER_CKMIN_B(0)); |
| if (ret) |
| goto set_failed; |
| ret = regmap_write(fsl_dev->regmap, DCU_CTRLDESCLN(index, 7), 0); |
| if (ret) |
| goto set_failed; |
| ret = regmap_write(fsl_dev->regmap, DCU_CTRLDESCLN(index, 8), |
| DCU_LAYER_FG_FCOLOR(0)); |
| if (ret) |
| goto set_failed; |
| ret = regmap_write(fsl_dev->regmap, DCU_CTRLDESCLN(index, 9), |
| DCU_LAYER_BG_BCOLOR(0)); |
| if (ret) |
| goto set_failed; |
| if (!strcmp(fsl_dev->soc->name, "ls1021a")) { |
| ret = regmap_write(fsl_dev->regmap, DCU_CTRLDESCLN(index, 10), |
| DCU_LAYER_POST_SKIP(0) | |
| DCU_LAYER_PRE_SKIP(0)); |
| if (ret) |
| goto set_failed; |
| } |
| ret = regmap_update_bits(fsl_dev->regmap, DCU_DCU_MODE, |
| DCU_MODE_DCU_MODE_MASK, |
| DCU_MODE_DCU_MODE(DCU_MODE_NORMAL)); |
| if (ret) |
| goto set_failed; |
| ret = regmap_write(fsl_dev->regmap, |
| DCU_UPDATE_MODE, DCU_UPDATE_MODE_READREG); |
| if (ret) |
| goto set_failed; |
| return; |
| |
| set_failed: |
| dev_err(fsl_dev->dev, "set DCU register failed\n"); |
| } |
| |
| static void |
| fsl_dcu_drm_plane_cleanup_fb(struct drm_plane *plane, |
| const struct drm_plane_state *new_state) |
| { |
| } |
| |
| static int |
| fsl_dcu_drm_plane_prepare_fb(struct drm_plane *plane, |
| const struct drm_plane_state *new_state) |
| { |
| return 0; |
| } |
| |
| static const struct drm_plane_helper_funcs fsl_dcu_drm_plane_helper_funcs = { |
| .atomic_check = fsl_dcu_drm_plane_atomic_check, |
| .atomic_disable = fsl_dcu_drm_plane_atomic_disable, |
| .atomic_update = fsl_dcu_drm_plane_atomic_update, |
| .cleanup_fb = fsl_dcu_drm_plane_cleanup_fb, |
| .prepare_fb = fsl_dcu_drm_plane_prepare_fb, |
| }; |
| |
| static void fsl_dcu_drm_plane_destroy(struct drm_plane *plane) |
| { |
| drm_plane_cleanup(plane); |
| } |
| |
| static const struct drm_plane_funcs fsl_dcu_drm_plane_funcs = { |
| .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state, |
| .atomic_destroy_state = drm_atomic_helper_plane_destroy_state, |
| .destroy = fsl_dcu_drm_plane_destroy, |
| .disable_plane = drm_atomic_helper_disable_plane, |
| .reset = drm_atomic_helper_plane_reset, |
| .update_plane = drm_atomic_helper_update_plane, |
| }; |
| |
| static const u32 fsl_dcu_drm_plane_formats[] = { |
| DRM_FORMAT_RGB565, |
| DRM_FORMAT_RGB888, |
| DRM_FORMAT_ARGB8888, |
| DRM_FORMAT_ARGB4444, |
| DRM_FORMAT_ARGB1555, |
| DRM_FORMAT_YUV422, |
| }; |
| |
| struct drm_plane *fsl_dcu_drm_primary_create_plane(struct drm_device *dev) |
| { |
| struct drm_plane *primary; |
| int ret; |
| |
| primary = kzalloc(sizeof(*primary), GFP_KERNEL); |
| if (!primary) { |
| DRM_DEBUG_KMS("Failed to allocate primary plane\n"); |
| return NULL; |
| } |
| |
| /* possible_crtc's will be filled in later by crtc_init */ |
| ret = drm_universal_plane_init(dev, primary, 0, |
| &fsl_dcu_drm_plane_funcs, |
| fsl_dcu_drm_plane_formats, |
| ARRAY_SIZE(fsl_dcu_drm_plane_formats), |
| DRM_PLANE_TYPE_PRIMARY); |
| if (ret) { |
| kfree(primary); |
| primary = NULL; |
| } |
| drm_plane_helper_add(primary, &fsl_dcu_drm_plane_helper_funcs); |
| |
| return primary; |
| } |