Orange Pi5 kernel

// SPDX-License-Identifier: GPL-2.0
/* Copyright (C) 2020 Rockchip Electronics Co., Ltd. */
 
#include <linux/clk.h>
#include <linux/clk-provider.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/mfd/syscon.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/of_graph.h>
#include <linux/of_platform.h>
#include <linux/pm_runtime.h>
#include <linux/pinctrl/consumer.h>
#include <linux/regmap.h>
#include <linux/dma-buf.h>
#include <linux/highmem.h>
#include <linux/soc/rockchip/rockchip_thunderboot_service.h>
 
#include "rkisp_tb_helper.h"
 
static struct platform_device *rkisp_tb_pdev;
static struct clk_bulk_data *rkisp_tb_clk;
static int rkisp_tb_clk_num;
static struct rk_tb_client tb_cl;
 
struct shm_data {
<------>int npages;
<------>struct page *pages[];
};
 
static struct sg_table *shm_map_dma_buf(struct dma_buf_attachment *attachment,
<------><------><------><------><------>enum dma_data_direction dir)
{
<------>struct shm_data *data = attachment->dmabuf->priv;
<------>struct sg_table *table;
<------>struct scatterlist *sg;
<------>int i;
 
<------>table = kmalloc(sizeof(*table), GFP_KERNEL);
<------>if (!table)
<------><------>return ERR_PTR(-ENOMEM);
 
<------>sg_alloc_table(table, data->npages, GFP_KERNEL);
<------>sg = table->sgl;
<------>for (i = 0; i < data->npages; i++) {
<------><------>sg_set_page(sg, data->pages[i], PAGE_SIZE, 0);
<------><------>sg = sg_next(sg);
<------>}
 
<------>dma_map_sg_attrs(attachment->dev, table->sgl, table->nents, dir, DMA_ATTR_SKIP_CPU_SYNC);
 
<------>return table;
}
 
static void shm_unmap_dma_buf(struct dma_buf_attachment *attachment,
<------><------><------>      struct sg_table *table,
<------><------><------>      enum dma_data_direction dir)
{
<------>dma_unmap_sg(attachment->dev, table->sgl, table->nents, dir);
<------>sg_free_table(table);
<------>kfree(table);
}
 
static void shm_release(struct dma_buf *dma_buf)
{
<------>struct shm_data *data = dma_buf->priv;
 
<------>kfree(data);
}
 
static void *shm_vmap(struct dma_buf *dma_buf)
{
<------>struct shm_data *data = dma_buf->priv;
 
<------>return vm_map_ram(data->pages, data->npages, 0);
}
 
static void shm_vunmap(struct dma_buf *dma_buf, void *vaddr)
{
<------>struct shm_data *data = dma_buf->priv;
 
<------>vm_unmap_ram(vaddr, data->npages);
}
 
static int shm_mmap(struct dma_buf *dma_buf, struct vm_area_struct *vma)
{
<------>struct shm_data *data = dma_buf->priv;
<------>unsigned long vm_start = vma->vm_start;
<------>int i;
 
<------>for (i = 0; i < data->npages; i++) {
<------><------>remap_pfn_range(vma, vm_start, page_to_pfn(data->pages[i]),
<------><------><------><------>PAGE_SIZE, vma->vm_page_prot);
<------><------>vm_start += PAGE_SIZE;
<------>}
 
<------>return 0;
}
 
static int shm_begin_cpu_access(struct dma_buf *dmabuf, enum dma_data_direction dir)
{
<------>struct dma_buf_attachment *attachment;
<------>struct sg_table *table;
 
<------>attachment = list_first_entry(&dmabuf->attachments, struct dma_buf_attachment, node);
<------>table = attachment->priv;
<------>dma_sync_sg_for_cpu(NULL, table->sgl, table->nents, dir);
 
<------>return 0;
}
 
static int shm_end_cpu_access(struct dma_buf *dmabuf, enum dma_data_direction dir)
{
<------>struct dma_buf_attachment *attachment;
<------>struct sg_table *table;
 
<------>attachment = list_first_entry(&dmabuf->attachments, struct dma_buf_attachment, node);
<------>table = attachment->priv;
<------>dma_sync_sg_for_device(NULL, table->sgl, table->nents, dir);
 
<------>return 0;
}
 
static const struct dma_buf_ops shm_dmabuf_ops = {
<------>.map_dma_buf = shm_map_dma_buf,
<------>.unmap_dma_buf = shm_unmap_dma_buf,
<------>.release = shm_release,
<------>.mmap = shm_mmap,
<------>.vmap = shm_vmap,
<------>.vunmap = shm_vunmap,
<------>.begin_cpu_access = shm_begin_cpu_access,
<------>.end_cpu_access = shm_end_cpu_access,
};
 
static struct dma_buf *shm_alloc(struct rkisp_thunderboot_shmem *shmem)
{
<------>DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
<------>struct dma_buf *dmabuf;
<------>struct shm_data *data;
<------>int i, npages;
 
<------>npages = PAGE_ALIGN(shmem->shm_size) / PAGE_SIZE;
<------>data = kmalloc(sizeof(*data) + npages * sizeof(struct page *), GFP_KERNEL);
<------>if (!data)
<------><------>return ERR_PTR(-ENOMEM);
 
<------>data->npages = npages;
<------>for (i = 0; i < npages; i++)
<------><------>data->pages[i] = phys_to_page(shmem->shm_start + i * PAGE_SIZE);
 
<------>exp_info.ops = &shm_dmabuf_ops;
<------>exp_info.size = npages * PAGE_SIZE;
<------>exp_info.flags = O_RDWR;
<------>exp_info.priv = data;
 
<------>dmabuf = dma_buf_export(&exp_info);
 
<------>return dmabuf;
}
 
