Uncompressed rknpu-driver

This commit is contained in:
Pelochus
2024-04-03 16:02:10 +00:00
parent 3151e60b9a
commit 3cf6203826
24 changed files with 7808 additions and 0 deletions

View File

@@ -0,0 +1,88 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) Rockchip Electronics Co.Ltd
* Author: Felix Zeng <felix.zeng@rock-chips.com>
*/
#ifndef __LINUX_RKNPU_DEBUGGER_H_
#define __LINUX_RKNPU_DEBUGGER_H_
#include <linux/seq_file.h>
/*
* struct rknpu_debugger - rknpu debugger information
*
* This structure represents a debugger to be created by the rknpu driver
* or core.
*/
struct rknpu_debugger {
#ifdef CONFIG_ROCKCHIP_RKNPU_DEBUG_FS
/* Directory of debugfs file */
struct dentry *debugfs_dir;
struct list_head debugfs_entry_list;
struct mutex debugfs_lock;
#endif
#ifdef CONFIG_ROCKCHIP_RKNPU_PROC_FS
/* Directory of procfs file */
struct proc_dir_entry *procfs_dir;
struct list_head procfs_entry_list;
struct mutex procfs_lock;
#endif
};
/*
* struct rknpu_debugger_list - debugfs/procfs info list entry
*
* This structure represents a debugfs/procfs file to be created by the npu
* driver or core.
*/
struct rknpu_debugger_list {
/* File name */
const char *name;
/*
* Show callback. &seq_file->private will be set to the &struct
* rknpu_debugger_node corresponding to the instance of this info
* on a given &struct rknpu_debugger.
*/
int (*show)(struct seq_file *seq, void *data);
/*
* Write callback. &seq_file->private will be set to the &struct
* rknpu_debugger_node corresponding to the instance of this info
* on a given &struct rknpu_debugger.
*/
ssize_t (*write)(struct file *file, const char __user *ubuf, size_t len,
loff_t *offp);
/* Procfs/Debugfs private data. */
void *data;
};
/*
* struct rknpu_debugger_node - Nodes for debugfs/procfs
*
* This structure represents each instance of procfs/debugfs created from the
* template.
*/
struct rknpu_debugger_node {
struct rknpu_debugger *debugger;
/* template for this node. */
const struct rknpu_debugger_list *info_ent;
/* Each Procfs/Debugfs file. */
#ifdef CONFIG_ROCKCHIP_RKNPU_DEBUG_FS
struct dentry *dent;
#endif
#ifdef CONFIG_ROCKCHIP_RKNPU_PROC_FS
struct proc_dir_entry *pent;
#endif
struct list_head list;
};
struct rknpu_device;
int rknpu_debugger_init(struct rknpu_device *rknpu_dev);
int rknpu_debugger_remove(struct rknpu_device *rknpu_dev);
#endif /* __LINUX_RKNPU_FENCE_H_ */

View File

@@ -0,0 +1,46 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) Rockchip Electronics Co.Ltd
* Author: Finley Xiao <finley.xiao@rock-chips.com>
*/
#ifndef __LINUX_RKNPU_DEVFREQ_H
#define __LINUX_RKNPU_DEVFREQ_H
#ifdef CONFIG_PM_DEVFREQ
void rknpu_devfreq_lock(struct rknpu_device *rknpu_dev);
void rknpu_devfreq_unlock(struct rknpu_device *rknpu_dev);
int rknpu_devfreq_init(struct rknpu_device *rknpu_dev);
void rknpu_devfreq_remove(struct rknpu_device *rknpu_dev);
int rknpu_devfreq_runtime_suspend(struct device *dev);
int rknpu_devfreq_runtime_resume(struct device *dev);
#else
static inline int rknpu_devfreq_init(struct rknpu_device *rknpu_dev)
{
return -EOPNOTSUPP;
}
static inline void rknpu_devfreq_remove(struct rknpu_device *rknpu_dev)
{
}
static inline void rknpu_devfreq_lock(struct rknpu_device *rknpu_dev)
{
}
static inline void rknpu_devfreq_unlock(struct rknpu_device *rknpu_dev)
{
}
static inline int rknpu_devfreq_runtime_suspend(struct device *dev)
{
return -EOPNOTSUPP;
}
static inline int rknpu_devfreq_runtime_resume(struct device *dev)
{
return -EOPNOTSUPP;
}
#endif /* CONFIG_PM_DEVFREQ */
#endif /* __LINUX_RKNPU_DEVFREQ_H_ */

View File

