| /* | |
| * Copyright (C) 2016 Freescale Semiconductor, Inc. | |
| * Copyright 2017-2018 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" | |
| static unsigned int safety_stream_cf_color = 0x0; | |
| module_param(safety_stream_cf_color, uint, 0444); | |
| MODULE_PARM_DESC(safety_stream_cf_color, | |
| "Safety stream constframe color in hex(0xRRGGBBAA) [default=0x00000000]"); | |
| #define FRAMEDIMENSIONS 0xC | |
| #define WIDTH(w) (((w) - 1) & 0x3FFF) | |
| #define HEIGHT(h) ((((h) - 1) & 0x3FFF) << 16) | |
| #define CONSTANTCOLOR 0x10 | |
| #define RED(r) (((r) & 0xFF) << 24) | |
| #define GREEN(g) (((g) & 0xFF) << 16) | |
| #define BLUE(b) (((b) & 0xFF) << 8) | |
| #define ALPHA(a) ((a) & 0xFF) | |
| #define CONTROLTRIGGER 0x14 | |
| #define START 0x18 | |
| #define STATUS 0x1C | |
| static const shadow_load_req_t cf_shdlreqs[] = { | |
| SHLDREQID_CONSTFRAME0, SHLDREQID_CONSTFRAME1, | |
| SHLDREQID_CONSTFRAME4, SHLDREQID_CONSTFRAME5, | |
| }; | |
| struct dpu_constframe { | |
| void __iomem *pec_base; | |
| void __iomem *base; | |
| struct mutex mutex; | |
| int id; | |
| bool inuse; | |
| struct dpu_soc *dpu; | |
| shadow_load_req_t shdlreq; | |
| }; | |
| static inline u32 dpu_cf_read(struct dpu_constframe *cf, unsigned int offset) | |
| { | |
| return readl(cf->base + offset); | |
| } | |
| static inline void dpu_cf_write(struct dpu_constframe *cf, u32 value, | |
| unsigned int offset) | |
| { | |
| writel(value, cf->base + offset); | |
| } | |
| void constframe_shden(struct dpu_constframe *cf, bool enable) | |
| { | |
| u32 val; | |
| val = enable ? SHDEN : 0; | |
| mutex_lock(&cf->mutex); | |
| dpu_cf_write(cf, val, STATICCONTROL); | |
| mutex_unlock(&cf->mutex); | |
| } | |
| EXPORT_SYMBOL_GPL(constframe_shden); | |
| void constframe_framedimensions(struct dpu_constframe *cf, unsigned int w, | |
| unsigned int h) | |
| { | |
| u32 val; | |
| val = WIDTH(w) | HEIGHT(h); | |
| mutex_lock(&cf->mutex); | |
| dpu_cf_write(cf, val, FRAMEDIMENSIONS); | |
| mutex_unlock(&cf->mutex); | |
| } | |
| EXPORT_SYMBOL_GPL(constframe_framedimensions); | |
| void constframe_framedimensions_copy_prim(struct dpu_constframe *cf) | |
| { | |
| struct dpu_constframe *prim_cf = NULL; | |
| unsigned int prim_id; | |
| int i; | |
| u32 val; | |
| if (cf->id != 0 && cf->id != 1) { | |
| dev_warn(cf->dpu->dev, "ConstFrame%d is not a secondary one\n", | |
| cf->id); | |
| return; | |
| } | |
| prim_id = cf->id + 4; | |
| for (i = 0; i < ARRAY_SIZE(cf_ids); i++) | |
| if (cf_ids[i] == prim_id) | |
| prim_cf = cf->dpu->cf_priv[i]; | |
| if (!prim_cf) { | |
| dev_warn(cf->dpu->dev, "cannot find ConstFrame%d's primary peer\n", | |
| cf->id); | |
| return; | |
| } | |
| mutex_lock(&cf->mutex); | |
| val = dpu_cf_read(prim_cf, FRAMEDIMENSIONS); | |
| dpu_cf_write(cf, val, FRAMEDIMENSIONS); | |
| mutex_unlock(&cf->mutex); | |
| } | |
| EXPORT_SYMBOL_GPL(constframe_framedimensions_copy_prim); | |
| void constframe_constantcolor(struct dpu_constframe *cf, unsigned int r, | |
| unsigned int g, unsigned int b, unsigned int a) | |
| { | |
| u32 val; | |
| val = RED(r) | GREEN(g) | BLUE(b) | ALPHA(a); | |
| mutex_lock(&cf->mutex); | |
| dpu_cf_write(cf, val, CONSTANTCOLOR); | |
| mutex_unlock(&cf->mutex); | |
| } | |
| EXPORT_SYMBOL_GPL(constframe_constantcolor); | |
| void constframe_controltrigger(struct dpu_constframe *cf, bool trigger) | |
| { | |
| u32 val; | |
| val = trigger ? SHDTOKGEN : 0; | |
| mutex_lock(&cf->mutex); | |
| dpu_cf_write(cf, val, CONTROLTRIGGER); | |
| mutex_unlock(&cf->mutex); | |
| } | |
| EXPORT_SYMBOL_GPL(constframe_controltrigger); | |
| shadow_load_req_t constframe_to_shdldreq_t(struct dpu_constframe *cf) | |
| { | |
| shadow_load_req_t t = 0; | |
| switch (cf->id) { | |
| case 0: | |
| t = SHLDREQID_CONSTFRAME0; | |
| break; | |
| case 1: | |
| t = SHLDREQID_CONSTFRAME1; | |
| break; | |
| case 4: | |
| t = SHLDREQID_CONSTFRAME4; | |
| break; | |
| case 5: | |
| t = SHLDREQID_CONSTFRAME5; | |
| break; | |
| } | |
| return t; | |
| } | |
| EXPORT_SYMBOL_GPL(constframe_to_shdldreq_t); | |
| struct dpu_constframe *dpu_cf_get(struct dpu_soc *dpu, int id) | |
| { | |
| struct dpu_constframe *cf; | |
| int i; | |
| for (i = 0; i < ARRAY_SIZE(cf_ids); i++) | |
| if (cf_ids[i] == id) | |
| break; | |
| if (i == ARRAY_SIZE(cf_ids)) | |
| return ERR_PTR(-EINVAL); | |
| cf = dpu->cf_priv[i]; | |
| mutex_lock(&cf->mutex); | |
| if (cf->inuse) { | |
| mutex_unlock(&cf->mutex); | |
| return ERR_PTR(-EBUSY); | |
| } | |
| cf->inuse = true; | |
| mutex_unlock(&cf->mutex); | |
| return cf; | |
| } | |
| EXPORT_SYMBOL_GPL(dpu_cf_get); | |
| void dpu_cf_put(struct dpu_constframe *cf) | |
| { | |
| mutex_lock(&cf->mutex); | |
| cf->inuse = false; | |
| mutex_unlock(&cf->mutex); | |
| } | |
| EXPORT_SYMBOL_GPL(dpu_cf_put); | |
| struct dpu_constframe *dpu_aux_cf_peek(struct dpu_constframe *cf) | |
| { | |
| unsigned int aux_id = cf->id ^ 1; | |
| int i; | |
| for (i = 0; i < ARRAY_SIZE(cf_ids); i++) | |
| if (cf_ids[i] == aux_id) | |
| return cf->dpu->cf_priv[i]; | |
| return NULL; | |
| } | |
| EXPORT_SYMBOL_GPL(dpu_aux_cf_peek); | |
| void _dpu_cf_init(struct dpu_soc *dpu, unsigned int id) | |
| { | |
| struct dpu_constframe *cf; | |
| int i; | |
| for (i = 0; i < ARRAY_SIZE(cf_ids); i++) | |
| if (cf_ids[i] == id) | |
| break; | |
| if (WARN_ON(i == ARRAY_SIZE(cf_ids))) | |
| return; | |
| cf = dpu->cf_priv[i]; | |
| constframe_shden(cf, true); | |
| if (id == 4 || id == 5) { | |
| mutex_lock(&cf->mutex); | |
| dpu_cf_write(cf, safety_stream_cf_color, CONSTANTCOLOR); | |
| mutex_unlock(&cf->mutex); | |
| } | |
| } | |
| int dpu_cf_init(struct dpu_soc *dpu, unsigned int id, | |
| unsigned long pec_base, unsigned long base) | |
| { | |
| struct dpu_constframe *cf; | |
| int i; | |
| cf = devm_kzalloc(dpu->dev, sizeof(*cf), GFP_KERNEL); | |
| if (!cf) | |
| return -ENOMEM; | |
| for (i = 0; i < ARRAY_SIZE(cf_ids); i++) | |
| if (cf_ids[i] == id) | |
| break; | |
| if (i == ARRAY_SIZE(cf_ids)) | |
| return -EINVAL; | |
| dpu->cf_priv[i] = cf; | |
| cf->pec_base = devm_ioremap(dpu->dev, pec_base, SZ_16); | |
| if (!cf->pec_base) | |
| return -ENOMEM; | |
| cf->base = devm_ioremap(dpu->dev, base, SZ_32); | |
| if (!cf->base) | |
| return -ENOMEM; | |
| cf->dpu = dpu; | |
| cf->id = id; | |
| cf->shdlreq = cf_shdlreqs[i]; | |
| mutex_init(&cf->mutex); | |
| _dpu_cf_init(dpu, id); | |
| return 0; | |
| } |