Initial commit: Linux kernel 4.19 for Unplugged OS

This commit is contained in:
ziv committed 2025-10-06 13:52:42 +00:00
commit d30235b04c
80519 files changed
+35800681

No files matched your search

@@ -0,0 +1,9 @@
config MTK_CAMERA_ISP_RSC_SUPPORT
tristate "[RSC]Rolling Shutter Cancellation Support"
default n
depends on MTK_CAMERA_ISP
help
Rolling Shutter Cancellation. Enable to compensate
any distortion due to the interplay of moving objects
and rolling shutters of CMOS sensors. Disable if it is
not supported or not wanted.
@@ -0,0 +1,77 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# 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.
#
# 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.
#
ifeq ($(CONFIG_MACH_MT6833),y)
MTK_PLATFORM := mt6833
else
MTK_PLATFORM := $(subst ",,$(CONFIG_MTK_PLATFORM))
endif
# mt6761 mt6762 mt6768 without RSC
$(info $(srctree))
ccflags-y += -I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mmp/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v3/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v3/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/staging/android/ion \
-I$(srctree)/drivers/staging/android/ion/mtk
ccflags-y += -I$(srctree)/drivers/misc/mediatek/smi/
ccflags-y += -I$(srctree)/drivers/iommu
obj-$(CONFIG_MTK_CAMERA_ISP_RSC_SUPPORT) += camera_rsc.o
camera_rsc-objs += engine_request.o
ifeq ($(CONFIG_MACH_MT6758),y)
obj-$(CONFIG_MTK_CAMERA_ISP_RSC_SUPPORT) += $(MTK_PLATFORM)/camera_rsc.o
endif
ifeq ($(CONFIG_MACH_MT6771),y)
obj-$(CONFIG_MTK_CAMERA_ISP_RSC_SUPPORT) += isp_50/camera_rsc.o
endif
ifeq ($(CONFIG_MACH_MT6779),y)
obj-$(CONFIG_MTK_CAMERA_ISP_RSC_SUPPORT) += mt6779/camera_rsc.o
endif
ifeq ($(CONFIG_MACH_MT6785),y)
obj-$(CONFIG_MTK_CAMERA_ISP_RSC_SUPPORT) += mt6785/camera_rsc.o
endif
ifeq ($(CONFIG_MACH_MT6885),y)
obj-$(CONFIG_MTK_CAMERA_ISP_RSC_SUPPORT) += isp_6s/camera_rsc.o
endif
ifeq ($(CONFIG_MACH_MT6873),y)
obj-$(CONFIG_MTK_CAMERA_ISP_RSC_SUPPORT) += isp_6s/camera_rsc.o
endif
ifeq ($(CONFIG_MACH_MT6853),y)
obj-$(CONFIG_MTK_CAMERA_ISP_RSC_SUPPORT) += isp_6s/camera_rsc.o
endif
ifeq ($(CONFIG_MACH_MT6893),y)
obj-$(CONFIG_MTK_CAMERA_ISP_RSC_SUPPORT) += isp_6s/camera_rsc.o
endif
ifeq ($(CONFIG_MACH_MT6833),y)
obj-$(CONFIG_MTK_CAMERA_ISP_RSC_SUPPORT) += isp_6s/camera_rsc.o
endif
ifeq ($(CONFIG_MACH_MT6877),y)
obj-$(CONFIG_MTK_CAMERA_ISP_RSC_SUPPORT) += isp_6s/camera_rsc.o
endif
ifeq ($(CONFIG_MACH_MT6781),y)
obj-$(CONFIG_MTK_CAMERA_ISP_RSC_SUPPORT) += isp_6s/camera_rsc.o
endif
@@ -0,0 +1,645 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/stddef.h>
#include <linux/vmalloc.h>
#include <linux/spinlock.h>
#include <linux/printk.h>
#include <linux/module.h>
#include <linux/seqlock.h>
#include <linux/irqflags.h>
#include "engine_request.h"
/*
* module control
*/
#define TODO
MODULE_DESCRIPTION("Stand Alone Engine Request");
MODULE_AUTHOR("MM3SW5");
MODULE_LICENSE("GPL");
unsigned int egn_debug;
module_param(egn_debug, uint, 0644);
MODULE_PARM_DESC(egn_debug, " activates debug info");
#define MyTag "[STALN]"
#define LOG_VRB(format, args...) \
pr_debug(MyTag "[%s] " format, __func__, ##args)
#define LOG_DBG(format, args...) \
do { \
if (egn_debug >= 2) \
pr_info(MyTag "[%s] " format, __func__, ##args); \
} while (0)
#define LOG_INF(format, args...) \
do { \
if (egn_debug >= 1) \
pr_info(MyTag "[%s] " format, __func__, ##args);\
} while (0)
#define LOG_WRN(format, args...) \
do { \
if (egn_debug >= 0) \
pr_info(MyTag "[%s] " format, __func__, ##args); \
} while (0)
#define LOG_ERR(format, args...) \
do { \
if (egn_debug >= 0) \
pr_info(MyTag "[%s] " format, __func__, ##args); \
} while (0)
/*
* Single ring ctl init
*/
signed int init_ring_ctl(struct ring_ctrl *rctl)
{
if (!rctl)
return -1;
rctl->wcnt = 0;
rctl->rcnt = 0;
rctl->icnt = 0;
rctl->gcnt = 0;
rctl->size = 0;
return 0;
}
signed int set_ring_size(struct ring_ctrl *rctl, unsigned int size)
{
if (!rctl)
return -1;
rctl->size = size;
return 0;
}
signed int init_frame(struct frame *frame)
{
if (!frame)
return -1;
frame->state = FRAME_STATUS_EMPTY;
return 0;
}
/*
* single request init
*/
signed int init_request(struct request *req)
{
int f;
if (!req)
return -1;
req->state = REQUEST_STATE_EMPTY;
init_ring_ctl(&req->fctl);
set_ring_size(&req->fctl, MAX_FRAMES_PER_REQUEST);
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f++)
init_frame(&req->frames[f]);
req->pending_run = false;
return 0;
}
/*
* per-frame data init
*/
signed int set_frame_data(struct frame *f, void *engine)
{
if (!f) {
LOG_ERR("NULL frame(%p)", (void *)f);
return -1;
}
f->data = engine;
return 0;
}
/*
* TOP : per-sub-engine
* Size Limitaion: eng_reqs : [MAX_REQUEST_SIZE_PER_ENGINE]
* data : [MAX_REQUEST_SIZE_PER_ENGINE][MAX_FRAMES_PER_REQUEST]
*/
signed int register_requests(struct engine_requests *eng, size_t size)
{
int f, r, d;
char *_data;
size_t len;
if (!eng)
return -1;
init_ring_ctl(&eng->req_ctl);
set_ring_size(&eng->req_ctl, MAX_REQUEST_SIZE_PER_ENGINE);
/* TODO: KE Risk : array out of bound */
len = (size * MAX_FRAMES_PER_REQUEST) * MAX_REQUEST_SIZE_PER_ENGINE;
_data = vmalloc(len);
if (!_data) {
LOG_INF("[%s] vmalloc failed", __func__);
return -1;
}
memset(_data, 0x0, len);
LOG_INF("[%s]Engine struct total size is %zu", __func__, len);
for (r = 0; r < MAX_REQUEST_SIZE_PER_ENGINE; r++) {
init_request(&eng->reqs[r]);
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f++) {
d = (r * MAX_FRAMES_PER_REQUEST + f) * size;
set_frame_data(&eng->reqs[r].frames[f], &_data[d]);
}
}
/*seqlock_init(&eng->seqlock);*/
local_irq_disable();
write_seqlock(&eng->seqlock);
eng->req_running = false;
write_sequnlock(&eng->seqlock);
local_irq_enable();
/* init and inc for 1st request_handler use */
init_completion(&eng->req_handler_done);
complete(&eng->req_handler_done);
return 0;
}
EXPORT_SYMBOL(register_requests);
signed int unregister_requests(struct engine_requests *eng)
{
int f, r;
if (!eng)
return -1;
vfree(eng->reqs[0].frames[0].data);
for (r = 0; r < MAX_REQUEST_SIZE_PER_ENGINE; r++) {
init_request(&eng->reqs[r]);
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f++)
set_frame_data(&eng->reqs[r].frames[f], NULL);
}
local_irq_disable();
write_seqlock(&eng->seqlock);
eng->req_running = false;
write_sequnlock(&eng->seqlock);
local_irq_enable();
return 0;
}
EXPORT_SYMBOL(unregister_requests);
int set_engine_ops(struct engine_requests *eng, const struct engine_ops *ops)
{
if (!eng || !ops)
return -1;
eng->ops = ops;
return 0;
}
EXPORT_SYMBOL(set_engine_ops);
bool request_running(struct engine_requests *eng)
{
unsigned int seq;
seqlock_t *lock;
bool running;
lock = &eng->seqlock;
do {
seq = read_seqbegin(lock);
running = eng->req_running;
} while (read_seqretry(lock, seq));
LOG_DBG("[%s] engine running request(%d)\n", __func__, running);
return running;
}
EXPORT_SYMBOL(request_running);
/*TODO: called in ENQUE_REQ */
signed int enque_request(struct engine_requests *eng, unsigned int fcnt,
void *req, pid_t pid)
{
unsigned int r;
unsigned int f;
unsigned int enqnum = 0;
if (!eng)
return -1;
r = eng->req_ctl.wcnt;
/* FIFO when wcnt starts from 0 */
f = eng->reqs[r].fctl.wcnt;
if (eng->reqs[r].state != REQUEST_STATE_EMPTY) {
LOG_ERR("No empty requests available.");
goto ERROR;
}
if (!eng->ops->req_enque_cb || !req) {
LOG_ERR("NULL req_enque_cb or req");
goto ERROR;
}
if (eng->ops->req_enque_cb(eng->reqs[r].frames, req)) {
LOG_ERR("Failed to enque request, check cb");
goto ERROR;
}
LOG_DBG("request(%d) enqued with %d frames", r, fcnt);
for (f = 0; f < fcnt; f++)
eng->reqs[r].frames[f].state = FRAME_STATUS_ENQUE;
eng->reqs[r].state = REQUEST_STATE_PENDING;
eng->reqs[r].pid = pid;
eng->reqs[r].fctl.wcnt = fcnt;
eng->reqs[r].fctl.size = fcnt;
eng->req_ctl.wcnt = (r + 1) % MAX_REQUEST_SIZE_PER_ENGINE;
#if REQUEST_REGULATION
/*
* pending request count for request base regulation
*/
for (r = 0; r < MAX_REQUEST_SIZE_PER_ENGINE; r++)
if (eng->reqs[r].state == REQUEST_STATE_PENDING)
enqnum++;
#else
/*
* running frame count for frame base regulation
*/
for (r = 0; r < MAX_REQUEST_SIZE_PER_ENGINE; r++)
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f++)
if (eng->reqs[r].frames[f].state ==
FRAME_STATUS_RUNNING)
enqnum++;
#endif
return enqnum;
ERROR:
return -1;
}
EXPORT_SYMBOL(enque_request);
/* ConfigWMFERequest / ConfigOCCRequest abstraction
* TODO: locking should be here NOT camera_owe.c
*/
signed int request_handler(struct engine_requests *eng, spinlock_t *lock)
{
unsigned int f, fn;
unsigned int r;
enum REQUEST_STATE_ENUM rstate;
enum FRAME_STATUS_ENUM fstate;
unsigned long flags;
signed int ret = -1;
if (!eng)
return -1;
LOG_DBG("[%s]waits for completion(%d).\n", __func__,
eng->req_handler_done.done);
wait_for_completion(&eng->req_handler_done);
reinit_completion(&eng->req_handler_done);
LOG_DBG("[%s]previous request completed, reset(%d).\n", __func__,
eng->req_handler_done.done);
spin_lock_irqsave(lock, flags);
/*
* ioctl calls enque_request() request wcnt inc
* if request_handler is NOT called after enque_request() in serial,
* wcnt may inc many times maore than 1
*/
r = eng->req_ctl.gcnt;
LOG_DBG("[%s] processing request(%d)\n", __func__, r);
rstate = eng->reqs[r].state;
#if REQUEST_REGULATION
(void) fn;
if (rstate != REQUEST_STATE_PENDING) {
LOG_DBG("[%s]No pending request(%d), state:%d\n", __func__,
r, rstate);
write_seqlock(&eng->seqlock);
eng->req_running = false;
write_sequnlock(&eng->seqlock);
spin_unlock_irqrestore(lock, flags);
complete_all(&eng->req_handler_done);
LOG_DBG("[%s]complete(%d)\n", __func__,
eng->req_handler_done.done);
return 0;
}
/* running request contains all running frames */
eng->reqs[r].state = REQUEST_STATE_RUNNING;
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f++) {
fstate = eng->reqs[r].frames[f].state;
if (fstate == FRAME_STATUS_ENQUE) {
LOG_DBG("[%s]Processing request(%d) of frame(%d)\n",
__func__, r, f);
spin_unlock_irqrestore(lock, flags);
ret = eng->ops->frame_handler(&eng->reqs[r].frames[f]);
spin_lock_irqsave(lock, flags);
if (ret)
LOG_WRN("[%s]failed:frame %d of request %d",
__func__, f, r);
eng->reqs[r].frames[f].state = FRAME_STATUS_RUNNING;
}
}
eng->req_ctl.gcnt = (r + 1) % MAX_REQUEST_SIZE_PER_ENGINE;
#else
/*
* TODO: to prevent IRQ timing issue due to multi-frame requests,
* frame-based reguest handling should be used instead.
*/
if (eng->reqs[r].pending_run == false) {
if (rstate != REQUEST_STATE_PENDING) {
LOG_DBG("[%s]No pending request(%d), state:%d\n",
__func__, r, rstate);
write_seqlock(&eng->seqlock);
eng->req_running = false;
write_sequnlock(&eng->seqlock);
spin_unlock_irqrestore(lock, flags);
complete_all(&eng->req_handler_done);
LOG_DBG("[%s]complete(%d)\n", __func__,
eng->req_handler_done.done);
return 0;
}
eng->reqs[r].pending_run = true;
eng->reqs[r].state = REQUEST_STATE_RUNNING;
} else
if (rstate != REQUEST_STATE_RUNNING) {
LOG_WRN(
"[%s]No pending_run request(%d), state:%d\n", __func__,
r, rstate);
write_seqlock(&eng->seqlock);
eng->req_running = false;
write_sequnlock(&eng->seqlock);
spin_unlock_irqrestore(lock, flags);
complete_all(&eng->req_handler_done);
LOG_DBG(
"[%s]complete(%d)\n", __func__,
eng->req_handler_done.done);
return 0;
}
/* pending requets can have running frames */
f = eng->reqs[r].fctl.gcnt;
LOG_DBG("[%s]Iterating request(%d) of frame(%d)\n",
__func__, r, f);
fstate = eng->reqs[r].frames[f].state;
if (fstate == FRAME_STATUS_ENQUE) {
LOG_DBG("[%s]Processing request(%d) of frame(%d)\n",
__func__, r, f);
write_seqlock(&eng->seqlock);
eng->req_running = true;
write_sequnlock(&eng->seqlock);
eng->reqs[r].frames[f].state = FRAME_STATUS_RUNNING;
spin_unlock_irqrestore(lock, flags);
ret = eng->ops->frame_handler(&eng->reqs[r].frames[f]);
spin_lock_irqsave(lock, flags);
if (ret)
LOG_WRN("[%s]failed:frame %d of request %d",
__func__, f, r);
} else {
spin_unlock_irqrestore(lock, flags);
LOG_WRN("[%s]already running frame %d of request %d",
__func__, f, r);
complete_all(&eng->req_handler_done);
LOG_DBG("[%s]complete(%d)\n", __func__,
eng->req_handler_done.done);
return 1;
}
fn = (f + 1) % MAX_FRAMES_PER_REQUEST;
fstate = eng->reqs[r].frames[fn].state;
if (fstate == FRAME_STATUS_EMPTY || fn == 0) {
eng->reqs[r].pending_run = false;
eng->req_ctl.gcnt = (r + 1) % MAX_REQUEST_SIZE_PER_ENGINE;
} else
eng->reqs[r].fctl.gcnt = fn;
#endif
spin_unlock_irqrestore(lock, flags);
complete_all(&eng->req_handler_done);
LOG_DBG("complete_all done = %d\n", eng->req_handler_done.done);
return 1;
}
EXPORT_SYMBOL(request_handler);
int update_request(struct engine_requests *eng, pid_t *pid)
{
unsigned int i, f, n;
int req_jobs = -1;
if (!eng)
return -1;
/* TODO: request ring */
for (i = eng->req_ctl.icnt; i < MAX_REQUEST_SIZE_PER_ENGINE; i++) {
/* find 1st running request */
if (eng->reqs[i].state != REQUEST_STATE_RUNNING)
continue;
/* find 1st running frame, f. */
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f++) {
if (eng->reqs[i].frames[f].state ==
FRAME_STATUS_RUNNING)
break;
}
/* TODO: no running frame in a running request */
if (f == MAX_FRAMES_PER_REQUEST) {
LOG_ERR(
"[%s]No running frames in a running request(%d).",
__func__, i);
break;
}
eng->reqs[i].frames[f].state = FRAME_STATUS_FINISHED;
LOG_INF("[%s]request %d of frame %d finished.\n",
__func__, i, f);
/*TODO: to obtain statistics */
if (!eng->ops->req_feedback_cb) {
LOG_DBG("NULL req_feedback_cb");
goto NO_FEEDBACK;
}
if (eng->ops->req_feedback_cb(&eng->reqs[i].frames[f])) {
LOG_ERR("Failed to feedback statistics, check cb");
goto NO_FEEDBACK;
}
NO_FEEDBACK:
n = f + 1;
if ((n == MAX_FRAMES_PER_REQUEST) ||
((n < MAX_FRAMES_PER_REQUEST) &&
(eng->reqs[i].frames[n].state == FRAME_STATUS_EMPTY))) {
req_jobs = 0;
(*pid) = eng->reqs[i].pid;
eng->reqs[i].state = REQUEST_STATE_FINISHED;
eng->req_ctl.icnt = (eng->req_ctl.icnt + 1) %
MAX_REQUEST_SIZE_PER_ENGINE;
} else {
LOG_INF(
"[%s]more frames left of request(%d/%d).", __func__,
i, eng->req_ctl.icnt);
}
break;
}
return req_jobs;
}
EXPORT_SYMBOL(update_request);
/*TODO: called in DEQUE_REQ */
signed int deque_request(struct engine_requests *eng, unsigned int *fcnt,
void *req)
{
unsigned int r;
unsigned int f;
if (!eng)
return -1;
r = eng->req_ctl.rcnt;
/* FIFO when rcnt starts from 0 */
f = eng->reqs[r].fctl.rcnt;
if (eng->reqs[r].state != REQUEST_STATE_FINISHED) {
LOG_ERR("[%s]Request(%d) NOT finished", __func__, r);
goto ERROR;
}
*fcnt = eng->reqs[r].fctl.size;
LOG_DBG("[%s]deque request(%d) has %d frames", __func__, r, *fcnt);
if (!eng->ops->req_deque_cb || !req) {
LOG_ERR("[%s]NULL req_deque_cb/req", __func__);
goto ERROR;
}
if (eng->ops->req_deque_cb(eng->reqs[r].frames, req)) {
LOG_ERR("[%s]Failed to deque, check req_deque_cb", __func__);
goto ERROR;
}
for (f = 0; f < *fcnt; f++)
eng->reqs[r].frames[f].state = FRAME_STATUS_EMPTY;
eng->reqs[r].state = REQUEST_STATE_EMPTY;
eng->reqs[r].pid = 0;
eng->reqs[r].fctl.wcnt = 0;
eng->reqs[r].fctl.rcnt = 0;
eng->reqs[r].fctl.icnt = 0;
eng->reqs[r].fctl.gcnt = 0;
eng->reqs[r].fctl.size = 0;
eng->req_ctl.rcnt = (r + 1) % MAX_REQUEST_SIZE_PER_ENGINE;
return 0;
ERROR:
return -1;
}
EXPORT_SYMBOL(deque_request);
signed int request_dump(struct engine_requests *eng)
{
unsigned int r;
unsigned int f;
LOG_ERR("[%s] +\n", __func__);
if (!eng) {
LOG_ERR("[%s]can't dump NULL engine", __func__);
return -1;
}
LOG_ERR("req_ctl:wc:%d, gc:%d, ic:%d, rc:%d, data:%p\n",
eng->req_ctl.wcnt,
eng->req_ctl.gcnt,
eng->req_ctl.icnt,
eng->req_ctl.rcnt,
eng->reqs[0].frames[0].data);
for (r = 0; r < MAX_REQUEST_SIZE_PER_ENGINE; r++) {
LOG_ERR(
"R[%d].sta:%d, pid:0x%08X, wc:%d, gc:%d, ic:%d, rc:%d\n",
r,
eng->reqs[r].state,
eng->reqs[r].pid,
eng->reqs[r].fctl.wcnt,
eng->reqs[r].fctl.gcnt,
eng->reqs[r].fctl.icnt,
eng->reqs[r].fctl.rcnt);
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f += 2) {
LOG_ERR("F[%d].state:%d, F[%d].state:%d\n",
f, eng->reqs[r].frames[f].state,
f + 1, eng->reqs[r].frames[f + 1].state);
}
}
LOG_ERR("[%s] -\n", __func__);
return 0;
}
EXPORT_SYMBOL(request_dump);
#ifndef TODO
static int __init egnreq_init(void)
{
int ret = 0;
LOG_INF("engine_request module loaded");
return ret;
}
static void __exit egnreq_exit(void)
{
LOG_INF("engine_request module unloaded");
}
module_init(egnreq_init);
module_exit(egnreq_exit);
#endif
@@ -0,0 +1,93 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#include <linux/completion.h>
#ifndef _ENGINE_REQUESTS_H_
#define _ENGINE_REQUESTS_H_
#define MAX_REQUEST_SIZE_PER_ENGINE 4
#define MAX_FRAMES_PER_REQUEST 6
/* Regulation Options */
#define FRAME_BASE_REGULATION 0
#define REQUEST_BASE_REGULATION 1
#define REQUEST_REGULATION FRAME_BASE_REGULATION
enum FRAME_STATUS_ENUM {
FRAME_STATUS_EMPTY, /* 0 */
FRAME_STATUS_ENQUE, /* 1 */
FRAME_STATUS_RUNNING, /* 2 */
FRAME_STATUS_FINISHED, /* 3 */
FRAME_STATUS_TOTAL
};
enum REQUEST_STATE_ENUM {
REQUEST_STATE_EMPTY, /* 0 */
REQUEST_STATE_PENDING, /* 1 */
REQUEST_STATE_RUNNING, /* 2 */
REQUEST_STATE_FINISHED, /* 3 */
REQUEST_STATE_TOTAL
};
struct ring_ctrl {
unsigned int wcnt; /* enque */
unsigned int rcnt; /* deque */
unsigned int icnt; /* IRQ ringing counter w/o reset */
unsigned int gcnt; /* GCE */
unsigned int size;
/* init MAX_REQUEST_SIZE_PER_ENGINE MAX_FRAMES_PER_REQUEST */
};
struct frame {
enum FRAME_STATUS_ENUM state;
void *data; /* points to engine data */
};
struct request {
enum REQUEST_STATE_ENUM state;
pid_t pid;
struct ring_ctrl fctl;
struct frame frames[MAX_FRAMES_PER_REQUEST];
bool pending_run; /* pending frame in a running request */
};
struct engine_ops {
int (*req_enque_cb)(struct frame *frames, void *req);
int (*req_deque_cb)(struct frame *frames, void *req);
int (*frame_handler)(struct frame *frame);
int (*req_feedback_cb)(struct frame *frame);
};
struct engine_requests {
struct ring_ctrl req_ctl;
struct request reqs[MAX_REQUEST_SIZE_PER_ENGINE];
const struct engine_ops *ops;
struct completion req_handler_done;
bool req_running;
seqlock_t seqlock;
};
signed int init_ring_ctl(struct ring_ctrl *rctl);
signed int init_request(struct request *req);
signed int set_frame_data(struct frame *f, void *engine);
signed int register_requests(struct engine_requests *eng, size_t size);
signed int unregister_requests(struct engine_requests *eng);
signed int request_handler(struct engine_requests *eng, spinlock_t *lock);
/*TODO: APIs to manipulate requests */
int set_engine_ops(struct engine_requests *eng, const struct engine_ops *ops);
signed int enque_request(struct engine_requests *eng, unsigned int fcnt,
void *req, pid_t pid);
signed int deque_request(struct engine_requests *eng, unsigned int *fcnt,
void *req);
int update_request(struct engine_requests *eng, pid_t *pid);
bool request_running(struct engine_requests *eng);
signed int request_dump(struct engine_requests *eng);
#endif
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,215 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef _MT_RSC_H
#define _MT_RSC_H
#include <linux/ioctl.h>
#ifdef CONFIG_COMPAT
/* 64 bit */
#include <linux/fs.h>
#include <linux/compat.h>
#endif
/*
* enforce kernel log enable
*/
#define KERNEL_LOG /* enable debug log flag if defined */
#define _SUPPORT_MAX_RSC_FRAME_REQUEST_ 6
#define _SUPPORT_MAX_RSC_REQUEST_RING_SIZE_ 4
#define SIG_ERESTARTSYS 512 /* ERESTARTSYS */
/*
*
*/
#define RSC_DEV_MAJOR_NUMBER 251
#define RSC_MAGIC 'r'
#define RSC_REG_RANGE (0x1000)
#define RSC_BASE_HW 0x1b003000
/*This macro is for setting irq status represnted
* by a local variable,RSCInfo.IrqInfo.Status[RSC_IRQ_TYPE_INT_RSC_ST]
*/
#define RSC_INT_ST (1<<0)
struct RSC_REG_STRUCT {
unsigned int module;
unsigned int Addr; /* register's addr */
unsigned int Val; /* register's value */
};
struct RSC_REG_IO_STRUCT {
struct RSC_REG_STRUCT *pData; /* pointer to RSC_REG_STRUCT */
unsigned int Count; /* count */
};
/*
* interrupt clear type
*/
enum RSC_IRQ_CLEAR_ENUM {
RSC_IRQ_CLEAR_NONE, /* non-clear wait, clear after wait */
RSC_IRQ_CLEAR_WAIT, /* clear wait, clear before and after wait */
RSC_IRQ_WAIT_CLEAR,
/* wait the signal and clear it, avoid hw executime is too s hort. */
RSC_IRQ_CLEAR_STATUS, /* clear specific status only */
RSC_IRQ_CLEAR_ALL /* clear all status */
};
/*
* module's interrupt , each module should have its own isr.
* note:
* mapping to isr table,ISR_TABLE when using no device tree
*/
enum RSC_IRQ_TYPE_ENUM {
RSC_IRQ_TYPE_INT_RSC_ST, /* RSC */
RSC_IRQ_TYPE_AMOUNT
};
struct RSC_WAIT_IRQ_STRUCT {
enum RSC_IRQ_CLEAR_ENUM Clear;
enum RSC_IRQ_TYPE_ENUM Type;
unsigned int Status; /*IRQ Status */
unsigned int Timeout;
int UserKey; /* user key for doing interrupt operation */
int ProcessID; /* user ProcessID (will filled in kernel) */
unsigned int bDumpReg; /* check dump register or not */
};
struct RSC_CLEAR_IRQ_STRUCT {
enum RSC_IRQ_TYPE_ENUM Type;
int UserKey; /* user key for doing interrupt operation */
unsigned int Status; /* Input */
};
struct RSC_Config {
unsigned int RSC_CTRL;
unsigned int RSC_SIZE;
unsigned int RSC_IMGI_C_BASE_ADDR;
unsigned int RSC_IMGI_C_STRIDE;
unsigned int RSC_IMGI_P_BASE_ADDR;
unsigned int RSC_IMGI_P_STRIDE;
unsigned int RSC_MVI_BASE_ADDR;
unsigned int RSC_MVI_STRIDE;
unsigned int RSC_APLI_C_BASE_ADDR;
unsigned int RSC_APLI_P_BASE_ADDR;
unsigned int RSC_MVO_BASE_ADDR;
unsigned int RSC_MVO_STRIDE;
unsigned int RSC_BVO_BASE_ADDR;
unsigned int RSC_BVO_STRIDE;
#define RSC_TUNABLE
#ifdef RSC_TUNABLE
unsigned int RSC_MV_OFFSET;
unsigned int RSC_GMV_OFFSET;
unsigned int RSC_CAND_NUM;
unsigned int RSC_RAND_HORZ_LUT;
unsigned int RSC_RAND_VERT_LUT;
unsigned int RSC_SAD_CTRL;
unsigned int RSC_SAD_EDGE_GAIN_CTRL;
unsigned int RSC_SAD_CRNR_GAIN_CTRL;
unsigned int RSC_STILL_STRIP_CTRL0;
unsigned int RSC_STILL_STRIP_CTRL1;
unsigned int RSC_RAND_PNLTY_CTRL;
unsigned int RSC_RAND_PNLTY_GAIN_CTRL0;
unsigned int RSC_RAND_PNLTY_GAIN_CTRL1;
#endif
unsigned int RSC_STA_0;
};
/*
*
*/
enum RSC_CMD_ENUM {
RSC_CMD_RESET, /* Reset */
RSC_CMD_DUMP_REG, /* Dump RSC Register */
RSC_CMD_DUMP_ISR_LOG, /* Dump RSC ISR log */
RSC_CMD_READ_REG, /* Read register from driver */
RSC_CMD_WRITE_REG, /* Write register to driver */
RSC_CMD_WAIT_IRQ, /* Wait IRQ */
RSC_CMD_CLEAR_IRQ, /* Clear IRQ */
RSC_CMD_ENQUE_NUM, /* RSC Enque Number */
RSC_CMD_ENQUE, /* RSC Enque */
RSC_CMD_ENQUE_REQ, /* RSC Enque Request */
RSC_CMD_DEQUE_NUM, /* RSC Deque Number */
RSC_CMD_DEQUE, /* RSC Deque */
RSC_CMD_DEQUE_REQ, /* RSC Deque Request */
RSC_CMD_TOTAL,
};
/* */
struct RSC_Request {
unsigned int m_ReqNum;
struct RSC_Config *m_pRscConfig;
};
#ifdef CONFIG_COMPAT
struct compat_RSC_REG_IO_STRUCT {
compat_uptr_t pData;
unsigned int Count; /* count */
};
struct compat_RSC_Request {
unsigned int m_ReqNum;
compat_uptr_t m_pRscConfig;
};
#endif
#define RSC_RESET _IO(RSC_MAGIC, RSC_CMD_RESET)
#define RSC_DUMP_REG _IO(RSC_MAGIC, RSC_CMD_DUMP_REG)
#define RSC_DUMP_ISR_LOG _IO(RSC_MAGIC, RSC_CMD_DUMP_ISR_LOG)
#define RSC_READ_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_READ_REG, struct RSC_REG_IO_STRUCT)
#define RSC_WRITE_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_WRITE_REG, struct RSC_REG_IO_STRUCT)
#define RSC_WAIT_IRQ \
_IOW(RSC_MAGIC, RSC_CMD_WAIT_IRQ, struct RSC_WAIT_IRQ_STRUCT)
#define RSC_CLEAR_IRQ \
_IOW(RSC_MAGIC, RSC_CMD_CLEAR_IRQ, struct RSC_CLEAR_IRQ_STRUCT)
#define RSC_ENQNUE_NUM _IOW(RSC_MAGIC, RSC_CMD_ENQUE_NUM, int)
#define RSC_ENQUE _IOWR(RSC_MAGIC, RSC_CMD_ENQUE, struct RSC_Config)
#define RSC_ENQUE_REQ _IOWR(RSC_MAGIC, RSC_CMD_ENQUE_REQ, struct RSC_Request)
#define RSC_DEQUE_NUM _IOR(RSC_MAGIC, RSC_CMD_DEQUE_NUM, int)
#define RSC_DEQUE _IOWR(RSC_MAGIC, RSC_CMD_DEQUE, struct RSC_Config)
#define RSC_DEQUE_REQ _IOWR(RSC_MAGIC, RSC_CMD_DEQUE_REQ, struct RSC_Request)
#ifdef CONFIG_COMPAT
#define COMPAT_RSC_WRITE_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_WRITE_REG, struct compat_RSC_REG_IO_STRUCT)
#define COMPAT_RSC_READ_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_READ_REG, struct compat_RSC_REG_IO_STRUCT)
#define COMPAT_RSC_ENQUE_REQ \
_IOWR(RSC_MAGIC, RSC_CMD_ENQUE_REQ, struct compat_RSC_Request)
#define COMPAT_RSC_DEQUE_REQ \
_IOWR(RSC_MAGIC, RSC_CMD_DEQUE_REQ, struct compat_RSC_Request)
#endif
/* */
#endif
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,227 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2022 MediaTek Inc.
*/
#ifndef _MT_RSC_H
#define _MT_RSC_H
#include <linux/ioctl.h>
#ifdef CONFIG_COMPAT
/* 64 bit */
#include <linux/fs.h>
#include <linux/compat.h>
#endif
/*
* enforce kernel log enable
*/
#define KERNEL_LOG /* enable debug log flag if defined */
#define _SUPPORT_MAX_RSC_FRAME_REQUEST_ 6
#define _SUPPORT_MAX_RSC_REQUEST_RING_SIZE_ 4
#define SIG_ERESTARTSYS 512 /* ERESTARTSYS */
/*
*
*/
#define RSC_DEV_MAJOR_NUMBER 251
#define RSC_MAGIC 'r'
#define RSC_REG_RANGE (0x1000)
#define RSC_BASE_HW 0x15029000
/*This macro is for setting irq status represnted
* by a local variable,RSCInfo.IrqInfo.Status[RSC_IRQ_TYPE_INT_RSC_ST]
*/
#define RSC_INT_ST (1<<0)
struct RSC_REG_STRUCT {
unsigned int module;
unsigned int Addr; /* register's addr */
unsigned int Val; /* register's value */
};
struct RSC_REG_IO_STRUCT {
struct RSC_REG_STRUCT *pData; /* pointer to RSC_REG_STRUCT */
unsigned int Count; /* count */
};
/*
* interrupt clear type
*/
enum RSC_IRQ_CLEAR_ENUM {
RSC_IRQ_CLEAR_NONE, /* non-clear wait, clear after wait */
RSC_IRQ_CLEAR_WAIT, /* clear wait, clear before and after wait */
RSC_IRQ_WAIT_CLEAR,
/* wait the signal and clear it, avoid hw executime is too s hort. */
RSC_IRQ_CLEAR_STATUS, /* clear specific status only */
RSC_IRQ_CLEAR_ALL /* clear all status */
};
/*
* module's interrupt , each module should have its own isr.
* note:
* mapping to isr table,ISR_TABLE when using no device tree
*/
enum RSC_IRQ_TYPE_ENUM {
RSC_IRQ_TYPE_INT_RSC_ST, /* RSC */
RSC_IRQ_TYPE_AMOUNT
};
struct RSC_WAIT_IRQ_STRUCT {
enum RSC_IRQ_CLEAR_ENUM Clear;
enum RSC_IRQ_TYPE_ENUM Type;
unsigned int Status; /*IRQ Status */
unsigned int Timeout;
int UserKey; /* user key for doing interrupt operation */
int ProcessID; /* user ProcessID (will filled in kernel) */
unsigned int bDumpReg; /* check dump register or not */
};
struct RSC_CLEAR_IRQ_STRUCT {
enum RSC_IRQ_TYPE_ENUM Type;
int UserKey; /* user key for doing interrupt operation */
unsigned int Status; /* Input */
};
struct RSC_Config {
unsigned int RSC_CTRL;
unsigned int RSC_SIZE;
unsigned int RSC_IMGI_C_BASE_ADDR;
unsigned int RSC_IMGI_C_FD;
unsigned int RSC_IMGI_C_OFFSET;
unsigned int RSC_IMGI_C_STRIDE;
unsigned int RSC_IMGI_P_BASE_ADDR;
unsigned int RSC_IMGI_P_FD;
unsigned int RSC_IMGI_P_OFFSET;
unsigned int RSC_IMGI_P_STRIDE;
unsigned int RSC_MVI_BASE_ADDR;
unsigned int RSC_MVI_FD;
unsigned int RSC_MVI_OFFSET;
unsigned int RSC_MVI_STRIDE;
unsigned int RSC_APLI_C_BASE_ADDR;
unsigned int RSC_APLI_C_FD;
unsigned int RSC_APLI_C_OFFSET;
unsigned int RSC_APLI_P_BASE_ADDR;
unsigned int RSC_APLI_P_FD;
unsigned int RSC_APLI_P_OFFSET;
unsigned int RSC_MVO_BASE_ADDR;
unsigned int RSC_MVO_FD;
unsigned int RSC_MVO_OFFSET;
unsigned int RSC_MVO_STRIDE;
unsigned int RSC_BVO_BASE_ADDR;
unsigned int RSC_BVO_FD;
unsigned int RSC_BVO_OFFSET;
unsigned int RSC_BVO_STRIDE;
#define RSC_TUNABLE
#ifdef RSC_TUNABLE
unsigned int RSC_MV_OFFSET;
unsigned int RSC_GMV_OFFSET;
unsigned int RSC_CAND_NUM;
unsigned int RSC_RAND_HORZ_LUT;
unsigned int RSC_RAND_VERT_LUT;
unsigned int RSC_SAD_CTRL;
unsigned int RSC_SAD_EDGE_GAIN_CTRL;
unsigned int RSC_SAD_CRNR_GAIN_CTRL;
unsigned int RSC_STILL_STRIP_CTRL0;
unsigned int RSC_STILL_STRIP_CTRL1;
unsigned int RSC_RAND_PNLTY_CTRL;
unsigned int RSC_RAND_PNLTY_GAIN_CTRL0;
unsigned int RSC_RAND_PNLTY_GAIN_CTRL1;
#endif
unsigned int RSC_STA_0;
};
/*
*
*/
enum RSC_CMD_ENUM {
RSC_CMD_RESET, /* Reset */
RSC_CMD_DUMP_REG, /* Dump RSC Register */
RSC_CMD_DUMP_ISR_LOG, /* Dump RSC ISR log */
RSC_CMD_READ_REG, /* Read register from driver */
RSC_CMD_WRITE_REG, /* Write register to driver */
RSC_CMD_WAIT_IRQ, /* Wait IRQ */
RSC_CMD_CLEAR_IRQ, /* Clear IRQ */
RSC_CMD_ENQUE_NUM, /* RSC Enque Number */
RSC_CMD_ENQUE, /* RSC Enque */
RSC_CMD_ENQUE_REQ, /* RSC Enque Request */
RSC_CMD_DEQUE_NUM, /* RSC Deque Number */
RSC_CMD_DEQUE, /* RSC Deque */
RSC_CMD_DEQUE_REQ, /* RSC Deque Request */
RSC_CMD_TOTAL,
};
/* */
struct RSC_Request {
unsigned int m_ReqNum;
struct RSC_Config *m_pRscConfig;
};
#ifdef CONFIG_COMPAT
struct compat_RSC_REG_IO_STRUCT {
compat_uptr_t pData;
unsigned int Count; /* count */
};
struct compat_RSC_Request {
unsigned int m_ReqNum;
compat_uptr_t m_pRscConfig;
};
#endif
#define RSC_RESET _IO(RSC_MAGIC, RSC_CMD_RESET)
#define RSC_DUMP_REG _IO(RSC_MAGIC, RSC_CMD_DUMP_REG)
#define RSC_DUMP_ISR_LOG _IO(RSC_MAGIC, RSC_CMD_DUMP_ISR_LOG)
#define RSC_READ_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_READ_REG, struct RSC_REG_IO_STRUCT)
#define RSC_WRITE_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_WRITE_REG, struct RSC_REG_IO_STRUCT)
#define RSC_WAIT_IRQ \
_IOW(RSC_MAGIC, RSC_CMD_WAIT_IRQ, struct RSC_WAIT_IRQ_STRUCT)
#define RSC_CLEAR_IRQ \
_IOW(RSC_MAGIC, RSC_CMD_CLEAR_IRQ, struct RSC_CLEAR_IRQ_STRUCT)
#define RSC_ENQNUE_NUM _IOW(RSC_MAGIC, RSC_CMD_ENQUE_NUM, int)
#define RSC_ENQUE _IOWR(RSC_MAGIC, RSC_CMD_ENQUE, struct RSC_Config)
#define RSC_ENQUE_REQ _IOWR(RSC_MAGIC, RSC_CMD_ENQUE_REQ, struct RSC_Request)
#define RSC_DEQUE_NUM _IOR(RSC_MAGIC, RSC_CMD_DEQUE_NUM, int)
#define RSC_DEQUE _IOWR(RSC_MAGIC, RSC_CMD_DEQUE, struct RSC_Config)
#define RSC_DEQUE_REQ _IOWR(RSC_MAGIC, RSC_CMD_DEQUE_REQ, struct RSC_Request)
#ifdef CONFIG_COMPAT
#define COMPAT_RSC_WRITE_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_WRITE_REG, struct compat_RSC_REG_IO_STRUCT)
#define COMPAT_RSC_READ_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_READ_REG, struct compat_RSC_REG_IO_STRUCT)
#define COMPAT_RSC_ENQUE_REQ \
_IOWR(RSC_MAGIC, RSC_CMD_ENQUE_REQ, struct compat_RSC_Request)
#define COMPAT_RSC_DEQUE_REQ \
_IOWR(RSC_MAGIC, RSC_CMD_DEQUE_REQ, struct compat_RSC_Request)
#endif
/* */
#endif
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,227 @@
/* SPDX-License-Identifier: GPL-2.0 */
//
// Copyright (c) 2015 MediaTek Inc.
#ifndef _MT_RSC_H
#define _MT_RSC_H
#include <linux/ioctl.h>
#ifdef CONFIG_COMPAT
/* 64 bit */
#include <linux/fs.h>
#include <linux/compat.h>
#endif
/*
* enforce kernel log enable
*/
#define KERNEL_LOG /* enable debug log flag if defined */
#define _SUPPORT_MAX_RSC_FRAME_REQUEST_ 6
#define _SUPPORT_MAX_RSC_REQUEST_RING_SIZE_ 4
#define SIG_ERESTARTSYS 512 /* ERESTARTSYS */
/*
*
*/
#define RSC_DEV_MAJOR_NUMBER 251
#define RSC_MAGIC 'r'
#define RSC_REG_RANGE (0x1000)
#ifdef CONFIG_MACH_MT6781
#define RSC_BASE_HW 0x1C003000
#else
#define RSC_BASE_HW 0x1B003000
#endif
/*This macro is for setting irq status represnted
* by a local variable,RSCInfo.IrqInfo.Status[RSC_IRQ_TYPE_INT_RSC_ST]
*/
#define RSC_INT_ST (1<<0)
struct RSC_REG_STRUCT {
unsigned int module;
unsigned int Addr; /* register's addr */
unsigned int Val; /* register's value */
};
struct RSC_REG_IO_STRUCT {
struct RSC_REG_STRUCT *pData; /* pointer to RSC_REG_STRUCT */
unsigned int Count; /* count */
};
/*
* interrupt clear type
*/
enum RSC_IRQ_CLEAR_ENUM {
RSC_IRQ_CLEAR_NONE, /* non-clear wait, clear after wait */
RSC_IRQ_CLEAR_WAIT, /* clear wait, clear before and after wait */
RSC_IRQ_WAIT_CLEAR,
/* wait the signal and clear it, avoid hw executime is too s hort. */
RSC_IRQ_CLEAR_STATUS, /* clear specific status only */
RSC_IRQ_CLEAR_ALL /* clear all status */
};
/*
* module's interrupt , each module should have its own isr.
* note:
* mapping to isr table,ISR_TABLE when using no device tree
*/
enum RSC_IRQ_TYPE_ENUM {
RSC_IRQ_TYPE_INT_RSC_ST, /* RSC */
RSC_IRQ_TYPE_AMOUNT
};
struct RSC_WAIT_IRQ_STRUCT {
enum RSC_IRQ_CLEAR_ENUM Clear;
enum RSC_IRQ_TYPE_ENUM Type;
unsigned int Status; /*IRQ Status */
unsigned int Timeout;
int UserKey; /* user key for doing interrupt operation */
int ProcessID; /* user ProcessID (will filled in kernel) */
unsigned int bDumpReg; /* check dump register or not */
};
struct RSC_CLEAR_IRQ_STRUCT {
enum RSC_IRQ_TYPE_ENUM Type;
int UserKey; /* user key for doing interrupt operation */
unsigned int Status; /* Input */
};
struct RSC_Config {
unsigned int RSC_CTRL;
unsigned int RSC_SIZE;
unsigned int RSC_IMGI_C_BASE_ADDR;
unsigned int RSC_IMGI_C_FD;
unsigned int RSC_IMGI_C_OFFSET;
unsigned int RSC_IMGI_C_STRIDE;
unsigned int RSC_IMGI_P_BASE_ADDR;
unsigned int RSC_IMGI_P_FD;
unsigned int RSC_IMGI_P_OFFSET;
unsigned int RSC_IMGI_P_STRIDE;
unsigned int RSC_MVI_BASE_ADDR;
unsigned int RSC_MVI_FD;
unsigned int RSC_MVI_OFFSET;
unsigned int RSC_MVI_STRIDE;
unsigned int RSC_APLI_C_BASE_ADDR;
unsigned int RSC_APLI_C_FD;
unsigned int RSC_APLI_C_OFFSET;
unsigned int RSC_APLI_P_BASE_ADDR;
unsigned int RSC_APLI_P_FD;
unsigned int RSC_APLI_P_OFFSET;
unsigned int RSC_MVO_BASE_ADDR;
unsigned int RSC_MVO_FD;
unsigned int RSC_MVO_OFFSET;
unsigned int RSC_MVO_STRIDE;
unsigned int RSC_BVO_BASE_ADDR;
unsigned int RSC_BVO_FD;
unsigned int RSC_BVO_OFFSET;
unsigned int RSC_BVO_STRIDE;
#define RSC_TUNABLE
#ifdef RSC_TUNABLE
unsigned int RSC_MV_OFFSET;
unsigned int RSC_GMV_OFFSET;
unsigned int RSC_CAND_NUM;
unsigned int RSC_RAND_HORZ_LUT;
unsigned int RSC_RAND_VERT_LUT;
unsigned int RSC_SAD_CTRL;
unsigned int RSC_SAD_EDGE_GAIN_CTRL;
unsigned int RSC_SAD_CRNR_GAIN_CTRL;
unsigned int RSC_STILL_STRIP_CTRL0;
unsigned int RSC_STILL_STRIP_CTRL1;
unsigned int RSC_RAND_PNLTY_CTRL;
unsigned int RSC_RAND_PNLTY_GAIN_CTRL0;
unsigned int RSC_RAND_PNLTY_GAIN_CTRL1;
#endif
unsigned int RSC_STA_0;
};
/*
*
*/
enum RSC_CMD_ENUM {
RSC_CMD_RESET, /* Reset */
RSC_CMD_DUMP_REG, /* Dump RSC Register */
RSC_CMD_DUMP_ISR_LOG, /* Dump RSC ISR log */
RSC_CMD_READ_REG, /* Read register from driver */
RSC_CMD_WRITE_REG, /* Write register to driver */
RSC_CMD_WAIT_IRQ, /* Wait IRQ */
RSC_CMD_CLEAR_IRQ, /* Clear IRQ */
RSC_CMD_ENQUE_NUM, /* RSC Enque Number */
RSC_CMD_ENQUE, /* RSC Enque */
RSC_CMD_ENQUE_REQ, /* RSC Enque Request */
RSC_CMD_DEQUE_NUM, /* RSC Deque Number */
RSC_CMD_DEQUE, /* RSC Deque */
RSC_CMD_DEQUE_REQ, /* RSC Deque Request */
RSC_CMD_TOTAL,
};
struct RSC_Request {
unsigned int m_ReqNum;
struct RSC_Config *m_pRscConfig;
};
#ifdef CONFIG_COMPAT
struct compat_RSC_REG_IO_STRUCT {
compat_uptr_t pData;
unsigned int Count; /* count */
};
struct compat_RSC_Request {
unsigned int m_ReqNum;
compat_uptr_t m_pRscConfig;
};
#endif
#define RSC_RESET _IO(RSC_MAGIC, RSC_CMD_RESET)
#define RSC_DUMP_REG _IO(RSC_MAGIC, RSC_CMD_DUMP_REG)
#define RSC_DUMP_ISR_LOG _IO(RSC_MAGIC, RSC_CMD_DUMP_ISR_LOG)
#define RSC_READ_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_READ_REG, struct RSC_REG_IO_STRUCT)
#define RSC_WRITE_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_WRITE_REG, struct RSC_REG_IO_STRUCT)
#define RSC_WAIT_IRQ \
_IOW(RSC_MAGIC, RSC_CMD_WAIT_IRQ, struct RSC_WAIT_IRQ_STRUCT)
#define RSC_CLEAR_IRQ \
_IOW(RSC_MAGIC, RSC_CMD_CLEAR_IRQ, struct RSC_CLEAR_IRQ_STRUCT)
#define RSC_ENQNUE_NUM _IOW(RSC_MAGIC, RSC_CMD_ENQUE_NUM, int)
#define RSC_ENQUE _IOWR(RSC_MAGIC, RSC_CMD_ENQUE, struct RSC_Config)
#define RSC_ENQUE_REQ _IOWR(RSC_MAGIC, RSC_CMD_ENQUE_REQ, struct RSC_Request)
#define RSC_DEQUE_NUM _IOR(RSC_MAGIC, RSC_CMD_DEQUE_NUM, int)
#define RSC_DEQUE _IOWR(RSC_MAGIC, RSC_CMD_DEQUE, struct RSC_Config)
#define RSC_DEQUE_REQ _IOWR(RSC_MAGIC, RSC_CMD_DEQUE_REQ, struct RSC_Request)
#ifdef CONFIG_COMPAT
#define COMPAT_RSC_WRITE_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_WRITE_REG, struct compat_RSC_REG_IO_STRUCT)
#define COMPAT_RSC_READ_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_READ_REG, struct compat_RSC_REG_IO_STRUCT)
#define COMPAT_RSC_ENQUE_REQ \
_IOWR(RSC_MAGIC, RSC_CMD_ENQUE_REQ, struct compat_RSC_Request)
#define COMPAT_RSC_DEQUE_REQ \
_IOWR(RSC_MAGIC, RSC_CMD_DEQUE_REQ, struct compat_RSC_Request)
#endif
#endif
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,226 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef _MT_RSC_H
#define _MT_RSC_H
#include <linux/ioctl.h>
#ifdef CONFIG_COMPAT
/* 64 bit */
#include <linux/fs.h>
#include <linux/compat.h>
#endif
/*
* enforce kernel log enable
*/
#define KERNEL_LOG /* enable debug log flag if defined */
#define _SUPPORT_MAX_RSC_FRAME_REQUEST_ 6
#define _SUPPORT_MAX_RSC_REQUEST_RING_SIZE_ 4
#define SIG_ERESTARTSYS 512 /* ERESTARTSYS */
/*
*
*/
#define RSC_DEV_MAJOR_NUMBER 251
#define RSC_MAGIC 'r'
#define RSC_REG_RANGE (0x1000)
#define RSC_BASE_HW 0x1b003000
/*This macro is for setting irq status represnted
* by a local variable,RSCInfo.IrqInfo.Status[RSC_IRQ_TYPE_INT_RSC_ST]
*/
#define RSC_INT_ST (1<<0)
struct RSC_REG_STRUCT {
unsigned int module;
unsigned int Addr; /* register's addr */
unsigned int Val; /* register's value */
};
struct RSC_REG_IO_STRUCT {
struct RSC_REG_STRUCT *pData; /* pointer to RSC_REG_STRUCT */
unsigned int Count; /* count */
};
/*
* interrupt clear type
*/
enum RSC_IRQ_CLEAR_ENUM {
RSC_IRQ_CLEAR_NONE, /* non-clear wait, clear after wait */
RSC_IRQ_CLEAR_WAIT, /* clear wait, clear before and after wait */
RSC_IRQ_WAIT_CLEAR,
/* wait the signal and clear it, avoid hw executime is too s hort. */
RSC_IRQ_CLEAR_STATUS, /* clear specific status only */
RSC_IRQ_CLEAR_ALL /* clear all status */
};
/*
* module's interrupt , each module should have its own isr.
* note:
* mapping to isr table,ISR_TABLE when using no device tree
*/
enum RSC_IRQ_TYPE_ENUM {
RSC_IRQ_TYPE_INT_RSC_ST, /* RSC */
RSC_IRQ_TYPE_AMOUNT
};
struct RSC_WAIT_IRQ_STRUCT {
enum RSC_IRQ_CLEAR_ENUM Clear;
enum RSC_IRQ_TYPE_ENUM Type;
unsigned int Status; /*IRQ Status */
unsigned int Timeout;
int UserKey; /* user key for doing interrupt operation */
int ProcessID; /* user ProcessID (will filled in kernel) */
unsigned int bDumpReg; /* check dump register or not */
};
struct RSC_CLEAR_IRQ_STRUCT {
enum RSC_IRQ_TYPE_ENUM Type;
int UserKey; /* user key for doing interrupt operation */
unsigned int Status; /* Input */
};
struct RSC_Config {
unsigned int RSC_CTRL;
unsigned int RSC_SIZE;
unsigned int RSC_IMGI_C_BASE_ADDR;
unsigned int RSC_IMGI_C_FD;
unsigned int RSC_IMGI_C_OFFSET;
unsigned int RSC_IMGI_C_STRIDE;
unsigned int RSC_IMGI_P_BASE_ADDR;
unsigned int RSC_IMGI_P_FD;
unsigned int RSC_IMGI_P_OFFSET;
unsigned int RSC_IMGI_P_STRIDE;
unsigned int RSC_MVI_BASE_ADDR;
unsigned int RSC_MVI_FD;
unsigned int RSC_MVI_OFFSET;
unsigned int RSC_MVI_STRIDE;
unsigned int RSC_APLI_C_BASE_ADDR;
unsigned int RSC_APLI_C_FD;
unsigned int RSC_APLI_C_OFFSET;
unsigned int RSC_APLI_P_BASE_ADDR;
unsigned int RSC_APLI_P_FD;
unsigned int RSC_APLI_P_OFFSET;
unsigned int RSC_MVO_BASE_ADDR;
unsigned int RSC_MVO_FD;
unsigned int RSC_MVO_OFFSET;
unsigned int RSC_MVO_STRIDE;
unsigned int RSC_BVO_BASE_ADDR;
unsigned int RSC_BVO_FD;
unsigned int RSC_BVO_OFFSET;
unsigned int RSC_BVO_STRIDE;
#define RSC_TUNABLE
#ifdef RSC_TUNABLE
unsigned int RSC_MV_OFFSET;
unsigned int RSC_GMV_OFFSET;
unsigned int RSC_CAND_NUM;
unsigned int RSC_RAND_HORZ_LUT;
unsigned int RSC_RAND_VERT_LUT;
unsigned int RSC_SAD_CTRL;
unsigned int RSC_SAD_EDGE_GAIN_CTRL;
unsigned int RSC_SAD_CRNR_GAIN_CTRL;
unsigned int RSC_STILL_STRIP_CTRL0;
unsigned int RSC_STILL_STRIP_CTRL1;
unsigned int RSC_RAND_PNLTY_CTRL;
unsigned int RSC_RAND_PNLTY_GAIN_CTRL0;
unsigned int RSC_RAND_PNLTY_GAIN_CTRL1;
#endif
unsigned int RSC_STA_0;
};
/*
*
*/
enum RSC_CMD_ENUM {
RSC_CMD_RESET, /* Reset */
RSC_CMD_DUMP_REG, /* Dump RSC Register */
RSC_CMD_DUMP_ISR_LOG, /* Dump RSC ISR log */
RSC_CMD_READ_REG, /* Read register from driver */
RSC_CMD_WRITE_REG, /* Write register to driver */
RSC_CMD_WAIT_IRQ, /* Wait IRQ */
RSC_CMD_CLEAR_IRQ, /* Clear IRQ */
RSC_CMD_ENQUE_NUM, /* RSC Enque Number */
RSC_CMD_ENQUE, /* RSC Enque */
RSC_CMD_ENQUE_REQ, /* RSC Enque Request */
RSC_CMD_DEQUE_NUM, /* RSC Deque Number */
RSC_CMD_DEQUE, /* RSC Deque */
RSC_CMD_DEQUE_REQ, /* RSC Deque Request */
RSC_CMD_TOTAL,
};
/* */
struct RSC_Request {
unsigned int m_ReqNum;
struct RSC_Config *m_pRscConfig;
};
#ifdef CONFIG_COMPAT
struct compat_RSC_REG_IO_STRUCT {
compat_uptr_t pData;
unsigned int Count; /* count */
};
struct compat_RSC_Request {
unsigned int m_ReqNum;
compat_uptr_t m_pRscConfig;
};
#endif
#define RSC_RESET _IO(RSC_MAGIC, RSC_CMD_RESET)
#define RSC_DUMP_REG _IO(RSC_MAGIC, RSC_CMD_DUMP_REG)
#define RSC_DUMP_ISR_LOG _IO(RSC_MAGIC, RSC_CMD_DUMP_ISR_LOG)
#define RSC_READ_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_READ_REG, struct RSC_REG_IO_STRUCT)
#define RSC_WRITE_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_WRITE_REG, struct RSC_REG_IO_STRUCT)
#define RSC_WAIT_IRQ \
_IOW(RSC_MAGIC, RSC_CMD_WAIT_IRQ, struct RSC_WAIT_IRQ_STRUCT)
#define RSC_CLEAR_IRQ \
_IOW(RSC_MAGIC, RSC_CMD_CLEAR_IRQ, struct RSC_CLEAR_IRQ_STRUCT)
#define RSC_ENQNUE_NUM _IOW(RSC_MAGIC, RSC_CMD_ENQUE_NUM, int)
#define RSC_ENQUE _IOWR(RSC_MAGIC, RSC_CMD_ENQUE, struct RSC_Config)
#define RSC_ENQUE_REQ _IOWR(RSC_MAGIC, RSC_CMD_ENQUE_REQ, struct RSC_Request)
#define RSC_DEQUE_NUM _IOR(RSC_MAGIC, RSC_CMD_DEQUE_NUM, int)
#define RSC_DEQUE _IOWR(RSC_MAGIC, RSC_CMD_DEQUE, struct RSC_Config)
#define RSC_DEQUE_REQ _IOWR(RSC_MAGIC, RSC_CMD_DEQUE_REQ, struct RSC_Request)
#ifdef CONFIG_COMPAT
#define COMPAT_RSC_WRITE_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_WRITE_REG, struct compat_RSC_REG_IO_STRUCT)
#define COMPAT_RSC_READ_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_READ_REG, struct compat_RSC_REG_IO_STRUCT)
#define COMPAT_RSC_ENQUE_REQ \
_IOWR(RSC_MAGIC, RSC_CMD_ENQUE_REQ, struct compat_RSC_Request)
#define COMPAT_RSC_DEQUE_REQ \
_IOWR(RSC_MAGIC, RSC_CMD_DEQUE_REQ, struct compat_RSC_Request)
#endif
/* */
#endif
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,226 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_RSC_H
#define _MT_RSC_H
#include <linux/ioctl.h>
#ifdef CONFIG_COMPAT
/* 64 bit */
#include <linux/fs.h>
#include <linux/compat.h>
#endif
/*
* enforce kernel log enable
*/
#define KERNEL_LOG /* enable debug log flag if defined */
#define _SUPPORT_MAX_RSC_FRAME_REQUEST_ 6
#define _SUPPORT_MAX_RSC_REQUEST_RING_SIZE_ 4
#define SIG_ERESTARTSYS 512 /* ERESTARTSYS */
/*
*
*/
#define RSC_DEV_MAJOR_NUMBER 251
#define RSC_MAGIC 'r'
#define RSC_REG_RANGE (0x1000)
#define RSC_BASE_HW 0x15029000
/*This macro is for setting irq status represnted
* by a local variable,RSCInfo.IrqInfo.Status[RSC_IRQ_TYPE_INT_RSC_ST]
*/
#define RSC_INT_ST (1<<0)
struct RSC_REG_STRUCT {
unsigned int module;
unsigned int Addr; /* register's addr */
unsigned int Val; /* register's value */
};
struct RSC_REG_IO_STRUCT {
struct RSC_REG_STRUCT *pData; /* pointer to RSC_REG_STRUCT */
unsigned int Count; /* count */
};
/*
* interrupt clear type
*/
enum RSC_IRQ_CLEAR_ENUM {
RSC_IRQ_CLEAR_NONE, /* non-clear wait, clear after wait */
RSC_IRQ_CLEAR_WAIT, /* clear wait, clear before and after wait */
RSC_IRQ_WAIT_CLEAR,
/* wait the signal and clear it, avoid hw executime is too s hort. */
RSC_IRQ_CLEAR_STATUS, /* clear specific status only */
RSC_IRQ_CLEAR_ALL /* clear all status */
};
/*
* module's interrupt , each module should have its own isr.
* note:
* mapping to isr table,ISR_TABLE when using no device tree
*/
enum RSC_IRQ_TYPE_ENUM {
RSC_IRQ_TYPE_INT_RSC_ST, /* RSC */
RSC_IRQ_TYPE_AMOUNT
};
struct RSC_WAIT_IRQ_STRUCT {
enum RSC_IRQ_CLEAR_ENUM Clear;
enum RSC_IRQ_TYPE_ENUM Type;
unsigned int Status; /*IRQ Status */
unsigned int Timeout;
int UserKey; /* user key for doing interrupt operation */
int ProcessID; /* user ProcessID (will filled in kernel) */
unsigned int bDumpReg; /* check dump register or not */
};
struct RSC_CLEAR_IRQ_STRUCT {
enum RSC_IRQ_TYPE_ENUM Type;
int UserKey; /* user key for doing interrupt operation */
unsigned int Status; /* Input */
};
struct RSC_Config {
unsigned int RSC_CTRL;
unsigned int RSC_SIZE;
unsigned int RSC_IMGI_C_BASE_ADDR;
unsigned int RSC_IMGI_C_FD;
unsigned int RSC_IMGI_C_OFFSET;
unsigned int RSC_IMGI_C_STRIDE;
unsigned int RSC_IMGI_P_BASE_ADDR;
unsigned int RSC_IMGI_P_FD;
unsigned int RSC_IMGI_P_OFFSET;
unsigned int RSC_IMGI_P_STRIDE;
unsigned int RSC_MVI_BASE_ADDR;
unsigned int RSC_MVI_FD;
unsigned int RSC_MVI_OFFSET;
unsigned int RSC_MVI_STRIDE;
unsigned int RSC_APLI_C_BASE_ADDR;
unsigned int RSC_APLI_C_FD;
unsigned int RSC_APLI_C_OFFSET;
unsigned int RSC_APLI_P_BASE_ADDR;
unsigned int RSC_APLI_P_FD;
unsigned int RSC_APLI_P_OFFSET;
unsigned int RSC_MVO_BASE_ADDR;
unsigned int RSC_MVO_FD;
unsigned int RSC_MVO_OFFSET;
unsigned int RSC_MVO_STRIDE;
unsigned int RSC_BVO_BASE_ADDR;
unsigned int RSC_BVO_FD;
unsigned int RSC_BVO_OFFSET;
unsigned int RSC_BVO_STRIDE;
#define RSC_TUNABLE
#ifdef RSC_TUNABLE
unsigned int RSC_MV_OFFSET;
unsigned int RSC_GMV_OFFSET;
unsigned int RSC_CAND_NUM;
unsigned int RSC_RAND_HORZ_LUT;
unsigned int RSC_RAND_VERT_LUT;
unsigned int RSC_SAD_CTRL;
unsigned int RSC_SAD_EDGE_GAIN_CTRL;
unsigned int RSC_SAD_CRNR_GAIN_CTRL;
unsigned int RSC_STILL_STRIP_CTRL0;
unsigned int RSC_STILL_STRIP_CTRL1;
unsigned int RSC_RAND_PNLTY_CTRL;
unsigned int RSC_RAND_PNLTY_GAIN_CTRL0;
unsigned int RSC_RAND_PNLTY_GAIN_CTRL1;
#endif
unsigned int RSC_STA_0;
};
/*
*
*/
enum RSC_CMD_ENUM {
RSC_CMD_RESET, /* Reset */
RSC_CMD_DUMP_REG, /* Dump RSC Register */
RSC_CMD_DUMP_ISR_LOG, /* Dump RSC ISR log */
RSC_CMD_READ_REG, /* Read register from driver */
RSC_CMD_WRITE_REG, /* Write register to driver */
RSC_CMD_WAIT_IRQ, /* Wait IRQ */
RSC_CMD_CLEAR_IRQ, /* Clear IRQ */
RSC_CMD_ENQUE_NUM, /* RSC Enque Number */
RSC_CMD_ENQUE, /* RSC Enque */
RSC_CMD_ENQUE_REQ, /* RSC Enque Request */
RSC_CMD_DEQUE_NUM, /* RSC Deque Number */
RSC_CMD_DEQUE, /* RSC Deque */
RSC_CMD_DEQUE_REQ, /* RSC Deque Request */
RSC_CMD_TOTAL,
};
/* */
struct RSC_Request {
unsigned int m_ReqNum;
struct RSC_Config *m_pRscConfig;
};
#ifdef CONFIG_COMPAT
struct compat_RSC_REG_IO_STRUCT {
compat_uptr_t pData;
unsigned int Count; /* count */
};
struct compat_RSC_Request {
unsigned int m_ReqNum;
compat_uptr_t m_pRscConfig;
};
#endif
#define RSC_RESET _IO(RSC_MAGIC, RSC_CMD_RESET)
#define RSC_DUMP_REG _IO(RSC_MAGIC, RSC_CMD_DUMP_REG)
#define RSC_DUMP_ISR_LOG _IO(RSC_MAGIC, RSC_CMD_DUMP_ISR_LOG)
#define RSC_READ_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_READ_REG, struct RSC_REG_IO_STRUCT)
#define RSC_WRITE_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_WRITE_REG, struct RSC_REG_IO_STRUCT)
#define RSC_WAIT_IRQ \
_IOW(RSC_MAGIC, RSC_CMD_WAIT_IRQ, struct RSC_WAIT_IRQ_STRUCT)
#define RSC_CLEAR_IRQ \
_IOW(RSC_MAGIC, RSC_CMD_CLEAR_IRQ, struct RSC_CLEAR_IRQ_STRUCT)
#define RSC_ENQNUE_NUM _IOW(RSC_MAGIC, RSC_CMD_ENQUE_NUM, int)
#define RSC_ENQUE _IOWR(RSC_MAGIC, RSC_CMD_ENQUE, struct RSC_Config)
#define RSC_ENQUE_REQ _IOWR(RSC_MAGIC, RSC_CMD_ENQUE_REQ, struct RSC_Request)
#define RSC_DEQUE_NUM _IOR(RSC_MAGIC, RSC_CMD_DEQUE_NUM, int)
#define RSC_DEQUE _IOWR(RSC_MAGIC, RSC_CMD_DEQUE, struct RSC_Config)
#define RSC_DEQUE_REQ _IOWR(RSC_MAGIC, RSC_CMD_DEQUE_REQ, struct RSC_Request)
#ifdef CONFIG_COMPAT
#define COMPAT_RSC_WRITE_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_WRITE_REG, struct compat_RSC_REG_IO_STRUCT)
#define COMPAT_RSC_READ_REGISTER \
_IOWR(RSC_MAGIC, RSC_CMD_READ_REG, struct compat_RSC_REG_IO_STRUCT)
#define COMPAT_RSC_ENQUE_REQ \
_IOWR(RSC_MAGIC, RSC_CMD_ENQUE_REQ, struct compat_RSC_Request)
#define COMPAT_RSC_DEQUE_REQ \
_IOWR(RSC_MAGIC, RSC_CMD_DEQUE_REQ, struct compat_RSC_Request)
#endif
/* */
#endif