@@ -0,0 +1,183 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) Rockchip Electronics Co.Ltd
* Author: Felix Zeng <felix.zeng@rock-chips.com>
*/
#ifndef __LINUX_RKNPU_DRV_H_
#define __LINUX_RKNPU_DRV_H_
#include <linux/completion.h>
#include <linux/device.h>
#include <linux/kref.h>
#include <linux/irq.h>
#include <linux/platform_device.h>
#include <linux/spinlock.h>
#include <linux/regulator/consumer.h>
#include <linux/version.h>
#include <linux/hrtimer.h>
#include <linux/miscdevice.h>
#include <soc/rockchip/rockchip_opp_select.h>
#include <soc/rockchip/rockchip_system_monitor.h>
#include <soc/rockchip/rockchip_ipa.h>
#include "rknpu_job.h"
#include "rknpu_fence.h"
#include "rknpu_debugger.h"
#include "rknpu_mm.h"
#define DRIVER_NAME "rknpu"
#define DRIVER_DESC "RKNPU driver"
#define DRIVER_DATE "20240322"
#define DRIVER_MAJOR 0
#define DRIVER_MINOR 9
#define DRIVER_PATCHLEVEL 6
#define LOG_TAG "RKNPU"
/* sample interval: 1000ms */
#define RKNPU_LOAD_INTERVAL 1000000000
#define LOG_INFO(fmt, args...) pr_info(LOG_TAG ": " fmt, ##args)
#if KERNEL_VERSION(5, 5, 0) <= LINUX_VERSION_CODE
#define LOG_WARN(fmt, args...) pr_warn(LOG_TAG ": " fmt, ##args)
#else
#define LOG_WARN(fmt, args...) pr_warning(LOG_TAG ": " fmt, ##args)
#endif
#define LOG_DEBUG(fmt, args...) pr_devel(LOG_TAG ": " fmt, ##args)
#define LOG_ERROR(fmt, args...) pr_err(LOG_TAG ": " fmt, ##args)
#define LOG_DEV_INFO(dev, fmt, args...) dev_info(dev, LOG_TAG ": " fmt, ##args)
#define LOG_DEV_WARN(dev, fmt, args...) dev_warn(dev, LOG_TAG ": " fmt, ##args)
#define LOG_DEV_DEBUG(dev, fmt, args...) dev_dbg(dev, LOG_TAG ": " fmt, ##args)
#define LOG_DEV_ERROR(dev, fmt, args...) dev_err(dev, LOG_TAG ": " fmt, ##args)
#define RKNPU_MAX_IOMMU_DOMAIN_NUM 16
struct rknpu_irqs_data {
const char *name;
irqreturn_t (*irq_hdl)(int irq, void *ctx);
};
struct rknpu_amount_data {
uint16_t offset_clr_all;
uint16_t offset_dt_wr;
uint16_t offset_dt_rd;
uint16_t offset_wt_rd;
};
struct rknpu_config {
__u32 bw_priority_addr;
__u32 bw_priority_length;
__u64 dma_mask;
__u32 pc_data_amount_scale;
__u32 pc_task_number_bits;
__u32 pc_task_number_mask;
__u32 pc_task_status_offset;
__u32 pc_dma_ctrl;
const struct rknpu_irqs_data *irqs;
int num_irqs;
__u64 nbuf_phyaddr;
__u64 nbuf_size;
__u64 max_submit_number;
__u32 core_mask;
const struct rknpu_amount_data *amount_top;
const struct rknpu_amount_data *amount_core;
};
struct rknpu_timer {
ktime_t busy_time;
ktime_t total_busy_time;
};
struct rknpu_subcore_data {
struct list_head todo_list;
wait_queue_head_t job_done_wq;
struct rknpu_job *job;
int64_t task_num;
struct rknpu_timer timer;
};
/**
* RKNPU device
*
* @base: IO mapped base address for device
* @dev: Device instance
* @drm_dev: DRM device instance
*/
struct rknpu_device {
void __iomem *base[RKNPU_MAX_CORES];
struct device *dev;
#ifdef CONFIG_ROCKCHIP_RKNPU_DRM_GEM
struct device *fake_dev;
struct drm_device *drm_dev;
#endif
#ifdef CONFIG_ROCKCHIP_RKNPU_DMA_HEAP
struct miscdevice miscdev;
struct rk_dma_heap *heap;
#endif
atomic_t sequence;
spinlock_t lock;
spinlock_t irq_lock;
struct mutex power_lock;
struct mutex reset_lock;
struct mutex domain_lock;
struct rknpu_subcore_data subcore_datas[RKNPU_MAX_CORES];
const struct rknpu_config *config;
void __iomem *bw_priority_base;
struct rknpu_fence_context *fence_ctx;
bool iommu_en;
struct reset_control **srsts;
int num_srsts;
struct clk_bulk_data *clks;
int num_clks;
struct regulator *vdd;
struct regulator *mem;
struct monitor_dev_info *mdev_info;
struct ipa_power_model_data *model_data;
struct thermal_cooling_device *devfreq_cooling;
struct devfreq *devfreq;
unsigned long ondemand_freq;
struct rockchip_opp_info opp_info;
unsigned long current_freq;
unsigned long current_volt;
int bypass_irq_handler;
int bypass_soft_reset;
bool soft_reseting;
struct device *genpd_dev_npu0;
struct device *genpd_dev_npu1;
struct device *genpd_dev_npu2;
bool multiple_domains;
atomic_t power_refcount;
atomic_t cmdline_power_refcount;
struct delayed_work power_off_work;
struct workqueue_struct *power_off_wq;
struct rknpu_debugger debugger;
struct hrtimer timer;
ktime_t kt;
phys_addr_t sram_start;
phys_addr_t sram_end;
phys_addr_t nbuf_start;
phys_addr_t nbuf_end;
uint32_t sram_size;
uint32_t nbuf_size;
void __iomem *sram_base_io;
void __iomem *nbuf_base_io;
struct rknpu_mm *sram_mm;
unsigned long power_put_delay;
struct iommu_group *iommu_group;
int iommu_domain_num;
int iommu_domain_id;
struct iommu_domain *iommu_domains[RKNPU_MAX_IOMMU_DOMAIN_NUM];
};
struct rknpu_session {
struct rknpu_device *rknpu_dev;
struct list_head list;
};
int rknpu_power_get(struct rknpu_device *rknpu_dev);
int rknpu_power_put(struct rknpu_device *rknpu_dev);
#endif /* __LINUX_RKNPU_DRV_H_ */

