| /* |
| * Copyright (C) 2016 Freescale Semiconductor, Inc. |
| * Copyright 2017 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 <linux/io.h> |
| #include <linux/module.h> |
| #include <linux/mutex.h> |
| #include <linux/platform_device.h> |
| #include <linux/types.h> |
| #include <video/dpu.h> |
| #include "dpu-prv.h" |
| |
| #define PIXENGCFG_STATUS 0x8 |
| #define BASEADDRESS(n) (0x10 + (n) * 0x28) |
| #define SOURCEBUFFERATTRIBUTES(n) (0x14 + (n) * 0x28) |
| #define SOURCEBUFFERDIMENSION(n) (0x18 + (n) * 0x28) |
| #define COLORCOMPONENTBITS(n) (0x1C + (n) * 0x28) |
| #define COLORCOMPONENTSHIFT(n) (0x20 + (n) * 0x28) |
| #define LAYEROFFSET(n) (0x24 + (n) * 0x28) |
| #define CLIPWINDOWOFFSET(n) (0x28 + (n) * 0x28) |
| #define CLIPWINDOWDIMENSIONS(n) (0x2C + (n) * 0x28) |
| #define CONSTANTCOLOR(n) (0x30 + (n) * 0x28) |
| #define LAYERPROPERTY(n) (0x34 + (n) * 0x28) |
| #define FRAMEDIMENSIONS 0x150 |
| #define FRAMERESAMPLING 0x154 |
| #define CONTROL 0x158 |
| #define TRIGGERENABLE 0x15C |
| #define SHDLDREQ(lm) ((lm) & 0xFF) |
| #define CONTROLTRIGGER 0x160 |
| #define START 0x164 |
| #define FETCHTYPE 0x168 |
| #define BURSTBUFFERPROPERTIES 0x16C |
| #define STATUS 0x170 |
| #define HIDDENSTATUS 0x174 |
| |
| static const shadow_load_req_t fl_shdlreqs[] = { |
| SHLDREQID_FETCHLAYER0, SHLDREQID_FETCHLAYER1, |
| }; |
| |
| struct dpu_fetchlayer { |
| void __iomem *pec_base; |
| void __iomem *base; |
| struct mutex mutex; |
| int id; |
| bool inuse; |
| struct dpu_soc *dpu; |
| fetchtype_t fetchtype; |
| shadow_load_req_t shdlreq; |
| }; |
| |
| static inline u32 dpu_fl_read(struct dpu_fetchlayer *fl, unsigned int offset) |
| { |
| return readl(fl->base + offset); |
| } |
| |
| static inline void dpu_fl_write(struct dpu_fetchlayer *fl, u32 value, |
| unsigned int offset) |
| { |
| writel(value, fl->base + offset); |
| } |
| |
| static inline u32 rgb_color(u8 r, u8 g, u8 b, u8 a) |
| { |
| return (r << 24) | (g << 16) | (b << 8) | a; |
| } |
| |
| static inline u32 yuv_color(u8 y, u8 u, u8 v) |
| { |
| return (y << 24) | (u << 16) | (v << 8); |
| } |
| |
| void fetchlayer_shden(struct dpu_fetchlayer *fl, bool enable) |
| { |
| u32 val; |
| |
| mutex_lock(&fl->mutex); |
| val = dpu_fl_read(fl, STATICCONTROL); |
| if (enable) |
| val |= SHDEN; |
| else |
| val &= ~SHDEN; |
| dpu_fl_write(fl, val, STATICCONTROL); |
| mutex_unlock(&fl->mutex); |
| } |
| EXPORT_SYMBOL_GPL(fetchlayer_shden); |
| |
| void fetchlayer_baddr_autoupdate(struct dpu_fetchlayer *fl, u8 layer_mask) |
| { |
| u32 val; |
| |
| mutex_lock(&fl->mutex); |
| val = dpu_fl_read(fl, STATICCONTROL); |
| val &= ~BASEADDRESSAUTOUPDATE_MASK; |
| val |= BASEADDRESSAUTOUPDATE(layer_mask); |
| dpu_fl_write(fl, val, STATICCONTROL); |
| mutex_unlock(&fl->mutex); |
| } |
| EXPORT_SYMBOL_GPL(fetchlayer_baddr_autoupdate); |
| |
| void fetchlayer_framedimensions(struct dpu_fetchlayer *fl, unsigned int w, |
| unsigned int h) |
| { |
| u32 val; |
| |
| val = FRAMEWIDTH(w) | FRAMEHEIGHT(h); |
| |
| mutex_lock(&fl->mutex); |
| dpu_fl_write(fl, val, FRAMEDIMENSIONS); |
| mutex_unlock(&fl->mutex); |
| } |
| EXPORT_SYMBOL_GPL(fetchlayer_framedimensions); |
| |
| void fetchlayer_rgb_constantcolor(struct dpu_fetchlayer *fl, |
| u8 r, u8 g, u8 b, u8 a) |
| { |
| u32 val; |
| |
| val = rgb_color(r, g, b, a); |
| |
| mutex_lock(&fl->mutex); |
| dpu_fl_write(fl, val, CONSTANTCOLOR(fl->id)); |
| mutex_unlock(&fl->mutex); |
| } |
| EXPORT_SYMBOL_GPL(fetchlayer_rgb_constantcolor); |
| |
| void fetchlayer_yuv_constantcolor(struct dpu_fetchlayer *fl, u8 y, u8 u, u8 v) |
| { |
| u32 val; |
| |
| val = yuv_color(y, u, v); |
| |
| mutex_lock(&fl->mutex); |
| dpu_fl_write(fl, val, CONSTANTCOLOR(fl->id)); |
| mutex_unlock(&fl->mutex); |
| } |
| EXPORT_SYMBOL_GPL(fetchlayer_yuv_constantcolor); |
| |
| void fetchlayer_controltrigger(struct dpu_fetchlayer *fl, bool trigger) |
| { |
| u32 val; |
| |
| val = trigger ? SHDTOKGEN : 0; |
| |
| mutex_lock(&fl->mutex); |
| dpu_fl_write(fl, val, CONTROLTRIGGER); |
| mutex_unlock(&fl->mutex); |
| } |
| EXPORT_SYMBOL_GPL(fetchlayer_controltrigger); |
| |
| int fetchlayer_fetchtype(struct dpu_fetchlayer *fl, fetchtype_t *type) |
| { |
| struct dpu_soc *dpu = fl->dpu; |
| u32 val; |
| |
| mutex_lock(&fl->mutex); |
| val = dpu_fl_read(fl, FETCHTYPE); |
| val &= FETCHTYPE_MASK; |
| mutex_unlock(&fl->mutex); |
| |
| switch (val) { |
| case FETCHTYPE__DECODE: |
| dev_dbg(dpu->dev, "FetchLayer%d with RL and RLAD decoder\n", |
| fl->id); |
| break; |
| case FETCHTYPE__LAYER: |
| dev_dbg(dpu->dev, "FetchLayer%d with fractional " |
| "plane(8 layers)\n", fl->id); |
| break; |
| case FETCHTYPE__WARP: |
| dev_dbg(dpu->dev, "FetchLayer%d with arbitrary warping and " |
| "fractional plane(8 layers)\n", fl->id); |
| break; |
| case FETCHTYPE__ECO: |
| dev_dbg(dpu->dev, "FetchLayer%d with minimum feature set for " |
| "alpha, chroma and coordinate planes\n", |
| fl->id); |
| break; |
| case FETCHTYPE__PERSP: |
| dev_dbg(dpu->dev, "FetchLayer%d with affine, perspective and " |
| "arbitrary warping\n", fl->id); |
| break; |
| case FETCHTYPE__ROT: |
| dev_dbg(dpu->dev, "FetchLayer%d with affine and arbitrary " |
| "warping\n", fl->id); |
| break; |
| case FETCHTYPE__DECODEL: |
| dev_dbg(dpu->dev, "FetchLayer%d with RL and RLAD decoder, " |
| "reduced feature set\n", fl->id); |
| break; |
| case FETCHTYPE__LAYERL: |
| dev_dbg(dpu->dev, "FetchLayer%d with fractional " |
| "plane(8 layers), reduced feature set\n", |
| fl->id); |
| break; |
| case FETCHTYPE__ROTL: |
| dev_dbg(dpu->dev, "FetchLayer%d with affine and arbitrary " |
| "warping, reduced feature set\n", fl->id); |
| break; |
| default: |
| dev_warn(dpu->dev, "Invalid fetch type %u for FetchLayer%d\n", |
| val, fl->id); |
| return -EINVAL; |
| } |
| |
| *type = val; |
| return 0; |
| } |
| EXPORT_SYMBOL_GPL(fetchlayer_fetchtype); |
| |
| struct dpu_fetchlayer *dpu_fl_get(struct dpu_soc *dpu, int id) |
| { |
| struct dpu_fetchlayer *fl; |
| int i; |
| |
| for (i = 0; i < ARRAY_SIZE(fl_ids); i++) |
| if (fl_ids[i] == id) |
| break; |
| |
| if (i == ARRAY_SIZE(fl_ids)) |
| return ERR_PTR(-EINVAL); |
| |
| fl = dpu->fl_priv[i]; |
| |
| mutex_lock(&fl->mutex); |
| |
| if (fl->inuse) { |
| fl = ERR_PTR(-EBUSY); |
| goto out; |
| } |
| |
| fl->inuse = true; |
| out: |
| mutex_unlock(&fl->mutex); |
| |
| return fl; |
| } |
| EXPORT_SYMBOL_GPL(dpu_fl_get); |
| |
| void dpu_fl_put(struct dpu_fetchlayer *fl) |
| { |
| mutex_lock(&fl->mutex); |
| |
| fl->inuse = false; |
| |
| mutex_unlock(&fl->mutex); |
| } |
| EXPORT_SYMBOL_GPL(dpu_fl_put); |
| |
| void _dpu_fl_init(struct dpu_soc *dpu, unsigned int id) |
| { |
| } |
| |
| int dpu_fl_init(struct dpu_soc *dpu, unsigned int id, |
| unsigned long pec_base, unsigned long base) |
| { |
| struct dpu_fetchlayer *fl; |
| int ret, i; |
| |
| fl = devm_kzalloc(dpu->dev, sizeof(*fl), GFP_KERNEL); |
| if (!fl) |
| return -ENOMEM; |
| |
| dpu->fl_priv[id] = fl; |
| |
| fl->pec_base = devm_ioremap(dpu->dev, base, SZ_16); |
| if (!fl->pec_base) |
| return -ENOMEM; |
| |
| fl->base = devm_ioremap(dpu->dev, base, SZ_512); |
| if (!fl->base) |
| return -ENOMEM; |
| |
| fl->dpu = dpu; |
| fl->id = id; |
| for (i = 0; i < ARRAY_SIZE(fl_ids); i++) { |
| if (fl_ids[i] == id) { |
| fl->shdlreq = fl_shdlreqs[i]; |
| break; |
| } |
| } |
| mutex_init(&fl->mutex); |
| |
| ret = fetchlayer_fetchtype(fl, &fl->fetchtype); |
| if (ret < 0) |
| return ret; |
| |
| return 0; |
| } |