// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
|
/*
|
* Copyright (c) 2019 Fuzhou Rockchip Electronics Co., Ltd
|
*
|
* author:
|
* Alpha Lin, alpha.lin@rock-chips.com
|
* Randy Li, randy.li@rock-chips.com
|
* Ding Wei, leo.ding@rock-chips.com
|
*
|
*/
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
#include <linux/completion.h>
|
#include <linux/delay.h>
|
#include <linux/module.h>
|
#include <linux/of_platform.h>
|
#include <linux/proc_fs.h>
|
#include <linux/seq_file.h>
|
#include <linux/slab.h>
|
#include <linux/nospec.h>
|
#include <linux/mfd/syscon.h>
|
|
#include "mpp_debug.h"
|
#include "mpp_common.h"
|
#include "mpp_iommu.h"
|
|
#define MPP_CLASS_NAME "mpp_class"
|
#define MPP_SERVICE_NAME "mpp_service"
|
|
#define HAS_RKVDEC IS_ENABLED(CONFIG_ROCKCHIP_MPP_RKVDEC)
|
#define HAS_RKVENC IS_ENABLED(CONFIG_ROCKCHIP_MPP_RKVENC)
|
#define HAS_VDPU1 IS_ENABLED(CONFIG_ROCKCHIP_MPP_VDPU1)
|
#define HAS_VEPU1 IS_ENABLED(CONFIG_ROCKCHIP_MPP_VEPU1)
|
#define HAS_VDPU2 IS_ENABLED(CONFIG_ROCKCHIP_MPP_VDPU2)
|
#define HAS_VEPU2 IS_ENABLED(CONFIG_ROCKCHIP_MPP_VEPU2)
|
#define HAS_VEPU22 IS_ENABLED(CONFIG_ROCKCHIP_MPP_VEPU22)
|
#define HAS_IEP2 IS_ENABLED(CONFIG_ROCKCHIP_MPP_IEP2)
|
#define HAS_JPGDEC IS_ENABLED(CONFIG_ROCKCHIP_MPP_JPGDEC)
|
#define HAS_RKVDEC2 IS_ENABLED(CONFIG_ROCKCHIP_MPP_RKVDEC2)
|
#define HAS_RKVENC2 IS_ENABLED(CONFIG_ROCKCHIP_MPP_RKVENC2)
|
#define HAS_AV1DEC IS_ENABLED(CONFIG_ROCKCHIP_MPP_AV1DEC)
|
#define HAS_VDPP IS_ENABLED(CONFIG_ROCKCHIP_MPP_VDPP)
|
|
#define MPP_REGISTER_DRIVER(srv, flag, X, x) {\
|
if (flag)\
|
mpp_add_driver(srv, MPP_DRIVER_##X, &rockchip_##x##_driver, "grf_"#x);\
|
}
|
|
unsigned int mpp_dev_debug;
|
module_param(mpp_dev_debug, uint, 0644);
|
MODULE_PARM_DESC(mpp_dev_debug, "bit switch for mpp debug information");
|
|
static const char mpp_version[] = MPP_VERSION;
|
|
static int mpp_init_grf(struct device_node *np,
|
struct mpp_grf_info *grf_info,
|
const char *grf_name)
|
{
|
int ret;
|
int index;
|
u32 grf_offset = 0;
|
u32 grf_value = 0;
|
struct regmap *grf;
|
|
grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf");
|
if (IS_ERR_OR_NULL(grf))
|
return -EINVAL;
|
|
ret = of_property_read_u32(np, "rockchip,grf-offset", &grf_offset);
|
if (ret)
|
return -ENODATA;
|
|
index = of_property_match_string(np, "rockchip,grf-names", grf_name);
|
if (index < 0)
|
return -ENODATA;
|
|
ret = of_property_read_u32_index(np, "rockchip,grf-values",
|
index, &grf_value);
|
if (ret)
|
return -ENODATA;
|
|
grf_info->grf = grf;
|
grf_info->offset = grf_offset;
|
grf_info->val = grf_value;
|
|
mpp_set_grf(grf_info);
|
|
return 0;
|
}
|
|
static int mpp_add_driver(struct mpp_service *srv,
|
enum MPP_DRIVER_TYPE type,
|
struct platform_driver *driver,
|
const char *grf_name)
|
{
|
int ret;
|
|
mpp_init_grf(srv->dev->of_node,
|
&srv->grf_infos[type],
|
grf_name);
|
|
if (IS_ENABLED(CONFIG_ROCKCHIP_MPP_AV1DEC) && type == MPP_DRIVER_AV1DEC)
|
ret = av1dec_driver_register(driver);
|
else
|
ret = platform_driver_register(driver);
|
if (ret)
|
return ret;
|
|
srv->sub_drivers[type] = driver;
|
|
return 0;
|
}
|
|
static int mpp_remove_driver(struct mpp_service *srv, int i)
|
{
|
if (srv && srv->sub_drivers[i]) {
|
if (i != MPP_DRIVER_AV1DEC) {
|
mpp_set_grf(&srv->grf_infos[i]);
|
platform_driver_unregister(srv->sub_drivers[i]);
|
} else if (IS_ENABLED(CONFIG_ROCKCHIP_MPP_AV1DEC)) {
|
av1dec_driver_unregister(srv->sub_drivers[i]);
|
}
|
srv->sub_drivers[i] = NULL;
|
}
|
|
return 0;
|
}
|
|
static int mpp_register_service(struct mpp_service *srv,
|
const char *service_name)
|
{
|
int ret;
|
struct device *dev = srv->dev;
|
|
/* create a device */
|
ret = alloc_chrdev_region(&srv->dev_id, 0, 1, service_name);
|
if (ret) {
|
dev_err(dev, "alloc dev_t failed\n");
|
return ret;
|
}
|
|
cdev_init(&srv->mpp_cdev, &rockchip_mpp_fops);
|
srv->mpp_cdev.owner = THIS_MODULE;
|
srv->mpp_cdev.ops = &rockchip_mpp_fops;
|
|
ret = cdev_add(&srv->mpp_cdev, srv->dev_id, 1);
|
if (ret) {
|
unregister_chrdev_region(srv->dev_id, 1);
|
dev_err(dev, "add device failed\n");
|
return ret;
|
}
|
|
srv->child_dev = device_create(srv->cls, dev, srv->dev_id,
|
NULL, "%s", service_name);
|
|
return 0;
|
}
|
|
static int mpp_remove_service(struct mpp_service *srv)
|
{
|
device_destroy(srv->cls, srv->dev_id);
|
cdev_del(&srv->mpp_cdev);
|
unregister_chrdev_region(srv->dev_id, 1);
|
|
return 0;
|
}
|
|
#ifdef CONFIG_ROCKCHIP_MPP_PROC_FS
|
static int mpp_procfs_remove(struct mpp_service *srv)
|
{
|
if (srv->procfs) {
|
proc_remove(srv->procfs);
|
srv->procfs = NULL;
|
}
|
|
return 0;
|
}
|
|
static int mpp_show_version(struct seq_file *seq, void *offset)
|
{
|
seq_printf(seq, "%s\n", mpp_version);
|
|
return 0;
|
}
|
|
static int mpp_dump_session(struct mpp_session *session, struct seq_file *s)
|
{
|
struct mpp_dma_session *dma = session->dma;
|
struct mpp_dma_buffer *n;
|
struct mpp_dma_buffer *buffer;
|
phys_addr_t end;
|
unsigned long z = 0, t = 0;
|
int i = 0;
|
#define K(size) ((unsigned long)((size) >> 10))
|
|
if (!dma)
|
return 0;
|
|
seq_puts(s, "session iova range dump:\n");
|
|
mutex_lock(&dma->list_mutex);
|
list_for_each_entry_safe(buffer, n, &dma->used_list, link) {
|
end = buffer->iova + buffer->size - 1;
|
z = (unsigned long)buffer->size;
|
t += z;
|
|
seq_printf(s, "%4d: ", i++);
|
seq_printf(s, "%pa..%pa (%10lu %s)\n", &buffer->iova, &end,
|
(z >= 1024) ? (K(z)) : z,
|
(z >= 1024) ? "KiB" : "Bytes");
|
}
|
i = 0;
|
list_for_each_entry_safe(buffer, n, &dma->unused_list, link) {
|
if (!buffer->dmabuf)
|
continue;
|
|
end = buffer->iova + buffer->size - 1;
|
z = (unsigned long)buffer->size;
|
t += z;
|
|
seq_printf(s, "%4d: ", i++);
|
seq_printf(s, "%pa..%pa (%10lu %s)\n", &buffer->iova, &end,
|
(z >= 1024) ? (K(z)) : z,
|
(z >= 1024) ? "KiB" : "Bytes");
|
}
|
|
mutex_unlock(&dma->list_mutex);
|
seq_printf(s, "session: pid=%d index=%d\n", session->pid, session->index);
|
seq_printf(s, " device: %s\n", dev_name(session->mpp->dev));
|
seq_printf(s, " memory: %lu MiB\n", K(K(t)));
|
|
return 0;
|
}
|
|
static int mpp_show_session_summary(struct seq_file *seq, void *offset)
|
{
|
struct mpp_session *session = NULL, *n;
|
struct mpp_service *srv = seq->private;
|
|
mutex_lock(&srv->session_lock);
|
list_for_each_entry_safe(session, n,
|
&srv->session_list,
|
service_link) {
|
struct mpp_dev *mpp;
|
|
if (!session->priv)
|
continue;
|
|
if (!session->mpp)
|
continue;
|
mpp = session->mpp;
|
|
mpp_dump_session(session, seq);
|
|
if (mpp->dev_ops->dump_session)
|
mpp->dev_ops->dump_session(session, seq);
|
}
|
mutex_unlock(&srv->session_lock);
|
|
return 0;
|
}
|
|
static int mpp_show_support_cmd(struct seq_file *file, void *v)
|
{
|
seq_puts(file, "------------- SUPPORT CMD -------------\n");
|
seq_printf(file, "QUERY_HW_SUPPORT: 0x%08x\n", MPP_CMD_QUERY_HW_SUPPORT);
|
seq_printf(file, "QUERY_HW_ID: 0x%08x\n", MPP_CMD_QUERY_HW_ID);
|
seq_printf(file, "QUERY_CMD_SUPPORT: 0x%08x\n", MPP_CMD_QUERY_CMD_SUPPORT);
|
seq_printf(file, "QUERY_BUTT: 0x%08x\n", MPP_CMD_QUERY_BUTT);
|
seq_puts(file, "----\n");
|
seq_printf(file, "INIT_CLIENT_TYPE: 0x%08x\n", MPP_CMD_INIT_CLIENT_TYPE);
|
seq_printf(file, "INIT_TRANS_TABLE: 0x%08x\n", MPP_CMD_INIT_TRANS_TABLE);
|
seq_printf(file, "INIT_BUTT: 0x%08x\n", MPP_CMD_INIT_BUTT);
|
seq_puts(file, "----\n");
|
seq_printf(file, "SET_REG_WRITE: 0x%08x\n", MPP_CMD_SET_REG_WRITE);
|
seq_printf(file, "SET_REG_READ: 0x%08x\n", MPP_CMD_SET_REG_READ);
|
seq_printf(file, "SET_REG_ADDR_OFFSET: 0x%08x\n", MPP_CMD_SET_REG_ADDR_OFFSET);
|
seq_printf(file, "SEND_BUTT: 0x%08x\n", MPP_CMD_SEND_BUTT);
|
seq_puts(file, "----\n");
|
seq_printf(file, "POLL_HW_FINISH: 0x%08x\n", MPP_CMD_POLL_HW_FINISH);
|
seq_printf(file, "POLL_BUTT: 0x%08x\n", MPP_CMD_POLL_BUTT);
|
seq_puts(file, "----\n");
|
seq_printf(file, "RESET_SESSION: 0x%08x\n", MPP_CMD_RESET_SESSION);
|
seq_printf(file, "TRANS_FD_TO_IOVA: 0x%08x\n", MPP_CMD_TRANS_FD_TO_IOVA);
|
seq_printf(file, "RELEASE_FD: 0x%08x\n", MPP_CMD_RELEASE_FD);
|
seq_printf(file, "SEND_CODEC_INFO: 0x%08x\n", MPP_CMD_SEND_CODEC_INFO);
|
seq_printf(file, "CONTROL_BUTT: 0x%08x\n", MPP_CMD_CONTROL_BUTT);
|
|
return 0;
|
}
|
|
static int mpp_show_support_device(struct seq_file *file, void *v)
|
{
|
u32 i;
|
struct mpp_service *srv = file->private;
|
|
seq_puts(file, "---- SUPPORT DEVICES ----\n");
|
for (i = 0; i < MPP_DEVICE_BUTT; i++) {
|
struct mpp_dev *mpp;
|
struct mpp_hw_info *hw_info;
|
|
if (test_bit(i, &srv->hw_support)) {
|
mpp = srv->sub_devices[array_index_nospec(i, MPP_DEVICE_BUTT)];
|
if (!mpp)
|
continue;
|
|
seq_printf(file, "DEVICE[%2d]:%-10s", i, mpp_device_name[i]);
|
hw_info = mpp->var->hw_info;
|
if (hw_info->hw_id)
|
seq_printf(file, "HW_ID:0x%08x", hw_info->hw_id);
|
seq_puts(file, "\n");
|
}
|
}
|
|
return 0;
|
}
|
|
static int mpp_procfs_init(struct mpp_service *srv)
|
{
|
srv->procfs = proc_mkdir(MPP_SERVICE_NAME, NULL);
|
if (IS_ERR_OR_NULL(srv->procfs)) {
|
mpp_err("failed on mkdir /proc/%s\n", MPP_SERVICE_NAME);
|
srv->procfs = NULL;
|
return -EIO;
|
}
|
/* show version */
|
proc_create_single("version", 0444, srv->procfs, mpp_show_version);
|
/* for show session info */
|
proc_create_single_data("sessions-summary", 0444,
|
srv->procfs, mpp_show_session_summary, srv);
|
/* show support dev cmd */
|
proc_create_single("supports-cmd", 0444, srv->procfs, mpp_show_support_cmd);
|
/* show support devices */
|
proc_create_single_data("supports-device", 0444,
|
srv->procfs, mpp_show_support_device, srv);
|
mpp_procfs_create_u32("timing_en", 0644, srv->procfs, &srv->timing_en);
|
|
return 0;
|
}
|
#else
|
static inline int mpp_procfs_remove(struct mpp_service *srv)
|
{
|
return 0;
|
}
|
|
static inline int mpp_procfs_init(struct mpp_service *srv)
|
{
|
return 0;
|
}
|
#endif
|
|
static int mpp_service_probe(struct platform_device *pdev)
|
{
|
int ret, i;
|
struct mpp_service *srv = NULL;
|
struct mpp_taskqueue *queue;
|
struct device *dev = &pdev->dev;
|
struct device_node *np = dev->of_node;
|
|
dev_info(dev, "%s\n", mpp_version);
|
dev_info(dev, "probe start\n");
|
srv = devm_kzalloc(dev, sizeof(*srv), GFP_KERNEL);
|
if (!srv)
|
return -ENOMEM;
|
|
srv->dev = dev;
|
atomic_set(&srv->shutdown_request, 0);
|
platform_set_drvdata(pdev, srv);
|
|
srv->cls = class_create(THIS_MODULE, MPP_CLASS_NAME);
|
if (PTR_ERR_OR_ZERO(srv->cls))
|
return PTR_ERR(srv->cls);
|
|
of_property_read_u32(np, "rockchip,taskqueue-count",
|
&srv->taskqueue_cnt);
|
if (srv->taskqueue_cnt > MPP_DEVICE_BUTT) {
|
dev_err(dev, "rockchip,taskqueue-count %d must less than %d\n",
|
srv->taskqueue_cnt, MPP_DEVICE_BUTT);
|
return -EINVAL;
|
}
|
|
for (i = 0; i < srv->taskqueue_cnt; i++) {
|
queue = mpp_taskqueue_init(dev);
|
if (!queue)
|
continue;
|
|
kthread_init_worker(&queue->worker);
|
queue->kworker_task = kthread_run(kthread_worker_fn, &queue->worker,
|
"queue_work%d", i);
|
srv->task_queues[i] = queue;
|
}
|
|
of_property_read_u32(np, "rockchip,resetgroup-count",
|
&srv->reset_group_cnt);
|
if (srv->reset_group_cnt > MPP_DEVICE_BUTT) {
|
dev_err(dev, "rockchip,resetgroup-count %d must less than %d\n",
|
srv->reset_group_cnt, MPP_DEVICE_BUTT);
|
return -EINVAL;
|
}
|
|
if (srv->reset_group_cnt) {
|
u32 i = 0;
|
struct mpp_reset_group *group;
|
|
for (i = 0; i < srv->reset_group_cnt; i++) {
|
group = devm_kzalloc(dev, sizeof(*group), GFP_KERNEL);
|
if (!group)
|
continue;
|
|
init_rwsem(&group->rw_sem);
|
srv->reset_groups[i] = group;
|
}
|
}
|
|
ret = mpp_register_service(srv, MPP_SERVICE_NAME);
|
if (ret) {
|
dev_err(dev, "register %s device\n", MPP_SERVICE_NAME);
|
goto fail_register;
|
}
|
mutex_init(&srv->session_lock);
|
INIT_LIST_HEAD(&srv->session_list);
|
mpp_procfs_init(srv);
|
|
/* register sub drivers */
|
MPP_REGISTER_DRIVER(srv, HAS_RKVDEC, RKVDEC, rkvdec);
|
MPP_REGISTER_DRIVER(srv, HAS_RKVENC, RKVENC, rkvenc);
|
MPP_REGISTER_DRIVER(srv, HAS_VDPU1, VDPU1, vdpu1);
|
MPP_REGISTER_DRIVER(srv, HAS_VEPU1, VEPU1, vepu1);
|
MPP_REGISTER_DRIVER(srv, HAS_VDPU2, VDPU2, vdpu2);
|
MPP_REGISTER_DRIVER(srv, HAS_VEPU2, VEPU2, vepu2);
|
MPP_REGISTER_DRIVER(srv, HAS_VEPU22, VEPU22, vepu22);
|
MPP_REGISTER_DRIVER(srv, HAS_IEP2, IEP2, iep2);
|
MPP_REGISTER_DRIVER(srv, HAS_JPGDEC, JPGDEC, jpgdec);
|
MPP_REGISTER_DRIVER(srv, HAS_RKVDEC2, RKVDEC2, rkvdec2);
|
MPP_REGISTER_DRIVER(srv, HAS_RKVENC2, RKVENC2, rkvenc2);
|
MPP_REGISTER_DRIVER(srv, HAS_AV1DEC, AV1DEC, av1dec);
|
MPP_REGISTER_DRIVER(srv, HAS_VDPP, VDPP, vdpp);
|
|
dev_info(dev, "probe success\n");
|
|
return 0;
|
|
fail_register:
|
class_destroy(srv->cls);
|
|
return ret;
|
}
|
|
static int mpp_service_remove(struct platform_device *pdev)
|
{
|
struct mpp_taskqueue *queue;
|
struct device *dev = &pdev->dev;
|
struct mpp_service *srv = platform_get_drvdata(pdev);
|
int i;
|
|
dev_info(dev, "remove device\n");
|
|
for (i = 0; i < srv->taskqueue_cnt; i++) {
|
queue = srv->task_queues[i];
|
if (queue && queue->kworker_task) {
|
kthread_flush_worker(&queue->worker);
|
kthread_stop(queue->kworker_task);
|
queue->kworker_task = NULL;
|
}
|
}
|
|
/* remove sub drivers */
|
for (i = 0; i < MPP_DRIVER_BUTT; i++)
|
mpp_remove_driver(srv, i);
|
|
mpp_remove_service(srv);
|
class_destroy(srv->cls);
|
mpp_procfs_remove(srv);
|
|
return 0;
|
}
|
|
static const struct of_device_id mpp_dt_ids[] = {
|
{
|
.compatible = "rockchip,mpp-service",
|
},
|
{ },
|
};
|
|
static struct platform_driver mpp_service_driver = {
|
.probe = mpp_service_probe,
|
.remove = mpp_service_remove,
|
.driver = {
|
.name = "mpp_service",
|
.of_match_table = of_match_ptr(mpp_dt_ids),
|
},
|
};
|
|
module_platform_driver(mpp_service_driver);
|
|
MODULE_LICENSE("Dual MIT/GPL");
|
MODULE_VERSION(MPP_VERSION);
|
MODULE_AUTHOR("Ding Wei leo.ding@rock-chips.com");
|
MODULE_DESCRIPTION("Rockchip mpp service driver");
|