View File

@@ -0,0 +1,24 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) Rockchip Electronics Co.Ltd
* Author: Felix Zeng <felix.zeng@rock-chips.com>
*/
#ifndef __LINUX_RKNPU_FENCE_H_
#define __LINUX_RKNPU_FENCE_H_
#include "rknpu_job.h"
struct rknpu_fence_context {
unsigned int context;
unsigned int seqno;
spinlock_t spinlock;
};
int rknpu_fence_context_alloc(struct rknpu_device *rknpu_dev);
int rknpu_fence_alloc(struct rknpu_job *job);
int rknpu_fence_get_fd(struct rknpu_job *job);
#endif /* __LINUX_RKNPU_FENCE_H_ */

View File

@@ -0,0 +1,215 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) Rockchip Electronics Co.Ltd
* Author: Felix Zeng <felix.zeng@rock-chips.com>
*/
#ifndef __LINUX_RKNPU_GEM_H
#define __LINUX_RKNPU_GEM_H
#include <linux/mm_types.h>
#include <linux/version.h>
#include <drm/drm_device.h>
#include <drm/drm_vma_manager.h>
#include <drm/drm_gem.h>
#include <drm/drm_mode.h>
#if KERNEL_VERSION(4, 14, 0) > LINUX_VERSION_CODE
#include <drm/drm_mem_util.h>
#endif
#include "rknpu_mm.h"
#define to_rknpu_obj(x) container_of(x, struct rknpu_gem_object, base)
/*
* rknpu drm buffer structure.
*
* @base: a gem object.
* - a new handle to this gem object would be created
* by drm_gem_handle_create().
* @flags: indicate memory type to allocated buffer and cache attribute.
* @size: size requested from user, in bytes and this size is aligned
* in page unit.
* @cookie: cookie returned by dma_alloc_attrs
* @kv_addr: kernel virtual address to allocated memory region.
* @dma_addr: bus address(accessed by dma) to allocated memory region.
* - this address could be physical address without IOMMU and
* device address with IOMMU.
* @pages: Array of backing pages.
* @sgt: Imported sg_table.
*
* P.S. this object would be transferred to user as kms_bo.handle so
* user can access the buffer through kms_bo.handle.
*/
struct rknpu_gem_object {
struct drm_gem_object base;
unsigned int flags;
unsigned long size;
unsigned long sram_size;
unsigned long nbuf_size;
struct rknpu_mm_obj *sram_obj;
dma_addr_t iova_start;
unsigned long iova_size;
void *cookie;
void __iomem *kv_addr;
dma_addr_t dma_addr;
unsigned long dma_attrs;
unsigned long num_pages;
struct page **pages;
struct sg_table *sgt;
struct drm_mm_node mm_node;
int iommu_domain_id;
};
enum rknpu_cache_type {
RKNPU_CACHE_SRAM = 1 << 0,
RKNPU_CACHE_NBUF = 1 << 1,
};
/* create a new buffer with gem object */
struct rknpu_gem_object *rknpu_gem_object_create(struct drm_device *dev,
unsigned int flags,
unsigned long size,
unsigned long sram_size,
int iommu_domain_id);
/* destroy a buffer with gem object */
void rknpu_gem_object_destroy(struct rknpu_gem_object *rknpu_obj);
/* request gem object creation and buffer allocation as the size */
int rknpu_gem_create_ioctl(struct drm_device *dev, void *data,
struct drm_file *file_priv);
/* get fake-offset of gem object that can be used with mmap. */
int rknpu_gem_map_ioctl(struct drm_device *dev, void *data,
struct drm_file *file_priv);
int rknpu_gem_destroy_ioctl(struct drm_device *dev, void *data,
struct drm_file *file_priv);
/*
* get rknpu drm object,
* gem object reference count would be increased.
*/
static inline void rknpu_gem_object_get(struct drm_gem_object *obj)
{
#if KERNEL_VERSION(4, 13, 0) < LINUX_VERSION_CODE
drm_gem_object_get(obj);
#else
drm_gem_object_reference(obj);
#endif
}
/*
* put rknpu drm object acquired from rknpu_gem_object_find() or rknpu_gem_object_get(),
* gem object reference count would be decreased.
*/
static inline void rknpu_gem_object_put(struct drm_gem_object *obj)
{
#if KERNEL_VERSION(5, 9, 0) <= LINUX_VERSION_CODE
drm_gem_object_put(obj);
#elif KERNEL_VERSION(4, 13, 0) < LINUX_VERSION_CODE
drm_gem_object_put_unlocked(obj);
#else
drm_gem_object_unreference_unlocked(obj);
#endif
}
/*
* get rknpu drm object from gem handle, this function could be used for
* other drivers such as 2d/3d acceleration drivers.
* with this function call, gem object reference count would be increased.
*/
static inline struct rknpu_gem_object *
rknpu_gem_object_find(struct drm_file *filp, unsigned int handle)
{
struct drm_gem_object *obj;
obj = drm_gem_object_lookup(filp, handle);
if (!obj) {
// DRM_ERROR("failed to lookup gem object.\n");
return NULL;
}
rknpu_gem_object_put(obj);
return to_rknpu_obj(obj);
}
/* get buffer information to memory region allocated by gem. */
int rknpu_gem_get_ioctl(struct drm_device *dev, void *data,
struct drm_file *file_priv);
/* free gem object. */
void rknpu_gem_free_object(struct drm_gem_object *obj);
/* create memory region for drm framebuffer. */
int rknpu_gem_dumb_create(struct drm_file *file_priv, struct drm_device *dev,
struct drm_mode_create_dumb *args);
#if KERNEL_VERSION(4, 19, 0) > LINUX_VERSION_CODE
/* map memory region for drm framebuffer to user space. */
int rknpu_gem_dumb_map_offset(struct drm_file *file_priv,
struct drm_device *dev, uint32_t handle,
uint64_t *offset);
#endif
/* page fault handler and mmap fault address(virtual) to physical memory. */
#if KERNEL_VERSION(4, 15, 0) <= LINUX_VERSION_CODE
vm_fault_t rknpu_gem_fault(struct vm_fault *vmf);
#elif KERNEL_VERSION(4, 14, 0) <= LINUX_VERSION_CODE
int rknpu_gem_fault(struct vm_fault *vmf);
#else
int rknpu_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf);
#endif
int rknpu_gem_mmap_obj(struct drm_gem_object *obj, struct vm_area_struct *vma);
/* set vm_flags and we can change the vm attribute to other one at here. */
int rknpu_gem_mmap(struct file *filp, struct vm_area_struct *vma);
/* low-level interface prime helpers */
#if KERNEL_VERSION(4, 13, 0) <= LINUX_VERSION_CODE
struct drm_gem_object *rknpu_gem_prime_import(struct drm_device *dev,
struct dma_buf *dma_buf);
#endif
struct sg_table *rknpu_gem_prime_get_sg_table(struct drm_gem_object *obj);
struct drm_gem_object *
rknpu_gem_prime_import_sg_table(struct drm_device *dev,
struct dma_buf_attachment *attach,
struct sg_table *sgt);
#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
void *rknpu_gem_prime_vmap(struct drm_gem_object *obj);
void rknpu_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr);
#else
int rknpu_gem_prime_vmap(struct drm_gem_object *obj, struct iosys_map *map);
void rknpu_gem_prime_vunmap(struct drm_gem_object *obj, struct iosys_map *map);
#endif
int rknpu_gem_prime_mmap(struct drm_gem_object *obj,
struct vm_area_struct *vma);
int rknpu_gem_sync_ioctl(struct drm_device *dev, void *data,
struct drm_file *file_priv);
static inline void *rknpu_gem_alloc_page(size_t nr_pages)
{
#if KERNEL_VERSION(4, 13, 0) <= LINUX_VERSION_CODE
return kvmalloc_array(nr_pages, sizeof(struct page *),
GFP_KERNEL | __GFP_ZERO);
#else
return drm_calloc_large(nr_pages, sizeof(struct page *));
#endif
}
static inline void rknpu_gem_free_page(void *pages)
{
#if KERNEL_VERSION(4, 13, 0) <= LINUX_VERSION_CODE
kvfree(pages);
#else
drm_free_large(pages);
#endif
}
#endif