static int __maybe_unused rkisp_tb_clocks_loader_protect(void)
{
<------>int ret = 0;
 
<------>if (rkisp_tb_pdev) {
<------><------>pm_runtime_enable(&rkisp_tb_pdev->dev);
<------><------>pm_runtime_get_sync(&rkisp_tb_pdev->dev);
<------><------>if (rkisp_tb_clk_num) {
<------><------><------>ret = clk_bulk_prepare_enable(rkisp_tb_clk_num, rkisp_tb_clk);
<------><------><------>if (ret)
<------><------><------><------>dev_err(&rkisp_tb_pdev->dev, "Cannot enable clock\n");
<------><------>}
<------>}
 
<------>return ret;
}
 
static int __maybe_unused rkisp_tb_clocks_loader_unprotect(void)
{
<------>if (rkisp_tb_pdev) {
<------><------>if (rkisp_tb_clk_num)
<------><------><------>clk_bulk_disable_unprepare(rkisp_tb_clk_num, rkisp_tb_clk);
<------><------>pm_runtime_put_sync(&rkisp_tb_pdev->dev);
<------><------>pm_runtime_disable(&rkisp_tb_pdev->dev);
<------>}
<------>return 0;
}
 
static void rkisp_tb_cb(void *data)
{
<------>rkisp_tb_clocks_loader_unprotect();
}
 
static int __maybe_unused rkisp_tb_runtime_suspend(struct device *dev)
{
<------>return 0;
}
 
static int __maybe_unused rkisp_tb_runtime_resume(struct device *dev)
{
<------>return 0;
}
 
static const struct dev_pm_ops rkisp_tb_plat_pm_ops = {
<------>SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
<------><------><------><------>pm_runtime_force_resume)
<------>SET_RUNTIME_PM_OPS(rkisp_tb_runtime_suspend,
<------><------><------>   rkisp_tb_runtime_resume, NULL)
};
 
static const struct of_device_id rkisp_tb_plat_of_match[] = {
<------>{
<------><------>.compatible = "rockchip,thunder-boot-rkisp",
<------>},
<------>{},
};
 
static int rkisp_tb_plat_probe(struct platform_device *pdev)
{
<------>rkisp_tb_pdev = pdev;
<------>rkisp_tb_clk_num = devm_clk_bulk_get_all(&pdev->dev, &rkisp_tb_clk);
<------>if (rkisp_tb_clk_num <= 0) {
<------><------>dev_warn(&pdev->dev, "get clk fail:%d\n", rkisp_tb_clk_num);
<------><------>rkisp_tb_clk_num = 0;
<------>}
<------>rkisp_tb_clocks_loader_protect();
 
<------>if (IS_ENABLED(CONFIG_ROCKCHIP_THUNDER_BOOT_SERVICE)) {
<------><------>tb_cl.cb = rkisp_tb_cb;
<------><------>return rk_tb_client_register_cb(&tb_cl);
<------>}
 
<------>return 0;
}
 
static int rkisp_tb_plat_remove(struct platform_device *pdev)
{
<------>return 0;
}
 
static struct platform_driver __maybe_unused rkisp_tb_plat_drv = {
<------>.driver = {
<------><------>.name = "rkisp_thunderboot",
<------><------>.of_match_table = of_match_ptr(rkisp_tb_plat_of_match),
<------><------>.pm = &rkisp_tb_plat_pm_ops,
<------>},
<------>.probe = rkisp_tb_plat_probe,
<------>.remove = rkisp_tb_plat_remove,
};
 
static int __init rkisp_tb_plat_drv_init(void)
{
<------>return platform_driver_register(&rkisp_tb_plat_drv);
}
 
arch_initcall_sync(rkisp_tb_plat_drv_init);
 
long rkisp_tb_shm_ioctl(struct rkisp_thunderboot_shmem *shmem)
{
<------>struct dma_buf *dmabuf;
<------>int fd, ret;
 
<------>dmabuf = shm_alloc(shmem);
<------>if (IS_ERR(dmabuf)) {
<------><------>ret = PTR_ERR(dmabuf);
<------><------>return ret;
<------>}
 
<------>fd = dma_buf_fd(dmabuf, O_CLOEXEC);
<------>shmem->shm_fd = fd;
 
<------>return 0;
}
 
void rkisp_tb_unprotect_clk(void)
{
<------>if (IS_ENABLED(CONFIG_ROCKCHIP_THUNDER_BOOT_SERVICE))
<------><------>return;
 
<------>rkisp_tb_clocks_loader_unprotect();
}
EXPORT_SYMBOL(rkisp_tb_unprotect_clk);
 
static enum rkisp_tb_state tb_state;
 
void rkisp_tb_set_state(enum rkisp_tb_state result)
{
<------>tb_state = result;
}
EXPORT_SYMBOL(rkisp_tb_set_state);
 
enum rkisp_tb_state rkisp_tb_get_state(void)
{
<------>return tb_state;
}
EXPORT_SYMBOL(rkisp_tb_get_state);