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,37 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#ifndef __CCU_DRV_PUBK__
#define __CCU_DRV_PUBK__
#define CCU_DRV_PUBK_SZ 270
#define CCU_DRV_PUBK \
uint8_t g_ccu_drv_pubk[CCU_DRV_PUBK_SZ] = {\
0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xbd, \
0xd1, 0x8f, 0xda, 0x1c, 0x84, 0x3c, 0x4a, 0x29, 0x01, 0xa3, \
0x98, 0x60, 0xe4, 0xc0, 0x61, 0x77, 0x48, 0xc4, 0x41, 0x09, \
0x7e, 0xcc, 0xb8, 0x15, 0xa6, 0xd1, 0xfd, 0x87, 0xcd, 0x87, \
0xe1, 0x9e, 0x37, 0x2d, 0x97, 0x0d, 0xc7, 0x12, 0xf8, 0x99, \
0x3f, 0x5f, 0x4b, 0x16, 0x11, 0x9b, 0xed, 0x9e, 0xfd, 0x36, \
0x66, 0x6c, 0xe1, 0x4b, 0x99, 0x28, 0x86, 0xe0, 0x48, 0xcd, \
0xd9, 0x49, 0x88, 0xca, 0xb6, 0x01, 0x8f, 0xd3, 0xf5, 0xcb, \
0x63, 0xee, 0x53, 0x5c, 0xac, 0xc0, 0x93, 0x34, 0xe7, 0x15, \
0x6f, 0x2a, 0xee, 0x0e, 0xab, 0xe9, 0xb2, 0x5f, 0x55, 0x44, \
0xe6, 0x66, 0xfa, 0xbc, 0x88, 0xf6, 0xb4, 0x32, 0x9a, 0x5e, \
0x04, 0x36, 0x3f, 0xfd, 0x90, 0x8a, 0x2b, 0x7f, 0x42, 0xa7, \
0x2f, 0xe8, 0x60, 0x1d, 0x7c, 0x99, 0xb2, 0x80, 0x37, 0x93, \
0x07, 0x80, 0x18, 0xf9, 0xab, 0xfa, 0xfa, 0xa1, 0x6e, 0x36, \
0x63, 0xe6, 0x0f, 0x0c, 0xce, 0xee, 0xb8, 0x87, 0x88, 0x25, \
0x40, 0x39, 0xc3, 0x57, 0xa9, 0xf6, 0x7d, 0x20, 0xa2, 0x85, \
0xd9, 0xe0, 0x21, 0x80, 0x6a, 0xbd, 0xb3, 0x75, 0xeb, 0xf1, \
0xbf, 0x78, 0xaf, 0xa7, 0xe7, 0x7e, 0x6d, 0xa3, 0xf4, 0x7c, \
0xc0, 0xa4, 0xfe, 0x3f, 0xaf, 0xc0, 0x32, 0x32, 0xe4, 0x5d, \
0x40, 0x31, 0x4d, 0xcf, 0xa4, 0xfa, 0xe6, 0x6a, 0xe6, 0x48, \
0x8f, 0xbb, 0xea, 0x15, 0xb8, 0xe8, 0x07, 0x40, 0xae, 0x16, \
0x1d, 0xa5, 0x02, 0xb5, 0x23, 0x45, 0xfb, 0x34, 0x1a, 0x40, \
0x49, 0x80, 0xd2, 0x13, 0x04, 0x85, 0x71, 0x35, 0xf4, 0x05, \
0x19, 0x5e, 0xbb, 0x99, 0x15, 0x13, 0x61, 0xcf, 0xc7, 0xd3, \
0xb8, 0xf1, 0xec, 0xc4, 0x56, 0xac, 0xff, 0x70, 0x54, 0xe1, \
0xd1, 0x51, 0x33, 0x01, 0x1f, 0xd5, 0x8d, 0xb6, 0x36, 0x9c, \
0xb6, 0x18, 0x41, 0x37, 0xf7, 0x02, 0x03, 0x01, 0x00, 0x01}
#endif /*__CCU_DRV_PUBK__*/
@@ -0,0 +1,37 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#ifndef __CCU_FW_PUBK__
#define __CCU_FW_PUBK__
#define CCU_FW_PUBK_SZ 270
#define CCU_FW_PUBK \
uint8_t g_ccu_pubk[CCU_FW_PUBK_SZ] = {\
0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xab, \
0xde, 0x45, 0x55, 0x09, 0xca, 0xbf, 0x4c, 0x34, 0xef, 0x8d, \
0xdd, 0x1b, 0xd2, 0xda, 0x49, 0x83, 0x85, 0x4e, 0x08, 0xbb, \
0xf6, 0x05, 0xdc, 0xd6, 0x40, 0xb8, 0x3c, 0x9a, 0xb9, 0x2e, \
0x62, 0x81, 0xb7, 0x9f, 0xcd, 0x11, 0xeb, 0xba, 0x2d, 0x03, \
0x65, 0xdd, 0xb5, 0xdc, 0x9c, 0xfb, 0x46, 0x81, 0xc9, 0xc7, \
0x02, 0x0a, 0xee, 0x41, 0xec, 0xce, 0x01, 0xd9, 0x6e, 0x8d, \
0x84, 0x9d, 0xa9, 0xc3, 0xd5, 0x74, 0x8f, 0xd1, 0x84, 0x4d, \
0x65, 0x6a, 0x0d, 0xc9, 0xb0, 0xf7, 0x4d, 0x64, 0x7b, 0xb0, \
0x37, 0x46, 0x35, 0xcd, 0x0f, 0xf7, 0x3b, 0x89, 0xca, 0x03, \
0x40, 0x0e, 0x8a, 0x2d, 0x0a, 0xa3, 0xd2, 0xd3, 0xae, 0x5c, \
0xea, 0x8d, 0x61, 0x08, 0xb3, 0x69, 0x10, 0x5c, 0x18, 0x43, \
0x20, 0x38, 0x2d, 0x2f, 0xdf, 0x05, 0x7c, 0xba, 0x50, 0xc1, \
0xc0, 0xd4, 0xc8, 0x3b, 0xbc, 0x6f, 0x1b, 0x89, 0xb6, 0xfe, \
0xee, 0xeb, 0x8e, 0x56, 0xcd, 0xc7, 0x2d, 0xd3, 0x2d, 0x7d, \
0x83, 0x30, 0x7a, 0x49, 0x83, 0xa5, 0x8e, 0x31, 0x6d, 0x28, \
0x16, 0x35, 0x63, 0xe4, 0x44, 0xf5, 0x98, 0x98, 0xd6, 0x6c, \
0x7a, 0x9c, 0x78, 0xd0, 0x62, 0xae, 0x25, 0xd0, 0x0e, 0x8a, \
0x87, 0x08, 0x8b, 0xe5, 0xb3, 0x70, 0x9f, 0x9b, 0x67, 0xc2, \
0x9f, 0x76, 0x58, 0x07, 0xee, 0x0e, 0xc5, 0x1f, 0x63, 0x40, \
0xca, 0x25, 0xd0, 0x3d, 0xb8, 0xeb, 0xc7, 0x50, 0x4e, 0x92, \
0x6b, 0x4a, 0x18, 0x06, 0xc7, 0xc2, 0xbb, 0xc5, 0xbb, 0x74, \
0xa2, 0xb0, 0xce, 0x9c, 0x1a, 0xec, 0x55, 0x93, 0x28, 0x6e, \
0x7a, 0x6d, 0x56, 0x90, 0xc1, 0x8e, 0xb6, 0xd7, 0xd3, 0x1b, \
0x1f, 0xca, 0xbf, 0xde, 0xd4, 0x43, 0x1d, 0x1c, 0xbf, 0x8f, \
0xad, 0xff, 0xf8, 0x57, 0xbe, 0x96, 0xba, 0xc0, 0xae, 0x10, \
0xbc, 0x8e, 0xa0, 0x29, 0x0f, 0x02, 0x03, 0x01, 0x00, 0x01}
#endif /*__CCU_FW_PUBK__*/
@@ -0,0 +1,18 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef _CCU_IMGSENSOR_IF_H_
#define _CCU_IMGSENSOR_IF_H_
struct ccu_sensor_info {
int32_t slave_addr;
int32_t i2c_id;
char *sensor_name_string;
};
void ccu_set_current_fps(int32_t sensorType, int32_t current_fps);
void ccu_set_sensor_info(int32_t sensorType, struct ccu_sensor_info *info);
#endif
+20
View File
@@ -0,0 +1,20 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_INC_H__
#define __CCU_INC_H__
struct ccu_sensor_info {
int32_t slave_addr;
int32_t i2c_id;
char *sensor_name_string;
};
void ccu_set_current_fps(int32_t current_fps);
void ccu_set_sensor_info(int32_t sensorType, struct ccu_sensor_info *info);
void ccu_get_timestamp(uint32_t *low, uint32_t *high);
#endif
@@ -0,0 +1,10 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef _CCU_LENS_IF_H_
#define _CCU_LENS_IF_H_
void ccu_set_lens_info(int32_t sensorType, char *lens_name);
#endif
@@ -0,0 +1,33 @@
#
# 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_MTK_ION),y)
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion/
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion/mtk/
else
ccflags-$(CONFIG_ION) += -I$(srctree)/drivers/staging/android/aosp_ion/
endif
ccflags-y += -I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/$(MTK_PLATFORM)/ccu_ext_interface/
ccflags-y += -I$(srctree)/drivers/i2c/busses
ccflags-y += -I$(srctree)/drivers/misc/mediatek/imgsensor/inc
ccflags-y += -I$(srctree)/drivers/iommu/
$(warning CCU_INC=$(srctree)/drivers/misc/mediatek/ccu/src/$(MTK_PLATFORM)/ccu_ext_interface)
#$(warning $(subdir-ccflags-y))
#obj-$(CONFIG_MTK_VPU) += ccu_drv.o ccu_algo.o ccu_dbg.o
obj-y += ccu_drv.o ccu_n3d_a.o ccu_i2c.o
+302
View File
@@ -0,0 +1,302 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_CMN_H__
#define __CCU_CMN_H__
#include <linux/wait.h>
#include <linux/seq_file.h>
#include <linux/interrupt.h>
#include "ccu_drv.h"
#include "ccu_i2c.h"
#ifdef MTK_CCU_EMULATOR
/*#define CCUI_OF_M4U_PORT M4U_PORT_CAM_IMGI*/
/*#define CCUI_OF_M4U_PORT M4U_PORT_CAM_CCUI*/
/*#define CCUO_OF_M4U_PORT M4U_PORT_CAM_CCUO*/
/*#define CCUG_OF_M4U_PORT M4U_PORT_CAM_CCUG*/
#else
#define CCUI_OF_M4U_PORT M4U_PORT_CAM_CCUI
#define CCUO_OF_M4U_PORT M4U_PORT_CAM_CCUO
#define CCUG_OF_M4U_PORT M4U_PORT_CAM_CCUG
#endif
/* Common Structure */
enum ccu_req_type_e {
CCU_IRQ_TYPE_XXX,
CCU_IRQ_NUM_TYPES
};
struct ccu_device_s {
struct proc_dir_entry *proc_dir;
struct device *dev;
struct dentry *debug_root;
unsigned long ccu_base;
unsigned long camsys_base;
unsigned long bin_base;
unsigned long dmem_base;
unsigned long pmem_base;
unsigned long n3d_a_base;
unsigned int irq_num;
struct mutex dev_mutex;
struct mutex user_mutex;
struct mutex clk_mutex;
/* list of vlist_type(struct ccu_user_s) */
struct list_head user_list;
/* notify enque thread */
wait_queue_head_t cmd_wait;
};
struct ccu_user_s {
pid_t open_pid;
pid_t open_tgid;
uint32_t id;
/* to enque/deque must have mutex protection */
struct mutex data_mutex;
bool running;
bool flush;
/* list of vlist_type(struct ccu_cmd_s) */
struct list_head enque_ccu_cmd_list;
struct list_head deque_ccu_cmd_list;
wait_queue_head_t deque_wait;
};
/*type must be struct*/
/*#define DECLARE_VLIST(type) \*/
/*typedef struct { \*/
/*type node; \*/
/*struct list_head link; \*/
/*} type ## _list*/
/*
* vlist_node_of - get the pointer to the node which has specific vlist
* @ptr: the pointer to struct list_head
* @type: the type of list node
*/
#define vlist_node_of(ptr, type) ({ \
const struct list_head *__mptr = (ptr); \
(type *)((char *)__mptr - offsetof(type ## _list, link)); })
/*
* vlist_link - get the pointer to struct list_head
* @ptr: the pointer to struct vlist
* @type: the type of list node
*/
#define vlist_link(ptr, type) (&((type ## _list *)ptr)->link)
/*
* vlist_type - get the type of struct vlist
* @type: the type of list node
*/
#define vlist_type(type) type ## _list
/*
* vlist_node - get the pointer to the node of vlist
* @ptr: the pointer to struct vlist
* @type: the type of list node
*/
#define vlist_node(ptr, type) ((type *) ptr)
/*typedef struct work_struct work_struct_t;*/
/*DECLARE_VLIST(work_struct_t);*/
/*DECLARE_VLIST(struct ccu_user_s);*/
struct ccu_user_s_list {
struct ccu_user_s node;
struct list_head link;
};
/*DECLARE_VLIST(struct ccu_cmd_s);*/
struct ccu_cmd_s_list {
struct ccu_cmd_s node;
struct list_head link;
};
/* ======================== define in ccu_hw.c ========================= */
/**
* ccu_init_hw - init the procedure related to hw,
* include irq register and enque thread
* @device: the pointer of ccu_device.
*/
int ccu_init_hw(struct ccu_device_s *device);
/**
* ccu_uninit_hw - close resources related to hw module
*/
int ccu_uninit_hw(struct ccu_device_s *device);
/**
* ccu_mmap_hw - mmap kernel memory to user
*/
int ccu_mmap_hw(struct file *filp, struct vm_area_struct *vma);
/**
* ccu_send_command - send command, and it will block until done.
* @cmd: the pointer to command
*/
int ccu_send_command(struct ccu_cmd_s *pCmd);
int ccu_kenrel_fast_cmd_enque(struct ccu_cmd_s *cmd);
struct ccu_cmd_s *ccu_kenrel_fast_cmd_deque(void);
/**
* ccu_power - config ccu power.
* @s: the pointer to power relative settings.
*/
int ccu_power(struct ccu_power_s *power);
/**
* ccu_force_powerdown - force CCU to stop & shutdown
*/
int ccu_force_powerdown(void);
/**
* ccu_load_bin - load ccu dm/pm binary.
*/
int ccu_load_bin(struct ccu_device_s *device);
/**
* ccu_run - start running ccu .
*/
int ccu_run(void);
/**
* ccu_irq - interrupt wait.
* @s: wait mode.
*/
int ccu_waitirq(struct CCU_WAIT_IRQ_STRUCT *WaitIrq);
int ccu_flushLog(int argc, int *argv);
/**
* ccu_i2c_ctrl - i2c control.
* @argc: TBD.
* @argv: TBD.
*/
int ccu_i2c_ctrl(unsigned char i2c_write_id, int transfer_len);
int ccu_get_i2c_dma_buf_addr(uint32_t *mva, uint32_t *pa_h,
uint32_t *pa_l, uint32_t *i2c_id);
int ccu_memcpy(void *dest, void *src, int length);
int ccu_memclr(void *dest, int length);
int32_t ccu_get_current_fps(void);
void ccu_get_sensor_i2c_info(struct ccu_i2c_info *sensor_info);
void ccu_get_sensor_name(char **sensor_name);
void ccu_print_reg(uint32_t *Reg);
void ccu_print_sram_log(char *sram_log);
int ccu_query_power_status(void);
/* ======================== define in ccu_drv.c ======================== */
/**
* ccu_create_user - create ccu user, and add to user list
* @ruser: return the created user.
*/
int ccu_create_user(struct ccu_user_s **ruser);
/**
* ccu_delete_user - delete ccu user, and remove it from user list
* @user: the pointer to user.
*/
int ccu_delete_user(struct ccu_user_s *user);
int ccu_lock_user_mutex(void);
int ccu_unlock_user_mutex(void);
/**
* ccu_push_command_to_queue - add a command to user's queue
* @user: the pointer to user.
* @cmd: the command to be added to user's queue.
*/
int ccu_push_command_to_queue(struct ccu_user_s *user, struct ccu_cmd_s *cmd);
/**
* ccu_pop_command_from_queue - remove a command from user's queue
* @user: the pointer to user.
* @rcmd: return the command to be removed.
*/
int ccu_pop_command_from_queue(struct ccu_user_s *user,
struct ccu_cmd_s **rcmd);
/**
* ccu_flush_commands_from_queue - flush all commands of user's queue
* @user: the pointer to user.
*
* It's a blocking call, and waits for the processing command done.
* And push all remaining enque to the deque.
*/
int ccu_flush_commands_from_queue(struct ccu_user_s *user);
/**
* ccu_clock_enable - Set CCU clock on
*/
int ccu_clock_enable(void);
/**
* ccu_clock_disable - Set CCU clock off
*/
void ccu_clock_disable(void);
/* LOG & AEE */
#define CCU_TAG "[ccu]"
#define LOG_DBG_MUST(format, args...) \
pr_debug(CCU_TAG "[%s] " format, __func__, ##args)
#define LOG_INF_MUST(format, args...) \
pr_info(CCU_TAG "[%s] " format, __func__, ##args)
#define LOG_DBG(format, args...)
#define LOG_INF(format, args...)
#define LOG_WARN(format, args...) \
pr##_##warn(CCU_TAG "[%s] " format, __func__, ##args)
#define LOG_ERR(format, args...) \
pr##_##err(CCU_TAG "[%s] " format, __func__, ##args)
#define LOG_DERR(device, format, args...) \
dev##_##err(device, CCU_TAG "[%s] " format, __func__, ##args)
#define ccu_print_seq(seq_file, fmt, args...) \
do {\
if (seq_file)\
seq_printf(seq_file, fmt, ##args);\
else\
pr_debug(fmt, ##args);\
} while (0)
#define ccu_error(format, args...) \
do {\
LOG_ERR(CCU_TAG " error:"format, ##args); \
aee_kernel_exception("CCU", "[CCU] error:"format, ##args); \
} while (0)
#define ccu_aee(format, args...) \
do {\
char ccu_name[100];\
snprintf(ccu_name, 100, CCU_TAG format, ##args); \
aee_kernel_warning_api(__FILE__, __LINE__, \
DB_OPT_MMPROFILE_BUFFER | DB_OPT_DUMP_DISPLAY, \
ccu_name, CCU_TAG "error" format, ##args); \
LOG_ERR(CCU_TAG " error:" format, ##args); \
} while (0)
#define IS_KERNEL_32 ((sizeof(uint32_t *) == 4))
#endif
File diff suppressed because it is too large. Load diff
+330
View File
@@ -0,0 +1,330 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_DRV_H__
#define __CCU_DRV_H__
#include <linux/types.h>
#include <linux/ioctl.h>
#include <linux/wait.h>
#include "ccu_mailbox_extif.h"
#ifdef CONFIG_COMPAT
/*64 bit*/
#include <linux/fs.h>
#include <linux/compat.h>
#endif
/*---------------------------------------------------------------------------*/
/* CCU IRQ */
/*---------------------------------------------------------------------------*/
#define IRQ_USER_NUM_MAX 32
#define SUPPORT_MAX_IRQ 32
enum CCU_IRQ_CLEAR_ENUM {
CCU_IRQ_CLEAR_NONE, /* non-clear wait, clear after wait */
CCU_IRQ_CLEAR_WAIT, /* clear wait, clear before and after wait */
CCU_IRQ_CLEAR_STATUS, /* clear specific status only */
CCU_IRQ_CLEAR_ALL /* clear all status */
};
enum CCU_IRQ_TYPE_ENUM {
CCU_IRQ_TYPE_INT_CCU_ST,
CCU_IRQ_TYPE_INT_CCU_A_ST,
CCU_IRQ_TYPE_INT_CCU_B_ST,
CCU_IRQ_TYPE_AMOUNT
};
enum CCU_ST_ENUM {
CCU_SIGNAL_INT = 0, CCU_DMA_INT, CCU_IRQ_ST_AMOUNT
};
struct CCU_IRQ_TIME_STRUCT {
unsigned int tLastSig_sec;
/* time stamp of the latest occurring signal */
unsigned int tLastSig_usec;
/* time stamp of the latest occurring signal */
unsigned int tMark2WaitSig_sec;
/* time period from marking a signal to
* user try to wait and get the signal
*/
unsigned int tMark2WaitSig_usec;
/* time period from marking a signal to
* user try to wait and get the signal
*/
unsigned int tLastSig2GetSig_sec;
/* time period from latest signal to
* user try to wait and get the signal
*/
unsigned int tLastSig2GetSig_usec;
/* time period from latest signal to
* user try to wait and get the signal
*/
int passedbySigcnt; /* the count for the signal passed by */
};
struct CCU_WAIT_IRQ_ST {
enum CCU_IRQ_CLEAR_ENUM Clear;
enum CCU_ST_ENUM St_type;
unsigned int Status;
int UserKey; /* user key for doing interrupt operation */
unsigned int Timeout;
struct CCU_IRQ_TIME_STRUCT TimeInfo;
};
struct CCU_REGISTER_USERKEY_STRUCT {
int userKey;
char userName[32];
};
struct CCU_WAIT_IRQ_STRUCT {
enum CCU_IRQ_TYPE_ENUM Type;
unsigned int bDumpReg;
struct CCU_WAIT_IRQ_ST EventInfo;
};
struct CCU_CLEAR_IRQ_ST {
int UserKey; /* user key for doing interrupt operation */
enum CCU_ST_ENUM St_type;
unsigned int Status;
};
struct CCU_CLEAR_IRQ_STRUCT {
enum CCU_IRQ_TYPE_ENUM Type;
struct CCU_CLEAR_IRQ_ST EventInfo;
};
struct CCU_REG_STRUCT {
unsigned int module;
unsigned int Addr; /* register's addr */
unsigned int Val; /* register's value */
};
struct CCU_REG_IO_STRUCT {
struct CCU_REG_STRUCT *pData; /* pointer to struct CCU_REG_STRUCT */
unsigned int Count; /* count */
};
struct CCU_IRQ_INFO_STRUCT {
/* Add an extra index for status type in Ever-> signal or dma */
unsigned int Status[CCU_IRQ_TYPE_AMOUNT]
[CCU_IRQ_ST_AMOUNT][IRQ_USER_NUM_MAX];
unsigned int Mask[CCU_IRQ_TYPE_AMOUNT][CCU_IRQ_ST_AMOUNT];
unsigned int ErrMask[CCU_IRQ_TYPE_AMOUNT][CCU_IRQ_ST_AMOUNT];
signed int WarnMask[CCU_IRQ_TYPE_AMOUNT][CCU_IRQ_ST_AMOUNT];
/* flag for indicating that user do mark for a interrupt or not */
unsigned int MarkedFlag[CCU_IRQ_TYPE_AMOUNT]
[CCU_IRQ_ST_AMOUNT][IRQ_USER_NUM_MAX];
/* time for marking a specific interrupt */
unsigned int MarkedTime_sec[CCU_IRQ_TYPE_AMOUNT][32][IRQ_USER_NUM_MAX];
/* time for marking a specific interrupt */
unsigned int MarkedTime_usec[CCU_IRQ_TYPE_AMOUNT][32][IRQ_USER_NUM_MAX];
/* number of a specific signal that passed by */
signed int PassedBySigCnt[CCU_IRQ_TYPE_AMOUNT][32][IRQ_USER_NUM_MAX];
/* */
unsigned int LastestSigTime_sec[CCU_IRQ_TYPE_AMOUNT][32];
/* latest time for each interrupt */
unsigned int LastestSigTime_usec[CCU_IRQ_TYPE_AMOUNT][32];
/* latest time for each interrupt */
};
#define CCU_ISR_MAX_NUM 32
#define INT_ERR_WARN_TIMER_THREAS 1000
#define INT_ERR_WARN_MAX_TIME 3
struct CCU_IRQ_ERR_WAN_CNT_STRUCT {
/* cnt for each err int # */
unsigned int
m_err_int_cnt[CCU_IRQ_TYPE_AMOUNT][CCU_ISR_MAX_NUM];
/* cnt for each warning int # */
unsigned int m_warn_int_cnt[CCU_IRQ_TYPE_AMOUNT][CCU_ISR_MAX_NUM];
/* mark for err int, where its cnt > threshold */
unsigned int m_err_int_mark[CCU_IRQ_TYPE_AMOUNT];
/* mark for warn int, where its cnt > threshold */
unsigned int m_warn_int_mark[CCU_IRQ_TYPE_AMOUNT];
unsigned long m_int_usec[CCU_IRQ_TYPE_AMOUNT];
};
#define CCU_BUF_SIZE (4096)
#define CCU_BUF_SIZE_WRITE 1024
#define CCU_BUF_WRITE_AMOUNT 6
enum CCU_BUF_STATUS_ENUM {
CCU_BUF_STATUS_EMPTY,
CCU_BUF_STATUS_HOLD,
CCU_BUF_STATUS_READY
};
struct CCU_BUF_STRUCT {
enum CCU_BUF_STATUS_ENUM Status;
unsigned int Size;
unsigned char *pData;
};
struct CCU_BUF_INFO_STRUCT {
struct CCU_BUF_STRUCT Read;
struct CCU_BUF_STRUCT Write[CCU_BUF_WRITE_AMOUNT];
};
struct CCU_TIME_LOG_STRUCT {
unsigned int Vd;
unsigned int Expdone;
unsigned int WorkQueueVd;
unsigned int WorkQueueExpdone;
unsigned int TaskletVd;
unsigned int TaskletExpdone;
};
#ifdef MTK_VPU_KERNEL
struct CCU_INFO_STRUCT {
spinlock_t SpinLockCcuRef;
spinlock_t SpinLockCcu;
spinlock_t SpinLockIrq[CCU_IRQ_TYPE_AMOUNT];
spinlock_t SpinLockIrqCnt[CCU_IRQ_TYPE_AMOUNT];
spinlock_t SpinLockRTBC;
spinlock_t SpinLockClock;
spinlock_t SpinLockI2cPower;
unsigned int IsI2cPowerDisabling;
unsigned int IsI2cPoweredOn;
unsigned int IsCcuPoweredOn;
wait_queue_head_t WaitQueueHead;
wait_queue_head_t AFWaitQueueHead[2];
wait_queue_head_t WaitQHeadList[SUPPORT_MAX_IRQ];
unsigned int UserCount;
unsigned int DebugMask;
signed int IrqNum;
struct CCU_IRQ_INFO_STRUCT IrqInfo;
struct CCU_IRQ_ERR_WAN_CNT_STRUCT IrqCntInfo;
struct CCU_BUF_INFO_STRUCT BufInfo;
struct CCU_TIME_LOG_STRUCT TimeLog;
};
#endif
/*---------------------------------------------------------------------------*/
/* CCU working buffer */
/*---------------------------------------------------------------------------*/
#define SIZE_32BYTE (32)
#define SIZE_1MB (1024*1024)
#define SIZE_1MB_PWR2PAGE (8)
#define MAX_I2CBUF_NUM 1
#define MAX_MAILBOX_NUM 2
#define MAX_LOG_BUF_NUM 2
#define MAILBOX_SEND 0
#define MAILBOX_GET 1
struct ccu_working_buffer_s {
uint8_t *va_pool;
uint32_t mva_pool;
uint32_t sz_pool;
uint8_t *va_i2c; /* i2c buffer mode */
uint32_t mva_i2c;
uint32_t sz_i2c;
uint8_t *va_mb[MAX_MAILBOX_NUM]; /* mailbox */
uint32_t mva_mb[MAX_MAILBOX_NUM];
uint32_t sz_mb[MAX_MAILBOX_NUM];
char *va_log[MAX_LOG_BUF_NUM]; /* log buffer */
uint32_t mva_log[MAX_LOG_BUF_NUM];
uint32_t sz_log[MAX_LOG_BUF_NUM];
int32_t fd_log[MAX_LOG_BUF_NUM];
};
#ifdef CONFIG_COMPAT
struct compat_ccu_working_buffer_s {
compat_uptr_t va_pool;
uint32_t mva_pool;
uint32_t sz_pool;
compat_uptr_t va_i2c; /* i2c buffer mode */
uint32_t mva_i2c;
uint32_t sz_i2c;
compat_uptr_t va_mb[MAX_MAILBOX_NUM]; /* mailbox */
uint32_t mva_mb[MAX_MAILBOX_NUM];
uint32_t sz_mb[MAX_MAILBOX_NUM];
compat_uptr_t va_log[MAX_LOG_BUF_NUM]; /* log buffer */
uint32_t mva_log[MAX_LOG_BUF_NUM];
uint32_t sz_log[MAX_LOG_BUF_NUM];
int32_t fd_log[MAX_LOG_BUF_NUM];
};
#endif
/*---------------------------------------------------------------------------*/
/* CCU Power */
/*---------------------------------------------------------------------------*/
struct ccu_power_s {
uint32_t bON;
uint32_t freq;
uint32_t power;
struct ccu_working_buffer_s workBuf;
};
#ifdef CONFIG_COMPAT
struct compat_ccu_power_s {
uint32_t bON;
uint32_t freq;
uint32_t power;
struct compat_ccu_working_buffer_s workBuf;
};
#endif
/*---------------------------------------------------------------------------*/
/* CCU command */
/*---------------------------------------------------------------------------*/
enum ccu_eng_status_e {
CCU_ENG_STATUS_SUCCESS,
CCU_ENG_STATUS_BUSY,
CCU_ENG_STATUS_TIMEOUT,
CCU_ENG_STATUS_INVALID,
CCU_ENG_STATUS_FLUSH,
CCU_ENG_STATUS_FAILURE,
CCU_ENG_STATUS_ERESTARTSYS,
};
/*---------------------------------------------------------------------------*/
/* CCU Command */
/*---------------------------------------------------------------------------*/
struct ccu_cmd_s {
struct ccu_msg_t task;
enum ccu_eng_status_e status;
};
/*---------------------------------------------------------------------------*/
/* IOCTL Command */
/*---------------------------------------------------------------------------*/
#define CCU_MAGICNO 'c'
#define CCU_IOCTL_SET_POWER _IOW(CCU_MAGICNO, 0, int)
#define CCU_IOCTL_ENQUE_COMMAND _IOW(CCU_MAGICNO, 1, int)
#define CCU_IOCTL_DEQUE_COMMAND _IOWR(CCU_MAGICNO, 2, int)
#define CCU_IOCTL_FLUSH_COMMAND _IOW(CCU_MAGICNO, 3, int)
#define CCU_IOCTL_WAIT_IRQ _IOW(CCU_MAGICNO, 9, int)
#define CCU_IOCTL_SEND_CMD _IOWR(CCU_MAGICNO, 10, int)
#define CCU_IOCTL_SET_RUN _IO(CCU_MAGICNO, 11)
#define CCU_CLEAR_IRQ _IOW(CCU_MAGICNO, 12, int)
#define CCU_REGISTER_IRQ_USER_KEY _IOR(CCU_MAGICNO, 13, int)
#define CCU_READ_REGISTER _IOWR(CCU_MAGICNO, 14, int)
#define CCU_WRITE_REGISTER _IOWR(CCU_MAGICNO, 15, int)
#define CCU_IOCTL_SET_WORK_BUF _IOW(CCU_MAGICNO, 18, int)
#define CCU_IOCTL_FLUSH_LOG _IOW(CCU_MAGICNO, 19, int)
#define CCU_IOCTL_GET_I2C_DMA_BUF_ADDR _IOR(CCU_MAGICNO, 20, int)
#define CCU_IOCTL_SET_I2C_MODE _IOW(CCU_MAGICNO, 21, int)
#define CCU_IOCTL_SET_I2C_CHANNEL _IOW(CCU_MAGICNO, 22, int)
#define CCU_IOCTL_GET_CURRENT_FPS _IOR(CCU_MAGICNO, 23, int)
#define CCU_IOCTL_GET_SENSOR_I2C_SLAVE_ADDR _IOR(CCU_MAGICNO, 24, int)
#define CCU_IOCTL_GET_SENSOR_NAME _IOR(CCU_MAGICNO, 25, int)
#define CCU_IOCTL_GET_PLATFORM_INFO _IOR(CCU_MAGICNO, 26, int)
#define CCU_IOCTL_LOAD_CCU_BIN _IOW(CCU_MAGICNO, 30, int)
#define CCU_IOCTL_PRINT_REG _IOR(CCU_MAGICNO, 37, int)
#define CCU_IOCTL_PRINT_SRAM_LOG _IOR(CCU_MAGICNO, 38, int)
#endif
+381
View File
@@ -0,0 +1,381 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/uaccess.h>
#include <linux/sched.h>
#include <linux/printk.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/i2c.h>
#include "i2c-mtk.h"
#include <m4u.h>
#include "ccu_cmn.h"
#include "ccu_i2c.h"
#include "ccu_i2c_hw.h"
#include "kd_camera_feature.h"/*for IMGSENSOR_SENSOR_IDX*/
/**************************************************************************
*
**************************************************************************/
/*I2C Channel offset*/
#define I2C_BASE_OFS_CH1 (0x200)
#define MAX_I2C_CMD_LEN 255
#define CCU_I2C_APDMA_TXLEN 128
#define CCU_I2C_BUS2_HW_DRVNAME "ccu_i2c_2_hwtrg"
#define CCU_I2C_BUS4_HW_DRVNAME "ccu_i2c_4_hwtrg"
/*--todo: check if need id-table & name, id of_match_table is given*/
static int ccu_i2c_probe_2(struct i2c_client *client,
const struct i2c_device_id *id);
static int ccu_i2c_probe_4(struct i2c_client *client,
const struct i2c_device_id *id);
static int ccu_i2c_remove(struct i2c_client *client);
static uint32_t g_ccu_i2c_id = -1;
static MBOOL ccu_i2c_enabled = MFALSE;
static struct i2c_client *getCcuI2cClient(void);
static struct i2c_client *g_ccuI2cClient2;
static struct i2c_client *g_ccuI2cClient4;
static inline u32 i2c_readl_dma(struct mt_i2c *i2c, u16 offset);
static inline void i2c_writel_dma(u32 value, struct mt_i2c *i2c, u16 offset);
static inline u16 i2c_readw(struct mt_i2c *i2c, u16 offset);
static inline void i2c_writew(u16 value, struct mt_i2c *i2c, u16 offset);
static void ccu_i2c_dump_info(struct mt_i2c *i2c);
static const struct i2c_device_id ccu_i2c_2_ids[] = {
{CCU_I2C_BUS2_HW_DRVNAME, 0},
{}
};
static const struct i2c_device_id ccu_i2c_4_ids[] = {
{CCU_I2C_BUS4_HW_DRVNAME, 0},
{}
};
#ifdef CONFIG_OF
static const struct of_device_id ccu_i2c_2_driver_of_ids[] = {
{.compatible = "mediatek,ccu_sensor_i2c_2_hw",},
{}
};
static const struct of_device_id ccu_i2c_4_driver_of_ids[] = {
{.compatible = "mediatek,ccu_sensor_i2c_4_hw",},
{}
};
#endif
struct i2c_driver ccu_i2c_2_driver = {
.probe = ccu_i2c_probe_2,
.remove = ccu_i2c_remove,
.driver = {
.name = CCU_I2C_BUS2_HW_DRVNAME,
.owner = THIS_MODULE,
#ifdef CONFIG_OF
.of_match_table = ccu_i2c_2_driver_of_ids,
#endif
},
.id_table = ccu_i2c_2_ids,
};
struct i2c_driver ccu_i2c_4_driver = {
.probe = ccu_i2c_probe_4,
.remove = ccu_i2c_remove,
.driver = {
.name = CCU_I2C_BUS4_HW_DRVNAME,
.owner = THIS_MODULE,
#ifdef CONFIG_OF
.of_match_table = ccu_i2c_4_driver_of_ids,
#endif
},
.id_table = ccu_i2c_4_ids,
};
/*----------------------------------------------------------------------*/
/* CCU Driver: i2c driver funcs */
/*----------------------------------------------------------------------*/
static int ccu_i2c_probe_2(struct i2c_client *client,
const struct i2c_device_id *id)
{
/*int i4RetValue = 0;*/
LOG_DBG("[%s] Attach I2C for HW trriger g_ccuI2cClient2 %p\n",
"ccu_i2c_probe", client);
/* get sensor i2c client */
/*--todo: add subcam implementation*/
g_ccuI2cClient2 = client;
/* set I2C clock rate */
/*#ifdef CONFIG_MTK_I2C_EXTENSION*/
/*g_pstI2Cclient3->timing = 100;*/ /* 100k */
/* No I2C polling busy waiting */
/*g_pstI2Cclient3->ext_flag &= ~I2C_POLLING_FLAG;*/
/*#endif*/
LOG_DBG("[ccu_i2c_probe] Attached!!\n");
return 0;
}
static int ccu_i2c_probe_4(struct i2c_client *client,
const struct i2c_device_id *id)
{
/*int i4RetValue = 0;*/
LOG_DBG("[%s] Attach I2C for HW trriger g_ccuI2cClient4 %p\n",
"ccu_i2c_probe", client);
/* get sensor i2c client */
/*--todo: add subcam implementation*/
g_ccuI2cClient4 = client;
/* set I2C clock rate */
/*#ifdef CONFIG_MTK_I2C_EXTENSION*/
/*g_pstI2Cclient3->timing = 100;*/ /* 100k */
/* No I2C polling busy waiting */
/*g_pstI2Cclient3->ext_flag &= ~I2C_POLLING_FLAG;*/
/*#endif*/
LOG_DBG("[ccu_i2c_probe] Attached!!\n");
return 0;
}
static int ccu_i2c_remove(struct i2c_client *client)
{
return 0;
}
/*---------------------------------------------------------------------------*/
/* CCU i2c public funcs */
/*---------------------------------------------------------------------------*/
int ccu_i2c_register_driver(void)
{
int i2c_ret = 0;
LOG_DBG("i2c_add_driver(&ccu_i2c_2_driver)++\n");
i2c_ret = i2c_add_driver(&ccu_i2c_2_driver);
LOG_DBG("i2c_add_driver(&ccu_i2c_2_driver), ret: %d--\n", i2c_ret);
LOG_DBG("i2c_add_driver(&ccu_i2c_4_driver)++\n");
i2c_ret = i2c_add_driver(&ccu_i2c_4_driver);
LOG_DBG("i2c_add_driver(&ccu_i2c_4_driver), ret: %d--\n", i2c_ret);
return 0;
}
int ccu_i2c_delete_driver(void)
{
i2c_del_driver(&ccu_i2c_2_driver);
i2c_del_driver(&ccu_i2c_4_driver);
return 0;
}
int ccu_i2c_set_channel(uint32_t i2c_id)
{
if (i2c_id == 2 || i2c_id == 4) {
g_ccu_i2c_id = i2c_id;
return 0;
} else
return -EFAULT;
}
int ccu_i2c_buf_mode_init(unsigned char i2c_write_id, int transfer_len)
{
if (ccu_i2c_buf_mode_en(1) == -1) {
LOG_DBG("i2c_buf_mode_en fail\n");
return -1;
}
LOG_DBG_MUST("%s done.\n", __func__);
return 0;
}
int ccu_i2c_buf_mode_en(int enable)
{
int ret = 0;
struct i2c_client *pClient = NULL;
struct mt_i2c *i2c;
LOG_DBG_MUST("i2c_buf_mode_en %d\n", enable);
pClient = getCcuI2cClient();
LOG_DBG("i2c_buf_mode_en, pClient: %p\n", pClient);
if (pClient == NULL) {
LOG_ERR("i2c_client is null\n");
return -1;
}
LOG_DBG_MUST("ccu_i2c_enabled %d\n", ccu_i2c_enabled);
if (enable) {
if (ccu_i2c_enabled == MFALSE) {
ret = i2c_ccu_enable(
pClient->adapter, I2C_BASE_OFS_CH1);
ccu_i2c_enabled = MTRUE;
LOG_DBG_MUST("i2c_ccu_enable done(%d).\n", ret);
i2c = i2c_get_adapdata(pClient->adapter);
i2c_writew(2, i2c, 0x240);
}
} else {
if (ccu_i2c_enabled == MTRUE) {
ret = i2c_ccu_disable(pClient->adapter);
ccu_i2c_enabled = MFALSE;
LOG_DBG_MUST("i2c_ccu_disable done(%d).\n", ret);
}
}
return ret;
}
int i2c_get_dma_buffer_addr(void **va,
uint32_t *pa_h, uint32_t *pa_l, uint32_t *i2c_id)
{
struct i2c_client *pClient = NULL;
struct mt_i2c *i2c;
pClient = getCcuI2cClient();
if (pClient == MNULL) {
LOG_ERR("ccu client is NULL");
return -EFAULT;
}
i2c = i2c_get_adapdata(pClient->adapter);
/*i2c_get_dma_buffer_addr_imp(pClient->adapter ,va);*/
*va = i2c->dma_buf.vaddr + PAGE_SIZE;
*pa_l = i2c->dma_buf.paddr + PAGE_SIZE;
*pa_h = 0;
#ifdef CONFIG_COMPAT
*pa_h = ((i2c->dma_buf.paddr + PAGE_SIZE) >> 32);
#endif
*i2c_id = i2c->id;
LOG_DBG_MUST("va(%p), pal(%d), pah(%d), id(%d)\n",
*va, *pa_l, *pa_h, *i2c_id);
return 0;
}
/*-------------------------------------------------------------------*/
/* CCU i2c static funcs */
/*-------------------------------------------------------------------*/
static struct i2c_client *getCcuI2cClient(void)
{
switch (g_ccu_i2c_id) {
case 2:
{
return g_ccuI2cClient2;
}
case 4:
{
return g_ccuI2cClient4;
}
default:
{
return MNULL;
}
}
}
static inline u32 i2c_readl_dma(struct mt_i2c *i2c, u16 offset)
{
return readl(i2c->pdmabase + offset);
}
static inline void i2c_writel_dma(u32 value, struct mt_i2c *i2c, u16 offset)
{
writel(value, i2c->pdmabase + offset);
}
static inline u16 i2c_readw(struct mt_i2c *i2c, u16 offset)
{
return readw(i2c->base + offset);
}
static inline void i2c_writew(u16 value, struct mt_i2c *i2c, u16 offset)
{
writew(value, i2c->base + offset);
}
void ccu_i2c_dump_errr(void)
{
struct i2c_client *pClient = NULL;
struct mt_i2c *i2c;
LOG_DBG_MUST("CCU Dump I2C reg\n");
pClient = getCcuI2cClient();
if (pClient == NULL) {
LOG_ERR("i2c_client is null\n");
return;
}
i2c = i2c_get_adapdata(pClient->adapter);
ccu_i2c_dump_info(i2c);
}
static void ccu_i2c_dump_info(struct mt_i2c *i2c)
{
/* I2CFUC(); */
/* int val=0; */
pr_info("i2c_dump_info ++++++++++++++++++++++++++++++++++++++++++\n");
pr_info("base address 0x%p\n", i2c->base);
pr_info("I2C register:\n"
I2CTAG "SLAVE_ADDR=%x,INTR_MASK=%x,INTR_STAT=%x,"
I2CTAG "CONTROL=%x,TRANSFER_LEN=%x\n"
I2CTAG "TRANSAC_LEN=%x,DELAY_LEN=%x,"
I2CTAG "TIMING=%x,START=%x,FIFO_STAT=%x\n"
I2CTAG "IO_CONFIG=%x,HS=%x,DCM_EN=%x,DEBUGSTAT=%x,"
I2CTAG "EXT_CONF=%x,TRANSFER_LEN_AUX=%x\n",
(i2c_readw(i2c, 0x200 + OFFSET_SLAVE_ADDR)),
(i2c_readw(i2c, 0x200 + OFFSET_INTR_MASK)),
(i2c_readw(i2c, 0x200 + OFFSET_INTR_STAT)),
(i2c_readw(i2c, 0x200 + OFFSET_CONTROL)),
(i2c_readw(i2c, 0x200 + OFFSET_TRANSFER_LEN)),
(i2c_readw(i2c, 0x200 + OFFSET_TRANSAC_LEN)),
(i2c_readw(i2c, 0x200 + OFFSET_DELAY_LEN)),
(i2c_readw(i2c, 0x200 + OFFSET_TIMING)),
(i2c_readw(i2c, 0x200 + OFFSET_START)),
(i2c_readw(i2c, 0x200 + OFFSET_FIFO_STAT)),
(i2c_readw(i2c, 0x200 + OFFSET_IO_CONFIG)),
(i2c_readw(i2c, 0x200 + OFFSET_HS)),
(i2c_readw(i2c, 0x200 + OFFSET_DCM_EN)),
(i2c_readw(i2c, 0x200 + OFFSET_DEBUGSTAT)),
(i2c_readw(i2c, 0x200 + OFFSET_EXT_CONF)),
(i2c_readw(i2c, 0x200 + OFFSET_TRANSFER_LEN_AUX)));
pr_info("DMA register(0x%p):\n"
I2CTAG "INT_FLAG=%x,INT_EN=%x,EN=%x,RST=%x,\n"
I2CTAG "STOP=%x,FLUSH=%x,CON=%x,TX_MEM_ADDR=%x, RX_MEM_ADDR=%x\n"
I2CTAG "TX_LEN=%x,RX_LEN=%x,INT_BUF_SIZE=%x,DEBUG_STATUS=%x\n"
I2CTAG "TX_MEM_ADDR2=%x, RX_MEM_ADDR2=%x\n",
i2c->pdmabase,
(i2c_readl_dma(i2c, 0x80 + OFFSET_INT_FLAG)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_INT_EN)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_EN)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_RST)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_STOP)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_FLUSH)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_CON)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_TX_MEM_ADDR)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_RX_MEM_ADDR)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_TX_LEN)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_RX_LEN)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_INT_BUF_SIZE)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_DEBUG_STA)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_TX_MEM_ADDR2)),
(i2c_readl_dma(i2c, 0x80 + OFFSET_RX_MEM_ADDR2)));
pr_info("i2c_dump_info ------------------------------------------\n");
}
@@ -0,0 +1,31 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_I2C_H__
#define __CCU_I2C_H__
/*---------------------------------------------------------------------------*/
/* i2c interface from ccu_drv.c */
/*---------------------------------------------------------------------------*/
struct ccu_i2c_arg {
unsigned int i2c_write_id;
unsigned int transfer_len;
};
struct ccu_i2c_info {
uint32_t slave_addr;
uint32_t i2c_id;
};
extern int ccu_i2c_register_driver(void);
extern int ccu_i2c_delete_driver(void);
extern int ccu_i2c_set_channel(uint32_t i2c_id);
extern int i2c_get_dma_buffer_addr(void **va,
uint32_t *pa_h, uint32_t *pa_l, uint32_t *i2c_id);
void ccu_i2c_dump_errr(void);
extern int ccu_i2c_buf_mode_init(unsigned char i2c_write_id, int transfer_len);
extern int ccu_i2c_buf_mode_en(int enable);
#endif
@@ -0,0 +1,20 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include <linux/io.h>
#include "ccu_drv.h"
#include "ccu_cmn.h"
#include "ccu_n3d_a.h"
inline u32 n3d_a_readw(unsigned long n3d_a_base, u32 offset)
{
return readl((u32 *) (n3d_a_base + offset));
}
inline void n3d_a_writew(u32 value, unsigned long n3d_a_base, u32 offset)
{
writel(value, (u32 *) (n3d_a_base + offset));
}
@@ -0,0 +1,19 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_N3D_A_H__
#define __CCU_N3D_A_H__
enum N3DA_REGS_OFFSET {
OFFSET_CTL = 0x100,
OFFSET_TRIG = 0x108,
OFFSET_INT = 0x10C,
};
extern u32 n3d_a_readw(unsigned long n3d_a_base, u32 offset);
extern void n3d_a_writew(u32 value, unsigned long n3d_a_base, u32 offset);
#endif
@@ -0,0 +1,28 @@
#
# 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.
#
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion \
-I$(srctree)/drivers/staging/android/mtk_ion/mtk
ccflags-y += -I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/$(MTK_PLATFORM)/ccu_ext_interface/
ccflags-y += -I$(srctree)/drivers/i2c/busses
ccflags-y += -I$(srctree)/drivers/iommu/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/imgsensor/inc
#$(warning $(subdir-ccflags-y))
#obj-$(CONFIG_MTK_VPU) += ccu_drv.o ccu_algo.o ccu_dbg.o
obj-y += ccu_drv.o ccu_n3d_a.o ccu_i2c.o
+250
View File
@@ -0,0 +1,250 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CCU_CMN_H__
#define __CCU_CMN_H__
#include <linux/wait.h>
#include <linux/seq_file.h>
#include <linux/interrupt.h>
#include "ccu_drv.h"
/* Common Structure */
enum ccu_req_type_e {
CCU_IRQ_TYPE_XXX,
CCU_IRQ_NUM_TYPES
};
struct ccu_device_s {
struct proc_dir_entry *proc_dir;
struct device *dev;
struct dentry *debug_root;
void __iomem *ccu_base;
void __iomem *camsys_base;
void __iomem *bin_base;
void __iomem *dmem_base;
void __iomem *pmem_base;
void __iomem *ddrmem_base;
void __iomem *n3d_a_base;
unsigned int irq_num;
struct mutex dev_mutex;
struct mutex user_mutex;
struct mutex clk_mutex;
struct mutex ion_client_mutex;
/* list of vlist_type(ccu_user_t) */
struct list_head user_list;
/* notify enque thread */
wait_queue_head_t cmd_wait;
};
struct ccu_user_s {
pid_t open_pid;
pid_t open_tgid;
uint32_t id;
/* to enque/deque must have mutex protection */
struct mutex data_mutex;
bool running;
bool flush;
/* list of vlist_type(ccu_cmd_st) */
struct list_head enque_ccu_cmd_list;
struct list_head deque_ccu_cmd_list;
wait_queue_head_t deque_wait;
};
/*type must be struct*/
/*#define DECLARE_VLIST(type) \*/
/*typedef struct { \*/
/*type node; \*/
/*struct list_head link; \*/
/*} type ## _list*/
/*
* vlist_node_of - get the pointer to the node which has specific vlist
* @ptr: the pointer to struct list_head
* @type: the type of list node
*/
#define vlist_node_of(ptr, type) ({ \
const struct list_head *__mptr = (ptr); \
(type *)((char *)__mptr - offsetof(type ## _list, link)); })
/*
* vlist_link - get the pointer to struct list_head
* @ptr: the pointer to struct vlist
* @type: the type of list node
*/
#define vlist_link(ptr, type) (&((type ## _list *)ptr)->link)
/*
* vlist_type - get the type of struct vlist
* @type: the type of list node
*/
#define vlist_type(type) type ## _list
/*
* vlist_node - get the pointer to the node of vlist
* @ptr: the pointer to struct vlist
* @type: the type of list node
*/
#define vlist_node(ptr, type) ((type *) ptr)
/*typedef struct work_struct work_struct_t;*/
/*DECLARE_VLIST(work_struct_t);*/
/*DECLARE_VLIST(struct ccu_user_s);*/
struct ccu_user_s_list {
struct ccu_user_s node;
struct list_head link;
};
/*DECLARE_VLIST(struct ccu_cmd_s);*/
struct ccu_cmd_s_list {
struct ccu_cmd_s node;
struct list_head link;
};
/* ===== define in ccu_hw.c ===== */
/**
* ccu_init_hw - init the procedure related to hw,
* include irq register and enque thread
* @device: the pointer of ccu_device.
*/
int ccu_init_hw(struct ccu_device_s *device);
/**
* ccu_uninit_hw - close resources related to hw module
*/
int ccu_uninit_hw(struct ccu_device_s *device);
/**
* ccu_mmap_hw - mmap kernel memory to user
*/
int ccu_mmap_hw(struct file *filp, struct vm_area_struct *vma);
/**
* ccu_power - config ccu power.
* @s: the pointer to power relative settings.
*/
int ccu_power(struct ccu_power_s *power);
/**
* ccu_force_powerdown - force CCU to stop & shutdown
*/
int ccu_force_powerdown(void);
/**
* ccu_load_bin - load ccu dm/pm binary.
*/
int ccu_load_bin(struct ccu_device_s *device, struct ccu_bin_info_s *bin_info);
int ccu_sw_hw_reset(void);
/**
* ccu_run - start running ccu .
*/
int ccu_run(struct ccu_run_s *info);
/**
* ccu_irq - interrupt wait.
* @s: wait mode.
*/
int ccu_waitirq(struct CCU_WAIT_IRQ_STRUCT *WaitIrq);
int ccu_AFwaitirq(struct CCU_WAIT_IRQ_STRUCT *WaitIrq, int tg_num);
/**
* ccu_irq - interrupt wait.
* @s: wait mode.
*/
int ccu_flushLog(int argc, int *argv);
int ccu_memcpy(void *dest, void *src, int length);
int ccu_memclr(void *dest, int length);
int ccu_read_struct_size(uint32_t *structSizes, uint32_t structCnt);
void ccu_print_reg(uint32_t *Reg);
void ccu_print_sram_log(char *sram_log);
int ccu_read_data(uint32_t *buf, uint32_t ccu_da, uint32_t size);
int ccu_query_power_status(void);
/* ===== define in ccu_drv.c ===== */
/**
* ccu_create_user - create ccu user, and add to user list
* @ruser: return the created user.
*/
int ccu_create_user(struct ccu_user_s **ruser);
/**
* ccu_delete_user - delete ccu user, and remove it from user list
* @user: the pointer to user.
*/
int ccu_delete_user(struct ccu_user_s *user);
int ccu_lock_ion_client_mutex(void);
int ccu_unlock_ion_client_mutex(void);
/**
* ccu_clock_enable - Set CCU clock on
*/
int ccu_clock_enable(void);
/**
* ccu_clock_disable - Set CCU clock off
*/
void ccu_clock_disable(void);
/* LOG & AEE */
#define CCU_TAG "[ccu]"
#define LOG_DBG_MUST(format, args...) \
pr_debug(CCU_TAG "[%s] " format, __func__, ##args)
#define LOG_INF_MUST(format, args...) \
pr_info(CCU_TAG "[%s] " format, __func__, ##args)
#define LOG_DBG(format, args...)
#define LOG_INF(format, args...)
#define LOG_WARN(format, args...) \
pr##_##warn(CCU_TAG "[%s] " format, __func__, ##args)
#define LOG_ERR(format, args...) \
pr##_##err(CCU_TAG "[%s] " format, __func__, ##args)
#define LOG_DERR(device, format, args...) \
dev##_##err(device, CCU_TAG "[%s] " format, __func__, ##args)
#define ccu_print_seq(seq_file, fmt, args...) \
do {\
if (seq_file)\
seq_printf(seq_file, fmt, ##args);\
else\
pr_debug(fmt, ##args);\
} while (0)
#define ccu_error(format, args...) \
do {\
LOG_ERR(CCU_TAG " error:"format, ##args); \
aee_kernel_exception("CCU", \
"[CCU] error:"format, ##args); \
} while (0)
#define ccu_aee(format, args...) \
do {\
char ccu_name[100];\
snprintf(ccu_name, 100, CCU_TAG format, ##args); \
aee_kernel_warning_api(__FILE__, __LINE__, \
DB_OPT_MMPROFILE_BUFFER | DB_OPT_DUMP_DISPLAY, \
ccu_name, CCU_TAG "error" format, ##args); \
LOG_ERR(CCU_TAG " error:" format, ##args); \
} while (0)
#endif
File diff suppressed because it is too large. Load diff
+378
View File
@@ -0,0 +1,378 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CCU_DRV_H__
#define __CCU_DRV_H__
#include <linux/types.h>
#include <linux/ioctl.h>
#include "ccu_mailbox_extif.h"
#include <linux/fs.h>
#ifdef CONFIG_COMPAT
/*64 bit*/
#include <linux/compat.h>
#endif
/*---------------------------------------------------------------------------*/
/* CCU IRQ */
/*---------------------------------------------------------------------------*/
#define IRQ_USER_NUM_MAX 32
#define SUPPORT_MAX_IRQ 32
enum CCU_IRQ_CLEAR_ENUM {
CCU_IRQ_CLEAR_NONE, /* non-clear wait, clear after wait */
CCU_IRQ_CLEAR_WAIT, /* clear wait, clear before and after wait */
CCU_IRQ_CLEAR_STATUS, /* clear specific status only */
CCU_IRQ_CLEAR_ALL /* clear all status */
};
enum CCU_IRQ_TYPE_ENUM {
CCU_IRQ_TYPE_INT_CCU_ST,
CCU_IRQ_TYPE_INT_CCU_A_ST,
CCU_IRQ_TYPE_INT_CCU_B_ST,
CCU_IRQ_TYPE_AMOUNT
};
enum CCU_ST_ENUM {
CCU_SIGNAL_INT = 0, CCU_DMA_INT, CCU_IRQ_ST_AMOUNT
};
struct CCU_IRQ_TIME_STRUCT {
unsigned int tLastSig_sec;
/* time stamp of the latest occurring signal */
unsigned int tLastSig_usec;
/* time stamp of the latest occurring signal */
unsigned int tMark2WaitSig_sec;
/* time period from marking a signal to user try to wait and get the signal */
unsigned int tMark2WaitSig_usec;
/* time period from marking a signal to user try to wait and get the signal */
unsigned int tLastSig2GetSig_sec;
/* time period from latest signal to user try to wait and get the signal */
unsigned int tLastSig2GetSig_usec;
/* time period from latest signal to user try to wait and get the signal */
int passedbySigcnt; /* the count for the signal passed by */
};
struct CCU_WAIT_IRQ_ST {
enum CCU_IRQ_CLEAR_ENUM Clear;
enum CCU_ST_ENUM St_type;
unsigned int Status;
int UserKey; /* user key for doing interrupt operation */
unsigned int Timeout;
struct CCU_IRQ_TIME_STRUCT TimeInfo;
};
struct CCU_REGISTER_USERKEY_STRUCT {
int userKey;
char userName[32];
};
struct CCU_WAIT_IRQ_STRUCT {
enum CCU_IRQ_TYPE_ENUM Type;
unsigned int bDumpReg;
struct CCU_WAIT_IRQ_ST EventInfo;
};
struct CCU_CLEAR_IRQ_ST {
int UserKey; /* user key for doing interrupt operation */
enum CCU_ST_ENUM St_type;
unsigned int Status;
};
struct CCU_CLEAR_IRQ_STRUCT {
enum CCU_IRQ_TYPE_ENUM Type;
struct CCU_CLEAR_IRQ_ST EventInfo;
};
struct CCU_REG_STRUCT {
unsigned int module;
unsigned int Addr; /* register's addr */
unsigned int Val; /* register's value */
};
struct CCU_REG_IO_STRUCT {
struct CCU_REG_STRUCT *pData; /* pointer to struct CCU_REG_STRUCT */
unsigned int Count; /* count */
};
struct CCU_IRQ_INFO_STRUCT {
/* Add an extra index for status type in ever -> signal or dma */
unsigned int Status[CCU_IRQ_TYPE_AMOUNT][CCU_IRQ_ST_AMOUNT]
[IRQ_USER_NUM_MAX];
unsigned int Mask[CCU_IRQ_TYPE_AMOUNT][CCU_IRQ_ST_AMOUNT];
unsigned int ErrMask[CCU_IRQ_TYPE_AMOUNT][CCU_IRQ_ST_AMOUNT];
signed int WarnMask[CCU_IRQ_TYPE_AMOUNT][CCU_IRQ_ST_AMOUNT];
/* flag for indicating that user do mark for a interrupt or not */
unsigned int MarkedFlag[CCU_IRQ_TYPE_AMOUNT][CCU_IRQ_ST_AMOUNT]
[IRQ_USER_NUM_MAX];
/* time for marking a specific interrupt */
unsigned int MarkedTime_sec[CCU_IRQ_TYPE_AMOUNT][32][IRQ_USER_NUM_MAX];
/* time for marking a specific interrupt */
unsigned int MarkedTime_usec[CCU_IRQ_TYPE_AMOUNT][32][IRQ_USER_NUM_MAX];
/* number of a specific signal that passed by */
signed int PassedBySigCnt[CCU_IRQ_TYPE_AMOUNT][32][IRQ_USER_NUM_MAX];
/* */
unsigned int LastestSigTime_sec[CCU_IRQ_TYPE_AMOUNT][32];
/* latest time for each interrupt */
unsigned int LastestSigTime_usec[CCU_IRQ_TYPE_AMOUNT][32];
/* latest time for each interrupt */
};
#define CCU_ISR_MAX_NUM 32
#define INT_ERR_WARN_TIMER_THREAS 1000
#define INT_ERR_WARN_MAX_TIME 3
struct CCU_IRQ_ERR_WAN_CNT_STRUCT {
/* cnt for each err int # */
unsigned int m_err_int_cnt[CCU_IRQ_TYPE_AMOUNT][CCU_ISR_MAX_NUM];
/* cnt for each warning int # */
unsigned int m_warn_int_cnt[CCU_IRQ_TYPE_AMOUNT][CCU_ISR_MAX_NUM];
/* mark for err int, where its cnt > threshold */
unsigned int m_err_int_mark[CCU_IRQ_TYPE_AMOUNT];
/* mark for warn int, where its cnt > threshold */
unsigned int m_warn_int_mark[CCU_IRQ_TYPE_AMOUNT];
unsigned long m_int_usec[CCU_IRQ_TYPE_AMOUNT];
};
#define CCU_BUF_SIZE (4096)
#define CCU_BUF_SIZE_WRITE 1024
#define CCU_BUF_WRITE_AMOUNT 6
enum CCU_BUF_STATUS_ENUM {
CCU_BUF_STATUS_EMPTY,
CCU_BUF_STATUS_HOLD,
CCU_BUF_STATUS_READY
};
struct CCU_BUF_STRUCT {
enum CCU_BUF_STATUS_ENUM Status;
unsigned int Size;
unsigned char *pData;
};
struct CCU_BUF_INFO_STRUCT {
struct CCU_BUF_STRUCT Read;
struct CCU_BUF_STRUCT Write[CCU_BUF_WRITE_AMOUNT];
};
struct CCU_TIME_LOG_STRUCT {
unsigned int Vd;
unsigned int Expdone;
unsigned int WorkQueueVd;
unsigned int WorkQueueExpdone;
unsigned int TaskletVd;
unsigned int TaskletExpdone;
};
#ifdef MTK_VPU_KERNEL
struct CCU_INFO_STRUCT {
spinlock_t SpinLockCcuRef;
spinlock_t SpinLockCcu;
spinlock_t SpinLockIrq[CCU_IRQ_TYPE_AMOUNT];
spinlock_t SpinLockIrqCnt[CCU_IRQ_TYPE_AMOUNT];
spinlock_t SpinLockRTBC;
spinlock_t SpinLockClock;
spinlock_t SpinLockI2cPower;
unsigned int IsI2cPowerDisabling;
unsigned int IsI2cPoweredOn;
unsigned int IsCcuPoweredOn;
wait_queue_head_t WaitQueueHead;
wait_queue_head_t AFWaitQueueHead[2];
wait_queue_head_t WaitQHeadList[SUPPORT_MAX_IRQ];
unsigned int UserCount;
unsigned int DebugMask;
signed int IrqNum;
struct CCU_IRQ_INFO_STRUCT IrqInfo;
struct CCU_IRQ_ERR_WAN_CNT_STRUCT IrqCntInfo;
struct CCU_BUF_INFO_STRUCT BufInfo;
struct CCU_TIME_LOG_STRUCT TimeLog;
};
#endif
/*---------------------------------------------------------------------------*/
/* CCU working buffer */
/*---------------------------------------------------------------------------*/
#define SIZE_32BYTE (32)
#define SIZE_1MB (1024*1024)
#define SIZE_1MB_PWR2PAGE (8)
#define MAX_I2CBUF_NUM 1
#define MAX_MAILBOX_NUM 2
#define MAX_LOG_BUF_NUM 2
#define MAILBOX_SEND 0
#define MAILBOX_GET 1
struct ccu_working_buffer_s {
uint8_t *va_pool;
uint32_t mva_pool;
uint32_t sz_pool;
uint8_t *va_i2c; /* i2c buffer mode */
uint32_t mva_i2c;
uint32_t sz_i2c;
uint8_t *va_mb[MAX_MAILBOX_NUM]; /* mailbox */
uint32_t mva_mb[MAX_MAILBOX_NUM];
uint32_t sz_mb[MAX_MAILBOX_NUM];
char *va_log[MAX_LOG_BUF_NUM]; /* log buffer */
uint32_t mva_log[MAX_LOG_BUF_NUM];
uint32_t sz_log[MAX_LOG_BUF_NUM];
int32_t fd_log[MAX_LOG_BUF_NUM];
};
#ifdef CONFIG_COMPAT
struct compat_ccu_working_buffer_s {
compat_uptr_t va_pool;
uint32_t mva_pool;
uint32_t sz_pool;
compat_uptr_t va_i2c; /* i2c buffer mode */
uint32_t mva_i2c;
uint32_t sz_i2c;
compat_uptr_t va_mb[MAX_MAILBOX_NUM]; /* mailbox */
uint32_t mva_mb[MAX_MAILBOX_NUM];
uint32_t sz_mb[MAX_MAILBOX_NUM];
compat_uptr_t va_log[MAX_LOG_BUF_NUM]; /* log buffer */
uint32_t mva_log[MAX_LOG_BUF_NUM];
uint32_t sz_log[MAX_LOG_BUF_NUM];
int32_t fd_log[MAX_LOG_BUF_NUM];
};
#endif
/*---------------------------------------------------------------------------*/
/* CCU Power */
/*---------------------------------------------------------------------------*/
struct ccu_power_s {
uint32_t bON;
uint32_t freq;
uint32_t power;
struct ccu_working_buffer_s workBuf;
};
#ifdef CONFIG_COMPAT
struct compat_ccu_power_s {
uint32_t bON;
uint32_t freq;
uint32_t power;
struct compat_ccu_working_buffer_s workBuf;
};
#endif
/*---------------------------------------------------------------------------*/
/* CCU Run */
/*---------------------------------------------------------------------------*/
struct ccu_run_s {
uint32_t log_level;
uint32_t log_taglevel;
uint32_t CtrlBufMva;
uint32_t CpuRefBufMva;
uint32_t CpuRefBufSz;
uint32_t bkdata_ddr_buf_mva;
};
/*---------------------------------------------------------------------------*/
/* CCU command */
/*---------------------------------------------------------------------------*/
enum ccu_eng_status_e {
CCU_ENG_STATUS_SUCCESS,
CCU_ENG_STATUS_BUSY,
CCU_ENG_STATUS_TIMEOUT,
CCU_ENG_STATUS_INVALID,
CCU_ENG_STATUS_FLUSH,
CCU_ENG_STATUS_FAILURE,
CCU_ENG_STATUS_ERESTARTSYS,
};
/*---------------------------------------------------------------------------*/
/* CCU Command */
/*---------------------------------------------------------------------------*/
struct ccu_cmd_s {
struct ccu_msg task;
enum ccu_eng_status_e status;
};
#define CCU_IMPORT_BUF_NUM 200
#define CCU_IMPORT_BUF_UNDEF 0xFFFFFFFF
struct import_mem_s {
uint32_t memID[CCU_IMPORT_BUF_NUM];
};
/*---------------------------------------------------------------------------*/
/* CCU Read/Write Reg */
/*---------------------------------------------------------------------------*/
struct ccu_reg_s {
uint32_t reg_no;
uint32_t reg_val;
};
/*---------------------------------------------------------------------------*/
/* CAM FREQ */
/*---------------------------------------------------------------------------*/
#define CCU_REQ_CAM_FREQ_HIGH 2
#define CCU_REQ_CAM_FREQ_MID 1
#define CCU_REQ_CAM_FREQ_NONE 0
/*---------------------------------------------------------------------------*/
/* CCU LOAD BIN */
/*---------------------------------------------------------------------------*/
enum CCU_BIN_TYPE {
CCU_DP_BIN,
CCU_DRIVER_BIN
};
#define CCU_BIN_NAME_MAX_LENGTH 50
struct ccu_bin_info_s {
enum CCU_BIN_TYPE type;
char name[CCU_BIN_NAME_MAX_LENGTH];
};
/*---------------------------------------------------------------------------*/
/* IOCTL Command */
/*---------------------------------------------------------------------------*/
#define CCU_MAGICNO 'c'
#define CCU_IOCTL_SET_POWER _IOW(CCU_MAGICNO, 0, int)
#define CCU_IOCTL_ENQUE_COMMAND _IOW(CCU_MAGICNO, 1, int)
#define CCU_IOCTL_DEQUE_COMMAND _IOWR(CCU_MAGICNO, 2, int)
#define CCU_IOCTL_FLUSH_COMMAND _IOW(CCU_MAGICNO, 3, int)
#define CCU_IOCTL_WAIT_AF_IRQ _IOW(CCU_MAGICNO, 8, int)
#define CCU_IOCTL_WAIT_IRQ _IOW(CCU_MAGICNO, 9, int)
#define CCU_IOCTL_SEND_CMD _IOWR(CCU_MAGICNO, 10, int)
#define CCU_IOCTL_SET_RUN_INPUT _IOW(CCU_MAGICNO, 11, int)
#define CCU_CLEAR_IRQ _IOW(CCU_MAGICNO, 12, int)
#define CCU_REGISTER_IRQ_USER_KEY _IOR(CCU_MAGICNO, 13, int)
#define CCU_READ_REGISTER _IOWR(CCU_MAGICNO, 14, int)
#define CCU_WRITE_REGISTER _IOWR(CCU_MAGICNO, 15, int)
#define CCU_IOCTL_SET_WORK_BUF _IOW(CCU_MAGICNO, 18, int)
#define CCU_IOCTL_FLUSH_LOG _IOW(CCU_MAGICNO, 19, int)
#define CCU_IOCTL_GET_I2C_DMA_BUF_ADDR _IOR(CCU_MAGICNO, 20, int)
#define CCU_IOCTL_SET_I2C_MODE _IOW(CCU_MAGICNO, 21, int)
#define CCU_IOCTL_GET_CURRENT_FPS _IOR(CCU_MAGICNO, 23, int)
#define CCU_IOCTL_GET_SENSOR_I2C_SLAVE_ADDR _IOR(CCU_MAGICNO, 24, int)
#define CCU_IOCTL_GET_SENSOR_NAME _IOR(CCU_MAGICNO, 25, int)
#define CCU_IOCTL_GET_PLATFORM_INFO _IOR(CCU_MAGICNO, 26, int)
#define CCU_IOCTL_IMPORT_MEM _IOW(CCU_MAGICNO, 27, int)
#define CCU_IOCTL_UPDATE_QOS_REQUEST _IOW(CCU_MAGICNO, 28, int)
#define CCU_IOCTL_UPDATE_CAM_FREQ_REQUEST _IOW(CCU_MAGICNO, 29, int)
#define CCU_IOCTL_LOAD_CCU_BIN _IOW(CCU_MAGICNO, 30, int)
#define CCU_IOCTL_IPC_INIT _IOW(CCU_MAGICNO, 31, int)
#define CCU_IOCTL_IPC_SEND_CMD _IOW(CCU_MAGICNO, 32, int)
#define CCU_IOCTL_ALLOC_MEM _IOW(CCU_MAGICNO, 33, int)
#define CCU_IOCTL_DEALLOC_MEM _IOW(CCU_MAGICNO, 34, int)
#define CCU_IOCTL_GET_IOVA _IOWR(CCU_MAGICNO, 35, int)
#define CCU_READ_STRUCT_SIZE _IOWR(CCU_MAGICNO, 36, int)
#define CCU_IOCTL_PRINT_REG _IOR(CCU_MAGICNO, 37, int)
#define CCU_IOCTL_PRINT_SRAM_LOG _IOR(CCU_MAGICNO, 38, int)
#define CCU_READ_DATA _IOWR(CCU_MAGICNO, 39, int)
#endif
+419
View File
@@ -0,0 +1,419 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/uaccess.h>
#include <linux/sched.h>
#include <linux/printk.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/i2c.h>
#include "i2c-mtk.h"
#include <m4u.h>
#include "ccu_cmn.h"
#include "ccu_i2c.h"
#include "ccu_i2c_hw.h"
#include "ccu_mva.h"
/*****************************************************************************/
/*I2C Channel offset*/
#define I2C_BASE_OFS_CH1 (0x200)
#define MAX_I2C_CMD_LEN 255
#define CCU_I2C_APDMA_TXLEN 128
#define CCU_I2C_2_HW_DRVNAME "ccu_i2c_2_hwtrg"
#define CCU_I2C_4_HW_DRVNAME "ccu_i2c_4_hwtrg"
#define CCU_I2C_7_HW_DRVNAME "ccu_i2c_7_hwtrg"
static DEFINE_MUTEX(ccu_i2c_mutex);
/*i2c driver hook*/
static int ccu_i2c_probe_2(struct i2c_client *client,
const struct i2c_device_id *id);
static int ccu_i2c_probe_4(struct i2c_client *client,
const struct i2c_device_id *id);
static int ccu_i2c_probe_7(struct i2c_client *client,
const struct i2c_device_id *id);
static int ccu_i2c_remove(struct i2c_client *client);
/*ccu i2c operation*/
static struct i2c_client *get_ccu_i2c_client(
uint32_t i2c_id);
static int ccu_i2c_controller_en(uint32_t i2c_id,
int enable);
static int i2c_query_dma_buffer_addr(uint32_t sensor_idx,
void **va, uint32_t *va_h, uint32_t *va_l, uint32_t *i2c_id);
static int ccu_i2c_controller_uninit(uint32_t i2c_id);
/*i2c reg operation*/
static inline void i2c_writew(u16 value, struct mt_i2c *i2c, u16 offset);
//static enum CCU_I2C_CHANNEL g_ccuI2cChannel;
static struct i2c_client *g_ccuI2cClient2;
static struct i2c_client *g_ccuI2cClient4;
static struct i2c_client *g_ccuI2cClient7;
static const struct i2c_device_id ccu_i2c_2_ids[] = {
{CCU_I2C_2_HW_DRVNAME, 0}, {} };
static const struct i2c_device_id ccu_i2c_4_ids[] = {
{CCU_I2C_4_HW_DRVNAME, 0}, {} };
static const struct i2c_device_id ccu_i2c_7_ids[] = {
{CCU_I2C_7_HW_DRVNAME, 0}, {} };
uint32_t i2c_mva[IMGSENSOR_SENSOR_IDX_MAX_NUM];
static bool ccu_i2c_initialized[I2C_MAX_CHANNEL] = {0};
#ifdef CONFIG_OF
static const struct of_device_id ccu_i2c_2_driver_of_ids[] = {
{.compatible = "mediatek,ccu_sensor_i2c_2_hw",},
{}
};
static const struct of_device_id ccu_i2c_4_driver_of_ids[] = {
{.compatible = "mediatek,ccu_sensor_i2c_4_hw",},
{}
};
static const struct of_device_id ccu_i2c_7_driver_of_ids[] = {
{.compatible = "mediatek,ccu_sensor_i2c_7_hw",},
{}
};
#endif
struct i2c_driver ccu_i2c_2_driver = {
.probe = ccu_i2c_probe_2,
.remove = ccu_i2c_remove,
.driver = {
.name = CCU_I2C_2_HW_DRVNAME,
.owner = THIS_MODULE,
#ifdef CONFIG_OF
.of_match_table = ccu_i2c_2_driver_of_ids,
#endif
},
.id_table = ccu_i2c_2_ids,
};
struct i2c_driver ccu_i2c_4_driver = {
.probe = ccu_i2c_probe_4,
.remove = ccu_i2c_remove,
.driver = {
.name = CCU_I2C_4_HW_DRVNAME,
.owner = THIS_MODULE,
#ifdef CONFIG_OF
.of_match_table = ccu_i2c_4_driver_of_ids,
#endif
},
.id_table = ccu_i2c_4_ids,
};
struct i2c_driver ccu_i2c_7_driver = {
.probe = ccu_i2c_probe_7,
.remove = ccu_i2c_remove,
.driver = {
.name = CCU_I2C_7_HW_DRVNAME,
.owner = THIS_MODULE,
#ifdef CONFIG_OF
.of_match_table = ccu_i2c_7_driver_of_ids,
#endif
},
.id_table = ccu_i2c_7_ids,
};
/*---------------------------------------------------------------------------*/
/* CCU Driver: i2c driver funcs */
/*---------------------------------------------------------------------------*/
static int ccu_i2c_probe_2(struct i2c_client *client,
const struct i2c_device_id *id)
{
LOG_DBG_MUST(
"[ccu_i2c_probe] Attach I2C for HW trriger g_ccuI2cClient2 %p\n",
client);
/* get sensor i2c client */
g_ccuI2cClient2 = client;
LOG_DBG_MUST("[ccu_i2c_probe] Attached!!\n");
return 0;
}
static int ccu_i2c_probe_4(struct i2c_client *client,
const struct i2c_device_id *id)
{
LOG_DBG_MUST(
"[ccu_i2c_probe] Attach I2C for HW trriger g_ccuI2cClient4 %p\n",
client);
/* get sensor i2c client */
g_ccuI2cClient4 = client;
LOG_DBG_MUST("[ccu_i2c_probe] Attached!!\n");
return 0;
}
static int ccu_i2c_probe_7(struct i2c_client *client,
const struct i2c_device_id *id)
{
LOG_DBG_MUST(
"[ccu_i2c_probe] Attach I2C for HW trriger g_ccuI2cClient7 %p\n",
client);
/* get sensor i2c client */
g_ccuI2cClient7 = client;
LOG_DBG_MUST("[ccu_i2c_probe] Attached!!\n");
return 0;
}
static int ccu_i2c_remove(struct i2c_client *client)
{
return 0;
}
/*---------------------------------------------------------------------------*/
/* CCU i2c public funcs */
/*---------------------------------------------------------------------------*/
int ccu_i2c_register_driver(void)
{
int i2c_ret = 0;
mutex_lock(&ccu_i2c_mutex);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_2_driver)++\n");
i2c_ret = i2c_add_driver(&ccu_i2c_2_driver);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_2_driver), ret: %d--\n",
i2c_ret);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_4_driver)++\n");
i2c_ret = i2c_add_driver(&ccu_i2c_4_driver);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_4_driver), ret: %d--\n",
i2c_ret);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_7_driver)++\n");
i2c_ret = i2c_add_driver(&ccu_i2c_7_driver);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_7_driver), ret: %d--\n",
i2c_ret);
mutex_unlock(&ccu_i2c_mutex);
return 0;
}
int ccu_i2c_delete_driver(void)
{
mutex_lock(&ccu_i2c_mutex);
i2c_del_driver(&ccu_i2c_2_driver);
i2c_del_driver(&ccu_i2c_4_driver);
i2c_del_driver(&ccu_i2c_7_driver);
mutex_unlock(&ccu_i2c_mutex);
return 0;
}
int ccu_i2c_controller_init(uint32_t i2c_id)
{
mutex_lock(&ccu_i2c_mutex);
if (i2c_id >= I2C_MAX_CHANNEL) {
LOG_ERR("i2c_id %d is invalid\n", i2c_id);
mutex_unlock(&ccu_i2c_mutex);
return -EINVAL;
}
if (ccu_i2c_initialized[i2c_id] == MTRUE) {
/*if not first time init, release mutex first to avoid deadlock*/
LOG_DBG_MUST("reinit, temporily release mutex.\n");
}
if (ccu_i2c_controller_en(i2c_id, 1) == -1) {
LOG_DBG("ccu_i2c_controller_en 1 fail\n");
mutex_unlock(&ccu_i2c_mutex);
return -1;
}
LOG_DBG_MUST("%s done.\n", __func__);
mutex_unlock(&ccu_i2c_mutex);
return 0;
}
int ccu_i2c_controller_uninit_all(void)
{
int i;
mutex_lock(&ccu_i2c_mutex);
for (i = 0 ; i < I2C_MAX_CHANNEL ; i++) {
if (ccu_i2c_initialized[i])
ccu_i2c_controller_uninit(i);
}
LOG_INF_MUST("%s done.\n", __func__);
mutex_unlock(&ccu_i2c_mutex);
return 0;
}
int ccu_get_i2c_dma_buf_addr(struct ccu_i2c_buf_mva_ioarg *ioarg)
{
int ret = 0;
void *va;
mutex_lock(&ccu_i2c_mutex);
ret = i2c_query_dma_buffer_addr(ioarg->sensor_idx,
&va, &ioarg->va_h, &ioarg->va_l, &ioarg->i2c_id);
if (ret != 0) {
mutex_unlock(&ccu_i2c_mutex);
return ret;
}
/*If there is existing i2c buffer mva allocated, deallocate it first*/
ccu_deallocate_mva(i2c_mva[ioarg->sensor_idx]);
i2c_mva[ioarg->sensor_idx] = 0;
ret = ccu_allocate_mva(&i2c_mva[ioarg->sensor_idx], va, 4096);
ioarg->mva = i2c_mva[ioarg->sensor_idx];
mutex_unlock(&ccu_i2c_mutex);
return ret;
}
int ccu_i2c_free_dma_buf_mva_all(void)
{
uint32_t i;
mutex_lock(&ccu_i2c_mutex);
for (i = IMGSENSOR_SENSOR_IDX_MIN_NUM;
i < IMGSENSOR_SENSOR_IDX_MAX_NUM; i++) {
ccu_deallocate_mva(i2c_mva[i]);
i2c_mva[i] = 0;
}
LOG_INF_MUST("%s done.\n", __func__);
mutex_unlock(&ccu_i2c_mutex);
return 0;
}
/*---------------------------------------------------------------------------*/
/* CCU i2c static funcs */
/*---------------------------------------------------------------------------*/
static int i2c_query_dma_buffer_addr(uint32_t sensor_idx,
void **va, uint32_t *va_h, uint32_t *va_l, uint32_t *i2c_id)
{
struct i2c_client *pClient = NULL;
struct mt_i2c *i2c;
pClient = get_ccu_i2c_client(*i2c_id);
if (pClient == MNULL) {
LOG_ERR("ccu client is NULL");
return -EFAULT;
}
i2c = i2c_get_adapdata(pClient->adapter);
/*i2c_get_dma_buffer_addr_imp(pClient->adapter ,va);*/
*va = i2c->dma_buf.vaddr + PAGE_SIZE;
*va_l = i2c->dma_buf.paddr + PAGE_SIZE;
*va_h = 0;
#ifdef CONFIG_COMPAT
*va_h = ((i2c->dma_buf.paddr + PAGE_SIZE) >> 32);
#endif
*i2c_id = i2c->id;
#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
LOG_DBG_MUST("$$pa(%lld), va(%p), i2c-id(%d)\n",
i2c->dma_buf.paddr + PAGE_SIZE,
i2c->dma_buf.vaddr + PAGE_SIZE, (uint32_t)i2c->id);
#else
LOG_DBG_MUST("$$pa(%ld), va(%p), i2c-id(%d)\n",
i2c->dma_buf.paddr + PAGE_SIZE,
i2c->dma_buf.vaddr + PAGE_SIZE, (uint32_t)i2c->id);
#endif
return 0;
}
static int ccu_i2c_controller_en(uint32_t i2c_id,
int enable)
{
int ret = 0;
struct i2c_client *pClient = NULL;
struct mt_i2c *i2c;
LOG_INF_MUST("%s, id(%d):(%d)->(%d)\n", __func__,
i2c_id, ccu_i2c_initialized[i2c_id], enable);
pClient = get_ccu_i2c_client(i2c_id);
LOG_DBG("%s, pClient: %p\n", __func__, pClient);
if (pClient == NULL) {
LOG_ERR("i2c_client is null\n");
return -1;
}
if (enable) {
if (ccu_i2c_initialized[i2c_id] == MFALSE) {
ret = i2c_ccu_enable(pClient->adapter,
I2C_BASE_OFS_CH1);
ccu_i2c_initialized[i2c_id] = MTRUE;
LOG_INF_MUST("i2c_ccu_enable done.\n");
/*dump controller status*/
i2c = i2c_get_adapdata(pClient->adapter);
/*MCU_INTR re-direct to CCU only*/
i2c_writew(2, i2c, 0x240);
}
} else {
if (ccu_i2c_initialized[i2c_id] == MTRUE) {
ret = i2c_ccu_disable(pClient->adapter);
ccu_i2c_initialized[i2c_id] = MFALSE;
LOG_INF_MUST("i2c_ccu_disable done.\n");
}
}
return ret;
}
static int ccu_i2c_controller_uninit(uint32_t i2c_id)
{
if (ccu_i2c_controller_en(i2c_id, 0) == -1) {
LOG_DBG("ccu_i2c_controller_en 0 fail\n");
return -1;
}
LOG_DBG_MUST("%s done: id(%d)\n", __func__,
i2c_id);
return 0;
}
static struct i2c_client *get_ccu_i2c_client(
uint32_t i2c_id)
{
switch (i2c_id) {
case 2:
{
return g_ccuI2cClient2;
}
case 4:
{
return g_ccuI2cClient4;
}
case 7:
{
return g_ccuI2cClient7;
}
default:
{
return MNULL;
}
}
}
static inline void i2c_writew(u16 value, struct mt_i2c *i2c, u16 offset)
{
writew(value, i2c->base + offset);
}
@@ -0,0 +1,33 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CCU_I2C_H__
#define __CCU_I2C_H__
#include "kd_camera_feature.h"
struct ccu_i2c_buf_mva_ioarg {
uint32_t sensor_idx;
uint32_t mva;
uint32_t va_h;
uint32_t va_l;
uint32_t i2c_id;
};
struct ccu_i2c_info {
uint32_t slave_addr;
uint32_t i2c_id;
};
/*i2c driver hook*/
int ccu_i2c_register_driver(void);
int ccu_i2c_delete_driver(void);
/*ccu i2c operation*/
//int ccu_i2c_set_channel(enum CCU_I2C_CHANNEL);
int ccu_get_i2c_dma_buf_addr(struct ccu_i2c_buf_mva_ioarg *ioarg);
int ccu_i2c_controller_init(uint32_t i2c_id);
int ccu_i2c_controller_uninit_all(void);
int ccu_i2c_free_dma_buf_mva_all(void);
#endif
@@ -0,0 +1,20 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/io.h>
#include "ccu_drv.h"
#include "ccu_cmn.h"
#include "ccu_n3d_a.h"
inline u32 n3d_a_readw(unsigned long n3d_a_base, u32 offset)
{
return readl((u32 *) (n3d_a_base + offset));
}
inline void n3d_a_writew(u32 value, unsigned long n3d_a_base, u32 offset)
{
writel(value, (u32 *) (n3d_a_base + offset));
}
@@ -0,0 +1,19 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CCU_N3D_A_H__
#define __CCU_N3D_A_H__
enum N3DA_REGS_OFFSET {
OFFSET_CTL = 0x100,
OFFSET_TRIG = 0x108,
OFFSET_INT = 0x10C,
};
extern u32 n3d_a_readw(unsigned long n3d_a_base, u32 offset);
extern void n3d_a_writew(u32 value, unsigned long n3d_a_base, u32 offset);
#endif
@@ -0,0 +1,36 @@
#
# 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_MTK_ION),y)
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion/
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion/mtk/
else
ccflags-$(CONFIG_ION) += -I$(srctree)/drivers/staging/android/aosp_ion/
endif
ccflags-y += -I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/$(MTK_PLATFORM)/ccu_ext_interface/
ccflags-y += -I$(srctree)/drivers/i2c/busses
ccflags-y += -I$(srctree)/drivers/iommu/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/imgsensor/inc
ccflags-y += -I$(srctree)/drivers/misc/mediatek/smi/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mmdvfs/
#$(warning $(subdir-ccflags-y))
#obj-$(CONFIG_MTK_VPU) += ccu_drv.o ccu_algo.o ccu_dbg.o
obj-y += ccu_drv.o ccu_n3d_a.o ccu_i2c.o
+254
View File
@@ -0,0 +1,254 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_CMN_H__
#define __CCU_CMN_H__
#include <linux/wait.h>
#include <linux/seq_file.h>
#include <linux/interrupt.h>
#include "ccu_drv.h"
#define CCU_I2C_DMA_BUF_SIZE (4*PAGE_SIZE)
/* Common Structure */
enum ccu_req_type_e {
CCU_IRQ_TYPE_XXX,
CCU_IRQ_NUM_TYPES
};
struct ccu_device_s {
struct proc_dir_entry *proc_dir;
struct device *dev;
struct dentry *debug_root;
void __iomem *ccu_base;
void __iomem *camsys_base;
void __iomem *bin_base;
void __iomem *dmem_base;
void __iomem *pmem_base;
void __iomem *ddrmem_base;
unsigned int irq_num;
struct mutex user_mutex;
struct mutex ion_client_mutex;
struct mutex dev_mutex;
struct mutex clk_mutex;
u8 *i2c_dma_vaddr;
dma_addr_t i2c_dma_paddr;
uint32_t i2c_dma_mva;
/* list of vlist_type(ccu_user_t) */
struct list_head user_list;
/* notify enque thread */
wait_queue_head_t cmd_wait;
};
struct ccu_user_s {
pid_t open_pid;
pid_t open_tgid;
uint32_t id;
/* to enque/deque must have mutex protection */
struct mutex data_mutex;
bool running;
bool flush;
/* list of vlist_type(ccu_cmd_st) */
struct list_head enque_ccu_cmd_list;
struct list_head deque_ccu_cmd_list;
wait_queue_head_t deque_wait;
};
/*type must be struct*/
/*#define DECLARE_VLIST(type) \*/
/*typedef struct { \*/
/*type node; \*/
/*struct list_head link; \*/
/*} type ## _list*/
/*
* vlist_node_of - get the pointer to the node which has specific vlist
* @ptr: the pointer to struct list_head
* @type: the type of list node
*/
#define vlist_node_of(ptr, type) ({ \
const struct list_head *__mptr = (ptr); \
(type *)((char *)__mptr - offsetof(type ## _list, link)); })
/*
* vlist_link - get the pointer to struct list_head
* @ptr: the pointer to struct vlist
* @type: the type of list node
*/
#define vlist_link(ptr, type) (&((type ## _list *)ptr)->link)
/*
* vlist_type - get the type of struct vlist
* @type: the type of list node
*/
#define vlist_type(type) type ## _list
/*
* vlist_node - get the pointer to the node of vlist
* @ptr: the pointer to struct vlist
* @type: the type of list node
*/
#define vlist_node(ptr, type) ((type *) ptr)
/*typedef struct work_struct work_struct_t;*/
/*DECLARE_VLIST(work_struct_t);*/
/*DECLARE_VLIST(struct ccu_user_s);*/
struct ccu_user_s_list {
struct ccu_user_s node;
struct list_head link;
};
/*DECLARE_VLIST(struct ccu_cmd_s);*/
struct ccu_cmd_s_list {
struct ccu_cmd_s node;
struct list_head link;
};
/* ================= define in ccu_hw.c =================== */
/**
* ccu_init_hw - init the procedure related to hw, include irq
* register and enque thread
* @device: the pointer of ccu_device.
*/
int ccu_init_hw(struct ccu_device_s *device);
/**
* ccu_uninit_hw - close resources related to hw module
*/
int ccu_uninit_hw(struct ccu_device_s *device);
/**
* ccu_mmap_hw - mmap kernel memory to user
*/
int ccu_mmap_hw(struct file *filp, struct vm_area_struct *vma);
/**
* ccu_power - config ccu power.
* @s: the pointer to power relative settings.
*/
int ccu_power(struct ccu_power_s *power);
/**
* ccu_force_powerdown - force CCU to stop & shutdown
*/
int ccu_force_powerdown(void);
/**
* ccu_load_bin - load ccu dm/pm binary.
*/
int ccu_load_bin(struct ccu_device_s *device, struct ccu_bin_info_s *bin_info);
int ccu_sw_hw_reset(void);
/**
* ccu_run - start running ccu .
*/
int ccu_run(struct ccu_run_s *info);
/**
* ccu_irq - interrupt wait.
* @s: wait mode.
*/
int ccu_waitirq(struct CCU_WAIT_IRQ_STRUCT *WaitIrq);
int ccu_AFwaitirq(struct CCU_WAIT_IRQ_STRUCT *WaitIrq, int sensoridx);
/**
* ccu_irq - interrupt wait.
* @s: wait mode.
*/
int ccu_flushLog(int argc, int *argv);
int ccu_memcpy(void *dest, void *src, int length);
int ccu_memclr(void *dest, int length);
int ccu_read_struct_size(uint32_t *structSizes, uint32_t structCnt);
void ccu_print_reg(uint32_t *Reg);
void ccu_print_sram_log(char *sram_log);
int ccu_read_data(uint32_t *buf, uint32_t ccu_da, uint32_t size);
int ccu_query_power_status(void);
/* ================ define in ccu_drv.c ================ */
/**
* ccu_create_user - create ccu user, and add to user list
* @ruser: return the created user.
*/
int ccu_create_user(struct ccu_user_s **ruser);
/**
* ccu_delete_user - delete ccu user, and remove it from user list
* @user: the pointer to user.
*/
int ccu_delete_user(struct ccu_user_s *user);
int ccu_lock_ion_client_mutex(void);
int ccu_unlock_ion_client_mutex(void);
/**
* ccu_clock_enable - Set CCU clock on
*/
int ccu_clock_enable(void);
/**
* ccu_clock_disable - Set CCU clock off
*/
void ccu_clock_disable(void);
/* LOG & AEE */
#define CCU_TAG "[ccu]"
#define LOG_DBG_MUST(format, args...) \
pr_debug(CCU_TAG "[%s] " format, __func__, ##args)
#define LOG_INF_MUST(format, args...) \
pr_info(CCU_TAG "[%s] " format, __func__, ##args)
#define LOG_DBG(format, args...)
#define LOG_INF(format, args...)
#define LOG_WARN(format, args...) \
pr##_##warn(CCU_TAG "[%s] " format, __func__, ##args)
#define LOG_ERR(format, args...) \
pr##_##err(CCU_TAG "[%s] " format, __func__, ##args)
#define LOG_DERR(device, format, args...) \
dev##_##err(device, CCU_TAG "[%s] " format, __func__, ##args)
#define ccu_print_seq(seq_file, fmt, args...) \
do {\
if (seq_file)\
seq_printf(seq_file, fmt, ##args);\
else\
pr_debug(fmt, ##args);\
} while (0)
#define ccu_error(format, args...) \
do {\
LOG_ERR(CCU_TAG " error:"format, ##args); \
aee_kernel_exception("CCU", "[CCU] error:"format, ##args); \
} while (0)
#define ccu_aee(format, args...) \
do {\
char ccu_name[100];\
snprintf(ccu_name, 100, CCU_TAG format, ##args); \
aee_kernel_warning_api(__FILE__, __LINE__, \
DB_OPT_MMPROFILE_BUFFER | DB_OPT_DUMP_DISPLAY, \
ccu_name, CCU_TAG "error" format, ##args); \
LOG_ERR(CCU_TAG " error:" format, ##args); \
} while (0)
#endif
File diff suppressed because it is too large. Load diff
+374
View File
@@ -0,0 +1,374 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_DRV_H__
#define __CCU_DRV_H__
#include <linux/types.h>
#include <linux/ioctl.h>
#include "ccu_mailbox_extif.h"
#include "kd_camera_feature.h"/*for sensoridx enum*/
#ifdef CONFIG_COMPAT
/*64 bit*/
#include <linux/fs.h>
#include <linux/compat.h>
#endif
/*---------------------------------------------------------------------------*/
/* CCU IRQ */
/*---------------------------------------------------------------------------*/
#define IRQ_USER_NUM_MAX 32
#define SUPPORT_MAX_IRQ 32
enum CCU_IRQ_CLEAR_ENUM {
CCU_IRQ_CLEAR_NONE, /* non-clear wait, clear after wait */
CCU_IRQ_CLEAR_WAIT, /* clear wait, clear before and after wait */
CCU_IRQ_CLEAR_STATUS, /* clear specific status only */
CCU_IRQ_CLEAR_ALL /* clear all status */
};
enum CCU_IRQ_TYPE_ENUM {
CCU_IRQ_TYPE_INT_CCU_ST,
CCU_IRQ_TYPE_INT_CCU_A_ST,
CCU_IRQ_TYPE_INT_CCU_B_ST,
CCU_IRQ_TYPE_AMOUNT
};
enum CCU_ST_ENUM {
CCU_SIGNAL_INT = 0, CCU_DMA_INT, CCU_IRQ_ST_AMOUNT
};
struct CCU_IRQ_TIME_STRUCT {
unsigned int tLastSig_sec;
/* time stamp of the latest occurring signal */
unsigned int tLastSig_usec;
/* time stamp of the latest occurring signal */
unsigned int tMark2WaitSig_sec;
/* time period from marking a signal to user try to wait and get the signal */
unsigned int tMark2WaitSig_usec;
/* time period from marking a signal to user try to wait and get the signal */
unsigned int tLastSig2GetSig_sec;
/* time period from latest signal to user try to wait and get the signal */
unsigned int tLastSig2GetSig_usec;
/* time period from latest signal to user try to wait and get the signal */
int passedbySigcnt; /* the count for the signal passed by */
};
struct CCU_WAIT_IRQ_ST {
enum CCU_IRQ_CLEAR_ENUM Clear;
enum CCU_ST_ENUM St_type;
unsigned int Status;
int UserKey; /* user key for doing interrupt operation */
unsigned int Timeout;
struct CCU_IRQ_TIME_STRUCT TimeInfo;
};
struct CCU_REGISTER_USERKEY_STRUCT {
int userKey;
char userName[32];
};
struct CCU_WAIT_IRQ_STRUCT {
enum CCU_IRQ_TYPE_ENUM Type;
unsigned int bDumpReg;
struct CCU_WAIT_IRQ_ST EventInfo;
};
struct CCU_CLEAR_IRQ_ST {
int UserKey; /* user key for doing interrupt operation */
enum CCU_ST_ENUM St_type;
unsigned int Status;
};
struct CCU_CLEAR_IRQ_STRUCT {
enum CCU_IRQ_TYPE_ENUM Type;
struct CCU_CLEAR_IRQ_ST EventInfo;
};
struct CCU_REG_STRUCT {
unsigned int module;
unsigned int Addr; /* register's addr */
unsigned int Val; /* register's value */
};
struct CCU_REG_IO_STRUCT {
struct CCU_REG_STRUCT *pData; /* pointer to struct CCU_REG_STRUCT */
unsigned int Count; /* count */
};
struct CCU_IRQ_INFO_STRUCT {
/* Add an extra index for status type in Ever -> signal or dma */
unsigned int Status[CCU_IRQ_TYPE_AMOUNT][CCU_IRQ_ST_AMOUNT][IRQ_USER_NUM_MAX];
unsigned int Mask[CCU_IRQ_TYPE_AMOUNT][CCU_IRQ_ST_AMOUNT];
unsigned int ErrMask[CCU_IRQ_TYPE_AMOUNT][CCU_IRQ_ST_AMOUNT];
signed int WarnMask[CCU_IRQ_TYPE_AMOUNT][CCU_IRQ_ST_AMOUNT];
/* flag for indicating that user do mark for a interrupt or not */
unsigned int MarkedFlag[CCU_IRQ_TYPE_AMOUNT][CCU_IRQ_ST_AMOUNT][IRQ_USER_NUM_MAX];
/* time for marking a specific interrupt */
unsigned int MarkedTime_sec[CCU_IRQ_TYPE_AMOUNT][32][IRQ_USER_NUM_MAX];
/* time for marking a specific interrupt */
unsigned int MarkedTime_usec[CCU_IRQ_TYPE_AMOUNT][32][IRQ_USER_NUM_MAX];
/* number of a specific signal that passed by */
signed int PassedBySigCnt[CCU_IRQ_TYPE_AMOUNT][32][IRQ_USER_NUM_MAX];
/* */
unsigned int LastestSigTime_sec[CCU_IRQ_TYPE_AMOUNT][32];
/* latest time for each interrupt */
unsigned int LastestSigTime_usec[CCU_IRQ_TYPE_AMOUNT][32];
/* latest time for each interrupt */
};
#define CCU_ISR_MAX_NUM 32
#define INT_ERR_WARN_TIMER_THREAS 1000
#define INT_ERR_WARN_MAX_TIME 3
struct CCU_IRQ_ERR_WAN_CNT_STRUCT {
unsigned int m_err_int_cnt[CCU_IRQ_TYPE_AMOUNT][CCU_ISR_MAX_NUM]; /* cnt for each err int # */
unsigned int m_warn_int_cnt[CCU_IRQ_TYPE_AMOUNT][CCU_ISR_MAX_NUM]; /* cnt for each warning int # */
unsigned int m_err_int_mark[CCU_IRQ_TYPE_AMOUNT]; /* mark for err int, where its cnt > threshold */
unsigned int m_warn_int_mark[CCU_IRQ_TYPE_AMOUNT]; /* mark for warn int, where its cnt > threshold */
unsigned long m_int_usec[CCU_IRQ_TYPE_AMOUNT];
};
#define CCU_BUF_SIZE (4096)
#define CCU_BUF_SIZE_WRITE 1024
#define CCU_BUF_WRITE_AMOUNT 6
enum CCU_BUF_STATUS_ENUM {
CCU_BUF_STATUS_EMPTY,
CCU_BUF_STATUS_HOLD,
CCU_BUF_STATUS_READY
};
struct CCU_BUF_STRUCT {
enum CCU_BUF_STATUS_ENUM Status;
unsigned int Size;
unsigned char *pData;
};
struct CCU_BUF_INFO_STRUCT {
struct CCU_BUF_STRUCT Read;
struct CCU_BUF_STRUCT Write[CCU_BUF_WRITE_AMOUNT];
};
struct CCU_TIME_LOG_STRUCT {
unsigned int Vd;
unsigned int Expdone;
unsigned int WorkQueueVd;
unsigned int WorkQueueExpdone;
unsigned int TaskletVd;
unsigned int TaskletExpdone;
};
#ifdef MTK_VPU_KERNEL
struct CCU_INFO_STRUCT {
spinlock_t SpinLockCcuRef;
spinlock_t SpinLockCcu;
spinlock_t SpinLockIrq[CCU_IRQ_TYPE_AMOUNT];
spinlock_t SpinLockIrqCnt[CCU_IRQ_TYPE_AMOUNT];
spinlock_t SpinLockRTBC;
spinlock_t SpinLockClock;
spinlock_t SpinLockI2cPower;
unsigned int IsCcuPoweredOn;
wait_queue_head_t WaitQueueHead;
wait_queue_head_t AFWaitQueueHead[IMGSENSOR_SENSOR_IDX_MAX_NUM];
wait_queue_head_t WaitQHeadList[SUPPORT_MAX_IRQ];
unsigned int UserCount;
unsigned int DebugMask;
signed int IrqNum;
struct CCU_IRQ_INFO_STRUCT IrqInfo;
struct CCU_IRQ_ERR_WAN_CNT_STRUCT IrqCntInfo;
struct CCU_BUF_INFO_STRUCT BufInfo;
struct CCU_TIME_LOG_STRUCT TimeLog;
};
#endif
/*---------------------------------------------------------------------------*/
/* CCU working buffer */
/*---------------------------------------------------------------------------*/
#define SIZE_32BYTE (32)
#define SIZE_1MB (1024*1024)
#define SIZE_1MB_PWR2PAGE (8)
#define MAX_I2CBUF_NUM 1
#define MAX_MAILBOX_NUM 2
#define MAX_LOG_BUF_NUM 2
#define MAILBOX_SEND 0
#define MAILBOX_GET 1
struct ccu_working_buffer_s {
uint8_t *va_pool;
uint32_t mva_pool;
uint32_t sz_pool;
uint8_t *va_i2c; /* i2c buffer mode */
uint32_t mva_i2c;
uint32_t sz_i2c;
uint8_t *va_mb[MAX_MAILBOX_NUM]; /* mailbox */
uint32_t mva_mb[MAX_MAILBOX_NUM];
uint32_t sz_mb[MAX_MAILBOX_NUM];
char *va_log[MAX_LOG_BUF_NUM]; /* log buffer */
uint32_t mva_log[MAX_LOG_BUF_NUM];
uint32_t sz_log[MAX_LOG_BUF_NUM];
int32_t fd_log[MAX_LOG_BUF_NUM];
};
#ifdef CONFIG_COMPAT
struct compat_ccu_working_buffer_s {
compat_uptr_t va_pool;
uint32_t mva_pool;
uint32_t sz_pool;
compat_uptr_t va_i2c; /* i2c buffer mode */
uint32_t mva_i2c;
uint32_t sz_i2c;
compat_uptr_t va_mb[MAX_MAILBOX_NUM]; /* mailbox */
uint32_t mva_mb[MAX_MAILBOX_NUM];
uint32_t sz_mb[MAX_MAILBOX_NUM];
compat_uptr_t va_log[MAX_LOG_BUF_NUM]; /* log buffer */
uint32_t mva_log[MAX_LOG_BUF_NUM];
uint32_t sz_log[MAX_LOG_BUF_NUM];
int32_t fd_log[MAX_LOG_BUF_NUM];
};
#endif
/*---------------------------------------------------------------------------*/
/* CCU Power */
/*---------------------------------------------------------------------------*/
struct ccu_power_s {
uint32_t bON;
uint32_t freq;
uint32_t power;
struct ccu_working_buffer_s workBuf;
};
#ifdef CONFIG_COMPAT
struct compat_ccu_power_s {
uint32_t bON;
uint32_t freq;
uint32_t power;
struct compat_ccu_working_buffer_s workBuf;
};
#endif
/*---------------------------------------------------------------------------*/
/* CCU Run */
/*---------------------------------------------------------------------------*/
struct ccu_run_s {
uint32_t log_level;
uint32_t log_taglevel;
uint32_t CtrlBufMva;
uint32_t CpuRefBufMva;
uint32_t CpuRefBufSz;
uint32_t bkdata_ddr_buf_mva;
uint32_t AEShareBufMva;
uint32_t LTMShareBufMva;
uint32_t AFShareBufMva;
};
/*---------------------------------------------------------------------------*/
/* CCU command */
/*---------------------------------------------------------------------------*/
enum ccu_eng_status_e {
CCU_ENG_STATUS_SUCCESS,
CCU_ENG_STATUS_BUSY,
CCU_ENG_STATUS_TIMEOUT,
CCU_ENG_STATUS_INVALID,
CCU_ENG_STATUS_FLUSH,
CCU_ENG_STATUS_FAILURE,
CCU_ENG_STATUS_ERESTARTSYS,
};
/*---------------------------------------------------------------------------*/
/* CCU Command */
/*---------------------------------------------------------------------------*/
struct ccu_cmd_s {
struct ccu_msg task;
enum ccu_eng_status_e status;
};
#define CCU_IMPORT_BUF_NUM 200
#define CCU_IMPORT_BUF_UNDEF 0xFFFFFFFF
struct import_mem_s {
uint32_t memID[CCU_IMPORT_BUF_NUM];
};
/*---------------------------------------------------------------------------*/
/* CCU Read/Write Reg */
/*---------------------------------------------------------------------------*/
struct ccu_reg_s {
uint32_t reg_no;
uint32_t reg_val;
};
/*---------------------------------------------------------------------------*/
/* CAM FREQ */
/*---------------------------------------------------------------------------*/
#define CCU_REQ_CAM_FREQ_HIGH 2
#define CCU_REQ_CAM_FREQ_MID 1
#define CCU_REQ_CAM_FREQ_NONE 0
/*---------------------------------------------------------------------------*/
/* CCU LOAD BIN */
/*---------------------------------------------------------------------------*/
enum CCU_BIN_TYPE {
CCU_DP_BIN,
CCU_DDR_BIN,
CCU_DRIVER_BIN
};
#define CCU_BIN_NAME_MAX_LENGTH 50
struct ccu_bin_info_s {
enum CCU_BIN_TYPE type;
char name[CCU_BIN_NAME_MAX_LENGTH];
};
/*---------------------------------------------------------------------------*/
/* IOCTL Command */
/*---------------------------------------------------------------------------*/
#define CCU_MAGICNO 'c'
#define CCU_IOCTL_SET_POWER _IOW(CCU_MAGICNO, 0, int)
#define CCU_IOCTL_ENQUE_COMMAND _IOW(CCU_MAGICNO, 1, int)
#define CCU_IOCTL_DEQUE_COMMAND _IOWR(CCU_MAGICNO, 2, int)
#define CCU_IOCTL_FLUSH_COMMAND _IOW(CCU_MAGICNO, 3, int)
#define CCU_IOCTL_WAIT_AF_IRQ _IOW(CCU_MAGICNO, 8, int)
#define CCU_IOCTL_WAIT_IRQ _IOW(CCU_MAGICNO, 9, int)
#define CCU_IOCTL_SEND_CMD _IOWR(CCU_MAGICNO, 10, int)
#define CCU_IOCTL_SET_RUN_INPUT _IOW(CCU_MAGICNO, 11, int)
#define CCU_CLEAR_IRQ _IOW(CCU_MAGICNO, 12, int)
#define CCU_REGISTER_IRQ_USER_KEY _IOR(CCU_MAGICNO, 13, int)
#define CCU_READ_REGISTER _IOWR(CCU_MAGICNO, 14, int)
#define CCU_WRITE_REGISTER _IOWR(CCU_MAGICNO, 15, int)
#define CCU_IOCTL_SET_WORK_BUF _IOW(CCU_MAGICNO, 18, int)
#define CCU_IOCTL_FLUSH_LOG _IOW(CCU_MAGICNO, 19, int)
#define CCU_IOCTL_GET_I2C_DMA_BUF_ADDR _IOR(CCU_MAGICNO, 20, int)
#define CCU_IOCTL_SET_I2C_MODE _IOW(CCU_MAGICNO, 21, int)
#define CCU_IOCTL_GET_CURRENT_FPS _IOR(CCU_MAGICNO, 23, int)
#define CCU_IOCTL_GET_SENSOR_I2C_SLAVE_ADDR _IOR(CCU_MAGICNO, 24, int)
#define CCU_IOCTL_GET_SENSOR_NAME _IOR(CCU_MAGICNO, 25, int)
#define CCU_IOCTL_GET_PLATFORM_INFO _IOR(CCU_MAGICNO, 26, int)
#define CCU_IOCTL_IMPORT_MEM _IOW(CCU_MAGICNO, 27, int)
#define CCU_IOCTL_UPDATE_QOS_REQUEST _IOW(CCU_MAGICNO, 28, int)
#define CCU_IOCTL_UPDATE_CAM_FREQ_REQUEST _IOW(CCU_MAGICNO, 29, int)
#define CCU_IOCTL_LOAD_CCU_BIN _IOW(CCU_MAGICNO, 30, int)
#define CCU_IOCTL_IPC_INIT _IOW(CCU_MAGICNO, 31, int)
#define CCU_IOCTL_IPC_SEND_CMD _IOW(CCU_MAGICNO, 32, int)
#define CCU_IOCTL_ALLOC_MEM _IOW(CCU_MAGICNO, 33, int)
#define CCU_IOCTL_DEALLOC_MEM _IOW(CCU_MAGICNO, 34, int)
#define CCU_IOCTL_GET_IOVA _IOWR(CCU_MAGICNO, 35, int)
#define CCU_READ_STRUCT_SIZE _IOWR(CCU_MAGICNO, 36, int)
#define CCU_IOCTL_PRINT_REG _IOR(CCU_MAGICNO, 37, int)
#define CCU_IOCTL_PRINT_SRAM_LOG _IOR(CCU_MAGICNO, 38, int)
#define CCU_READ_DATA _IOWR(CCU_MAGICNO, 39, int)
#endif
+561
View File
@@ -0,0 +1,561 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/platform_device.h>
#include <linux/dma-mapping.h>
#include <linux/delay.h>
#include <linux/uaccess.h>
#include <linux/sched.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/i2c.h>
#include "i2c-mtk.h"
#include <m4u.h>
#include "kd_camera_feature.h"/*for IMGSENSOR_SENSOR_IDX*/
#include "ccu_cmn.h"
#include "ccu_i2c.h"
#include "ccu_i2c_hw.h"
#include "ccu_mva.h"
#include "ccu_imgsensor.h"
/*******************************************************************************
*
******************************************************************************/
/*I2C Channel offset*/
#define I2C_BASE_OFS_CH1 (0x200)
#define MAX_I2C_CMD_LEN 255
#define CCU_I2C_APDMA_TXLEN 128
#define CCU_I2C_2_HW_DRVNAME "ccu_i2c_2_hwtrg"
#define CCU_I2C_4_HW_DRVNAME "ccu_i2c_4_hwtrg"
#define CCU_I2C_6_HW_DRVNAME "ccu_i2c_6_hwtrg"
#define CCU_I2C_7_HW_DRVNAME "ccu_i2c_7_hwtrg"
static DEFINE_MUTEX(ccu_i2c_mutex);
/*i2c driver hook*/
static int ccu_i2c_probe_2(struct i2c_client *client,
const struct i2c_device_id *id);
static int ccu_i2c_probe_4(struct i2c_client *client,
const struct i2c_device_id *id);
static int ccu_i2c_probe_6(struct i2c_client *client,
const struct i2c_device_id *id);
static int ccu_i2c_probe_7(struct i2c_client *client,
const struct i2c_device_id *id);
static int ccu_i2c_remove(struct i2c_client *client);
/*ccu i2c operation*/
static struct i2c_client *get_ccu_i2c_client(uint32_t i2c_id);
static void ccu_i2c_dump_info(struct mt_i2c *i2c);
static int ccu_i2c_controller_en(uint32_t i2c_id, int enable);
static int i2c_query_dma_buffer_addr(struct ccu_device_s
*g_ccu_device, uint32_t sensor_idx,
uint32_t *mva, uint32_t *va_h, uint32_t *va_l, uint32_t *i2c_id);
static int ccu_i2c_controller_uninit(uint32_t i2c_id);
/*i2c reg operation*/
static inline u32 i2c_readl_dma(struct mt_i2c *i2c, u8 offset);
static inline void i2c_writel_dma(u32 value, struct mt_i2c *i2c,
u8 offset);
static inline u16 i2c_readw(struct mt_i2c *i2c, u8 offset);
static inline void i2c_writew(u16 value, struct mt_i2c *i2c,
u16 offset);
static struct i2c_client *g_ccuI2cClient2;
static struct i2c_client *g_ccuI2cClient4;
static struct i2c_client *g_ccuI2cClient6;
static struct i2c_client *g_ccuI2cClient7;
static const struct i2c_device_id ccu_i2c_2_ids[]
= { {CCU_I2C_2_HW_DRVNAME, 0}, {} };
static const struct i2c_device_id ccu_i2c_4_ids[]
= { {CCU_I2C_4_HW_DRVNAME, 0}, {} };
static const struct i2c_device_id ccu_i2c_6_ids[]
= { {CCU_I2C_6_HW_DRVNAME, 0}, {} };
static const struct i2c_device_id ccu_i2c_7_ids[]
= { {CCU_I2C_7_HW_DRVNAME, 0}, {} };
static bool ccu_i2c_initialized[I2C_MAX_CHANNEL] = {0};
#ifdef CONFIG_OF
static const struct of_device_id ccu_i2c_2_driver_of_ids[] = {
{.compatible = "mediatek,ccu_sensor_i2c_2_hw",},
{}
};
static const struct of_device_id ccu_i2c_4_driver_of_ids[] = {
{.compatible = "mediatek,ccu_sensor_i2c_4_hw",},
{}
};
static const struct of_device_id ccu_i2c_6_driver_of_ids[] = {
{.compatible = "mediatek,ccu_sensor_i2c_6_hw",},
{}
};
static const struct of_device_id ccu_i2c_7_driver_of_ids[] = {
{.compatible = "mediatek,ccu_sensor_i2c_7_hw",},
{}
};
#endif
struct i2c_driver ccu_i2c_2_driver = {
.probe = ccu_i2c_probe_2,
.remove = ccu_i2c_remove,
.driver = {
.name = CCU_I2C_2_HW_DRVNAME,
.owner = THIS_MODULE,
#ifdef CONFIG_OF
.of_match_table = ccu_i2c_2_driver_of_ids,
#endif
},
.id_table = ccu_i2c_2_ids,
};
struct i2c_driver ccu_i2c_4_driver = {
.probe = ccu_i2c_probe_4,
.remove = ccu_i2c_remove,
.driver = {
.name = CCU_I2C_4_HW_DRVNAME,
.owner = THIS_MODULE,
#ifdef CONFIG_OF
.of_match_table = ccu_i2c_4_driver_of_ids,
#endif
},
.id_table = ccu_i2c_4_ids,
};
struct i2c_driver ccu_i2c_6_driver = {
.probe = ccu_i2c_probe_6,
.remove = ccu_i2c_remove,
.driver = {
.name = CCU_I2C_6_HW_DRVNAME,
.owner = THIS_MODULE,
#ifdef CONFIG_OF
.of_match_table = ccu_i2c_6_driver_of_ids,
#endif
},
.id_table = ccu_i2c_6_ids,
};
struct i2c_driver ccu_i2c_7_driver = {
.probe = ccu_i2c_probe_7,
.remove = ccu_i2c_remove,
.driver = {
.name = CCU_I2C_7_HW_DRVNAME,
.owner = THIS_MODULE,
#ifdef CONFIG_OF
.of_match_table = ccu_i2c_7_driver_of_ids,
#endif
},
.id_table = ccu_i2c_7_ids,
};
/*---------------------------------------------------------------------------*/
/* CCU Driver: i2c driver funcs */
/*---------------------------------------------------------------------------*/
static int ccu_i2c_probe_2(struct i2c_client *client,
const struct i2c_device_id *id)
{
LOG_DBG_MUST(
"[ccu_i2c_probe] Attach I2C for HW trriger g_ccuI2cClient2 %p\n",
client);
/* get sensor i2c client */
g_ccuI2cClient2 = client;
LOG_DBG_MUST("[ccu_i2c_probe] Attached!!\n");
return 0;
}
static int ccu_i2c_probe_4(struct i2c_client *client,
const struct i2c_device_id *id)
{
LOG_DBG_MUST(
"[ccu_i2c_probe] Attach I2C for HW trriger g_ccuI2cClient4 %p\n",
client);
/* get sensor i2c client */
g_ccuI2cClient4 = client;
LOG_DBG_MUST("[ccu_i2c_probe] Attached!!\n");
return 0;
}
static int ccu_i2c_probe_6(struct i2c_client *client,
const struct i2c_device_id *id)
{
LOG_DBG_MUST(
"[ccu_i2c_probe] Attach I2C for HW trriger g_ccuI2cClient6 %p\n",
client);
/* get sensor i2c client */
g_ccuI2cClient6 = client;
LOG_DBG_MUST("[ccu_i2c_probe] Attached!!\n");
return 0;
}
static int ccu_i2c_probe_7(struct i2c_client *client,
const struct i2c_device_id *id)
{
LOG_DBG_MUST(
"[ccu_i2c_probe] Attach I2C for HW trriger g_ccuI2cClient7 %p\n",
client);
/* get sensor i2c client */
g_ccuI2cClient7 = client;
LOG_DBG_MUST("[ccu_i2c_probe] Attached!!\n");
return 0;
}
static int ccu_i2c_remove(struct i2c_client *client)
{
return 0;
}
/*---------------------------------------------------------------------------*/
/* CCU i2c public funcs */
/*---------------------------------------------------------------------------*/
int ccu_i2c_register_driver(void)
{
int i2c_ret = 0;
mutex_lock(&ccu_i2c_mutex);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_2_driver)++\n");
i2c_ret = i2c_add_driver(&ccu_i2c_2_driver);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_2_driver), ret: %d--\n",
i2c_ret);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_4_driver)++\n");
i2c_ret = i2c_add_driver(&ccu_i2c_4_driver);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_4_driver), ret: %d--\n",
i2c_ret);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_6_driver)++\n");
i2c_ret = i2c_add_driver(&ccu_i2c_6_driver);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_6_driver), ret: %d--\n",
i2c_ret);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_7_driver)++\n");
i2c_ret = i2c_add_driver(&ccu_i2c_7_driver);
LOG_DBG_MUST("i2c_add_driver(&ccu_i2c_7_driver), ret: %d--\n",
i2c_ret);
mutex_unlock(&ccu_i2c_mutex);
return 0;
}
int ccu_i2c_delete_driver(void)
{
mutex_lock(&ccu_i2c_mutex);
i2c_del_driver(&ccu_i2c_2_driver);
i2c_del_driver(&ccu_i2c_4_driver);
i2c_del_driver(&ccu_i2c_6_driver);
i2c_del_driver(&ccu_i2c_7_driver);
mutex_unlock(&ccu_i2c_mutex);
return 0;
}
int ccu_i2c_controller_init(uint32_t i2c_id)
{
mutex_lock(&ccu_i2c_mutex);
if (i2c_id >= I2C_MAX_CHANNEL) {
LOG_ERR("i2c_id %d is invalid\n", i2c_id);
mutex_unlock(&ccu_i2c_mutex);
return -EINVAL;
}
if (ccu_i2c_initialized[i2c_id] == MTRUE) {
/*if not first time init, release mutex first to avoid deadlock*/
LOG_DBG_MUST("reinit, temporily release mutex.\n");
}
if (ccu_i2c_controller_en(i2c_id, 1) == -1) {
LOG_DBG("ccu_i2c_controller_en 1 fail\n");
mutex_unlock(&ccu_i2c_mutex);
return -1;
}
LOG_DBG_MUST("%s done.\n", __func__);
mutex_unlock(&ccu_i2c_mutex);
return 0;
}
int ccu_i2c_controller_uninit_all(void)
{
int i;
mutex_lock(&ccu_i2c_mutex);
for (i = 0 ; i < I2C_MAX_CHANNEL ; i++) {
if (ccu_i2c_initialized[i])
ccu_i2c_controller_uninit(i);
}
LOG_INF_MUST("%s done.\n", __func__);
mutex_unlock(&ccu_i2c_mutex);
return 0;
}
int ccu_get_i2c_dma_buf_addr(struct ccu_device_s *g_ccu_device,
struct ccu_i2c_buf_mva_ioarg *ioarg)
{
int ret = 0;
mutex_lock(&ccu_i2c_mutex);
ret = i2c_query_dma_buffer_addr(g_ccu_device, ioarg->sensor_idx,
&ioarg->mva, &ioarg->va_h, &ioarg->va_l, &ioarg->i2c_id);
mutex_unlock(&ccu_i2c_mutex);
return ret;
}
int ccu_i2c_free_dma_buf_mva_all(struct ccu_device_s *g_ccu_device)
{
mutex_lock(&ccu_i2c_mutex);
ccu_deallocate_mva(g_ccu_device->i2c_dma_mva);
LOG_INF_MUST("%s done.\n", __func__);
mutex_unlock(&ccu_i2c_mutex);
return 0;
}
void ccu_i2c_dump_errr(void)
{
struct i2c_client *pClient = NULL;
struct mt_i2c *i2c;
int i;
for (i = 0 ; i < I2C_MAX_CHANNEL ; i++) {
LOG_INF_MUST(
"CCU Dump I2C controller[%d] reg =========\n", i);
pClient = get_ccu_i2c_client(i);
if (pClient != NULL) {
i2c = i2c_get_adapdata(pClient->adapter);
ccu_i2c_dump_info(i2c);
} else {
LOG_INF_MUST("I2C controller[%d] CCU client is null\n", i);
}
}
}
/*---------------------------------------------------------------------------*/
/* CCU i2c static funcs */
/*---------------------------------------------------------------------------*/
static int i2c_query_dma_buffer_addr(struct ccu_device_s *g_ccu_device,
uint32_t sensor_idx, uint32_t *mva, uint32_t *va_h,
uint32_t *va_l, uint32_t *i2c_id)
{
struct i2c_client *pClient = NULL;
struct mt_i2c *i2c;
int ret = 0;
*i2c_id = ccu_get_sensor_i2c_id(sensor_idx);
pClient = get_ccu_i2c_client(*i2c_id);
if (pClient == MNULL) {
LOG_ERR("ccu client is NULL");
return -EFAULT;
}
if (g_ccu_device->dev == MNULL) {
LOG_ERR("ccu device is NULL");
return -EFAULT;
}
i2c = i2c_get_adapdata(pClient->adapter);
if (g_ccu_device->i2c_dma_mva == 0) {
ret = ccu_allocate_mva(&g_ccu_device->i2c_dma_mva,
g_ccu_device->i2c_dma_vaddr,
CCU_I2C_DMA_BUF_SIZE);
if (ret != 0) {
LOG_ERR("ccu alloc mva fail");
return -EFAULT;
}
}
/*i2c_get_dma_buffer_addr_imp(pClient->adapter ,va);*/
*mva = g_ccu_device->i2c_dma_mva;
*va_l = g_ccu_device->i2c_dma_paddr;
*va_h = ((g_ccu_device->i2c_dma_paddr) >> 32);
*i2c_id = i2c->id;
LOG_DBG_MUST("$$pa(%lld), mva(%x), i2c-id(%d)\n",
g_ccu_device->i2c_dma_paddr,
g_ccu_device->i2c_dma_mva, (uint32_t)i2c->id);
return 0;
}
static int ccu_i2c_controller_en(uint32_t i2c_id, int enable)
{
int ret = 0;
struct i2c_client *pClient = NULL;
struct mt_i2c *i2c;
LOG_INF_MUST("%s, id(%d):(%d)->(%d)\n",
__func__, i2c_id, ccu_i2c_initialized[i2c_id], enable);
pClient = get_ccu_i2c_client(i2c_id);
LOG_DBG("%s, pClient: %p\n", __func__, pClient);
if (pClient == NULL) {
LOG_ERR("i2c_client is null\n");
return -1;
}
if (enable) {
if (ccu_i2c_initialized[i2c_id] == MFALSE) {
ret = i2c_ccu_enable(pClient->adapter, I2C_BASE_OFS_CH1);
ccu_i2c_initialized[i2c_id] = MTRUE;
LOG_INF_MUST("i2c_ccu_enable done.\n");
/*dump controller status*/
i2c = i2c_get_adapdata(pClient->adapter);
i2c_writew(2, i2c, 0x240); /*MCU_INTR re-direct to CCU only*/
}
} else {
if (ccu_i2c_initialized[i2c_id] == MTRUE) {
ret = i2c_ccu_disable(pClient->adapter);
ccu_i2c_initialized[i2c_id] = MFALSE;
LOG_INF_MUST("i2c_ccu_disable done.\n");
}
}
return ret;
}
static int ccu_i2c_controller_uninit(uint32_t i2c_id)
{
if (ccu_i2c_controller_en(i2c_id, 0) == -1) {
LOG_DBG("ccu_i2c_controller_en 0 fail\n");
return -1;
}
LOG_DBG_MUST("%s done: id(%d)\n", __func__, i2c_id);
return 0;
}
static struct i2c_client *get_ccu_i2c_client(uint32_t i2c_id)
{
switch (i2c_id) {
case 2:
{
return g_ccuI2cClient2;
}
case 4:
{
return g_ccuI2cClient4;
}
case 6:
{
return g_ccuI2cClient6;
}
case 7:
{
return g_ccuI2cClient7;
}
default:
{
return MNULL;
}
}
}
static inline u32 i2c_readl_dma(struct mt_i2c *i2c, u8 offset)
{
return readl(i2c->pdmabase + offset);
}
static inline void i2c_writel_dma(u32 value, struct mt_i2c *i2c,
u8 offset)
{
writel(value, i2c->pdmabase + offset);
}
static inline u16 i2c_readw(struct mt_i2c *i2c, u8 offset)
{
return readw(i2c->base + offset);
}
static inline void i2c_writew(u16 value, struct mt_i2c *i2c,
u16 offset)
{
writew(value, i2c->base + offset);
}
static void ccu_i2c_dump_info(struct mt_i2c *i2c)
{
/* I2CFUC(); */
/* int val=0; */
pr_info("i2c_dump_info ++++++++++++++++++++++++++++++++++++++++++\n");
pr_info("I2C structure:\n"
I2CTAG "Clk=%d,Id=%d,Op=%x,Irq_stat=%x,Total_len=%x\n"
I2CTAG "Trans_len=%x,Trans_num=%x,Trans_auxlen=%x,speed=%d\n"
I2CTAG "Trans_stop=%u\n",
15600, i2c->id, i2c->op, i2c->irq_stat, i2c->total_len,
i2c->msg_len, 1, i2c->msg_aux_len, i2c->speed_hz,
i2c->trans_stop);
pr_info("base address 0x%p\n", i2c->base);
pr_info("I2C register:\n"
I2CTAG "SLAVE_ADDR=%x,INTR_MASK=%x,INTR_STAT=%x,CONTROL=%x,TRANSFER_LEN=%x\n"
I2CTAG "TRANSAC_LEN=%x,DELAY_LEN=%x,TIMING=%x,START=%x,FIFO_STAT=%x\n"
I2CTAG "IO_CONFIG=%x,HS=%x,DCM_EN=%x,DEBUGSTAT=%x,EXT_CONF=%x,TRANSFER_LEN_AUX=%x\n",
(i2c_readw(i2c, OFFSET_SLAVE_ADDR)),
(i2c_readw(i2c, OFFSET_INTR_MASK)),
(i2c_readw(i2c, OFFSET_INTR_STAT)),
(i2c_readw(i2c, OFFSET_CONTROL)),
(i2c_readw(i2c, OFFSET_TRANSFER_LEN)),
(i2c_readw(i2c, OFFSET_TRANSAC_LEN)),
(i2c_readw(i2c, OFFSET_DELAY_LEN)),
(i2c_readw(i2c, OFFSET_TIMING)),
(i2c_readw(i2c, OFFSET_START)),
(i2c_readw(i2c, OFFSET_FIFO_STAT)),
(i2c_readw(i2c, OFFSET_IO_CONFIG)),
(i2c_readw(i2c, OFFSET_HS)),
(i2c_readw(i2c, OFFSET_DCM_EN)),
(i2c_readw(i2c, OFFSET_DEBUGSTAT)),
(i2c_readw(i2c, OFFSET_EXT_CONF)), (i2c_readw(i2c,
OFFSET_TRANSFER_LEN_AUX)));
pr_info("DMA register(0x%p):\n"
I2CTAG "INT_FLAG=%x,INT_EN=%x,EN=%x,RST=%x,\n"
I2CTAG "STOP=%x,FLUSH=%x,CON=%x,TX_MEM_ADDR=%x, RX_MEM_ADDR=%x\n"
I2CTAG "TX_LEN=%x,RX_LEN=%x,INT_BUF_SIZE=%x,DEBUG_STATUS=%x\n"
I2CTAG "TX_MEM_ADDR2=%x, RX_MEM_ADDR2=%x\n",
i2c->pdmabase,
(i2c_readl_dma(i2c, OFFSET_INT_FLAG)),
(i2c_readl_dma(i2c, OFFSET_INT_EN)),
(i2c_readl_dma(i2c, OFFSET_EN)),
(i2c_readl_dma(i2c, OFFSET_RST)),
(i2c_readl_dma(i2c, OFFSET_STOP)),
(i2c_readl_dma(i2c, OFFSET_FLUSH)),
(i2c_readl_dma(i2c, OFFSET_CON)),
(i2c_readl_dma(i2c, OFFSET_TX_MEM_ADDR)),
(i2c_readl_dma(i2c, OFFSET_RX_MEM_ADDR)),
(i2c_readl_dma(i2c, OFFSET_TX_LEN)),
(i2c_readl_dma(i2c, OFFSET_RX_LEN)),
(i2c_readl_dma(i2c, OFFSET_INT_BUF_SIZE)),
(i2c_readl_dma(i2c, OFFSET_DEBUG_STA)),
(i2c_readl_dma(i2c, OFFSET_TX_MEM_ADDR2)),
(i2c_readl_dma(i2c, OFFSET_RX_MEM_ADDR2)));
pr_info("i2c_dump_info ------------------------------------------\n");
}
@@ -0,0 +1,27 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_I2C_H__
#define __CCU_I2C_H__
struct ccu_i2c_buf_mva_ioarg {
uint32_t sensor_idx;
uint32_t mva;
uint32_t va_h;
uint32_t va_l;
uint32_t i2c_id;
};
/*i2c driver hook*/
int ccu_i2c_register_driver(void);
int ccu_i2c_delete_driver(void);
/*ccu i2c operation*/
int ccu_get_i2c_dma_buf_addr(struct ccu_device_s *g_ccu_device, struct ccu_i2c_buf_mva_ioarg *ioarg);
int ccu_i2c_controller_init(uint32_t i2c_id);
int ccu_i2c_controller_uninit_all(void);
int ccu_i2c_free_dma_buf_mva_all(struct ccu_device_s *g_ccu_device);
void ccu_i2c_dump_errr(void);
#endif
@@ -0,0 +1,20 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include <linux/io.h>
#include "ccu_drv.h"
#include "ccu_cmn.h"
#include "ccu_n3d_a.h"
inline u32 n3d_a_readw(unsigned long n3d_a_base, u32 offset)
{
return readl((u32 *) (n3d_a_base + offset));
}
inline void n3d_a_writew(u32 value, unsigned long n3d_a_base, u32 offset)
{
writel(value, (u32 *) (n3d_a_base + offset));
}
@@ -0,0 +1,19 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_N3D_A_H__
#define __CCU_N3D_A_H__
enum N3DA_REGS_OFFSET {
OFFSET_CTL = 0x100,
OFFSET_TRIG = 0x108,
OFFSET_INT = 0x10C,
};
extern u32 n3d_a_readw(unsigned long n3d_a_base, u32 offset);
extern void n3d_a_writew(u32 value, unsigned long n3d_a_base, u32 offset);
#endif
+8
View File
@@ -0,0 +1,8 @@
config MTK_CCU
tristate "MediaTek CCU Driver"
---help---
Support 3A using CCU hardware
Offers speed up of 3A, including
Faster control flow and
Stabler frame rate.
+45
View File
@@ -0,0 +1,45 @@
#
# Copyright (C) 2016 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.
#
#obj-y += $(subst ",,$(CONFIG_MTK_PLATFORM))/
#obj-$(CONFIG_ARCH_MT6799) += 1.0/
#subdir-ccflags-y += -DMTK_VPU_EMULATOR
subdir-ccflags-y += -DMTK_VPU_KERNEL
subdir-ccflags-y += -DCCU_AF_ENABLE
ifeq ($(CONFIG_MACH_MT6833),y)
platform = mt6833
else ifeq ($(CONFIG_MACH_MT6893),y)
platform = mt6893
else ifeq ($(CONFIG_MACH_MT6877),y)
platform = mt6877
else
platform = $(subst ",,$(CONFIG_MTK_PLATFORM))
endif
obj-y += $(subst ",,$(platform))/
$(warning CCU_MAKE_FILE_CALLED)
ifneq (,$(filter $(platform),mt6757 mt6799))
obj-y += 1.0/
else ifneq (,$(filter $(platform),mt6758 mt6763))
obj-y += 1.1/
else ifneq (,$(filter $(platform),mt6765 mt6768)) #copy 1.2 from 1.1 for sensor decouple
obj-y += 1.2/
else ifneq (,$(filter $(platform),mt6771 mt6775 mt6785))
obj-y += 2.0/
else ifneq (,$(filter $(platform),mt6779))
obj-y += 2.1/
$(warning CCU_MAKE_FILE_CALLED_2_1)
endif
@@ -0,0 +1,835 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_A_REGS_H__
#define __CCU_A_REGS_H__
#include "common.h"
#ifdef __cplusplus
extern "C" {
#endif
/* ----------------- CCU_A Bit Field Definitions ------------------- */
#define PACKING
#define FIELD unsigned int
PACKING union CCU_A_REG_RESET
{
PACKING struct
{
FIELD RDMA_SOFT_RST_ST : 1;
FIELD WDMA_SOFT_RST_ST : 1;
FIELD rsv_2 : 6;
FIELD RDMA_SOFT_RST : 1;
FIELD WDMA_SOFT_RST : 1;
FIELD rsv_10 : 6;
FIELD CCU_HW_RST : 1;
FIELD ARBITER_HW_RST : 1;
FIELD S2T_A_HW_RST : 1;
FIELD T2S_A_HW_RST : 1;
FIELD T2S_B_HW_RST : 1;
FIELD RDMA_HW_RST : 1;
FIELD WDMA_HW_RST : 1;
FIELD AHB2GMC_HW_RST : 1;
FIELD rsv_24 : 8;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_START_TRIG
{
PACKING struct
{
FIELD rsv_0 : 1;
FIELD S2T_A_START : 1;
FIELD T2S_A_START : 1;
FIELD RDMA_START : 1;
FIELD WDMA_START : 1;
FIELD rsv_5 : 27;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_BANK_INCR
{
PACKING struct
{
FIELD S2T_A_FINISH : 1;
FIELD T2S_A_FINISH : 1;
FIELD T2S_B_FINISH : 1;
FIELD rsv_3 : 29;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CTRL
{
PACKING struct
{
FIELD RDMA_ENABLE : 1;
FIELD WDMA_ENABLE : 1;
FIELD T2S_B_ENABLE : 1;
FIELD CCU_PRINNER : 1;
FIELD DB_LOAD_DISABLE : 1;
FIELD CCU_DL_PATH_SEL : 1;
FIELD CCU_TILE_SOURCE : 1;
FIELD INT_CLR_MODE : 1;
FIELD H2G_GID : 2;
FIELD H2G_GULTRA_ENABLE : 1;
FIELD H2G_EARLY_RESP : 1;
FIELD CCU_AHB_BASE : 4;
FIELD OCD_JTAG_BYPASS : 1;
FIELD DAP_DIS : 1;
FIELD rsv_18 : 2;
FIELD CROP_EN : 1;
FIELD CCUI_DCM_DIS : 1;
FIELD CCUO_DCM_DIS : 1;
FIELD SRAM_DCM_DIS : 1;
FIELD rsv_24 : 8;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_T2S_A_DONE_ST
{
PACKING struct
{
FIELD T2S_A_BANK_DONE : 1;
FIELD T2S_A_FRAME_DONE : 1;
FIELD rsv_2 : 30;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_T2S_B_DONE_ST
{
PACKING struct
{
FIELD T2S_B_BANK_DONE : 1;
FIELD T2S_B_FRAME_DONE : 1;
FIELD rsv_2 : 30;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_S2T_A_DONE_ST
{
PACKING struct
{
FIELD S2T_A_BANK_DONE : 1;
FIELD S2T_A_FRAME_DONE : 1;
FIELD rsv_2 : 30;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_WDMA_DONE_ST
{
PACKING struct
{
FIELD WDMA_DONE_ST : 1;
FIELD rsv_1 : 31;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_ST
{
PACKING struct
{
FIELD CCU_HALT : 1;
FIELD CCU_GATED : 1;
FIELD rsv_2 : 30;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INT_EN
{
PACKING struct
{
FIELD CCU_INT_EN : 8;
FIELD rsv_8 : 24;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INT
{
PACKING struct
{
FIELD INT_CCU : 1;
FIELD rsv_1 : 31;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CTL_CCU_INT
{
PACKING struct
{
FIELD INT_CTL_CCU : 1;
FIELD rsv_1 : 31;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_DCM_ST
{
PACKING struct
{
FIELD CCUI_DCM_ST : 1;
FIELD rsv_1 : 3;
FIELD CCUO_DCM_ST : 1;
FIELD rsv_5 : 3;
FIELD SRAM_DCM_ST : 1;
FIELD rsv_9 : 23;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_DMA_ERR_ST
{
PACKING struct
{
FIELD DMA_ERR_INT : 1;
FIELD rsv_1 : 7;
FIELD DMA_REQ_ST : 4;
FIELD rsv_12 : 4;
FIELD DMA_RDY_ST : 1;
FIELD rsv_17 : 15;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_DMA_DEBUG
{
PACKING struct
{
FIELD DMA_DEBUG : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_EINTC_MASK
{
PACKING struct
{
FIELD CCU_EINTC_MASK : 8;
FIELD rsv_8 : 8;
FIELD CCU_EINTC_MODE : 1;
FIELD rsv_17 : 15;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_EINTC_CLR
{
PACKING struct
{
FIELD CCU_EINTC_CLR : 8;
FIELD rsv_8 : 24;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_EINTC_ST
{
PACKING struct
{
FIELD CCU_EINTC_ST : 8;
FIELD rsv_8 : 24;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_EINTC_MISC
{
PACKING struct
{
FIELD CCU_EINTC_RAW_ST : 8;
FIELD rsv_8 : 8;
FIELD CCU_EINTC_TRIG_ST : 1;
FIELD rsv_17 : 15;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CROP_SIZE
{
PACKING struct
{
FIELD CCU_CROP_X_SIZE : 16;
FIELD CCU_CROP_Y_SIZE : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CROP_START
{
PACKING struct
{
FIELD CCU_CROP_START_X : 16;
FIELD CCU_CROP_START_Y : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CROP_END
{
PACKING struct
{
FIELD CCU_CROP_END_X : 16;
FIELD CCU_CROP_END_Y : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_ERR_ST
{
PACKING struct
{
FIELD T2S_B_OVERFLOW : 1;
FIELD rsv_1 : 3;
FIELD T2S_A_INCF : 1;
FIELD S2T_A_INCF : 1;
FIELD T2S_B_INCF : 1;
FIELD rsv_7 : 25;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_PC
{
PACKING struct
{
FIELD CCU_CCU_PC : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_TOP_SPARE
{
PACKING struct
{
FIELD CCU_SPARE : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO00
{
PACKING struct
{
FIELD CCU_INFO0 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO01
{
PACKING struct
{
FIELD CCU_INFO1 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO02
{
PACKING struct
{
FIELD CCU_INFO2 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO03
{
PACKING struct
{
FIELD CCU_INFO3 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO04
{
PACKING struct
{
FIELD CCU_INFO4 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO05
{
PACKING struct
{
FIELD CCU_INFO5 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO06
{
PACKING struct
{
FIELD CCU_INFO6 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO07
{
PACKING struct
{
FIELD CCU_INFO7 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO08
{
PACKING struct
{
FIELD CCU_INFO8 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO09
{
PACKING struct
{
FIELD CCU_INFO9 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO10
{
PACKING struct
{
FIELD CCU_INFO10 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO11
{
PACKING struct
{
FIELD CCU_INFO11 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO12
{
PACKING struct
{
FIELD CCU_INFO12 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO13
{
PACKING struct
{
FIELD CCU_INFO13 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO14
{
PACKING struct
{
FIELD CCU_INFO14 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO15
{
PACKING struct
{
FIELD CCU_INFO15 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO16
{
PACKING struct
{
FIELD CCU_INFO16 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO17
{
PACKING struct
{
FIELD CCU_INFO17 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO18
{
PACKING struct
{
FIELD CCU_INFO18 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO19
{
PACKING struct
{
FIELD CCU_INFO19 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO20
{
PACKING struct
{
FIELD CCU_INFO20 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO21
{
PACKING struct
{
FIELD CCU_INFO21 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO22
{
PACKING struct
{
FIELD CCU_INFO22 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO23
{
PACKING struct
{
FIELD CCU_INFO23 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO24
{
PACKING struct
{
FIELD CCU_INFO24 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO25
{
PACKING struct
{
FIELD CCU_INFO25 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO26
{
PACKING struct
{
FIELD CCU_INFO26 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO27
{
PACKING struct
{
FIELD CCU_INFO27 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO28
{
PACKING struct
{
FIELD CCU_INFO28 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO29
{
PACKING struct
{
FIELD CCU_INFO29 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO30
{
PACKING struct
{
FIELD CCU_INFO30 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO31
{
PACKING struct
{
FIELD CCU_INFO31 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AAO_INT_PERIOD
{
PACKING struct
{
FIELD AAO_A_INT_PRD : 16;
FIELD AAO_B_INT_PRD : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AAO_INT_CNT
{
PACKING struct
{
FIELD AAO_A_INT_CNT : 16;
FIELD AAO_B_INT_CNT : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AFO_INT_PERIOD
{
PACKING struct
{
FIELD AFO_A_INT_PRD : 16;
FIELD AFO_B_INT_PRD : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AFO_INT_CNT
{
PACKING struct
{
FIELD AFO_A_INT_CNT : 16;
FIELD AFO_B_INT_CNT : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_PSO_INT_PERIOD
{
PACKING struct
{
FIELD PSO_A_INT_PRD : 16;
FIELD PSO_B_INT_PRD : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_PSO_INT_CNT
{
PACKING struct
{
FIELD PSO_A_INT_CNT : 16;
FIELD PSO_B_INT_CNT : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AAO_FRAME_BCNT
{
PACKING struct
{
FIELD AAO_A_FRAME_BCNT : 16;
FIELD AAO_B_FRAME_BCNT : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AAO_INT_ST
{
PACKING struct
{
FIELD AAO_A_BANK_INT_ST : 1;
FIELD AAO_A_FRAME_INT_ST : 1;
FIELD AAO_B_BANK_INT_ST : 1;
FIELD AAO_B_FRAME_INT_ST : 1;
FIELD rsv_4 : 28;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AFO_FRAME_BCNT
{
PACKING struct
{
FIELD AFO_A_FRAME_BCNT : 16;
FIELD AFO_B_FRAME_BCNT : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AFO_INT_ST
{
PACKING struct
{
FIELD AFO_A_BANK_INT_ST : 1;
FIELD AFO_A_FRAME_INT_ST : 1;
FIELD AFO_B_BANK_INT_ST : 1;
FIELD AFO_B_FRAME_INT_ST : 1;
FIELD rsv_4 : 28;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_PSO_FRAME_BCNT
{
PACKING struct
{
FIELD PSO_A_FRAME_BCNT : 16;
FIELD PSO_B_FRAME_BCNT : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_PSO_INT_ST
{
PACKING struct
{
FIELD PSO_A_BANK_INT_ST : 1;
FIELD PSO_A_FRAME_INT_ST : 1;
FIELD PSO_B_BANK_INT_ST : 1;
FIELD PSO_B_FRAME_INT_ST : 1;
FIELD rsv_4 : 28;
} Bits;
UINT32 Raw;
};
/* ----------------- CCU_A Grouping Definitions -------------------*/
/* ----------------- CCU_A Register Definition -------------------*/
PACKING struct CCU_A_REGS
{
PACKING union CCU_A_REG_RESET RESET; /* 1000*/
PACKING union CCU_A_REG_START_TRIG START_TRIG; /* 1004*/
PACKING union CCU_A_REG_BANK_INCR BANK_INCR; /* 1008*/
PACKING union CCU_A_REG_CTRL CTRL; /* 100C*/
PACKING union CCU_A_REG_T2S_A_DONE_ST T2S_A_DONE_ST; /* 1010*/
PACKING union CCU_A_REG_T2S_B_DONE_ST T2S_B_DONE_ST; /* 1014*/
PACKING union CCU_A_REG_S2T_A_DONE_ST S2T_A_DONE_ST; /* 1018*/
PACKING union CCU_A_REG_WDMA_DONE_ST WDMA_DONE_ST; /* 101C*/
UINT32 rsv_1020[4]; /* 1020..102C*/
PACKING union CCU_A_REG_CCU_ST DONE_ST; /* 1030*/
PACKING union CCU_A_REG_CCU_INT_EN CCU_INT_EN; /* 1034*/
PACKING union CCU_A_REG_CCU_INT CCU_INT; /* 1038*/
PACKING union CCU_A_REG_CTL_CCU_INT CTL_CCU_INT; /* 103C*/
PACKING union CCU_A_REG_DCM_ST DCM_ST; /* 1040*/
PACKING union CCU_A_REG_DMA_ERR_ST DMA_ERR_ST; /* 1044*/
PACKING union CCU_A_REG_DMA_DEBUG DMA_DEBUG; /* 1048*/
UINT32 rsv_104C; /* 104C*/
PACKING union CCU_A_REG_EINTC_MASK EINTC_MASK; /* 1050*/
PACKING union CCU_A_REG_EINTC_CLR EINTC_CLR; /* 1054*/
PACKING union CCU_A_REG_EINTC_ST EINTC_ST; /* 1058*/
PACKING union CCU_A_REG_EINTC_MISC EINTC_MISC; /* 105C*/
PACKING union CCU_A_REG_CROP_SIZE CROP_SIZE; /* 1060*/
PACKING union CCU_A_REG_CROP_START CROP_START; /* 1064*/
PACKING union CCU_A_REG_CROP_END CROP_END; /* 1068*/
PACKING union CCU_A_REG_ERR_ST ERR_ST; /* 106C*/
PACKING union CCU_A_REG_CCU_PC CCU_PC; /* 1070*/
PACKING union CCU_A_REG_TOP_SPARE TOP_SPARE; /* 1074*/
UINT32 rsv_1078[2]; /* 1078..107C*/
PACKING union CCU_A_REG_CCU_INFO00 CCU_INFO00; /* 1080*/
PACKING union CCU_A_REG_CCU_INFO01 CCU_INFO01; /* 1084*/
PACKING union CCU_A_REG_CCU_INFO02 CCU_INFO02; /* 1088*/
PACKING union CCU_A_REG_CCU_INFO03 CCU_INFO03; /* 108C*/
PACKING union CCU_A_REG_CCU_INFO04 CCU_INFO04; /* 1090*/
PACKING union CCU_A_REG_CCU_INFO05 CCU_INFO05; /* 1094*/
PACKING union CCU_A_REG_CCU_INFO06 CCU_INFO06; /* 1098*/
PACKING union CCU_A_REG_CCU_INFO07 CCU_INFO07; /* 109C*/
PACKING union CCU_A_REG_CCU_INFO08 CCU_INFO08; /* 10A0*/
PACKING union CCU_A_REG_CCU_INFO09 CCU_INFO09; /* 10A4*/
PACKING union CCU_A_REG_CCU_INFO10 CCU_INFO10; /* 10A8*/
PACKING union CCU_A_REG_CCU_INFO11 CCU_INFO11; /* 10AC*/
PACKING union CCU_A_REG_CCU_INFO12 CCU_INFO12; /* 10B0*/
PACKING union CCU_A_REG_CCU_INFO13 CCU_INFO13; /* 10B4*/
PACKING union CCU_A_REG_CCU_INFO14 CCU_INFO14; /* 10B8*/
PACKING union CCU_A_REG_CCU_INFO15 CCU_INFO15; /* 10BC*/
PACKING union CCU_A_REG_CCU_INFO16 CCU_INFO16; /* 10C0*/
PACKING union CCU_A_REG_CCU_INFO17 CCU_INFO17; /* 10C4*/
PACKING union CCU_A_REG_CCU_INFO18 CCU_INFO18; /* 10C8*/
PACKING union CCU_A_REG_CCU_INFO19 CCU_INFO19; /* 10CC*/
PACKING union CCU_A_REG_CCU_INFO20 CCU_INFO20; /* 10D0*/
PACKING union CCU_A_REG_CCU_INFO21 CCU_INFO21; /* 10D4*/
PACKING union CCU_A_REG_CCU_INFO22 CCU_INFO22; /* 10D8*/
PACKING union CCU_A_REG_CCU_INFO23 CCU_INFO23; /* 10DC*/
PACKING union CCU_A_REG_CCU_INFO24 CCU_INFO24; /* 10E0*/
PACKING union CCU_A_REG_CCU_INFO25 CCU_INFO25; /* 10E4*/
PACKING union CCU_A_REG_CCU_INFO26 CCU_INFO26; /* 10E8*/
PACKING union CCU_A_REG_CCU_INFO27 CCU_INFO27; /* 10EC*/
PACKING union CCU_A_REG_CCU_INFO28 CCU_INFO28; /* 10F0*/
PACKING union CCU_A_REG_CCU_INFO29 CCU_INFO29; /* 10F4*/
PACKING union CCU_A_REG_CCU_INFO30 CCU_INFO30; /* 10F8*/
PACKING union CCU_A_REG_CCU_INFO31 CCU_INFO31; /* 10FC*/
PACKING union CCU_A_REG_AAO_INT_PERIOD AAO_INT_PERIOD; /* 1100*/
PACKING union CCU_A_REG_AAO_INT_CNT AAO_INT_CNT; /* 1104*/
PACKING union CCU_A_REG_AFO_INT_PERIOD AFO_INT_PERIOD; /* 1108*/
PACKING union CCU_A_REG_AFO_INT_CNT AFO_INT_CNT; /* 110C*/
PACKING union CCU_A_REG_PSO_INT_PERIOD PSO_INT_PERIOD; /* 1110*/
PACKING union CCU_A_REG_PSO_INT_CNT PSO_INT_CNT; /* 1114*/
UINT32 rsv_1118[2]; /* 1118..111C*/
PACKING union CCU_A_REG_AAO_FRAME_BCNT AAO_FRAME_BCNT; /* 1120*/
PACKING union CCU_A_REG_AAO_INT_ST AAO_INT_ST; /* 1124*/
PACKING union CCU_A_REG_AFO_FRAME_BCNT AFO_FRAME_BCNT; /* 1128*/
PACKING union CCU_A_REG_AFO_INT_ST AFO_INT_ST; /* 112C*/
PACKING union CCU_A_REG_PSO_FRAME_BCNT PSO_FRAME_BCNT; /* 1130*/
PACKING union CCU_A_REG_PSO_INT_ST PSO_INT_ST; /* 1134*/
UINT32 rsv_1138[14257]; /* 1138..EFF8*/
UINT8 rsv_EFFC; /* EFFC*/
UINT16 rsv_EFFD; /* EFFD*/
UINT8 rsv_F0FF; /* F0FF*/
UINT32 rsv_F100[959]; /* F100..FFF8*/
UINT8 rsv_FFFC; /* FFFC*/
UINT16 rsv_FFFD; /* FFFD*/
};
#ifdef __cplusplus
}
#endif
#endif /* __CCU_A_REGS_H__*/
@@ -0,0 +1,41 @@
#
# Copyright (C) 2016 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.
#
#ion
ccflags-y += -I$(srctree)/drivers/iommu/
ifeq ($(CONFIG_MTK_ION),y)
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion/
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion/mtk/
else
ccflags-$(CONFIG_ION) += -I$(srctree)/drivers/staging/android/aosp_ion/
endif
#for sensorType in ccu_set_sensor_info
ccflags-y += -I$(srctree)/drivers/misc/mediatek/imgsensor/inc
#
ccflags-y += -I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mach/$(MTK_PLATFORM)/include/mach
ccflags-y += -I$(srctree)/drivers/misc/mediatek/irq/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(MTK_PLATFORM)/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mmp/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/1.2
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/inc/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/$(MTK_PLATFORM)/ccu_ext_interface/
ccflags-y += -I$(srctree)/drivers/i2c/busses/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/imgsensor/inc
#obj-$(CONFIG_MTK_VPU) += ccu_hw.o
obj-y += ccu_hw.o ccu_reg.o ccu_kd_mailbox.o ccu_i2c_hw.o ccu_sw_ver.o
@@ -0,0 +1,12 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_H__
#define __CCU_H__
#include "../1.0/ccu_drv.h"
#endif
@@ -0,0 +1,110 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_INTERFACE__
#define __CCU_INTERFACE__
#include "ccu_ext_interface/ccu_types.h"
extern MBOOL sec_vsync_pushed;
/********************************************************************
* Task definition
********************************************************************/
enum ccu_msg_id {
/*Receive by CCU */
/*CCU Task*/
MSG_TO_CCU_IDLE = 0x00000000,
MSG_TO_CCU_SENSOR_INIT,
MSG_TO_CCU_AE_INIT,
MSG_TO_CCU_AE_START,
MSG_TO_CCU_AE_STOP,
MSG_TO_CCU_SET_SKIP_ALGO,
MSG_TO_CCU_SET_AP_AE_FRAME_SYNC_DATA,
MSG_TO_CCU_SET_AP_AE_ONCHANGE_DATA,
MSG_TO_CCU_GET_CCU_OUTPUT,
MSG_TO_CCU_SET_AP_AE_OUTPUT,
MSG_TO_CCU_SET_AE_ROI,/*9*/
MSG_TO_CCU_SET_AE_EV,
MSG_TO_CCU_SET_MAX_FRAMERATE,
MSG_TO_CCU_SHUTDOWN,
/*todo-add timer sync task */
DELIMITER_CCU_CONTROL_CNT_1,
/*APMCU Ack*/
/*CCU internal task*/
MSG_CCU_INTERNAL_BANK_AE_ALGO,/*14*/
MSG_CCU_INTERNAL_FRAME_AE_ALGO,
MSG_CCU_INTERNAL_VSYNC_AE_SYNC,
DELIMITER_CCU_CONTROL_CNT_2,
/*Send to APMCU */
/*CCU Ack/Done*/
MSG_CCU_DONE_SHUTDOWN,/*18*/
MSG_CCU_DONE_SENSOR_INIT,
MSG_CCU_DONE_AE_INIT,
MSG_CCU_ACK_AE_START,
MSG_CCU_ACK_AE_STOP,/*22*/
MSG_CCU_ACK_SET_SKIP_ALGO,/*22*/
MSG_CCU_ACK_SET_AP_AE_READY,
MSG_CCU_ACK_SET_AP_AE_FRAME_SYNC_DATA,
MSG_CCU_ACK_SET_AP_AE_ONCHANGE_DATA,
MSG_CCU_ACK_GET_CCU_OUTPUT,/*26*/
MSG_CCU_ACK_SET_AP_AE_OUTPUT,
MSG_CCU_ACK_SET_AE_ROI,
MSG_CCU_ACK_SET_AE_EV,
MSG_CCU_ACK_SET_MAX_FRAMERATE,
/*APMCU Task*/
MSG_TO_APMCU_FLUSH_LOG,/*31*/
MSG_TO_APMCU_CCU_ASSERT,
MSG_TO_APMCU_CCU_WARNING,
};
enum ccu_tg_info {
CCU_CAM_TG_NONE = 0x0,
CCU_CAM_TG_1 = 0x1,
CCU_CAM_TG_2 = 0x2,
CAM_CCU_TG_MAX
};
struct ccu_msg_t { /*16bytes*/
enum ccu_msg_id msg_id;
MUINT32 in_data_ptr;
MUINT32 out_data_ptr;
enum ccu_tg_info tg_info;
};
/********************************************************************
* Special isr task (execute in isr)
********************************************************************/
#define ISR_SP_TASK_SHUTDOWN 0x000000FF
#define ISR_SP_TASK_TRG_I2C_DONE 0x000000C1
#define ISR_SP_TASK_RST_I2C_DONE 0x000000B9
/********************************************************************
* Special ap isr task (execute in apmcu_isr)
********************************************************************/
#define APISR_SP_TASK_TRIGGER_I2C 0x000000A1
#define APISR_SP_TASK_RESET_I2C 0x000000A2
/********************************************************************
* Error code definition
********************************************************************/
#define CCU_ERROR_NO (0)
#define CCU_ERROR_QUEUE_FULL (1)
/********************************************************************
* Status definition
********************************************************************/
#define CCU_STATUS_INIT_DONE 0xffff0000
#define CCU_STATUS_INIT_DONE_2 0xffff00a5
/********************************************************************
* Direct-link source definition
********************************************************************/
#define AE_STREAM_DL_SRC_AAO 0x00000000
#define AE_STREAM_DL_SRC_PSO 0x00000001
#endif
@@ -0,0 +1,41 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
/***********************************************************************
* Module: CCU mailbox external interface
*
* Description: External interface for both CCU/APMCU side reference,
* Develop an unified data structure and
* circular queue full/empty definition
***********************************************************************/
#ifndef __CCU_MAILBOX_EXTIF__
#define __CCU_MAILBOX_EXTIF__
#include "ccu_ext_interface/ccu_ext_interface.h"
/*must be power of 2 for modulo operation take work*/
#define CCU_MAILBOX_QUEUE_SIZE 8
/***********************************************************************
* Mailbox is a circular queue
* Composed of 2 pointer front/rear, and a buffer of ccu_msg_t
!!! Implement mailbox operation with following rules !!!
- Initial queue with front=rear=0
- Dequeue with read queue[front+1] and
increase front pointer by 1 (modulus add)
- Enqueue with write into queue[rear+1] and
increase rear pointer by 1 (modulus add)
- Queue is full when front=rear+1
(modulus add: rear+1 = rear+1 % CCU_MAILBOX_QUEUE_SIZE)
- Queue is empty when front=rear
***********************************************************************/
struct ccu_mailbox_t {
MUINT32 front;
MUINT32 rear;
struct ccu_msg_t queue[CCU_MAILBOX_QUEUE_SIZE];
};
#endif
@@ -0,0 +1,65 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef CCU_TYPES_H
#define CCU_TYPES_H
/*********************************************************************/
/* typedef unsigned char BOOLEAN; // uint8_t*/
#define MUINT8 unsigned char
#define MUINT16 unsigned short
#define MUINT32 unsigned int
/*typedef unsigned long MUINT64;*/
/**/
#define MINT8 signed char
#define MINT16 signed short
#define MINT32 signed int
/*typedef signed long MINT64;*/
/**/
#define MFLOAT float
#define MDOUBLE double
/**/
#define MVOID void
#define MBOOL int
#ifndef MTRUE
#define MTRUE 1
#endif
#ifndef MFALSE
#define MFALSE 0
#endif
#ifndef MNULL
#define MNULL 0
#endif
/********************************************************************
*Sensor Types
********************************************************************/
/* #define CCU_CODE_SLIM*/
/* typedef unsigned char BOOLEAN; // uint8_t*/
#define U8 unsigned char /* uint8_t*/
#define U16 unsigned short /* uint16_t*/
#define U32 unsigned int /* uint32_t*/
/*typedef unsigned long long U64; // uint64_t*/
#define I8 char /* int8_t*/
#define I16 short /* int16_t*/
#define I32 int /* int32_t*/
/*typedef long long I64; // int64_t*/
#ifndef NULL
#define NULL 0
#endif /* NULL*/
/********************************************************************
* Error code
********************************************************************/
#define ERR_NONE (0)
#define ERR_INVALID (-1)
#define ERR_TIMEOUT (-2)
#endif /* CCU_TYPES_H*/
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,33 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef _MT6798_CCU_HW_H_
#define _MT6798_CCU_HW_H_
#include "ccu_reg.h"
#include "ccu_drv.h"
/*spare register define*/
#define CCU_STA_REG_SW_INIT_DONE CCU_INFO30
#define CCU_STA_REG_3A_INIT_DONE CCU_INFO01
#define CCU_STA_REG_SP_ISR_TASK CCU_INFO24
#define CCU_STA_REG_I2C_TRANSAC_LEN CCU_INFO25
#define CCU_STA_REG_I2C_DO_DMA_EN CCU_INFO26
/*
* KuanFu Yeh@20160715
* Spare Register Data Type Field
* 0 int32 APMCU mailbox addr.
* 1 int32 CCU mailbox addr.
* 2 int32 DRAM log buffer addr.1
* 3 int32 DRAM log buffer addr.2
*/
#define CCU_DATA_REG_MAILBOX_APMCU CCU_INFO00
#define CCU_DATA_REG_MAILBOX_CCU CCU_INFO01
#define CCU_DATA_REG_LOG_BUF0 CCU_INFO02
#define CCU_DATA_REG_LOG_BUF1 CCU_INFO03
#endif
@@ -0,0 +1,18 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include "ccu_cmn.h"
#include "ccu_i2c.h"
#include "ccu_i2c_hw.h"
#include "ccu_n3d_a.h"
static unsigned long g_n3d_base;
int ccu_i2c_set_n3d_base(unsigned long n3d_base)
{
g_n3d_base = n3d_base;
return 0;
}
@@ -0,0 +1,14 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_I2C_HW_H__
#define __CCU_I2C_HW_H__
/*---------------------------------------------------------------------------*/
/* i2c interface from ccu_i2c_hw.c */
/*---------------------------------------------------------------------------*/
extern int ccu_i2c_set_n3d_base(unsigned long n3d_base);
#endif
@@ -0,0 +1,171 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include <linux/io.h>
#include "ccu_cmn.h"
#include "ccu_reg.h"
#include "ccu_kd_mailbox.h"
#include "ccu_mailbox_extif.h"
static struct ccu_mailbox_t *_ccu_mailbox;
static struct ccu_mailbox_t *_apmcu_mailbox;
static enum mb_result _mailbox_write_to_buffer(struct ccu_msg_t *task);
static int ccu_msg_copy(struct ccu_msg_t *dest, struct ccu_msg_t *src);
/*********************************************************************
* Public functions
*********************************************************************/
enum mb_result mailbox_init(struct ccu_mailbox_t *apmcu_mb_addr,
struct ccu_mailbox_t *ccu_mb_addr)
{
_ccu_mailbox = ccu_mb_addr;
_apmcu_mailbox = apmcu_mb_addr;
LOG_DBG("ccu_mailbox addr: %p\n", _ccu_mailbox);
LOG_DBG("apmcu_mailbox addr: %p\n", _apmcu_mailbox);
/* memory barrier to check mailbox value wrote into DRAM*/
/* instead of keep in CPU write buffer*/
mb();
return MAILBOX_OK;
}
enum mb_result mailbox_send_cmd(struct ccu_msg_t *task)
{
enum mb_result result;
if (!_ccu_mailbox)
return MAILBOX_UNINIT;
/*Fill slot*/
result = _mailbox_write_to_buffer(task);
if (result != MAILBOX_OK)
return result;
LOG_DBG("sending cmd: f(%d), r(%d), cmd(%d), in(%x), out(%x)\n",
_ccu_mailbox->front,
_ccu_mailbox->rear,
_ccu_mailbox->queue[_ccu_mailbox->rear].msg_id,
_ccu_mailbox->queue[_ccu_mailbox->rear].in_data_ptr,
_ccu_mailbox->queue[_ccu_mailbox->rear].out_data_ptr);
/*Send interrupt*/
/* MCU write this field to trigger ccu interrupt pulse */
ccu_write_reg_bit(ccu_base, CTL_CCU_INT, INT_CTL_CCU, 1);
return MAILBOX_OK;
}
enum mb_result mailbox_receive_cmd(struct ccu_msg_t *task)
{
enum mb_result result;
MUINT32 rear;
MUINT32 front;
MUINT32 nextReadSlot;
if (!_apmcu_mailbox)
return MAILBOX_UNINIT;
rear = _apmcu_mailbox->rear;
front = _apmcu_mailbox->front;
/*Check if queue is empty*/
/*empty when front=rear*/
if (rear != front) {
/*modulus add:
*rear+1 = rear+1 % CCU_MAILBOX_QUEUE_SIZE
*/
nextReadSlot = (_apmcu_mailbox->front + 1) &
(CCU_MAILBOX_QUEUE_SIZE - 1);
ccu_msg_copy(task, &(_apmcu_mailbox->queue[nextReadSlot]));
_apmcu_mailbox->front = nextReadSlot;
LOG_DBG("%s: f(%d), r(%d), cmd(%d), in(%x), out(%x)\n",
"received cmd",
_apmcu_mailbox->front,
_apmcu_mailbox->rear,
_apmcu_mailbox->queue[nextReadSlot].msg_id,
_apmcu_mailbox->queue[nextReadSlot].in_data_ptr,
_apmcu_mailbox->queue[nextReadSlot].out_data_ptr);
result = MAILBOX_OK;
} else {
LOG_DBG("apmcu mailbox is empty\n");
result = MAILBOX_QUEUE_EMPTY;
}
return result;
}
/*********************************************************************
* Private functions
*********************************************************************/
static int ccu_msg_copy(struct ccu_msg_t *dest, struct ccu_msg_t *src)
{
dest->msg_id = src->msg_id;
dest->in_data_ptr = src->in_data_ptr;
dest->out_data_ptr = src->out_data_ptr;
dest->tg_info = src->tg_info;
return 0;
}
static enum mb_result _mailbox_write_to_buffer(struct ccu_msg_t *task)
{
enum mb_result result;
MUINT32 nextWriteSlot =
(_ccu_mailbox->rear + 1) & (CCU_MAILBOX_QUEUE_SIZE - 1);
/*Check if queue is full*/
/*full when front=rear+1
*(modulus add: rear+1 = rear+1 % CCU_MAILBOX_QUEUE_SIZE)
*/
if (nextWriteSlot == _ccu_mailbox->front) {
LOG_DBG("ccu mailbox queue full !!\n");
result = MAILBOX_QUEUE_FULL;
} else {
LOG_DBG("copy cmd to mailbox slot: %d\n", nextWriteSlot);
LOG_DBG("target mailbox slot address: %p\n",
&(_ccu_mailbox->queue[nextWriteSlot]));
LOG_DBG("incming cmd: cmd(%d), in(%x), out(%x)\n",
task->msg_id,
task->in_data_ptr,
task->out_data_ptr
);
LOG_DBG("writing target: slot(%d), cmd(%d), in(%x), out(%x)\n",
nextWriteSlot,
_ccu_mailbox->queue[nextWriteSlot].msg_id,
_ccu_mailbox->queue[nextWriteSlot].in_data_ptr,
_ccu_mailbox->queue[nextWriteSlot].out_data_ptr
);
ccu_msg_copy(&(_ccu_mailbox->queue[nextWriteSlot]), task);
_ccu_mailbox->rear = nextWriteSlot;
LOG_DBG("wrote target: slot(%d), cmd(%d), in(%x), out(%x)\n",
_ccu_mailbox->rear,
_ccu_mailbox->queue[_ccu_mailbox->rear].msg_id,
_ccu_mailbox->queue[_ccu_mailbox->rear].in_data_ptr,
_ccu_mailbox->queue[_ccu_mailbox->rear].out_data_ptr
);
/* memory barrier to check mailbox value wrote into DRAM*/
/* instead of keep in CPU write buffer*/
mb();
result = MAILBOX_OK;
}
return result;
}
@@ -0,0 +1,25 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_MAILBOX_H__
#define __CCU_MAILBOX_H__
#include "ccu_ext_interface/ccu_mailbox_extif.h"
enum mb_result {
MAILBOX_OK = 0,
MAILBOX_QUEUE_FULL,
MAILBOX_QUEUE_EMPTY,
MAILBOX_UNINIT
};
enum mb_result mailbox_init(struct ccu_mailbox_t *apmcu_mb_addr,
struct ccu_mailbox_t *ccu_mb_addr);
enum mb_result mailbox_send_cmd(struct ccu_msg_t *task);
enum mb_result mailbox_receive_cmd(struct ccu_msg_t *task);
#endif
@@ -0,0 +1,29 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef _CCU_PLATFORM_DEF_
#define _CCU_PLATFORM_DEF_
/*For user/kernel space sync.*/
#define CCU_HW_OFFSET (0x0)
#define CCU_PMEM_BASE (0x1A0A0000)
#define CCU_PMEM_SIZE (0x10000)
#define CCU_DMEM_BASE (0x1A080000)
#define CCU_DMEM_SIZE (0x8000)
#define CCU_DMEM_OFFSET (0x1C00)
#define CCU_LOG_BASE (0x500)
#define CCU_LOG_SIZE (0x400)
#define CCU_HW_DUMP_SIZE (0x550)
#define CCU_CAMSYS_BASE (0x1A000000)
#define CCU_CAMSYS_SIZE (0x1000)
#define CCU_N3D_A_BASE (0x1A040000)
#define CCU_N3D_A_SIZE (0x1000)
#define CCU_SENSOR_PM_SIZE (0x1000)
#define CCU_SENSOR_DM_SIZE (0x600)
#define CCU_ISR_LOG_BASE (0x1A00)
#define CCU_ISR_LOG_SIZE (0x200)
#define CCU_HEADER_NUM (20)
#endif
@@ -0,0 +1,12 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include "ccu_reg.h"
/*js_test*/
#include "CCU_A_c_header.h"
struct CCU_A_REGS *g_CCU_A_BASE;
uint64_t ccu_base;
@@ -0,0 +1,66 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef _MT6799_CCU_REG_H_
#define _MT6799_CCU_REG_H_
#include <sync_write.h>
#include "ccu_sw_ver.h"
#include "CCU_A_c_header.h"
/*For CCU_A_c_header_v2*/
/*
*#define SW_VER_SPLIT 0
*#if (SW_VER_SPLIT == 1)
*#include "CCU_A_c_header_v2.h"
*#define ccu_read_reg(base, regName) \
* ((g_ccu_sw_version == CHIP_SW_VER_01) ? \
* ((PCCU_A_REGS)base)->regName.Raw : \
* ((PCCU_A_REGS_V2)base)->regName.Raw \
* )
*#define ccu_write_reg(base, regName, val) \
* do { if (g_ccu_sw_version == CHIP_SW_VER_01) { \
* ((PCCU_A_REGS)base)->regName.Raw = val; \
* } else { \
* ((PCCU_A_REGS_V2)base)->regName.Raw = val; \
* } } while (0)
*#define ccu_read_reg_bit(base, regName, fieldNmae) \
* ((g_ccu_sw_version == CHIP_SW_VER_01) ? \
* ((PCCU_A_REGS)base)->regName.Bits.fieldNmae : \
* ((PCCU_A_REGS_V2)base)->regName.Bits.fieldNmae \
* )
*#define ccu_write_reg_bit(base, regName, fieldNmae, val) \
* do { if (g_ccu_sw_version == CHIP_SW_VER_01) { \
* ((PCCU_A_REGS)base)->regName.Bits.fieldNmae = val; \
* } else { \
* ((PCCU_A_REGS_V2)base)->regName.Bits.fieldNmae = val; \
* } } while (0)
*#else
*/
/*#define ccu_read_reg(base, regName) \
* (((struct CCU_A_REGS *)base)->regName.Raw)
*#define ccu_write_reg(base, regName, val) \
* (((struct CCU_A_REGS *)base)->regName.Raw = val)
*/
#define ccu_read_reg_bit(base, regName, fieldNmae) \
(((struct CCU_A_REGS *)(uintptr_t)base)->regName.Bits.fieldNmae)
#define ccu_write_reg_bit(base, regName, fieldNmae, val) \
(((struct CCU_A_REGS *)(uintptr_t)base)->regName.Bits.fieldNmae = val)
#define ccu_read_reg(base, regName) \
readl(&(((struct CCU_A_REGS *)(uintptr_t)base)->regName))
#define ccu_write_reg(base, regName, val) \
writel(val, &(((struct CCU_A_REGS *)(uintptr_t)base)->regName))
/*#endif*/
#define CCU_SET_BIT(reg, bit) \
((*(unsigned int *)(reg)) |= (unsigned int)(1 << (bit)))
#define CCU_CLR_BIT(reg, bit) \
((*(unsigned int *)(reg)) &= ~((unsigned int)(1 << (bit))))
extern uint64_t ccu_base;
#endif
@@ -0,0 +1,28 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifdef CONFIG_MTK_CHIP
#include <linux/kernel.h>
#include "ccu_cmn.h"
#include "ccu_sw_ver.h"
enum chip_sw_ver g_ccu_sw_version = -1;
int init_check_sw_ver(void)
{
g_ccu_sw_version = mt_get_chip_sw_ver();
if ((g_ccu_sw_version != CHIP_SW_VER_02) &&
(g_ccu_sw_version != CHIP_SW_VER_01)) {
LOG_ERR("have a wrong software version:%x!\n",
g_ccu_sw_version);
return -EINVAL;
}
return 0;
}
#endif
@@ -0,0 +1,19 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifdef CONFIG_MTK_CHIP
#ifndef _CCU_SW_VER_H_
#define _CCU_SW_VER_H_
#include <mt-plat/mtk_chip.h>
extern enum chip_sw_ver g_ccu_sw_version;
int init_check_sw_ver(void);
#endif
#endif
@@ -0,0 +1,12 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __COMMON_H__
#define __COMMON_H__
#define UINT8 unsigned char
#define UINT16 unsigned short
#define UINT32 unsigned int
#endif /* __COMMON_H__*/
@@ -0,0 +1,835 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CCU_A_REGS_H__
#define __CCU_A_REGS_H__
#include "common.h"
#ifdef __cplusplus
extern "C" {
#endif
/* ----------------- CCU_A Bit Field Definitions ------------------- */
#define PACKING
#define FIELD unsigned int
PACKING union CCU_A_REG_RESET
{
PACKING struct
{
FIELD RDMA_SOFT_RST_ST : 1;
FIELD WDMA_SOFT_RST_ST : 1;
FIELD rsv_2 : 6;
FIELD RDMA_SOFT_RST : 1;
FIELD WDMA_SOFT_RST : 1;
FIELD rsv_10 : 6;
FIELD CCU_HW_RST : 1;
FIELD ARBITER_HW_RST : 1;
FIELD S2T_A_HW_RST : 1;
FIELD T2S_A_HW_RST : 1;
FIELD T2S_B_HW_RST : 1;
FIELD RDMA_HW_RST : 1;
FIELD WDMA_HW_RST : 1;
FIELD AHB2GMC_HW_RST : 1;
FIELD rsv_24 : 8;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_START_TRIG
{
PACKING struct
{
FIELD rsv_0 : 1;
FIELD S2T_A_START : 1;
FIELD T2S_A_START : 1;
FIELD RDMA_START : 1;
FIELD WDMA_START : 1;
FIELD rsv_5 : 27;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_BANK_INCR
{
PACKING struct
{
FIELD S2T_A_FINISH : 1;
FIELD T2S_A_FINISH : 1;
FIELD T2S_B_FINISH : 1;
FIELD rsv_3 : 29;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CTRL
{
PACKING struct
{
FIELD RDMA_ENABLE : 1;
FIELD WDMA_ENABLE : 1;
FIELD T2S_B_ENABLE : 1;
FIELD CCU_PRINNER : 1;
FIELD DB_LOAD_DISABLE : 1;
FIELD CCU_DL_PATH_SEL : 1;
FIELD CCU_TILE_SOURCE : 1;
FIELD INT_CLR_MODE : 1;
FIELD H2G_GID : 2;
FIELD H2G_GULTRA_ENABLE : 1;
FIELD H2G_EARLY_RESP : 1;
FIELD CCU_AHB_BASE : 4;
FIELD OCD_JTAG_BYPASS : 1;
FIELD DAP_DIS : 1;
FIELD rsv_18 : 2;
FIELD CROP_EN : 1;
FIELD CCUI_DCM_DIS : 1;
FIELD CCUO_DCM_DIS : 1;
FIELD SRAM_DCM_DIS : 1;
FIELD rsv_24 : 8;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_T2S_A_DONE_ST
{
PACKING struct
{
FIELD T2S_A_BANK_DONE : 1;
FIELD T2S_A_FRAME_DONE : 1;
FIELD rsv_2 : 30;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_T2S_B_DONE_ST
{
PACKING struct
{
FIELD T2S_B_BANK_DONE : 1;
FIELD T2S_B_FRAME_DONE : 1;
FIELD rsv_2 : 30;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_S2T_A_DONE_ST
{
PACKING struct
{
FIELD S2T_A_BANK_DONE : 1;
FIELD S2T_A_FRAME_DONE : 1;
FIELD rsv_2 : 30;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_WDMA_DONE_ST
{
PACKING struct
{
FIELD WDMA_DONE_ST : 1;
FIELD rsv_1 : 31;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_ST
{
PACKING struct
{
FIELD CCU_HALT : 1;
FIELD CCU_GATED : 1;
FIELD rsv_2 : 30;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INT_EN
{
PACKING struct
{
FIELD CCU_INT_EN : 8;
FIELD rsv_8 : 24;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INT
{
PACKING struct
{
FIELD INT_CCU : 1;
FIELD rsv_1 : 31;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CTL_CCU_INT
{
PACKING struct
{
FIELD INT_CTL_CCU : 1;
FIELD rsv_1 : 31;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_DCM_ST
{
PACKING struct
{
FIELD CCUI_DCM_ST : 1;
FIELD rsv_1 : 3;
FIELD CCUO_DCM_ST : 1;
FIELD rsv_5 : 3;
FIELD SRAM_DCM_ST : 1;
FIELD rsv_9 : 23;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_DMA_ERR_ST
{
PACKING struct
{
FIELD DMA_ERR_INT : 1;
FIELD rsv_1 : 7;
FIELD DMA_REQ_ST : 4;
FIELD rsv_12 : 4;
FIELD DMA_RDY_ST : 1;
FIELD rsv_17 : 15;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_DMA_DEBUG
{
PACKING struct
{
FIELD DMA_DEBUG : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_EINTC_MASK
{
PACKING struct
{
FIELD CCU_EINTC_MASK : 8;
FIELD rsv_8 : 8;
FIELD CCU_EINTC_MODE : 1;
FIELD rsv_17 : 15;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_EINTC_CLR
{
PACKING struct
{
FIELD CCU_EINTC_CLR : 8;
FIELD rsv_8 : 24;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_EINTC_ST
{
PACKING struct
{
FIELD CCU_EINTC_ST : 8;
FIELD rsv_8 : 24;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_EINTC_MISC
{
PACKING struct
{
FIELD CCU_EINTC_RAW_ST : 8;
FIELD rsv_8 : 8;
FIELD CCU_EINTC_TRIG_ST : 1;
FIELD rsv_17 : 15;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CROP_SIZE
{
PACKING struct
{
FIELD CCU_CROP_X_SIZE : 16;
FIELD CCU_CROP_Y_SIZE : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CROP_START
{
PACKING struct
{
FIELD CCU_CROP_START_X : 16;
FIELD CCU_CROP_START_Y : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CROP_END
{
PACKING struct
{
FIELD CCU_CROP_END_X : 16;
FIELD CCU_CROP_END_Y : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_ERR_ST
{
PACKING struct
{
FIELD T2S_B_OVERFLOW : 1;
FIELD rsv_1 : 3;
FIELD T2S_A_INCF : 1;
FIELD S2T_A_INCF : 1;
FIELD T2S_B_INCF : 1;
FIELD rsv_7 : 25;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_PC
{
PACKING struct
{
FIELD CCU_CCU_PC : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_TOP_SPARE
{
PACKING struct
{
FIELD CCU_SPARE : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO00
{
PACKING struct
{
FIELD CCU_INFO0 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO01
{
PACKING struct
{
FIELD CCU_INFO1 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO02
{
PACKING struct
{
FIELD CCU_INFO2 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO03
{
PACKING struct
{
FIELD CCU_INFO3 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO04
{
PACKING struct
{
FIELD CCU_INFO4 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO05
{
PACKING struct
{
FIELD CCU_INFO5 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO06
{
PACKING struct
{
FIELD CCU_INFO6 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO07
{
PACKING struct
{
FIELD CCU_INFO7 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO08
{
PACKING struct
{
FIELD CCU_INFO8 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO09
{
PACKING struct
{
FIELD CCU_INFO9 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO10
{
PACKING struct
{
FIELD CCU_INFO10 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO11
{
PACKING struct
{
FIELD CCU_INFO11 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO12
{
PACKING struct
{
FIELD CCU_INFO12 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO13
{
PACKING struct
{
FIELD CCU_INFO13 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO14
{
PACKING struct
{
FIELD CCU_INFO14 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO15
{
PACKING struct
{
FIELD CCU_INFO15 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO16
{
PACKING struct
{
FIELD CCU_INFO16 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO17
{
PACKING struct
{
FIELD CCU_INFO17 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO18
{
PACKING struct
{
FIELD CCU_INFO18 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO19
{
PACKING struct
{
FIELD CCU_INFO19 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO20
{
PACKING struct
{
FIELD CCU_INFO20 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO21
{
PACKING struct
{
FIELD CCU_INFO21 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO22
{
PACKING struct
{
FIELD CCU_INFO22 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO23
{
PACKING struct
{
FIELD CCU_INFO23 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO24
{
PACKING struct
{
FIELD CCU_INFO24 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO25
{
PACKING struct
{
FIELD CCU_INFO25 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO26
{
PACKING struct
{
FIELD CCU_INFO26 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO27
{
PACKING struct
{
FIELD CCU_INFO27 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO28
{
PACKING struct
{
FIELD CCU_INFO28 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO29
{
PACKING struct
{
FIELD CCU_INFO29 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO30
{
PACKING struct
{
FIELD CCU_INFO30 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_CCU_INFO31
{
PACKING struct
{
FIELD CCU_INFO31 : 32;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AAO_INT_PERIOD
{
PACKING struct
{
FIELD AAO_A_INT_PRD : 16;
FIELD AAO_B_INT_PRD : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AAO_INT_CNT
{
PACKING struct
{
FIELD AAO_A_INT_CNT : 16;
FIELD AAO_B_INT_CNT : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AFO_INT_PERIOD
{
PACKING struct
{
FIELD AFO_A_INT_PRD : 16;
FIELD AFO_B_INT_PRD : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AFO_INT_CNT
{
PACKING struct
{
FIELD AFO_A_INT_CNT : 16;
FIELD AFO_B_INT_CNT : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_PSO_INT_PERIOD
{
PACKING struct
{
FIELD PSO_A_INT_PRD : 16;
FIELD PSO_B_INT_PRD : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_PSO_INT_CNT
{
PACKING struct
{
FIELD PSO_A_INT_CNT : 16;
FIELD PSO_B_INT_CNT : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AAO_FRAME_BCNT
{
PACKING struct
{
FIELD AAO_A_FRAME_BCNT : 16;
FIELD AAO_B_FRAME_BCNT : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AAO_INT_ST
{
PACKING struct
{
FIELD AAO_A_BANK_INT_ST : 1;
FIELD AAO_A_FRAME_INT_ST : 1;
FIELD AAO_B_BANK_INT_ST : 1;
FIELD AAO_B_FRAME_INT_ST : 1;
FIELD rsv_4 : 28;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AFO_FRAME_BCNT
{
PACKING struct
{
FIELD AFO_A_FRAME_BCNT : 16;
FIELD AFO_B_FRAME_BCNT : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_AFO_INT_ST
{
PACKING struct
{
FIELD AFO_A_BANK_INT_ST : 1;
FIELD AFO_A_FRAME_INT_ST : 1;
FIELD AFO_B_BANK_INT_ST : 1;
FIELD AFO_B_FRAME_INT_ST : 1;
FIELD rsv_4 : 28;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_PSO_FRAME_BCNT
{
PACKING struct
{
FIELD PSO_A_FRAME_BCNT : 16;
FIELD PSO_B_FRAME_BCNT : 16;
} Bits;
UINT32 Raw;
};
PACKING union CCU_A_REG_PSO_INT_ST
{
PACKING struct
{
FIELD PSO_A_BANK_INT_ST : 1;
FIELD PSO_A_FRAME_INT_ST : 1;
FIELD PSO_B_BANK_INT_ST : 1;
FIELD PSO_B_FRAME_INT_ST : 1;
FIELD rsv_4 : 28;
} Bits;
UINT32 Raw;
};
/* ----------------- CCU_A Grouping Definitions -------------------*/
/* ----------------- CCU_A Register Definition -------------------*/
PACKING struct CCU_A_REGS
{
PACKING union CCU_A_REG_RESET RESET; /* 1000*/
PACKING union CCU_A_REG_START_TRIG START_TRIG; /* 1004*/
PACKING union CCU_A_REG_BANK_INCR BANK_INCR; /* 1008*/
PACKING union CCU_A_REG_CTRL CTRL; /* 100C*/
PACKING union CCU_A_REG_T2S_A_DONE_ST T2S_A_DONE_ST; /* 1010*/
PACKING union CCU_A_REG_T2S_B_DONE_ST T2S_B_DONE_ST; /* 1014*/
PACKING union CCU_A_REG_S2T_A_DONE_ST S2T_A_DONE_ST; /* 1018*/
PACKING union CCU_A_REG_WDMA_DONE_ST WDMA_DONE_ST; /* 101C*/
UINT32 rsv_1020[4]; /* 1020..102C*/
PACKING union CCU_A_REG_CCU_ST DONE_ST; /* 1030*/
PACKING union CCU_A_REG_CCU_INT_EN CCU_INT_EN; /* 1034*/
PACKING union CCU_A_REG_CCU_INT CCU_INT; /* 1038*/
PACKING union CCU_A_REG_CTL_CCU_INT CTL_CCU_INT; /* 103C*/
PACKING union CCU_A_REG_DCM_ST DCM_ST; /* 1040*/
PACKING union CCU_A_REG_DMA_ERR_ST DMA_ERR_ST; /* 1044*/
PACKING union CCU_A_REG_DMA_DEBUG DMA_DEBUG; /* 1048*/
UINT32 rsv_104C; /* 104C*/
PACKING union CCU_A_REG_EINTC_MASK EINTC_MASK; /* 1050*/
PACKING union CCU_A_REG_EINTC_CLR EINTC_CLR; /* 1054*/
PACKING union CCU_A_REG_EINTC_ST EINTC_ST; /* 1058*/
PACKING union CCU_A_REG_EINTC_MISC EINTC_MISC; /* 105C*/
PACKING union CCU_A_REG_CROP_SIZE CROP_SIZE; /* 1060*/
PACKING union CCU_A_REG_CROP_START CROP_START; /* 1064*/
PACKING union CCU_A_REG_CROP_END CROP_END; /* 1068*/
PACKING union CCU_A_REG_ERR_ST ERR_ST; /* 106C*/
PACKING union CCU_A_REG_CCU_PC CCU_PC; /* 1070*/
PACKING union CCU_A_REG_TOP_SPARE TOP_SPARE; /* 1074*/
UINT32 rsv_1078[2]; /* 1078..107C*/
PACKING union CCU_A_REG_CCU_INFO00 CCU_INFO00; /* 1080*/
PACKING union CCU_A_REG_CCU_INFO01 CCU_INFO01; /* 1084*/
PACKING union CCU_A_REG_CCU_INFO02 CCU_INFO02; /* 1088*/
PACKING union CCU_A_REG_CCU_INFO03 CCU_INFO03; /* 108C*/
PACKING union CCU_A_REG_CCU_INFO04 CCU_INFO04; /* 1090*/
PACKING union CCU_A_REG_CCU_INFO05 CCU_INFO05; /* 1094*/
PACKING union CCU_A_REG_CCU_INFO06 CCU_INFO06; /* 1098*/
PACKING union CCU_A_REG_CCU_INFO07 CCU_INFO07; /* 109C*/
PACKING union CCU_A_REG_CCU_INFO08 CCU_INFO08; /* 10A0*/
PACKING union CCU_A_REG_CCU_INFO09 CCU_INFO09; /* 10A4*/
PACKING union CCU_A_REG_CCU_INFO10 CCU_INFO10; /* 10A8*/
PACKING union CCU_A_REG_CCU_INFO11 CCU_INFO11; /* 10AC*/
PACKING union CCU_A_REG_CCU_INFO12 CCU_INFO12; /* 10B0*/
PACKING union CCU_A_REG_CCU_INFO13 CCU_INFO13; /* 10B4*/
PACKING union CCU_A_REG_CCU_INFO14 CCU_INFO14; /* 10B8*/
PACKING union CCU_A_REG_CCU_INFO15 CCU_INFO15; /* 10BC*/
PACKING union CCU_A_REG_CCU_INFO16 CCU_INFO16; /* 10C0*/
PACKING union CCU_A_REG_CCU_INFO17 CCU_INFO17; /* 10C4*/
PACKING union CCU_A_REG_CCU_INFO18 CCU_INFO18; /* 10C8*/
PACKING union CCU_A_REG_CCU_INFO19 CCU_INFO19; /* 10CC*/
PACKING union CCU_A_REG_CCU_INFO20 CCU_INFO20; /* 10D0*/
PACKING union CCU_A_REG_CCU_INFO21 CCU_INFO21; /* 10D4*/
PACKING union CCU_A_REG_CCU_INFO22 CCU_INFO22; /* 10D8*/
PACKING union CCU_A_REG_CCU_INFO23 CCU_INFO23; /* 10DC*/
PACKING union CCU_A_REG_CCU_INFO24 CCU_INFO24; /* 10E0*/
PACKING union CCU_A_REG_CCU_INFO25 CCU_INFO25; /* 10E4*/
PACKING union CCU_A_REG_CCU_INFO26 CCU_INFO26; /* 10E8*/
PACKING union CCU_A_REG_CCU_INFO27 CCU_INFO27; /* 10EC*/
PACKING union CCU_A_REG_CCU_INFO28 CCU_INFO28; /* 10F0*/
PACKING union CCU_A_REG_CCU_INFO29 CCU_INFO29; /* 10F4*/
PACKING union CCU_A_REG_CCU_INFO30 CCU_INFO30; /* 10F8*/
PACKING union CCU_A_REG_CCU_INFO31 CCU_INFO31; /* 10FC*/
PACKING union CCU_A_REG_AAO_INT_PERIOD AAO_INT_PERIOD; /* 1100*/
PACKING union CCU_A_REG_AAO_INT_CNT AAO_INT_CNT; /* 1104*/
PACKING union CCU_A_REG_AFO_INT_PERIOD AFO_INT_PERIOD; /* 1108*/
PACKING union CCU_A_REG_AFO_INT_CNT AFO_INT_CNT; /* 110C*/
PACKING union CCU_A_REG_PSO_INT_PERIOD PSO_INT_PERIOD; /* 1110*/
PACKING union CCU_A_REG_PSO_INT_CNT PSO_INT_CNT; /* 1114*/
UINT32 rsv_1118[2]; /* 1118..111C*/
PACKING union CCU_A_REG_AAO_FRAME_BCNT AAO_FRAME_BCNT; /* 1120*/
PACKING union CCU_A_REG_AAO_INT_ST AAO_INT_ST; /* 1124*/
PACKING union CCU_A_REG_AFO_FRAME_BCNT AFO_FRAME_BCNT; /* 1128*/
PACKING union CCU_A_REG_AFO_INT_ST AFO_INT_ST; /* 112C*/
PACKING union CCU_A_REG_PSO_FRAME_BCNT PSO_FRAME_BCNT; /* 1130*/
PACKING union CCU_A_REG_PSO_INT_ST PSO_INT_ST; /* 1134*/
UINT32 rsv_1138[14257]; /* 1138..EFF8*/
UINT8 rsv_EFFC; /* EFFC*/
UINT16 rsv_EFFD; /* EFFD*/
UINT8 rsv_F0FF; /* F0FF*/
UINT32 rsv_F100[959]; /* F100..FFF8*/
UINT8 rsv_FFFC; /* FFFC*/
UINT16 rsv_FFFD; /* FFFD*/
};
#ifdef __cplusplus
}
#endif
#endif /* __CCU_A_REGS_H__*/
@@ -0,0 +1,37 @@
#
# Copyright (C) 2016 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.
#
#ion
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion \
-I$(srctree)/drivers/staging/android/mtk_ion/mtk \
-I$(srctree)/drivers/iommu/
#for sensorType in ccu_set_sensor_info
ccflags-y += -I$(srctree)/drivers/misc/mediatek/imgsensor/inc
#
ccflags-y += -I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mach/$(MTK_PLATFORM)/include/mach
ccflags-y += -I$(srctree)/drivers/misc/mediatek/irq/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(MTK_PLATFORM)/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mmp/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/1.2
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/inc/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/$(MTK_PLATFORM)/ccu_ext_interface/
ccflags-y += -I$(srctree)/drivers/i2c/busses/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/imgsensor/inc
#obj-$(CONFIG_MTK_VPU) += ccu_hw.o
obj-y += ccu_hw.o ccu_reg.o ccu_kd_mailbox.o ccu_i2c_hw.o ccu_sw_ver.o
@@ -0,0 +1,12 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CCU_H__
#define __CCU_H__
#include "../1.2/ccu_drv.h"
#endif
@@ -0,0 +1,110 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CCU_INTERFACE__
#define __CCU_INTERFACE__
#include "ccu_ext_interface/ccu_types.h"
extern MBOOL sec_vsync_pushed;
/********************************************************************
* Task definition
********************************************************************/
enum ccu_msg_id {
/*Receive by CCU */
/*CCU Task*/
MSG_TO_CCU_IDLE = 0x00000000,
MSG_TO_CCU_SENSOR_INIT,
MSG_TO_CCU_AE_INIT,
MSG_TO_CCU_AE_START,
MSG_TO_CCU_AE_STOP,
MSG_TO_CCU_SET_SKIP_ALGO,
MSG_TO_CCU_SET_AP_AE_FRAME_SYNC_DATA,
MSG_TO_CCU_SET_AP_AE_ONCHANGE_DATA,
MSG_TO_CCU_GET_CCU_OUTPUT,
MSG_TO_CCU_SET_AP_AE_OUTPUT,
MSG_TO_CCU_SET_AE_ROI,/*9*/
MSG_TO_CCU_SET_AE_EV,
MSG_TO_CCU_SET_MAX_FRAMERATE,
MSG_TO_CCU_SHUTDOWN,
/*todo-add timer sync task */
DELIMITER_CCU_CONTROL_CNT_1,
/*APMCU Ack*/
/*CCU internal task*/
MSG_CCU_INTERNAL_BANK_AE_ALGO,/*14*/
MSG_CCU_INTERNAL_FRAME_AE_ALGO,
MSG_CCU_INTERNAL_VSYNC_AE_SYNC,
DELIMITER_CCU_CONTROL_CNT_2,
/*Send to APMCU */
/*CCU Ack/Done*/
MSG_CCU_DONE_SHUTDOWN,/*18*/
MSG_CCU_DONE_SENSOR_INIT,
MSG_CCU_DONE_AE_INIT,
MSG_CCU_ACK_AE_START,
MSG_CCU_ACK_AE_STOP,/*22*/
MSG_CCU_ACK_SET_SKIP_ALGO,/*22*/
MSG_CCU_ACK_SET_AP_AE_READY,
MSG_CCU_ACK_SET_AP_AE_FRAME_SYNC_DATA,
MSG_CCU_ACK_SET_AP_AE_ONCHANGE_DATA,
MSG_CCU_ACK_GET_CCU_OUTPUT,/*26*/
MSG_CCU_ACK_SET_AP_AE_OUTPUT,
MSG_CCU_ACK_SET_AE_ROI,
MSG_CCU_ACK_SET_AE_EV,
MSG_CCU_ACK_SET_MAX_FRAMERATE,
/*APMCU Task*/
MSG_TO_APMCU_FLUSH_LOG,/*31*/
MSG_TO_APMCU_CCU_ASSERT,
MSG_TO_APMCU_CCU_WARNING,
};
enum ccu_tg_info {
CCU_CAM_TG_NONE = 0x0,
CCU_CAM_TG_1 = 0x1,
CCU_CAM_TG_2 = 0x2,
CAM_CCU_TG_MAX
};
struct ccu_msg_t { /*16bytes*/
enum ccu_msg_id msg_id;
MUINT32 in_data_ptr;
MUINT32 out_data_ptr;
enum ccu_tg_info tg_info;
};
/********************************************************************
* Special isr task (execute in isr)
********************************************************************/
#define ISR_SP_TASK_SHUTDOWN 0x000000FF
#define ISR_SP_TASK_TRG_I2C_DONE 0x000000C1
#define ISR_SP_TASK_RST_I2C_DONE 0x000000B9
/********************************************************************
* Special ap isr task (execute in apmcu_isr)
********************************************************************/
#define APISR_SP_TASK_TRIGGER_I2C 0x000000A1
#define APISR_SP_TASK_RESET_I2C 0x000000A2
/********************************************************************
* Error code definition
********************************************************************/
#define CCU_ERROR_NO (0)
#define CCU_ERROR_QUEUE_FULL (1)
/********************************************************************
* Status definition
********************************************************************/
#define CCU_STATUS_INIT_DONE 0xffff0000
#define CCU_STATUS_INIT_DONE_2 0xffff00a5
/********************************************************************
* Direct-link source definition
********************************************************************/
#define AE_STREAM_DL_SRC_AAO 0x00000000
#define AE_STREAM_DL_SRC_PSO 0x00000001
#endif
@@ -0,0 +1,41 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
/***********************************************************************
* Module: CCU mailbox external interface
*
* Description: External interface for both CCU/APMCU side reference,
* Develop an unified data structure and
* circular queue full/empty definition
***********************************************************************/
#ifndef __CCU_MAILBOX_EXTIF__
#define __CCU_MAILBOX_EXTIF__
#include "ccu_ext_interface/ccu_ext_interface.h"
/*must be power of 2 for modulo operation take work*/
#define CCU_MAILBOX_QUEUE_SIZE 8
/***********************************************************************
* Mailbox is a circular queue
* Composed of 2 pointer front/rear, and a buffer of ccu_msg_t
!!! Implement mailbox operation with following rules !!!
- Initial queue with front=rear=0
- Dequeue with read queue[front+1] and
increase front pointer by 1 (modulus add)
- Enqueue with write into queue[rear+1] and
increase rear pointer by 1 (modulus add)
- Queue is full when front=rear+1
(modulus add: rear+1 = rear+1 % CCU_MAILBOX_QUEUE_SIZE)
- Queue is empty when front=rear
***********************************************************************/
struct ccu_mailbox_t {
MUINT32 front;
MUINT32 rear;
struct ccu_msg_t queue[CCU_MAILBOX_QUEUE_SIZE];
};
#endif
@@ -0,0 +1,66 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef CCU_TYPES_H
#define CCU_TYPES_H
/*********************************************************************/
/* typedef unsigned char BOOLEAN; // uint8_t*/
#define MUINT8 unsigned char
#define MUINT16 unsigned short
#define MUINT32 unsigned int
/*typedef unsigned long MUINT64;*/
/**/
#define MINT8 signed char
#define MINT16 signed short
#define MINT32 signed int
/*typedef signed long MINT64;*/
/**/
#define MFLOAT float
#define MDOUBLE double
/**/
#define MVOID void
#define MBOOL int
#ifndef MTRUE
#define MTRUE 1
#endif
#ifndef MFALSE
#define MFALSE 0
#endif
#ifndef MNULL
#define MNULL 0
#endif
/********************************************************************
*Sensor Types
********************************************************************/
/* #define CCU_CODE_SLIM*/
/* typedef unsigned char BOOLEAN; // uint8_t*/
#define U8 unsigned char /* uint8_t*/
#define U16 unsigned short /* uint16_t*/
#define U32 unsigned int /* uint32_t*/
/*typedef unsigned long long U64; // uint64_t*/
#define I8 char /* int8_t*/
#define I16 short /* int16_t*/
#define I32 int /* int32_t*/
/*typedef long long I64; // int64_t*/
#ifndef NULL
#define NULL 0
#endif /* NULL*/
/********************************************************************
* Error code
********************************************************************/
#define ERR_NONE (0)
#define ERR_INVALID (-1)
#define ERR_TIMEOUT (-2)
#endif /* CCU_TYPES_H*/
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,33 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT6798_CCU_HW_H_
#define _MT6798_CCU_HW_H_
#include "ccu_reg.h"
#include "ccu_drv.h"
/*spare register define*/
#define CCU_STA_REG_SW_INIT_DONE CCU_INFO30
#define CCU_STA_REG_3A_INIT_DONE CCU_INFO01
#define CCU_STA_REG_SP_ISR_TASK CCU_INFO24
#define CCU_STA_REG_I2C_TRANSAC_LEN CCU_INFO25
#define CCU_STA_REG_I2C_DO_DMA_EN CCU_INFO26
/*
* KuanFu Yeh@20160715
* Spare Register Data Type Field
* 0 int32 APMCU mailbox addr.
* 1 int32 CCU mailbox addr.
* 2 int32 DRAM log buffer addr.1
* 3 int32 DRAM log buffer addr.2
*/
#define CCU_DATA_REG_MAILBOX_APMCU CCU_INFO00
#define CCU_DATA_REG_MAILBOX_CCU CCU_INFO01
#define CCU_DATA_REG_LOG_BUF0 CCU_INFO02
#define CCU_DATA_REG_LOG_BUF1 CCU_INFO03
#endif
@@ -0,0 +1,18 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "ccu_cmn.h"
#include "ccu_i2c.h"
#include "ccu_i2c_hw.h"
#include "ccu_n3d_a.h"
static unsigned long g_n3d_base;
int ccu_i2c_set_n3d_base(unsigned long n3d_base)
{
g_n3d_base = n3d_base;
return 0;
}
@@ -0,0 +1,14 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CCU_I2C_HW_H__
#define __CCU_I2C_HW_H__
/*---------------------------------------------------------------------------*/
/* i2c interface from ccu_i2c_hw.c */
/*---------------------------------------------------------------------------*/
extern int ccu_i2c_set_n3d_base(unsigned long n3d_base);
#endif
@@ -0,0 +1,164 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/io.h>
#include "ccu_cmn.h"
#include "ccu_reg.h"
#include "ccu_kd_mailbox.h"
#include "ccu_mailbox_extif.h"
static struct ccu_mailbox_t *_ccu_mailbox;
static struct ccu_mailbox_t *_apmcu_mailbox;
static enum mb_result _mailbox_write_to_buffer(struct ccu_msg_t *task);
static int ccu_msg_copy(struct ccu_msg_t *dest, struct ccu_msg_t *src);
/*********************************************************************
* Public functions
*********************************************************************/
enum mb_result mailbox_init(struct ccu_mailbox_t *apmcu_mb_addr,
struct ccu_mailbox_t *ccu_mb_addr)
{
_ccu_mailbox = ccu_mb_addr;
_apmcu_mailbox = apmcu_mb_addr;
LOG_DBG("ccu_mailbox addr: %p\n", _ccu_mailbox);
LOG_DBG("apmcu_mailbox addr: %p\n", _apmcu_mailbox);
/* memory barrier to check mailbox value wrote into DRAM*/
/* instead of keep in CPU write buffer*/
mb();
return MAILBOX_OK;
}
enum mb_result mailbox_send_cmd(struct ccu_msg_t *task)
{
/*Fill slot*/
enum mb_result result = _mailbox_write_to_buffer(task);
if (result != MAILBOX_OK)
return result;
LOG_DBG("sending cmd: f(%d), r(%d), cmd(%d), in(%x), out(%x)\n",
_ccu_mailbox->front,
_ccu_mailbox->rear,
_ccu_mailbox->queue[_ccu_mailbox->rear].msg_id,
_ccu_mailbox->queue[_ccu_mailbox->rear].in_data_ptr,
_ccu_mailbox->queue[_ccu_mailbox->rear].out_data_ptr);
/*Send interrupt*/
/* MCU write this field to trigger ccu interrupt pulse */
ccu_write_reg_bit(ccu_base, CTL_CCU_INT, INT_CTL_CCU, 1);
return MAILBOX_OK;
}
enum mb_result mailbox_receive_cmd(struct ccu_msg_t *task)
{
enum mb_result result;
MUINT32 rear;
MUINT32 front;
MUINT32 nextReadSlot;
rear = _apmcu_mailbox->rear;
front = _apmcu_mailbox->front;
/*Check if queue is empty*/
/*empty when front=rear*/
if (rear != front) {
/*modulus add:
*rear+1 = rear+1 % CCU_MAILBOX_QUEUE_SIZE
*/
nextReadSlot = (_apmcu_mailbox->front + 1) &
(CCU_MAILBOX_QUEUE_SIZE - 1);
ccu_msg_copy(task, &(_apmcu_mailbox->queue[nextReadSlot]));
_apmcu_mailbox->front = nextReadSlot;
LOG_DBG("%s: f(%d), r(%d), cmd(%d), in(%x), out(%x)\n",
"received cmd",
_apmcu_mailbox->front,
_apmcu_mailbox->rear,
_apmcu_mailbox->queue[nextReadSlot].msg_id,
_apmcu_mailbox->queue[nextReadSlot].in_data_ptr,
_apmcu_mailbox->queue[nextReadSlot].out_data_ptr);
result = MAILBOX_OK;
} else {
LOG_DBG("apmcu mailbox is empty\n");
result = MAILBOX_QUEUE_EMPTY;
}
return result;
}
/*********************************************************************
* Private functions
*********************************************************************/
static int ccu_msg_copy(struct ccu_msg_t *dest, struct ccu_msg_t *src)
{
dest->msg_id = src->msg_id;
dest->in_data_ptr = src->in_data_ptr;
dest->out_data_ptr = src->out_data_ptr;
dest->tg_info = src->tg_info;
return 0;
}
static enum mb_result _mailbox_write_to_buffer(struct ccu_msg_t *task)
{
enum mb_result result;
MUINT32 nextWriteSlot =
(_ccu_mailbox->rear + 1) & (CCU_MAILBOX_QUEUE_SIZE - 1);
/*Check if queue is full*/
/*full when front=rear+1
*(modulus add: rear+1 = rear+1 % CCU_MAILBOX_QUEUE_SIZE)
*/
if (nextWriteSlot == _ccu_mailbox->front) {
LOG_DBG("ccu mailbox queue full !!\n");
result = MAILBOX_QUEUE_FULL;
} else {
LOG_DBG("copy cmd to mailbox slot: %d\n", nextWriteSlot);
LOG_DBG("target mailbox slot address: %p\n",
&(_ccu_mailbox->queue[nextWriteSlot]));
LOG_DBG("incming cmd: cmd(%d), in(%x), out(%x)\n",
task->msg_id,
task->in_data_ptr,
task->out_data_ptr
);
LOG_DBG("writing target: slot(%d), cmd(%d), in(%x), out(%x)\n",
nextWriteSlot,
_ccu_mailbox->queue[nextWriteSlot].msg_id,
_ccu_mailbox->queue[nextWriteSlot].in_data_ptr,
_ccu_mailbox->queue[nextWriteSlot].out_data_ptr
);
ccu_msg_copy(&(_ccu_mailbox->queue[nextWriteSlot]), task);
_ccu_mailbox->rear = nextWriteSlot;
LOG_DBG("wrote target: slot(%d), cmd(%d), in(%x), out(%x)\n",
_ccu_mailbox->rear,
_ccu_mailbox->queue[_ccu_mailbox->rear].msg_id,
_ccu_mailbox->queue[_ccu_mailbox->rear].in_data_ptr,
_ccu_mailbox->queue[_ccu_mailbox->rear].out_data_ptr
);
/* memory barrier to check mailbox value wrote into DRAM*/
/* instead of keep in CPU write buffer*/
mb();
result = MAILBOX_OK;
}
return result;
}
@@ -0,0 +1,24 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CCU_MAILBOX_H__
#define __CCU_MAILBOX_H__
#include "ccu_ext_interface/ccu_mailbox_extif.h"
enum mb_result {
MAILBOX_OK = 0,
MAILBOX_QUEUE_FULL,
MAILBOX_QUEUE_EMPTY
};
enum mb_result mailbox_init(struct ccu_mailbox_t *apmcu_mb_addr,
struct ccu_mailbox_t *ccu_mb_addr);
enum mb_result mailbox_send_cmd(struct ccu_msg_t *task);
enum mb_result mailbox_receive_cmd(struct ccu_msg_t *task);
#endif
@@ -0,0 +1,29 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _CCU_PLATFORM_DEF_
#define _CCU_PLATFORM_DEF_
/*For user/kernel space sync.*/
#define CCU_HW_OFFSET (0x0)
#define CCU_PMEM_BASE (0x1A0A0000)
#define CCU_PMEM_SIZE (0x10000)
#define CCU_DMEM_BASE (0x1A080000)
#define CCU_DMEM_SIZE (0x8000)
#define CCU_DMEM_OFFSET (0x1C00)
#define CCU_LOG_BASE (0x500)
#define CCU_LOG_SIZE (0x400)
#define CCU_HW_DUMP_SIZE (0x550)
#define CCU_CAMSYS_BASE (0x1A000000)
#define CCU_CAMSYS_SIZE (0x1000)
#define CCU_N3D_A_BASE (0x1A040000)
#define CCU_N3D_A_SIZE (0x1000)
#define CCU_SENSOR_PM_SIZE (0x1000)
#define CCU_SENSOR_DM_SIZE (0x600)
#define CCU_ISR_LOG_BASE (0x1A00)
#define CCU_ISR_LOG_SIZE (0x200)
#define CCU_HEADER_NUM (20)
#endif
@@ -0,0 +1,12 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "ccu_reg.h"
/*js_test*/
#include "CCU_A_c_header.h"
struct CCU_A_REGS *g_CCU_A_BASE;
uint64_t ccu_base;
@@ -0,0 +1,66 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT6799_CCU_REG_H_
#define _MT6799_CCU_REG_H_
#include <sync_write.h>
#include "ccu_sw_ver.h"
#include "CCU_A_c_header.h"
/*For CCU_A_c_header_v2*/
/*
*#define SW_VER_SPLIT 0
*#if (SW_VER_SPLIT == 1)
*#include "CCU_A_c_header_v2.h"
*#define ccu_read_reg(base, regName) \
* ((g_ccu_sw_version == CHIP_SW_VER_01) ? \
* ((PCCU_A_REGS)base)->regName.Raw : \
* ((PCCU_A_REGS_V2)base)->regName.Raw \
* )
*#define ccu_write_reg(base, regName, val) \
* do { if (g_ccu_sw_version == CHIP_SW_VER_01) { \
* ((PCCU_A_REGS)base)->regName.Raw = val; \
* } else { \
* ((PCCU_A_REGS_V2)base)->regName.Raw = val; \
* } } while (0)
*#define ccu_read_reg_bit(base, regName, fieldNmae) \
* ((g_ccu_sw_version == CHIP_SW_VER_01) ? \
* ((PCCU_A_REGS)base)->regName.Bits.fieldNmae : \
* ((PCCU_A_REGS_V2)base)->regName.Bits.fieldNmae \
* )
*#define ccu_write_reg_bit(base, regName, fieldNmae, val) \
* do { if (g_ccu_sw_version == CHIP_SW_VER_01) { \
* ((PCCU_A_REGS)base)->regName.Bits.fieldNmae = val; \
* } else { \
* ((PCCU_A_REGS_V2)base)->regName.Bits.fieldNmae = val; \
* } } while (0)
*#else
*/
/*#define ccu_read_reg(base, regName) \
* (((struct CCU_A_REGS *)base)->regName.Raw)
*#define ccu_write_reg(base, regName, val) \
* (((struct CCU_A_REGS *)base)->regName.Raw = val)
*/
#define ccu_read_reg_bit(base, regName, fieldNmae) \
(((struct CCU_A_REGS *)(uintptr_t)base)->regName.Bits.fieldNmae)
#define ccu_write_reg_bit(base, regName, fieldNmae, val) \
(((struct CCU_A_REGS *)(uintptr_t)base)->regName.Bits.fieldNmae = val)
#define ccu_read_reg(base, regName) \
readl(&(((struct CCU_A_REGS *)(uintptr_t)base)->regName))
#define ccu_write_reg(base, regName, val) \
writel(val, &(((struct CCU_A_REGS *)(uintptr_t)base)->regName))
/*#endif*/
#define CCU_SET_BIT(reg, bit) \
((*(unsigned int *)(reg)) |= (unsigned int)(1 << (bit)))
#define CCU_CLR_BIT(reg, bit) \
((*(unsigned int *)(reg)) &= ~((unsigned int)(1 << (bit))))
extern uint64_t ccu_base;
#endif
@@ -0,0 +1,28 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifdef CONFIG_MTK_CHIP
#include <linux/kernel.h>
#include "ccu_cmn.h"
#include "ccu_sw_ver.h"
enum chip_sw_ver g_ccu_sw_version = -1;
int init_check_sw_ver(void)
{
g_ccu_sw_version = mt_get_chip_sw_ver();
if ((g_ccu_sw_version != CHIP_SW_VER_02) &&
(g_ccu_sw_version != CHIP_SW_VER_01)) {
LOG_ERR("have a wrong software version:%x!\n",
g_ccu_sw_version);
return -EINVAL;
}
return 0;
}
#endif
@@ -0,0 +1,19 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifdef CONFIG_MTK_CHIP
#ifndef _CCU_SW_VER_H_
#define _CCU_SW_VER_H_
#include <mt-plat/mtk_chip.h>
extern enum chip_sw_ver g_ccu_sw_version;
int init_check_sw_ver(void);
#endif
#endif
@@ -0,0 +1,13 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __COMMON_H__
#define __COMMON_H__
#define UINT8 unsigned char
#define UINT16 unsigned short
#define UINT32 unsigned int
#endif /* __COMMON_H__*/
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,45 @@
#
# Copyright (C) 2016 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.
#
#ion
ccflags-y += -I$(srctree)/drivers/iommu/ \
# -I$(srctree)/drivers/staging/android/ion \
# -I$(srctree)/drivers/staging/android/ion/mtk \
ifeq ($(CONFIG_MTK_ION),y)
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion/
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion/mtk/
else
ccflags-$(CONFIG_ION) += -I$(srctree)/drivers/staging/android/aosp_ion/
endif
#for sensorType in ccu_set_sensor_info
ccflags-y += -I$(srctree)/drivers/misc/mediatek/imgsensor/inc
#
ccflags-y += -I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mach/$(MTK_PLATFORM)/include/mach
ccflags-y += -I$(srctree)/drivers/misc/mediatek/irq/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(MTK_PLATFORM)/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mmp/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/2.1
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/inc/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/$(MTK_PLATFORM)/ccu_ext_interface/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/smi/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/smi/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mmdvfs/
ccflags-y += -I$(srctree)/drivers/i2c/busses/
#obj-$(CONFIG_MTK_VPU) += ccu_hw.o
obj-y += ccu_hw.o ccu_reg.o ccu_kd_mailbox.o ccu_i2c_hw.o ccu_sw_ver.o ccu_imgsensor.o ccu_mva.o ccu_qos.o ccu_ipc.o
@@ -0,0 +1,12 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_H__
#define __CCU_H__
#include "../1.0/ccu_drv.h"
#endif
@@ -0,0 +1,128 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_INTERFACE__
#define __CCU_INTERFACE__
#include "ccu_ext_interface/ccu_types.h"
extern MBOOL sec_vsync_pushed;
/******************************************************************************
* Task definition
******************************************************************************/
typedef enum {
DELIMITER_SYSCTRL_MSG_MIN = 0, /*To identify ccu control msg count*/
/*Receive by CCU*/
MSG_TO_CCU_IDLE = DELIMITER_SYSCTRL_MSG_MIN,
MSG_TO_CCU_SUSPEND, /*Request CCU to suspend on corresponding TG*/
MSG_TO_CCU_RESUME, /*Request CCU to resume on corresponding TG*/
MSG_TO_CCU_SHUTDOWN, /*Request CCU to shutdown*/
MSG_TO_CCU_UPDATE_TG_SENSOR_MAP,
DELIMITER_SYSCTRL_MSG_1, /*To identify ccu control msg count*/
/*CCU internal task generated in HW isr*/
MSG_CCU_INTERNAL_VSYNC_SYS = DELIMITER_SYSCTRL_MSG_1,
MSG_CCU_INTERNAL_P1_DONE_SYS,
MSG_CCU_INTERNAL_PR_LOG,
MSG_CCU_INTERNAL_FORCE_SHUTDOWN, /*Request CCU to shutdown*/
DELIMITER_SYSCTRL_MSG_MAX /*To identify ccu control msg count*/
} ccu_msg_id;
typedef enum {
MSG_TO_APMCU_FLUSH_LOG, //CCU Request APMCU to print out CCU logs
MSG_TO_APMCU_CCU_ASSERT, //CCU inform APMCU that CCU ASSERT occurs
MSG_TO_APMCU_CCU_WARNING, //CCU inform APMCU that CCU WARNING occurs
MSG_TO_APMCU_CAM_AFO_i,
MSG_TO_APMCU_CAM_AFO_ABORT = 255
} ccu_to_ap_msg_id;
enum ccu_feature_type {
CCU_FEATURE_UNDEF = 0x0,
CCU_FEATURE_MIN = 0x1,
CCU_FEATURE_AE = CCU_FEATURE_MIN,
CCU_FEATURE_AF,
CCU_FEATURE_LTM,
CCU_FEATURE_3ACTRL,
CCU_FEATURE_SYSCTRL,
CCU_FEATURE_MAX,
};
enum ccu_tg_info {
CCU_CAM_TG_NONE = 0x0,
CCU_CAM_TG_MIN = 0x1,
CCU_CAM_TG_1 = 0x1,
CCU_CAM_TG_2 = 0x2,
CCU_CAM_TG_3 = 0x3,
CCU_CAM_TG_MAX
};
struct ccu_msg {
enum ccu_feature_type feature_type;
uint32_t msg_id;
MUINT32 in_data_ptr;
MUINT32 out_data_ptr;
enum ccu_tg_info tg_info;
uint32_t sensor_idx;
};
struct ccu_control_info {
enum ccu_feature_type feature_type;
uint32_t sensor_idx; //new
uint32_t msg_id;
uint64_t inDataPtr;
uint32_t inDataSize;
uint64_t outDataPtr;
uint32_t outDataSize;
};
struct ap2ccu_ipc_t {
MUINT32 write_cnt;
MUINT32 read_cnt;
struct ccu_msg msg;
MBOOL ack;
};
struct exif_data_addrs_s {
MUINT32 ae_algo_data_addr;
MUINT32 ae_init_data_addr;
MUINT32 ae_vsync_info_addr;
MUINT32 aesync_algo_in_addr;
MUINT32 aesync_algo_out_addr;
};
#define CCU_INSTANCE_CAPACITY 2
struct __aligned(8) shared_buf_map {
/*** from CCU->APMCU ***/
MUINT32 ipc_in_data_addr_ccu;
MUINT32 ipc_out_data_addr_ccu;
MUINT32 ipc_in_data_base_offset;
MUINT32 ipc_out_data_base_offset;
MUINT32 ipc_base_offset;
struct exif_data_addrs_s exif_data_addrs[CCU_INSTANCE_CAPACITY];
MUINT32 ae_shared_buf_mva;
//>>>>>>> LTM datas
MUINT32 ltm_shared_buf_mva;
//AF datas
MUINT32 af_shared_buf_mva;
/*** from APMCU->CCU ***/
MUINT32 bkdata_ddr_buf_mva;
};
/******************************************************************************
* Status definition
******************************************************************************/
#define CCU_STATUS_INIT_DONE 0xffff0000
#define CCU_STATUS_INIT_DONE_2 0xffff00a5
#endif
@@ -0,0 +1,36 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
/*******************************************************************************************
* Module: CCU mailbox external interface
*
* Description: External interface for both CCU/APMCU side reference,
* Develop an unified data structure and circular queue full/empty definition
********************************************************************************************/
#ifndef __CCU_MAILBOX_EXTIF__
#define __CCU_MAILBOX_EXTIF__
#include "ccu_ext_interface/ccu_ext_interface.h"
#define CCU_MAILBOX_QUEUE_SIZE 8 /*must be power of 2 for modulo operation take work*/
/******************************************************************************
* Mailbox is a circular queue
* Composed of 2 pointer front/rear, and a buffer of struct ccu_msg
!!! Implement mailbox operation with following rules !!!
- Initial queue with front=rear=0
- Dequeue with read queue[front+1] and increase front pointer by 1 (modulus add)
- Enqueue with write into queue[rear+1] and increase rear pointer by 1 (modulus add)
- Queue is full when front=rear+1 (modulus add: rear+1 = rear+1 % CCU_MAILBOX_QUEUE_SIZE)
- Queue is empty when front=rear
******************************************************************************/
struct ccu_mailbox_t {
MUINT32 front;
MUINT32 rear;
struct ccu_msg queue[CCU_MAILBOX_QUEUE_SIZE];
};
#endif
@@ -0,0 +1,66 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef CCU_TYPES_H
#define CCU_TYPES_H
/*******************************************************************************/
/* typedef unsigned char BOOLEAN; // uint8_t*/
#define MUINT8 unsigned char
#define MUINT16 unsigned short
#define MUINT32 unsigned int
/*typedef unsigned long MUINT64;*/
/**/
#define MINT8 signed char
#define MINT16 signed short
#define MINT32 signed int
/*typedef signed long MINT64;*/
/**/
#define MFLOAT float
#define MDOUBLE double
/**/
#define MVOID void
#define MBOOL int
#ifndef MTRUE
#define MTRUE 1
#endif
#ifndef MFALSE
#define MFALSE 0
#endif
#ifndef MNULL
#define MNULL 0
#endif
/******************************************************************************
*Sensor Types
******************************************************************************/
/* #define CCU_CODE_SLIM*/
/* typedef unsigned char BOOLEAN; // uint8_t*/
#define U8 unsigned char /* uint8_t*/
#define U16 unsigned short /* uint16_t*/
#define U32 unsigned int /* uint32_t*/
/*typedef unsigned long long U64; // uint64_t*/
#define I8 char /* int8_t*/
#define I16 short /* int16_t*/
#define I32 int /* int32_t*/
/*typedef long long I64; // int64_t*/
#ifndef NULL
#define NULL 0
#endif /* NULL*/
/******************************************************************************
* Error code
******************************************************************************/
#define ERR_NONE (0)
#define ERR_INVALID (-1)
#define ERR_TIMEOUT (-2)
#endif /* CCU_TYPES_H*/
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,36 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef _MT6798_CCU_HW_H_
#define _MT6798_CCU_HW_H_
#include "ccu_reg.h"
#include "ccu_drv.h"
extern void cam_mtcmos_check(void);
/*spare register define*/
#define CCU_STA_REG_SW_INIT_DONE CCU_INFO30
#define CCU_STA_REG_3A_INIT_DONE CCU_INFO01
#define CCU_STA_REG_SP_ISR_TASK CCU_INFO24
#define CCU_STA_REG_I2C_TRANSAC_LEN CCU_INFO25
#define CCU_STA_REG_I2C_DO_DMA_EN CCU_INFO26
#define CCU_STA_REG_QOS_BW_I CCU_INFO27
#define CCU_STA_REG_QOS_BW_O CCU_INFO28
#define CCU_STA_REG_QOS_BW_G CCU_INFO29
/*
* KuanFu Yeh@20160715
* Spare Register Data Type Field
* 0 int32 APMCU mailbox addr.
* 1 int32 CCU mailbox addr.
* 2 int32 DRAM log buffer addr.1
* 3 int32 DRAM log buffer addr.2
*/
#define CCU_DATA_REG_MAILBOX_APMCU CCU_INFO00
#define CCU_DATA_REG_MAILBOX_CCU CCU_INFO01
#define CCU_DATA_REG_LOG_BUF0 CCU_INFO02
#define CCU_DATA_REG_LOG_BUF1 CCU_INFO03
#endif
@@ -0,0 +1,18 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include "ccu_cmn.h"
#include "ccu_i2c.h"
#include "ccu_i2c_hw.h"
#include "ccu_n3d_a.h"
static unsigned long g_n3d_base;
int ccu_i2c_set_n3d_base(unsigned long n3d_base)
{
g_n3d_base = n3d_base;
return 0;
}
@@ -0,0 +1,14 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_I2C_HW_H__
#define __CCU_I2C_HW_H__
/*---------------------------------------------------------------------------*/
/* i2c interface from ccu_i2c_hw.c */
/*---------------------------------------------------------------------------*/
extern int ccu_i2c_set_n3d_base(unsigned long n3d_base);
#endif
@@ -0,0 +1,137 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include <linux/types.h>
#include "ccu_cmn.h"
#include "ccu_imgsensor_if.h"
#include "ccu_lens_if.h"
#include "ccu_imgsensor.h"
#include "kd_camera_feature.h"/*for IMGSENSOR_SENSOR_IDX*/
/*>>>>> Information get from imgsensor driver*/
static int32_t g_ccu_sensor_current_fps[IMGSENSOR_SENSOR_IDX_MAX_NUM] = {-1};
#define SENSOR_NAME_MAX_LEN 50
static struct ccu_sensor_info
g_ccu_sensor_info[IMGSENSOR_SENSOR_IDX_MAX_NUM] = {0};
static char g_ccu_sensor_name
[IMGSENSOR_SENSOR_IDX_MAX_NUM][SENSOR_NAME_MAX_LEN];
static char g_ccu_lens_name
[IMGSENSOR_SENSOR_IDX_MAX_NUM][SENSOR_NAME_MAX_LEN];
/*<<<<< Information get from imgsensor driver*/
void ccu_set_current_fps(int32_t sensorType, int32_t current_fps)
{
g_ccu_sensor_current_fps[sensorType] = current_fps;
LOG_DBG_MUST("ccu catch current fps : type(%d), fps(%d)\n",
sensorType, current_fps);
}
void ccu_get_current_fps(int32_t *current_fps_list)
{
int i;
for (i = IMGSENSOR_SENSOR_IDX_MIN_NUM;
i < IMGSENSOR_SENSOR_IDX_MAX_NUM;
i++)
current_fps_list[i] = g_ccu_sensor_current_fps[i];
}
void ccu_set_sensor_info(int32_t sensorType, struct ccu_sensor_info *info)
{
if (sensorType == IMGSENSOR_SENSOR_IDX_NONE) {
/*Non-sensor*/
LOG_ERR("No sensor been detected.\n");
} else if ((sensorType >= IMGSENSOR_SENSOR_IDX_MIN_NUM) &&
(sensorType < IMGSENSOR_SENSOR_IDX_MAX_NUM)) {
g_ccu_sensor_info[sensorType].slave_addr = info->slave_addr;
g_ccu_sensor_info[sensorType].i2c_id = info->i2c_id;
if (info->sensor_name_string != NULL) {
memcpy(g_ccu_sensor_name[sensorType],
info->sensor_name_string,
strlen(info->sensor_name_string)+1);
g_ccu_sensor_info[sensorType].sensor_name_string =
g_ccu_sensor_name[sensorType];
}
LOG_DBG_MUST("ccu catch sensor %d i2c slave address : 0x%x\n",
sensorType, info->slave_addr);
LOG_DBG_MUST("ccu catch sensor %d name : %s\n",
sensorType, g_ccu_sensor_info[sensorType].sensor_name_string);
LOG_DBG_MUST("ccu catch sensor %d i2c_id : %d\n",
sensorType, g_ccu_sensor_info[sensorType].i2c_id);
} else {
LOG_DBG_MUST("ccu catch sensor i2c slave address fail!\n");
}
}
void ccu_get_sensor_i2c_slave_addr(int32_t *sensorI2cSlaveAddr)
{
int32_t i;
for (i = IMGSENSOR_SENSOR_IDX_MIN_NUM;
i < IMGSENSOR_SENSOR_IDX_MAX_NUM; ++i) {
sensorI2cSlaveAddr[i] =
g_ccu_sensor_info[i].slave_addr;
}
}
void ccu_get_sensor_name(char **sensor_name)
{
int32_t i;
for (i = IMGSENSOR_SENSOR_IDX_MIN_NUM;
i < IMGSENSOR_SENSOR_IDX_MAX_NUM; ++i) {
sensor_name[i] =
g_ccu_sensor_info[i].sensor_name_string;
}
}
uint32_t ccu_get_sensor_i2c_id(uint32_t sensor_idx)
{
uint32_t i2c_id = 0;
if ((sensor_idx >= IMGSENSOR_SENSOR_IDX_MIN_NUM) &&
(sensor_idx < IMGSENSOR_SENSOR_IDX_MAX_NUM))
i2c_id = g_ccu_sensor_info[sensor_idx].i2c_id;
LOG_DBG_MUST("ccu get sensor %d i2c_id : %d\n",
sensor_idx, i2c_id);
return i2c_id;
}
void ccu_set_lens_info(int32_t sensorType, char *lens_name)
{
if (sensorType == IMGSENSOR_SENSOR_IDX_NONE) {
/*Non-sensor*/
LOG_ERR("No lens been detected.\n");
} else if ((sensorType >= IMGSENSOR_SENSOR_IDX_MIN_NUM) &&
(sensorType < IMGSENSOR_SENSOR_IDX_MAX_NUM)) {
if (lens_name != NULL) {
memcpy(g_ccu_lens_name[sensorType],
lens_name,
strlen(lens_name)+1);
}
LOG_DBG_MUST("ccu catch lens %d name : %s\n",
sensorType, lens_name);
} else {
LOG_DBG_MUST("ccu catch lens info fail!\n");
}
}
void ccu_get_lens_name(char **lens_name)
{
int32_t i;
for (i = IMGSENSOR_SENSOR_IDX_MIN_NUM;
i < IMGSENSOR_SENSOR_IDX_MAX_NUM; ++i) {
lens_name[i] = g_ccu_lens_name[i];
}
}
@@ -0,0 +1,19 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef _CCU_IMGSENSOR_H_
#define _CCU_IMGSENSOR_H_
void ccu_get_current_fps(int32_t *current_fps_list);
void ccu_get_sensor_i2c_slave_addr(int32_t *sensorI2cSlaveAddr);
void ccu_get_sensor_name(char **sensor_name);
uint32_t ccu_get_sensor_i2c_id(uint32_t sensor_idx);
void ccu_get_lens_name(char **lens_name);
#endif
@@ -0,0 +1,305 @@
// SPDX-License-Identifier: GPL-2.0
//
// Copyright (c) 2016 MediaTek Inc.
#include <linux/kernel.h>
#include <linux/delay.h>
#include "ccu_ipc.h"
#include "ccu_cmn.h"
#include "ccu_reg.h"
#include "ccu_platform_def.h"
static DEFINE_MUTEX(ccu_ipc_mutex);
#define CCU_IPC_NO_ACK 0x66669999
#define CCU_IPC_CMD_TIMEOUT_SPEC 3000 //3000us = 3ms
struct CCU_IPC_DATA {
MBOOL m_initialized;
uint32_t *m_ccuIntTriggerPtr;
struct ap2ccu_ipc_t *m_ccuIpcPtr;
void *m_ipcInDataPtr;
void *m_ipcOutDataPtr;
uint32_t m_ipcInDataAddrCcu;
uint32_t m_ipcOutDataAddrCcu;
uint64_t ccu_base;
};
static struct CCU_IPC_DATA ccu_ipc;
void ccu_ipc_init(unsigned int *ccuDmBase, unsigned int *ccuCtrlBase)
{
struct shared_buf_map *sb_map_ptr =
(struct shared_buf_map *)(ccuDmBase + OFFSET_CCU_SHARED_BUF_MAP_BASE);
ccu_ipc.m_ccuIntTriggerPtr =
(uint32_t *)ccuCtrlBase + OFFSET_CCU_INT_TRG;
ccu_ipc.m_ccuIpcPtr =
(struct ap2ccu_ipc_t *)(((uint8_t *)ccuDmBase) +
sb_map_ptr->ipc_base_offset);
ccu_ipc.m_ipcInDataPtr =
(void *)(((uint8_t *)ccuDmBase) + sb_map_ptr->ipc_in_data_base_offset);
ccu_ipc.m_ipcOutDataPtr =
(void *)(((uint8_t *)ccuDmBase) + sb_map_ptr->ipc_out_data_base_offset);
ccu_ipc.m_ipcInDataAddrCcu = sb_map_ptr->ipc_in_data_addr_ccu;
ccu_ipc.m_ipcOutDataAddrCcu = sb_map_ptr->ipc_out_data_addr_ccu;
ccu_ipc.m_initialized = MTRUE;
ccu_ipc.ccu_base = (unsigned long)ccuCtrlBase;
LOG_DBG("ccuDmBase: %x", ccuDmBase);
LOG_DBG("ccuCtrlBase: %x", ccuCtrlBase);
LOG_DBG("m_ccuIntTriggerPtr: %x", ccu_ipc.m_ccuIntTriggerPtr);
LOG_DBG("m_ccuIpcPtr: %x", ccu_ipc.m_ccuIpcPtr);
LOG_DBG("m_ipcInDataPtr: %x", ccu_ipc.m_ipcInDataPtr);
LOG_DBG("m_ipcOutDataPtr: %x", ccu_ipc.m_ipcOutDataPtr);
}
bool ccu_ipc_getIObuffer(void **ipcInDataPtr, void **ipcOutDataPtr,
uint32_t *ipcInDataAddrCcu, uint32_t *ipcOutDataAddrCcu)
{
LOG_DBG("+");
if (ccu_ipc.m_initialized == MFALSE) {
LOG_ERR("not initialized, invalid operation.");
return MFALSE;
}
*ipcInDataPtr = ccu_ipc.m_ipcInDataPtr;
*ipcOutDataPtr = ccu_ipc.m_ipcOutDataPtr;
*ipcInDataAddrCcu = ccu_ipc.m_ipcInDataAddrCcu;
*ipcOutDataAddrCcu = ccu_ipc.m_ipcOutDataAddrCcu;
LOG_DBG("*ipcInDataPtr: %x", *ipcInDataPtr);
LOG_DBG("*ipcOutDataPtr: %x", *ipcOutDataPtr);
LOG_DBG("*ipcInDataAddrCcu: %x", *ipcInDataAddrCcu);
LOG_DBG("*ipcOutDataAddrCcu: %x", *ipcOutDataAddrCcu);
LOG_DBG("-");
return MTRUE;
}
int ccu_ipc_send(struct ccu_msg *msg)
{
uint32_t loopCount = 0;
uint32_t ackValue = 0;
bool timeout = false;
uint32_t write_cnt = 0;
uint32_t read_cnt = 0;
LOG_DBG("+, ftype(%d), msg_id(%d)", msg->feature_type, msg->msg_id);
if (ccu_ipc.m_initialized == MFALSE) {
LOG_ERR("not initialized, invalid operation.");
return -1;
}
LOG_DBG("+, read_cnt1,%x", &ccu_ipc.m_ccuIpcPtr);
//since ipc is synchronized, check no previous ipc
write_cnt = readl(&(ccu_ipc.m_ccuIpcPtr->write_cnt));
read_cnt = readl(&(ccu_ipc.m_ccuIpcPtr->read_cnt));
if (read_cnt != write_cnt) {
LOG_ERR("CCU IPC synchronization violation, rcnt:%d, wcnt:%d",
read_cnt, write_cnt);
return -1;
}
LOG_DBG("+, read_cnt2");
writel(CCU_IPC_NO_ACK, &ccu_ipc.m_ccuIpcPtr->ack);
write_cnt = readl(&ccu_ipc.m_ccuIpcPtr->write_cnt);
writel(write_cnt + 1, &ccu_ipc.m_ccuIpcPtr->write_cnt);
LOG_DBG("+set msg");
writel(msg->feature_type, &ccu_ipc.m_ccuIpcPtr->msg.feature_type);
writel(msg->msg_id, &ccu_ipc.m_ccuIpcPtr->msg.msg_id);
writel(msg->in_data_ptr, &ccu_ipc.m_ccuIpcPtr->msg.in_data_ptr);
writel(msg->out_data_ptr, &ccu_ipc.m_ccuIpcPtr->msg.out_data_ptr);
writel(msg->tg_info, &ccu_ipc.m_ccuIpcPtr->msg.tg_info);
writel(msg->sensor_idx, &ccu_ipc.m_ccuIpcPtr->msg.sensor_idx);
LOG_DBG("+, CCU IPC TRIG");
ccu_write_reg_bit(ccu_ipc.ccu_base, EXT2CCU_INT_CCU,
EXT2CCU_INT_CCU, 1);
while (readl(&ccu_ipc.m_ccuIpcPtr->ack) == CCU_IPC_NO_ACK) {
loopCount++;
udelay(100);
if (loopCount > CCU_IPC_CMD_TIMEOUT_SPEC) {
ackValue = readl(&ccu_ipc.m_ccuIpcPtr->ack);
if (ackValue == CCU_IPC_NO_ACK)
timeout = true;
else
LOG_DBG_MUST("CCU cmd timeout false alarm");
break;
}
}
if (timeout) {
LOG_ERR("CCU cmd timeout");
LOG_ERR("ftype(%d), msg_id(%d), ackValue(%d), loopCount(%d)",
msg->feature_type, msg->msg_id, ackValue, loopCount);
return -1;
}
LOG_DBG("-, ftype(%d), msg_id(%d), loopCount(%d)",
msg->feature_type, msg->msg_id, loopCount);
return 0;
}
bool _copyCmdInData(struct CcuIOBufInfo *inDataBufInfo,
void *inDataPtr, uint32_t inDataSize)
{
uint32_t i, copy_len;
uint32_t data = 0;
uint32_t align_data = 0;
LOG_DBG("+:%s\n", __func__);
if (inDataBufInfo->bufType == CCU_SRAM_IO) {
// copy to sram
uint32_t *realIoBuf = (uint32_t *)inDataBufInfo->addr_ap;
//copy from _interIBuf to real IO buffer in unit of 4bytes,
//to avoid APB bus constraint of non-4byte-aligned data access
for (i = 0; i < (inDataSize/4); i++) {
// realIoBuf[i] = ((uint32_t *)inDataPtr)[i];
writel(((uint32_t *)inDataPtr)[i], &realIoBuf[i]);
}
if ((inDataSize % 4) != 0) {
copy_len = inDataSize & ~(0x3);
for (i = 0; i < inDataSize%4; ++i) {
data = *((char *)inDataPtr + copy_len + i);
align_data += data << (8 * i);
}
writel(align_data, &realIoBuf[inDataSize/4]);
}
}
LOG_DBG("-:%s\n", __func__);
return true;
}
bool _copyCmdOutData(struct CcuIOBufInfo *outDataBufInfo,
void *outDataPtr, uint32_t outDataSize)
{
uint32_t i;
LOG_DBG("+:%s\n", __func__);
if (outDataBufInfo->bufType == CCU_SRAM_IO) {
uint32_t *realIoBuf = (uint32_t *)outDataBufInfo->addr_ap;
//copy from _interIBuf to real IO buffer in unit of 4bytes,
//to avoid APB bus constraint of non-4byte-aligned data access
for (i = 0; i < (outDataSize/4); i++) {
// ((uint32_t *)outDataPtr)[i] = realIoBuf[i];
writel(realIoBuf[i], &((uint32_t *)outDataPtr)[i]);
}
if ((outDataSize % 4) != 0)
writel(realIoBuf[i], &((uint32_t *)outDataPtr)[i]);
}
LOG_DBG("-:%s\n", __func__);
return MTRUE;
}
bool _resolveCmdIOBuf(struct CcuIOBufInfo *inDataBufInfo,
struct CcuIOBufInfo *outDataBufInfo,
uint32_t inDataSize, uint32_t outDataSize)
{
bool ret;
ret = ccu_ipc_getIObuffer((void **)&inDataBufInfo->addr_ap,
(void **)&outDataBufInfo->addr_ap,
&inDataBufInfo->addr_ccu, &outDataBufInfo->addr_ccu);
if (!ret) {
LOG_ERR("IPC not initialized");
return false;
}
LOG_DBG("inDataSize(%d), sramInBufCapacity(%d)",
inDataSize, CCU_IPC_IBUF_CAPACITY);
LOG_DBG("outDataSize(%d), sramOutBufCapacity(%d)",
outDataSize, CCU_IPC_OBUF_CAPACITY);
// Resolve Input buffer
if (inDataSize <= CCU_IPC_IBUF_CAPACITY) {
LOG_DBG("using Sram input buffer");
inDataBufInfo->bufType = CCU_SRAM_IO;
} else {
LOG_ERR("inDataSize excceed buffer capacity., sramBufCap(%d)",
CCU_IPC_IBUF_CAPACITY);
return false;
}
LOG_DBG("inDataBufInfo.addr_ap: %x, addr_ccu: %x",
inDataBufInfo->addr_ap, inDataBufInfo->addr_ccu);
// Resolve Output buffer
if (outDataSize <= CCU_IPC_OBUF_CAPACITY) {
LOG_DBG("using Sram output buffer");
outDataBufInfo->bufType = CCU_SRAM_IO;
} else {
LOG_ERR("outDataSize excceed buffer capacity.");
return false;
}
LOG_DBG("outDataBufInfo.addr_ap: %x, addr_ccu: %x",
outDataBufInfo->addr_ap, outDataBufInfo->addr_ccu);
return true;
}
bool ccuControl(
enum ccu_feature_type featureType,
enum IMGSENSOR_SENSOR_IDX sensorIdx,
uint32_t msgId, void *inDataPtr,
uint32_t inDataSize, void *outDataPtr, uint32_t outDataSize)
{
struct CcuIOBufInfo inDataBufInfo = {0};
struct CcuIOBufInfo outDataBufInfo = {0};
struct ccu_msg msg = {featureType, msgId, inDataBufInfo.addr_ccu,
outDataBufInfo.addr_ccu, CCU_CAM_TG_NONE, sensorIdx};
uint32_t ret;
mutex_lock(&ccu_ipc_mutex);
LOG_DBG("[%s]+: ft(%d), sIdx(%d), msgId(%d)\n",
__func__, featureType, sensorIdx, msgId);
//resolve IO buf
ret = _resolveCmdIOBuf(&inDataBufInfo,
&outDataBufInfo, inDataSize, outDataSize);
if (ret == MFALSE) {
LOG_ERR("resolveCmdIOBuf failed, cmd abort.");
mutex_unlock(&ccu_ipc_mutex);
return false;
}
//Check if need input data
if (inDataSize != 0) {
//copy input data to IPC buffer & command data buffer
_copyCmdInData(&inDataBufInfo, inDataPtr, inDataSize);
}
msg.in_data_ptr = inDataBufInfo.addr_ccu;
msg.out_data_ptr = outDataBufInfo.addr_ccu;
ret = ccu_ipc_send(&msg);
if (ret != 0) {
LOG_ERR("sendCcuCommnadIpc failed, msgId(%d)", msgId);
mutex_unlock(&ccu_ipc_mutex);
return false;
}
//check if need to copy output data
if (outDataSize != 0)
_copyCmdOutData(&outDataBufInfo, outDataPtr, outDataSize);
LOG_DBG("-:\n", __func__);
mutex_unlock(&ccu_ipc_mutex);
return true;
}
@@ -0,0 +1,33 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include "ccu_ext_interface/ccu_ext_interface.h"
#include "kd_camera_feature.h"/*for sensoridx enum*/
enum IoBufType {
SYS_DRAM_IO,
CCU_SRAM_IO
};
struct CcuIOBufInfo {
enum IoBufType bufType;
uint8_t *addr_ap;
uint8_t *addr_ap_interm;
uint32_t addr_ccu;
};
bool ccuControl(
enum ccu_feature_type featureType,
enum IMGSENSOR_SENSOR_IDX sensorIdx,
uint32_t msgId, void *inDataPtr, uint32_t inDataSize,
void *outDataPtr, uint32_t outDataSize);
bool _copyCmdInData(struct CcuIOBufInfo *inDataBufInfo,
void *inDataPtr, uint32_t inDataSize);
bool _copyCmdOutData(struct CcuIOBufInfo *outDataBufInfo,
void *outDataPtr, uint32_t outDataSize);
void ccu_ipc_init(unsigned int *ccuDmBase, unsigned int *ccuCtrlBase);
int ccu_ipc_send(struct ccu_msg *msg);
bool ccu_ipc_getIObuffer(void **ipcInDataPtr, void **ipcOutDataPtr,
uint32_t *ipcInDataAddrCcu, uint32_t *ipcOutDataAddrCcu);
@@ -0,0 +1,165 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include <linux/io.h>
#include "ccu_cmn.h"
#include "ccu_reg.h"
#include "ccu_kd_mailbox.h"
#include "ccu_mailbox_extif.h"
static struct ccu_mailbox_t *_ccu_mailbox;
static struct ccu_mailbox_t *_apmcu_mailbox;
static enum mb_result _mailbox_write_to_buffer(struct ccu_msg *task);
/*******************************************************************************
* Public functions
********************************************************************************/
enum mb_result mailbox_init(struct ccu_mailbox_t *apmcu_mb_addr, struct ccu_mailbox_t *ccu_mb_addr)
{
_ccu_mailbox = ccu_mb_addr;
_apmcu_mailbox = apmcu_mb_addr;
LOG_DBG("ccu_mailbox addr: %p\n", _ccu_mailbox);
LOG_DBG("apmcu_mailbox addr: %p\n", _apmcu_mailbox);
/* memory barrier to check mailbox value wrote into DRAM*/
/* instead of keep in CPU write buffer*/
mb();
return MAILBOX_OK;
}
enum mb_result mailbox_send_cmd(struct ccu_msg *task)
{
/*Fill slot*/
enum mb_result result = _mailbox_write_to_buffer(task);
if (result != MAILBOX_OK)
return result;
LOG_DBG("sending cmd: f(%d), r(%d), cmd(%d), in(%x), out(%x)\n",
_ccu_mailbox->front,
_ccu_mailbox->rear,
_ccu_mailbox->queue[_ccu_mailbox->rear].msg_id,
_ccu_mailbox->queue[_ccu_mailbox->rear].in_data_ptr,
_ccu_mailbox->queue[_ccu_mailbox->rear].out_data_ptr);
/*Send interrupt*/
/* MCU write this field to trigger ccu interrupt pulse */
ccu_write_reg_bit(ccu_base, EXT2CCU_INT_CCU,
EXT2CCU_INT_CCU, 1);
return MAILBOX_OK;
}
enum mb_result mailbox_receive_cmd(struct ccu_msg *task)
{
enum mb_result result;
MUINT32 rear;
MUINT32 front;
MUINT32 nextReadSlot;
rear = _apmcu_mailbox->rear;
front = _apmcu_mailbox->front;
/*Check if queue is empty*/
/*empty when front=rear*/
if (rear != front) {
/*modulus add: rear+1 = rear+1 % CCU_MAILBOX_QUEUE_SIZE*/
nextReadSlot = (_apmcu_mailbox->front + 1) & (CCU_MAILBOX_QUEUE_SIZE - 1);
ccu_memcpy(task, &(_apmcu_mailbox->queue[nextReadSlot]), sizeof(struct ccu_msg));
_apmcu_mailbox->front = nextReadSlot;
LOG_DBG("received cmd: f(%d), r(%d), cmd(%d), in(%x), out(%x)\n",
_apmcu_mailbox->front,
_apmcu_mailbox->rear,
_apmcu_mailbox->queue[nextReadSlot].msg_id,
_apmcu_mailbox->queue[nextReadSlot].in_data_ptr,
_apmcu_mailbox->queue[nextReadSlot].out_data_ptr);
result = MAILBOX_OK;
} else {
LOG_DBG("apmcu mailbox is empty\n");
result = MAILBOX_QUEUE_EMPTY;
}
return result;
}
/*******************************************************************************
* Private functions
********************************************************************************/
static int ccu_msg_copy(struct ccu_msg *dest, struct ccu_msg *src)
{
/*LOG_DBG("src->msg_id: %d\n", src->msg_id);*/
dest->msg_id = src->msg_id;
/*LOG_DBG("dest->msg_id: %d\n", dest->msg_id);*/
/*LOG_DBG("src->in_data_ptr: %d\n", src->in_data_ptr);*/
dest->in_data_ptr = src->in_data_ptr;
/*LOG_DBG("dest->in_data_ptr: %d\n", dest->in_data_ptr);*/
/*LOG_DBG("src->out_data_ptr: %d\n", src->out_data_ptr);*/
dest->out_data_ptr = src->out_data_ptr;
/*LOG_DBG("dest->out_data_ptr: %d\n", dest->out_data_ptr);*/
dest->tg_info = src->tg_info;
/*LOG_DBG_MUST("dest->tg_info: %d\n", dest->tg_info);*/
return 0;
}
static enum mb_result _mailbox_write_to_buffer(struct ccu_msg *task)
{
enum mb_result result;
MUINT32 nextWriteSlot = (_ccu_mailbox->rear + 1) & (CCU_MAILBOX_QUEUE_SIZE - 1);
/*Check if queue is full*/
/*full when front=rear+1 (modulus add: rear+1 = rear+1 % CCU_MAILBOX_QUEUE_SIZE)*/
if (nextWriteSlot == _ccu_mailbox->front) {
LOG_DBG("ccu mailbox queue full !!\n");
result = MAILBOX_QUEUE_FULL;
} else {
LOG_DBG("copy cmd to mailbox slot: %d\n", nextWriteSlot);
LOG_DBG("target mailbox slot address: %p\n",
&(_ccu_mailbox->queue[nextWriteSlot]));
LOG_DBG("incming cmd: cmd(%d), in(%x), out(%x)\n",
task->msg_id,
task->in_data_ptr,
task->out_data_ptr
);
LOG_DBG("writing target: slot(%d), cmd(%d), in(%x), out(%x)\n",
nextWriteSlot,
_ccu_mailbox->queue[nextWriteSlot].msg_id,
_ccu_mailbox->queue[nextWriteSlot].in_data_ptr,
_ccu_mailbox->queue[nextWriteSlot].out_data_ptr
);
ccu_msg_copy(&(_ccu_mailbox->queue[nextWriteSlot]), task);
_ccu_mailbox->rear = nextWriteSlot;
LOG_DBG("wrote target: slot(%d), cmd(%d), in(%x), out(%x)\n",
_ccu_mailbox->rear,
_ccu_mailbox->queue[_ccu_mailbox->rear].msg_id,
_ccu_mailbox->queue[_ccu_mailbox->rear].in_data_ptr,
_ccu_mailbox->queue[_ccu_mailbox->rear].out_data_ptr
);
/* memory barrier to check mailbox value wrote into DRAM*/
/* instead of keep in CPU write buffer*/
mb();
result = MAILBOX_OK;
}
return result;
}
@@ -0,0 +1,23 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __CCU_MAILBOX_H__
#define __CCU_MAILBOX_H__
#include "ccu_ext_interface/ccu_mailbox_extif.h"
enum mb_result {
MAILBOX_OK = 0,
MAILBOX_QUEUE_FULL,
MAILBOX_QUEUE_EMPTY
};
enum mb_result mailbox_init(struct ccu_mailbox_t *apmcu_mb_addr, struct ccu_mailbox_t *ccu_mb_addr);
enum mb_result mailbox_send_cmd(struct ccu_msg *task);
enum mb_result mailbox_receive_cmd(struct ccu_msg *task);
#endif
@@ -0,0 +1,413 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include "ccu_cmn.h"
#include "ccu_mva.h"
#include "ccu_platform_def.h"
#define ION_LOG_SIZE (10*1024*1024) // 10M
static struct ion_client *_ccu_ion_client;
static struct m4u_client_t *m4u_client;
struct CcuMemHandle ccu_buffer_handle[2];
static int _ccu_ion_get_mva(struct ion_client *client,
struct ion_handle *handle,
unsigned int *mva, bool cached);
static struct ion_handle *_ccu_ion_alloc(struct ion_client *client,
unsigned int heap_id_mask, size_t align, unsigned int size,
bool cached, bool ion_log);
static unsigned long get_ns_systemtime(void);
static int ccu_ion_init_result;
int ccu_ion_init(void)
{
MBOOL need_init = MFALSE;
ccu_lock_ion_client_mutex();
if (!_ccu_ion_client && g_ion_device) {
LOG_INF_MUST("CCU ION_client need init\n");
need_init = MTRUE;
ccu_ion_init_result = 1;
} else if (_ccu_ion_client) {
LOG_INF_MUST("ION Client exist: 0x%p\n",
_ccu_ion_client);
ccu_ion_init_result = 2;
} else {
LOG_INF_MUST("Device NULL: 0x%p\n",
g_ion_device);
ccu_ion_init_result = 3;
}
if (need_init == MTRUE) {
_ccu_ion_client = ion_client_create(g_ion_device, "ccu");
LOG_INF_MUST("CCU ION_client create success: 0x%p\n", _ccu_ion_client);
}
if (!_ccu_ion_client) {
LOG_INF_MUST("ION Client NULL: 0x%p\n",
_ccu_ion_client);
ccu_ion_init_result = 4;
}
m4u_client = m4u_create_client();
if (IS_ERR_OR_NULL(m4u_client))
LOG_ERR("create client fail!\n");
ccu_unlock_ion_client_mutex();
return 0;
}
int ccu_ion_uninit(void)
{
MBOOL need_uninit = MFALSE;
ccu_lock_ion_client_mutex();
ccu_ion_init_result = 0;
if (_ccu_ion_client && g_ion_device) {
LOG_INF_MUST("CCU ION_client need uninit\n");
need_uninit = MTRUE;
}
if (need_uninit == MTRUE) {
ion_client_destroy(_ccu_ion_client);
LOG_INF_MUST("CCU ION_client destroy done.\n");
_ccu_ion_client = NULL;
}
if (m4u_client)
m4u_destroy_client(m4u_client);
ccu_unlock_ion_client_mutex();
return 0;
}
int ccu_deallocate_mva(uint32_t mva)
{
int ret = 0;
LOG_DBG("X-:%s\n", __func__);
if (m4u_client == NULL) {
LOG_ERR("%s: _ccu_ion_client(%d) is null!\n",
__func__, ccu_ion_init_result);
return -EINVAL;
}
if (mva != 0) {
ret = m4u_dealloc_mva(m4u_client, M4U_PORT_CCU0, mva);
if (ret)
LOG_ERR("dealloc mva fail");
}
return ret;
}
int ccu_allocate_mva(uint32_t *mva, void *va, int buffer_size)
{
int ret = 0;
struct sg_table *sg_table;
unsigned int flag;
ret = ccu_config_m4u_port();
if (ret) {
LOG_ERR("fail to config m4u port!\n");
return ret;
}
/* alloc mva */
flag = M4U_FLAGS_START_FROM;
ret = m4u_alloc_mva(m4u_client, M4U_PORT_CCU0, (unsigned long)va,
sg_table, buffer_size,
M4U_PROT_READ | M4U_PROT_WRITE, flag, mva);
if (ret)
LOG_ERR("alloc mva fail");
return ret;
}
int ccu_config_m4u_port(void)
{
int ret = 0;
#if defined(CONFIG_MTK_M4U)
struct M4U_PORT_STRUCT port;
port.ePortID = M4U_PORT_CCU0;
port.Virtuality = 1;
port.Security = 0;
port.domain = 3;
port.Distance = 1;
port.Direction = 0;
ret = m4u_config_port(&port);
#endif
return ret;
}
int ccu_allocate_mem(struct CcuMemHandle *memHandle, int size, bool cached)
{
int ret = 0;
LOG_DBG_MUST("_ccuAllocMem+\n");
LOG_DBG_MUST("size(%d) cached(%d) memHandle->ionHandleKd(%d)\n",
size, cached, memHandle->ionHandleKd);
if (_ccu_ion_client == NULL) {
LOG_ERR("%s: _ccu_ion_client is null!\n", __func__);
return -EINVAL;
}
if (ccu_buffer_handle[cached].ionHandleKd != NULL) {
LOG_ERR("idx %d handle %p is not empty\n", cached,
ccu_buffer_handle[cached].ionHandleKd);
return -EINVAL;
}
//allocate ion buffer handle
memHandle->ionHandleKd = _ccu_ion_alloc(_ccu_ion_client,
ION_HEAP_MULTIMEDIA_MASK,
0, (size_t)size, (cached)?3:0, memHandle->meminfo.ion_log);
if (!memHandle->ionHandleKd) {
LOG_ERR("fail to get ion buffer handle (size=0x%lx)\n", size);
return -1;
}
LOG_DBG_MUST("memHandle->ionHandleKd(%p)\n", memHandle->ionHandleKd);
// get buffer virtual address
memHandle->meminfo.size = size;
memHandle->meminfo.cached = cached;
memHandle->meminfo.va = (char *)ion_map_kernel(_ccu_ion_client,
memHandle->ionHandleKd);
if (memHandle->meminfo.va == NULL) {
LOG_ERR("fail to get buffer kernel virtual address");
return -EINVAL;
}
LOG_DBG_MUST("memHandle->va(0x%lx)\n", memHandle->meminfo.va);
ret = _ccu_ion_get_mva(_ccu_ion_client, memHandle->ionHandleKd,
&memHandle->meminfo.mva, cached);
if (ret) {
LOG_ERR("ccu ion_get_mva failed\n");
return -1;
}
LOG_DBG_MUST("memHandle->mva(0x%lx)\n", memHandle->meminfo.mva);
LOG_DBG_MUST("_ccuAllocMem-\n");
ccu_buffer_handle[memHandle->meminfo.cached] = *memHandle;
return (memHandle->ionHandleKd != NULL) ? 0 : -1;
}
int ccu_deallocate_mem(struct CcuMemHandle *memHandle)
{
uint32_t idx = (memHandle->meminfo.cached != 0) ? 1 : 0;
LOG_DBG_MUST("free idx(%d) mva(0x%x) fd(0x%x) cached(0x%x)\n", idx,
ccu_buffer_handle[idx].meminfo.mva,
ccu_buffer_handle[idx].meminfo.shareFd,
memHandle->meminfo.cached);
if (_ccu_ion_client == NULL) {
LOG_ERR("%s: _ccu_ion_client is null!\n", __func__);
return -EINVAL;
}
if (ccu_buffer_handle[idx].ionHandleKd == 0) {
LOG_ERR("idx %d handle %d is empty\n", idx,
ccu_buffer_handle[idx].ionHandleKd);
return -EINVAL;
}
ion_unmap_kernel(_ccu_ion_client,
ccu_buffer_handle[idx].ionHandleKd);
ion_free(_ccu_ion_client,
ccu_buffer_handle[idx].ionHandleKd);
if ((memHandle->meminfo.ion_log) && (memHandle->meminfo.size > ION_LOG_SIZE)) //10M
LOG_INF_MUST("ion free size = %d, caller = CCU\n", memHandle->meminfo.size);
memset(&(ccu_buffer_handle[idx]), 0,
sizeof(struct CcuMemHandle));
return 0;
}
#define ION_FLAG_FREE_WITHOUT_DEFER (4)
static struct ion_handle *_ccu_ion_alloc(struct ion_client *client,
unsigned int heap_id_mask, size_t align, unsigned int size, bool cached, bool ion_log)
{
unsigned long ts_start, ts_end;
struct ion_handle *disp_handle = NULL;
if (ion_log)
ts_start = get_ns_systemtime();
disp_handle = ion_alloc(client, size, align,
heap_id_mask, ((cached)?3:0) | ION_FLAG_FREE_WITHOUT_DEFER);
if (IS_ERR(disp_handle)) {
LOG_ERR("disp_ion_alloc 1error %p\n", disp_handle);
return NULL;
}
if ((ion_log) && (size > ION_LOG_SIZE)) { //10M
ts_end = get_ns_systemtime();
LOG_INF_MUST("ion alloc size = %d, caller = CCU, costTime = %lu ns\n",
size, (unsigned long)(ts_end-ts_start));
}
LOG_DBG("disp_ion_alloc 1 %p\n", disp_handle);
return disp_handle;
}
static int _ccu_ion_get_mva(struct ion_client *client,
struct ion_handle *handle,
unsigned int *mva, bool cached)
{
int ret = 0;
struct ion_mm_data mm_data;
struct ion_sys_data sys_data;
int err;
size_t count = 0;
char const *ccu_bufferName = "CCU_BUFFER";
ret = ccu_config_m4u_port();
if (ret) {
LOG_ERR("fail to config m4u port!\n");
return ret;
}
mm_data.mm_cmd = ION_MM_CONFIG_BUFFER_EXT;
mm_data.config_buffer_param.kernel_handle = handle;
mm_data.config_buffer_param.security = 0;
mm_data.config_buffer_param.coherent = 1;
mm_data.config_buffer_param.module_id = M4U_PORT_CCU0;
if (cached == false) {
mm_data.config_buffer_param.reserve_iova_start =
CCU_DDR_BUF_MVA_LOWER_BOUND;
mm_data.config_buffer_param.reserve_iova_end =
CCU_DDR_BUF_MVA_UPPER_BOUND;
} else if (cached == true) {
mm_data.config_buffer_param.reserve_iova_start =
CCU_CTRL_BUFS_LOWER_BOUND;
mm_data.config_buffer_param.reserve_iova_end =
CCU_CTRL_BUFS_UPPER_BOUND;
}
if (ion_kernel_ioctl(client, ION_CMD_MULTIMEDIA,
(unsigned long)&mm_data) < 0) {
LOG_ERR("ION_MM_CONFIG_BUFFER_EXT: config buffer failed.%p -%p\n",
client, handle);
ion_free(client, handle);
return -1;
}
LOG_DBG_MUST("ION_MM_CONFIG_BUFFER_EXT done\n");
sys_data.sys_cmd = ION_SYS_GET_PHYS;
sys_data.get_phys_param.kernel_handle = handle;
sys_data.get_phys_param.phy_addr = (M4U_PORT_CCU0<<24) |
ION_FLAG_GET_FIXED_PHYS;
sys_data.get_phys_param.len = ION_FLAG_GET_FIXED_PHYS;
if (ion_kernel_ioctl(client, ION_CMD_SYSTEM,
(unsigned long)&sys_data) < 0) {
LOG_ERR("ION_SYS_GET_PHYS: get iova failed.%p -%p\n",
client, handle);
ion_free(client, handle);
return -1;
}
*mva = sys_data.get_phys_param.phy_addr;
LOG_DBG_MUST("alloc mmu addr hnd=0x%p,mva=0x%lx\n",
handle, sys_data.get_phys_param.phy_addr);
LOG_DBG_MUST("alloc mmu addr hnd=0x%p,mva=0x%08x\n",
handle, (unsigned int)*mva);
mm_data.mm_cmd = ION_MM_SET_DEBUG_INFO;
mm_data.buf_debug_info_param.kernel_handle = handle;
// Check Length of "ccu_bufferName"
if (strlen(ccu_bufferName) < ION_MM_DBG_NAME_LEN)
count = strlen(ccu_bufferName);
else
count = ION_MM_DBG_NAME_LEN - 1;
strncpy(mm_data.buf_debug_info_param.dbg_name, ccu_bufferName, count);
mm_data.buf_debug_info_param.dbg_name[count] = '\0';
mm_data.buf_debug_info_param.value1 = 67;
mm_data.buf_debug_info_param.value2 = 97;
mm_data.buf_debug_info_param.value3 = 109;
mm_data.buf_debug_info_param.value4 = 0;
err = ion_kernel_ioctl(client, ION_CMD_MULTIMEDIA, (unsigned long)&mm_data);
if (err)
LOG_ERR("ion_kernel_ioctl(ION_MM_SET_DEBUG_INFO) returns %d, client %p",
err, client);
return 0;
}
static unsigned long get_ns_systemtime(void)
{
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 0;
getnstimeofday(&ts);
return ((unsigned long)(ts.tv_sec)) * 1000000000 + (ts.tv_nsec);
}
void ccu_ion_free_import_handle(struct ion_handle *handle)
{
if (_ccu_ion_client == NULL) {
LOG_ERR("%s: _ccu_ion_client(%d) is null!\n",
__func__, ccu_ion_init_result);
return;
}
if (handle == NULL) {
LOG_ERR("invalid ion handle!\n");
return;
}
ion_free(_ccu_ion_client, handle);
}
struct ion_handle *ccu_ion_import_handle(int fd)
{
struct ion_handle *handle = NULL;
if (_ccu_ion_client == NULL) {
LOG_ERR("%s: _ccu_ion_client(%d) is null!\n",
__func__, ccu_ion_init_result);
return handle;
}
if (fd == -1) {
LOG_ERR("ccu invalid ion fd!\n");
return handle;
}
handle = ion_import_dma_buf_fd(_ccu_ion_client, fd);
LOG_INF_MUST("ccu_ion_import_fd : %d, ccu_ion_import_handle : 0x%p\n", fd, handle);
if (IS_ERR(handle)) {
LOG_ERR("ccu import ion handle failed!\n");
return NULL;
}
return handle;
}
struct CcuMemInfo *ccu_get_binary_memory(void)
{
if (ccu_buffer_handle[0].meminfo.va != NULL)
return &ccu_buffer_handle[0].meminfo;
LOG_ERR("ccu ddr va not found!\n");
return NULL;
}
@@ -0,0 +1,47 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef _CCU_MVA_H_
#define _CCU_MVA_H_
#include "mtk_ion.h"
#include "ion_drv.h"
#include <linux/iommu.h>
#ifdef CONFIG_MTK_IOMMU
#include "mtk_iommu.h"
#include <dt-bindings/memory/mt6779-larb-port.h>
#else
#include "m4u.h"
#endif
struct CcuMemInfo {
int shareFd;
unsigned int align_mva;
unsigned int mva;
unsigned int size;
unsigned int occupiedSize;
unsigned int cached;
bool ion_log;
char *va;
};
struct CcuMemHandle {
struct ion_handle *ionHandleKd;
struct CcuMemInfo meminfo;
};
int ccu_ion_init(void);
int ccu_ion_uninit(void);
int ccu_allocate_mva(uint32_t *mva, void *va, int buffer_size);
int ccu_deallocate_mva(uint32_t mva);
struct ion_handle *ccu_ion_import_handle(int fd);
void ccu_ion_free_import_handle(struct ion_handle *handle);
int ccu_config_m4u_port(void);
int ccu_allocate_mem(struct CcuMemHandle *memHandle, int size, bool cached);
int ccu_deallocate_mem(struct CcuMemHandle *memHandle);
struct CcuMemInfo *ccu_get_binary_memory(void);
#endif
@@ -0,0 +1,51 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef _CCU_PLATFORM_DEF_
#define _CCU_PLATFORM_DEF_
/*For user/kernel space sync.*/
#define CCU_HW_OFFSET (0x0)
#define CCU_PMEM_BASE (0x1A0C0000)
#define CCU_CORE_PMEM_BASE (0x00000000)
#define CCU_PMEM_SIZE (0x20000)
#define CCU_DMEM_BASE (0x1A0A0000)
#define CCU_CORE_DMEM_BASE (0x80000000)
#define CCU_DMEM_SIZE (0x20000)
#define CCU_DMEM_OFFSET (0x0)
#define CCU_LOG_SIZE (0x800)
#define CCU_ISR_LOG_SIZE (0x400)
#define CCU_HW_DUMP_SIZE (0x550)
#define CCU_CACHE_SIZE (0xA00000)
#define CCU_CACHE_BASE (0x10000000)
#define SENSOR_RESERVED (0x100000)
#define CCU_CTRL_BUF_TOTAL_SIZE (0x1600000)
#define CCU_CPUREF_BUF_TOTAL_SIZE (0x2000000)
#define CCU_CPUREF_BUF_ALIGN_SIZE (0x1000000)
#define CCU_CPUREF_BUF_ALIGN_MASK (0xFE000000)
#define CCU_CAMSYS_BASE (0x1A000000)
#define CCU_CAMSYS_SIZE (0x1000)
#define CCU_N3D_A_BASE (0x1A040000)
#define CCU_N3D_A_SIZE (0x1000)
#define CCU_SENSOR_BIN_SIZE (0x4000)
#define CCU_LENS_BIN_SIZE (0x4000)
#define CCU_DDR_BUF_MVA_LOWER_BOUND (0x40000000)
#define CCU_DDR_BUF_MVA_UPPER_BOUND (0x44000000-1)
#define CCU_CTRL_BUFS_LOWER_BOUND (0x44000000)
#define CCU_CTRL_BUFS_UPPER_BOUND (0x48000000-1)
#define CCU_DRAM_LOG_BUF_CNT (2)
#define CCU_DRAM_LOG_BUF_SIZE (1024 * 1024) //1MB
#define OFFSET_CCU_SHARED_BUF_MAP_BASE 0 //at DCCM start
#define OFFSET_CCU_INT_TRG (0x3C/4)
#define CCU_IPC_IBUF_CAPACITY (10240) //10k
#define CCU_IPC_OBUF_CAPACITY (1024*2) //2k
#define CCU_HEADER_NUM (20)
#define CCU_STRUCT_SIZE_CAPACITY (20)
#define MMU_ENABLE_BIT 0x33//ccu Cache to EMI enable
#endif
@@ -0,0 +1,130 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include <mmdvfs_pmqos.h>
#include "smi_port.h"
#include "ccu_qos.h"
#include "ccu_cmn.h"
#include "ccu_hw.h"
#define CONFIG_MTK_QOS_SUPPORT_ENABLE
#ifdef CONFIG_MTK_QOS_SUPPORT_ENABLE
static struct plist_head ccu_request_list;
static struct mm_qos_request pccu_i_request;
static struct mm_qos_request pccu_g_request;
static struct mm_qos_request pccu_o_request;
static struct mm_qos_request ltmso_a_o_request;
static struct mm_qos_request ltmso_b_o_request;
static struct mm_qos_request ltmso_c_o_request;
static struct mm_qos_request afo_a_o_request;
static struct mm_qos_request afo_b_o_request;
static struct mm_qos_request afo_c_o_request;
#endif
static DEFINE_MUTEX(ccu_qos_mutex);
#define CCU_BW_I 60
#define CCU_BW_O 60
#define CCU_BW_G 15
#define LTMSO_BW_O 5
#define AFO_BW_O 35
void ccu_qos_init(void)
{
#ifdef CONFIG_MTK_QOS_SUPPORT_ENABLE
mutex_lock(&ccu_qos_mutex);
LOG_DBG_MUST("ccu qos init+++");
/*Initialize request list*/
plist_head_init(&ccu_request_list);
/*Add request for dram input, output and single access*/
mm_qos_add_request(&ccu_request_list, &pccu_i_request, SMI_PORT_CCUI);
mm_qos_add_request(&ccu_request_list, &pccu_g_request,
get_virtual_port(VIRTUAL_CCU_COMMON));
mm_qos_add_request(&ccu_request_list, &pccu_o_request, SMI_PORT_CCUO);
mm_qos_add_request(&ccu_request_list, &ltmso_a_o_request,
SMI_PORT_LTMSO_R1_A);
mm_qos_add_request(&ccu_request_list, &ltmso_b_o_request,
SMI_PORT_LTMSO_R1_B);
mm_qos_add_request(&ccu_request_list, &ltmso_c_o_request,
SMI_PORT_LTMSO_R1_C);
mm_qos_add_request(&ccu_request_list, &afo_a_o_request,
SMI_PORT_AFO_R1_A);
mm_qos_add_request(&ccu_request_list, &afo_b_o_request,
SMI_PORT_AFO_R1_B);
mm_qos_add_request(&ccu_request_list, &afo_c_o_request,
SMI_PORT_AFO_R1_C);
mm_qos_set_request(&pccu_i_request, CCU_BW_I, CCU_BW_I, BW_COMP_NONE);
mm_qos_set_request(&pccu_g_request, CCU_BW_G, CCU_BW_G, BW_COMP_NONE);
mm_qos_set_request(&pccu_o_request, CCU_BW_O, CCU_BW_O, BW_COMP_NONE);
mm_qos_set_request(&ltmso_a_o_request, LTMSO_BW_O, LTMSO_BW_O,
BW_COMP_NONE);
mm_qos_set_request(&ltmso_b_o_request, LTMSO_BW_O, LTMSO_BW_O,
BW_COMP_NONE);
mm_qos_set_request(&ltmso_c_o_request, LTMSO_BW_O, LTMSO_BW_O,
BW_COMP_NONE);
mm_qos_set_request(&afo_a_o_request, AFO_BW_O, AFO_BW_O,
BW_COMP_NONE);
mm_qos_set_request(&afo_b_o_request, AFO_BW_O, AFO_BW_O,
BW_COMP_NONE);
mm_qos_set_request(&afo_c_o_request, AFO_BW_O, AFO_BW_O,
BW_COMP_NONE);
mm_qos_update_all_request(&ccu_request_list);
mutex_unlock(&ccu_qos_mutex);
#endif
}
void ccu_qos_update_req(uint32_t *ccu_bw)
{
#ifdef CONFIG_MTK_QOS_SUPPORT_ENABLE
unsigned int i_request;
unsigned int g_request;
unsigned int o_request;
mutex_lock(&ccu_qos_mutex);
i_request = ccu_read_reg(ccu_base, CCU_STA_REG_QOS_BW_I);
g_request = ccu_read_reg(ccu_base, CCU_STA_REG_QOS_BW_G);
o_request = ccu_read_reg(ccu_base, CCU_STA_REG_QOS_BW_O);
if ((i_request > CCU_BW_I) ||
(o_request > CCU_BW_O) ||
(g_request > CCU_BW_G)) {
LOG_DBG_MUST("ccu qos update out+ i(%d) o(%d) g(%d)",
i_request, o_request, g_request);
i_request = CCU_BW_I;
g_request = CCU_BW_G;
o_request = CCU_BW_O;
}
LOG_DBG("ccu qos update+ i(%d) o(%d) g(%d)",
i_request, o_request, g_request);
mm_qos_set_request(&pccu_i_request, i_request, i_request, BW_COMP_NONE);
mm_qos_set_request(&pccu_g_request, g_request, g_request, BW_COMP_NONE);
mm_qos_set_request(&pccu_o_request, o_request, o_request, BW_COMP_NONE);
ccu_bw[0] = i_request;
ccu_bw[1] = o_request;
ccu_bw[2] = g_request;
if (!plist_head_empty(&ccu_request_list))
mm_qos_update_all_request(&ccu_request_list);
mutex_unlock(&ccu_qos_mutex);
#endif
}
void ccu_qos_uninit(void)
{
#ifdef CONFIG_MTK_QOS_SUPPORT_ENABLE
mutex_lock(&ccu_qos_mutex);
LOG_DBG_MUST("ccu qos uninit+");
mm_qos_update_all_request_zero(&ccu_request_list);
mm_qos_remove_all_request(&ccu_request_list);
mutex_unlock(&ccu_qos_mutex);
#endif
}
@@ -0,0 +1,14 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef _CCU_QOS_H_
#define _CCU_QOS_H_
#include "ccu_reg.h"
void ccu_qos_init(void);
void ccu_qos_update_req(uint32_t *ccu_bw);
void ccu_qos_uninit(void);
#endif
@@ -0,0 +1,11 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#include "ccu_reg.h"
/*js_test*/
#include "CCU_A_c_header.h"
struct CCU_A_REGS *g_CCU_A_BASE;
uint64_t ccu_base;
@@ -0,0 +1,60 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef _MT6799_CCU_REG_H_
#define _MT6799_CCU_REG_H_
#include <sync_write.h>
#include "ccu_sw_ver.h"
#include "CCU_A_c_header.h"
/*For CCU_A_c_header_v2*/
/*
*#define SW_VER_SPLIT 0
*#if (SW_VER_SPLIT == 1)
*#include "CCU_A_c_header_v2.h"
*#define ccu_read_reg(base, regName) \
* ((g_ccu_sw_version == CHIP_SW_VER_01) ? \
* ((PCCU_A_REGS)base)->regName.Raw : \
* ((PCCU_A_REGS_V2)base)->regName.Raw \
* )
*#define ccu_write_reg(base, regName, val) \
* do { if (g_ccu_sw_version == CHIP_SW_VER_01) { \
* ((PCCU_A_REGS)base)->regName.Raw = val; \
* } else { \
* ((PCCU_A_REGS_V2)base)->regName.Raw = val; \
* } } while (0)
*#define ccu_read_reg_bit(base, regName, fieldNmae) \
* ((g_ccu_sw_version == CHIP_SW_VER_01) ? \
* ((PCCU_A_REGS)base)->regName.Bits.fieldNmae : \
* ((PCCU_A_REGS_V2)base)->regName.Bits.fieldNmae \
* )
*#define ccu_write_reg_bit(base, regName, fieldNmae, val) \
* do { if (g_ccu_sw_version == CHIP_SW_VER_01) { \
* ((PCCU_A_REGS)base)->regName.Bits.fieldNmae = val; \
* } else { \
* ((PCCU_A_REGS_V2)base)->regName.Bits.fieldNmae = val; \
* } } while (0)
*#else
*/
/*#define ccu_read_reg(base, regName) (((struct CCU_A_REGS *)base)->regName.Raw)
*#define ccu_write_reg(base, regName, val) (((struct CCU_A_REGS *)base)->regName.Raw = val)
*/
#define ccu_read_reg_bit(base, regName, fieldNmae) \
(((struct CCU_A_REGS *)(uintptr_t)base)->regName.Bits.fieldNmae)
#define ccu_write_reg_bit(base, regName, fieldNmae, val) \
(((struct CCU_A_REGS *)(uintptr_t)base)->regName.Bits.fieldNmae = val)
#define ccu_read_reg(base, regName) readl(&(((struct CCU_A_REGS *)(uintptr_t)base)->regName))
#define ccu_write_reg(base, regName, val) writel(val, &(((struct CCU_A_REGS *)(uintptr_t)base)->regName))
/*#endif*/
#define CCU_SET_BIT(reg, bit) ((*(unsigned int *)(reg)) |= (unsigned int)(1 << (bit)))
#define CCU_CLR_BIT(reg, bit) ((*(unsigned int *)(reg)) &= ~((unsigned int)(1 << (bit))))
extern uint64_t ccu_base;
#endif
@@ -0,0 +1,27 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifdef CONFIG_MTK_CHIP
#include <linux/kernel.h>
#include "ccu_cmn.h"
#include "ccu_sw_ver.h"
enum chip_sw_ver g_ccu_sw_version = -1;
int init_check_sw_ver(void)
{
g_ccu_sw_version = mt_get_chip_sw_ver();
if ((g_ccu_sw_version != CHIP_SW_VER_02) && (g_ccu_sw_version == CHIP_SW_VER_01)) {
LOG_ERR("have a wrong software version:%x!\n", g_ccu_sw_version);
return -EINVAL;
}
return 0;
}
#endif
@@ -0,0 +1,19 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifdef CONFIG_MTK_CHIP
#ifndef _CCU_SW_VER_H_
#define _CCU_SW_VER_H_
#include <mt-plat/mtk_chip.h>
extern enum chip_sw_ver g_ccu_sw_version;
int init_check_sw_ver(void);
#endif
#endif
@@ -0,0 +1,13 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2016 MediaTek Inc.
*/
#ifndef __COMMON_H__
#define __COMMON_H__
#define UINT8 unsigned char
#define UINT16 unsigned short
#define UINT32 unsigned int
#endif /* __COMMON_H__*/
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,37 @@
#
# Copyright (C) 2016 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.
#
#ion
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion \
-I$(srctree)/drivers/staging/android/mtk_ion/mtk \
-I$(srctree)/drivers/iommu/
#for sensorType in ccu_set_sensor_info
ccflags-y += -I$(srctree)/drivers/misc/mediatek/imgsensor/inc
#
ccflags-y += -I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mach/$(MTK_PLATFORM)/include/mach
ccflags-y += -I$(srctree)/drivers/misc/mediatek/irq/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(MTK_PLATFORM)/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mmp/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/2.0
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/inc/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccu/src/$(MTK_PLATFORM)/ccu_ext_interface/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/smi/mt6785/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mmdvfs/
ccflags-y += -I$(srctree)/drivers/i2c/busses/
#obj-$(CONFIG_MTK_VPU) += ccu_hw.o
obj-y += ccu_hw.o ccu_reg.o ccu_kd_mailbox.o ccu_i2c_hw.o ccu_sw_ver.o ccu_imgsensor.o ccu_mva.o ccu_qos.o ccu_ipc.o
@@ -0,0 +1,12 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CCU_H__
#define __CCU_H__
#include "../1.0/ccu_drv.h"
#endif
@@ -0,0 +1,208 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CCU_INTERFACE__
#define __CCU_INTERFACE__
#include "ccu_ext_interface/ccu_types.h"
extern MBOOL sec_vsync_pushed;
/*****************************************************************************/
/* Task definition */
/*****************************************************************************/
enum ccu_msg_id {
/*Receive by CCU*/
/*CCU Task*/
MSG_TO_CCU_IDLE = 0x00000000,
MSG_TO_CCU_SENSOR_INIT,
MSG_TO_CCU_AE_INIT,
MSG_TO_CCU_AE_START,
MSG_TO_CCU_AE_STOP,
MSG_TO_CCU_SET_AP_AE_FRAME_SYNC_DATA,
MSG_TO_CCU_SET_AP_AE_ONCHANGE_DATA,
MSG_TO_CCU_GET_CCU_OUTPUT,
MSG_TO_CCU_SET_MAX_FRAMERATE,
MSG_TO_CCU_GET_AE_DEBUG_INFO,
MSG_TO_CCU_SET_3A_SYNC_STATE,
MSG_TO_CCU_SYNC_AE_SETTING,
MSG_TO_CCU_START_FRAME_SYNC,
MSG_TO_CCU_STOP_FRAME_SYNC,
MSG_TO_CCU_QUERY_FRAME_SYNC_DONE,
MSG_TO_CCU_SUSPEND,
MSG_TO_CCU_RESUME,
MSG_TO_CCU_SHUTDOWN,
// for new framesync
MSG_TO_CCU_FRAME_SYNC_SET_SENSOR_INFO,
MSG_TO_CCU_FRAME_SYNC_SET_AE_INFO,
MSG_TO_CCU_FS_START_FRAME_SYNC,
MSG_TO_CCU_FS_STOP_FRAME_SYNC,
MSG_TO_CCU_FS_QUERY_FRAME_SYNC_DONE,
MSG_TO_CCU_FRAME_SYNC_PERFRAME_CTRL,
MSG_TO_CCU_UPDATE_TG_SENSOR_MAP,
MSG_TO_CCU_INVALIDATE_TG_SENSOR_MAP,
#ifdef CCU_AF_ENABLE
MSG_TO_CCU_AF_INIT,
MSG_TO_CCU_AF_START,
MSG_TO_CCU_AF_ALGO_DONE,
MSG_TO_CCU_AF_ACQUIRE_AFO_BUFFER,
MSG_TO_CCU_AF_SET_HW_REG,
MSG_TO_CCU_AF_STOP,
MSG_TO_CCU_AF_ABORT,
#endif /*CCU_AF_ENABLE*/
/*To identify ccu control msg count*/
DELIMITER_CCU_CONTROL_CNT_1,
/*CCU internal task*/
#ifdef CCU_AF_ENABLE
MSG_TO_CCU_AF_CQ0,
MSG_TO_CCU_AF_AFO,
MSG_TO_CCU_AF_CQ0B,
MSG_TO_CCU_AF_AFOB,
#endif /*CCU_AF_ENABLE*/
MSG_CCU_INTERNAL_BANK_AE_ALGO,
MSG_CCU_INTERNAL_FRAME_AE_ALGO,
MSG_CCU_INTERNAL_VSYNC_AE_SYNC,
MSG_CCU_INTERNAL_FRAME_SYNC,
MSG_CCU_INTERNAL_PR_LOG,
/*To identify ccu control msg count*/
DELIMITER_CCU_CONTROL_CNT_2,
/*Send to APMCU*/
/*CCU Ack/Done*/
/**< Ack cmd for #MSG_TO_CCU_SENSOR_INIT */
MSG_CCU_DONE_SENSOR_INIT,
/**< Ack cmd for #MSG_TO_CCU_AE_INIT */
MSG_CCU_DONE_AE_INIT,
/**< Ack cmd for #MSG_TO_CCU_AE_START */
MSG_CCU_ACK_AE_START,
/**< Ack cmd for #MSG_TO_CCU_AE_STOP */
MSG_CCU_ACK_AE_STOP,
/**< Ack cmd for #MSG_TO_CCU_SET_AP_AE_FRAME_SYNC_DATA */
MSG_CCU_ACK_SET_AP_AE_FRAME_SYNC_DATA,
/**< Ack cmd for #MSG_TO_CCU_SET_AP_AE_ONCHANGE_DATA */
MSG_CCU_ACK_SET_AP_AE_ONCHANGE_DATA,
/**< Ack cmd for #MSG_TO_CCU_GET_CCU_OUTPUT */
MSG_CCU_ACK_GET_CCU_OUTPUT,
/**< Ack cmd for #MSG_TO_CCU_SET_MAX_FRAMERATE */
MSG_CCU_ACK_SET_MAX_FRAMERATE,
/**< Ack cmd for #MSG_TO_CCU_GET_AE_DEBUG_INFO */
MSG_CCU_ACK_GET_AE_DEBUG_INFO,
/**< Ack cmd for #MSG_TO_CCU_SET_3A_SYNC_STATE */
MSG_CCU_ACK_SET_3A_SYNC_STATE,
/**< Ack cmd for #MSG_TO_CCU_SYNC_AE_SETTING */
MSG_CCU_ACK_SYNC_AE_SETTING,
MSG_CCU_ACK_START_FRAME_SYNC,
MSG_CCU_ACK_STOP_FRAME_SYNC,
MSG_CCU_ACK_QUERY_FRAME_SYNC_DONE,
/**< Ack cmd for #MSG_TO_CCU_SUSPEND */
MSG_CCU_ACK_SUSPEND,
/**< Ack cmd for #MSG_TO_CCU_RESUME */
MSG_CCU_ACK_RESUME,
/**< Ack cmd for #MSG_TO_CCU_SHUTDOWN */
MSG_CCU_DONE_SHUTDOWN,
#ifdef CCU_AF_ENABLE
MSG_CCU_ACK_AF_INIT,
MSG_CCU_ACK_AF_START,
MSG_CCU_ACK_AF_ALGO_DONE,
MSG_CCU_ACK_AF_ACQUIRE_AFO_BUFFER,
MSG_CCU_ACK_AF_SET_HW_REG,
MSG_CCU_ACK_AF_STOP,
MSG_CCU_ACK_AF_ABORT,
#endif /*CCU_AF_ENABLE*/
/*APMCU Task*/
MSG_TO_APMCU_FLUSH_LOG,
MSG_TO_APMCU_CCU_ASSERT,
MSG_TO_APMCU_CCU_WARNING
#ifdef CCU_AF_ENABLE
, MSG_TO_APMCU_CAM_A_AFO_i,
MSG_TO_APMCU_CAM_B_AFO_i
#endif /*CCU_AF_ENABLE*/
};
enum ccu_tg_info {
CCU_CAM_TG_NONE = 0x0,
CCU_CAM_TG_MIN = 0x1,
CCU_CAM_TG_1 = 0x1,
CCU_CAM_TG_2 = 0x2,
CCU_CAM_TG_MAX
};
#define CCU_CAM_TG_CNT (CCU_CAM_TG_MAX - CCU_CAM_TG_MIN)
struct ccu_msg { /*16bytes*/
enum ccu_msg_id msg_id;
MUINT32 in_data_ptr;
MUINT32 out_data_ptr;
enum ccu_tg_info tg_info;
};
struct ccu_control_info {
enum ccu_tg_info tg_info; //new
uint32_t msg_id;
uint64_t inDataPtr;
uint32_t inDataSize;
uint64_t outDataPtr;
uint32_t outDataSize;
};
struct ap2ccu_ipc_t {
MUINT32 write_cnt;
MUINT32 read_cnt;
struct ccu_msg msg;
MBOOL ack;
};
struct exif_data_addrs_s {
MUINT32 ae_algo_data_addr;
MUINT32 ae_init_data_addr;
MUINT32 ae_vsync_info_addr;
MUINT32 aesync_algo_in_addr;
MUINT32 aesync_algo_out_addr;
};
struct shared_buf_map {
MUINT32 ipc_in_data_addr_ccu;
MUINT32 ipc_out_data_addr_ccu;
MUINT32 ipc_in_data_base_offset;
MUINT32 ipc_out_data_base_offset;
MUINT32 ipc_base_offset;
struct exif_data_addrs_s exif_data_addrs[CCU_CAM_TG_CNT];
};
/*****************************************************************************/
/* Special isr task (execute in isr) */
/*****************************************************************************/
#define ISR_SP_TASK_SHUTDOWN 0x000000FF
#define ISR_SP_TASK_TRG_I2C_DONE 0x000000C1
#define ISR_SP_TASK_RST_I2C_DONE 0x000000B9
/*****************************************************************************/
/* Special ap isr task (execute in apmcu_isr) */
/*****************************************************************************/
#define APISR_SP_TASK_TRIGGER_I2C 0x000000A1
#define APISR_SP_TASK_RESET_I2C 0x000000A2
/*****************************************************************************/
/* Error code definition */
/*****************************************************************************/
#define CCU_ERROR_NO (0)
#define CCU_ERROR_QUEUE_FULL (1)
/*****************************************************************************/
/* Status definition */
/*****************************************************************************/
#define CCU_STATUS_INIT_DONE 0xffff0000
#define CCU_STATUS_INIT_DONE_2 0xffff00a5
/*****************************************************************************/
/* Direct-link source definition */
/*****************************************************************************/
#define AE_STREAM_DL_SRC_AAO 0x00000000
#define AE_STREAM_DL_SRC_PSO 0x00000001
#endif
@@ -0,0 +1,42 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
/*
* Module: CCU mailbox external interface
*
* Description:
* External interface for both CCU/APMCU side reference,
* Develop an unified data structure
* and circular queue full/empty definition
*/
#ifndef __CCU_MAILBOX_EXTIF__
#define __CCU_MAILBOX_EXTIF__
#include "ccu_ext_interface/ccu_ext_interface.h"
/*must be power of 2 for modulo operation take work*/
#define CCU_MAILBOX_QUEUE_SIZE 8
/*
* Mailbox is a circular queue
* Composed of 2 pointer front/rear, and a buffer of struct ccu_msg
*
*!!! Implement mailbox operation with following rules !!!
* - Initial queue with front=rear=0
* - Dequeue with read queue[front+1] and
* - increase front pointer by 1 (modulus add)
* - Enqueue with write into queue[rear+1] and
* - increase rear pointer by 1 (modulus add)
* - Queue is full when front=rear+1
* - (modulus add: rear+1 = rear+1 % CCU_MAILBOX_QUEUE_SIZE)
* - Queue is empty when front=rear
*/
struct ccu_mailbox_t {
MUINT32 front;
MUINT32 rear;
struct ccu_msg queue[CCU_MAILBOX_QUEUE_SIZE];
};
#endif
@@ -0,0 +1,66 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef CCU_TYPES_H
#define CCU_TYPES_H
/*****************************************************************************/
/* typedef unsigned char BOOLEAN; // uint8_t*/
#define MUINT8 unsigned char
#define MUINT16 unsigned short
#define MUINT32 unsigned int
/*typedef unsigned long MUINT64;*/
/**/
#define MINT8 signed char
#define MINT16 signed short
#define MINT32 signed int
/*typedef signed long MINT64;*/
/**/
#define MFLOAT float
#define MDOUBLE double
/**/
#define MVOID void
#define MBOOL int
#ifndef MTRUE
#define MTRUE 1
#endif
#ifndef MFALSE
#define MFALSE 0
#endif
#ifndef MNULL
#define MNULL 0
#endif
/*****************************************************************************/
/* Sensor Types */
/*****************************************************************************/
/* #define CCU_CODE_SLIM*/
/* typedef unsigned char BOOLEAN; // uint8_t*/
#define U8 unsigned char /* uint8_t*/
#define U16 unsigned short /* uint16_t*/
#define U32 unsigned int /* uint32_t*/
/*typedef unsigned long long U64; // uint64_t*/
#define I8 char /* int8_t*/
#define I16 short /* int16_t*/
#define I32 int /* int32_t*/
/*typedef long long I64; // int64_t*/
#ifndef NULL
#define NULL 0
#endif /* NULL*/
/*****************************************************************************/
/* Error code */
/*****************************************************************************/
#define ERR_NONE (0)
#define ERR_INVALID (-1)
#define ERR_TIMEOUT (-2)
#endif /* CCU_TYPES_H*/
File diff suppressed because it is too large. Load diff
Loaded 100 of 80519 files, more files were not shown because too many files have changed in this diff. Show more