View File

@@ -0,0 +1,327 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) Rockchip Electronics Co.Ltd
* Author: Felix Zeng <felix.zeng@rock-chips.com>
*/
#ifndef __LINUX_RKNPU_IOCTL_H
#define __LINUX_RKNPU_IOCTL_H
#include <linux/ioctl.h>
#include <linux/types.h>
#if !defined(__KERNEL__)
#define __user
#endif
#ifndef __packed
#define __packed __attribute__((packed))
#endif
#define RKNPU_OFFSET_VERSION 0x0
#define RKNPU_OFFSET_VERSION_NUM 0x4
#define RKNPU_OFFSET_PC_OP_EN 0x8
#define RKNPU_OFFSET_PC_DATA_ADDR 0x10
#define RKNPU_OFFSET_PC_DATA_AMOUNT 0x14
#define RKNPU_OFFSET_PC_TASK_CONTROL 0x30
#define RKNPU_OFFSET_PC_DMA_BASE_ADDR 0x34
#define RKNPU_OFFSET_INT_MASK 0x20
#define RKNPU_OFFSET_INT_CLEAR 0x24
#define RKNPU_OFFSET_INT_STATUS 0x28
#define RKNPU_OFFSET_INT_RAW_STATUS 0x2c
#define RKNPU_OFFSET_ENABLE_MASK 0xf008
#define RKNPU_INT_CLEAR 0x1ffff
#define RKNPU_PC_DATA_EXTRA_AMOUNT 4
#define RKNPU_STR_HELPER(x) #x
#define RKNPU_GET_DRV_VERSION_STRING(MAJOR, MINOR, PATCHLEVEL) \
RKNPU_STR_HELPER(MAJOR) \
"." RKNPU_STR_HELPER(MINOR) "." RKNPU_STR_HELPER(PATCHLEVEL)
#define RKNPU_GET_DRV_VERSION_CODE(MAJOR, MINOR, PATCHLEVEL) \
(MAJOR * 10000 + MINOR * 100 + PATCHLEVEL)
#define RKNPU_GET_DRV_VERSION_MAJOR(CODE) (CODE / 10000)
#define RKNPU_GET_DRV_VERSION_MINOR(CODE) ((CODE % 10000) / 100)
#define RKNPU_GET_DRV_VERSION_PATCHLEVEL(CODE) (CODE % 100)
/* memory type definitions. */
enum e_rknpu_mem_type {
/* physically continuous memory and used as default. */
RKNPU_MEM_CONTIGUOUS = 0 << 0,
/* physically non-continuous memory. */
RKNPU_MEM_NON_CONTIGUOUS = 1 << 0,
/* non-cacheable mapping and used as default. */
RKNPU_MEM_NON_CACHEABLE = 0 << 1,
/* cacheable mapping. */
RKNPU_MEM_CACHEABLE = 1 << 1,
/* write-combine mapping. */
RKNPU_MEM_WRITE_COMBINE = 1 << 2,
/* dma attr kernel mapping */
RKNPU_MEM_KERNEL_MAPPING = 1 << 3,
/* iommu mapping */
RKNPU_MEM_IOMMU = 1 << 4,
/* zero mapping */
RKNPU_MEM_ZEROING = 1 << 5,
/* allocate secure buffer */
RKNPU_MEM_SECURE = 1 << 6,
/* allocate from dma32 zone */
RKNPU_MEM_DMA32 = 1 << 7,
/* request SRAM */
RKNPU_MEM_TRY_ALLOC_SRAM = 1 << 8,
/* request NBUF */
RKNPU_MEM_TRY_ALLOC_NBUF = 1 << 9,
RKNPU_MEM_MASK = RKNPU_MEM_NON_CONTIGUOUS | RKNPU_MEM_CACHEABLE |
RKNPU_MEM_WRITE_COMBINE | RKNPU_MEM_KERNEL_MAPPING |
RKNPU_MEM_IOMMU | RKNPU_MEM_ZEROING |
RKNPU_MEM_SECURE | RKNPU_MEM_DMA32 |
RKNPU_MEM_TRY_ALLOC_SRAM | RKNPU_MEM_TRY_ALLOC_NBUF
};
/* sync mode definitions. */
enum e_rknpu_mem_sync_mode {
RKNPU_MEM_SYNC_TO_DEVICE = 1 << 0,
RKNPU_MEM_SYNC_FROM_DEVICE = 1 << 1,
RKNPU_MEM_SYNC_MASK =
RKNPU_MEM_SYNC_TO_DEVICE | RKNPU_MEM_SYNC_FROM_DEVICE
};
/* job mode definitions. */
enum e_rknpu_job_mode {
RKNPU_JOB_SLAVE = 0 << 0,
RKNPU_JOB_PC = 1 << 0,
RKNPU_JOB_BLOCK = 0 << 1,
RKNPU_JOB_NONBLOCK = 1 << 1,
RKNPU_JOB_PINGPONG = 1 << 2,
RKNPU_JOB_FENCE_IN = 1 << 3,
RKNPU_JOB_FENCE_OUT = 1 << 4,
RKNPU_JOB_MASK = RKNPU_JOB_PC | RKNPU_JOB_NONBLOCK |
RKNPU_JOB_PINGPONG | RKNPU_JOB_FENCE_IN |
RKNPU_JOB_FENCE_OUT
};
/* action definitions */
enum e_rknpu_action {
RKNPU_GET_HW_VERSION = 0,
RKNPU_GET_DRV_VERSION = 1,
RKNPU_GET_FREQ = 2,
RKNPU_SET_FREQ = 3,
RKNPU_GET_VOLT = 4,
RKNPU_SET_VOLT = 5,
RKNPU_ACT_RESET = 6,
RKNPU_GET_BW_PRIORITY = 7,
RKNPU_SET_BW_PRIORITY = 8,
RKNPU_GET_BW_EXPECT = 9,
RKNPU_SET_BW_EXPECT = 10,
RKNPU_GET_BW_TW = 11,
RKNPU_SET_BW_TW = 12,
RKNPU_ACT_CLR_TOTAL_RW_AMOUNT = 13,
RKNPU_GET_DT_WR_AMOUNT = 14,
RKNPU_GET_DT_RD_AMOUNT = 15,
RKNPU_GET_WT_RD_AMOUNT = 16,
RKNPU_GET_TOTAL_RW_AMOUNT = 17,
RKNPU_GET_IOMMU_EN = 18,
RKNPU_SET_PROC_NICE = 19,
RKNPU_POWER_ON = 20,
RKNPU_POWER_OFF = 21,
RKNPU_GET_TOTAL_SRAM_SIZE = 22,
RKNPU_GET_FREE_SRAM_SIZE = 23,
RKNPU_GET_IOMMU_DOMAIN_ID = 24,
RKNPU_SET_IOMMU_DOMAIN_ID = 25,
};
/**
* User-desired buffer creation information structure.
*
* @handle: The handle of the created GEM object.
* @flags: user request for setting memory type or cache attributes.
* @size: user-desired memory allocation size.
* - this size value would be page-aligned internally.
* @obj_addr: address of RKNPU memory object.
* @dma_addr: dma address that access by rknpu.
* @sram_size: user-desired sram memory allocation size.
* - this size value would be page-aligned internally.
* @iommu_domain_id: iommu domain id
* @reserved: just padding to be 64-bit aligned.
*/
struct rknpu_mem_create {
__u32 handle;
__u32 flags;
__u64 size;
__u64 obj_addr;
__u64 dma_addr;
__u64 sram_size;
__s32 iommu_domain_id;
__u32 reserved;
};
/**
* A structure for getting a fake-offset that can be used with mmap.
*
* @handle: handle of gem object.
* @reserved: just padding to be 64-bit aligned.
* @offset: a fake-offset of gem object.
*/
struct rknpu_mem_map {
__u32 handle;
__u32 reserved;
__u64 offset;
};
/**
* For destroying DMA buffer
*
* @handle: handle of the buffer.
* @reserved: reserved for padding.
* @obj_addr: rknpu_mem_object addr.
*/
struct rknpu_mem_destroy {
__u32 handle;
__u32 reserved;
__u64 obj_addr;
};
/**
* For synchronizing DMA buffer
*
* @flags: user request for setting memory type or cache attributes.
* @reserved: reserved for padding.
* @obj_addr: address of RKNPU memory object.
* @offset: offset in bytes from start address of buffer.
* @size: size of memory region.
*
*/
struct rknpu_mem_sync {
__u32 flags;
__u32 reserved;
__u64 obj_addr;
__u64 offset;
__u64 size;
};
/**
* struct rknpu_task structure for task information
*
* @flags: flags for task
* @op_idx: operator index
* @enable_mask: enable mask
* @int_mask: interrupt mask
* @int_clear: interrupt clear
* @int_status: interrupt status
* @regcfg_amount: register config number
* @regcfg_offset: offset for register config
* @regcmd_addr: address for register command
*
*/
struct rknpu_task {
__u32 flags;
__u32 op_idx;
__u32 enable_mask;
__u32 int_mask;
__u32 int_clear;
__u32 int_status;
__u32 regcfg_amount;
__u32 regcfg_offset;
__u64 regcmd_addr;
} __packed;
/**
* struct rknpu_subcore_task structure for subcore task index
*
* @task_start: task start index
* @task_number: task number
*
*/
struct rknpu_subcore_task {
__u32 task_start;
__u32 task_number;
};
/**
* struct rknpu_submit structure for job submit
*
* @flags: flags for job submit
* @timeout: submit timeout
* @task_start: task start index
* @task_number: task number
* @task_counter: task counter
* @priority: submit priority
* @task_obj_addr: address of task object
* @iommu_domain_id: iommu domain id
* @reserved: just padding to be 64-bit aligned.
* @task_base_addr: task base address
* @hw_elapse_time: hardware elapse time
* @core_mask: core mask of rknpu
* @fence_fd: dma fence fd
* @subcore_task: subcore task
*
*/
struct rknpu_submit {
__u32 flags;
__u32 timeout;
__u32 task_start;
__u32 task_number;
__u32 task_counter;
__s32 priority;
__u64 task_obj_addr;
__u32 iommu_domain_id;
__u32 reserved;
__u64 task_base_addr;
__s64 hw_elapse_time;
__u32 core_mask;
__s32 fence_fd;
struct rknpu_subcore_task subcore_task[5];
};
/**
* struct rknpu_task structure for action (GET, SET or ACT)
*
* @flags: flags for action
* @value: GET or SET value
*
*/
struct rknpu_action {
__u32 flags;
__u32 value;
};
#define RKNPU_ACTION 0x00
#define RKNPU_SUBMIT 0x01
#define RKNPU_MEM_CREATE 0x02
#define RKNPU_MEM_MAP 0x03
#define RKNPU_MEM_DESTROY 0x04
#define RKNPU_MEM_SYNC 0x05
#define RKNPU_IOC_MAGIC 'r'
#define RKNPU_IOW(nr, type) _IOW(RKNPU_IOC_MAGIC, nr, type)
#define RKNPU_IOR(nr, type) _IOR(RKNPU_IOC_MAGIC, nr, type)
#define RKNPU_IOWR(nr, type) _IOWR(RKNPU_IOC_MAGIC, nr, type)
#include <drm/drm.h>
#define DRM_IOCTL_RKNPU_ACTION \
DRM_IOWR(DRM_COMMAND_BASE + RKNPU_ACTION, struct rknpu_action)
#define DRM_IOCTL_RKNPU_SUBMIT \
DRM_IOWR(DRM_COMMAND_BASE + RKNPU_SUBMIT, struct rknpu_submit)
#define DRM_IOCTL_RKNPU_MEM_CREATE \
DRM_IOWR(DRM_COMMAND_BASE + RKNPU_MEM_CREATE, struct rknpu_mem_create)
#define DRM_IOCTL_RKNPU_MEM_MAP \
DRM_IOWR(DRM_COMMAND_BASE + RKNPU_MEM_MAP, struct rknpu_mem_map)
#define DRM_IOCTL_RKNPU_MEM_DESTROY \
DRM_IOWR(DRM_COMMAND_BASE + RKNPU_MEM_DESTROY, struct rknpu_mem_destroy)
#define DRM_IOCTL_RKNPU_MEM_SYNC \
DRM_IOWR(DRM_COMMAND_BASE + RKNPU_MEM_SYNC, struct rknpu_mem_sync)
#define IOCTL_RKNPU_ACTION RKNPU_IOWR(RKNPU_ACTION, struct rknpu_action)
#define IOCTL_RKNPU_SUBMIT RKNPU_IOWR(RKNPU_SUBMIT, struct rknpu_submit)
#define IOCTL_RKNPU_MEM_CREATE \
RKNPU_IOWR(RKNPU_MEM_CREATE, struct rknpu_mem_create)
#define IOCTL_RKNPU_MEM_MAP RKNPU_IOWR(RKNPU_MEM_MAP, struct rknpu_mem_map)
#define IOCTL_RKNPU_MEM_DESTROY \
RKNPU_IOWR(RKNPU_MEM_DESTROY, struct rknpu_mem_destroy)
#define IOCTL_RKNPU_MEM_SYNC RKNPU_IOWR(RKNPU_MEM_SYNC, struct rknpu_mem_sync)
#endif

