|
|
@@ -0,0 +1,237 @@
|
|
|
+/* Copyright (c) 2023, Canaan Bright Sight Co., Ltd
|
|
|
+ *
|
|
|
+ * Redistribution and use in source and binary forms, with or without
|
|
|
+ * modification, are permitted provided that the following conditions are met:
|
|
|
+ * 1. Redistributions of source code must retain the above copyright
|
|
|
+ * notice, this list of conditions and the following disclaimer.
|
|
|
+ * 2. Redistributions in binary form must reproduce the above copyright
|
|
|
+ * notice, this list of conditions and the following disclaimer in the
|
|
|
+ * documentation and/or other materials provided with the distribution.
|
|
|
+ *
|
|
|
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
|
|
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
|
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
|
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
|
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
|
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
|
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
|
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
+ */
|
|
|
+
|
|
|
+/*
|
|
|
+ * Copyright (c) 2006-2025 RT-Thread Development Team
|
|
|
+ *
|
|
|
+ * SPDX-License-Identifier: Apache-2.0
|
|
|
+ */
|
|
|
+
|
|
|
+#include <rtthread.h>
|
|
|
+#include <rthw.h>
|
|
|
+#include "io.h"
|
|
|
+#include <ioremap.h>
|
|
|
+#include "board.h"
|
|
|
+#include "drv_hardlock.h"
|
|
|
+
|
|
|
+#if defined(RT_USING_POSIX_DEVIO)
|
|
|
+ #include <dfs_posix.h>
|
|
|
+ #include <poll.h>
|
|
|
+ #include <termios.h>
|
|
|
+#endif
|
|
|
+
|
|
|
+struct gnne_dev_handle
|
|
|
+{
|
|
|
+ rt_wqueue_t *wait;
|
|
|
+ rt_bool_t is_lock;
|
|
|
+};
|
|
|
+
|
|
|
+#define gnne_log(s...) rt_kprintf(s)
|
|
|
+
|
|
|
+#define gnne_err(s...) do { \
|
|
|
+ gnne_log("<err>[%s:%d] ", __func__, __LINE__); \
|
|
|
+ gnne_log(s); \
|
|
|
+ gnne_log("\r\n"); \
|
|
|
+} while (0)
|
|
|
+
|
|
|
+#define GNNE_CMD_LOCK 0
|
|
|
+#define GNNE_CMD_TRYLOCK 1
|
|
|
+#define GNNE_CMD_UNLOCK 2
|
|
|
+
|
|
|
+static struct rt_device g_gnne_device = {0};
|
|
|
+static struct rt_event g_gnne_event = {0};
|
|
|
+void *gnne_base_addr = RT_NULL;
|
|
|
+static hardlock_type g_kpu_lock = HARDLOCK_MAX;
|
|
|
+
|
|
|
+static int gnne_device_open(struct dfs_file *file)
|
|
|
+{
|
|
|
+ struct gnne_dev_handle *handle;
|
|
|
+ rt_device_t device;
|
|
|
+
|
|
|
+ handle = rt_malloc(sizeof(struct gnne_dev_handle));
|
|
|
+ if (handle == RT_NULL)
|
|
|
+ {
|
|
|
+ gnne_err("malloc failed\n");
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ device = (rt_device_t)file->vnode->data;
|
|
|
+ handle->wait = &device->wait_queue;
|
|
|
+ handle->is_lock = RT_FALSE;
|
|
|
+ file->data = (void *)handle;
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+
|
|
|
+static int gnne_device_close(struct dfs_file *file)
|
|
|
+{
|
|
|
+ struct gnne_dev_handle *handle;
|
|
|
+
|
|
|
+ handle = (struct gnne_dev_handle *)file->data;
|
|
|
+ if (handle == RT_NULL)
|
|
|
+ {
|
|
|
+ gnne_err("try to close a invalid handle");
|
|
|
+ return -RT_EINVAL;
|
|
|
+ }
|
|
|
+ if (handle->is_lock)
|
|
|
+ {
|
|
|
+ kd_hardlock_unlock(g_kpu_lock);
|
|
|
+ }
|
|
|
+ rt_free(handle);
|
|
|
+ file->data = RT_NULL;
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+
|
|
|
+static int gnne_device_ioctl(struct dfs_file *file, int cmd, void *args)
|
|
|
+{
|
|
|
+ struct gnne_dev_handle *handle;
|
|
|
+ int ret = -1;
|
|
|
+ handle = (struct gnne_dev_handle *)file->data;
|
|
|
+ if ((g_kpu_lock == HARDLOCK_MAX))
|
|
|
+ {
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+ if (cmd == GNNE_CMD_LOCK)
|
|
|
+ {
|
|
|
+ if (handle->is_lock == RT_TRUE)
|
|
|
+ {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ while (kd_hardlock_lock(g_kpu_lock));
|
|
|
+ handle->is_lock = RT_TRUE;
|
|
|
+ ret = 0;
|
|
|
+ }
|
|
|
+ else if (cmd == GNNE_CMD_UNLOCK)
|
|
|
+ {
|
|
|
+ if (handle->is_lock == RT_FALSE)
|
|
|
+ {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ kd_hardlock_unlock(g_kpu_lock);
|
|
|
+ handle->is_lock = RT_FALSE;
|
|
|
+ ret = 0;
|
|
|
+ }
|
|
|
+ else if (cmd == GNNE_CMD_TRYLOCK)
|
|
|
+ {
|
|
|
+ if (handle->is_lock == RT_TRUE)
|
|
|
+ {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (!kd_hardlock_lock(g_kpu_lock))
|
|
|
+ {
|
|
|
+ handle->is_lock = RT_TRUE;
|
|
|
+ ret = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+int gnne_device_poll(struct dfs_file *file, struct rt_pollreq *req)
|
|
|
+{
|
|
|
+ struct gnne_dev_handle *handle;
|
|
|
+ unsigned int flags;
|
|
|
+ handle = (struct gnne_dev_handle *)file->data;
|
|
|
+ if (!handle)
|
|
|
+ {
|
|
|
+ gnne_err("gnne_dev_handle NULL!");
|
|
|
+ return -EINVAL;
|
|
|
+ }
|
|
|
+ rt_event_recv(&g_gnne_event, 0x01, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, NULL);
|
|
|
+ rt_poll_add(handle->wait, req);
|
|
|
+ return POLLIN;
|
|
|
+}
|
|
|
+
|
|
|
+static const struct dfs_file_ops gnne_input_fops =
|
|
|
+{
|
|
|
+ .open = gnne_device_open,
|
|
|
+ .close = gnne_device_close,
|
|
|
+ .ioctl = gnne_device_ioctl,
|
|
|
+ .poll = gnne_device_poll,
|
|
|
+};
|
|
|
+
|
|
|
+static void irq_callback(int irq, void *data)
|
|
|
+{
|
|
|
+ rt_wqueue_t *wait = (rt_wqueue_t *)data;
|
|
|
+ volatile void *write_addr = (void *)((char *)gnne_base_addr + 0x128);
|
|
|
+ if (gnne_base_addr == RT_NULL)
|
|
|
+ {
|
|
|
+ gnne_err("gnne interrupts while the hardware is not yet initialized\n");
|
|
|
+ }
|
|
|
+ /*clear kpu intr*/
|
|
|
+ __iowmb();
|
|
|
+ *(rt_uint64_t *)write_addr = 0x400000004;
|
|
|
+ rt_wqueue_wakeup(wait, (void *)POLLIN);
|
|
|
+ rt_event_send(&g_gnne_event, 0x1);
|
|
|
+}
|
|
|
+
|
|
|
+int gnne_device_init(void)
|
|
|
+{
|
|
|
+ int ret = 0;
|
|
|
+ rt_isr_handler_t old_handler;
|
|
|
+ rt_device_t gnne_device = &g_gnne_device;
|
|
|
+
|
|
|
+ ret = rt_event_init(&g_gnne_event, "gnne_event", RT_IPC_FLAG_PRIO);
|
|
|
+ if (ret)
|
|
|
+ {
|
|
|
+ gnne_err("event init failed\n");
|
|
|
+ return -ENOMEM;
|
|
|
+ }
|
|
|
+
|
|
|
+ ret = rt_device_register(gnne_device, "gnne_device", RT_DEVICE_FLAG_RDWR);
|
|
|
+ if (ret)
|
|
|
+ {
|
|
|
+ gnne_err("gnne_device register fail\n");
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ /*rt_ioremap maps the size of at least one page*/
|
|
|
+ gnne_base_addr = rt_ioremap((void *)KPU_BASE_ADDR, (KPU_IO_SIZE + FFT_IO_SIZE + AI2D_IO_SIZE));
|
|
|
+ if (gnne_base_addr == RT_NULL)
|
|
|
+ {
|
|
|
+ gnne_err("gnne ioremap error\n");
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ rt_wqueue_init(&gnne_device->wait_queue);
|
|
|
+ old_handler = rt_hw_interrupt_install(K230_IRQ_GNNE, irq_callback, &gnne_device->wait_queue, "gnne_irq");
|
|
|
+ if (old_handler == RT_NULL)
|
|
|
+ {
|
|
|
+ gnne_err("gnne_device interrupt install fail\n");
|
|
|
+ return -RT_ERROR;
|
|
|
+ }
|
|
|
+ rt_hw_interrupt_umask(K230_IRQ_GNNE);
|
|
|
+
|
|
|
+ gnne_device->fops = &gnne_input_fops;
|
|
|
+
|
|
|
+ if (kd_request_lock(HARDLOCK_KPU))
|
|
|
+ {
|
|
|
+ gnne_err("fail to request hardlock-%d\n", HARDLOCK_KPU);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ g_kpu_lock = HARDLOCK_KPU;
|
|
|
+ }
|
|
|
+
|
|
|
+ return RT_EOK;
|
|
|
+}
|
Chuan