261 lines
6.6 KiB
C
261 lines
6.6 KiB
C
/*
|
|
* 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;
|
|
}
|