View File

@@ -0,0 +1,48 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) Rockchip Electronics Co.Ltd
* Author: Felix Zeng <felix.zeng@rock-chips.com>
*/
#ifndef __LINUX_RKNPU_IOMMU_H
#define __LINUX_RKNPU_IOMMU_H
#include <linux/mutex.h>
#include <linux/seq_file.h>
#include <linux/iommu.h>
#include <linux/iova.h>
#include <linux/version.h>
#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
#include <linux/dma-iommu.h>
#endif
#include "rknpu_drv.h"
enum iommu_dma_cookie_type {
IOMMU_DMA_IOVA_COOKIE,
IOMMU_DMA_MSI_COOKIE,
};
struct rknpu_iommu_dma_cookie {
enum iommu_dma_cookie_type type;
/* Full allocator for IOMMU_DMA_IOVA_COOKIE */
struct iova_domain iovad;
};
dma_addr_t rknpu_iommu_dma_alloc_iova(struct iommu_domain *domain, size_t size,
u64 dma_limit, struct device *dev);
void rknpu_iommu_dma_free_iova(struct rknpu_iommu_dma_cookie *cookie,
dma_addr_t iova, size_t size);
int rknpu_iommu_init_domain(struct rknpu_device *rknpu_dev);
int rknpu_iommu_switch_domain(struct rknpu_device *rknpu_dev, int domain_id);
void rknpu_iommu_free_domains(struct rknpu_device *rknpu_dev);
#if KERNEL_VERSION(5, 10, 0) < LINUX_VERSION_CODE
int iommu_get_dma_cookie(struct iommu_domain *domain);
#endif
#endif

