wen/luban-lite-t3e-pro
1
0
Fork 0
mirror of https://gitee.com/Vancouver2017/luban-lite-t3e-pro.git synced 2025-12-14 18:38:55 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
3b4064f334acf90ed035839e784c2efe38910324
luban-lite-t3e-pro/bsp/artinchip/hal/ge/hal_ge_normal.c
刘可亮 3b4064f334 v1.0.2
2023-11-30 19:48:02 +08:00

1612 lines
43 KiB
C
Raw Blame History

/*
* Copyright (c) 2022-2023, ArtInChip Technology Co., Ltd
*
* SPDX-License-Identifier: Apache-2.0
*
* Authors: Ning Fang <ning.fang@artinchip.com>
*/
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "aic_core.h"
#include "aic_hal.h"
#include "aic_log.h"
#include "mpp_types.h"
#include "aic_drv_ge.h"
#include <sys/time.h>
#include "hal_ge_hw.h"
#include "hal_ge_reg.h"
#define AIC_GE_NAME "ge"
#define MAX_WIDTH 4096
#define MAX_HEIGHT 4096
#define ALIGN_128B(x) ALIGN_UP(x, 128)
#define GE_TIMEOUT (1000 * 2) //second
#define HW_RUNNING_EVENT 0x02
#define BIT_SHIFT(bit) (1 << (bit))
#define INIT_PHASE(step) (((step) >= BIT_SHIFT(16)) ? \
(((step) >> 1) - BIT_SHIFT(15)) :\
((step) >> 1))
#ifdef AIC_GE_DRV_V11
#define GE_CLOCK (150000000)
#else
#define GE_CLOCK (200000000)
#endif
struct aic_ge_data {
struct device *dev;
aicos_mutex_t lock;
aicos_event_t wait;
u32 status;
u32 src_premul_en;
u32 src_de_premul_en;
u32 dst_de_premul_en;
u32 out_premul_en;
u32 src_alpha_coef;
u32 dst_alpha_coef;
u32 csc0_en;
u32 csc1_en;
u32 csc2_en;
bool blend_is_rgb;
bool enable_dma_buf;
u8 *dither_line_ptr;
uintptr_t dither_line_phys;
enum ge_mode ge_mode;
};
struct aic_ge_data *g_data;
static inline int ge_check_buf(struct aic_ge_data *data,
struct mpp_buf *video_buf)
{
if (video_buf->buf_type == MPP_DMA_BUF_FD &&
!data->enable_dma_buf) {
hal_log_err("unsupported buf type:%d\n",
video_buf->buf_type);
return -1;
}
return 0;
}
static irqreturn_t aic_ge_handler(int irq, void *ctx)
{
struct aic_ge_data *data = (struct aic_ge_data *)g_data;
(void)ctx;
data->status = ge_read_status(GE_BASE);
ge_clear_status(GE_BASE, data->status);
/* disable interrupt*/
ge_disable_interrupt(GE_BASE);
aicos_event_send(data->wait, HW_RUNNING_EVENT);
return 0;
}
static void ge_reset(struct aic_ge_data *data)
{
hal_reset_assert(RESET_GE);
hal_reset_deassert(RESET_GE);
}
static void dump_regs()
{
int i=0;
for (i=0; i<256; i+=4) {
hal_log_info("%08x: %08x %08x %08x %08x\n", (u32)GE_BASE + 4*i,
readl(GE_BASE + 4*i), readl(GE_BASE + 4*i+4),
readl(GE_BASE + 4*i+8), readl(GE_BASE + 4*i+12));
}
}
static int ge_start_and_wait(struct aic_ge_data *data)
{
int ret;
uint32_t recved;
data->status = 0;
ge_enable_interrupt(GE_BASE);
ge_start(GE_BASE);
ret = aicos_event_recv(data->wait,
HW_RUNNING_EVENT,
&recved,
GE_TIMEOUT);
ge_clear_status(GE_BASE, data->status);
if (data->status == 0) {
hal_log_err("ge timeout\n");
dump_regs();
ge_disable_interrupt(GE_BASE);
ge_reset(data);
return ret;
} else if ((data->status & GE_CTRL_FINISH_IRQ_EN) == 0) {
dump_regs();
hal_log_err("ge error status:%08x\n", data->status);
ge_reset(data);
}
return 0;
}
static inline bool is_rgb(enum mpp_pixel_format format)
{
switch (format) {
case MPP_FMT_ARGB_8888:
case MPP_FMT_ABGR_8888:
case MPP_FMT_RGBA_8888:
case MPP_FMT_BGRA_8888:
case MPP_FMT_XRGB_8888:
case MPP_FMT_XBGR_8888:
case MPP_FMT_RGBX_8888:
case MPP_FMT_BGRX_8888:
case MPP_FMT_RGB_888:
case MPP_FMT_BGR_888:
case MPP_FMT_ARGB_1555:
case MPP_FMT_ABGR_1555:
case MPP_FMT_RGBA_5551:
case MPP_FMT_BGRA_5551:
case MPP_FMT_RGB_565:
case MPP_FMT_BGR_565:
case MPP_FMT_ARGB_4444:
case MPP_FMT_ABGR_4444:
case MPP_FMT_RGBA_4444:
case MPP_FMT_BGRA_4444:
return true;
default:
break;
}
return false;
}
static inline bool need_blend(struct ge_ctrl *ctrl)
{
if (ctrl->alpha_en || ctrl->ck_en)
return true;
else
return false;
}
static void set_csc_flow(struct aic_ge_data *data,
struct ge_ctrl *ctrl,
enum mpp_pixel_format src_format,
enum mpp_pixel_format dst_format)
{
bool src_is_rgb = is_rgb(src_format);
bool dst_is_rgb = is_rgb(dst_format);
bool is_blending = need_blend(ctrl);
data->blend_is_rgb = true;
if (!src_is_rgb &&
(is_blending || dst_is_rgb)) {
data->csc0_en = 1;
} else if (!src_is_rgb) {
data->blend_is_rgb = false;
data->csc0_en = 0;
} else {
data->csc0_en = 0;
}
if (is_blending && !dst_is_rgb)
data->csc1_en = 1;
else
data->csc1_en = 0;
if (data->blend_is_rgb && !dst_is_rgb)
data->csc2_en = 1;
else
data->csc2_en = 0;
}
static void set_alpha_rules(struct aic_ge_data *data,
enum ge_pd_rules rules)
{
switch (rules) {
case GE_PD_NONE:
data->src_alpha_coef = 2;
data->dst_alpha_coef = 3;
break;
case GE_PD_CLEAR:
data->src_alpha_coef = 0;
data->dst_alpha_coef = 0;
break;
case GE_PD_SRC:
data->src_alpha_coef = 1;
data->dst_alpha_coef = 0;
break;
case GE_PD_SRC_OVER:
data->src_alpha_coef = 1;
data->dst_alpha_coef = 3;
break;
case GE_PD_DST_OVER:
data->src_alpha_coef = 5;
data->dst_alpha_coef = 1;
break;
case GE_PD_SRC_IN:
data->src_alpha_coef = 4;
data->dst_alpha_coef = 0;
break;
case GE_PD_DST_IN:
data->src_alpha_coef = 0;
data->dst_alpha_coef = 2;
break;
case GE_PD_SRC_OUT:
data->src_alpha_coef = 5;
data->dst_alpha_coef = 0;
break;
case GE_PD_DST_OUT:
data->src_alpha_coef = 0;
data->dst_alpha_coef = 3;
break;
case GE_PD_SRC_ATOP:
data->src_alpha_coef = 4;
data->dst_alpha_coef = 3;
break;
case GE_PD_DST_ATOP:
data->src_alpha_coef = 5;
data->dst_alpha_coef = 2;
break;
case GE_PD_ADD:
data->src_alpha_coef = 1;
data->dst_alpha_coef = 1;
break;
case GE_PD_XOR:
data->src_alpha_coef = 5;
data->dst_alpha_coef = 3;
break;
case GE_PD_DST:
data->src_alpha_coef = 0;
data->dst_alpha_coef = 1;
break;
default:
data->src_alpha_coef = 2;
data->dst_alpha_coef = 3;
break;
}
}
/* must call set_premuliply after set_alpha_rules */
int set_premuliply(struct aic_ge_data *data,
enum mpp_pixel_format src_format,
enum mpp_pixel_format dst_format,
int src_premul,
int dst_premul,
int is_fill_color,
struct ge_ctrl *ctrl)
{
if (src_format > MPP_FMT_BGRA_4444)
src_premul = 0;
if (dst_format > MPP_FMT_BGRA_4444)
dst_premul = 0;
if (src_premul == 0 && dst_premul == 0) {
data->src_premul_en = 0;
data->src_de_premul_en = 0;
data->dst_de_premul_en = 0;
data->out_premul_en = 0;
if (is_fill_color == 0 &&
ctrl->src_alpha_mode == 0 &&
ctrl->alpha_en &&
ctrl->ck_en == 0 &&
data->src_alpha_coef == 2 &&
data->dst_alpha_coef == 3) {
data->src_premul_en = 1;
data->src_alpha_coef = 1;
}
} else if (src_premul == 1 && dst_premul == 0) {
data->src_premul_en = 0;
data->src_de_premul_en = 1;
data->dst_de_premul_en = 0;
data->out_premul_en = 0;
if (ctrl->src_alpha_mode == 0 &&
ctrl->alpha_en &&
ctrl->ck_en == 0 &&
data->src_alpha_coef == 2 &&
data->dst_alpha_coef == 3) {
data->src_de_premul_en = 0;
data->src_alpha_coef = 1;
}
} else if (src_premul == 1 && dst_premul == 1) {
data->src_premul_en = 0;
data->src_de_premul_en = 1;
data->dst_de_premul_en = 1;
data->out_premul_en = 1;
} else if (src_premul == 0 && dst_premul == 1) {
data->src_premul_en = 0;
data->src_de_premul_en = 0;
data->dst_de_premul_en = 1;
data->out_premul_en = 1;
}
return 0;
}
static int check_bitblt(struct aic_ge_data *data, struct ge_bitblt *blt)
{
enum mpp_pixel_format src_format = blt->src_buf.format;
enum mpp_pixel_format dst_format = blt->dst_buf.format;
struct mpp_rect *src_rect = &blt->src_buf.crop;
struct mpp_rect *dst_rect = &blt->dst_buf.crop;
struct mpp_size *src_size = &blt->src_buf.size;
struct mpp_size *dst_size = &blt->dst_buf.size;
if (MPP_SCAN_ORDER_GET(blt->ctrl.flags)) {
if (MPP_ROTATION_GET(blt->ctrl.flags)) {
hal_log_err( "%s failed, scan order unsupport rot0\n",
__func__);
return -1;
}
if (blt->ctrl.dither_en) {
hal_log_err("%s failed, scan order unsupport dither\n",
__func__);
return -1;
}
if (!is_rgb(src_format) || !is_rgb(dst_format)) {
hal_log_err("%s failed, scan order just support rgb format\n",
__func__);
return -1;
}
}
if (blt->ctrl.dither_en) {
if (!is_rgb(dst_format)) {
hal_log_err("%s failed, invalid dst format with the dither func on\n",
__func__);
return -1;
}
if (!g_data->dither_line_ptr) {
hal_log_err("%s failed, dither function is closed and cannot be used\n",
__func__);
blt->ctrl.dither_en = 0;
}
}
if (blt->src_buf.crop_en) {
if (src_rect->x < 0 ||
src_rect->y < 0 ||
src_rect->x >= src_size->width ||
src_rect->y >= src_size->height) {
hal_log_err("%s failed, invalid src crop\n",
__func__);
return -1;
}
}
if (blt->dst_buf.crop_en) {
if (dst_rect->x < 0 ||
dst_rect->y < 0 ||
dst_rect->x >= dst_size->width ||
dst_rect->y >= dst_size->height) {
hal_log_err("%s failed, invalid dst crop\n",
__func__);
return -1;
}
}
if (!blt->src_buf.crop_en) {
src_rect->x = 0;
src_rect->y = 0;
src_rect->width = src_size->width;
src_rect->height = src_size->height;
}
if (!blt->dst_buf.crop_en) {
dst_rect->x = 0;
dst_rect->y = 0;
dst_rect->width = dst_size->width;
dst_rect->height = dst_size->height;
}
switch (src_format) {
case MPP_FMT_YUV420P:
case MPP_FMT_NV12:
case MPP_FMT_NV21:
src_rect->x = src_rect->x & (~1);
src_rect->y = src_rect->y & (~1);
src_rect->width = src_rect->width & (~1);
src_rect->height = src_rect->height & (~1);
src_size->width = src_size->width & (~1);
src_size->height = src_size->height & (~1);
break;
case MPP_FMT_YUV422P:
case MPP_FMT_NV16:
case MPP_FMT_NV61:
case MPP_FMT_YUYV:
case MPP_FMT_YVYU:
case MPP_FMT_UYVY:
case MPP_FMT_VYUY:
src_rect->x = src_rect->x & (~1);
src_rect->width = src_rect->width & (~1);
src_size->width = src_size->width & (~1);
break;
default:
break;
}
switch (dst_format) {
case MPP_FMT_YUV420P:
case MPP_FMT_NV12:
case MPP_FMT_NV21:
dst_rect->x = dst_rect->x & (~1);
dst_rect->y = dst_rect->y & (~1);
dst_rect->width = dst_rect->width & (~1);
dst_rect->height = dst_rect->height & (~1);
dst_size->width = dst_size->width & (~1);
dst_size->height = dst_size->height & (~1);
break;
case MPP_FMT_YUV422P:
case MPP_FMT_NV16:
case MPP_FMT_NV61:
case MPP_FMT_YUYV:
case MPP_FMT_YVYU:
case MPP_FMT_UYVY:
case MPP_FMT_VYUY:
dst_rect->x = dst_rect->x & (~1);
dst_rect->width = dst_rect->width & (~1);
dst_size->width = dst_size->width & (~1);
break;
default:
break;
}
/* crop src invalid region */
if ((src_rect->x + src_rect->width) > src_size->width)
src_rect->width = src_size->width - src_rect->x;
if ((src_rect->y + src_rect->height) > src_size->height)
src_rect->height = src_size->height - src_rect->y;
/* crop dst invalid region */
if ((dst_rect->x + dst_rect->width) > dst_size->width)
dst_rect->width = dst_size->width - dst_rect->x;
if ((dst_rect->y + dst_rect->height) > dst_size->height)
dst_rect->height = dst_size->height - dst_rect->y;
if (src_rect->height > MAX_HEIGHT ||
src_rect->width > MAX_WIDTH) {
hal_log_err("invalid src size, over the largest\n");
return -1;
}
if (dst_rect->height > MAX_HEIGHT ||
dst_rect->width > MAX_WIDTH) {
hal_log_err("invalid dst size, over the largest\n");
return -1;
}
if (!is_rgb(src_format) &&
(src_rect->width < 8 || src_rect->height < 8)) {
hal_log_err("invalid src size, the min size of yuv is 8x8\n");
return -1;
}
if (!is_rgb(dst_format) &&
(dst_rect->width < 8 || dst_rect->height < 8)) {
hal_log_err("invalid dst size, the min size of yuv is 8x8\n");
return -1;;
}
return 0;
}
static void set_alpha_rules_and_premul(struct aic_ge_data *data,
struct ge_ctrl *ctrl,
enum mpp_pixel_format src_format,
enum mpp_pixel_format dst_format,
u32 src_buf_flags,
u32 dst_buf_flags,
int is_fill_color)
{
if (ctrl->alpha_en)
set_alpha_rules(data, ctrl->alpha_rules);
set_premuliply(data, src_format, dst_format,
MPP_BUF_PREMULTIPLY_GET(src_buf_flags),
MPP_BUF_PREMULTIPLY_GET(dst_buf_flags),
is_fill_color, ctrl);
}
static int ge_config_scaler(struct aic_ge_data *data,
struct ge_bitblt *blt)
{
enum mpp_pixel_format format;
int in_w[2];
int in_h[2];
int out_w;
int out_h;
int channel_num;
int scaler_en;
int rot0_degree;
int i;
int dx[2];
int dy[2];
int h_phase[2];
int v_phase[2];
channel_num = 1;
scaler_en = 1;
format = blt->src_buf.format;
rot0_degree = MPP_ROTATION_GET(blt->ctrl.flags);
in_w[0] = blt->src_buf.crop.width;
in_h[0] = blt->src_buf.crop.height;
if (rot0_degree == MPP_ROTATION_90 ||
rot0_degree == MPP_ROTATION_270) {
out_w = blt->dst_buf.crop.height;
out_h = blt->dst_buf.crop.width;
} else {
out_w = blt->dst_buf.crop.width;
out_h = blt->dst_buf.crop.height;
}
switch (format) {
case MPP_FMT_ARGB_8888:
case MPP_FMT_ABGR_8888:
case MPP_FMT_RGBA_8888:
case MPP_FMT_BGRA_8888:
case MPP_FMT_XRGB_8888:
case MPP_FMT_XBGR_8888:
case MPP_FMT_RGBX_8888:
case MPP_FMT_BGRX_8888:
case MPP_FMT_RGB_888:
case MPP_FMT_BGR_888:
case MPP_FMT_ARGB_1555:
case MPP_FMT_ABGR_1555:
case MPP_FMT_RGBA_5551:
case MPP_FMT_BGRA_5551:
case MPP_FMT_RGB_565:
case MPP_FMT_BGR_565:
case MPP_FMT_ARGB_4444:
case MPP_FMT_ABGR_4444:
case MPP_FMT_RGBA_4444:
case MPP_FMT_BGRA_4444:
if (in_w[0] == out_w && in_h[0] == out_h) {
scaler_en = 0;
} else {
dx[0] = (in_w[0] << 16) / out_w;
dy[0] = (in_h[0] << 16) / out_h;
h_phase[0] = INIT_PHASE(dx[0]);
v_phase[0] = INIT_PHASE(dy[0]);
}
break;
case MPP_FMT_YUV400:
dx[0] = (in_w[0] << 16) / out_w;
dy[0] = (in_h[0] << 16) / out_h;
h_phase[0] = INIT_PHASE(dx[0]);
v_phase[0] = INIT_PHASE(dy[0]);
break;
case MPP_FMT_YUV420P:
case MPP_FMT_NV12:
case MPP_FMT_NV21:
channel_num = 2;
in_w[1] = in_w[0] >> 1;
in_h[1] = in_h[0] >> 1;
dx[0] = (in_w[0] << 16) / out_w;
dy[0] = (in_h[0] << 16) / out_h;
h_phase[0] = INIT_PHASE(dx[0]);
v_phase[0] = INIT_PHASE(dy[0]);
dx[0] = dx[0] & (~1);
dy[0] = dy[0] & (~1);
h_phase[0] = h_phase[0] & (~1);
v_phase[0] = v_phase[0] & (~1);
/* change init phase */
if (((dx[0] - h_phase[0]) >> 16) > 4) {
h_phase[0] += (((dx[0] - h_phase[0]) >> 16) - 4) << 16;
}
if (((dy[0] - v_phase[0]) >> 16) > 3) {
v_phase[0] += (((dy[0] - v_phase[0]) >> 16) - 4) << 16;
}
dx[1] = dx[0] >> 1;
dy[1] = dy[0] >> 1;
h_phase[1] = h_phase[0] >> 1;
v_phase[1] = v_phase[0] >> 1;
break;
case MPP_FMT_YUV422P:
case MPP_FMT_NV16:
case MPP_FMT_NV61:
case MPP_FMT_YUYV:
case MPP_FMT_YVYU:
case MPP_FMT_UYVY:
case MPP_FMT_VYUY:
channel_num = 2;
in_w[1] = in_w[0] >> 1;
in_h[1] = in_h[0];
dx[0] = (in_w[0] << 16) / out_w;
dy[0] = (in_h[0] << 16) / out_h;
h_phase[0] = INIT_PHASE(dx[0]);
v_phase[0] = INIT_PHASE(dy[0]);
dx[0] = dx[0] & (~1);
h_phase[0] = h_phase[0] & (~1);
/* change init phase */
if (((dx[0] - h_phase[0]) >> 16) > 4) {
h_phase[0] += (((dx[0] - h_phase[0]) >> 16) - 4) << 16;
}
dx[1] = dx[0] >> 1;
dy[1] = dy[0];
h_phase[1] = h_phase[0] >> 1;
v_phase[1] = v_phase[0];
break;
case MPP_FMT_YUV444P:
channel_num = 2;
in_w[1] = in_w[0];
in_h[1] = in_h[0];
dx[0] = (in_w[0] << 16) / out_w;
dy[0] = (in_h[0] << 16) / out_h;
h_phase[0] = INIT_PHASE(dx[0]);
v_phase[0] = INIT_PHASE(dy[0]);
dx[1] = dx[0];
dy[1] = dy[0];
h_phase[1] = h_phase[0];
v_phase[1] = v_phase[0];
break;
default:
scaler_en = 0;
hal_log_err("invalid format: %d\n", format);
return -1;
}
if (scaler_en) {
if (is_rgb(format) &&
(in_w[0] < 4 || in_h[0] < 4)) {
hal_log_err(
"the min size of rgb is 4x4, when scaler enable\n");
return -1;
}
if (is_rgb(blt->dst_buf.format) &&
(out_h < 4 || out_w < 4)) {
hal_log_err(
"the min size of rgb is 4x4, when scaler enable\n");
return -1;
}
for (i = 0; i < channel_num; i++) {
ge_set_scaler0(GE_BASE, in_w[i], in_h[i],
out_w, out_h,
dx[i], dy[i],
h_phase[i], v_phase[i],
i);
}
ge_scaler0_enable(GE_BASE, 1);
} else {
ge_scaler0_enable(GE_BASE, 0);
}
return 0;
}
/*
*@addr[]: in/out addr
*
*/
static int ge_buf_crop(u32 addr[], u32 stride[],
enum mpp_pixel_format format,
u32 x_offset,
u32 y_offset,
u32 width,
u32 height)
{
int offset;
switch (format) {
case MPP_FMT_ARGB_8888:
case MPP_FMT_ABGR_8888:
case MPP_FMT_RGBA_8888:
case MPP_FMT_BGRA_8888:
case MPP_FMT_XRGB_8888:
case MPP_FMT_XBGR_8888:
case MPP_FMT_RGBX_8888:
case MPP_FMT_BGRX_8888:
addr[0] += x_offset * 4 + y_offset * stride[0];
break;
case MPP_FMT_RGB_888:
case MPP_FMT_BGR_888:
addr[0] += x_offset * 3 + y_offset * stride[0];
break;
case MPP_FMT_ARGB_1555:
case MPP_FMT_ABGR_1555:
case MPP_FMT_RGBA_5551:
case MPP_FMT_BGRA_5551:
case MPP_FMT_RGB_565:
case MPP_FMT_BGR_565:
case MPP_FMT_ARGB_4444:
case MPP_FMT_ABGR_4444:
case MPP_FMT_RGBA_4444:
case MPP_FMT_BGRA_4444:
addr[0] += x_offset * 2 + y_offset * stride[0];
break;
case MPP_FMT_YUV420P:
addr[0] += x_offset + y_offset * stride[0];
offset = (x_offset >> 1) + (y_offset >> 1) * stride[1];
addr[1] += offset;
addr[2] += offset;
break;
case MPP_FMT_NV12:
case MPP_FMT_NV21:
addr[0] += x_offset + y_offset * stride[0];
addr[1] += x_offset + (y_offset >> 1) * stride[1];
break;
case MPP_FMT_YUV400:
addr[0] += x_offset + y_offset * stride[0];
break;
case MPP_FMT_YUV422P:
addr[0] += x_offset + y_offset * stride[0];
offset = (x_offset >> 1) + y_offset * stride[1];
addr[1] += offset;
addr[2] += offset;
break;
case MPP_FMT_NV16:
case MPP_FMT_NV61:
addr[0] += x_offset + y_offset * stride[0];
addr[1] += x_offset + y_offset * stride[1];
break;
case MPP_FMT_YUYV:
case MPP_FMT_YVYU:
case MPP_FMT_UYVY:
case MPP_FMT_VYUY:
addr[0] += (x_offset << 1) + y_offset * stride[0];
break;
case MPP_FMT_YUV444P:
addr[0] += x_offset + y_offset * stride[0];
addr[1] += x_offset + y_offset * stride[1];
addr[2] += x_offset + y_offset * stride[1];
break;
default:
return -1;
}
return 0;
}
static int ge_config_addr(struct aic_ge_data *data,
struct mpp_buf *src_buf,
struct mpp_buf *dst_buf,
struct ge_ctrl *ctrl)
{
u32 src_w;
u32 src_h;
u32 dst_w;
u32 dst_h;
u32 src_addr[3];
u32 dst_addr[3];
u32 src_stride[2];
u32 dst_stride[2];
struct mpp_rect *src_rect;
struct mpp_rect *dst_rect;
src_rect = &src_buf->crop;
dst_rect = &dst_buf->crop;
src_w = src_rect->width;
src_h = src_rect->height;
dst_w = dst_rect->width;
dst_h = dst_rect->height;
src_addr[0] = src_buf->phy_addr[0];
src_addr[1] = src_buf->phy_addr[1];
src_addr[2] = src_buf->phy_addr[2];
dst_addr[0] = dst_buf->phy_addr[0];
dst_addr[1] = dst_buf->phy_addr[1];
dst_addr[2] = dst_buf->phy_addr[2];
src_stride[0] = src_buf->stride[0];
src_stride[1] = src_buf->stride[1];
dst_stride[0] = dst_buf->stride[0];
dst_stride[1] = dst_buf->stride[1];
ge_buf_crop(src_addr, src_stride,
src_buf->format,
src_rect->x,
src_rect->y,
src_w,
src_h);
ge_buf_crop(dst_addr, dst_stride,
dst_buf->format,
dst_rect->x,
dst_rect->y,
dst_w,
dst_h);
ge_set_src_info(GE_BASE, src_w, src_h,
src_stride[0], src_stride[1],
src_addr);
ge_set_output_info(GE_BASE, dst_w, dst_h,
dst_stride[0], dst_stride[1],
dst_addr);
if (need_blend(ctrl)) {
ge_set_dst_info(GE_BASE, dst_w, dst_h,
dst_stride[0], dst_stride[1],
dst_addr);
}
return 0;
}
static int check_fillrect(struct aic_ge_data *data,
struct ge_fillrect *fill)
{
enum mpp_pixel_format dst_format = fill->dst_buf.format;
struct mpp_rect *dst_rect = &fill->dst_buf.crop;
struct mpp_size *dst_size = &fill->dst_buf.size;
if (fill->dst_buf.crop_en) {
if (dst_rect->x < 0 ||
dst_rect->y < 0 ||
dst_rect->x >= dst_size->width ||
dst_rect->y >= dst_size->height) {
hal_log_err("%s failed\n", __func__);
return -1;
}
}
switch (fill->type) {
case GE_NO_GRADIENT:
case GE_H_LINEAR_GRADIENT:
case GE_V_LINEAR_GRADIENT:
break;
default:
hal_log_err("invalid type: %08x\n", fill->type);
return -1;
}
if (!fill->dst_buf.crop_en) {
dst_rect->x = 0;
dst_rect->y = 0;
dst_rect->width = dst_size->width;
dst_rect->height = dst_size->height;
}
switch (dst_format) {
case MPP_FMT_YUV420P:
case MPP_FMT_NV12:
case MPP_FMT_NV21:
dst_rect->x = dst_rect->x & (~1);
dst_rect->y = dst_rect->y & (~1);
dst_rect->width = dst_rect->width & (~1);
dst_rect->height = dst_rect->height & (~1);
dst_size->width = dst_size->width & (~1);
dst_size->height = dst_size->height & (~1);
break;
case MPP_FMT_YUV422P:
case MPP_FMT_NV16:
case MPP_FMT_NV61:
case MPP_FMT_YUYV:
case MPP_FMT_YVYU:
case MPP_FMT_UYVY:
case MPP_FMT_VYUY:
dst_rect->x = dst_rect->x & (~1);
dst_rect->width = dst_rect->width & (~1);
dst_size->width = dst_size->width & (~1);
break;
default:
break;
}
/* crop dst invalid region */
if ((dst_rect->x + dst_rect->width) > dst_size->width)
dst_rect->width = dst_size->width - dst_rect->x;
if ((dst_rect->y + dst_rect->height) > dst_size->height)
dst_rect->height = dst_size->height - dst_rect->y;
if (dst_rect->width > MAX_WIDTH ||
dst_rect->height > MAX_HEIGHT) {
hal_log_err("invalid dst size, over the largest\n");
return -1;
}
if (!is_rgb(dst_format) &&
(dst_rect->width < 8 ||
dst_rect->height < 8)) {
hal_log_err("invalid dst nsize, the min size of yuv is 8\n");
return -1;
}
return 0;
}
static int ge_config_fillrect_addr(struct aic_ge_data *data,
struct ge_fillrect *fill)
{
u32 dst_w;
u32 dst_h;
u32 dst_addr[3];
u32 dst_stride[2];
struct mpp_rect *dst_rect;
dst_rect = &fill->dst_buf.crop;
dst_w = dst_rect->width;
dst_h = dst_rect->height;
dst_addr[0] = fill->dst_buf.phy_addr[0];
dst_addr[1] = fill->dst_buf.phy_addr[1];
dst_addr[2] = fill->dst_buf.phy_addr[2];
dst_stride[0] = fill->dst_buf.stride[0];
dst_stride[1] = fill->dst_buf.stride[1];
ge_buf_crop(dst_addr, dst_stride,
fill->dst_buf.format,
dst_rect->x,
dst_rect->y,
dst_w,
dst_h);
ge_set_output_info(GE_BASE, dst_w, dst_h,
dst_stride[0], dst_stride[1],
dst_addr);
/* src must has the same width and height as dst in fillrect */
ge_set_src_info(GE_BASE, dst_w, dst_h,
dst_stride[0], dst_stride[1],
dst_addr);
if (need_blend(&fill->ctrl)) {
ge_set_dst_info(GE_BASE, dst_w, dst_h,
dst_stride[0], dst_stride[1],
dst_addr);
}
return 0;
}
static int ge_fillrect(struct aic_ge_data *data,
struct ge_fillrect *fill)
{
int ret;
enum mpp_pixel_format src_fmt = MPP_FMT_ARGB_8888;
/* check buf type */
if (ge_check_buf(data, &fill->dst_buf) < 0)
return -1;
if (check_fillrect(data, fill) != 0)
return -1;
#ifdef AIC_GE_DRV_V11
/* check rgb type */
if (!is_rgb(fill->dst_buf.format)) {
hal_log_err("fill rectangle not support yuv format\n");
return -1;
}
#endif
set_alpha_rules_and_premul(data, &fill->ctrl,
src_fmt, fill->dst_buf.format,
0, fill->dst_buf.flags,
1);
set_csc_flow(data, &fill->ctrl,
src_fmt, fill->dst_buf.format);
/* config dst csc1 yuvtorgb coefs */
if (data->csc1_en)
ge_set_csc_coefs(GE_BASE,
MPP_BUF_COLOR_SPACE_GET(fill->dst_buf.flags),
1);
/* config dst csc2 rgb2yuv coefs */
if (data->csc2_en)
ge_set_csc2_coefs(GE_BASE,
MPP_BUF_COLOR_SPACE_GET(fill->dst_buf.flags));
ge_config_src_simple(GE_BASE,
fill->ctrl.src_global_alpha,
fill->ctrl.src_alpha_mode,
data->src_premul_en,
0, /* func_select */
src_fmt,
fill->type + 1); /* source_mode */
ge_config_output_ctrl(GE_BASE,
data->out_premul_en,
fill->dst_buf.format,
fill->ctrl.dither_en,
data->csc2_en);
if (need_blend(&fill->ctrl)) {
ge_dst_enable(GE_BASE,
fill->ctrl.dst_global_alpha,
fill->ctrl.dst_alpha_mode,
fill->dst_buf.format,
data->csc1_en);
ge_config_blend(GE_BASE,
data->src_de_premul_en,
data->dst_de_premul_en,
0, /* disable alpha output oxff */
data->src_alpha_coef,
data->dst_alpha_coef,
fill->ctrl.ck_en,
fill->ctrl.alpha_en);
} else {
ge_config_blend(GE_BASE,
data->src_de_premul_en,
data->dst_de_premul_en,
0, /* disable alpha output oxff */
data->src_alpha_coef,
data->dst_alpha_coef,
fill->ctrl.ck_en,
fill->ctrl.alpha_en);
ge_dst_disable(GE_BASE);
}
if (fill->ctrl.ck_en)
ge_config_color_key(GE_BASE, fill->ctrl.ck_value);
ge_scaler0_enable(GE_BASE, 0);
ge_config_fillrect_addr(data, fill);
switch (fill->type) {
case GE_NO_GRADIENT:
ge_config_fillrect(GE_BASE, fill->start_color);
break;
case GE_H_LINEAR_GRADIENT:
ge_config_fill_gradient(GE_BASE,
fill->dst_buf.crop.width,
fill->dst_buf.crop.height,
fill->start_color,
fill->end_color,
0);
break;
case GE_V_LINEAR_GRADIENT:
ge_config_fill_gradient(GE_BASE,
fill->dst_buf.crop.width,
fill->dst_buf.crop.height,
fill->start_color,
fill->end_color,
1);
break;
default:
break;
}
ret = ge_start_and_wait(data);
return ret;
}
static int ge_bitblt(struct aic_ge_data *data, struct ge_bitblt *blt)
{
int ret;
/* check buf type */
if (ge_check_buf(data, &blt->src_buf) < 0 ||
ge_check_buf(data, &blt->dst_buf) < 0) {
return -1;
}
#ifdef AIC_GE_DRV_V11
/* check rgb type */
if (!is_rgb(blt->src_buf.format) ||
!is_rgb(blt->dst_buf.format)) {
hal_log_err("bitblt not support yuv format\n");
return -1;
}
#endif
if (check_bitblt(data, blt) != 0)
return -1;
set_alpha_rules_and_premul(data, &blt->ctrl,
blt->src_buf.format, blt->dst_buf.format,
blt->src_buf.flags, blt->dst_buf.flags,
0);
set_csc_flow(data, &blt->ctrl,
blt->src_buf.format, blt->dst_buf.format);
/* config src csc0 yuvtorgb coefs */
if (data->csc0_en)
ge_set_csc_coefs(GE_BASE,
MPP_BUF_COLOR_SPACE_GET(blt->src_buf.flags),
0);
/* config dst csc1 yuvtorgb coefs */
if (data->csc1_en)
ge_set_csc_coefs(GE_BASE,
MPP_BUF_COLOR_SPACE_GET(blt->dst_buf.flags),
1);
/* config dst csc2 rgb2yuv coefs */
if (data->csc2_en)
ge_set_csc2_coefs(GE_BASE,
MPP_BUF_COLOR_SPACE_GET(blt->dst_buf.flags));
ge_config_src_ctrl(GE_BASE,
blt->ctrl.src_global_alpha,
blt->ctrl.src_alpha_mode,
data->src_premul_en,
MPP_SCAN_ORDER_GET(blt->ctrl.flags),
0, /* func_select */
blt->src_buf.format,
MPP_FLIP_V_GET(blt->ctrl.flags),
MPP_FLIP_H_GET(blt->ctrl.flags),
MPP_ROTATION_GET(blt->ctrl.flags),
0, /* fill buffer mode */
data->csc0_en);
ge_config_output_ctrl(GE_BASE,
data->out_premul_en,
blt->dst_buf.format,
blt->ctrl.dither_en,
data->csc2_en);
if (need_blend(&blt->ctrl)) {
ge_dst_enable(GE_BASE,
blt->ctrl.dst_global_alpha,
blt->ctrl.dst_alpha_mode,
blt->dst_buf.format,
data->csc1_en);
ge_config_blend(GE_BASE,
data->src_de_premul_en,
data->dst_de_premul_en,
0, /* disable alpha output oxff */
data->src_alpha_coef,
data->dst_alpha_coef,
blt->ctrl.ck_en,
blt->ctrl.alpha_en);
} else {
ge_config_blend(GE_BASE,
data->src_de_premul_en,
data->dst_de_premul_en,
0, /* disable alpha output oxff */
data->src_alpha_coef,
data->dst_alpha_coef,
blt->ctrl.ck_en,
blt->ctrl.alpha_en);
ge_dst_disable(GE_BASE);
}
if (blt->ctrl.ck_en)
ge_config_color_key(GE_BASE, blt->ctrl.ck_value);
if (blt->ctrl.dither_en)
ge_config_dither(GE_BASE, g_data->dither_line_phys);
ge_config_scaler(data, blt);
ge_config_addr(data, &blt->src_buf, &blt->dst_buf, &blt->ctrl);
ret = ge_start_and_wait(data);
return ret;
}
static int check_format_and_size(struct aic_ge_data *data,
struct mpp_buf *src_buf,
struct mpp_buf *dst_buf)
{
enum mpp_pixel_format src_format = src_buf->format;
enum mpp_pixel_format dst_format = dst_buf->format;
struct mpp_rect *src_rect = &src_buf->crop;
struct mpp_rect *dst_rect = &dst_buf->crop;
if (src_buf->crop_en) {
if (src_rect->x < 0 ||
src_rect->y < 0 ||
src_rect->x >= src_buf->size.width ||
src_rect->y >= src_buf->size.height) {
hal_log_err("src_rect->x:%d, src_rect->y:%d\n", src_rect->x, src_rect->y);
hal_log_err("width:%d, height:%d\n", src_buf->size.width, src_buf->size.height);
hal_log_err("%s failed, invalid src crop\n", __func__);
return -1;
}
}
if (dst_buf->crop_en) {
if (dst_rect->x < 0 ||
dst_rect->y < 0 ||
dst_rect->x >= dst_buf->size.width ||
dst_rect->y >= dst_buf->size.height) {
hal_log_err("%s failed, invalid dst crop\n", __func__);
return -1;
}
}
if (!src_buf->crop_en) {
src_rect->x = 0;
src_rect->y = 0;
src_rect->width = src_buf->size.width;
src_rect->height = src_buf->size.height;
}
if (!dst_buf->crop_en) {
dst_rect->x = 0;
dst_rect->y = 0;
dst_rect->width = dst_buf->size.width;
dst_rect->height = dst_buf->size.height;
}
switch (src_format) {
case MPP_FMT_ARGB_8888:
case MPP_FMT_ABGR_8888:
case MPP_FMT_RGBA_8888:
case MPP_FMT_BGRA_8888:
case MPP_FMT_XRGB_8888:
case MPP_FMT_XBGR_8888:
case MPP_FMT_RGBX_8888:
case MPP_FMT_BGRX_8888:
case MPP_FMT_RGB_888:
case MPP_FMT_BGR_888:
case MPP_FMT_ARGB_1555:
case MPP_FMT_ABGR_1555:
case MPP_FMT_RGBA_5551:
case MPP_FMT_BGRA_5551:
case MPP_FMT_RGB_565:
case MPP_FMT_BGR_565:
case MPP_FMT_ARGB_4444:
case MPP_FMT_ABGR_4444:
case MPP_FMT_RGBA_4444:
case MPP_FMT_BGRA_4444:
break;
default:
hal_log_err("unsupport src format:%d\n", src_format);
return -1;
}
switch (dst_format) {
case MPP_FMT_ARGB_8888:
case MPP_FMT_ABGR_8888:
case MPP_FMT_RGBA_8888:
case MPP_FMT_BGRA_8888:
case MPP_FMT_XRGB_8888:
case MPP_FMT_XBGR_8888:
case MPP_FMT_RGBX_8888:
case MPP_FMT_BGRX_8888:
case MPP_FMT_RGB_888:
case MPP_FMT_BGR_888:
case MPP_FMT_ARGB_1555:
case MPP_FMT_ABGR_1555:
case MPP_FMT_RGBA_5551:
case MPP_FMT_BGRA_5551:
case MPP_FMT_RGB_565:
case MPP_FMT_BGR_565:
case MPP_FMT_ARGB_4444:
case MPP_FMT_ABGR_4444:
case MPP_FMT_RGBA_4444:
case MPP_FMT_BGRA_4444:
break;
default:
hal_log_err("unsupport dst format:%d\n", dst_format);
return -1;
}
/* crop src invalid region */
if ((src_rect->x + src_rect->width) >
src_buf->size.width)
src_rect->width = src_buf->size.width -
src_rect->x;
if ((src_rect->y + src_rect->height) >
src_buf->size.height)
src_rect->height = src_buf->size.height -
src_rect->y;
if (src_rect->width < 4 || src_rect->height < 4 ||
src_rect->width > MAX_WIDTH ||
src_rect->height > MAX_HEIGHT) {
hal_log_err("unsupport src size\n");
return -1;
}
/* crop dst invalid region */
if ((dst_rect->x + dst_rect->width) >
dst_buf->size.width)
dst_rect->width = dst_buf->size.width -
dst_rect->x;
if ((dst_rect->y + dst_rect->height) >
dst_buf->size.height)
dst_rect->height = dst_buf->size.height -
dst_rect->y;
if (dst_rect->width < 4 || dst_rect->height < 4 ||
dst_rect->width > MAX_WIDTH ||
dst_rect->height > MAX_HEIGHT) {
hal_log_err("unsupport dst size\n");
return -1;
}
return 0;
}
static int ge_rotate(struct aic_ge_data *data, struct ge_rotation *rot)
{
int ret;
/* check buf type */
if (ge_check_buf(data, &rot->src_buf) < 0 ||
ge_check_buf(data, &rot->dst_buf) < 0) {
return -1;
}
/* check rgb type */
if (!is_rgb(rot->src_buf.format) ||
!is_rgb(rot->dst_buf.format)) {
hal_log_err("rotation does not support yuv format\n");
return -1;
}
if (MPP_SCAN_ORDER_GET(rot->ctrl.flags)) {
hal_log_err("opening scan order is not supported " \
"using the rotation\n");
return -1;
}
if (check_format_and_size(data, &rot->src_buf,
&rot->dst_buf) != 0)
return -1;
set_alpha_rules_and_premul(data, &rot->ctrl,
rot->src_buf.format, rot->dst_buf.format,
rot->src_buf.flags, rot->dst_buf.flags,
0);
/* rot1 only support rgb format */
data->csc0_en = 0;
data->csc1_en = 0;
data->csc2_en = 0;
ge_config_src_simple(GE_BASE,
rot->ctrl.src_global_alpha,
rot->ctrl.src_alpha_mode,
data->src_premul_en,
1, /* rot1 */
rot->src_buf.format,
0); /* fill buffer mode */
ge_config_output_ctrl(GE_BASE,
data->out_premul_en,
rot->dst_buf.format,
0, /* rot1 does't support dither */
data->csc2_en);
if (need_blend(&rot->ctrl)) {
ge_dst_enable(GE_BASE,
rot->ctrl.dst_global_alpha,
rot->ctrl.dst_alpha_mode,
rot->dst_buf.format,
data->csc1_en);
ge_config_blend(GE_BASE,
data->src_de_premul_en,
data->dst_de_premul_en,
0, /* disable alpha output oxff */
data->src_alpha_coef,
data->dst_alpha_coef,
rot->ctrl.ck_en,
rot->ctrl.alpha_en);
} else {
ge_config_blend(GE_BASE,
data->src_de_premul_en,
data->dst_de_premul_en,
0, /* disable alpha output oxff */
data->src_alpha_coef,
data->dst_alpha_coef,
rot->ctrl.ck_en,
rot->ctrl.alpha_en);
ge_dst_disable(GE_BASE);
}
if (rot->ctrl.ck_en) {
hal_log_warn("warning: rot does't support color key\n");
rot->ctrl.ck_en = 0;
}
ge_scaler0_enable(GE_BASE, 0);
ge_config_rot1(GE_BASE,
rot->angle_sin,
rot->angle_cos,
rot->src_rot_center.x,
rot->src_rot_center.y,
rot->dst_rot_center.x,
rot->dst_rot_center.y);
ge_config_addr(data, &rot->src_buf, &rot->dst_buf, &rot->ctrl);
ret = ge_start_and_wait(data);
return ret;
}
int hal_ge_write(struct aic_ge_client *clt, const char *buff, size_t count)
{
return -1;
}
int hal_ge_control(struct aic_ge_client *clt, int cmd, void *arg)
{
int ret = 0;
(void)clt;
aicos_mutex_take(g_data->lock, AICOS_WAIT_FOREVER);
switch (cmd) {
case IOC_GE_VERSION:
{
u32 version = ge_get_version_id(GE_BASE);
memcpy(arg, &version, sizeof(u32));
}
break;
case IOC_GE_MODE:
memcpy(arg, &g_data->ge_mode, sizeof(u32));
break;
case IOC_GE_FILLRECT:
{
struct ge_fillrect fill;
memcpy(&fill, arg, sizeof(fill));
ret = ge_fillrect(g_data, &fill);
}
break;
case IOC_GE_BITBLT:
{
struct ge_bitblt blt;
memcpy(&blt, arg, sizeof(blt));
ret = ge_bitblt(g_data, &blt);
}
break;
case IOC_GE_ROTATE:
{
struct ge_rotation rot;
memcpy(&rot, arg, sizeof(rot));
ret = ge_rotate(g_data, &rot);
}
break;
default:
hal_log_err("Invalid ioctl: %08x\n", cmd);
ret = -1;
}
aicos_mutex_give(g_data->lock);
return ret;
}
static int ge_clk_enable(struct aic_ge_data *data)
{
int ret;
hal_reset_assert(RESET_GE);
ret = hal_reset_deassert(RESET_GE);
if (ret) {
hal_log_err("%s() - Couldn't deassert\n", __func__);
return ret;
}
ret = hal_clk_set_freq(CLK_GE, GE_CLOCK);
if (ret < 0) {
hal_log_err("VE set clk failed");
return -1;
}
ret = hal_clk_enable(CLK_GE);
if (ret) {
hal_log_err("%s() - Couldn't enable mclk\n", __func__);
return ret;
}
return 0;
}
struct aic_ge_client *hal_ge_open(void)
{
struct aic_ge_client *client = NULL;
client = aicos_malloc(GE_DEFAULT, sizeof(struct aic_ge_client));
if (!client)
return NULL;
memset(client, 0, sizeof(struct aic_ge_client));
return client;
}
int hal_ge_close(struct aic_ge_client *clt)
{
struct aic_ge_client *client = clt;
if (client) {
aicos_free(GE_DEFAULT, client);
}
return 0;
}
int hal_ge_init(void)
{
struct aic_ge_data *data;
hal_log_info("%s()\n", __func__);
data = aicos_malloc(GE_DEFAULT, sizeof(struct aic_ge_data));
if (!data)
return -1;
memset(data, 0, sizeof(struct aic_ge_data));
data->wait = aicos_event_create();
aicos_request_irq(GE_IRQn, aic_ge_handler, 0, NULL, (void *)data);
data->ge_mode = GE_MODE_NORMAL;
data->lock = aicos_mutex_create();
#ifdef AIC_GE_DITHER
int dither_line_len = ALIGN_128B(((MAX_WIDTH * 4) + 127));
data->dither_line_ptr = (u8 *)aicos_malloc(GE_CMA, dither_line_len);
if (!data->dither_line_ptr) {
hal_log_err("failed to malloc dither line buffer\n");
return -1;
}
data->dither_line_phys = ALIGN_128B((uintptr_t)data->dither_line_ptr);
aicos_dcache_clean_invalid_range((unsigned long *)(data->dither_line_phys), (MAX_WIDTH * 4));
hal_log_info("dither line phys :0X0%08x\n", (u32)data->dither_line_phys);
#endif
g_data = data;
ge_clk_enable(data);
hal_log_info("%s() end\n", __func__);
return 0;
}
int hal_ge_deinit(void)
{
if (g_data) {
aicos_mutex_delete(g_data->lock);
aicos_event_delete(g_data->wait);
aicos_free(GE_DEFAULT, g_data);
#ifdef AIC_GE_DITHER
aicos_free(GE_CMA, g_data->dither_line_ptr);
#endif
}
g_data = NULL;
return 0;
}
Reference in New Issue View Git Blame Copy Permalink