/* linux/drivers/char/sunxi_tr/sunxi_tr.c
|
*
|
* Copyright (c) 2014 Allwinnertech Co., Ltd.
|
* Author: Tyle <tyle@allwinnertech.com>
|
*
|
* Transform driver for sunxi platform
|
*
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License version 2 as
|
* published by the Free Software Foundation.
|
*/
|
|
#include "transform.h"
|
#include <linux/compat.h>
|
#include <linux/idr.h>
|
#include <linux/dma-buf.h>
|
|
#define TR_CHAN_MAX 32
|
/* #define TR_POLL */
|
/* #define TR_CHECK_THREAD */
|
|
#if (defined CONFIG_ARCH_SUN50IW3P1) || (defined CONFIG_ARCH_SUN50IW1P1)
|
#define USE_DMA_BUF
|
#endif
|
|
struct dmabuf_item {
|
struct list_head list;
|
int fd;
|
struct dma_buf *buf;
|
struct dma_buf_attachment *attachment;
|
struct sg_table *sgt;
|
dma_addr_t dma_addr;
|
unsigned long long id;
|
};
|
struct sunxi_transform {
|
int id; /* chan id */
|
struct rb_node node;
|
struct list_head list;
|
bool requested; /* indicate if have request */
|
bool busy; /* at busy state when transforming */
|
bool error;/* indicate some error happens in this channel */
|
unsigned long start_time; /* the time when starting transform */
|
unsigned long timeout;/* ms */
|
tr_info info;
|
};
|
|
struct sunxi_trdev {
|
struct device *dev;
|
void __iomem *base;
|
int irq;
|
struct clk *clk; /* clock gate for tr */
|
spinlock_t slock;
|
struct mutex mlock;
|
struct list_head trs; /* transform chan list */
|
unsigned int count; /* transform channel counter */
|
struct sunxi_transform *cur_tr; /*curent transform channel processing*/
|
bool busy;
|
struct task_struct *task;
|
struct idr idr;
|
struct rb_node node;
|
struct rb_root handles;
|
};
|
|
static struct sunxi_trdev *gsunxi_dev;
|
|
static struct cdev *tr_cdev;
|
static dev_t devid;
|
static struct class *tr_class;
|
static struct device *tr_dev;
|
static bool dev_init;
|
static struct mutex id_lock;
|
static struct device *dmabuf_dev;
|
|
u32 dbg_inf;
|
|
/* #define struct sunxi_trdev *to_sunxi_trdev(dev)
|
* container_of(dev, struct sunxi_trdev, dev)
|
*/
|
static int sunxi_tr_finish_procss(void);
|
|
#if !defined(CONFIG_OF)
|
static struct resource tr_resource[] = {
|
[0] = {
|
.start = (int __force)SUNXI_DE_VBASE,
|
.end = (int __force)(SUNXI_DE_VBASE + SUNXI_DE_SIZE),
|
.flags = IORESOURCE_MEM,
|
},
|
[1] = {
|
.start = (int __force)SUNXI_IRQ_DEIRQ1,
|
.end = (int __force)SUNXI_IRQ_DEIRQ1,
|
.flags = IORESOURCE_IRQ,
|
},
|
};
|
#endif
|
|
static ssize_t tr_debug_show(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
return sprintf(buf, "debug=%d\n", dbg_inf);
|
}
|
|
static ssize_t tr_debug_store(struct device *dev,
|
struct device_attribute *attr,
|
const char *buf, size_t count)
|
{
|
if (strncasecmp(buf, "1", 1) == 0)
|
dbg_inf = 1;
|
else if (strncasecmp(buf, "0", 1) == 0)
|
dbg_inf = 0;
|
else
|
pr_err("Error input!\n");
|
|
return count;
|
}
|
|
static DEVICE_ATTR(debug, 0660,
|
tr_debug_show, tr_debug_store);
|
|
static struct attribute *tr_attributes[] = {
|
&dev_attr_debug.attr,
|
NULL
|
};
|
|
static struct attribute_group tr_attribute_group = {
|
.name = "attr",
|
.attrs = tr_attributes
|
};
|
|
#ifdef USE_DMA_BUF
|
static int tr_dma_map(int fd, struct dmabuf_item *item)
|
{
|
struct dma_buf *dmabuf;
|
struct dma_buf_attachment *attachment;
|
struct sg_table *sgt, *sgt_bak;
|
struct scatterlist *sgl, *sgl_bak;
|
s32 sg_count = 0;
|
int ret = -1;
|
int i;
|
|
if (fd < 0) {
|
pr_err("dma_buf_id(%d) is invalid\n", fd);
|
goto exit;
|
}
|
dmabuf = dma_buf_get(fd);
|
if (IS_ERR(dmabuf)) {
|
pr_err("dma_buf_get failed\n");
|
goto exit;
|
}
|
|
attachment = dma_buf_attach(dmabuf, dmabuf_dev);
|
if (IS_ERR(attachment)) {
|
pr_err("dma_buf_attach failed\n");
|
goto err_buf_put;
|
}
|
sgt = dma_buf_map_attachment(attachment, DMA_FROM_DEVICE);
|
if (IS_ERR_OR_NULL(sgt)) {
|
pr_err("dma_buf_map_attachment failed\n");
|
goto err_buf_detach;
|
}
|
|
/* create a private sgtable base on the given dmabuf */
|
sgt_bak = kmalloc(sizeof(struct sg_table), GFP_KERNEL | __GFP_ZERO);
|
if (sgt_bak == NULL) {
|
pr_err("alloc sgt fail\n");
|
goto err_buf_unmap;
|
}
|
ret = sg_alloc_table(sgt_bak, sgt->nents, GFP_KERNEL);
|
if (ret != 0) {
|
pr_err("alloc sgt fail\n");
|
goto err_kfree;
|
}
|
sgl_bak = sgt_bak->sgl;
|
for_each_sg(sgt->sgl, sgl, sgt->nents, i) {
|
sg_set_page(sgl_bak, sg_page(sgl), sgl->length, sgl->offset);
|
sgl_bak = sg_next(sgl_bak);
|
}
|
|
sg_count = dma_map_sg_attrs(dmabuf_dev, sgt_bak->sgl,
|
sgt_bak->nents, DMA_FROM_DEVICE,
|
DMA_ATTR_SKIP_CPU_SYNC);
|
|
if (sg_count != 1) {
|
pr_err("dma_map_sg failed:%d\n", sg_count);
|
goto err_sgt_free;
|
}
|
|
item->fd = fd;
|
item->buf = dmabuf;
|
item->sgt = sgt_bak;
|
item->attachment = attachment;
|
item->dma_addr = sg_dma_address(sgt_bak->sgl);
|
ret = 0;
|
|
goto exit;
|
|
err_sgt_free:
|
sg_free_table(sgt_bak);
|
err_kfree:
|
kfree(sgt_bak);
|
err_buf_unmap:
|
/* unmap attachment sgt, not sgt_bak, because it's not alloc yet! */
|
dma_buf_unmap_attachment(attachment, sgt, DMA_FROM_DEVICE);
|
err_buf_detach:
|
dma_buf_detach(dmabuf, attachment);
|
err_buf_put:
|
dma_buf_put(dmabuf);
|
exit:
|
return ret;
|
}
|
|
static void tr_dma_unmap(struct dmabuf_item *item)
|
{
|
dma_unmap_sg_attrs(dmabuf_dev, item->sgt->sgl,
|
item->sgt->nents, DMA_FROM_DEVICE,
|
DMA_ATTR_SKIP_CPU_SYNC);
|
dma_buf_unmap_attachment(item->attachment, item->sgt, DMA_FROM_DEVICE);
|
sg_free_table(item->sgt);
|
kfree(item->sgt);
|
dma_buf_detach(item->buf, item->attachment);
|
dma_buf_put(item->buf);
|
}
|
|
static struct tr_format_attr fmt_attr_tbl[] = {
|
/*
|
*format bits
|
* hor_rsample(u,v)
|
* ver_rsample(u,v)
|
* uvc
|
* interleave
|
* factor
|
* div
|
*/
|
{ TR_FORMAT_ARGB_8888, 8, 1, 1, 1, 1, 0, 1, 4, 1},
|
{ TR_FORMAT_ABGR_8888, 8, 1, 1, 1, 1, 0, 1, 4, 1},
|
{ TR_FORMAT_RGBA_8888, 8, 1, 1, 1, 1, 0, 1, 4, 1},
|
{ TR_FORMAT_BGRA_8888, 8, 1, 1, 1, 1, 0, 1, 4, 1},
|
{ TR_FORMAT_XRGB_8888, 8, 1, 1, 1, 1, 0, 1, 4, 1},
|
{ TR_FORMAT_XBGR_8888, 8, 1, 1, 1, 1, 0, 1, 4, 1},
|
{ TR_FORMAT_RGBX_8888, 8, 1, 1, 1, 1, 0, 1, 4, 1},
|
{ TR_FORMAT_BGRX_8888, 8, 1, 1, 1, 1, 0, 1, 4, 1},
|
{ TR_FORMAT_RGB_888, 8, 1, 1, 1, 1, 0, 1, 3, 1},
|
{ TR_FORMAT_BGR_888, 8, 1, 1, 1, 1, 0, 1, 3, 1},
|
{ TR_FORMAT_RGB_565, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
{ TR_FORMAT_BGR_565, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
{ TR_FORMAT_ARGB_4444, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
{ TR_FORMAT_ABGR_4444, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
{ TR_FORMAT_RGBA_4444, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
{ TR_FORMAT_BGRA_4444, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
{ TR_FORMAT_ARGB_1555, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
{ TR_FORMAT_ABGR_1555, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
{ TR_FORMAT_RGBA_5551, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
{ TR_FORMAT_BGRA_5551, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
|
{ TR_FORMAT_YUV444_I_AYUV, 8, 1, 1, 1, 1, 0, 1, 3, 1},
|
{ TR_FORMAT_YUV444_I_VUYA, 8, 1, 1, 1, 1, 0, 1, 3, 1},
|
{ TR_FORMAT_YUV422_I_YVYU, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
{ TR_FORMAT_YUV422_I_YUYV, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
{ TR_FORMAT_YUV422_I_UYVY, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
{ TR_FORMAT_YUV422_I_VYUY, 8, 1, 1, 1, 1, 0, 1, 2, 1},
|
{ TR_FORMAT_YUV444_P, 8, 1, 1, 1, 1, 0, 1, 1, 1},
|
{ TR_FORMAT_YUV422_P, 8, 2, 2, 1, 1, 0, 0, 2, 1},
|
{ TR_FORMAT_YUV420_P, 8, 2, 2, 2, 2, 0, 0, 3, 2},
|
{ TR_FORMAT_YUV411_P, 8, 4, 4, 1, 1, 0, 0, 3, 2},
|
{ TR_FORMAT_YUV422_SP_UVUV, 8, 2, 2, 1, 1, 1, 0, 2, 1},
|
{ TR_FORMAT_YUV422_SP_VUVU, 8, 2, 2, 1, 1, 1, 0, 2, 1},
|
{ TR_FORMAT_YUV420_SP_UVUV, 8, 2, 2, 2, 2, 1, 0, 3, 2},
|
{ TR_FORMAT_YUV420_SP_VUVU, 8, 2, 2, 2, 2, 1, 0, 3, 2},
|
{ TR_FORMAT_YUV411_SP_UVUV, 8, 4, 4, 1, 1, 1, 0, 3, 2},
|
{ TR_FORMAT_YUV411_SP_VUVU, 8, 4, 4, 1, 1, 1, 0, 3, 2},
|
};
|
|
s32 tr_set_info(tr_frame *tr_para, struct dmabuf_item *item)
|
{
|
s32 ret = -1;
|
u32 i = 0;
|
u32 len = ARRAY_SIZE(fmt_attr_tbl);
|
u32 y_width, y_height, u_width, u_height;
|
u32 y_pitch, u_pitch;
|
u32 y_size, u_size;
|
|
tr_para->laddr[0] = item->dma_addr;
|
|
if (tr_para->fmt >= TR_FORMAT_MAX) {
|
pr_err("%s, format 0x%x is out of range\n", __func__,
|
tr_para->fmt);
|
goto exit;
|
}
|
|
for (i = 0; i < len; ++i) {
|
|
if (fmt_attr_tbl[i].format == tr_para->fmt) {
|
y_width = tr_para->pitch[0];
|
y_height = tr_para->height[0];
|
u_width = y_width/fmt_attr_tbl[i].hor_rsample_u;
|
u_height = y_height/fmt_attr_tbl[i].ver_rsample_u;
|
|
y_pitch = y_width;
|
u_pitch = u_width * (fmt_attr_tbl[i].uvc + 1);
|
|
y_size = y_pitch * y_height;
|
u_size = u_pitch * u_height;
|
tr_para->laddr[1] = tr_para->laddr[0] + y_size;
|
tr_para->laddr[2] = tr_para->laddr[0] + y_size + u_size;
|
if (tr_para->fmt == TR_FORMAT_YUV420_P) {
|
/* v */
|
tr_para->laddr[1] = tr_para->laddr[0] + y_size + u_size;
|
tr_para->laddr[2] = tr_para->laddr[0] + y_size; /* u */
|
}
|
|
ret = 0;
|
break;
|
}
|
}
|
if (ret != 0)
|
pr_err("%s, format 0x%x is invalid\n", __func__,
|
tr_para->fmt);
|
exit:
|
return ret;
|
|
}
|
#endif
|
#if defined(TR_CHECK_THREAD)
|
static int tr_thread(void *parg)
|
{
|
while (1) {
|
struct sunxi_transform *tr = NULL;
|
unsigned long timeout = 0;
|
|
if (kthread_should_stop())
|
break;
|
tr = gsunxi_dev->cur_tr;
|
if (tr) {
|
timeout = tr->start_time +
|
msecs_to_jiffies(tr->timeout);
|
if (time_after_eq(jiffies, timeout)) {
|
pr_warn("%s, timeout(%d ms)\n", __func__,
|
jiffies_to_msecs(jiffies - tr->start_time));
|
de_tr_reset();
|
tr->busy = false;
|
tr->error = true;
|
|
sunxi_tr_finish_procss();
|
}
|
}
|
|
msleep(10);
|
}
|
|
return 0;
|
}
|
#endif
|
|
static int tr_check_timeout(void)
|
{
|
struct sunxi_transform *tr = NULL;
|
unsigned long timeout = 0;
|
unsigned long flags;
|
|
tr = gsunxi_dev->cur_tr;
|
if (tr == NULL)
|
return 0;
|
|
spin_lock_irqsave(&gsunxi_dev->slock, flags);
|
timeout = tr->start_time + msecs_to_jiffies(tr->timeout);
|
if (tr->busy && time_after_eq(jiffies, timeout)) {
|
tr->busy = false;
|
tr->error = true;
|
spin_unlock_irqrestore(&gsunxi_dev->slock, flags);
|
de_tr_exception();
|
pr_warn("%s, timeout(%d ms)\n", __func__,
|
jiffies_to_msecs(jiffies - tr->start_time));
|
sunxi_tr_finish_procss();
|
} else
|
spin_unlock_irqrestore(&gsunxi_dev->slock, flags);
|
|
return 0;
|
}
|
|
/* find a tr which has request and a longest time to process */
|
static struct sunxi_transform *tr_find_proper_task(void)
|
{
|
struct sunxi_transform *tr = NULL, *proper_tr = NULL;
|
unsigned long min_time = jiffies;
|
|
list_for_each_entry(tr, &gsunxi_dev->trs, list) {
|
bool condition1 = (true == tr->requested);
|
bool condition2 = time_after_eq(min_time, tr->start_time);
|
|
if (condition1 && condition2) {
|
min_time = tr->start_time;
|
proper_tr = tr;
|
} else {
|
/* printk("find_task: %d,%d, %ld,%ld\n", condition1,
|
* condition2, min_time, tr->start_time);
|
*/
|
}
|
}
|
|
return proper_tr;
|
}
|
|
/* protect by @slock */
|
static int tr_process_next_proper_task(u32 from)
|
{
|
unsigned long flags;
|
struct sunxi_transform *tr = NULL;
|
int ret = -1;
|
|
spin_lock_irqsave(&gsunxi_dev->slock, flags);
|
if (gsunxi_dev->busy) {
|
spin_unlock_irqrestore(&gsunxi_dev->slock, flags);
|
return -1;
|
}
|
|
/* find a tr which has request */
|
tr = tr_find_proper_task();
|
if (tr != NULL) {
|
/* process request */
|
gsunxi_dev->busy = true;
|
tr->busy = true;
|
tr->error = false;
|
tr->start_time = jiffies;
|
tr->requested = false;
|
|
gsunxi_dev->cur_tr = tr;
|
}
|
spin_unlock_irqrestore(&gsunxi_dev->slock, flags);
|
|
if (tr != NULL)
|
ret = de_tr_set_cfg(&tr->info);
|
|
return ret;
|
}
|
|
static int sunxi_tr_finish_procss(void)
|
{
|
unsigned long flags;
|
|
/* correct interrupt */
|
spin_lock_irqsave(&gsunxi_dev->slock, flags);
|
if (gsunxi_dev->cur_tr) {
|
gsunxi_dev->cur_tr->busy = false;
|
gsunxi_dev->cur_tr = NULL;
|
gsunxi_dev->busy = false;
|
}
|
spin_unlock_irqrestore(&gsunxi_dev->slock, flags);
|
|
tr_process_next_proper_task(0);
|
|
return 0;
|
}
|
|
static struct sunxi_transform *tr_get_by_id(int id)
|
{
|
struct sunxi_transform *tr;
|
|
mutex_lock(&gsunxi_dev->mlock);
|
tr = idr_find(&gsunxi_dev->idr, id);
|
mutex_unlock(&gsunxi_dev->mlock);
|
|
return tr ? tr : ERR_PTR(-EINVAL);
|
}
|
|
/*
|
* sunxi_tr_request - request transform channel
|
* On success, returns transform handle. On failure, returns 0.
|
*/
|
|
unsigned int sunxi_tr_request(void)
|
{
|
struct sunxi_transform *tr = NULL;
|
unsigned long flags;
|
unsigned int count = 0;
|
struct rb_node **p = &gsunxi_dev->handles.rb_node;
|
struct rb_node *parent = NULL;
|
struct sunxi_transform *entry;
|
int id;
|
|
if (gsunxi_dev->count > TR_CHAN_MAX) {
|
pr_warn("%s(), user number have exceed max number %d\n",
|
__func__, TR_CHAN_MAX);
|
return 0;
|
}
|
|
tr = kzalloc(sizeof(struct sunxi_transform), GFP_KERNEL);
|
if (!tr) {
|
pr_warn("alloc fail\n");
|
return 0;
|
}
|
|
RB_CLEAR_NODE(&tr->node);
|
tr->requested = false;
|
tr->busy = false;
|
tr->error = false;
|
tr->timeout = 50; /* default 50ms timeout */
|
tr->start_time = jiffies;
|
id = idr_alloc(&gsunxi_dev->idr, tr, 1, 0, GFP_KERNEL);
|
if (id < 0)
|
return 0;
|
tr->id = id;
|
|
mutex_lock(&gsunxi_dev->mlock);
|
while (*p) {
|
parent = *p;
|
entry = rb_entry(parent, struct sunxi_transform, node);
|
|
if (tr < entry)
|
p = &(*p)->rb_left;
|
|
else if (tr > entry)
|
p = &(*p)->rb_right;
|
else
|
pr_warn("%s: tr already found.\n", __func__);
|
}
|
rb_link_node(&tr->node, parent, p);
|
rb_insert_color(&tr->node, &gsunxi_dev->handles);
|
mutex_unlock(&gsunxi_dev->mlock);
|
|
spin_lock_irqsave(&gsunxi_dev->slock, flags);
|
list_add_tail(&tr->list, &gsunxi_dev->trs);
|
gsunxi_dev->count++;
|
count = gsunxi_dev->count;
|
spin_unlock_irqrestore(&gsunxi_dev->slock, flags);
|
|
mutex_lock(&gsunxi_dev->mlock);
|
if (count == 1) {
|
if (gsunxi_dev->clk)
|
clk_prepare_enable(gsunxi_dev->clk);
|
de_tr_init();
|
|
#if defined(TR_CHECK_THREAD)
|
gsunxi_dev->task = kthread_create(tr_thread,
|
(void *)0, "tr_thread");
|
if (IS_ERR(gsunxi_dev->task)) {
|
pr_warn("Unable to start kernel thread %s.\n",
|
"tr_thread");
|
gsunxi_dev->task = NULL;
|
} else
|
wake_up_process(gsunxi_dev->task);
|
#endif
|
}
|
mutex_unlock(&gsunxi_dev->mlock);
|
TR_INFO_MSG("%s, count=%d\n", __func__, count);
|
|
return id;
|
}
|
EXPORT_SYMBOL_GPL(sunxi_tr_request);
|
/*
|
* sunxi_tr_release - release transform channel
|
* @hdl: transform handle which return by sunxi_tr_request
|
* On success, returns 0. On failure, returns ERR_PTR(-errno).
|
*/
|
int sunxi_tr_release(unsigned int id)
|
{
|
struct sunxi_transform *tr = tr_get_by_id(id);
|
unsigned long flags;
|
unsigned int count = 0;
|
|
if (IS_ERR_OR_NULL(tr)) {
|
pr_warn("%s, hdl is invalid!\n", __func__);
|
return -EINVAL;
|
}
|
|
|
mutex_lock(&gsunxi_dev->mlock);
|
idr_remove(&gsunxi_dev->idr, tr->id);
|
if (!RB_EMPTY_NODE(&tr->node))
|
rb_erase(&tr->node, &gsunxi_dev->handles);
|
mutex_unlock(&gsunxi_dev->mlock);
|
|
spin_lock_irqsave(&gsunxi_dev->slock, flags);
|
list_del(&tr->list);
|
gsunxi_dev->count--;
|
count = gsunxi_dev->count;
|
kfree((void *)tr);
|
spin_unlock_irqrestore(&gsunxi_dev->slock, flags);
|
|
mutex_lock(&gsunxi_dev->mlock);
|
if (count == 0) {
|
#if defined(TR_CHECK_THREAD)
|
kthread_stop(gsunxi_dev->task);
|
gsunxi_dev->task = NULL;
|
#endif
|
de_tr_exit();
|
if (gsunxi_dev->clk)
|
clk_disable(gsunxi_dev->clk);
|
}
|
mutex_unlock(&gsunxi_dev->mlock);
|
TR_INFO_MSG("%s, count=%d\n", __func__, count);
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(sunxi_tr_release);
|
/*
|
* sunxi_tr_commit - commit an transform request
|
* @hdl: transform handle which return by sunxi_tr_request
|
* On success, returns 0. On failure, returns ERR_PTR(-errno).
|
*/
|
int sunxi_tr_commit(unsigned int id, tr_info *info)
|
{
|
int ret = 0;
|
struct sunxi_transform *tr = tr_get_by_id(id);
|
#ifdef USE_DMA_BUF
|
struct dmabuf_item *src_item = NULL;
|
struct dmabuf_item *dst_item = NULL;
|
|
src_item = kmalloc(sizeof(struct dmabuf_item),
|
GFP_KERNEL | __GFP_ZERO);
|
if (src_item == NULL) {
|
pr_err("malloc memory of size %ld fail!\n",
|
sizeof(struct dmabuf_item));
|
goto EXIT;
|
}
|
dst_item = kmalloc(sizeof(struct dmabuf_item),
|
GFP_KERNEL | __GFP_ZERO);
|
if (dst_item == NULL) {
|
pr_err("malloc memory of size %ld fail!\n",
|
sizeof(struct dmabuf_item));
|
goto FREE_SRC;
|
}
|
|
#endif
|
|
if (IS_ERR_OR_NULL(tr)) {
|
pr_warn("%s, hdl is invalid\n", __func__);
|
return -EINVAL;
|
}
|
|
TR_INFO_MSG("Input info:\n");
|
TR_INFO_MSG(" Format: 0x%x\n", info->src_frame.fmt);
|
TR_INFO_MSG(" Pitch: %d,%d,%d\n", info->src_frame.pitch[0],
|
info->src_frame.pitch[1], info->src_frame.pitch[2]);
|
TR_INFO_MSG(" RECT X:%d\n", info->src_rect.x);
|
TR_INFO_MSG(" RECT Y:%d\n", info->src_rect.y);
|
TR_INFO_MSG(" RECT W:%d\n", info->src_rect.w);
|
TR_INFO_MSG(" RECT H:%d\n", info->src_rect.h);
|
|
TR_INFO_MSG("Output info:\n");
|
TR_INFO_MSG(" Format: 0x%x\n", info->dst_frame.fmt);
|
TR_INFO_MSG(" Pitch: %d,%d,%d\n", info->dst_frame.pitch[0],
|
info->dst_frame.pitch[1], info->dst_frame.pitch[2]);
|
TR_INFO_MSG(" RECT X:%d\n", info->dst_rect.x);
|
TR_INFO_MSG(" RECT Y:%d\n", info->dst_rect.y);
|
TR_INFO_MSG(" RECT W:%d\n", info->dst_rect.w);
|
TR_INFO_MSG(" RECT H:%d\n", info->dst_rect.h);
|
|
if (!tr->requested && !tr->busy) {
|
memcpy(&tr->info, info, sizeof(tr_info));
|
tr->requested = true;
|
|
#ifdef USE_DMA_BUF
|
ret = tr_dma_map(tr->info.src_frame.fd, src_item);
|
if (ret != 0) {
|
pr_err("map src_item fail!\n");
|
goto FREE_DST;
|
}
|
ret = tr_dma_map(tr->info.dst_frame.fd, dst_item);
|
if (ret != 0) {
|
pr_err("map dst_item fail!\n");
|
goto SRC_DMA_UNMAP;
|
}
|
|
tr_set_info(&tr->info.src_frame, src_item);
|
tr_set_info(&tr->info.dst_frame, dst_item);
|
#endif
|
TR_INFO_MSG("InputAddr: 0x%x,0x%x,0x%x\n",
|
tr->info.src_frame.laddr[0],
|
tr->info.src_frame.laddr[1],
|
tr->info.src_frame.laddr[2]);
|
TR_INFO_MSG("OutputAddr: 0x%x,0x%x,0x%x\n",
|
tr->info.dst_frame.laddr[0],
|
tr->info.dst_frame.laddr[1],
|
tr->info.dst_frame.laddr[2]);
|
|
ret = tr_process_next_proper_task(1);
|
}
|
|
#if defined(TR_POLL)
|
{
|
int wait_cnt = 5, delay_ms = 10, i = 0;
|
|
while ((i < wait_cnt) && (de_tr_irq_query() != 0)) {
|
msleep(delay_ms);
|
i++;
|
}
|
if (wait_cnt >= 5)
|
pr_warn("%s, timeout !!!\n", __func__);
|
sunxi_tr_finish_procss();
|
}
|
#endif
|
#ifdef USE_DMA_BUF
|
tr_dma_unmap(dst_item);
|
SRC_DMA_UNMAP:
|
tr_dma_unmap(src_item);
|
FREE_DST:
|
kfree(dst_item);
|
FREE_SRC:
|
kfree(src_item);
|
EXIT:
|
return ret;
|
#else
|
return ret;
|
#endif
|
}
|
EXPORT_SYMBOL_GPL(sunxi_tr_commit);
|
/*
|
* sunxi_tr_query - query transform status
|
* @hdl: transform handle which return by sunxi_tr_request
|
* On finish, returns 0. On failure, returns ERR_PTR(-errno).
|
* On busy,returns 1.
|
*/
|
int sunxi_tr_query(unsigned int id)
|
{
|
int status = 0;
|
struct sunxi_transform *tr = tr_get_by_id(id);
|
|
if (IS_ERR_OR_NULL(tr)) {
|
pr_warn("%s, hdl is invalid!\n", __func__);
|
return 0;
|
}
|
#if !defined(TR_CHECK_THREAD)
|
tr_check_timeout();
|
#endif
|
|
if (tr->requested || tr->busy)
|
status = 1; /* busy */
|
else if (tr->error)
|
status = -1; /*error:timeout */
|
else
|
status = 0;/* finish */
|
|
return status;
|
|
#if 0
|
timeout = tr->start_time + msecs_to_jiffies(tr->timeout);
|
if (time_after_eq(jiffies, timeout)) {
|
pr_warn("%s, timeout(%d ms)\n", __func__,
|
jiffies_to_msecs(jiffies - tr->start_time));
|
de_tr_reset();
|
tr->busy = false;
|
return -1;
|
}
|
|
return tr->busy?1:0;
|
#endif
|
}
|
EXPORT_SYMBOL_GPL(sunxi_tr_query);
|
/*
|
* sunxi_tr_set_timeout - set transform timeout(ms)
|
* @hdl: transform hdl
|
* @timeout: time(ms)
|
* On success, returns 0. On failure, returns ERR_PTR(-errno).
|
*/
|
int sunxi_tr_set_timeout(unsigned int id, unsigned long timeout /* ms */)
|
{
|
struct sunxi_transform *tr = tr_get_by_id(id);
|
|
if (IS_ERR_OR_NULL(tr)) {
|
pr_warn("%s, hdl is invalid!\n", __func__);
|
return -EINVAL;
|
}
|
|
if (timeout == 0) {
|
pr_warn("%s, para error(timeout=0)!\n", __func__);
|
return -EINVAL;
|
}
|
tr->timeout = timeout;
|
|
return 0;
|
}
|
|
static irqreturn_t sunxi_tr_interrupt(int irq, void *dev_id)
|
{
|
int ret = 0;
|
|
/* get irq status */
|
ret = de_tr_irq_query();
|
if (ret == 0)
|
sunxi_tr_finish_procss();
|
/* clear irq status */
|
return IRQ_HANDLED;
|
}
|
|
static int tr_open(struct inode *inode, struct file *file)
|
{
|
return 0;
|
}
|
|
static int tr_release(struct inode *inode, struct file *file)
|
{
|
return 0;
|
}
|
static ssize_t tr_read(struct file *file, char __user *buf,
|
size_t count, loff_t *ppos)
|
{
|
return 0;
|
}
|
|
static ssize_t tr_write(struct file *file, const char __user *buf,
|
size_t count, loff_t *ppos)
|
{
|
return 0;
|
}
|
|
static u64 sunxi_tr_dma_mask = DMA_BIT_MASK(32);
|
/* static int __devinit tr_probe(struct platform_device *pdev) */
|
static int tr_probe(struct platform_device *pdev)
|
{
|
#if !defined(CONFIG_OF)
|
struct resource *res;
|
#endif
|
struct sunxi_trdev *sunxi_dev = NULL;
|
int ret = 0;
|
int irq;
|
|
pr_info("enter %s\n", __func__);
|
|
dmabuf_dev = &pdev->dev;
|
dmabuf_dev->dma_mask = &sunxi_tr_dma_mask;
|
dmabuf_dev->coherent_dma_mask = DMA_BIT_MASK(32);
|
sunxi_dev = kzalloc(sizeof(struct sunxi_trdev), GFP_KERNEL);
|
if (!sunxi_dev)
|
return -ENOMEM;
|
|
/* register base */
|
#if !defined(CONFIG_OF)
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
if (!res) {
|
dev_err(&pdev->dev, "get reource MEM fail\n");
|
ret = -EINVAL;
|
goto io_err;
|
}
|
sunxi_dev->base = (void __iomem *)res->start;
|
#else
|
sunxi_dev->base = of_iomap(pdev->dev.of_node, 0);
|
if (sunxi_dev->base == NULL) {
|
dev_err(&pdev->dev, "unable to map transform registers\n");
|
ret = -EINVAL;
|
goto io_err;
|
}
|
#endif
|
/* irq */
|
#if !defined(CONFIG_OF)
|
irq = platform_get_irq(pdev, 0);
|
if (irq < 0) {
|
ret = irq;
|
goto io_err;
|
}
|
#else
|
irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
|
if (!irq)
|
dev_err(&pdev->dev,
|
"irq_of_parse_and_map irq fail for transform\n");
|
#endif
|
sunxi_dev->irq = irq;
|
ret = request_irq(irq, sunxi_tr_interrupt, IRQF_SHARED,
|
dev_name(&pdev->dev), sunxi_dev);
|
if (ret) {
|
dev_err(&pdev->dev, "NO IRQ found!!!\n");
|
goto iomap_err;
|
}
|
|
/* clk init */
|
sunxi_dev->clk = of_clk_get(pdev->dev.of_node, 0);
|
if (IS_ERR(sunxi_dev->clk))
|
dev_err(&pdev->dev, "fail to get clk\n");
|
|
gsunxi_dev = sunxi_dev;
|
platform_set_drvdata(pdev, sunxi_dev);
|
INIT_LIST_HEAD(&sunxi_dev->trs);
|
spin_lock_init(&sunxi_dev->slock);
|
mutex_init(&sunxi_dev->mlock);
|
mutex_init(&id_lock);
|
idr_init(&sunxi_dev->idr);
|
sunxi_dev->dev = &pdev->dev;
|
sunxi_dev->handles = RB_ROOT;
|
dev_init = true;
|
|
ret = sysfs_create_group(&tr_dev->kobj, &tr_attribute_group);
|
if (ret < 0)
|
pr_err("sysfs_create_file fail!\n");
|
|
/* init hw */
|
de_tr_set_base((uintptr_t)sunxi_dev->base);
|
|
pr_info("exit %s\n", __func__);
|
return 0;
|
|
iomap_err:
|
iounmap(sunxi_dev->base);
|
io_err:
|
kfree(sunxi_dev);
|
|
return ret;
|
}
|
|
static int tr_remove(struct platform_device *pdev)
|
{
|
struct sunxi_trdev *sunxi_dev = NULL;
|
|
pr_info("tr_remove enter\n");
|
|
sunxi_dev = (struct sunxi_trdev *)platform_get_drvdata(pdev);
|
if (sunxi_dev && (sunxi_dev->count != 0)) {
|
struct sunxi_transform *tr = NULL, *tr_tmp = NULL;
|
unsigned long flags;
|
|
pr_warn("%s(), there are still %d t'users, force release them\n",
|
__func__, sunxi_dev->count);
|
spin_lock_irqsave(&sunxi_dev->slock, flags);
|
list_for_each_entry_safe(tr, tr_tmp, &sunxi_dev->trs, list) {
|
list_del(&tr->list);
|
sunxi_dev->count--;
|
kfree((void *)tr);
|
}
|
spin_unlock_irqrestore(&sunxi_dev->slock, flags);
|
if (sunxi_dev->clk)
|
clk_disable(sunxi_dev->clk);
|
}
|
if (sunxi_dev) {
|
dev_init = false;
|
free_irq(sunxi_dev->irq, sunxi_dev);
|
clk_put(sunxi_dev->clk);
|
#if defined(CONFIG_OF)
|
iounmap(sunxi_dev->base);
|
#endif
|
kfree(sunxi_dev);
|
platform_set_drvdata(pdev, NULL);
|
|
sysfs_remove_group(&tr_dev->kobj, &tr_attribute_group);
|
|
return 0;
|
}
|
|
return -1;
|
}
|
|
static int tr_suspend(struct platform_device *pdev, pm_message_t state)
|
{
|
pr_info("enter %s\n", __func__);
|
|
pr_info("exit %s\n", __func__);
|
|
return 0;
|
}
|
|
|
static int tr_resume(struct platform_device *pdev)
|
{
|
pr_info("%s\n", __func__);
|
|
if (gsunxi_dev->count != 0)
|
de_tr_init();
|
pr_info("exit %s\n", __func__);
|
|
return 0;
|
}
|
|
static void tr_shutdown(struct platform_device *pdev)
|
{
|
|
}
|
|
static long tr_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
{
|
unsigned long karg[4];
|
unsigned long ubuffer[4] = {0};
|
long ret = -1;
|
|
if (copy_from_user((void *)karg, (void __user *)arg,
|
4*sizeof(unsigned long))) {
|
pr_warn("copy_from_user fail\n");
|
return -EFAULT;
|
}
|
|
ubuffer[0] = *(unsigned long *)karg;
|
ubuffer[1] = (*(unsigned long *)(karg+1));
|
ubuffer[2] = (*(unsigned long *)(karg+2));
|
ubuffer[3] = (*(unsigned long *)(karg+3));
|
|
switch (cmd) {
|
case TR_REQUEST:
|
{
|
/* request a chan */
|
unsigned int id;
|
|
id = sunxi_tr_request();
|
TR_INFO_MSG("TR_REQUEST id:%d\n", id);
|
if (put_user(id, (unsigned int __user *)ubuffer[0])) {
|
pr_err("%s: put_user fail\n", __func__);
|
return -EFAULT;
|
}
|
|
if (id == 0)
|
ret = -EFAULT;
|
else
|
ret = 0;
|
break;
|
}
|
|
case TR_COMMIT:
|
{
|
tr_info info;
|
|
if (copy_from_user(&info, (void __user *)ubuffer[1],
|
sizeof(tr_info))) {
|
pr_warn("%s, copy_from_user fail\n", __func__);
|
return -EFAULT;
|
}
|
ret = sunxi_tr_commit(ubuffer[0], &info);
|
|
break;
|
}
|
|
case TR_RELEASE:
|
{
|
/* release a chan */
|
ret = sunxi_tr_release(ubuffer[0]);
|
break;
|
}
|
|
case TR_QUERY:
|
{
|
/* query status */
|
ret = sunxi_tr_query(ubuffer[0]);
|
break;
|
}
|
|
case TR_SET_TIMEOUT:
|
{
|
/* set timeout */
|
ret = sunxi_tr_set_timeout(ubuffer[0], ubuffer[1]);
|
break;
|
}
|
|
default:
|
break;
|
}
|
|
return ret;
|
}
|
|
#ifdef CONFIG_COMPAT
|
static long tr_compat_ioctl32(struct file *file, unsigned int cmd,
|
unsigned long arg)
|
{
|
compat_uptr_t karg[4];
|
unsigned long __user *ubuffer;
|
int ret = 0;
|
|
if (copy_from_user((void *)karg, (void __user *)arg,
|
4 * sizeof(compat_uptr_t))) {
|
pr_err("copy_from_user fail\n");
|
return -EFAULT;
|
}
|
|
ubuffer = compat_alloc_user_space(4 * sizeof(unsigned long));
|
if (!access_ok(VERIFY_WRITE, ubuffer, 4 * sizeof(unsigned long)))
|
return -EFAULT;
|
|
if (put_user(karg[0], &ubuffer[0])
|
|| put_user(karg[1], &ubuffer[1])
|
|| put_user(karg[2], &ubuffer[2])
|
|| put_user(karg[3], &ubuffer[3])) {
|
pr_err("put_user fail\n");
|
return -EFAULT;
|
}
|
|
switch (cmd) {
|
case TR_REQUEST:
|
{
|
/* request a chan */
|
compat_uint_t id = 0;
|
|
id = sunxi_tr_request();
|
|
if (put_user(id, (compat_uint_t __user *)ubuffer[0])) {
|
pr_err("%s, put tr user failed.", __func__);
|
ret = -EFAULT;
|
} else {
|
ret = 0;
|
}
|
|
break;
|
}
|
|
case TR_COMMIT:
|
{
|
tr_info info;
|
compat_uint_t id = karg[0];
|
|
ret = copy_from_user(&info, (void __user *)ubuffer[1],
|
sizeof(tr_info));
|
if (ret) {
|
pr_warn("%s, tr copy_from_user fail\n", __func__);
|
return -EFAULT;
|
}
|
|
ret = sunxi_tr_commit(id, &info);
|
|
break;
|
}
|
|
case TR_RELEASE:
|
{
|
/* release a chan */
|
compat_uint_t id = karg[0];
|
|
ret = sunxi_tr_release(id);
|
break;
|
}
|
|
case TR_QUERY:
|
{
|
/* query status */
|
compat_uint_t id = karg[0];
|
|
ret = sunxi_tr_query((unsigned long)id);
|
break;
|
}
|
|
case TR_SET_TIMEOUT:
|
{
|
/* set timeout */
|
compat_uint_t id = karg[0];
|
compat_uptr_t timeout = karg[1];
|
|
ret = sunxi_tr_set_timeout(id, (unsigned long)timeout);
|
break;
|
}
|
|
default:
|
break;
|
}
|
|
return ret;
|
}
|
#endif
|
|
static const struct file_operations tr_fops = {
|
.owner = THIS_MODULE,
|
.open = tr_open,
|
.release = tr_release,
|
.write = tr_write,
|
.read = tr_read,
|
.unlocked_ioctl = tr_ioctl,
|
|
#ifdef CONFIG_COMPAT
|
.compat_ioctl = tr_compat_ioctl32,
|
#endif
|
};
|
|
#if !defined(CONFIG_OF)
|
static struct platform_device tr_device = {
|
.name = "transform",
|
.id = -1,
|
.num_resources = ARRAY_SIZE(tr_resource),
|
.resource = tr_resource,
|
.dev = {
|
|
},
|
};
|
#else
|
static const struct of_device_id sunxi_tr_match[] = {
|
{ .compatible = "allwinner,sun50i-tr", },
|
{ .compatible = "allwinner,sun8iw11-tr", },
|
{},
|
};
|
#endif
|
|
static struct platform_driver tr_driver = {
|
.probe = tr_probe,
|
.remove = tr_remove,
|
.suspend = tr_suspend,
|
.resume = tr_resume,
|
.shutdown = tr_shutdown,
|
.driver = {
|
|
.name = "transform",
|
.owner = THIS_MODULE,
|
.of_match_table = sunxi_tr_match,
|
},
|
};
|
|
static int __init tr_module_init(void)
|
{
|
int ret = 0, err;
|
|
alloc_chrdev_region(&devid, 0, 1, "transform");
|
tr_cdev = cdev_alloc();
|
cdev_init(tr_cdev, &tr_fops);
|
tr_cdev->owner = THIS_MODULE;
|
err = cdev_add(tr_cdev, devid, 1);
|
if (err) {
|
pr_warn("cdev_add fail\n");
|
return -1;
|
}
|
|
tr_class = class_create(THIS_MODULE, "transform");
|
if (IS_ERR(tr_class)) {
|
pr_warn("class_create fail\n");
|
return -1;
|
}
|
|
tr_dev = device_create(tr_class, NULL, devid, NULL, "transform");
|
#if !defined(CONFIG_OF)
|
ret = platform_device_register(&tr_device);
|
#endif
|
|
if (ret == 0)
|
ret = platform_driver_register(&tr_driver);
|
|
return ret;
|
}
|
|
static void __exit tr_module_exit(void)
|
{
|
platform_driver_unregister(&tr_driver);
|
#if !defined(CONFIG_OF)
|
platform_device_unregister(&tr_device);
|
#endif
|
device_destroy(tr_class, devid);
|
class_destroy(tr_class);
|
|
cdev_del(tr_cdev);
|
}
|
|
module_init(tr_module_init);
|
module_exit(tr_module_exit);
|
|
MODULE_AUTHOR("tyle");
|
MODULE_DESCRIPTION("transform driver");
|
MODULE_LICENSE("GPL");
|
MODULE_ALIAS("platform:transform");
|