View File

@@ -0,0 +1,81 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) Rockchip Electronics Co.Ltd
* Author: Felix Zeng <felix.zeng@rock-chips.com>
*/
#ifndef __LINUX_RKNPU_JOB_H_
#define __LINUX_RKNPU_JOB_H_
#include <linux/spinlock.h>
#include <linux/dma-fence.h>
#include <linux/irq.h>
#include <drm/drm_device.h>
#include "rknpu_ioctl.h"
#define RKNPU_MAX_CORES 3
#define RKNPU_JOB_DONE (1 << 0)
#define RKNPU_JOB_ASYNC (1 << 1)
#define RKNPU_JOB_DETACHED (1 << 2)
#define RKNPU_CORE_AUTO_MASK 0x00
#define RKNPU_CORE0_MASK 0x01
#define RKNPU_CORE1_MASK 0x02
#define RKNPU_CORE2_MASK 0x04
struct rknpu_job {
struct rknpu_device *rknpu_dev;
struct list_head head[RKNPU_MAX_CORES];
struct work_struct cleanup_work;
bool irq_entry[RKNPU_MAX_CORES];
unsigned int flags;
int ret;
struct rknpu_submit *args;
bool args_owner;
struct rknpu_task *first_task;
struct rknpu_task *last_task;
uint32_t int_mask[RKNPU_MAX_CORES];
uint32_t int_status[RKNPU_MAX_CORES];
struct dma_fence *fence;
ktime_t timestamp;
uint32_t use_core_num;
atomic_t run_count;
atomic_t interrupt_count;
ktime_t hw_commit_time;
ktime_t hw_recoder_time;
ktime_t hw_elapse_time;
atomic_t submit_count[RKNPU_MAX_CORES];
int iommu_domain_id;
};
irqreturn_t rknpu_core0_irq_handler(int irq, void *data);
irqreturn_t rknpu_core1_irq_handler(int irq, void *data);
irqreturn_t rknpu_core2_irq_handler(int irq, void *data);
#ifdef CONFIG_ROCKCHIP_RKNPU_DRM_GEM
int rknpu_submit_ioctl(struct drm_device *dev, void *data,
struct drm_file *file_priv);
#endif
#ifdef CONFIG_ROCKCHIP_RKNPU_DMA_HEAP
int rknpu_submit_ioctl(struct rknpu_device *rknpu_dev, unsigned long data);
#endif
int rknpu_get_hw_version(struct rknpu_device *rknpu_dev, uint32_t *version);
int rknpu_get_bw_priority(struct rknpu_device *rknpu_dev, uint32_t *priority,
uint32_t *expect, uint32_t *tw);
int rknpu_set_bw_priority(struct rknpu_device *rknpu_dev, uint32_t priority,
uint32_t expect, uint32_t tw);
int rknpu_clear_rw_amount(struct rknpu_device *rknpu_dev);
int rknpu_get_rw_amount(struct rknpu_device *rknpu_dev, uint32_t *dt_wr,
uint32_t *dt_rd, uint32_t *wd_rd);
int rknpu_get_total_rw_amount(struct rknpu_device *rknpu_dev, uint32_t *amount);
#endif /* __LINUX_RKNPU_JOB_H_ */

