threeeye/android
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
bc1d038eac5003cdc9cab2c363a88dbbc9bebe92
android/drivers/gpu/drm/mediatek/mtk_fbconfig_kdebug.c
T
threeeye bc1d038eac REVVL 6 Pro kernel bring-up: full working tree snapshot (2026-09-12) 
Squashed backup commit (no shallow-clone history issues) of
xiaomi-mt6833-dev/kernel_xiaomi_mt6833 (lineage-23.2 branch, upstream
commit 9eece662e) plus all fixes applied to get everpal_defconfig building
clean against a modern (GCC 15.2.0) toolchain -- see the previous commit
message on the lineage-23.2 branch (also in this repo history is not
available here since this is a squashed snapshot; full incremental history
lives in the local DL380 checkout and the upstream GitHub remote).

Upstream: https://github.com/xiaomi-mt6833-dev/kernel_xiaomi_mt6833 (lineage-23.2)
2026-09-12 13:36:46 +00:00

471 lines
11 KiB
C
Raw Blame History

/*
* 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.
*/
#include <linux/string.h>
#include <linux/time.h>
#include <linux/uaccess.h>
#include <linux/fb.h>
#include <linux/vmalloc.h>
#include <linux/sched.h>
#include <linux/debugfs.h>
#include <linux/wait.h>
#include <linux/types.h>
#include "mtk_fbconfig_kdebug.h"
#include "mtk_mipi_tx.h"
#include "mtk_drm_crtc.h"
#include "mtk_panel_ext.h"
#include "mtk_drm_drv.h"
#include "mtk_drm_ddp_comp.h"
/* ************************************************************************* */
/* This part is for customization parameters of D-IC and DSI . */
/* ************************************************************************* */
#define FBCONFIG_KEEP_NEW_SETTING 1
#define FBCONFIG_DEBUG 0
#define FBCONFIG_IOW(num, dtype) _IOW('X', num, dtype)
#define FBCONFIG_IOR(num, dtype) _IOR('X', num, dtype)
#define FBCONFIG_IOWR(num, dtype) _IOWR('X', num, dtype)
#define FBCONFIG_IO(num) _IO('X', num)
#define GET_DSI_ID FBCONFIG_IOW(43, unsigned int)
#define SET_DSI_ID FBCONFIG_IOW(44, unsigned int)
#define LCM_GET_ID FBCONFIG_IOR(45, unsigned int)
#define LCM_GET_ESD FBCONFIG_IOWR(46, unsigned int)
#define DRIVER_IC_CONFIG FBCONFIG_IOR(47, unsigned int)
#define DRIVER_IC_CONFIG_DONE FBCONFIG_IO(0)
#define DRIVER_IC_RESET FBCONFIG_IOR(48, unsigned int)
#define MIPI_SET_CLK FBCONFIG_IOW(51, unsigned int)
#define MIPI_SET_LANE FBCONFIG_IOW(52, unsigned int)
#define MIPI_SET_TIMING FBCONFIG_IOW(53, unsigned int)
/* mipi video mode timing setting */
#define MIPI_SET_VM FBCONFIG_IOW(54, unsigned int)
/* mipi non-continuous clock */
#define MIPI_SET_CC FBCONFIG_IOW(55, unsigned int)
/* spread frequency */
#define MIPI_SET_SSC FBCONFIG_IOW(56, unsigned int)
/* For div1,div2,fbk_div case */
#define MIPI_SET_CLK_V2 FBCONFIG_IOW(57, unsigned int)
#define TE_SET_ENABLE FBCONFIG_IOW(61, unsigned int)
#define FB_LAYER_DUMP FBCONFIG_IOW(62, unsigned int)
#define FB_LAYER_GET_INFO FBCONFIG_IOW(63, unsigned int)
#define FB_LAYER_GET_EN FBCONFIG_IOW(64, unsigned int)
#define LCM_GET_ESD_RET FBCONFIG_IOR(65, unsigned int)
#define LCM_GET_DSI_CONTINU FBCONFIG_IOR(71, unsigned int)
#define LCM_GET_DSI_CLK FBCONFIG_IOR(72, unsigned int)
#define LCM_GET_DSI_TIMING FBCONFIG_IOR(73, unsigned int)
#define LCM_GET_DSI_LANE_NUM FBCONFIG_IOR(74, unsigned int)
#define LCM_GET_DSI_TE FBCONFIG_IOR(75, unsigned int)
#define LCM_GET_DSI_SSC FBCONFIG_IOR(76, unsigned int)
#define LCM_GET_DSI_CLK_V2 FBCONFIG_IOR(77, unsigned int)
#define LCM_TEST_DSI_CLK FBCONFIG_IOR(78, unsigned int)
#define FB_GET_MISC FBCONFIG_IOR(80, unsigned int)
#ifdef UFMT_GET_bpp
#define DP_COLOR_BITS_PER_PIXEL(color) UFMT_GET_bpp(color)
#else
#define DP_COLOR_BITS_PER_PIXEL(color) ((0x0003FF00 & color) >> 8)
#endif
struct dentry *ConfigPara_dbgfs;
struct CONFIG_RECORD_LIST head_list;
struct LCM_REG_READ reg_read;
struct drm_device *drm_dev;
struct drm_crtc *crtc;
struct mtk_drm_crtc *mtk_crtc;
struct mtk_ddp_comp *output_comp;
struct PM_TOOL_S {
enum DSI_INDEX dsi_id;
struct LCM_REG_READ reg_read;
struct mtk_panel_params *pMtk_panel_params;
};
static struct PM_TOOL_S pm_params = {
.dsi_id = PM_DSI0,
.pMtk_panel_params = NULL,
};
static void *pm_get_handle(void)
{
return (void *)&pm_params;
}
static int fbconfig_open(struct inode *inode, struct file *file)
{
struct PM_TOOL_S *pm_params = NULL;
file->private_data = inode->i_private;
pm_params = (struct PM_TOOL_S *) pm_get_handle();
if (pm_params == NULL)
return -EFAULT;
crtc = list_first_entry(&(drm_dev)->mode_config.crtc_list,
typeof(*crtc), head);
if (!crtc) {
DDPPR_ERR("find crtc fail\n");
return -EFAULT;
}
mtk_crtc = to_mtk_crtc(crtc);
if (!(crtc->enabled) || mtk_crtc->ddp_mode == DDP_NO_USE)
return -EFAULT;
output_comp = mtk_ddp_comp_request_output(mtk_crtc);
if (!output_comp)
return -EFAULT;
pm_params->pMtk_panel_params = mtk_drm_get_lcm_ext_params(crtc);
switch (output_comp->id) {
case DDP_COMPONENT_DSI0:
{
pm_params->dsi_id = PM_DSI0;
break;
}
case DDP_COMPONENT_DSI1:
{
pm_params->dsi_id = PM_DSI1;
break;
}
default:
break;
}
return 0;
}
static char fbconfig_buffer[2048];
static ssize_t fbconfig_read(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
const int debug_bufmax = sizeof(fbconfig_buffer) - 1; /* 2047 */
int n = 0;
n += scnprintf(fbconfig_buffer + n, debug_bufmax - n, "sxkhome");
fbconfig_buffer[n++] = 0;
/* n = 5 ; */
/* memcpy(fbconfig_buffer,"sxkhome",6); */
return simple_read_from_buffer(ubuf, count, ppos, fbconfig_buffer, n);
}
static ssize_t fbconfig_write(struct file *file,
const char __user *ubuf, size_t count, loff_t *ppos)
{
return 0;
}
static long fbconfig_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
int ret = 0;
void __user *argp = (void __user *)arg;
struct PM_TOOL_S *pm = (struct PM_TOOL_S *) pm_get_handle();
uint32_t dsi_id = pm->dsi_id;
if (!(crtc->state->active))
return -EFAULT;
#ifdef FBCONFIG_SHOULD_KICK_IDLEMGR
mtk_drm_idlemgr_kick(__func__, crtc, 1);
#endif
switch (cmd) {
case GET_DSI_ID:
{
put_user(dsi_id, (unsigned long *)argp);
return 0;
}
case SET_DSI_ID:
{
if (arg > PM_DSI1)
return -EINVAL;
pm->dsi_id = arg;
pr_debug("fbconfig=>SET_DSI_ID:%d\n", dsi_id);
return 0;
}
case LCM_TEST_DSI_CLK:
{
struct LCM_TYPE_FB lcm_fb;
lcm_fb.clock = pm->pMtk_panel_params->pll_clk;
lcm_fb.lcm_type = fbconfig_mtk_dsi_get_mode_type(output_comp);
pr_debug("fbconfig=>LCM_TEST_DSI_CLK:%d\n", ret);
return copy_to_user(argp, &lcm_fb,
sizeof(lcm_fb)) ? -EFAULT : 0;
}
case LCM_GET_ID:
{
/* not support anymore */
return 0;
}
case DRIVER_IC_CONFIG:
{
/* not support anymore */
return 0;
}
case DRIVER_IC_CONFIG_DONE:
{
/* not support anymore */
return 0;
}
case MIPI_SET_CC:
{
uint32_t enable = 0;
if (get_user(enable, (uint32_t __user *) argp)) {
pr_debug("[MIPI_SET_CC]: copy_from_user failed! line:%d\n",
__LINE__);
return -EFAULT;
}
if (enable > 1)
return -EFAULT;
Panel_Master_mipi_set_cc_entry(crtc, enable);
return 0;
}
case LCM_GET_DSI_CONTINU:
{
uint32_t ret = Panel_Master_mipi_get_cc_entry(crtc);
/*need to improve ,0 now means nothing but one parameter. */
pr_debug("LCM_GET_DSI_CONTINU=>DSI: %d\n", ret);
return put_user(ret, (unsigned long *)argp);
}
case MIPI_SET_CLK:
{
uint32_t clk = 0;
if (get_user(clk, (uint32_t __user *) argp)) {
pr_debug("[MIPI_SET_CLK]: copy_from_user failed! line:%d\n",
__LINE__);
return -EFAULT;
}
pr_debug("LCM_GET_DSI_CLK=>dsi:%d\n", clk);
Panel_Master_dsi_config_entry(crtc, "PM_CLK", clk);
return 0;
}
case LCM_GET_DSI_CLK:
{
uint32_t clk = pm->pMtk_panel_params->pll_clk;
pr_debug("LCM_GET_DSI_CLK=>dsi:%d\n", clk);
return put_user(clk, (unsigned long *)argp);
}
case MIPI_SET_SSC:
{
struct DSI_RET dsi_ssc;
if (copy_from_user(&dsi_ssc, (void __user *)argp,
sizeof(dsi_ssc))) {
pr_debug("[MIPI_SET_SSC]: copy_from_user failed! line:%d\n",
__LINE__);
return -EFAULT;
}
pr_debug("Pmaster:set mipi ssc line:%d\n", __LINE__);
/* not support ssc in drm */
/* Panel_Master_dsi_config_entry(crtc, "PM_SSC", dsi_ssc); */
return 0;
}
case LCM_GET_DSI_SSC:
{
/* but drm framework not support ssc anymore */
uint32_t ssc = pm->pMtk_panel_params->ssc_range;
if (pm->pMtk_panel_params->ssc_disable)
ssc = 0;
return put_user(ssc, (unsigned long *)argp);
}
case LCM_GET_DSI_LANE_NUM:
{
uint32_t lanes_num;
lanes_num = fbconfig_mtk_dsi_get_lanes_num(output_comp);
pr_debug("Panel Master=>LCM_GET_DSI_Lane_num=>dsi:%d\r\n",
lanes_num);
return put_user(lanes_num, (unsigned long *)argp);
}
case LCM_GET_DSI_TE:
{
/* not support anymore */
return 0;
}
case LCM_GET_DSI_TIMING:
{
uint32_t ret;
struct MIPI_TIMING timing;
if (copy_from_user(&timing, (void __user *)argp,
sizeof(timing))) {
pr_debug("[MIPI_GET_TIMING]: copy_from_user failed! line:%d\n",
__LINE__);
return -EFAULT;
}
ret = Panel_Master_lcm_get_dsi_timing_entry(crtc, timing.type);
pr_debug("fbconfig=>LCM_GET_DSI_TIMING:%d\n", ret);
timing.value = ret;
return copy_to_user(argp,
&timing, sizeof(timing)) ? -EFAULT : 0;
}
case MIPI_SET_TIMING:
{
struct MIPI_TIMING timing;
int ret = 0;
if (!(crtc->state->active))
return -EFAULT;
if (copy_from_user(&timing, (void __user *)argp,
sizeof(timing))) {
pr_debug("[MIPI_SET_TIMING]: copy_from_user failed! line:%d\n",
__LINE__);
return -EFAULT;
}
ret = Panel_Master_mipi_set_timing_entry(crtc, timing);
return ret;
}
case FB_LAYER_GET_EN:
{
pr_debug("[FB_LAYER_GET_EN] not support any more\n");
return 0;
}
case FB_LAYER_GET_INFO:
{
pr_debug("[FB_LAYER_GET_INFO] not support any more\n");
return 0;
}
case FB_LAYER_DUMP:
{
pr_debug("[FB_LAYER_DUMP] not support any more\n");
return 0;
}
case LCM_GET_ESD:
{
struct ESD_PARA esd_para;
uint8_t *buffer;
if (copy_from_user(&esd_para, (void __user *)arg,
sizeof(esd_para))) {
pr_debug("[LCM_GET_ESD]: copy_from_user failed! line:%d\n",
__LINE__);
return -EFAULT;
}
if (esd_para.para_num < 0 || esd_para.para_num > 0x30) {
pr_debug(
"[LCM_GET_ESD]: wrong esd_para.para_num= %d! line:%d\n",
esd_para.para_num, __LINE__);
return -EFAULT;
}
buffer = kzalloc(esd_para.para_num + 6, GFP_KERNEL);
if (!buffer)
return -ENOMEM;
ret = fbconfig_get_esd_check_test(crtc, esd_para.addr,
buffer, esd_para.para_num);
if (ret < 0) {
kfree(buffer);
return -EFAULT;
}
ret = copy_to_user(esd_para.esd_ret_buffer,
buffer, esd_para.para_num);
kfree(buffer);
return ret;
}
case TE_SET_ENABLE:
{
return 0;
}
case DRIVER_IC_RESET:
{
Panel_Master_dsi_config_entry(crtc, "PM_DRIVER_IC_RESET", 0);
return 0;
}
case FB_GET_MISC:
{
/* not support anymore */
return 0;
}
default:
return ret;
}
}
static int fbconfig_release(struct inode *inode, struct file *file)
{
return 0;
}
static const struct file_operations fbconfig_fops = {
.read = fbconfig_read,
.write = fbconfig_write,
.open = fbconfig_open,
.unlocked_ioctl = fbconfig_ioctl,
/*
* #ifdef CONFIG_COMPAT
* waiting to designed
* .compat_ioctl = compat_fbconfig_ioctl,
* #endif
*/
.release = fbconfig_release,
};
void PanelMaster_probe(void)
{
ConfigPara_dbgfs = debugfs_create_file("fbconfig", S_IFREG | 0444,
NULL, (void *)0, &fbconfig_fops);
INIT_LIST_HEAD(&head_list.list);
}
void PanelMaster_Init(struct drm_device *dev)
{
drm_dev = dev;
}
void PanelMaster_Deinit(void)
{
debugfs_remove(ConfigPara_dbgfs);
}
Reference in new issue View Git Blame Copy Permalink