// SPDX-License-Identifier: GPL-2.0
|
/* Copyright (C) 2019 Rockchip Electronics Co., Ltd */
|
|
#include <linux/clk.h>
|
#include <linux/delay.h>
|
#include <linux/interrupt.h>
|
#include <linux/io.h>
|
#include <linux/module.h>
|
#include <linux/of.h>
|
#include <linux/of_graph.h>
|
#include <linux/of_platform.h>
|
#include <linux/of_reserved_mem.h>
|
#include <linux/pinctrl/consumer.h>
|
#include <linux/pm_runtime.h>
|
#include <linux/reset.h>
|
#include <linux/regmap.h>
|
#include <media/videobuf2-dma-contig.h>
|
#include <media/v4l2-fwnode.h>
|
|
#include "dev.h"
|
#include "regs.h"
|
#include "version.h"
|
|
#define RKISPP_VERNO_LEN 10
|
|
int rkispp_debug;
|
module_param_named(debug, rkispp_debug, int, 0644);
|
MODULE_PARM_DESC(debug, "Debug level (0-3)");
|
|
static bool rkispp_clk_dbg;
|
module_param_named(clk_dbg, rkispp_clk_dbg, bool, 0644);
|
MODULE_PARM_DESC(clk_dbg, "rkispp clk set by user");
|
|
bool rkispp_monitor;
|
module_param_named(monitor, rkispp_monitor, bool, 0644);
|
MODULE_PARM_DESC(monitor, "rkispp abnormal restart monitor");
|
|
static int rkisp_ispp_mode = ISP_ISPP_FBC;
|
module_param_named(mode, rkisp_ispp_mode, int, 0644);
|
MODULE_PARM_DESC(mode, "isp->ispp mode: bit0 fbc, bit1 yuv422, bit2 quick");
|
|
static bool rkispp_stream_sync;
|
module_param_named(stream_sync, rkispp_stream_sync, bool, 0644);
|
MODULE_PARM_DESC(stream_sync, "rkispp stream sync output");
|
|
static char rkispp_version[RKISPP_VERNO_LEN];
|
module_param_string(version, rkispp_version, RKISPP_VERNO_LEN, 0444);
|
MODULE_PARM_DESC(version, "version number");
|
|
bool rkispp_reg_withstream;
|
module_param_named(sendreg_withstream, rkispp_reg_withstream, bool, 0644);
|
MODULE_PARM_DESC(sendreg_withstream, "rkispp send reg out with stream");
|
|
char rkispp_reg_withstream_video_name[RKISPP_VIDEO_NAME_LEN];
|
module_param_string(sendreg_withstream_video_name, rkispp_reg_withstream_video_name,
|
RKISPP_VIDEO_NAME_LEN, 0644);
|
MODULE_PARM_DESC(sendreg_withstream, "rkispp video send reg out with stream");
|
|
unsigned int rkispp_debug_reg = 0x1F;
|
module_param_named(debug_reg, rkispp_debug_reg, uint, 0644);
|
MODULE_PARM_DESC(debug_reg, "rkispp debug register");
|
|
static unsigned int rkispp_wait_line;
|
module_param_named(wait_line, rkispp_wait_line, uint, 0644);
|
MODULE_PARM_DESC(wait_line, "rkispp wait line to buf done early");
|
|
char rkispp_dump_path[128];
|
module_param_string(dump_path, rkispp_dump_path, sizeof(rkispp_dump_path), 0644);
|
MODULE_PARM_DESC(dump_path, "rkispp dump debug file path");
|
|
void rkispp_set_clk_rate(struct clk *clk, unsigned long rate)
|
{
|
if (rkispp_clk_dbg)
|
return;
|
|
clk_set_rate(clk, rate);
|
}
|
|
static void get_remote_node_dev(struct rkispp_device *ispp_dev)
|
{
|
struct device *dev = ispp_dev->dev;
|
struct device_node *parent = dev->of_node;
|
struct platform_device *remote_dev = NULL;
|
struct device_node *remote = NULL;
|
struct v4l2_subdev *sd = NULL;
|
int i;
|
|
for (i = 0; i < 2; i++) {
|
remote = of_graph_get_remote_node(parent, 0, i);
|
if (!remote)
|
continue;
|
remote_dev = of_find_device_by_node(remote);
|
of_node_put(remote);
|
if (!remote_dev) {
|
dev_err(dev, "Failed to get remote device(%s)\n",
|
of_node_full_name(remote));
|
continue;
|
} else {
|
rkisp_get_bridge_sd(remote_dev, &sd);
|
if (!sd) {
|
dev_err(dev, "Failed to get isp bridge sd\n");
|
} else {
|
ispp_dev->ispp_sdev.remote_sd = sd;
|
v4l2_set_subdev_hostdata(sd, &ispp_dev->ispp_sdev.sd);
|
if (ispp_dev->hw_dev->max_in.w && ispp_dev->hw_dev->max_in.h)
|
v4l2_subdev_call(sd, core, ioctl, RKISP_ISPP_CMD_SET_FMT,
|
&ispp_dev->hw_dev->max_in);
|
break;
|
}
|
}
|
}
|
}
|
|
static int rkispp_create_links(struct rkispp_device *ispp_dev)
|
{
|
struct rkispp_stream_vdev *stream_vdev;
|
struct media_entity *source, *sink;
|
struct rkispp_stream *stream;
|
unsigned int flags = 0;
|
int ret;
|
|
stream_vdev = &ispp_dev->stream_vdev;
|
stream = &stream_vdev->stream[STREAM_II];
|
/* input stream links */
|
sink = &ispp_dev->ispp_sdev.sd.entity;
|
get_remote_node_dev(ispp_dev);
|
if (ispp_dev->ispp_sdev.remote_sd) {
|
ispp_dev->inp = INP_ISP;
|
} else {
|
flags = MEDIA_LNK_FL_ENABLED;
|
ispp_dev->inp = INP_DDR;
|
stream->linked = true;
|
}
|
source = &stream->vnode.vdev.entity;
|
ret = media_create_pad_link(source, 0, sink, RKISPP_PAD_SINK, flags);
|
if (ret < 0)
|
return ret;
|
|
/* params links */
|
flags = MEDIA_LNK_FL_ENABLED;
|
source = &ispp_dev->params_vdev[PARAM_VDEV_FEC].vnode.vdev.entity;
|
ret = media_create_pad_link(source, 0, sink, RKISPP_PAD_SINK_PARAMS, flags);
|
if (ret < 0)
|
return ret;
|
ispp_dev->stream_vdev.module_ens = ISPP_MODULE_FEC;
|
if (ispp_dev->ispp_ver == ISPP_V10) {
|
/* params links */
|
source = &ispp_dev->params_vdev[PARAM_VDEV_TNR].vnode.vdev.entity;
|
ret = media_create_pad_link(source, 0, sink, RKISPP_PAD_SINK_PARAMS, flags);
|
if (ret < 0)
|
return ret;
|
source = &ispp_dev->params_vdev[PARAM_VDEV_NR].vnode.vdev.entity;
|
ret = media_create_pad_link(source, 0, sink, RKISPP_PAD_SINK_PARAMS, flags);
|
if (ret < 0)
|
return ret;
|
|
/* stats links */
|
source = &ispp_dev->ispp_sdev.sd.entity;
|
sink = &ispp_dev->stats_vdev[STATS_VDEV_TNR].vnode.vdev.entity;
|
ret = media_create_pad_link(source, RKISPP_PAD_SOURCE_STATS, sink, 0, flags);
|
if (ret < 0)
|
return ret;
|
sink = &ispp_dev->stats_vdev[STATS_VDEV_NR].vnode.vdev.entity;
|
ret = media_create_pad_link(source, RKISPP_PAD_SOURCE_STATS, sink, 0, flags);
|
if (ret < 0)
|
return ret;
|
|
/* output stream links */
|
stream = &stream_vdev->stream[STREAM_S0];
|
stream->linked = flags;
|
sink = &stream->vnode.vdev.entity;
|
ret = media_create_pad_link(source, RKISPP_PAD_SOURCE, sink, 0, flags);
|
if (ret < 0)
|
return ret;
|
|
stream = &stream_vdev->stream[STREAM_S1];
|
stream->linked = flags;
|
sink = &stream->vnode.vdev.entity;
|
ret = media_create_pad_link(source, RKISPP_PAD_SOURCE, sink, 0, flags);
|
if (ret < 0)
|
return ret;
|
|
stream = &stream_vdev->stream[STREAM_S2];
|
stream->linked = flags;
|
sink = &stream->vnode.vdev.entity;
|
ret = media_create_pad_link(source, RKISPP_PAD_SOURCE, sink, 0, flags);
|
if (ret < 0)
|
return ret;
|
|
ispp_dev->stream_vdev.module_ens = ISPP_MODULE_NR | ISPP_MODULE_SHP;
|
}
|
|
flags = rkispp_stream_sync ? 0 : MEDIA_LNK_FL_ENABLED;
|
stream = &stream_vdev->stream[STREAM_MB];
|
stream->linked = flags;
|
source = &ispp_dev->ispp_sdev.sd.entity;
|
sink = &stream->vnode.vdev.entity;
|
ret = media_create_pad_link(source, RKISPP_PAD_SOURCE, sink, 0, flags);
|
if (ret < 0)
|
return ret;
|
|
stream = &stream_vdev->stream[STREAM_VIR];
|
stream->linked = flags;
|
sink = &stream->vnode.vdev.entity;
|
ret = media_create_pad_link(source, RKISPP_PAD_SOURCE, sink, 0, flags);
|
if (ret < 0)
|
return ret;
|
|
return 0;
|
}
|
|
static int rkispp_register_platform_subdevs(struct rkispp_device *ispp_dev)
|
{
|
int ret;
|
|
ret = rkispp_register_stream_vdevs(ispp_dev);
|
if (ret < 0)
|
return ret;
|
|
ret = rkispp_register_params_vdevs(ispp_dev);
|
if (ret < 0)
|
goto err_unreg_stream_vdevs;
|
|
ret = rkispp_register_stats_vdevs(ispp_dev);
|
if (ret < 0)
|
goto err_unreg_params_vdev;
|
|
ret = rkispp_register_subdev(ispp_dev, &ispp_dev->v4l2_dev);
|
if (ret < 0)
|
goto err_unreg_stats_vdev;
|
|
ret = rkispp_create_links(ispp_dev);
|
if (ret < 0)
|
goto err_unreg_ispp_subdev;
|
return ret;
|
err_unreg_ispp_subdev:
|
rkispp_unregister_subdev(ispp_dev);
|
err_unreg_stats_vdev:
|
rkispp_unregister_stats_vdevs(ispp_dev);
|
err_unreg_params_vdev:
|
rkispp_unregister_params_vdevs(ispp_dev);
|
err_unreg_stream_vdevs:
|
rkispp_unregister_stream_vdevs(ispp_dev);
|
return ret;
|
}
|
|
static const struct of_device_id rkispp_plat_of_match[] = {
|
{
|
.compatible = "rockchip,rv1126-rkispp-vir",
|
}, {
|
.compatible = "rockchip,rk3588-rkispp-vir",
|
},
|
{},
|
};
|
|
static int rkispp_plat_probe(struct platform_device *pdev)
|
{
|
struct device *dev = &pdev->dev;
|
struct v4l2_device *v4l2_dev;
|
struct rkispp_device *ispp_dev;
|
int ret;
|
|
sprintf(rkispp_version, "v%02x.%02x.%02x",
|
RKISPP_DRIVER_VERSION >> 16,
|
(RKISPP_DRIVER_VERSION & 0xff00) >> 8,
|
RKISPP_DRIVER_VERSION & 0x00ff);
|
|
dev_info(dev, "rkispp driver version: %s\n", rkispp_version);
|
|
ispp_dev = devm_kzalloc(dev, sizeof(*ispp_dev), GFP_KERNEL);
|
if (!ispp_dev)
|
return -ENOMEM;
|
ispp_dev->sw_base_addr = devm_kzalloc(dev, RKISP_ISPP_SW_MAX_SIZE, GFP_KERNEL);
|
if (!ispp_dev->sw_base_addr)
|
return -ENOMEM;
|
|
dev_set_drvdata(dev, ispp_dev);
|
ispp_dev->dev = dev;
|
|
ret = rkispp_attach_hw(ispp_dev);
|
if (ret)
|
return ret;
|
|
sprintf(ispp_dev->media_dev.model, "%s%d",
|
DRIVER_NAME, ispp_dev->dev_id);
|
ispp_dev->irq_hdl = rkispp_isr;
|
mutex_init(&ispp_dev->apilock);
|
mutex_init(&ispp_dev->iqlock);
|
init_waitqueue_head(&ispp_dev->sync_onoff);
|
|
strscpy(ispp_dev->name, dev_name(dev), sizeof(ispp_dev->name));
|
strscpy(ispp_dev->media_dev.driver_name, ispp_dev->name,
|
sizeof(ispp_dev->media_dev.driver_name));
|
ispp_dev->media_dev.dev = &pdev->dev;
|
v4l2_dev = &ispp_dev->v4l2_dev;
|
v4l2_dev->mdev = &ispp_dev->media_dev;
|
strlcpy(v4l2_dev->name, ispp_dev->name, sizeof(v4l2_dev->name));
|
v4l2_ctrl_handler_init(&ispp_dev->ctrl_handler, 5);
|
v4l2_dev->ctrl_handler = &ispp_dev->ctrl_handler;
|
|
ret = v4l2_device_register(ispp_dev->dev, v4l2_dev);
|
if (ret < 0) {
|
v4l2_err(v4l2_dev, "register v4l2 device failed:%d\n", ret);
|
return ret;
|
}
|
media_device_init(&ispp_dev->media_dev);
|
ret = media_device_register(&ispp_dev->media_dev);
|
if (ret < 0) {
|
v4l2_err(v4l2_dev, "register media device failed:%d\n", ret);
|
goto err_unreg_v4l2_dev;
|
}
|
|
ret = rkispp_register_platform_subdevs(ispp_dev);
|
if (ret < 0)
|
goto err_unreg_media_dev;
|
|
rkispp_wait_line = 0;
|
of_property_read_u32(pdev->dev.of_node, "wait-line",
|
&rkispp_wait_line);
|
rkispp_proc_init(ispp_dev);
|
pm_runtime_enable(&pdev->dev);
|
|
return 0;
|
|
err_unreg_media_dev:
|
media_device_unregister(&ispp_dev->media_dev);
|
err_unreg_v4l2_dev:
|
v4l2_device_unregister(&ispp_dev->v4l2_dev);
|
return ret;
|
}
|
|
static int rkispp_plat_remove(struct platform_device *pdev)
|
{
|
struct rkispp_device *ispp_dev = platform_get_drvdata(pdev);
|
|
pm_runtime_disable(&pdev->dev);
|
|
rkispp_proc_cleanup(ispp_dev);
|
rkispp_unregister_subdev(ispp_dev);
|
rkispp_unregister_stats_vdevs(ispp_dev);
|
rkispp_unregister_params_vdevs(ispp_dev);
|
rkispp_unregister_stream_vdevs(ispp_dev);
|
|
media_device_unregister(&ispp_dev->media_dev);
|
v4l2_device_unregister(&ispp_dev->v4l2_dev);
|
mutex_destroy(&ispp_dev->apilock);
|
mutex_destroy(&ispp_dev->iqlock);
|
return 0;
|
}
|
|
static int __maybe_unused rkispp_runtime_suspend(struct device *dev)
|
{
|
struct rkispp_device *ispp_dev = dev_get_drvdata(dev);
|
int ret;
|
|
mutex_lock(&ispp_dev->hw_dev->dev_lock);
|
ret = pm_runtime_put_sync(ispp_dev->hw_dev->dev);
|
mutex_unlock(&ispp_dev->hw_dev->dev_lock);
|
return (ret > 0) ? 0 : ret;
|
}
|
|
static int __maybe_unused rkispp_runtime_resume(struct device *dev)
|
{
|
struct rkispp_device *ispp_dev = dev_get_drvdata(dev);
|
int ret;
|
|
ispp_dev->isp_mode = rkisp_ispp_mode;
|
ispp_dev->stream_sync = rkispp_stream_sync;
|
ispp_dev->stream_vdev.monitor.is_en = rkispp_monitor;
|
ispp_dev->stream_vdev.wait_line = rkispp_wait_line;
|
|
mutex_lock(&ispp_dev->hw_dev->dev_lock);
|
ret = pm_runtime_get_sync(ispp_dev->hw_dev->dev);
|
mutex_unlock(&ispp_dev->hw_dev->dev_lock);
|
return (ret > 0) ? 0 : ret;
|
}
|
|
static const struct dev_pm_ops rkispp_plat_pm_ops = {
|
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
|
pm_runtime_force_resume)
|
SET_RUNTIME_PM_OPS(rkispp_runtime_suspend,
|
rkispp_runtime_resume, NULL)
|
};
|
|
struct platform_driver rkispp_plat_drv = {
|
.driver = {
|
.name = DRIVER_NAME,
|
.of_match_table = of_match_ptr(rkispp_plat_of_match),
|
.pm = &rkispp_plat_pm_ops,
|
},
|
.probe = rkispp_plat_probe,
|
.remove = rkispp_plat_remove,
|
};
|
|
MODULE_AUTHOR("Rockchip Camera/ISP team");
|
MODULE_DESCRIPTION("Rockchip ISPP platform driver");
|
MODULE_LICENSE("GPL v2");
|
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
|