View File

@@ -0,0 +1,46 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) Rockchip Electronics Co.Ltd
* Author: Felix Zeng <felix.zeng@rock-chips.com>
*/
#ifndef __LINUX_RKNPU_MEM_H
#define __LINUX_RKNPU_MEM_H
#include <linux/mm_types.h>
#include <linux/version.h>
/*
* rknpu DMA buffer structure.
*
* @flags: indicate memory type to allocated buffer and cache attribute.
* @size: size requested from user, in bytes and this size is aligned
* in page unit.
* @kv_addr: kernel virtual address to allocated memory region.
* @dma_addr: bus address(accessed by dma) to allocated memory region.
* - this address could be physical address without IOMMU and
* device address with IOMMU.
* @pages: Array of backing pages.
* @sgt: Imported sg_table.
* @dmabuf: buffer for this attachment.
* @owner: Is this memory internally allocated.
*/
struct rknpu_mem_object {
unsigned long flags;
unsigned long size;
void __iomem *kv_addr;
dma_addr_t dma_addr;
struct page **pages;
struct sg_table *sgt;
struct dma_buf *dmabuf;
struct list_head head;
unsigned int owner;
};
int rknpu_mem_create_ioctl(struct rknpu_device *rknpu_dev, struct file *file,
unsigned int cmd, unsigned long data);
int rknpu_mem_destroy_ioctl(struct rknpu_device *rknpu_dev, struct file *file,
unsigned long data);
int rknpu_mem_sync_ioctl(struct rknpu_device *rknpu_dev, unsigned long data);
#endif

