mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
941 lines
25 KiB
941 lines
25 KiB
/* |
|
* Copyright (C) 2017 Samsung Electronics Co.Ltd |
|
* Authors: |
|
* Marek Szyprowski <[email protected]> |
|
* |
|
* Exynos DRM Image Post Processing (IPP) related functions |
|
* |
|
* Permission is hereby granted, free of charge, to any person obtaining a |
|
* copy of this software and associated documentation files (the "Software"), |
|
* to deal in the Software without restriction, including without limitation |
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|
* and/or sell copies of the Software, and to permit persons to whom the |
|
* Software is furnished to do so, subject to the following conditions: |
|
* |
|
* The above copyright notice and this permission notice shall be included in |
|
* all copies or substantial portions of the Software. |
|
*/ |
|
|
|
#include <linux/uaccess.h> |
|
|
|
#include <drm/drm_file.h> |
|
#include <drm/drm_fourcc.h> |
|
#include <drm/drm_mode.h> |
|
#include <drm/exynos_drm.h> |
|
|
|
#include "exynos_drm_drv.h" |
|
#include "exynos_drm_gem.h" |
|
#include "exynos_drm_ipp.h" |
|
|
|
static int num_ipp; |
|
static LIST_HEAD(ipp_list); |
|
|
|
/** |
|
* exynos_drm_ipp_register - Register a new picture processor hardware module |
|
* @dev: DRM device |
|
* @ipp: ipp module to init |
|
* @funcs: callbacks for the new ipp object |
|
* @caps: bitmask of ipp capabilities (%DRM_EXYNOS_IPP_CAP_*) |
|
* @formats: array of supported formats |
|
* @num_formats: size of the supported formats array |
|
* @name: name (for debugging purposes) |
|
* |
|
* Initializes a ipp module. |
|
* |
|
* Returns: |
|
* Zero on success, error code on failure. |
|
*/ |
|
int exynos_drm_ipp_register(struct device *dev, struct exynos_drm_ipp *ipp, |
|
const struct exynos_drm_ipp_funcs *funcs, unsigned int caps, |
|
const struct exynos_drm_ipp_formats *formats, |
|
unsigned int num_formats, const char *name) |
|
{ |
|
WARN_ON(!ipp); |
|
WARN_ON(!funcs); |
|
WARN_ON(!formats); |
|
WARN_ON(!num_formats); |
|
|
|
spin_lock_init(&ipp->lock); |
|
INIT_LIST_HEAD(&ipp->todo_list); |
|
init_waitqueue_head(&ipp->done_wq); |
|
ipp->dev = dev; |
|
ipp->funcs = funcs; |
|
ipp->capabilities = caps; |
|
ipp->name = name; |
|
ipp->formats = formats; |
|
ipp->num_formats = num_formats; |
|
|
|
/* ipp_list modification is serialized by component framework */ |
|
list_add_tail(&ipp->head, &ipp_list); |
|
ipp->id = num_ipp++; |
|
|
|
DRM_DEV_DEBUG_DRIVER(dev, "Registered ipp %d\n", ipp->id); |
|
|
|
return 0; |
|
} |
|
|
|
/** |
|
* exynos_drm_ipp_unregister - Unregister the picture processor module |
|
* @dev: DRM device |
|
* @ipp: ipp module |
|
*/ |
|
void exynos_drm_ipp_unregister(struct device *dev, |
|
struct exynos_drm_ipp *ipp) |
|
{ |
|
WARN_ON(ipp->task); |
|
WARN_ON(!list_empty(&ipp->todo_list)); |
|
list_del(&ipp->head); |
|
} |
|
|
|
/** |
|
* exynos_drm_ipp_get_res_ioctl - enumerate all ipp modules |
|
* @dev: DRM device |
|
* @data: ioctl data |
|
* @file_priv: DRM file info |
|
* |
|
* Construct a list of ipp ids. |
|
* |
|
* Called by the user via ioctl. |
|
* |
|
* Returns: |
|
* Zero on success, negative errno on failure. |
|
*/ |
|
int exynos_drm_ipp_get_res_ioctl(struct drm_device *dev, void *data, |
|
struct drm_file *file_priv) |
|
{ |
|
struct drm_exynos_ioctl_ipp_get_res *resp = data; |
|
struct exynos_drm_ipp *ipp; |
|
uint32_t __user *ipp_ptr = (uint32_t __user *) |
|
(unsigned long)resp->ipp_id_ptr; |
|
unsigned int count = num_ipp, copied = 0; |
|
|
|
/* |
|
* This ioctl is called twice, once to determine how much space is |
|
* needed, and the 2nd time to fill it. |
|
*/ |
|
if (count && resp->count_ipps >= count) { |
|
list_for_each_entry(ipp, &ipp_list, head) { |
|
if (put_user(ipp->id, ipp_ptr + copied)) |
|
return -EFAULT; |
|
copied++; |
|
} |
|
} |
|
resp->count_ipps = count; |
|
|
|
return 0; |
|
} |
|
|
|
static inline struct exynos_drm_ipp *__ipp_get(uint32_t id) |
|
{ |
|
struct exynos_drm_ipp *ipp; |
|
|
|
list_for_each_entry(ipp, &ipp_list, head) |
|
if (ipp->id == id) |
|
return ipp; |
|
return NULL; |
|
} |
|
|
|
/** |
|
* exynos_drm_ipp_get_caps_ioctl - get ipp module capabilities and formats |
|
* @dev: DRM device |
|
* @data: ioctl data |
|
* @file_priv: DRM file info |
|
* |
|
* Construct a structure describing ipp module capabilities. |
|
* |
|
* Called by the user via ioctl. |
|
* |
|
* Returns: |
|
* Zero on success, negative errno on failure. |
|
*/ |
|
int exynos_drm_ipp_get_caps_ioctl(struct drm_device *dev, void *data, |
|
struct drm_file *file_priv) |
|
{ |
|
struct drm_exynos_ioctl_ipp_get_caps *resp = data; |
|
void __user *ptr = (void __user *)(unsigned long)resp->formats_ptr; |
|
struct exynos_drm_ipp *ipp; |
|
int i; |
|
|
|
ipp = __ipp_get(resp->ipp_id); |
|
if (!ipp) |
|
return -ENOENT; |
|
|
|
resp->ipp_id = ipp->id; |
|
resp->capabilities = ipp->capabilities; |
|
|
|
/* |
|
* This ioctl is called twice, once to determine how much space is |
|
* needed, and the 2nd time to fill it. |
|
*/ |
|
if (resp->formats_count >= ipp->num_formats) { |
|
for (i = 0; i < ipp->num_formats; i++) { |
|
struct drm_exynos_ipp_format tmp = { |
|
.fourcc = ipp->formats[i].fourcc, |
|
.type = ipp->formats[i].type, |
|
.modifier = ipp->formats[i].modifier, |
|
}; |
|
|
|
if (copy_to_user(ptr, &tmp, sizeof(tmp))) |
|
return -EFAULT; |
|
ptr += sizeof(tmp); |
|
} |
|
} |
|
resp->formats_count = ipp->num_formats; |
|
|
|
return 0; |
|
} |
|
|
|
static inline const struct exynos_drm_ipp_formats *__ipp_format_get( |
|
struct exynos_drm_ipp *ipp, uint32_t fourcc, |
|
uint64_t mod, unsigned int type) |
|
{ |
|
int i; |
|
|
|
for (i = 0; i < ipp->num_formats; i++) { |
|
if ((ipp->formats[i].type & type) && |
|
ipp->formats[i].fourcc == fourcc && |
|
ipp->formats[i].modifier == mod) |
|
return &ipp->formats[i]; |
|
} |
|
return NULL; |
|
} |
|
|
|
/** |
|
* exynos_drm_ipp_get_limits_ioctl - get ipp module limits |
|
* @dev: DRM device |
|
* @data: ioctl data |
|
* @file_priv: DRM file info |
|
* |
|
* Construct a structure describing ipp module limitations for provided |
|
* picture format. |
|
* |
|
* Called by the user via ioctl. |
|
* |
|
* Returns: |
|
* Zero on success, negative errno on failure. |
|
*/ |
|
int exynos_drm_ipp_get_limits_ioctl(struct drm_device *dev, void *data, |
|
struct drm_file *file_priv) |
|
{ |
|
struct drm_exynos_ioctl_ipp_get_limits *resp = data; |
|
void __user *ptr = (void __user *)(unsigned long)resp->limits_ptr; |
|
const struct exynos_drm_ipp_formats *format; |
|
struct exynos_drm_ipp *ipp; |
|
|
|
if (resp->type != DRM_EXYNOS_IPP_FORMAT_SOURCE && |
|
resp->type != DRM_EXYNOS_IPP_FORMAT_DESTINATION) |
|
return -EINVAL; |
|
|
|
ipp = __ipp_get(resp->ipp_id); |
|
if (!ipp) |
|
return -ENOENT; |
|
|
|
format = __ipp_format_get(ipp, resp->fourcc, resp->modifier, |
|
resp->type); |
|
if (!format) |
|
return -EINVAL; |
|
|
|
/* |
|
* This ioctl is called twice, once to determine how much space is |
|
* needed, and the 2nd time to fill it. |
|
*/ |
|
if (format->num_limits && resp->limits_count >= format->num_limits) |
|
if (copy_to_user((void __user *)ptr, format->limits, |
|
sizeof(*format->limits) * format->num_limits)) |
|
return -EFAULT; |
|
resp->limits_count = format->num_limits; |
|
|
|
return 0; |
|
} |
|
|
|
struct drm_pending_exynos_ipp_event { |
|
struct drm_pending_event base; |
|
struct drm_exynos_ipp_event event; |
|
}; |
|
|
|
static inline struct exynos_drm_ipp_task * |
|
exynos_drm_ipp_task_alloc(struct exynos_drm_ipp *ipp) |
|
{ |
|
struct exynos_drm_ipp_task *task; |
|
|
|
task = kzalloc(sizeof(*task), GFP_KERNEL); |
|
if (!task) |
|
return NULL; |
|
|
|
task->dev = ipp->dev; |
|
task->ipp = ipp; |
|
|
|
/* some defaults */ |
|
task->src.rect.w = task->dst.rect.w = UINT_MAX; |
|
task->src.rect.h = task->dst.rect.h = UINT_MAX; |
|
task->transform.rotation = DRM_MODE_ROTATE_0; |
|
|
|
DRM_DEV_DEBUG_DRIVER(task->dev, "Allocated task %pK\n", task); |
|
|
|
return task; |
|
} |
|
|
|
static const struct exynos_drm_param_map { |
|
unsigned int id; |
|
unsigned int size; |
|
unsigned int offset; |
|
} exynos_drm_ipp_params_maps[] = { |
|
{ |
|
DRM_EXYNOS_IPP_TASK_BUFFER | DRM_EXYNOS_IPP_TASK_TYPE_SOURCE, |
|
sizeof(struct drm_exynos_ipp_task_buffer), |
|
offsetof(struct exynos_drm_ipp_task, src.buf), |
|
}, { |
|
DRM_EXYNOS_IPP_TASK_BUFFER | |
|
DRM_EXYNOS_IPP_TASK_TYPE_DESTINATION, |
|
sizeof(struct drm_exynos_ipp_task_buffer), |
|
offsetof(struct exynos_drm_ipp_task, dst.buf), |
|
}, { |
|
DRM_EXYNOS_IPP_TASK_RECTANGLE | DRM_EXYNOS_IPP_TASK_TYPE_SOURCE, |
|
sizeof(struct drm_exynos_ipp_task_rect), |
|
offsetof(struct exynos_drm_ipp_task, src.rect), |
|
}, { |
|
DRM_EXYNOS_IPP_TASK_RECTANGLE | |
|
DRM_EXYNOS_IPP_TASK_TYPE_DESTINATION, |
|
sizeof(struct drm_exynos_ipp_task_rect), |
|
offsetof(struct exynos_drm_ipp_task, dst.rect), |
|
}, { |
|
DRM_EXYNOS_IPP_TASK_TRANSFORM, |
|
sizeof(struct drm_exynos_ipp_task_transform), |
|
offsetof(struct exynos_drm_ipp_task, transform), |
|
}, { |
|
DRM_EXYNOS_IPP_TASK_ALPHA, |
|
sizeof(struct drm_exynos_ipp_task_alpha), |
|
offsetof(struct exynos_drm_ipp_task, alpha), |
|
}, |
|
}; |
|
|
|
static int exynos_drm_ipp_task_set(struct exynos_drm_ipp_task *task, |
|
struct drm_exynos_ioctl_ipp_commit *arg) |
|
{ |
|
const struct exynos_drm_param_map *map = exynos_drm_ipp_params_maps; |
|
void __user *params = (void __user *)(unsigned long)arg->params_ptr; |
|
unsigned int size = arg->params_size; |
|
uint32_t id; |
|
int i; |
|
|
|
while (size) { |
|
if (get_user(id, (uint32_t __user *)params)) |
|
return -EFAULT; |
|
|
|
for (i = 0; i < ARRAY_SIZE(exynos_drm_ipp_params_maps); i++) |
|
if (map[i].id == id) |
|
break; |
|
if (i == ARRAY_SIZE(exynos_drm_ipp_params_maps) || |
|
map[i].size > size) |
|
return -EINVAL; |
|
|
|
if (copy_from_user((void *)task + map[i].offset, params, |
|
map[i].size)) |
|
return -EFAULT; |
|
|
|
params += map[i].size; |
|
size -= map[i].size; |
|
} |
|
|
|
DRM_DEV_DEBUG_DRIVER(task->dev, |
|
"Got task %pK configuration from userspace\n", |
|
task); |
|
return 0; |
|
} |
|
|
|
static int exynos_drm_ipp_task_setup_buffer(struct exynos_drm_ipp_buffer *buf, |
|
struct drm_file *filp) |
|
{ |
|
int ret = 0; |
|
int i; |
|
|
|
/* get GEM buffers and check their size */ |
|
for (i = 0; i < buf->format->num_planes; i++) { |
|
unsigned int height = (i == 0) ? buf->buf.height : |
|
DIV_ROUND_UP(buf->buf.height, buf->format->vsub); |
|
unsigned long size = height * buf->buf.pitch[i]; |
|
struct exynos_drm_gem *gem = exynos_drm_gem_get(filp, |
|
buf->buf.gem_id[i]); |
|
if (!gem) { |
|
ret = -ENOENT; |
|
goto gem_free; |
|
} |
|
buf->exynos_gem[i] = gem; |
|
|
|
if (size + buf->buf.offset[i] > buf->exynos_gem[i]->size) { |
|
i++; |
|
ret = -EINVAL; |
|
goto gem_free; |
|
} |
|
buf->dma_addr[i] = buf->exynos_gem[i]->dma_addr + |
|
buf->buf.offset[i]; |
|
} |
|
|
|
return 0; |
|
gem_free: |
|
while (i--) { |
|
exynos_drm_gem_put(buf->exynos_gem[i]); |
|
buf->exynos_gem[i] = NULL; |
|
} |
|
return ret; |
|
} |
|
|
|
static void exynos_drm_ipp_task_release_buf(struct exynos_drm_ipp_buffer *buf) |
|
{ |
|
int i; |
|
|
|
if (!buf->exynos_gem[0]) |
|
return; |
|
for (i = 0; i < buf->format->num_planes; i++) |
|
exynos_drm_gem_put(buf->exynos_gem[i]); |
|
} |
|
|
|
static void exynos_drm_ipp_task_free(struct exynos_drm_ipp *ipp, |
|
struct exynos_drm_ipp_task *task) |
|
{ |
|
DRM_DEV_DEBUG_DRIVER(task->dev, "Freeing task %pK\n", task); |
|
|
|
exynos_drm_ipp_task_release_buf(&task->src); |
|
exynos_drm_ipp_task_release_buf(&task->dst); |
|
if (task->event) |
|
drm_event_cancel_free(ipp->drm_dev, &task->event->base); |
|
kfree(task); |
|
} |
|
|
|
struct drm_ipp_limit { |
|
struct drm_exynos_ipp_limit_val h; |
|
struct drm_exynos_ipp_limit_val v; |
|
}; |
|
|
|
enum drm_ipp_size_id { |
|
IPP_LIMIT_BUFFER, IPP_LIMIT_AREA, IPP_LIMIT_ROTATED, IPP_LIMIT_MAX |
|
}; |
|
|
|
static const enum drm_exynos_ipp_limit_type limit_id_fallback[IPP_LIMIT_MAX][4] = { |
|
[IPP_LIMIT_BUFFER] = { DRM_EXYNOS_IPP_LIMIT_SIZE_BUFFER }, |
|
[IPP_LIMIT_AREA] = { DRM_EXYNOS_IPP_LIMIT_SIZE_AREA, |
|
DRM_EXYNOS_IPP_LIMIT_SIZE_BUFFER }, |
|
[IPP_LIMIT_ROTATED] = { DRM_EXYNOS_IPP_LIMIT_SIZE_ROTATED, |
|
DRM_EXYNOS_IPP_LIMIT_SIZE_AREA, |
|
DRM_EXYNOS_IPP_LIMIT_SIZE_BUFFER }, |
|
}; |
|
|
|
static inline void __limit_set_val(unsigned int *ptr, unsigned int val) |
|
{ |
|
if (!*ptr) |
|
*ptr = val; |
|
} |
|
|
|
static void __get_size_limit(const struct drm_exynos_ipp_limit *limits, |
|
unsigned int num_limits, enum drm_ipp_size_id id, |
|
struct drm_ipp_limit *res) |
|
{ |
|
const struct drm_exynos_ipp_limit *l = limits; |
|
int i = 0; |
|
|
|
memset(res, 0, sizeof(*res)); |
|
for (i = 0; limit_id_fallback[id][i]; i++) |
|
for (l = limits; l - limits < num_limits; l++) { |
|
if (((l->type & DRM_EXYNOS_IPP_LIMIT_TYPE_MASK) != |
|
DRM_EXYNOS_IPP_LIMIT_TYPE_SIZE) || |
|
((l->type & DRM_EXYNOS_IPP_LIMIT_SIZE_MASK) != |
|
limit_id_fallback[id][i])) |
|
continue; |
|
__limit_set_val(&res->h.min, l->h.min); |
|
__limit_set_val(&res->h.max, l->h.max); |
|
__limit_set_val(&res->h.align, l->h.align); |
|
__limit_set_val(&res->v.min, l->v.min); |
|
__limit_set_val(&res->v.max, l->v.max); |
|
__limit_set_val(&res->v.align, l->v.align); |
|
} |
|
} |
|
|
|
static inline bool __align_check(unsigned int val, unsigned int align) |
|
{ |
|
if (align && (val & (align - 1))) { |
|
DRM_DEBUG_DRIVER("Value %d exceeds HW limits (align %d)\n", |
|
val, align); |
|
return false; |
|
} |
|
return true; |
|
} |
|
|
|
static inline bool __size_limit_check(unsigned int val, |
|
struct drm_exynos_ipp_limit_val *l) |
|
{ |
|
if ((l->min && val < l->min) || (l->max && val > l->max)) { |
|
DRM_DEBUG_DRIVER("Value %d exceeds HW limits (min %d, max %d)\n", |
|
val, l->min, l->max); |
|
return false; |
|
} |
|
return __align_check(val, l->align); |
|
} |
|
|
|
static int exynos_drm_ipp_check_size_limits(struct exynos_drm_ipp_buffer *buf, |
|
const struct drm_exynos_ipp_limit *limits, unsigned int num_limits, |
|
bool rotate, bool swap) |
|
{ |
|
enum drm_ipp_size_id id = rotate ? IPP_LIMIT_ROTATED : IPP_LIMIT_AREA; |
|
struct drm_ipp_limit l; |
|
struct drm_exynos_ipp_limit_val *lh = &l.h, *lv = &l.v; |
|
int real_width = buf->buf.pitch[0] / buf->format->cpp[0]; |
|
|
|
if (!limits) |
|
return 0; |
|
|
|
__get_size_limit(limits, num_limits, IPP_LIMIT_BUFFER, &l); |
|
if (!__size_limit_check(real_width, &l.h) || |
|
!__size_limit_check(buf->buf.height, &l.v)) |
|
return -EINVAL; |
|
|
|
if (swap) { |
|
lv = &l.h; |
|
lh = &l.v; |
|
} |
|
__get_size_limit(limits, num_limits, id, &l); |
|
if (!__size_limit_check(buf->rect.w, lh) || |
|
!__align_check(buf->rect.x, lh->align) || |
|
!__size_limit_check(buf->rect.h, lv) || |
|
!__align_check(buf->rect.y, lv->align)) |
|
return -EINVAL; |
|
|
|
return 0; |
|
} |
|
|
|
static inline bool __scale_limit_check(unsigned int src, unsigned int dst, |
|
unsigned int min, unsigned int max) |
|
{ |
|
if ((max && (dst << 16) > src * max) || |
|
(min && (dst << 16) < src * min)) { |
|
DRM_DEBUG_DRIVER("Scale from %d to %d exceeds HW limits (ratio min %d.%05d, max %d.%05d)\n", |
|
src, dst, |
|
min >> 16, 100000 * (min & 0xffff) / (1 << 16), |
|
max >> 16, 100000 * (max & 0xffff) / (1 << 16)); |
|
return false; |
|
} |
|
return true; |
|
} |
|
|
|
static int exynos_drm_ipp_check_scale_limits( |
|
struct drm_exynos_ipp_task_rect *src, |
|
struct drm_exynos_ipp_task_rect *dst, |
|
const struct drm_exynos_ipp_limit *limits, |
|
unsigned int num_limits, bool swap) |
|
{ |
|
const struct drm_exynos_ipp_limit_val *lh, *lv; |
|
int dw, dh; |
|
|
|
for (; num_limits; limits++, num_limits--) |
|
if ((limits->type & DRM_EXYNOS_IPP_LIMIT_TYPE_MASK) == |
|
DRM_EXYNOS_IPP_LIMIT_TYPE_SCALE) |
|
break; |
|
if (!num_limits) |
|
return 0; |
|
|
|
lh = (!swap) ? &limits->h : &limits->v; |
|
lv = (!swap) ? &limits->v : &limits->h; |
|
dw = (!swap) ? dst->w : dst->h; |
|
dh = (!swap) ? dst->h : dst->w; |
|
|
|
if (!__scale_limit_check(src->w, dw, lh->min, lh->max) || |
|
!__scale_limit_check(src->h, dh, lv->min, lv->max)) |
|
return -EINVAL; |
|
|
|
return 0; |
|
} |
|
|
|
static int exynos_drm_ipp_check_format(struct exynos_drm_ipp_task *task, |
|
struct exynos_drm_ipp_buffer *buf, |
|
struct exynos_drm_ipp_buffer *src, |
|
struct exynos_drm_ipp_buffer *dst, |
|
bool rotate, bool swap) |
|
{ |
|
const struct exynos_drm_ipp_formats *fmt; |
|
int ret, i; |
|
|
|
fmt = __ipp_format_get(task->ipp, buf->buf.fourcc, buf->buf.modifier, |
|
buf == src ? DRM_EXYNOS_IPP_FORMAT_SOURCE : |
|
DRM_EXYNOS_IPP_FORMAT_DESTINATION); |
|
if (!fmt) { |
|
DRM_DEV_DEBUG_DRIVER(task->dev, |
|
"Task %pK: %s format not supported\n", |
|
task, buf == src ? "src" : "dst"); |
|
return -EINVAL; |
|
} |
|
|
|
/* basic checks */ |
|
if (buf->buf.width == 0 || buf->buf.height == 0) |
|
return -EINVAL; |
|
|
|
buf->format = drm_format_info(buf->buf.fourcc); |
|
for (i = 0; i < buf->format->num_planes; i++) { |
|
unsigned int width = (i == 0) ? buf->buf.width : |
|
DIV_ROUND_UP(buf->buf.width, buf->format->hsub); |
|
|
|
if (buf->buf.pitch[i] == 0) |
|
buf->buf.pitch[i] = width * buf->format->cpp[i]; |
|
if (buf->buf.pitch[i] < width * buf->format->cpp[i]) |
|
return -EINVAL; |
|
if (!buf->buf.gem_id[i]) |
|
return -ENOENT; |
|
} |
|
|
|
/* pitch for additional planes must match */ |
|
if (buf->format->num_planes > 2 && |
|
buf->buf.pitch[1] != buf->buf.pitch[2]) |
|
return -EINVAL; |
|
|
|
/* check driver limits */ |
|
ret = exynos_drm_ipp_check_size_limits(buf, fmt->limits, |
|
fmt->num_limits, |
|
rotate, |
|
buf == dst ? swap : false); |
|
if (ret) |
|
return ret; |
|
ret = exynos_drm_ipp_check_scale_limits(&src->rect, &dst->rect, |
|
fmt->limits, |
|
fmt->num_limits, swap); |
|
return ret; |
|
} |
|
|
|
static int exynos_drm_ipp_task_check(struct exynos_drm_ipp_task *task) |
|
{ |
|
struct exynos_drm_ipp *ipp = task->ipp; |
|
struct exynos_drm_ipp_buffer *src = &task->src, *dst = &task->dst; |
|
unsigned int rotation = task->transform.rotation; |
|
int ret = 0; |
|
bool swap = drm_rotation_90_or_270(rotation); |
|
bool rotate = (rotation != DRM_MODE_ROTATE_0); |
|
bool scale = false; |
|
|
|
DRM_DEV_DEBUG_DRIVER(task->dev, "Checking task %pK\n", task); |
|
|
|
if (src->rect.w == UINT_MAX) |
|
src->rect.w = src->buf.width; |
|
if (src->rect.h == UINT_MAX) |
|
src->rect.h = src->buf.height; |
|
if (dst->rect.w == UINT_MAX) |
|
dst->rect.w = dst->buf.width; |
|
if (dst->rect.h == UINT_MAX) |
|
dst->rect.h = dst->buf.height; |
|
|
|
if (src->rect.x + src->rect.w > (src->buf.width) || |
|
src->rect.y + src->rect.h > (src->buf.height) || |
|
dst->rect.x + dst->rect.w > (dst->buf.width) || |
|
dst->rect.y + dst->rect.h > (dst->buf.height)) { |
|
DRM_DEV_DEBUG_DRIVER(task->dev, |
|
"Task %pK: defined area is outside provided buffers\n", |
|
task); |
|
return -EINVAL; |
|
} |
|
|
|
if ((!swap && (src->rect.w != dst->rect.w || |
|
src->rect.h != dst->rect.h)) || |
|
(swap && (src->rect.w != dst->rect.h || |
|
src->rect.h != dst->rect.w))) |
|
scale = true; |
|
|
|
if ((!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_CROP) && |
|
(src->rect.x || src->rect.y || dst->rect.x || dst->rect.y)) || |
|
(!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_ROTATE) && rotate) || |
|
(!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_SCALE) && scale) || |
|
(!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_CONVERT) && |
|
src->buf.fourcc != dst->buf.fourcc)) { |
|
DRM_DEV_DEBUG_DRIVER(task->dev, "Task %pK: hw capabilities exceeded\n", |
|
task); |
|
return -EINVAL; |
|
} |
|
|
|
ret = exynos_drm_ipp_check_format(task, src, src, dst, rotate, swap); |
|
if (ret) |
|
return ret; |
|
|
|
ret = exynos_drm_ipp_check_format(task, dst, src, dst, false, swap); |
|
if (ret) |
|
return ret; |
|
|
|
DRM_DEV_DEBUG_DRIVER(ipp->dev, "Task %pK: all checks done.\n", |
|
task); |
|
|
|
return ret; |
|
} |
|
|
|
static int exynos_drm_ipp_task_setup_buffers(struct exynos_drm_ipp_task *task, |
|
struct drm_file *filp) |
|
{ |
|
struct exynos_drm_ipp_buffer *src = &task->src, *dst = &task->dst; |
|
int ret = 0; |
|
|
|
DRM_DEV_DEBUG_DRIVER(task->dev, "Setting buffer for task %pK\n", |
|
task); |
|
|
|
ret = exynos_drm_ipp_task_setup_buffer(src, filp); |
|
if (ret) { |
|
DRM_DEV_DEBUG_DRIVER(task->dev, |
|
"Task %pK: src buffer setup failed\n", |
|
task); |
|
return ret; |
|
} |
|
ret = exynos_drm_ipp_task_setup_buffer(dst, filp); |
|
if (ret) { |
|
DRM_DEV_DEBUG_DRIVER(task->dev, |
|
"Task %pK: dst buffer setup failed\n", |
|
task); |
|
return ret; |
|
} |
|
|
|
DRM_DEV_DEBUG_DRIVER(task->dev, "Task %pK: buffers prepared.\n", |
|
task); |
|
|
|
return ret; |
|
} |
|
|
|
|
|
static int exynos_drm_ipp_event_create(struct exynos_drm_ipp_task *task, |
|
struct drm_file *file_priv, uint64_t user_data) |
|
{ |
|
struct drm_pending_exynos_ipp_event *e = NULL; |
|
int ret; |
|
|
|
e = kzalloc(sizeof(*e), GFP_KERNEL); |
|
if (!e) |
|
return -ENOMEM; |
|
|
|
e->event.base.type = DRM_EXYNOS_IPP_EVENT; |
|
e->event.base.length = sizeof(e->event); |
|
e->event.user_data = user_data; |
|
|
|
ret = drm_event_reserve_init(task->ipp->drm_dev, file_priv, &e->base, |
|
&e->event.base); |
|
if (ret) |
|
goto free; |
|
|
|
task->event = e; |
|
return 0; |
|
free: |
|
kfree(e); |
|
return ret; |
|
} |
|
|
|
static void exynos_drm_ipp_event_send(struct exynos_drm_ipp_task *task) |
|
{ |
|
struct timespec64 now; |
|
|
|
ktime_get_ts64(&now); |
|
task->event->event.tv_sec = now.tv_sec; |
|
task->event->event.tv_usec = now.tv_nsec / NSEC_PER_USEC; |
|
task->event->event.sequence = atomic_inc_return(&task->ipp->sequence); |
|
|
|
drm_send_event(task->ipp->drm_dev, &task->event->base); |
|
} |
|
|
|
static int exynos_drm_ipp_task_cleanup(struct exynos_drm_ipp_task *task) |
|
{ |
|
int ret = task->ret; |
|
|
|
if (ret == 0 && task->event) { |
|
exynos_drm_ipp_event_send(task); |
|
/* ensure event won't be canceled on task free */ |
|
task->event = NULL; |
|
} |
|
|
|
exynos_drm_ipp_task_free(task->ipp, task); |
|
return ret; |
|
} |
|
|
|
static void exynos_drm_ipp_cleanup_work(struct work_struct *work) |
|
{ |
|
struct exynos_drm_ipp_task *task = container_of(work, |
|
struct exynos_drm_ipp_task, cleanup_work); |
|
|
|
exynos_drm_ipp_task_cleanup(task); |
|
} |
|
|
|
static void exynos_drm_ipp_next_task(struct exynos_drm_ipp *ipp); |
|
|
|
/** |
|
* exynos_drm_ipp_task_done - finish given task and set return code |
|
* @task: ipp task to finish |
|
* @ret: error code or 0 if operation has been performed successfully |
|
*/ |
|
void exynos_drm_ipp_task_done(struct exynos_drm_ipp_task *task, int ret) |
|
{ |
|
struct exynos_drm_ipp *ipp = task->ipp; |
|
unsigned long flags; |
|
|
|
DRM_DEV_DEBUG_DRIVER(task->dev, "ipp: %d, task %pK done: %d\n", |
|
ipp->id, task, ret); |
|
|
|
spin_lock_irqsave(&ipp->lock, flags); |
|
if (ipp->task == task) |
|
ipp->task = NULL; |
|
task->flags |= DRM_EXYNOS_IPP_TASK_DONE; |
|
task->ret = ret; |
|
spin_unlock_irqrestore(&ipp->lock, flags); |
|
|
|
exynos_drm_ipp_next_task(ipp); |
|
wake_up(&ipp->done_wq); |
|
|
|
if (task->flags & DRM_EXYNOS_IPP_TASK_ASYNC) { |
|
INIT_WORK(&task->cleanup_work, exynos_drm_ipp_cleanup_work); |
|
schedule_work(&task->cleanup_work); |
|
} |
|
} |
|
|
|
static void exynos_drm_ipp_next_task(struct exynos_drm_ipp *ipp) |
|
{ |
|
struct exynos_drm_ipp_task *task; |
|
unsigned long flags; |
|
int ret; |
|
|
|
DRM_DEV_DEBUG_DRIVER(ipp->dev, "ipp: %d, try to run new task\n", |
|
ipp->id); |
|
|
|
spin_lock_irqsave(&ipp->lock, flags); |
|
|
|
if (ipp->task || list_empty(&ipp->todo_list)) { |
|
spin_unlock_irqrestore(&ipp->lock, flags); |
|
return; |
|
} |
|
|
|
task = list_first_entry(&ipp->todo_list, struct exynos_drm_ipp_task, |
|
head); |
|
list_del_init(&task->head); |
|
ipp->task = task; |
|
|
|
spin_unlock_irqrestore(&ipp->lock, flags); |
|
|
|
DRM_DEV_DEBUG_DRIVER(ipp->dev, |
|
"ipp: %d, selected task %pK to run\n", ipp->id, |
|
task); |
|
|
|
ret = ipp->funcs->commit(ipp, task); |
|
if (ret) |
|
exynos_drm_ipp_task_done(task, ret); |
|
} |
|
|
|
static void exynos_drm_ipp_schedule_task(struct exynos_drm_ipp *ipp, |
|
struct exynos_drm_ipp_task *task) |
|
{ |
|
unsigned long flags; |
|
|
|
spin_lock_irqsave(&ipp->lock, flags); |
|
list_add(&task->head, &ipp->todo_list); |
|
spin_unlock_irqrestore(&ipp->lock, flags); |
|
|
|
exynos_drm_ipp_next_task(ipp); |
|
} |
|
|
|
static void exynos_drm_ipp_task_abort(struct exynos_drm_ipp *ipp, |
|
struct exynos_drm_ipp_task *task) |
|
{ |
|
unsigned long flags; |
|
|
|
spin_lock_irqsave(&ipp->lock, flags); |
|
if (task->flags & DRM_EXYNOS_IPP_TASK_DONE) { |
|
/* already completed task */ |
|
exynos_drm_ipp_task_cleanup(task); |
|
} else if (ipp->task != task) { |
|
/* task has not been scheduled for execution yet */ |
|
list_del_init(&task->head); |
|
exynos_drm_ipp_task_cleanup(task); |
|
} else { |
|
/* |
|
* currently processed task, call abort() and perform |
|
* cleanup with async worker |
|
*/ |
|
task->flags |= DRM_EXYNOS_IPP_TASK_ASYNC; |
|
spin_unlock_irqrestore(&ipp->lock, flags); |
|
if (ipp->funcs->abort) |
|
ipp->funcs->abort(ipp, task); |
|
return; |
|
} |
|
spin_unlock_irqrestore(&ipp->lock, flags); |
|
} |
|
|
|
/** |
|
* exynos_drm_ipp_commit_ioctl - perform image processing operation |
|
* @dev: DRM device |
|
* @data: ioctl data |
|
* @file_priv: DRM file info |
|
* |
|
* Construct a ipp task from the set of properties provided from the user |
|
* and try to schedule it to framebuffer processor hardware. |
|
* |
|
* Called by the user via ioctl. |
|
* |
|
* Returns: |
|
* Zero on success, negative errno on failure. |
|
*/ |
|
int exynos_drm_ipp_commit_ioctl(struct drm_device *dev, void *data, |
|
struct drm_file *file_priv) |
|
{ |
|
struct drm_exynos_ioctl_ipp_commit *arg = data; |
|
struct exynos_drm_ipp *ipp; |
|
struct exynos_drm_ipp_task *task; |
|
int ret = 0; |
|
|
|
if ((arg->flags & ~DRM_EXYNOS_IPP_FLAGS) || arg->reserved) |
|
return -EINVAL; |
|
|
|
/* can't test and expect an event at the same time */ |
|
if ((arg->flags & DRM_EXYNOS_IPP_FLAG_TEST_ONLY) && |
|
(arg->flags & DRM_EXYNOS_IPP_FLAG_EVENT)) |
|
return -EINVAL; |
|
|
|
ipp = __ipp_get(arg->ipp_id); |
|
if (!ipp) |
|
return -ENOENT; |
|
|
|
task = exynos_drm_ipp_task_alloc(ipp); |
|
if (!task) |
|
return -ENOMEM; |
|
|
|
ret = exynos_drm_ipp_task_set(task, arg); |
|
if (ret) |
|
goto free; |
|
|
|
ret = exynos_drm_ipp_task_check(task); |
|
if (ret) |
|
goto free; |
|
|
|
ret = exynos_drm_ipp_task_setup_buffers(task, file_priv); |
|
if (ret || arg->flags & DRM_EXYNOS_IPP_FLAG_TEST_ONLY) |
|
goto free; |
|
|
|
if (arg->flags & DRM_EXYNOS_IPP_FLAG_EVENT) { |
|
ret = exynos_drm_ipp_event_create(task, file_priv, |
|
arg->user_data); |
|
if (ret) |
|
goto free; |
|
} |
|
|
|
/* |
|
* Queue task for processing on the hardware. task object will be |
|
* then freed after exynos_drm_ipp_task_done() |
|
*/ |
|
if (arg->flags & DRM_EXYNOS_IPP_FLAG_NONBLOCK) { |
|
DRM_DEV_DEBUG_DRIVER(ipp->dev, |
|
"ipp: %d, nonblocking processing task %pK\n", |
|
ipp->id, task); |
|
|
|
task->flags |= DRM_EXYNOS_IPP_TASK_ASYNC; |
|
exynos_drm_ipp_schedule_task(task->ipp, task); |
|
ret = 0; |
|
} else { |
|
DRM_DEV_DEBUG_DRIVER(ipp->dev, "ipp: %d, processing task %pK\n", |
|
ipp->id, task); |
|
exynos_drm_ipp_schedule_task(ipp, task); |
|
ret = wait_event_interruptible(ipp->done_wq, |
|
task->flags & DRM_EXYNOS_IPP_TASK_DONE); |
|
if (ret) |
|
exynos_drm_ipp_task_abort(ipp, task); |
|
else |
|
ret = exynos_drm_ipp_task_cleanup(task); |
|
} |
|
return ret; |
|
free: |
|
exynos_drm_ipp_task_free(ipp, task); |
|
|
|
return ret; |
|
}
|
|
|