forked from rrcarlosr/Jetpack
669 lines
16 KiB
C
669 lines
16 KiB
C
/*
|
|
* mods_debugfs.c - This file is part of NVIDIA MODS kernel driver.
|
|
*
|
|
* Copyright (c) 2014-2018, NVIDIA CORPORATION. All rights reserved.
|
|
*
|
|
* NVIDIA MODS kernel driver 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.
|
|
*
|
|
* NVIDIA MODS kernel driver 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.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with NVIDIA MODS kernel driver.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "mods_internal.h"
|
|
|
|
#ifdef MODS_HAS_DEBUGFS
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/miscdevice.h>
|
|
#include <linux/device.h>
|
|
#include <linux/uaccess.h>
|
|
|
|
static struct dentry *mods_debugfs_dir;
|
|
|
|
#if defined(MODS_TEGRA) && defined(MODS_HAS_KFUSE)
|
|
#include <soc/tegra/kfuse.h>
|
|
#endif
|
|
|
|
#ifdef CONFIG_TEGRA_DC
|
|
#include <video/tegra_dc_ext_kernel.h>
|
|
#include <../drivers/video/tegra/dc/dc_config.h>
|
|
#include <../drivers/video/tegra/dc/dsi.h>
|
|
|
|
static int mods_dc_color_formats_show(struct seq_file *s, void *unused)
|
|
{
|
|
struct tegra_dc *dc = s->private;
|
|
u32 i, j;
|
|
|
|
for (i = 0; i < tegra_dc_get_numof_dispwindows(); i++) {
|
|
struct tegra_dc_win *win;
|
|
u32 *fmt_masks;
|
|
|
|
win = tegra_dc_get_window(dc, i);
|
|
if (!win)
|
|
continue;
|
|
fmt_masks = tegra_dc_parse_feature(dc, i, GET_WIN_FORMATS);
|
|
if (!fmt_masks)
|
|
continue;
|
|
seq_printf(s, "window_%u:", i);
|
|
for (j = 0; j < WIN_FEATURE_ENTRY_SIZE; j++)
|
|
seq_printf(s, " 0x%08x", fmt_masks[j]);
|
|
seq_puts(s, "\n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int mods_dc_color_formats_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, mods_dc_color_formats_show, inode->i_private);
|
|
}
|
|
|
|
static const struct file_operations mods_dc_color_formats_fops = {
|
|
.open = mods_dc_color_formats_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static int mods_dc_blend_gen_show(struct seq_file *s, void *unused)
|
|
{
|
|
struct tegra_dc *dc = s->private;
|
|
u32 i;
|
|
|
|
for (i = 0; i < tegra_dc_get_numof_dispwindows(); i++) {
|
|
struct tegra_dc_win *win;
|
|
u32 *blend_gen;
|
|
|
|
win = tegra_dc_get_window(dc, i);
|
|
if (!win)
|
|
continue;
|
|
blend_gen = tegra_dc_parse_feature(dc, i, HAS_GEN2_BLEND);
|
|
if (!blend_gen)
|
|
continue;
|
|
seq_printf(s, "window_%u: %u\n", i,
|
|
blend_gen[BLEND_GENERATION]);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int mods_dc_blend_gen_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, mods_dc_blend_gen_show, inode->i_private);
|
|
}
|
|
|
|
static const struct file_operations mods_dc_blend_gen_fops = {
|
|
.open = mods_dc_blend_gen_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static int mods_dc_layout_show(struct seq_file *s, void *unused)
|
|
{
|
|
struct tegra_dc *dc = s->private;
|
|
u32 i;
|
|
|
|
seq_puts(s, " Pitch Tiled Block\n");
|
|
for (i = 0; i < tegra_dc_get_numof_dispwindows(); i++) {
|
|
struct tegra_dc_win *win;
|
|
u32 *layouts;
|
|
|
|
win = tegra_dc_get_window(dc, i);
|
|
if (!win)
|
|
continue;
|
|
layouts = tegra_dc_parse_feature(dc, i, HAS_TILED);
|
|
if (!layouts)
|
|
continue;
|
|
seq_printf(s, "window_%u: %5u %5u %5u\n", i,
|
|
layouts[PITCHED_LAYOUT],
|
|
layouts[TILED_LAYOUT],
|
|
layouts[BLOCK_LINEAR]);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int mods_dc_layout_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, mods_dc_layout_show, inode->i_private);
|
|
}
|
|
|
|
static const struct file_operations mods_dc_layout_fops = {
|
|
.open = mods_dc_layout_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static int mods_dc_invert_show(struct seq_file *s, void *unused)
|
|
{
|
|
struct tegra_dc *dc = s->private;
|
|
u32 i;
|
|
|
|
seq_puts(s, " FlipH FlipV ScanColumn\n");
|
|
for (i = 0; i < tegra_dc_get_numof_dispwindows(); i++) {
|
|
struct tegra_dc_win *win;
|
|
u32 *invert_data;
|
|
|
|
win = tegra_dc_get_window(dc, i);
|
|
if (!win)
|
|
continue;
|
|
invert_data = tegra_dc_parse_feature(dc, i, GET_INVERT);
|
|
if (!invert_data)
|
|
continue;
|
|
seq_printf(s, "window_%u: %5u %5u %10u\n", i,
|
|
invert_data[H_INVERT],
|
|
invert_data[V_INVERT],
|
|
invert_data[SCAN_COLUMN]);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int mods_dc_invert_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, mods_dc_invert_show, inode->i_private);
|
|
}
|
|
|
|
static const struct file_operations mods_dc_invert_fops = {
|
|
.open = mods_dc_invert_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static int mods_dc_interlaced_show(struct seq_file *s, void *unused)
|
|
{
|
|
struct tegra_dc *dc = s->private;
|
|
u32 i;
|
|
const unsigned int head_interlaced = 1;
|
|
|
|
seq_printf(s, "head: %u\n", head_interlaced);
|
|
for (i = 0; i < tegra_dc_get_numof_dispwindows(); i++) {
|
|
struct tegra_dc_win *win;
|
|
u32 *interlaced;
|
|
|
|
win = tegra_dc_get_window(dc, i);
|
|
|
|
if (!win)
|
|
continue;
|
|
interlaced = tegra_dc_parse_feature(dc, i, HAS_INTERLACE);
|
|
if (!interlaced)
|
|
continue;
|
|
seq_printf(s, "window_%u: %u\n", i, interlaced[0]);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int mods_dc_interlaced_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, mods_dc_interlaced_show, inode->i_private);
|
|
}
|
|
|
|
static const struct file_operations mods_dc_interlaced_fops = {
|
|
.open = mods_dc_interlaced_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static int mods_dc_window_mask_show(struct seq_file *s, void *unused)
|
|
{
|
|
struct tegra_dc *dc = s->private;
|
|
|
|
seq_printf(s, "0x%02lx\n", dc->valid_windows);
|
|
return 0;
|
|
}
|
|
|
|
static int mods_dc_window_mask_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, mods_dc_window_mask_show, inode->i_private);
|
|
}
|
|
|
|
static const struct file_operations mods_dc_window_mask_fops = {
|
|
.open = mods_dc_window_mask_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static int mods_dc_scaling_show(struct seq_file *s, void *unused)
|
|
{
|
|
struct tegra_dc *dc = s->private;
|
|
u32 i;
|
|
|
|
seq_puts(s, " UpH UpV DownH DownV\n");
|
|
for (i = 0; i < tegra_dc_get_numof_dispwindows(); i++) {
|
|
struct tegra_dc_win *win;
|
|
u32 *scaling;
|
|
|
|
win = tegra_dc_get_window(dc, i);
|
|
if (!win)
|
|
continue;
|
|
scaling = tegra_dc_parse_feature(dc, i, HAS_SCALE);
|
|
if (!scaling)
|
|
continue;
|
|
seq_printf(s, "window_%u: %3u %3u %5u %5u\n", i,
|
|
scaling[H_SCALE_UP],
|
|
scaling[V_SCALE_UP],
|
|
scaling[H_FILTER_DOWN],
|
|
scaling[V_FILTER_DOWN]);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int mods_dc_scaling_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, mods_dc_scaling_show, inode->i_private);
|
|
}
|
|
|
|
static const struct file_operations mods_dc_scaling_fops = {
|
|
.open = mods_dc_scaling_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static int mods_dsi_ganged_get(void *data, u64 *val)
|
|
{
|
|
struct tegra_dc_dsi_data *dsi = data;
|
|
|
|
*val = (u64)dsi->info.ganged_type;
|
|
return 0;
|
|
}
|
|
DEFINE_SIMPLE_ATTRIBUTE(mods_dsi_ganged_fops, mods_dsi_ganged_get, NULL,
|
|
"%llu\n");
|
|
|
|
static int mods_dsi_inst_get(void *data, u64 *val)
|
|
{
|
|
struct tegra_dc_dsi_data *dsi = data;
|
|
|
|
*val = (u64)dsi->info.dsi_instance;
|
|
return 0;
|
|
}
|
|
DEFINE_SIMPLE_ATTRIBUTE(mods_dsi_inst_fops, mods_dsi_inst_get, NULL, "%llu\n");
|
|
|
|
static int mods_dc_border_get(void *data, u64 *val)
|
|
{
|
|
struct tegra_dc *dc = data;
|
|
u32 blender_reg = DC_DISP_BLEND_BACKGROUND_COLOR;
|
|
|
|
if (!dc->enabled)
|
|
*val = 0ULL;
|
|
else
|
|
*val = (u64)tegra_dc_readl_exported(dc, blender_reg);
|
|
return 0;
|
|
}
|
|
static int mods_dc_border_set(void *data, u64 val)
|
|
{
|
|
struct tegra_dc *dc = data;
|
|
u32 blender_reg = DC_DISP_BLEND_BACKGROUND_COLOR;
|
|
|
|
if (!dc->enabled)
|
|
return 0;
|
|
mutex_lock(&dc->lock);
|
|
tegra_dc_get(dc);
|
|
tegra_dc_writel_exported(dc, val, blender_reg);
|
|
tegra_dc_writel_exported(dc, GENERAL_ACT_REQ, DC_CMD_STATE_CONTROL);
|
|
tegra_dc_put(dc);
|
|
mutex_unlock(&dc->lock);
|
|
return 0;
|
|
}
|
|
DEFINE_SIMPLE_ATTRIBUTE(mods_dc_border_fops, mods_dc_border_get,
|
|
mods_dc_border_set, "0x%llx\n");
|
|
|
|
static int mods_dc_ocp_show(struct seq_file *s, void *unused)
|
|
{
|
|
seq_puts(s, "rgb\n");
|
|
return 0;
|
|
}
|
|
|
|
static int mods_dc_ocp_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, mods_dc_ocp_show, inode->i_private);
|
|
}
|
|
|
|
static const struct file_operations mods_dc_ocp_fops = {
|
|
.open = mods_dc_ocp_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
|
|
#define DC_DISP_CSC2_CONTROL 0x4ef
|
|
#define CSC2_OUTPUT_COLOR_RGB (0 << 0)
|
|
#define CSC2_OUTPUT_COLOR_709 (1 << 0)
|
|
#define CSC2_OUTPUT_COLOR_601 (2 << 0)
|
|
#define CSC2_OUTPUT_COLOR(val) (val & 0x3)
|
|
#define CSC2_LIMIT_RGB_DISABLE (0 << 2)
|
|
#define CSC2_LIMIT_RGB_ENABLE (1 << 2)
|
|
|
|
static int mods_dc_oc_show(struct seq_file *s, void *unused)
|
|
{
|
|
seq_puts(s, "rgb\n");
|
|
return 0;
|
|
}
|
|
|
|
static int mods_dc_oc_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, mods_dc_oc_show, inode->i_private);
|
|
}
|
|
|
|
static ssize_t mods_dc_oc_write(struct file *file, const char __user *user_buf,
|
|
size_t size, loff_t *ppos)
|
|
{
|
|
char buf[8];
|
|
int buf_size;
|
|
|
|
buf_size = min(size, (sizeof(buf) - 1));
|
|
if (strncpy_from_user(buf, user_buf, buf_size) < 0)
|
|
return -EFAULT;
|
|
buf[buf_size] = 0;
|
|
|
|
if (strncmp(buf, "rgb", 3) != 0)
|
|
return -EINVAL;
|
|
*ppos += size;
|
|
return size;
|
|
}
|
|
|
|
static const struct file_operations mods_dc_oc_fops = {
|
|
.open = mods_dc_oc_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
.write = mods_dc_oc_write,
|
|
};
|
|
|
|
static int mods_dc_ddc_bus_get(void *data, u64 *val)
|
|
{
|
|
struct tegra_dc *dc = data;
|
|
*val = dc->out->ddc_bus;
|
|
return 0;
|
|
}
|
|
DEFINE_SIMPLE_ATTRIBUTE(mods_dc_ddc_bus_fops, mods_dc_ddc_bus_get,
|
|
NULL, "%lld\n");
|
|
|
|
|
|
static int mods_dc_crc_latched_show(struct seq_file *s, void *unused)
|
|
{
|
|
struct tegra_dc *dc = s->private;
|
|
u32 crc = tegra_dc_sysfs_read_checksum_latched(dc);
|
|
u32 field = 0;
|
|
u32 val;
|
|
|
|
val = tegra_dc_readl_exported(dc, DC_DISP_INTERLACE_CONTROL);
|
|
if (val & INTERLACE_MODE_ENABLE)
|
|
field = (val & INTERLACE_STATUS_FIELD_2) ? 1 : 0;
|
|
seq_printf(s, "0x%08x %u\n", crc, field);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mods_dc_crc_latched_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, mods_dc_crc_latched_show, inode->i_private);
|
|
}
|
|
|
|
static const struct file_operations mods_dc_crc_latched_fops = {
|
|
.open = mods_dc_crc_latched_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
#endif /* CONFIG_TEGRA_DC */
|
|
|
|
#if defined(MODS_TEGRA) && defined(MODS_HAS_KFUSE)
|
|
static int mods_kfuse_show(struct seq_file *s, void *unused)
|
|
{
|
|
unsigned int buf[KFUSE_DATA_SZ / 4];
|
|
|
|
/* copy load kfuse into buffer - only needed for early Tegra parts */
|
|
int ret = tegra_kfuse_read(buf, sizeof(buf));
|
|
int i;
|
|
|
|
if (ret)
|
|
return ret;
|
|
|
|
for (i = 0; i < KFUSE_DATA_SZ / 4; i += 4)
|
|
seq_printf(s, "0x%08x 0x%08x 0x%08x 0x%08x\n",
|
|
buf[i], buf[i+1], buf[i+2], buf[i+3]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mods_kfuse_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, mods_kfuse_show, inode->i_private);
|
|
}
|
|
|
|
static const struct file_operations mods_kfuse_fops = {
|
|
.open = mods_kfuse_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
#endif /* MODS_TEGRA */
|
|
|
|
static int mods_debug_get(void *data, u64 *val)
|
|
{
|
|
*val = (u64)(mods_get_debug_level() & DEBUG_ALL);
|
|
return 0;
|
|
}
|
|
static int mods_debug_set(void *data, u64 val)
|
|
{
|
|
mods_set_debug_level((int)val & DEBUG_ALL);
|
|
return 0;
|
|
}
|
|
DEFINE_SIMPLE_ATTRIBUTE(mods_debug_fops, mods_debug_get, mods_debug_set,
|
|
"0x%08llx\n");
|
|
|
|
static int mods_mi_get(void *data, u64 *val)
|
|
{
|
|
*val = (u64)mods_get_multi_instance();
|
|
return 0;
|
|
}
|
|
static int mods_mi_set(void *data, u64 val)
|
|
{
|
|
mods_set_multi_instance((int)val);
|
|
return 0;
|
|
}
|
|
DEFINE_SIMPLE_ATTRIBUTE(mods_mi_fops, mods_mi_get, mods_mi_set, "%llu\n");
|
|
#endif /* MODS_HAS_DEBUGFS */
|
|
|
|
void mods_remove_debugfs(void)
|
|
{
|
|
#ifdef MODS_HAS_DEBUGFS
|
|
debugfs_remove_recursive(mods_debugfs_dir);
|
|
mods_debugfs_dir = NULL;
|
|
#endif
|
|
}
|
|
|
|
int mods_create_debugfs(struct miscdevice *modsdev)
|
|
{
|
|
#ifdef MODS_HAS_DEBUGFS
|
|
struct dentry *retval;
|
|
#ifdef CONFIG_TEGRA_DC
|
|
unsigned int dc_idx;
|
|
int nheads = tegra_dc_get_numof_dispheads();
|
|
#endif
|
|
int err = 0;
|
|
|
|
#ifdef CONFIG_TEGRA_DC
|
|
if (nheads <= 0) {
|
|
pr_err("%s: max heads:%d cannot be negative or zero\n",
|
|
__func__, nheads);
|
|
return -EINVAL;
|
|
}
|
|
#endif
|
|
|
|
mods_debugfs_dir = debugfs_create_dir(dev_name(modsdev->this_device),
|
|
NULL);
|
|
if (IS_ERR(mods_debugfs_dir)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
|
|
retval = debugfs_create_file("debug", 0644,
|
|
mods_debugfs_dir, 0, &mods_debug_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
|
|
retval = debugfs_create_file("multi_instance", 0644,
|
|
mods_debugfs_dir, 0, &mods_mi_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
|
|
#if defined(MODS_TEGRA) && defined(MODS_HAS_KFUSE)
|
|
retval = debugfs_create_file("kfuse_data", 0444,
|
|
mods_debugfs_dir, 0, &mods_kfuse_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_TEGRA_DC
|
|
for (dc_idx = 0; dc_idx < nheads; dc_idx++) {
|
|
struct dentry *dc_debugfs_dir;
|
|
char devname[16];
|
|
struct tegra_dc *dc = tegra_dc_get_dc(dc_idx);
|
|
|
|
if (!dc)
|
|
continue;
|
|
|
|
snprintf(devname, sizeof(devname), "tegradc.%d", dc->ctrl_num);
|
|
dc_debugfs_dir = debugfs_create_dir(devname, mods_debugfs_dir);
|
|
|
|
if (IS_ERR(dc_debugfs_dir)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
|
|
retval = debugfs_create_file("window_mask", 0444,
|
|
dc_debugfs_dir, dc, &mods_dc_window_mask_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
retval = debugfs_create_file("color_formats", 0444,
|
|
dc_debugfs_dir, dc, &mods_dc_color_formats_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
retval = debugfs_create_file("blend_gen", 0444,
|
|
dc_debugfs_dir, dc, &mods_dc_blend_gen_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
retval = debugfs_create_file("layout", 0444, dc_debugfs_dir,
|
|
dc, &mods_dc_layout_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
retval = debugfs_create_file("invert", 0444, dc_debugfs_dir,
|
|
dc, &mods_dc_invert_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
retval = debugfs_create_file("interlaced", 0444,
|
|
dc_debugfs_dir, dc, &mods_dc_interlaced_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
retval = debugfs_create_file("scaling", 0444, dc_debugfs_dir,
|
|
dc, &mods_dc_scaling_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
retval = debugfs_create_file("border_color", 0644,
|
|
dc_debugfs_dir, dc, &mods_dc_border_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
|
|
retval = debugfs_create_file("output_color_possible", 0444,
|
|
dc_debugfs_dir, NULL, &mods_dc_ocp_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
retval = debugfs_create_file("output_color", 0644,
|
|
dc_debugfs_dir, dc, &mods_dc_oc_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
|
|
retval = debugfs_create_file("crc_checksum_latched", 0444,
|
|
dc_debugfs_dir, dc, &mods_dc_crc_latched_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
|
|
if (dc->out && dc->out->type == TEGRA_DC_OUT_DSI) {
|
|
struct dentry *dsi_debugfs_dir;
|
|
|
|
dsi_debugfs_dir = debugfs_create_dir("dsi",
|
|
dc_debugfs_dir);
|
|
if (IS_ERR(dsi_debugfs_dir)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
retval = debugfs_create_file("ganged", 0444,
|
|
dsi_debugfs_dir, tegra_dc_get_outdata(dc),
|
|
&mods_dsi_ganged_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
retval = debugfs_create_file("instance", 0444,
|
|
dsi_debugfs_dir, tegra_dc_get_outdata(dc),
|
|
&mods_dsi_inst_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
}
|
|
|
|
if (dc->out && dc->out->type == TEGRA_DC_OUT_HDMI) {
|
|
retval = debugfs_create_file("ddc_bus", 0444,
|
|
dc_debugfs_dir, dc, &mods_dc_ddc_bus_fops);
|
|
if (IS_ERR(retval)) {
|
|
err = -EIO;
|
|
goto remove_out;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return 0;
|
|
remove_out:
|
|
dev_err(modsdev->this_device, "could not create debugfs\n");
|
|
mods_remove_debugfs();
|
|
return err;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|