View File

@@ -0,0 +1,42 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) Rockchip Electronics Co.Ltd
* Author: Felix Zeng <felix.zeng@rock-chips.com>
*/
#ifndef __LINUX_RKNPU_MM_H
#define __LINUX_RKNPU_MM_H
#include <linux/mutex.h>
#include <linux/seq_file.h>
#include <linux/iommu.h>
#include <linux/iova.h>
#include "rknpu_drv.h"
struct rknpu_mm {
void *bitmap;
struct mutex lock;
unsigned int chunk_size;
unsigned int total_chunks;
unsigned int free_chunks;
};
struct rknpu_mm_obj {
uint32_t range_start;
uint32_t range_end;
};
int rknpu_mm_create(unsigned int mem_size, unsigned int chunk_size,
struct rknpu_mm **mm);
void rknpu_mm_destroy(struct rknpu_mm *mm);
int rknpu_mm_alloc(struct rknpu_mm *mm, unsigned int size,
struct rknpu_mm_obj **mm_obj);
int rknpu_mm_free(struct rknpu_mm *mm, struct rknpu_mm_obj *mm_obj);
int rknpu_mm_dump(struct seq_file *m, void *data);
#endif

View File

@@ -0,0 +1,18 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) Rockchip Electronics Co.Ltd
* Author: Felix Zeng <felix.zeng@rock-chips.com>
*/
#ifndef __LINUX_RKNPU_RESET_H
#define __LINUX_RKNPU_RESET_H
#include <linux/reset.h>
#include "rknpu_drv.h"
int rknpu_reset_get(struct rknpu_device *rknpu_dev);
int rknpu_soft_reset(struct rknpu_device *rknpu_dev);
#endif