diff options
| author | GUI <[email protected]> | 2022-06-18 08:09:57 +0800 |
|---|---|---|
| committer | GitHub <[email protected]> | 2022-06-18 08:09:57 +0800 |
| commit | 8fa16f968a2e952fc8be84dc69724aa90ffa9b37 (patch) | |
| tree | 890d3997dbb3d324daa3a1c5b4727511f415f073 | |
| parent | fb941e6d8d79164185f97a40e68dd73ac2a9fdda (diff) | |
[bsp/qemu-virt64-aarch64] Add more VirtIO drivers (#6091)
22 files changed, 3778 insertions, 38 deletions
diff --git a/bsp/qemu-virt64-aarch64/.config b/bsp/qemu-virt64-aarch64/.config index 00aae227c0..aa2cb9d819 100644 --- a/bsp/qemu-virt64-aarch64/.config +++ b/bsp/qemu-virt64-aarch64/.config @@ -8,7 +8,8 @@ # CONFIG_RT_NAME_MAX=16 # CONFIG_RT_USING_ARCH_DATA_TYPE is not set -# CONFIG_RT_USING_SMP is not set +CONFIG_RT_USING_SMP=y +CONFIG_RT_CPUS_NR=4 CONFIG_RT_ALIGN_SIZE=4 # CONFIG_RT_THREAD_PRIORITY_8 is not set CONFIG_RT_THREAD_PRIORITY_32=y @@ -21,6 +22,7 @@ CONFIG_RT_HOOK_USING_FUNC_PTR=y CONFIG_RT_USING_IDLE_HOOK=y CONFIG_RT_IDLE_HOOK_LIST_SIZE=4 CONFIG_IDLE_THREAD_STACK_SIZE=4096 +CONFIG_SYSTEM_THREAD_STACK_SIZE=4096 CONFIG_RT_USING_TIMER_SOFT=y CONFIG_RT_TIMER_THREAD_PRIO=4 CONFIG_RT_TIMER_THREAD_STACK_SIZE=4096 @@ -31,7 +33,7 @@ CONFIG_RT_TIMER_THREAD_STACK_SIZE=4096 # CONFIG_RT_KSERVICE_USING_STDLIB is not set # CONFIG_RT_KSERVICE_USING_TINY_SIZE is not set # CONFIG_RT_USING_TINY_FFS is not set -# CONFIG_RT_PRINTF_LONGLONG is not set +CONFIG_RT_KPRINTF_USING_LONGLONG=y CONFIG_RT_DEBUG=y CONFIG_RT_DEBUG_COLOR=y # CONFIG_RT_DEBUG_INIT_CONFIG is not set @@ -82,7 +84,7 @@ CONFIG_RT_USING_DEVICE_OPS=y CONFIG_RT_USING_CONSOLE=y CONFIG_RT_CONSOLEBUF_SIZE=128 CONFIG_RT_CONSOLE_DEVICE_NAME="uart0" -CONFIG_RT_VER_NUM=0x40100 +CONFIG_RT_VER_NUM=0x40101 CONFIG_ARCH_CPU_64BIT=y # CONFIG_RT_USING_CPU_FFS is not set CONFIG_ARCH_ARMV8=y @@ -144,6 +146,7 @@ CONFIG_RT_DFS_ELM_MUTEX_TIMEOUT=3000 CONFIG_RT_USING_DFS_DEVFS=y # CONFIG_RT_USING_DFS_ROMFS is not set # CONFIG_RT_USING_DFS_RAMFS is not set +# CONFIG_RT_USING_DFS_NFS is not set # CONFIG_RT_USING_FAL is not set # @@ -151,7 +154,7 @@ CONFIG_RT_USING_DFS_DEVFS=y # CONFIG_RT_USING_DEVICE_IPC=y CONFIG_RT_USING_SYSTEM_WORKQUEUE=y -CONFIG_RT_SYSTEM_WORKQUEUE_STACKSIZE=2048 +CONFIG_RT_SYSTEM_WORKQUEUE_STACKSIZE=4096 CONFIG_RT_SYSTEM_WORKQUEUE_PRIORITY=23 CONFIG_RT_USING_SERIAL=y CONFIG_RT_USING_SERIAL_V1=y @@ -221,9 +224,83 @@ CONFIG_RT_LIBC_DEFAULT_TIMEZONE=8 # # Network # -# CONFIG_RT_USING_SAL is not set -# CONFIG_RT_USING_NETDEV is not set -# CONFIG_RT_USING_LWIP is not set +CONFIG_RT_USING_SAL=y +CONFIG_SAL_INTERNET_CHECK=y + +# +# Docking with protocol stacks +# +CONFIG_SAL_USING_LWIP=y +# CONFIG_SAL_USING_AT is not set +# CONFIG_SAL_USING_TLS is not set +CONFIG_SAL_USING_POSIX=y +CONFIG_RT_USING_NETDEV=y +CONFIG_NETDEV_USING_IFCONFIG=y +CONFIG_NETDEV_USING_PING=y +CONFIG_NETDEV_USING_NETSTAT=y +CONFIG_NETDEV_USING_AUTO_DEFAULT=y +# CONFIG_NETDEV_USING_IPV6 is not set +CONFIG_NETDEV_IPV4=1 +CONFIG_NETDEV_IPV6=0 +# CONFIG_NETDEV_IPV6_SCOPES is not set +CONFIG_RT_USING_LWIP=y +# CONFIG_RT_USING_LWIP_LOCAL_VERSION is not set +# CONFIG_RT_USING_LWIP141 is not set +CONFIG_RT_USING_LWIP203=y +# CONFIG_RT_USING_LWIP212 is not set +# CONFIG_RT_USING_LWIP_LATEST is not set +CONFIG_RT_USING_LWIP_VER_NUM=0x20003 +# CONFIG_RT_USING_LWIP_IPV6 is not set +CONFIG_RT_LWIP_MEM_ALIGNMENT=4 +# CONFIG_RT_LWIP_IGMP is not set +CONFIG_RT_LWIP_ICMP=y +# CONFIG_RT_LWIP_SNMP is not set +CONFIG_RT_LWIP_DNS=y +CONFIG_RT_LWIP_DHCP=y +CONFIG_IP_SOF_BROADCAST=1 +CONFIG_IP_SOF_BROADCAST_RECV=1 + +# +# Static IPv4 Address +# +CONFIG_RT_LWIP_IPADDR="192.168.1.30" +CONFIG_RT_LWIP_GWADDR="192.168.1.1" +CONFIG_RT_LWIP_MSKADDR="255.255.255.0" +CONFIG_RT_LWIP_UDP=y +CONFIG_RT_LWIP_TCP=y +CONFIG_RT_LWIP_RAW=y +# CONFIG_RT_LWIP_PPP is not set +CONFIG_RT_MEMP_NUM_NETCONN=8 +CONFIG_RT_LWIP_PBUF_NUM=16 +CONFIG_RT_LWIP_RAW_PCB_NUM=4 +CONFIG_RT_LWIP_UDP_PCB_NUM=4 +CONFIG_RT_LWIP_TCP_PCB_NUM=4 +CONFIG_RT_LWIP_TCP_SEG_NUM=40 +CONFIG_RT_LWIP_TCP_SND_BUF=8196 +CONFIG_RT_LWIP_TCP_WND=8196 +CONFIG_RT_LWIP_TCPTHREAD_PRIORITY=10 +CONFIG_RT_LWIP_TCPTHREAD_MBOX_SIZE=8 +CONFIG_RT_LWIP_TCPTHREAD_STACKSIZE=4096 +# CONFIG_LWIP_NO_RX_THREAD is not set +# CONFIG_LWIP_NO_TX_THREAD is not set +CONFIG_RT_LWIP_ETHTHREAD_PRIORITY=12 +CONFIG_RT_LWIP_ETHTHREAD_STACKSIZE=4096 +CONFIG_RT_LWIP_ETHTHREAD_MBOX_SIZE=8 +CONFIG_RT_LWIP_REASSEMBLY_FRAG=y +CONFIG_LWIP_NETIF_STATUS_CALLBACK=1 +CONFIG_LWIP_NETIF_LINK_CALLBACK=1 +CONFIG_SO_REUSE=1 +CONFIG_LWIP_SO_RCVTIMEO=1 +CONFIG_LWIP_SO_SNDTIMEO=1 +CONFIG_LWIP_SO_RCVBUF=1 +CONFIG_LWIP_SO_LINGER=0 +# CONFIG_RT_LWIP_NETIF_LOOPBACK is not set +CONFIG_LWIP_NETIF_LOOPBACK=0 +# CONFIG_RT_LWIP_STATS is not set +# CONFIG_RT_LWIP_USING_HW_CHECKSUM is not set +CONFIG_RT_LWIP_USING_PING=y +# CONFIG_LWIP_USING_DHCPD is not set +# CONFIG_RT_LWIP_DEBUG is not set # CONFIG_RT_USING_AT is not set # @@ -299,6 +376,7 @@ CONFIG_RT_LIBC_DEFAULT_TIMEZONE=8 # CONFIG_PKG_USING_UCLOUD_IOT_SDK is not set # CONFIG_PKG_USING_JOYLINK is not set # CONFIG_PKG_USING_EZ_IOT_OS is not set +# CONFIG_PKG_USING_IOTSHARP_SDK is not set # CONFIG_PKG_USING_NIMBLE is not set # CONFIG_PKG_USING_LLSYNC_SDK_ADAPTER is not set # CONFIG_PKG_USING_OTA_DOWNLOADER is not set @@ -332,12 +410,14 @@ CONFIG_RT_LIBC_DEFAULT_TIMEZONE=8 # CONFIG_PKG_USING_HM is not set # CONFIG_PKG_USING_SMALL_MODBUS is not set # CONFIG_PKG_USING_NET_SERVER is not set +# CONFIG_PKG_USING_ZFTP is not set # # security packages # # CONFIG_PKG_USING_MBEDTLS is not set # CONFIG_PKG_USING_LIBSODIUM is not set +# CONFIG_PKG_USING_LIBHYDROGEN is not set # CONFIG_PKG_USING_TINYCRYPT is not set # CONFIG_PKG_USING_TFM is not set # CONFIG_PKG_USING_YD_CRYPTO is not set @@ -366,6 +446,7 @@ CONFIG_RT_LIBC_DEFAULT_TIMEZONE=8 # CONFIG_PKG_USING_JERRYSCRIPT is not set # CONFIG_PKG_USING_MICROPYTHON is not set # CONFIG_PKG_USING_PIKASCRIPT is not set +# CONFIG_PKG_USING_RTT_RUST is not set # # multimedia packages @@ -377,6 +458,7 @@ CONFIG_RT_LIBC_DEFAULT_TIMEZONE=8 # CONFIG_PKG_USING_LVGL is not set # CONFIG_PKG_USING_LITTLEVGL2RTT is not set # CONFIG_PKG_USING_LV_MUSIC_DEMO is not set +# CONFIG_PKG_USING_GUI_GUIDER_DEMO is not set # # u8g2: a monochrome graphic library @@ -451,6 +533,9 @@ CONFIG_RT_LIBC_DEFAULT_TIMEZONE=8 # CONFIG_PKG_USING_FDT is not set # CONFIG_PKG_USING_CBOX is not set # CONFIG_PKG_USING_SNOWFLAKE is not set +# CONFIG_PKG_USING_HASH_MATCH is not set +# CONFIG_PKG_USING_FIRE_PID_CURVE is not set +# CONFIG_PKG_USING_ARMV7M_DWT_TOOL is not set # # system packages @@ -470,6 +555,7 @@ CONFIG_RT_LIBC_DEFAULT_TIMEZONE=8 # CONFIG_PKG_USING_POSIX_WCWIDTH is not set # CONFIG_PKG_USING_POSIX_ITOA is not set # CONFIG_PKG_USING_POSIX_STRINGS is not set +# CONFIG_PKG_USING_POSIX_CTYPES is not set # # acceleration: Assembly language or algorithmic acceleration packages @@ -482,6 +568,7 @@ CONFIG_RT_LIBC_DEFAULT_TIMEZONE=8 # CMSIS: ARM Cortex-M Microcontroller Software Interface Standard # # CONFIG_PKG_USING_CMSIS_5 is not set +# CONFIG_PKG_USING_CMSIS_RTOS1 is not set # CONFIG_PKG_USING_CMSIS_RTOS2 is not set # @@ -497,6 +584,7 @@ CONFIG_RT_LIBC_DEFAULT_TIMEZONE=8 # CONFIG_PKG_USING_CAIRO is not set # CONFIG_PKG_USING_PIXMAN is not set # CONFIG_PKG_USING_PARTITION is not set +# CONFIG_PKG_USING_PERF_COUNTER is not set # CONFIG_PKG_USING_FLASHDB is not set # CONFIG_PKG_USING_SQLITE is not set # CONFIG_PKG_USING_RTI is not set @@ -524,6 +612,8 @@ CONFIG_RT_LIBC_DEFAULT_TIMEZONE=8 # CONFIG_PKG_USING_TINYUSB is not set # CONFIG_PKG_USING_CHERRYUSB is not set # CONFIG_PKG_USING_KMULTI_RTIMER is not set +# CONFIG_PKG_USING_TFDB is not set +# CONFIG_PKG_USING_QPC is not set # # peripheral libraries and drivers @@ -678,6 +768,8 @@ CONFIG_RT_LIBC_DEFAULT_TIMEZONE=8 # CONFIG_PKG_USING_CONTROLLER is not set # CONFIG_PKG_USING_PHASE_LOCKED_LOOP is not set # CONFIG_PKG_USING_MFBD is not set +# CONFIG_PKG_USING_SLCAN2RTT is not set +# CONFIG_PKG_USING_SOEM is not set CONFIG_SOC_VIRT64_AARCH64=y # @@ -688,6 +780,9 @@ CONFIG_RT_USING_UART0=y CONFIG_BSP_USING_RTC=y CONFIG_BSP_USING_ALARM=y CONFIG_BSP_USING_VIRTIO_BLK=y +CONFIG_BSP_USING_VIRTIO_NET=y +CONFIG_BSP_USING_VIRTIO_GPU=y +CONFIG_BSP_USING_VIRTIO_INPUT=y CONFIG_BSP_USING_GIC=y CONFIG_BSP_USING_GICV2=y # CONFIG_BSP_USING_GICV3 is not set diff --git a/bsp/qemu-virt64-aarch64/README.md b/bsp/qemu-virt64-aarch64/README.md index b0999e61d8..2d775c9614 100644 --- a/bsp/qemu-virt64-aarch64/README.md +++ b/bsp/qemu-virt64-aarch64/README.md @@ -51,4 +51,7 @@ msh /> | ------ | --------- | ------ | | UART | Support | UART0 | | RTC | Support | - | -| VIRTIO BLK | Support | - |
\ No newline at end of file +| VIRTIO BLK | Support | - | +| VIRTIO NET | Support | - | +| VIRTIO GPU | Support | 2D | +| VIRTIO Input | Support | Keyboard, Mouse, Tablet |
\ No newline at end of file diff --git a/bsp/qemu-virt64-aarch64/README_zh.md b/bsp/qemu-virt64-aarch64/README_zh.md index e723e83ac1..472aefb097 100644 --- a/bsp/qemu-virt64-aarch64/README_zh.md +++ b/bsp/qemu-virt64-aarch64/README_zh.md @@ -52,4 +52,7 @@ msh /> | ------ | ---- | :------: | | UART | 支持 | UART0 | | RTC | 支持 | - | -| VIRTIO BLK | 支持 | - |
\ No newline at end of file +| VIRTIO BLK | 支持 | - | +| VIRTIO NET | 支持 | - | +| VIRTIO GPU | 支持 | 2D | +| VIRTIO Input | 支持 | Keyboard, Mouse, Tablet |
\ No newline at end of file diff --git a/bsp/qemu-virt64-aarch64/applications/graphic.c b/bsp/qemu-virt64-aarch64/applications/graphic.c new file mode 100644 index 0000000000..ce268accf5 --- /dev/null +++ b/bsp/qemu-virt64-aarch64/applications/graphic.c @@ -0,0 +1,198 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-11-11 GuEe-GUI the first version + */ + +#include <rtthread.h> + +#include <virtio_gpu.h> +#include <virtio_input.h> + +#define GRAPHIC_THREAD_PRIORITY 25 +#define GRAPHIC_THREAD_STACK_SIZE 4096 +#define GRAPHIC_THREAD_TIMESLICE 5 + +static rt_uint32_t cur_min[2]; +static rt_uint32_t cur_max[2]; +static rt_uint32_t cur_range[2]; +static rt_uint32_t cur_points[2]; +static rt_uint32_t cur_last_points[2]; +static rt_bool_t cur_event_sync; + +void tablet_event_handler(struct virtio_input_event event) +{ + if (event.type == EV_ABS) + { + if (event.code == 0) + { + cur_points[0] = (cur_max[0] * (event.value - cur_min[0]) + cur_range[0] / 2) / cur_range[0]; + } + else if (event.code == 1) + { + cur_points[1] = (cur_max[1] * (event.value - cur_min[1]) + cur_range[1] / 2) / cur_range[1]; + } + } + else if (event.type == EV_SYN) + { + cur_event_sync = RT_TRUE; + } +} + +void graphic_thread(void *param) +{ + int i; + char dev_name[RT_NAME_MAX]; + rt_device_t device = RT_NULL; + + rt_device_t tablet_dev = RT_NULL; + struct virtio_input_config tablet_config; + + rt_uint32_t red = 0xff0000; + rt_uint32_t blue = 0x0000ff; + rt_uint32_t white = 0xffffff; + rt_device_t gpu_dev = RT_NULL; + struct rt_device_rect_info rect_info; + struct rt_device_graphic_info graphic_info; + struct rt_device_graphic_ops *virtio_gpu_graphic_ops; + + /* GPU */ + device = rt_device_find("virtio-gpu0"); + + if (device != RT_NULL && rt_device_open(device, 0) == RT_EOK) + { + virtio_gpu_graphic_ops = rt_graphix_ops(device); + + rt_memset(&rect_info, 0, sizeof(rect_info)); + rt_memset(&graphic_info, 0, sizeof(graphic_info)); + + rt_device_control(device, VIRTIO_DEVICE_CTRL_GPU_SET_PRIMARY, RT_NULL); + rt_device_control(device, VIRTIO_DEVICE_CTRL_GPU_CREATE_2D, (void *)RTGRAPHIC_PIXEL_FORMAT_RGB888); + rt_device_control(device, RTGRAPHIC_CTRL_GET_INFO, &graphic_info); + + rect_info.x = 0; + rect_info.y = 0; + rect_info.width = graphic_info.width; + rect_info.height = graphic_info.height; + + if (graphic_info.framebuffer != RT_NULL) + { + rt_memset(graphic_info.framebuffer, 0xff, + graphic_info.width * graphic_info.height * graphic_info.bits_per_pixel); + + cur_last_points[0] = graphic_info.width / 2; + cur_last_points[1] = graphic_info.height / 2; + + virtio_gpu_graphic_ops->draw_hline((char *)&red, 0, graphic_info.width, cur_last_points[1]); + virtio_gpu_graphic_ops->draw_vline((char *)&blue, cur_last_points[0], 0, graphic_info.height); + + rt_device_control(device, RTGRAPHIC_CTRL_RECT_UPDATE, &rect_info); + + gpu_dev = device; + } + + rt_device_close(device); + } + + /* Keyboard, Mouse, Tablet */ + for (i = 0; i < 3; ++i) + { + rt_snprintf(dev_name, RT_NAME_MAX, "virtio-input%d", i); + + device = rt_device_find(dev_name); + + if (device != RT_NULL && rt_device_open(device, 0) == RT_EOK) + { + enum virtio_input_type type; + rt_device_control(device, VIRTIO_DEVICE_CTRL_INPUT_GET_TYPE, &type); + + if (type == VIRTIO_INPUT_TYPE_TABLET) + { + tablet_dev = device; + } + else + { + rt_device_close(device); + } + } + } + + if (tablet_dev == RT_NULL || gpu_dev == RT_NULL) + { + goto _graphic_fail; + } + + cur_max[0] = graphic_info.width; + cur_max[1] = graphic_info.height; + + rt_device_control(tablet_dev, VIRTIO_DEVICE_CTRL_INPUT_GET_ABS_X_INFO, &tablet_config); + + cur_min[0] = tablet_config.abs.min; + cur_range[0] = tablet_config.abs.max - cur_min[0]; + + rt_device_control(tablet_dev, VIRTIO_DEVICE_CTRL_INPUT_GET_ABS_Y_INFO, &tablet_config); + + cur_min[1] = tablet_config.abs.min; + cur_range[1] = tablet_config.abs.max - cur_min[1]; + + cur_event_sync = RT_FALSE; + + rt_device_control(tablet_dev, VIRTIO_DEVICE_CTRL_INPUT_BIND_BSCT_HANDLER, tablet_event_handler); + + for (;;) + { + while (cur_event_sync) + { + virtio_gpu_graphic_ops->draw_hline((char *)&white, 0, graphic_info.width, cur_last_points[1]); + virtio_gpu_graphic_ops->draw_vline((char *)&white, cur_last_points[0], 0, graphic_info.height); + + cur_last_points[0] = cur_points[0]; + cur_last_points[1] = cur_points[1]; + + virtio_gpu_graphic_ops->draw_hline((char *)&red, 0, graphic_info.width, cur_last_points[1]); + virtio_gpu_graphic_ops->draw_vline((char *)&blue, cur_last_points[0], 0, graphic_info.height); + + rt_device_control(gpu_dev, RTGRAPHIC_CTRL_RECT_UPDATE, &rect_info); + + cur_event_sync = RT_FALSE; + + rt_thread_mdelay(1); + } + } + +_graphic_fail: + + if (gpu_dev != RT_NULL) + { + rt_device_close(gpu_dev); + } + + if (tablet_dev != RT_NULL) + { + rt_device_close(tablet_dev); + } +} + +int graphic_init(void) +{ + rt_thread_t graphic_tid = rt_thread_create("graphic work", graphic_thread, RT_NULL, + GRAPHIC_THREAD_STACK_SIZE, GRAPHIC_THREAD_PRIORITY, GRAPHIC_THREAD_TIMESLICE); + + if (graphic_tid != RT_NULL) + { + rt_thread_startup(graphic_tid); + + return RT_EOK; + } + + return -RT_ERROR; +} +#ifdef RT_USING_SMP +INIT_ENV_EXPORT(graphic_init); +#else +MSH_CMD_EXPORT(graphic_init, Graphic initialize); +#endif diff --git a/bsp/qemu-virt64-aarch64/driver/Kconfig b/bsp/qemu-virt64-aarch64/driver/Kconfig index 5d617eb42a..c159872f7a 100644 --- a/bsp/qemu-virt64-aarch64/driver/Kconfig +++ b/bsp/qemu-virt64-aarch64/driver/Kconfig @@ -24,10 +24,22 @@ menu "AARCH64 qemu virt64 configs" default n endif - menuconfig BSP_USING_VIRTIO_BLK + config BSP_USING_VIRTIO_BLK bool "Using VirtIO BLK" default y + config BSP_USING_VIRTIO_NET + bool "Using VirtIO NET" + default y + + config BSP_USING_VIRTIO_GPU + bool "Using VirtIO GPU" + default y + + config BSP_USING_VIRTIO_INPUT + bool "Using VirtIO Input" + default y + config BSP_USING_GIC bool default y diff --git a/bsp/qemu-virt64-aarch64/driver/drv_virtio.c b/bsp/qemu-virt64-aarch64/driver/drv_virtio.c index 33f91ab725..5aca6a81e9 100644 --- a/bsp/qemu-virt64-aarch64/driver/drv_virtio.c +++ b/bsp/qemu-virt64-aarch64/driver/drv_virtio.c @@ -14,6 +14,15 @@ #ifdef BSP_USING_VIRTIO_BLK #include <virtio_blk.h> #endif +#ifdef BSP_USING_VIRTIO_NET +#include <virtio_net.h> +#endif +#ifdef BSP_USING_VIRTIO_GPU +#include <virtio_gpu.h> +#endif +#ifdef BSP_USING_VIRTIO_INPUT +#include <virtio_input.h> +#endif #include <board.h> @@ -22,6 +31,15 @@ static virtio_device_init_handler virtio_device_init_handlers[] = #ifdef BSP_USING_VIRTIO_BLK [VIRTIO_DEVICE_ID_BLOCK] = rt_virtio_blk_init, #endif +#ifdef BSP_USING_VIRTIO_NET + [VIRTIO_DEVICE_ID_NET] = rt_virtio_net_init, +#endif +#ifdef BSP_USING_VIRTIO_GPU + [VIRTIO_DEVICE_ID_GPU] = rt_virtio_gpu_init, +#endif +#ifdef BSP_USING_VIRTIO_INPUT + [VIRTIO_DEVICE_ID_INPUT] = rt_virtio_input_init, +#endif }; int rt_virtio_devices_init(void) diff --git a/bsp/qemu-virt64-aarch64/driver/virtio/virtio.c b/bsp/qemu-virt64-aarch64/driver/virtio/virtio.c index faf05eb297..f0cd10d816 100644 --- a/bsp/qemu-virt64-aarch64/driver/virtio/virtio.c +++ b/bsp/qemu-virt64-aarch64/driver/virtio/virtio.c @@ -40,11 +40,18 @@ void virtio_status_driver_ok(struct virtio_device *dev) dev->mmio_config->status |= VIRTIO_STATUS_FEATURES_OK | VIRTIO_STATUS_DRIVER_OK; } -void virtio_interrupt_ack(struct virtio_device *dev, rt_uint32_t ack) +void virtio_interrupt_ack(struct virtio_device *dev) { + rt_uint32_t status; + _virtio_dev_check(dev); - dev->mmio_config->interrupt_ack = ack; + status = dev->mmio_config->interrupt_status; + + if (status != 0) + { + dev->mmio_config->interrupt_ack = status; + } } rt_err_t virtio_queue_init(struct virtio_device *dev, rt_uint32_t queue_index, rt_size_t ring_size) @@ -105,6 +112,8 @@ rt_err_t virtio_queue_init(struct virtio_device *dev, rt_uint32_t queue_index, r queue->free[i] = RT_TRUE; } + queue->free_count = ring_size; + return RT_EOK; } @@ -162,7 +171,6 @@ void virtio_submit_chain(struct virtio_device *dev, rt_uint32_t queue_index, rt_ rt_uint16_t virtio_alloc_desc(struct virtio_device *dev, rt_uint32_t queue_index) { int i; - rt_size_t ring_size; struct virtq *queue; _virtio_dev_check(dev); @@ -170,19 +178,24 @@ rt_uint16_t virtio_alloc_desc(struct virtio_device *dev, rt_uint32_t queue_index RT_ASSERT(queue_index < RT_USING_VIRTIO_QUEUE_MAX_NR); queue = &dev->queues[queue_index]; - ring_size = queue->num; - for (i = 0; i < ring_size; ++i) + if (queue->free_count > 0) { - if (queue->free[i]) + rt_size_t ring_size = queue->num; + + for (i = 0; i < ring_size; ++i) { - queue->free[i] = RT_FALSE; + if (queue->free[i]) + { + queue->free[i] = RT_FALSE; + queue->free_count--; - return (rt_uint16_t)i; + return (rt_uint16_t)i; + } } } - return RT_UINT16_MAX; + return VIRTQ_INVALID_DESC_ID; } void virtio_free_desc(struct virtio_device *dev, rt_uint32_t queue_index, rt_uint16_t desc_index) @@ -202,6 +215,8 @@ void virtio_free_desc(struct virtio_device *dev, rt_uint32_t queue_index, rt_uin queue->desc[desc_index].next = 0; queue->free[desc_index] = RT_TRUE; + + queue->free_count++; } rt_err_t virtio_alloc_desc_chain(struct virtio_device *dev, rt_uint32_t queue_index, rt_size_t count, @@ -213,11 +228,16 @@ rt_err_t virtio_alloc_desc_chain(struct virtio_device *dev, rt_uint32_t queue_in RT_ASSERT(indexs != RT_NULL); + if (dev->queues[queue_index].free_count < count) + { + return -RT_ERROR; + } + for (i = 0; i < count; ++i) { indexs[i] = virtio_alloc_desc(dev, queue_index); - if (indexs[i] == RT_UINT16_MAX) + if (indexs[i] == VIRTQ_INVALID_DESC_ID) { for (j = 0; j < i; ++j) { diff --git a/bsp/qemu-virt64-aarch64/driver/virtio/virtio.h b/bsp/qemu-virt64-aarch64/driver/virtio/virtio.h index 8a1dffa8c7..84bb8a8b0e 100644 --- a/bsp/qemu-virt64-aarch64/driver/virtio/virtio.h +++ b/bsp/qemu-virt64-aarch64/driver/virtio/virtio.h @@ -43,6 +43,7 @@ #define VIRTIO_F_RING_PACKED 34 #define VIRTIO_VA2PA(vaddr) ((rt_ubase_t)vaddr) +#define VIRTIO_PA2VA(paddr) ((rt_ubase_t)paddr) #define VIRTIO_PAGE_SHIFT 12 #define VIRTIO_PAGE_SIZE (1 << VIRTIO_PAGE_SHIFT) #define VIRTIO_PAGE_ALIGN(addr) (RT_ALIGN(addr, VIRTIO_PAGE_SIZE)) @@ -74,6 +75,25 @@ enum VIRTIO_DEVICE_ID_PSTORE = 22, /* Pstore device */ VIRTIO_DEVICE_ID_IOMMU = 23, /* IOMMU device */ VIRTIO_DEVICE_ID_MEM = 24, /* Memory device */ + /* virtio 1.2 */ + VIRTIO_DEVICE_ID_AUDIO = 25, /* Audio device */ + VIRTIO_DEVICE_ID_FS = 26, /* File system device */ + VIRTIO_DEVICE_ID_PMEM = 27, /* PMEM device */ + VIRTIO_DEVICE_ID_RPMB = 28, /* RPMB device */ + VIRTIO_DEVICE_ID_MAC80211_HWSIM = 29, /* Mac80211 hwsim wireless simulation device */ + VIRTIO_DEVICE_ID_VIDEO_ENCODER = 30, /* Video encoder device */ + VIRTIO_DEVICE_ID_VIDEO_DECODER = 31, /* Video decoder device */ + VIRTIO_DEVICE_ID_SCMI = 32, /* SCMI device */ + VIRTIO_DEVICE_ID_NITRO_SEC_MOD = 33, /* NitroSecureModule */ + VIRTIO_DEVICE_ID_I2C_ADAPTER = 34, /* I2C adapter */ + VIRTIO_DEVICE_ID_WATCHDOG = 35, /* Watchdog */ + VIRTIO_DEVICE_ID_CAN = 36, /* CAN device */ + VIRTIO_DEVICE_ID_DMABUF = 37, /* Virtio dmabuf */ + VIRTIO_DEVICE_ID_PARAM_SERV = 38, /* Parameter Server */ + VIRTIO_DEVICE_ID_AUDIO_POLICY = 39, /* Audio policy device */ + VIRTIO_DEVICE_ID_BT = 40, /* Bluetooth device */ + VIRTIO_DEVICE_ID_GPIO = 41, /* GPIO device */ + VIRTIO_DEVICE_ID_RDMA = 42, /* RDMA device */ VIRTIO_DEVICE_TYPE_SIZE }; @@ -101,7 +121,7 @@ typedef rt_err_t (*virtio_device_init_handler)(rt_ubase_t *mmio_base, rt_uint32_ void virtio_reset_device(struct virtio_device *dev); void virtio_status_acknowledge_driver(struct virtio_device *dev); void virtio_status_driver_ok(struct virtio_device *dev); -void virtio_interrupt_ack(struct virtio_device *dev, rt_uint32_t ack); +void virtio_interrupt_ack(struct virtio_device *dev); rt_err_t virtio_queue_init(struct virtio_device *dev, rt_uint32_t queue_index, rt_size_t ring_size); void virtio_queue_destroy(struct virtio_device *dev, rt_uint32_t queue_index); diff --git a/bsp/qemu-virt64-aarch64/driver/virtio/virtio_blk.c b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_blk.c index aac6ff7511..3978039b55 100644 --- a/bsp/qemu-virt64-aarch64/driver/virtio/virtio_blk.c +++ b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_blk.c @@ -13,9 +13,10 @@ #include <rtthread.h> #include <cpuport.h> +#ifdef BSP_USING_VIRTIO_BLK + #include <virtio_blk.h> -#ifdef BSP_USING_VIRTIO_BLK static void virtio_blk_rw(struct virtio_blk_device *virtio_blk_dev, rt_off_t pos, void *buffer, int flags) { rt_uint16_t idx[3]; @@ -38,18 +39,18 @@ static void virtio_blk_rw(struct virtio_blk_device *virtio_blk_dev, rt_off_t pos flags = flags == VIRTIO_BLK_T_OUT ? 0 : VIRTQ_DESC_F_WRITE; - virtio_fill_desc(virtio_dev, 0, idx[0], + virtio_fill_desc(virtio_dev, VIRTIO_BLK_QUEUE, idx[0], VIRTIO_VA2PA(&virtio_blk_dev->info[idx[0]].req), sizeof(struct virtio_blk_req), VIRTQ_DESC_F_NEXT, idx[1]); - virtio_fill_desc(virtio_dev, 0, idx[1], + virtio_fill_desc(virtio_dev, VIRTIO_BLK_QUEUE, idx[1], VIRTIO_VA2PA(buffer), VIRTIO_BLK_BUF_DATA_SIZE, flags | VIRTQ_DESC_F_NEXT, idx[2]); - virtio_fill_desc(virtio_dev, 0, idx[2], - VIRTIO_VA2PA(&virtio_blk_dev->info[idx[0]].status), 1, VIRTQ_DESC_F_WRITE, 0); + virtio_fill_desc(virtio_dev, VIRTIO_BLK_QUEUE, idx[2], + VIRTIO_VA2PA(&virtio_blk_dev->info[idx[0]].status), sizeof(rt_uint8_t), VIRTQ_DESC_F_WRITE, 0); - virtio_submit_chain(virtio_dev, 0, idx[0]); + virtio_submit_chain(virtio_dev, VIRTIO_BLK_QUEUE, idx[0]); - virtio_queue_notify(virtio_dev, 0); + virtio_queue_notify(virtio_dev, VIRTIO_BLK_QUEUE); /* Wait for virtio_blk_isr() to done */ while (virtio_blk_dev->info[idx[0]].valid) @@ -64,7 +65,7 @@ static void virtio_blk_rw(struct virtio_blk_device *virtio_blk_dev, rt_off_t pos #endif } - virtio_free_desc_chain(virtio_dev, 0, idx[0]); + virtio_free_desc_chain(virtio_dev, VIRTIO_BLK_QUEUE, idx[0]); #ifdef RT_USING_SMP rt_spin_unlock_irqrestore(&virtio_dev->spinlock, level); @@ -104,10 +105,11 @@ static rt_err_t virtio_blk_control(rt_device_t dev, int cmd, void *args) geometry->bytes_per_sector = VIRTIO_BLK_BYTES_PER_SECTOR; geometry->block_size = VIRTIO_BLK_BLOCK_SIZE; - geometry->sector_count = virtio_blk_dev->virtio_dev.mmio_config->config[0]; + geometry->sector_count = virtio_blk_dev->config->capacity; } break; default: + status = -RT_EINVAL; break; } @@ -129,19 +131,20 @@ static void virtio_blk_isr(int irqno, void *param) rt_uint32_t id; struct virtio_blk_device *virtio_blk_dev = (struct virtio_blk_device *)param; struct virtio_device *virtio_dev = &virtio_blk_dev->virtio_dev; + struct virtq *queue = &virtio_dev->queues[VIRTIO_BLK_QUEUE]; #ifdef RT_USING_SMP rt_base_t level = rt_spin_lock_irqsave(&virtio_dev->spinlock); #endif - virtio_interrupt_ack(virtio_dev, virtio_dev->mmio_config->interrupt_status & 0x3); + virtio_interrupt_ack(virtio_dev); rt_hw_dsb(); /* The device increments disk.used->idx when it adds an entry to the used ring */ - while (virtio_dev->queues[0].used_idx != virtio_dev->queues[0].used->idx) + while (queue->used_idx != queue->used->idx) { rt_hw_dsb(); - id = virtio_dev->queues[0].used->ring[virtio_dev->queues[0].used_idx % VIRTIO_BLK_QUEUE_RING_SIZE].id; + id = queue->used->ring[queue->used_idx % queue->num].id; RT_ASSERT(virtio_blk_dev->info[id].status == 0); @@ -149,7 +152,7 @@ static void virtio_blk_isr(int irqno, void *param) virtio_blk_dev->info[id].valid = RT_FALSE; rt_thread_yield(); - virtio_dev->queues[0].used_idx++; + queue->used_idx++; } #ifdef RT_USING_SMP @@ -175,6 +178,8 @@ rt_err_t rt_virtio_blk_init(rt_ubase_t *mmio_base, rt_uint32_t irq) virtio_dev->irq = irq; virtio_dev->mmio_base = mmio_base; + virtio_blk_dev->config = (struct virtio_blk_config *)virtio_dev->mmio_config->config; + #ifdef RT_USING_SMP rt_spin_lock_init(&virtio_dev->spinlock); #endif @@ -206,7 +211,7 @@ rt_err_t rt_virtio_blk_init(rt_ubase_t *mmio_base, rt_uint32_t irq) virtio_blk_dev->parent.type = RT_Device_Class_Block; virtio_blk_dev->parent.ops = &virtio_blk_ops; - rt_snprintf(dev_name, RT_NAME_MAX, "%s%d", "virtio-blk", dev_no++); + rt_snprintf(dev_name, RT_NAME_MAX, "virtio-blk%d", dev_no++); rt_hw_interrupt_install(irq, virtio_blk_isr, virtio_blk_dev, dev_name); rt_hw_interrupt_umask(irq); diff --git a/bsp/qemu-virt64-aarch64/driver/virtio/virtio_blk.h b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_blk.h index dfc08a1c55..e3c3e9d587 100644 --- a/bsp/qemu-virt64-aarch64/driver/virtio/virtio_blk.h +++ b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_blk.h @@ -16,6 +16,7 @@ #include <virtio.h> +#define VIRTIO_BLK_QUEUE 0 #define VIRTIO_BLK_BUF_DATA_SIZE 512 #define VIRTIO_BLK_BYTES_PER_SECTOR 512 #define VIRTIO_BLK_BLOCK_SIZE 512 @@ -40,12 +41,56 @@ struct virtio_blk_req rt_uint64_t sector; }; +struct virtio_blk_config +{ + rt_uint64_t capacity; + rt_uint32_t size_max; + rt_uint32_t seg_max; + + struct virtio_blk_geometry + { + rt_uint16_t cylinders; + rt_uint8_t heads; + rt_uint8_t sectors; + } geometry; + + rt_uint32_t blk_size; + + struct virtio_blk_topology + { + /* # Of logical blocks per physical block (log2) */ + rt_uint8_t physical_block_exp; + /* Offset of first aligned logical block */ + rt_uint8_t alignment_offset; + /* Suggested minimum I/O size in blocks */ + rt_uint16_t min_io_size; + /* Optimal (suggested maximum) I/O size in blocks */ + rt_uint32_t opt_io_size; + } topology; + + rt_uint8_t writeback; + rt_uint8_t unused0; + rt_uint16_t num_queues; + rt_uint32_t max_discard_sectors; + rt_uint32_t max_discard_seg; + rt_uint32_t discard_sector_alignment; + rt_uint32_t max_write_zeroes_sectors; + rt_uint32_t max_write_zeroes_seg; + rt_uint8_t write_zeroes_may_unmap; + rt_uint8_t unused1[3]; + rt_uint32_t max_secure_erase_sectors; + rt_uint32_t max_secure_erase_seg; + rt_uint32_t secure_erase_sector_alignment; +} __attribute__((packed)); + struct virtio_blk_device { struct rt_device parent; struct virtio_device virtio_dev; + struct virtio_blk_config *config; + struct { rt_bool_t valid; diff --git a/bsp/qemu-virt64-aarch64/driver/virtio/virtio_gpu.c b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_gpu.c new file mode 100644 index 0000000000..f951a319cb --- /dev/null +++ b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_gpu.c @@ -0,0 +1,903 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-11-11 GuEe-GUI the first version + */ + +#include <rthw.h> +#include <rtthread.h> +#include <cpuport.h> + +#ifdef BSP_USING_VIRTIO_GPU + +#include <virtio_gpu.h> + +static struct virtio_gpu_device *_primary_virtio_gpu_dev = RT_NULL; + +static rt_ubase_t _pixel_format_convert(rt_ubase_t format, rt_bool_t to_virtio_gpu_format) +{ + rt_ubase_t ret = 0; + + if (to_virtio_gpu_format) + { + switch (format) + { + case RTGRAPHIC_PIXEL_FORMAT_RGB888: + ret = VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM; + break; + case RTGRAPHIC_PIXEL_FORMAT_ARGB888: + ret = VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM; + break; + case RTGRAPHIC_PIXEL_FORMAT_ABGR888: + ret = VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM; + break; + default: + break; + } + } + else + { + switch (format) + { + case VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM: + ret = RTGRAPHIC_PIXEL_FORMAT_RGB888; + break; + case VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM: + ret = RTGRAPHIC_PIXEL_FORMAT_ARGB888; + break; + case VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM: + ret = RTGRAPHIC_PIXEL_FORMAT_ABGR888; + break; + default: + break; + } + } + + return ret; +} + +static void virtio_gpu_ctrl_send_command(struct virtio_gpu_device *virtio_gpu_dev, + const void *cmd, rt_size_t cmd_len, void *res, rt_size_t res_len) +{ + rt_uint16_t idx[2]; + void *addr = &virtio_gpu_dev->gpu_request; + void *ret_res = ((rt_uint8_t *)addr + cmd_len); + struct virtio_device *virtio_dev = &virtio_gpu_dev->virtio_dev; + +#ifdef RT_USING_SMP + rt_base_t level = rt_spin_lock_irqsave(&virtio_dev->spinlock); +#endif + + while (virtio_alloc_desc_chain(virtio_dev, VIRTIO_GPU_QUEUE_CTRL, 2, idx)) + { + } + + rt_hw_dsb(); + + virtio_gpu_dev->info[idx[0]].ctrl_valid = RT_TRUE; + + rt_memcpy(&virtio_gpu_dev->gpu_request, cmd, cmd_len); + + virtio_fill_desc(virtio_dev, VIRTIO_GPU_QUEUE_CTRL, idx[0], + VIRTIO_VA2PA(addr), cmd_len, VIRTQ_DESC_F_NEXT, idx[1]); + + virtio_fill_desc(virtio_dev, VIRTIO_GPU_QUEUE_CTRL, idx[1], + VIRTIO_VA2PA(addr) + cmd_len, res_len, VIRTQ_DESC_F_WRITE, 0); + + rt_memset(ret_res, 0, res_len); + + virtio_submit_chain(virtio_dev, VIRTIO_GPU_QUEUE_CTRL, idx[0]); + + virtio_queue_notify(virtio_dev, VIRTIO_GPU_QUEUE_CTRL); + + while (virtio_gpu_dev->info[idx[0]].ctrl_valid) + { +#ifdef RT_USING_SMP + rt_spin_unlock_irqrestore(&virtio_dev->spinlock, level); +#endif + rt_thread_yield(); + +#ifdef RT_USING_SMP + level = rt_spin_lock_irqsave(&virtio_dev->spinlock); +#endif + } + + virtio_free_desc_chain(virtio_dev, VIRTIO_GPU_QUEUE_CTRL, idx[0]); + + rt_memcpy(res, ret_res, res_len); + +#ifdef RT_USING_SMP + rt_spin_unlock_irqrestore(&virtio_dev->spinlock, level); +#endif +} + +static void virtio_gpu_cursor_send_command(struct virtio_gpu_device *virtio_gpu_dev, + const void *cmd, rt_size_t cmd_len) +{ + rt_uint16_t id; + void *addr; + struct virtio_device *virtio_dev = &virtio_gpu_dev->virtio_dev; + +#ifdef RT_USING_SMP + rt_base_t level = rt_spin_lock_irqsave(&virtio_dev->spinlock); +#endif + + id = virtio_alloc_desc(virtio_dev, VIRTIO_GPU_QUEUE_CURSOR); + + addr = &virtio_gpu_dev->info[id].cursor_cmd; + virtio_gpu_dev->info[id].cursor_valid = RT_TRUE; + + rt_memcpy(addr, cmd, cmd_len); + + virtio_fill_desc(virtio_dev, VIRTIO_GPU_QUEUE_CURSOR, id, VIRTIO_VA2PA(addr), cmd_len, 0, 0); + + virtio_submit_chain(virtio_dev, VIRTIO_GPU_QUEUE_CURSOR, id); + + virtio_queue_notify(virtio_dev, VIRTIO_GPU_QUEUE_CURSOR); + + while (virtio_gpu_dev->info[id].cursor_valid) + { +#ifdef RT_USING_SMP + rt_spin_unlock_irqrestore(&virtio_dev->spinlock, level); +#endif + rt_thread_yield(); + +#ifdef RT_USING_SMP + level = rt_spin_lock_irqsave(&virtio_dev->spinlock); +#endif + } + + virtio_free_desc(virtio_dev, VIRTIO_GPU_QUEUE_CURSOR, id); + +#ifdef RT_USING_SMP + rt_spin_unlock_irqrestore(&virtio_dev->spinlock, level); +#endif +} + +static rt_err_t virtio_gpu_create_2d_resource(struct virtio_gpu_device *virtio_gpu_dev, enum virtio_gpu_formats format, + rt_uint32_t *resource_id, rt_uint32_t width, rt_uint32_t height) +{ + struct virtio_gpu_ctrl_hdr res; + struct virtio_gpu_resource_create_2d req; + + *resource_id = ++virtio_gpu_dev->next_resource_id; + + req.hdr.type = VIRTIO_GPU_CMD_RESOURCE_CREATE_2D; + req.resource_id = *resource_id; + req.format = format; + req.width = width; + req.height = height; + + virtio_gpu_ctrl_send_command(virtio_gpu_dev, &req, sizeof(req), &res, sizeof(res)); + + if (res.type == VIRTIO_GPU_RESP_OK_NODATA) + { + return RT_EOK; + } + + return -RT_ERROR; +} + +static rt_err_t virtio_gpu_unref_resource(struct virtio_gpu_device *virtio_gpu_dev, rt_uint32_t resource_id) +{ + struct virtio_gpu_ctrl_hdr res; + struct virtio_gpu_resource_unref req; + + rt_memset(&req, 0, sizeof(req)); + + req.hdr.type = VIRTIO_GPU_CMD_RESOURCE_UNREF; + req.resource_id = resource_id; + + virtio_gpu_ctrl_send_command(virtio_gpu_dev, &req, sizeof(req), &res, sizeof(res)); + + if (res.type == VIRTIO_GPU_RESP_OK_NODATA) + { + return RT_EOK; + } + + return -RT_ERROR; +} + +static rt_err_t virtio_gpu_attach_backing_resource(struct virtio_gpu_device *virtio_gpu_dev, rt_uint32_t resource_id, + void *buffer, rt_size_t size) +{ + struct virtio_gpu_ctrl_hdr res; + struct + { + struct virtio_gpu_resource_attach_backing req; + struct virtio_gpu_mem_entry mem; + } req; + + rt_memset(&req, 0, sizeof(req)); + + req.req.hdr.type = VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING; + req.req.resource_id = resource_id; + req.req.nr_entries = 1; + + req.mem.addr = VIRTIO_VA2PA(buffer); + req.mem.length = size; + + virtio_gpu_ctrl_send_command(virtio_gpu_dev, &req, sizeof(req), &res, sizeof(res)); + + if (res.type == VIRTIO_GPU_RESP_OK_NODATA) + { + return RT_EOK; + } + + return -RT_ERROR; +} + +static rt_err_t virtio_gpu_set_scanout(struct virtio_gpu_device *virtio_gpu_dev, rt_uint32_t scanout_id, + rt_uint32_t resource_id, rt_uint32_t width, rt_uint32_t height) +{ + struct virtio_gpu_ctrl_hdr res; + struct virtio_gpu_set_scanout req; + + rt_memset(&req, 0, sizeof(req)); + + req.hdr.type = VIRTIO_GPU_CMD_SET_SCANOUT; + req.r.x = 0; + req.r.y = 0; + req.r.width = width; + req.r.height = height; + req.scanout_id = scanout_id; + req.resource_id = resource_id; + + virtio_gpu_ctrl_send_command(virtio_gpu_dev, &req, sizeof(req), &res, sizeof(res)); + + if (res.type == VIRTIO_GPU_RESP_OK_NODATA) + { + return RT_EOK; + } + + return -RT_ERROR; +} + +static rt_err_t virtio_gpu_flush_resource(struct virtio_gpu_device *virtio_gpu_dev, rt_uint32_t resource_id, + rt_uint32_t x, rt_uint32_t y, rt_uint32_t width, rt_uint32_t height) +{ + struct virtio_gpu_ctrl_hdr res; + struct virtio_gpu_resource_flush req; + + rt_memset(&req, 0, sizeof(req)); + + req.hdr.type = VIRTIO_GPU_CMD_RESOURCE_FLUSH; + req.r.x = x; + req.r.y = y; + req.r.width = width; + req.r.height = height; + req.resource_id = resource_id; + + virtio_gpu_ctrl_send_command(virtio_gpu_dev, &req, sizeof(req), &res, sizeof(res)); + + if (res.type == VIRTIO_GPU_RESP_OK_NODATA) + { + return RT_EOK; + } + + return -RT_ERROR; +} + +static rt_err_t virtio_gpu_transfer_to_host_2d(struct virtio_gpu_device *virtio_gpu_dev, rt_uint32_t resource_id, + rt_uint32_t x, rt_uint32_t y, rt_uint32_t width, rt_uint32_t height, rt_uint32_t offset) +{ + struct virtio_gpu_ctrl_hdr res; + struct virtio_gpu_transfer_to_host_2d req; + + rt_memset(&req, 0, sizeof(req)); + + req.hdr.type = VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D; + req.r.x = x; + req.r.y = y; + req.r.width = width; + req.r.height = height; + req.offset = offset; + req.resource_id = resource_id; + + virtio_gpu_ctrl_send_command(virtio_gpu_dev, &req, sizeof(req), &res, sizeof(res)); + + if (res.type == VIRTIO_GPU_RESP_OK_NODATA) + { + return RT_EOK; + } + + return -RT_ERROR; +} + +static rt_err_t virtio_gpu_gfx_flush_2d(struct virtio_gpu_device *virtio_gpu_dev, rt_uint32_t resource_id, + rt_uint32_t x, rt_uint32_t y, rt_uint32_t width, rt_uint32_t height) +{ + rt_err_t status = virtio_gpu_transfer_to_host_2d(virtio_gpu_dev, resource_id, x, y, width, height, 0); + + if (status == RT_EOK) + { + status = virtio_gpu_flush_resource(virtio_gpu_dev, resource_id, x, y, width, height); + } + + return status; +} + +static rt_err_t virtio_gpu_update_cursor(struct virtio_gpu_device *virtio_gpu_dev, rt_uint32_t scanout_id, + rt_uint32_t resource_id, rt_uint32_t hot_x, rt_uint32_t hot_y) +{ + struct virtio_gpu_update_cursor req; + + rt_memset(&req, 0, sizeof(req)); + + req.hdr.type = VIRTIO_GPU_CMD_UPDATE_CURSOR; + req.pos.scanout_id = scanout_id; + req.resource_id = resource_id; + req.hot_x = hot_x; + req.hot_y = hot_y; + + virtio_gpu_cursor_send_command(virtio_gpu_dev, &req, sizeof(req)); + + return RT_EOK; +} + +static rt_err_t virtio_gpu_cursor_move(struct virtio_gpu_device *virtio_gpu_dev, rt_uint32_t scanout_id, + rt_uint32_t resource_id, rt_uint32_t x, rt_uint32_t y) +{ + struct virtio_gpu_update_cursor req; + + rt_memset(&req, 0, sizeof(req)); + + req.hdr.type = VIRTIO_GPU_CMD_MOVE_CURSOR; + req.pos.scanout_id = scanout_id; + req.pos.x = x; + req.pos.y = y; + req.resource_id = resource_id; + + virtio_gpu_cursor_send_command(virtio_gpu_dev, &req, sizeof(req)); + + return RT_EOK; +} + +static rt_err_t virtio_gpu_cursor_set_img(struct virtio_gpu_device *virtio_gpu_dev, void *img) +{ + rt_err_t status; + + rt_memcpy(virtio_gpu_dev->cursor_img, img, VIRTIO_GPU_CURSOR_IMG_SIZE); + + status = virtio_gpu_attach_backing_resource(virtio_gpu_dev, + virtio_gpu_dev->cursor_resource_id, virtio_gpu_dev->cursor_img, VIRTIO_GPU_CURSOR_IMG_SIZE); + + if (status != RT_EOK) + { + return status; + } + + status = virtio_gpu_transfer_to_host_2d(virtio_gpu_dev, virtio_gpu_dev->cursor_resource_id, + 0, 0, VIRTIO_GPU_CURSOR_WIDTH, VIRTIO_GPU_CURSOR_HEIGHT, 0); + + return status; +} + +static rt_err_t virtio_gpu_get_display_info(struct virtio_gpu_device *virtio_gpu_dev) +{ + int i; + struct virtio_gpu_ctrl_hdr req; + struct virtio_gpu_resp_display_info info; + + rt_memset(&req, 0, sizeof(req)); + req.type = VIRTIO_GPU_CMD_GET_DISPLAY_INFO; + + virtio_gpu_ctrl_send_command(virtio_gpu_dev, &req, sizeof(req), &info, sizeof(info)); + + if (info.hdr.type != VIRTIO_GPU_RESP_OK_DISPLAY_INFO) + { + return -RT_ERROR; + } + + for (i = 0; i < VIRTIO_GPU_MAX_SCANOUTS; ++i) + { + if (info.pmodes[i].enabled) + { + if (virtio_gpu_dev->pmode_id == VIRTIO_GPU_INVALID_PMODE_ID) + { + rt_memcpy(&virtio_gpu_dev->pmode, &info.pmodes[i], sizeof(virtio_gpu_dev->pmode)); + virtio_gpu_dev->pmode_id = i; + } + } + } + + return RT_EOK; +} + +static rt_err_t virtio_gpu_init(rt_device_t dev) +{ + rt_err_t status; + struct virtio_gpu_device *virtio_gpu_dev = (struct virtio_gpu_device *)dev; + struct virtio_device *virtio_dev = &virtio_gpu_dev->virtio_dev; + struct virtq *queue_ctrl, *queue_cursor; + + queue_ctrl = &virtio_dev->queues[VIRTIO_GPU_QUEUE_CTRL]; + queue_cursor = &virtio_dev->queues[VIRTIO_GPU_QUEUE_CURSOR]; + + queue_ctrl->avail->flags = 0; + queue_cursor->avail->flags = 0; + + status = virtio_gpu_get_display_info(virtio_gpu_dev); + + if (virtio_gpu_dev->pmode_id != VIRTIO_GPU_INVALID_PMODE_ID && _primary_virtio_gpu_dev == RT_NULL) + { + /* This device is ready */ + _primary_virtio_gpu_dev = virtio_gpu_dev; + } + + return status; +} + +static rt_size_t virtio_gpu_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size) +{ + struct virtio_gpu_device *virtio_gpu_dev = (struct virtio_gpu_device *)dev; + + if (virtio_gpu_dev->framebuffer == RT_NULL || pos + size >= virtio_gpu_dev->smem_len) + { + return 0; + } + + rt_mutex_take(&virtio_gpu_dev->rw_mutex, RT_WAITING_FOREVER); + + rt_memcpy(buffer, (rt_uint8_t *)virtio_gpu_dev->framebuffer + pos, size); + + rt_mutex_release(&virtio_gpu_dev->rw_mutex); + + return size; +} + +static rt_size_t virtio_gpu_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size) +{ + struct virtio_gpu_device *virtio_gpu_dev = (struct virtio_gpu_device *)dev; + + if (virtio_gpu_dev->framebuffer == RT_NULL || pos + size >= virtio_gpu_dev->smem_len) + { + return 0; + } + + rt_mutex_take(&virtio_gpu_dev->rw_mutex, RT_WAITING_FOREVER); + + rt_memcpy((rt_uint8_t *)virtio_gpu_dev->framebuffer + pos, buffer, size); + + rt_mutex_release(&virtio_gpu_dev->rw_mutex); + + return size; +} + +static rt_err_t virtio_gpu_control(rt_device_t dev, int cmd, void *args) +{ + rt_err_t status = RT_EOK; + struct virtio_gpu_device *virtio_gpu_dev = (struct virtio_gpu_device *)dev; + + switch (cmd) + { + case VIRTIO_DEVICE_CTRL_GPU_SET_PRIMARY: + + _primary_virtio_gpu_dev = virtio_gpu_dev; + + return status; + } + + if (args == RT_NULL) + { + return -RT_ERROR; + } + + switch (cmd) + { + case RTGRAPHIC_CTRL_RECT_UPDATE: + { + struct rt_device_rect_info *info = (struct rt_device_rect_info *)args; + + if (virtio_gpu_dev->pmode_id == VIRTIO_GPU_INVALID_PMODE_ID) + { + status = -RT_ERROR; + break; + } + + status = virtio_gpu_gfx_flush_2d(virtio_gpu_dev, virtio_gpu_dev->display_resource_id, + info->x, info->y, info->width, info->height); + } + break; + case RTGRAPHIC_CTRL_GET_INFO: + { + struct rt_device_graphic_info *info = (struct rt_device_graphic_info *)args; + + info->pixel_format = _pixel_format_convert((rt_ubase_t)args, RT_FALSE); + info->bits_per_pixel = VIRTIO_GPU_FORMAT_BPP; + info->pitch = virtio_gpu_dev->pmode.r.width * VIRTIO_GPU_FORMAT_PIXEL; + info->width = virtio_gpu_dev->pmode.r.width; + info->height = virtio_gpu_dev->pmode.r.height; + info->framebuffer = virtio_gpu_dev->framebuffer; + info->smem_len = virtio_gpu_dev->smem_len; + } + break; + case VIRTIO_DEVICE_CTRL_GPU_CREATE_2D: + + virtio_gpu_dev->format = _pixel_format_convert((rt_ubase_t)args, RT_TRUE); + + if (virtio_gpu_dev->format == 0 || virtio_gpu_dev->pmode_id == VIRTIO_GPU_INVALID_PMODE_ID) + { + status = -RT_ERROR; + break; + } + + status = virtio_gpu_create_2d_resource(virtio_gpu_dev, virtio_gpu_dev->format, + &virtio_gpu_dev->display_resource_id, virtio_gpu_dev->pmode.r.width, virtio_gpu_dev->pmode.r.height); + + if (status != RT_EOK) + { + break; + } + + virtio_gpu_dev->smem_len = + virtio_gpu_dev->pmode.r.width * virtio_gpu_dev->pmode.r.height * VIRTIO_GPU_FORMAT_PIXEL; + virtio_gpu_dev->smem_len = RT_ALIGN(virtio_gpu_dev->smem_len, VIRTIO_PAGE_SIZE); + virtio_gpu_dev->framebuffer = rt_malloc_align(virtio_gpu_dev->smem_len, VIRTIO_PAGE_SIZE); + + if (virtio_gpu_dev->framebuffer == RT_NULL) + { + virtio_gpu_unref_resource(virtio_gpu_dev, virtio_gpu_dev->display_resource_id); + + status = -RT_ENOMEM; + break; + } + + status = virtio_gpu_attach_backing_resource(virtio_gpu_dev, + virtio_gpu_dev->display_resource_id, virtio_gpu_dev->framebuffer, virtio_gpu_dev->smem_len); + + if (status != RT_EOK) + { + break; + } + + status = virtio_gpu_set_scanout(virtio_gpu_dev, virtio_gpu_dev->pmode_id, virtio_gpu_dev->display_resource_id, + virtio_gpu_dev->pmode.r.width, virtio_gpu_dev->pmode.r.height); + + break; + case VIRTIO_DEVICE_CTRL_CURSOR_SETUP: + + if (virtio_gpu_dev->pmode_id == VIRTIO_GPU_INVALID_PMODE_ID) + { + status = -RT_ERROR; + break; + } + + rt_mutex_take(&virtio_gpu_dev->ops_mutex, RT_WAITING_FOREVER); + + status = virtio_gpu_create_2d_resource(virtio_gpu_dev, virtio_gpu_dev->format, + &virtio_gpu_dev->cursor_resource_id, VIRTIO_GPU_CURSOR_WIDTH, VIRTIO_GPU_CURSOR_HEIGHT); + + if (status != RT_EOK) + { + goto _cursor_setup_end; + } + + status = virtio_gpu_cursor_set_img(virtio_gpu_dev, args); + + if (status != RT_EOK) + { + goto _cursor_setup_end; + } + + virtio_gpu_dev->cursor_x = 0; + virtio_gpu_dev->cursor_y = 0; + + status = virtio_gpu_update_cursor(virtio_gpu_dev, virtio_gpu_dev->pmode_id, virtio_gpu_dev->cursor_resource_id, + virtio_gpu_dev->cursor_x, virtio_gpu_dev->cursor_y); + + if (status == RT_EOK) + { + virtio_gpu_dev->cursor_enable = RT_TRUE; + } + +_cursor_setup_end: + rt_mutex_release(&virtio_gpu_dev->ops_mutex); + + break; + case VIRTIO_DEVICE_CTRL_CURSOR_SET_IMG: + + if (virtio_gpu_dev->pmode_id == VIRTIO_GPU_INVALID_PMODE_ID || !virtio_gpu_dev->cursor_enable) + { + status = -RT_ERROR; + break; + } + + rt_mutex_take(&virtio_gpu_dev->ops_mutex, RT_WAITING_FOREVER); + + status = virtio_gpu_cursor_set_img(virtio_gpu_dev, args); + + if (status != RT_EOK) + { + goto _cursor_set_img_end; + } + + status = virtio_gpu_update_cursor(virtio_gpu_dev, virtio_gpu_dev->pmode_id, virtio_gpu_dev->cursor_resource_id, + virtio_gpu_dev->cursor_x, virtio_gpu_dev->cursor_y); + +_cursor_set_img_end: + rt_mutex_release(&virtio_gpu_dev->ops_mutex); + + break; + case VIRTIO_DEVICE_CTRL_CURSOR_MOVE: + + if (virtio_gpu_dev->pmode_id == VIRTIO_GPU_INVALID_PMODE_ID || !virtio_gpu_dev->cursor_enable) + { + status = -RT_ERROR; + break; + } + + rt_mutex_take(&virtio_gpu_dev->ops_mutex, RT_WAITING_FOREVER); + + virtio_gpu_dev->cursor_x = ((rt_uint32_t *)args)[0]; + virtio_gpu_dev->cursor_y = ((rt_uint32_t *)args)[1]; + + status = virtio_gpu_cursor_move(virtio_gpu_dev, virtio_gpu_dev->pmode_id, virtio_gpu_dev->cursor_resource_id, + virtio_gpu_dev->cursor_x, virtio_gpu_dev->cursor_y); + + rt_mutex_release(&virtio_gpu_dev->ops_mutex); + + break; + default: + status = -RT_EINVAL; + break; + } + + return status; +} + +const static struct rt_device_ops virtio_gpu_ops = +{ + virtio_gpu_init, + RT_NULL, + RT_NULL, + virtio_gpu_read, + virtio_gpu_write, + virtio_gpu_control +}; + +static void virtio_gpu_set_pixel(const char *pixel, int x, int y) +{ + rt_uint8_t *fb; + struct virtio_gpu_device *virtio_gpu_dev = _primary_virtio_gpu_dev; + + if (virtio_gpu_dev == RT_NULL || virtio_gpu_dev->pmode_id == VIRTIO_GPU_INVALID_PMODE_ID) + { + return; + } + + fb = (rt_uint8_t *)virtio_gpu_dev->framebuffer; + fb += (y * virtio_gpu_dev->pmode.r.width + x) * VIRTIO_GPU_FORMAT_PIXEL; + *((rt_uint32_t *)fb) = *((rt_uint32_t *)pixel); +} + +static void virtio_gpu_get_pixel(char *pixel, int x, int y) +{ + rt_uint8_t *fb; + struct virtio_gpu_device *virtio_gpu_dev = _primary_virtio_gpu_dev; + + if (virtio_gpu_dev == RT_NULL || virtio_gpu_dev->pmode_id == VIRTIO_GPU_INVALID_PMODE_ID) + { + return; + } + + fb = (rt_uint8_t *)virtio_gpu_dev->framebuffer; + *((rt_uint32_t *)pixel) = *(fb + (y * virtio_gpu_dev->pmode.r.width + x) * VIRTIO_GPU_FORMAT_PIXEL); +} + +static void virtio_gpu_draw_hline(const char *pixel, int x1, int x2, int y) +{ + int i; + rt_uint8_t *fb; + rt_uint32_t color = *((rt_uint32_t *)pixel); + struct virtio_gpu_device *virtio_gpu_dev = _primary_virtio_gpu_dev; + + if (virtio_gpu_dev == RT_NULL || virtio_gpu_dev->pmode_id == VIRTIO_GPU_INVALID_PMODE_ID || + x1 < 0 || x2 < 0 || y < 0) + { + return; + } + + if (x1 > x2) + { + x1 ^= x2; + x2 ^= x1; + x1 ^= x2; + } + + fb = (rt_uint8_t *)virtio_gpu_dev->framebuffer; + fb += (y * virtio_gpu_dev->pmode.r.width + x1) * VIRTIO_GPU_FORMAT_PIXEL; + + for (i = x1; i < x2; ++i) + { + *((rt_uint32_t *)fb) = color; + + fb += VIRTIO_GPU_FORMAT_PIXEL; + } +} + +static void virtio_gpu_draw_vline(const char *pixel, int x, int y1, int y2) +{ + int i; + rt_uint8_t *fb; + rt_uint16_t pitch; + rt_uint32_t color = *((rt_uint32_t *)pixel); + struct virtio_gpu_device *virtio_gpu_dev = _primary_virtio_gpu_dev; + + if (virtio_gpu_dev == RT_NULL || virtio_gpu_dev->pmode_id == VIRTIO_GPU_INVALID_PMODE_ID || + x < 0 || y1 < 0 || y2 < 0) + { + return; + } + + if (y1 > y2) + { + y1 ^= y2; + y2 ^= y1; + y1 ^= y2; + } + + fb = (rt_uint8_t *)virtio_gpu_dev->framebuffer; + fb += (y1 * virtio_gpu_dev->pmode.r.width + x) * VIRTIO_GPU_FORMAT_PIXEL; + + pitch = virtio_gpu_dev->pmode.r.width * VIRTIO_GPU_FORMAT_PIXEL; + + for (i = y1; i < y2; ++i) + { + *((rt_uint32_t *)fb) = color; + + fb += pitch; + } +} + +static void virtio_gpu_blit_line(const char *pixel, int x, int y, rt_size_t size) +{ + int i; + rt_uint8_t *fb; + rt_uint32_t *colors = (rt_uint32_t *)pixel; + struct virtio_gpu_device *virtio_gpu_dev = _primary_virtio_gpu_dev; + + if (virtio_gpu_dev == RT_NULL || virtio_gpu_dev->pmode_id == VIRTIO_GPU_INVALID_PMODE_ID || x < 0 || y < 0) + { + return; + } + + fb = (rt_uint8_t *)virtio_gpu_dev->framebuffer; + fb += (y * virtio_gpu_dev->pmode.r.width + x) * VIRTIO_GPU_FORMAT_PIXEL; + + for (i = 0; i < size; ++i) + { + *((rt_uint32_t *)fb) = *colors++; + fb += VIRTIO_GPU_FORMAT_PIXEL; + } +} + +static struct rt_device_graphic_ops virtio_gpu_graphic_ops = +{ + virtio_gpu_set_pixel, + virtio_gpu_get_pixel, + virtio_gpu_draw_hline, + virtio_gpu_draw_vline, + virtio_gpu_blit_line +}; + +static void virtio_gpu_isr(int irqno, void *param) +{ + rt_uint16_t id; + struct virtio_gpu_device *virtio_gpu_dev = (struct virtio_gpu_device *)param; + struct virtio_device *virtio_dev = &virtio_gpu_dev->virtio_dev; + struct virtq *queue_ctrl = &virtio_dev->queues[VIRTIO_GPU_QUEUE_CTRL]; + struct virtq *queue_cursor = &virtio_dev->queues[VIRTIO_GPU_QUEUE_CURSOR]; + +#ifdef RT_USING_SMP + rt_base_t level = rt_spin_lock_irqsave(&virtio_dev->spinlock); +#endif + + virtio_interrupt_ack(virtio_dev); + rt_hw_dsb(); + + while (queue_ctrl->used_idx != queue_ctrl->used->idx) + { + rt_hw_dsb(); + id = queue_ctrl->used->ring[queue_ctrl->used_idx % queue_ctrl->num].id; + + virtio_gpu_dev->info[id].ctrl_valid = RT_FALSE; + rt_thread_yield(); + + queue_ctrl->used_idx++; + } + + while (queue_cursor->used_idx != queue_cursor->used->idx) + { + rt_hw_dsb(); + id = queue_cursor->used->ring[queue_cursor->used_idx % queue_cursor->num].id; + + virtio_gpu_dev->info[id].cursor_valid = RT_FALSE; + rt_thread_yield(); + + queue_cursor->used_idx++; + } + +#ifdef RT_USING_SMP + rt_spin_unlock_irqrestore(&virtio_dev->spinlock, level); +#endif +} + +rt_err_t rt_virtio_gpu_init(rt_ubase_t *mmio_base, rt_uint32_t irq) +{ + static int dev_no = 0; + char dev_name[RT_NAME_MAX]; + struct virtio_device *virtio_dev; + struct virtio_gpu_device *virtio_gpu_dev; + + virtio_gpu_dev = rt_malloc(sizeof(struct virtio_gpu_device)); + + if (virtio_gpu_dev == RT_NULL) + { + goto _alloc_fail; + } + + virtio_dev = &virtio_gpu_dev->virtio_dev; + virtio_dev->irq = irq; + virtio_dev->mmio_base = mmio_base; + + virtio_gpu_dev->pmode_id = VIRTIO_GPU_INVALID_PMODE_ID; + virtio_gpu_dev->display_resource_id = 0; + virtio_gpu_dev->cursor_resource_id = 0; + virtio_gpu_dev->next_resource_id = 0; + virtio_gpu_dev->framebuffer = RT_NULL; + virtio_gpu_dev->smem_len = 0; + virtio_gpu_dev->cursor_enable = RT_FALSE; + +#ifdef RT_USING_SMP + rt_spin_lock_init(&virtio_dev->spinlock); +#endif + + virtio_reset_device(virtio_dev); + virtio_status_acknowledge_driver(virtio_dev); + + virtio_dev->mmio_config->driver_features = virtio_dev->mmio_config->device_features & ~( + (1 << VIRTIO_F_RING_EVENT_IDX) | + (1 << VIRTIO_F_RING_INDIRECT_DESC)); + + virtio_status_driver_ok(virtio_dev); + + if (virtio_queue_init(virtio_dev, VIRTIO_GPU_QUEUE_CTRL, VIRTIO_GPU_QUEUE_SIZE) != RT_EOK) + { + goto _alloc_fail; + } + + if (virtio_queue_init(virtio_dev, VIRTIO_GPU_QUEUE_CURSOR, VIRTIO_GPU_QUEUE_SIZE) != RT_EOK) + { + virtio_queue_destroy(virtio_dev, VIRTIO_GPU_QUEUE_CTRL); + + goto _alloc_fail; + } + + virtio_gpu_dev->parent.type = RT_Device_Class_Graphic; + virtio_gpu_dev->parent.ops = &virtio_gpu_ops; + virtio_gpu_dev->parent.user_data = &virtio_gpu_graphic_ops; + + rt_snprintf(dev_name, RT_NAME_MAX, "virtio-gpu%d", dev_no++); + + rt_mutex_init(&virtio_gpu_dev->rw_mutex, dev_name, RT_IPC_FLAG_PRIO); + rt_mutex_init(&virtio_gpu_dev->ops_mutex, dev_name, RT_IPC_FLAG_PRIO); + + rt_hw_interrupt_install(irq, virtio_gpu_isr, virtio_gpu_dev, dev_name); + rt_hw_interrupt_umask(irq); + + return rt_device_register((rt_device_t)virtio_gpu_dev, dev_name, RT_DEVICE_FLAG_RDWR); + +_alloc_fail: + + if (virtio_gpu_dev != RT_NULL) + { + rt_free(virtio_gpu_dev); + } + return -RT_ENOMEM; +} +#endif /* BSP_USING_VIRTIO_GPU */ diff --git a/bsp/qemu-virt64-aarch64/driver/virtio/virtio_gpu.h b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_gpu.h new file mode 100644 index 0000000000..0c49ecbd2f --- /dev/null +++ b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_gpu.h @@ -0,0 +1,412 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-11-11 GuEe-GUI the first version + */ + +#ifndef __VIRTIO_GPU_H__ +#define __VIRTIO_GPU_H__ + +#include <rtdef.h> + +#include <virtio.h> + +#define VIRTIO_GPU_QUEUE_CTRL 0 +#define VIRTIO_GPU_QUEUE_CURSOR 1 +#define VIRTIO_GPU_QUEUE_SIZE 32 + +#define VIRTIO_GPU_F_VIRGL 0 /* VIRTIO_GPU_CMD_CTX_*, VIRTIO_GPU_CMD_*_3D */ +#define VIRTIO_GPU_F_EDID 1 /* VIRTIO_GPU_CMD_GET_EDID */ +#define VIRTIO_GPU_F_RESOURCE_UUID 2 /* VIRTIO_GPU_CMD_RESOURCE_ASSIGN_UUID */ +#define VIRTIO_GPU_F_RESOURCE_BLOB 3 /* VIRTIO_GPU_CMD_RESOURCE_CREATE_BLOB */ +#define VIRTIO_GPU_F_CONTEXT_INIT 4 /* VIRTIO_GPU_CMD_CREATE_CONTEXT with context_init and multiple timelines */ + +#define VIRTIO_GPU_EVENT_DISPLAY (1 << 0) + +#define VIRTIO_GPU_FORMAT_BPP 32 +#define VIRTIO_GPU_FORMAT_PIXEL 4 +#define VIRTIO_GPU_CURSOR_WIDTH 64 +#define VIRTIO_GPU_CURSOR_HEIGHT 64 +#define VIRTIO_GPU_CURSOR_IMG_SIZE (VIRTIO_GPU_CURSOR_WIDTH * VIRTIO_GPU_CURSOR_HEIGHT * VIRTIO_GPU_FORMAT_PIXEL) +#define VIRTIO_GPU_INVALID_PMODE_ID RT_UINT32_MAX + +/* GPU control */ + +struct virtio_gpu_config +{ + rt_uint32_t events_read; + rt_uint32_t events_clear; + rt_uint32_t num_scanouts; /* 1 ~ 16 */ + rt_uint32_t reserved; +}; + +enum virtio_gpu_ctrl_type +{ + VIRTIO_GPU_UNDEFINED = 0, + + /* 2d commands */ + VIRTIO_GPU_CMD_GET_DISPLAY_INFO = 0x0100, + VIRTIO_GPU_CMD_RESOURCE_CREATE_2D, + VIRTIO_GPU_CMD_RESOURCE_UNREF, + VIRTIO_GPU_CMD_SET_SCANOUT, + VIRTIO_GPU_CMD_RESOURCE_FLUSH, + VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D, + VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING, + VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING, + VIRTIO_GPU_CMD_GET_CAPSET_INFO, + VIRTIO_GPU_CMD_GET_CAPSET, + VIRTIO_GPU_CMD_GET_EDID, + VIRTIO_GPU_CMD_RESOURCE_ASSIGN_UUID, + VIRTIO_GPU_CMD_RESOURCE_CREATE_BLOB, + VIRTIO_GPU_CMD_SET_SCANOUT_BLOB, + + /* 3d commands */ + VIRTIO_GPU_CMD_CTX_CREATE = 0x0200, + VIRTIO_GPU_CMD_CTX_DESTROY, + VIRTIO_GPU_CMD_CTX_ATTACH_RESOURCE, + VIRTIO_GPU_CMD_CTX_DETACH_RESOURCE, + VIRTIO_GPU_CMD_RESOURCE_CREATE_3D, + VIRTIO_GPU_CMD_TRANSFER_TO_HOST_3D, + VIRTIO_GPU_CMD_TRANSFER_FROM_HOST_3D, + VIRTIO_GPU_CMD_SUBMIT_3D, + VIRTIO_GPU_CMD_RESOURCE_MAP_BLOB, + VIRTIO_GPU_CMD_RESOURCE_UNMAP_BLOB, + + /* cursor commands */ + VIRTIO_GPU_CMD_UPDATE_CURSOR = 0x0300, + VIRTIO_GPU_CMD_MOVE_CURSOR, + + /* success responses */ + VIRTIO_GPU_RESP_OK_NODATA = 0x1100, + VIRTIO_GPU_RESP_OK_DISPLAY_INFO, + VIRTIO_GPU_RESP_OK_CAPSET_INFO, + VIRTIO_GPU_RESP_OK_CAPSET, + VIRTIO_GPU_RESP_OK_EDID, + VIRTIO_GPU_RESP_OK_RESOURCE_UUID, + VIRTIO_GPU_RESP_OK_MAP_INFO, + + /* error responses */ + VIRTIO_GPU_RESP_ERR_UNSPEC = 0x1200, + VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY, + VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID, + VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID, + VIRTIO_GPU_RESP_ERR_INVALID_CONTEXT_ID, + VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER, +}; + +#define VIRTIO_GPU_FLAG_FENCE (1 << 0) + +struct virtio_gpu_ctrl_hdr +{ + rt_uint32_t type; + rt_uint32_t flags; + rt_uint64_t fence_id; + rt_uint32_t ctx_id; + rt_uint8_t ring_idx; + rt_uint8_t padding[3]; +}; + +#define VIRTIO_GPU_MAX_SCANOUTS 16 + +struct virtio_gpu_rect +{ + rt_uint32_t x; + rt_uint32_t y; + rt_uint32_t width; + rt_uint32_t height; +}; + +struct virtio_gpu_resp_display_info +{ + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_display_one + { + struct virtio_gpu_rect r; + rt_uint32_t enabled; + rt_uint32_t flags; + } pmodes[VIRTIO_GPU_MAX_SCANOUTS]; +}; + +struct virtio_gpu_get_edid +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t scanout; + rt_uint32_t padding; +}; + +struct virtio_gpu_resp_edid +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t size; + rt_uint32_t padding; + rt_uint8_t edid[1024]; +}; + +enum virtio_gpu_formats +{ + VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM = 1, + VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM = 2, + VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM = 3, + VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM = 4, + + VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM = 67, + VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM = 68, + + VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM = 121, + VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM = 134, +}; + +struct virtio_gpu_resource_create_2d +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t resource_id; + rt_uint32_t format; + rt_uint32_t width; + rt_uint32_t height; +}; + +struct virtio_gpu_resource_unref +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t resource_id; + rt_uint32_t padding; +}; + +struct virtio_gpu_set_scanout +{ + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_rect r; + rt_uint32_t scanout_id; + rt_uint32_t resource_id; +}; + +struct virtio_gpu_resource_flush +{ + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_rect r; + rt_uint32_t resource_id; + rt_uint32_t padding; +}; + +struct virtio_gpu_transfer_to_host_2d +{ + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_rect r; + rt_uint64_t offset; + rt_uint32_t resource_id; + rt_uint32_t padding; +}; + +struct virtio_gpu_resource_attach_backing +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t resource_id; + rt_uint32_t nr_entries; +}; + +struct virtio_gpu_mem_entry +{ + rt_uint64_t addr; + rt_uint32_t length; + rt_uint32_t padding; +}; + +struct virtio_gpu_resource_detach_backing +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t resource_id; + rt_uint32_t padding; +}; + +struct virtio_gpu_get_capset_info +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t capset_index; + rt_uint32_t padding; +}; + +#define VIRTIO_GPU_CAPSET_VIRGL 1 +#define VIRTIO_GPU_CAPSET_VIRGL2 2 +#define VIRTIO_GPU_CAPSET_GFXSTREAM 3 +#define VIRTIO_GPU_CAPSET_VENUS 4 +#define VIRTIO_GPU_CAPSET_CROSS_DOMAIN 5 + +struct virtio_gpu_resp_capset_info +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t capset_id; + rt_uint32_t capset_max_version; + rt_uint32_t capset_max_size; + rt_uint32_t padding; +}; + +struct virtio_gpu_get_capset +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t capset_id; + rt_uint32_t capset_version; +}; + +struct virtio_gpu_resp_capset +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint8_t capset_data[]; +}; + +struct virtio_gpu_resource_assign_uuid +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t resource_id; + rt_uint32_t padding; +}; + +struct virtio_gpu_resp_resource_uuid +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint8_t uuid[16]; +}; + +#define VIRTIO_GPU_BLOB_MEM_GUEST 0x0001 +#define VIRTIO_GPU_BLOB_MEM_HOST3D 0x0002 +#define VIRTIO_GPU_BLOB_MEM_HOST3D_GUEST 0x0003 + +#define VIRTIO_GPU_BLOB_FLAG_USE_MAPPABLE 0x0001 +#define VIRTIO_GPU_BLOB_FLAG_USE_SHAREABLE 0x0002 +#define VIRTIO_GPU_BLOB_FLAG_USE_CROSS_DEVICE 0x0004 + +struct virtio_gpu_resource_create_blob +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t resource_id; + rt_uint32_t blob_mem; + rt_uint32_t blob_flags; + rt_uint32_t nr_entries; + rt_uint64_t blob_id; + rt_uint64_t size; +}; + +struct virtio_gpu_set_scanout_blob +{ + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_rect r; + rt_uint32_t scanout_id; + rt_uint32_t resource_id; + rt_uint32_t width; + rt_uint32_t height; + rt_uint32_t format; + rt_uint32_t padding; + rt_uint32_t strides[4]; + rt_uint32_t offsets[4]; +}; + +#define VIRTIO_GPU_CONTEXT_INIT_CAPSET_ID_MASK 0x000000ff +struct virtio_gpu_ctx_create +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t nlen; + rt_uint32_t context_init; + char debug_name[64]; +}; + +struct virtio_gpu_resource_map_blob +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t resource_id; + rt_uint32_t padding; + rt_uint64_t offset; +}; + +#define VIRTIO_GPU_MAP_CACHE_MASK 0x0f +#define VIRTIO_GPU_MAP_CACHE_NONE 0x00 +#define VIRTIO_GPU_MAP_CACHE_CACHED 0x01 +#define VIRTIO_GPU_MAP_CACHE_UNCACHED 0x02 +#define VIRTIO_GPU_MAP_CACHE_WC 0x03 + +struct virtio_gpu_resp_map_info +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t map_info; + rt_uint32_t padding; +}; + +struct virtio_gpu_resource_unmap_blob +{ + struct virtio_gpu_ctrl_hdr hdr; + rt_uint32_t resource_id; + rt_uint32_t padding; +}; + +/* GPU cursor */ + +struct virtio_gpu_cursor_pos +{ + rt_uint32_t scanout_id; + rt_uint32_t x; + rt_uint32_t y; + rt_uint32_t padding; +}; + +struct virtio_gpu_update_cursor +{ + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_cursor_pos pos; + rt_uint32_t resource_id; + rt_uint32_t hot_x; + rt_uint32_t hot_y; + rt_uint32_t padding; +}; + +struct virtio_gpu_device +{ + struct rt_device parent; + + struct virtio_device virtio_dev; + + /* Current display's info */ + struct virtio_gpu_display_one pmode; + enum virtio_gpu_formats format; + rt_uint32_t pmode_id; + rt_uint32_t cursor_x, cursor_y; + rt_uint32_t display_resource_id; + rt_uint32_t cursor_resource_id; + rt_uint32_t next_resource_id; + + /* Display framebuffer */ + struct rt_mutex rw_mutex; + void *framebuffer; + rt_uint32_t smem_len; + + /* Cursor image info */ + rt_bool_t cursor_enable; + struct rt_mutex ops_mutex; + rt_uint8_t cursor_img[VIRTIO_GPU_CURSOR_IMG_SIZE]; + + /* GPU request info */ + struct virtio_gpu_resp_display_info gpu_request; + + struct + { + rt_bool_t ctrl_valid; + rt_bool_t cursor_valid; + + struct virtio_gpu_update_cursor cursor_cmd; + } info[VIRTIO_GPU_QUEUE_SIZE]; +}; + +rt_err_t rt_virtio_gpu_init(rt_ubase_t *mmio_base, rt_uint32_t irq); + +enum +{ + VIRTIO_DEVICE_CTRL_GPU_SET_PRIMARY = 0x20, + VIRTIO_DEVICE_CTRL_GPU_CREATE_2D, + + VIRTIO_DEVICE_CTRL_CURSOR_SETUP, + VIRTIO_DEVICE_CTRL_CURSOR_SET_IMG, + VIRTIO_DEVICE_CTRL_CURSOR_MOVE, +}; + +#endif /* __VIRTIO_GPU_H__ */ diff --git a/bsp/qemu-virt64-aarch64/driver/virtio/virtio_input.c b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_input.c new file mode 100644 index 0000000000..6bd21bec92 --- /dev/null +++ b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_input.c @@ -0,0 +1,432 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-11-11 GuEe-GUI the first version + */ + +#include <rthw.h> +#include <rtthread.h> +#include <cpuport.h> + +#ifdef BSP_USING_VIRTIO_INPUT + +#include <virtio_input.h> + +static void _set_bit(rt_uint32_t nr, volatile rt_ubase_t *addr) +{ + rt_ubase_t mask = BIT_MASK(nr); + rt_ubase_t *p = ((rt_ubase_t *)addr) + BIT_WORD(nr); + + *p |= mask; +} + +static rt_size_t virtio_input_cfg_select(struct virtio_input_device *virtio_input_dev, + rt_uint8_t select, rt_uint8_t subsel) +{ + struct virtio_input_config *config = virtio_input_dev->config; + + rt_hw_dsb(); + config->select = select; + config->subsel = subsel; + rt_hw_dsb(); + + return config->size; +} + +static void virtio_input_cfg_bits(struct virtio_input_device *virtio_input_dev, + rt_uint8_t select, rt_uint8_t subsel, rt_ubase_t *bits, rt_uint32_t bitcount) +{ + int i; + rt_uint32_t bit; + rt_uint8_t bytes; + rt_uint8_t *virtio_bits; + void *config_base = virtio_input_dev->config; + rt_off_t offset = (rt_size_t)&((struct virtio_input_config *)0)->bitmap; + + bytes = virtio_input_cfg_select(virtio_input_dev, select, subsel); + + if (bytes == 0) + { + return; + } + + if (bitcount > bytes * 8) + { + bitcount = bytes * 8; + } + + /* + * Bitmap in virtio config space is a simple stream of bytes, + * with the first byte carrying bits 0-7, second bits 8-15 and + * so on. + */ + virtio_bits = rt_malloc(bytes); + + if (virtio_bits == RT_NULL) + { + return; + } + + for (i = 0; i < bytes; ++i) + { + void *buffer = (void *)virtio_bits + i; + + if (virtio_input_dev->virtio_dev.mmio_config->version == 1) + { + HWREG8(config_base + offset + i) = *((rt_uint8_t *)buffer); + } + else + { + rt_memcpy(config_base + offset + i, buffer, sizeof(rt_uint8_t)); + } + } + + for (bit = 0; bit < bitcount; ++bit) + { + if (virtio_bits[bit / 8] & (1 << (bit % 8))) + { + _set_bit(bit, bits); + } + } + + rt_free(virtio_bits); + + if (select == VIRTIO_INPUT_CFG_EV_BITS) + { + _set_bit(subsel, virtio_input_dev->ev_bit); + } +} + +static rt_err_t virtio_input_init(rt_device_t dev) +{ + int i; + rt_uint16_t idx[VIRTIO_INPUT_QUEUE_MAX_SIZE]; + struct virtio_input_device *virtio_input_dev = (struct virtio_input_device *)dev; + struct virtio_device *virtio_dev = &virtio_input_dev->virtio_dev; + struct virtq *queue_event, *queue_status; + + virtio_input_cfg_bits(virtio_input_dev, VIRTIO_INPUT_CFG_EV_BITS, EV_KEY, virtio_input_dev->key_bit, KEY_CNT); + virtio_input_cfg_bits(virtio_input_dev, VIRTIO_INPUT_CFG_EV_BITS, EV_REL, virtio_input_dev->rel_bit, REL_CNT); + virtio_input_cfg_bits(virtio_input_dev, VIRTIO_INPUT_CFG_EV_BITS, EV_ABS, virtio_input_dev->abs_bit, ABS_CNT); + + queue_event = &virtio_dev->queues[VIRTIO_INPUT_QUEUE_EVENT]; + queue_status = &virtio_dev->queues[VIRTIO_INPUT_QUEUE_STATUS]; + + virtio_alloc_desc_chain(virtio_dev, VIRTIO_INPUT_QUEUE_EVENT, queue_event->num, idx); + virtio_alloc_desc_chain(virtio_dev, VIRTIO_INPUT_QUEUE_STATUS, queue_status->num, idx); + + for (i = 0; i < queue_event->num; ++i) + { + rt_uint16_t id = i; + void *addr = &virtio_input_dev->recv_events[i]; + + virtio_fill_desc(virtio_dev, VIRTIO_INPUT_QUEUE_EVENT, id, + VIRTIO_VA2PA(addr), sizeof(struct virtio_input_event), VIRTQ_DESC_F_WRITE, 0); + + virtio_submit_chain(virtio_dev, VIRTIO_INPUT_QUEUE_EVENT, id); + } + rt_hw_dsb(); + + queue_event->avail->flags = 0; + queue_status->avail->flags = VIRTQ_AVAIL_F_NO_INTERRUPT; + + virtio_queue_notify(virtio_dev, VIRTIO_INPUT_QUEUE_EVENT); + + return RT_EOK; +} + +static rt_size_t virtio_input_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size) +{ + struct virtio_input_device *virtio_input_dev = (struct virtio_input_device *)dev; + + if (buffer == RT_NULL || pos + size >= virtio_input_dev->virtio_dev.queues[VIRTIO_INPUT_QUEUE_EVENT].num) + { + return 0; + } + + rt_mutex_take(&virtio_input_dev->rw_mutex, RT_WAITING_FOREVER); + + rt_memcpy(buffer, &virtio_input_dev->bcst_events[pos], size); + + rt_mutex_release(&virtio_input_dev->rw_mutex); + + return size; +} + +static rt_size_t virtio_input_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size) +{ + struct virtio_input_device *virtio_input_dev = (struct virtio_input_device *)dev; + + if (buffer == RT_NULL || pos + size >= virtio_input_dev->virtio_dev.queues[VIRTIO_INPUT_QUEUE_EVENT].num) + { + return 0; + } + + rt_mutex_take(&virtio_input_dev->rw_mutex, RT_WAITING_FOREVER); + + rt_memcpy(&virtio_input_dev->bcst_events[pos], buffer, size); + + rt_mutex_release(&virtio_input_dev->rw_mutex); + + return size; +} + +static rt_err_t virtio_input_control(rt_device_t dev, int cmd, void *args) +{ + rt_err_t status = RT_EOK; + struct virtio_input_device *virtio_input_dev = (struct virtio_input_device *)dev; + struct virtio_device *virtio_dev = &virtio_input_dev->virtio_dev; + struct virtio_input_config *config = virtio_input_dev->config; + + if (args == RT_NULL) + { + return -RT_ERROR; + } + + switch (cmd) + { + case VIRTIO_DEVICE_CTRL_INPUT_GET_TYPE: + + *(enum virtio_input_type *)args = virtio_input_dev->type; + + break; + case VIRTIO_DEVICE_CTRL_INPUT_BIND_BSCT_HANDLER: + + virtio_input_dev->bsct_handler = args; + + break; + case VIRTIO_DEVICE_CTRL_INPUT_GET_ABS_X_INFO: + + virtio_input_cfg_select(virtio_input_dev, VIRTIO_INPUT_CFG_ABS_INFO, VIRTIO_INPUT_ABS_AXIS_X); + rt_memcpy(args, config, sizeof(struct virtio_input_config)); + + break; + case VIRTIO_DEVICE_CTRL_INPUT_GET_ABS_Y_INFO: + + virtio_input_cfg_select(virtio_input_dev, VIRTIO_INPUT_CFG_ABS_INFO, VIRTIO_INPUT_ABS_AXIS_Y); + rt_memcpy(args, config, sizeof(struct virtio_input_config)); + + break; + case VIRTIO_DEVICE_CTRL_INPUT_SET_STATUS: + { + rt_uint16_t id; + void *addr; + struct virtq *queue_status = &virtio_dev->queues[VIRTIO_INPUT_QUEUE_STATUS]; + +#ifdef RT_USING_SMP + rt_base_t level = rt_spin_lock_irqsave(&virtio_dev->spinlock); +#endif + id = queue_status->avail->idx % queue_status->num; + addr = &virtio_input_dev->xmit_events[id]; + + rt_memcpy(addr, args, sizeof(struct virtio_input_event)); + + virtio_free_desc(virtio_dev, VIRTIO_INPUT_QUEUE_STATUS, id); + + virtio_fill_desc(virtio_dev, VIRTIO_INPUT_QUEUE_STATUS, id, + VIRTIO_VA2PA(addr), sizeof(struct virtio_input_event), 0, 0); + + virtio_submit_chain(virtio_dev, VIRTIO_INPUT_QUEUE_STATUS, id); + + virtio_queue_notify(virtio_dev, VIRTIO_INPUT_QUEUE_STATUS); + + virtio_alloc_desc(virtio_dev, VIRTIO_INPUT_QUEUE_STATUS); + +#ifdef RT_USING_SMP + rt_spin_unlock_irqrestore(&virtio_dev->spinlock, level); +#endif + } + break; + case VIRTIO_DEVICE_CTRL_INPUT_GET_EV_BIT: + + rt_memcpy(args, virtio_input_dev->ev_bit, sizeof(virtio_input_dev->ev_bit)); + + break; + case VIRTIO_DEVICE_CTRL_INPUT_GET_KEY_BIT: + + rt_memcpy(args, virtio_input_dev->key_bit, sizeof(virtio_input_dev->key_bit)); + + break; + case VIRTIO_DEVICE_CTRL_INPUT_GET_REL_BIT: + + rt_memcpy(args, virtio_input_dev->rel_bit, sizeof(virtio_input_dev->rel_bit)); + + break; + case VIRTIO_DEVICE_CTRL_INPUT_GET_ABS_BIT: + + rt_memcpy(args, virtio_input_dev->abs_bit, sizeof(virtio_input_dev->abs_bit)); + + break; + default: + status = -RT_EINVAL; + break; + } + + return status; +} + +const static struct rt_device_ops virtio_input_ops = +{ + virtio_input_init, + RT_NULL, + RT_NULL, + virtio_input_read, + virtio_input_write, + virtio_input_control +}; + +static void virtio_input_isr(int irqno, void *param) +{ + struct virtio_input_device *virtio_input_dev = (struct virtio_input_device *)param; + struct virtio_device *virtio_dev = &virtio_input_dev->virtio_dev; + struct virtq *event_queue = &virtio_dev->queues[VIRTIO_INPUT_QUEUE_EVENT]; + const char *dev_name = virtio_input_dev->parent.parent.name; + +#ifdef RT_USING_SMP + rt_base_t level = rt_spin_lock_irqsave(&virtio_dev->spinlock); +#endif + + virtio_interrupt_ack(virtio_dev); + rt_hw_dsb(); + + while (event_queue->used_idx != event_queue->used->idx) + { + rt_uint16_t id = event_queue->used->ring[event_queue->used_idx % event_queue->num].id; + rt_uint32_t len = event_queue->used->ring[event_queue->used_idx % event_queue->num].len; + + if (len == sizeof(struct virtio_input_event)) + { + struct virtio_input_event *recv_events = &virtio_input_dev->recv_events[id]; + struct virtio_input_event *bcst_events = &virtio_input_dev->bcst_events[id]; + + if (recv_events->type >= EV_SYN && recv_events->type <= EV_ABS) + { + bcst_events->type = recv_events->type; + bcst_events->code = recv_events->code; + bcst_events->value = recv_events->value; + + if (virtio_input_dev->bsct_handler != RT_NULL) + { + virtio_input_dev->bsct_handler(*bcst_events); + } + } + else + { + rt_kprintf("%s: Unsupport event[type: %02x, code: %02x, value: %08x]!\n", + dev_name, recv_events->type, recv_events->code, recv_events->value); + } + } + else + { + rt_kprintf("%s: Invalid event!\n", dev_name); + } + + event_queue->used_idx++; + + virtio_submit_chain(virtio_dev, VIRTIO_INPUT_QUEUE_EVENT, id); + + virtio_queue_notify(virtio_dev, VIRTIO_INPUT_QUEUE_EVENT); + } + +#ifdef RT_USING_SMP + rt_spin_unlock_irqrestore(&virtio_dev->spinlock, level); +#endif +} + +rt_err_t rt_virtio_input_init(rt_ubase_t *mmio_base, rt_uint32_t irq) +{ + rt_uint32_t flag; + static int dev_no = 0; + char dev_name[RT_NAME_MAX]; + struct virtio_device *virtio_dev; + struct virtio_input_device *virtio_input_dev; + + virtio_input_dev = rt_malloc(sizeof(struct virtio_input_device)); + + if (virtio_input_dev == RT_NULL) + { + goto _alloc_fail; + } + + virtio_dev = &virtio_input_dev->virtio_dev; + virtio_dev->irq = irq; + virtio_dev->mmio_base = mmio_base; + + virtio_input_dev->config = (struct virtio_input_config *)virtio_dev->mmio_config->config; + virtio_input_dev->bsct_handler = RT_NULL; + +#ifdef RT_USING_SMP + rt_spin_lock_init(&virtio_dev->spinlock); +#endif + + virtio_reset_device(virtio_dev); + virtio_status_acknowledge_driver(virtio_dev); + + virtio_dev->mmio_config->driver_features = virtio_dev->mmio_config->device_features & ~( + (1 << VIRTIO_F_RING_EVENT_IDX) | + (1 << VIRTIO_F_RING_INDIRECT_DESC)); + + virtio_status_driver_ok(virtio_dev); + + if (virtio_queue_init(virtio_dev, VIRTIO_INPUT_QUEUE_EVENT, VIRTIO_INPUT_EVENT_QUEUE_SIZE) != RT_EOK) + { + goto _alloc_fail; + } + + if (virtio_queue_init(virtio_dev, VIRTIO_INPUT_QUEUE_STATUS, VIRTIO_INPUT_STATUS_QUEUE_SIZE) != RT_EOK) + { + virtio_queue_destroy(virtio_dev, VIRTIO_INPUT_QUEUE_EVENT); + + goto _alloc_fail; + } + + virtio_input_cfg_select(virtio_input_dev, VIRTIO_INPUT_CFG_ID_DEVIDS, 0); + + if (virtio_input_dev->config->ids.product == EV_ABS) + { + virtio_input_dev->type = VIRTIO_INPUT_TYPE_TABLET; + + virtio_input_dev->parent.type = RT_Device_Class_Touch; + + flag = RT_DEVICE_FLAG_STANDALONE | RT_DEVICE_FLAG_INT_RX; + } + else + { + if (virtio_input_dev->config->ids.product == EV_KEY) + { + virtio_input_dev->type = VIRTIO_INPUT_TYPE_KEYBOARD; + } + else + { + virtio_input_dev->type = VIRTIO_INPUT_TYPE_MOUSE; + } + + /* Replace it to "KeyBoard" or "Mouse" if support in the future */ + virtio_input_dev->parent.type = RT_Device_Class_Miscellaneous; + + flag = RT_DEVICE_FLAG_RDWR; + } + virtio_input_dev->parent.ops = &virtio_input_ops; + + rt_snprintf(dev_name, RT_NAME_MAX, "virtio-input%d", dev_no++); + + rt_mutex_init(&virtio_input_dev->rw_mutex, dev_name, RT_IPC_FLAG_PRIO); + + rt_hw_interrupt_install(irq, virtio_input_isr, virtio_input_dev, dev_name); + rt_hw_interrupt_umask(irq); + + return rt_device_register((rt_device_t)virtio_input_dev, dev_name, flag); + +_alloc_fail: + + if (virtio_input_dev != RT_NULL) + { + rt_free(virtio_input_dev); + } + return -RT_ENOMEM; +} +#endif /* BSP_USING_VIRTIO_INPUT */ diff --git a/bsp/qemu-virt64-aarch64/driver/virtio/virtio_input.h b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_input.h new file mode 100644 index 0000000000..367d0a5d6d --- /dev/null +++ b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_input.h @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-11-11 GuEe-GUI the first version + */ + +#ifndef __VIRTIO_INPUT_H__ +#define __VIRTIO_INPUT_H__ + +#include <rtdef.h> + +#include <virtio.h> +#include <virtio_input_event_codes.h> + +#define VIRTIO_INPUT_QUEUE_EVENT 0 +#define VIRTIO_INPUT_QUEUE_STATUS 1 +#define VIRTIO_INPUT_EVENT_QUEUE_SIZE 64 +#define VIRTIO_INPUT_STATUS_QUEUE_SIZE 8 +#define VIRTIO_INPUT_QUEUE_MAX_SIZE (VIRTIO_INPUT_EVENT_QUEUE_SIZE > VIRTIO_INPUT_STATUS_QUEUE_SIZE ? \ + VIRTIO_INPUT_EVENT_QUEUE_SIZE : VIRTIO_INPUT_STATUS_QUEUE_SIZE) + +#define VIRTIO_INPUT_ABS_AXIS_X 0 +#define VIRTIO_INPUT_ABS_AXIS_Y 1 + +enum virtio_input_type +{ + VIRTIO_INPUT_TYPE_KEYBOARD, + VIRTIO_INPUT_TYPE_MOUSE, + VIRTIO_INPUT_TYPE_TABLET, + + VIRTIO_INPUT_TYPE_SIZE, +}; + +enum virtio_input_config_select +{ + VIRTIO_INPUT_CFG_UNSET = 0x00, + VIRTIO_INPUT_CFG_ID_NAME = 0x01, + VIRTIO_INPUT_CFG_ID_SERIAL = 0x02, + VIRTIO_INPUT_CFG_ID_DEVIDS = 0x03, + VIRTIO_INPUT_CFG_PROP_BITS = 0x10, + VIRTIO_INPUT_CFG_EV_BITS = 0x11, + VIRTIO_INPUT_CFG_ABS_INFO = 0x12, +}; + +struct virtio_input_absinfo +{ + rt_uint32_t min; /* Minimum value for the axis */ + rt_uint32_t max; /* Maximum value for the axis */ + rt_uint32_t fuzz; /* Fuzz value that is used to filter noise from the event stream */ + rt_uint32_t flat; /* Within this value will be discarded by joydev interface and reported as 0 instead */ + rt_uint32_t res; /* Resolution for the values reported for the axis */ +}; + +struct virtio_input_devids +{ + rt_uint16_t bustype; + rt_uint16_t vendor; + rt_uint16_t product; + rt_uint16_t version; +}; + +struct virtio_input_config +{ + rt_uint8_t select; + rt_uint8_t subsel; + rt_uint8_t size; + rt_uint8_t reserved[5]; + + union + { + char string[128]; + rt_uint8_t bitmap[128]; + struct virtio_input_absinfo abs; + struct virtio_input_devids ids; + }; +} __attribute__((packed)); + +struct virtio_input_event +{ + rt_uint16_t type; + rt_uint16_t code; + rt_uint32_t value; +}; + +#ifdef ARCH_CPU_64BIT +#define BITS_PER_LONG 64 +#else +#define BITS_PER_LONG 32 +#endif +#define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG)) +#define BIT_WORD(nr) ((nr) / BITS_PER_LONG) +#define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d)) + +#define BITS_PER_BYTE 8 +#define BITS_PER_TYPE(type) (sizeof(type) * BITS_PER_BYTE) +#define BITS_TO_BYTES(nr) DIV_ROUND_UP(nr, BITS_PER_TYPE(char)) +#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_TYPE(long)) + +struct virtio_input_device +{ + struct rt_device parent; + + struct virtio_device virtio_dev; + + rt_ubase_t ev_bit[BITS_TO_LONGS(EV_CNT)]; + rt_ubase_t key_bit[BITS_TO_LONGS(KEY_CNT)]; + rt_ubase_t rel_bit[BITS_TO_LONGS(REL_CNT)]; + rt_ubase_t abs_bit[BITS_TO_LONGS(ABS_CNT)]; + + enum virtio_input_type type; + struct virtio_input_config *config; + + /* Broadcast events */ + struct rt_mutex rw_mutex; + void (*bsct_handler)(struct virtio_input_event event); + struct virtio_input_event bcst_events[VIRTIO_INPUT_EVENT_QUEUE_SIZE]; + + /* Receive events */ + struct virtio_input_event recv_events[VIRTIO_INPUT_EVENT_QUEUE_SIZE]; + + /* Transmit status */ + struct virtio_input_event xmit_events[VIRTIO_INPUT_STATUS_QUEUE_SIZE]; +}; + +enum +{ + VIRTIO_DEVICE_CTRL_INPUT_GET_TYPE = 0x20, + VIRTIO_DEVICE_CTRL_INPUT_BIND_BSCT_HANDLER, + VIRTIO_DEVICE_CTRL_INPUT_GET_ABS_X_INFO, + VIRTIO_DEVICE_CTRL_INPUT_GET_ABS_Y_INFO, + VIRTIO_DEVICE_CTRL_INPUT_SET_STATUS, + + VIRTIO_DEVICE_CTRL_INPUT_GET_EV_BIT, + VIRTIO_DEVICE_CTRL_INPUT_GET_KEY_BIT, + VIRTIO_DEVICE_CTRL_INPUT_GET_REL_BIT, + VIRTIO_DEVICE_CTRL_INPUT_GET_ABS_BIT, +}; + +rt_err_t rt_virtio_input_init(rt_ubase_t *mmio_base, rt_uint32_t irq); + +#endif /* __VIRTIO_INPUT_H__ */ diff --git a/bsp/qemu-virt64-aarch64/driver/virtio/virtio_input_event_codes.h b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_input_event_codes.h new file mode 100644 index 0000000000..b84723374e --- /dev/null +++ b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_input_event_codes.h @@ -0,0 +1,932 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-11-11 GuEe-GUI the first version + */ + +#ifndef __VIRTIO_INPUT_EVENT_CODES__ +#define __VIRTIO_INPUT_EVENT_CODES__ + +/* Device properties and quirks */ +#define INPUT_PROP_POINTER 0x00 /* Needs a pointer */ +#define INPUT_PROP_DIRECT 0x01 /* Direct input devices */ +#define INPUT_PROP_BUTTONPAD 0x02 /* Has button(s) under pad */ +#define INPUT_PROP_SEMI_MT 0x03 /* Touch rectangle only */ +#define INPUT_PROP_TOPBUTTONPAD 0x04 /* Softbuttons at top of pad */ +#define INPUT_PROP_POINTING_STICK 0x05 /* Is a pointing stick */ +#define INPUT_PROP_ACCELEROMETER 0x06 /* Has accelerometer */ + +#define INPUT_PROP_MAX 0x1f +#define INPUT_PROP_CNT (INPUT_PROP_MAX + 1) + +/* Event types */ +#define EV_SYN 0x00 /* Synchronization events */ +#define EV_KEY 0x01 /* Keys and buttons type */ +#define EV_REL 0x02 /* Relative axes events */ +#define EV_ABS 0x03 /* Absolute axes events */ +#define EV_MSC 0x04 /* Misc events */ +#define EV_SW 0x05 /* Switch events */ +#define EV_LED 0x11 /* LEDs events */ +#define EV_SND 0x12 /* Sounds events */ +#define EV_REP 0x14 /* Repeat events */ +#define EV_FF 0x15 /* Force feedback events */ +#define EV_PWR 0x16 /* Power management events */ +#define EV_FF_STATUS 0x17 /* Force feedback state */ +#define EV_MAX 0x1f /* Maximum number of events */ +#define EV_CNT (EV_MAX + 1)/* Event count */ + +/* Synchronization events.*/ +#define SYN_REPORT 0 +#define SYN_CONFIG 1 +#define SYN_MT_REPORT 2 +#define SYN_DROPPED 3 +#define SYN_MAX 0xf +#define SYN_CNT (SYN_MAX + 1) + +/* + * Keys and buttons + * + * Most of the keys/buttons are modeled after USB HUT 1.12 + * (see http://www.usb.org/developers/hidpage). + * Abbreviations in the comments: + * AC - Application Control + * AL - Application Launch Button + * SC - System Control + */ +#define KEY_RESERVED 0 +#define KEY_ESC 1 +#define KEY_1 2 +#define KEY_2 3 +#define KEY_3 4 +#define KEY_4 5 +#define KEY_5 6 +#define KEY_6 7 +#define KEY_7 8 +#define KEY_8 9 +#define KEY_9 10 +#define KEY_0 11 +#define KEY_MINUS 12 +#define KEY_EQUAL 13 +#define KEY_BACKSPACE 14 +#define KEY_TAB 15 +#define KEY_Q 16 +#define KEY_W 17 +#define KEY_E 18 +#define KEY_R 19 +#define KEY_T 20 +#define KEY_Y 21 +#define KEY_U 22 +#define KEY_I 23 +#define KEY_O 24 +#define KEY_P 25 +#define KEY_LEFTBRACE 26 +#define KEY_RIGHTBRACE 27 +#define KEY_ENTER 28 +#define KEY_LEFTCTRL 29 +#define KEY_A 30 +#define KEY_S 31 +#define KEY_D 32 +#define KEY_F 33 +#define KEY_G 34 +#define KEY_H 35 +#define KEY_J 36 +#define KEY_K 37 +#define KEY_L 38 +#define KEY_SEMICOLON 39 +#define KEY_APOSTROPHE 40 +#define KEY_GRAVE 41 +#define KEY_LEFTSHIFT 42 +#define KEY_BACKSLASH 43 +#define KEY_Z 44 +#define KEY_X 45 +#define KEY_C 46 +#define KEY_V 47 +#define KEY_B 48 +#define KEY_N 49 +#define KEY_M 50 +#define KEY_COMMA 51 +#define KEY_DOT 52 +#define KEY_SLASH 53 +#define KEY_RIGHTSHIFT 54 +#define KEY_KPASTERISK 55 +#define KEY_LEFTALT 56 +#define KEY_SPACE 57 +#define KEY_CAPSLOCK 58 +#define KEY_F1 59 +#define KEY_F2 60 +#define KEY_F3 61 +#define KEY_F4 62 +#define KEY_F5 63 +#define KEY_F6 64 +#define KEY_F7 65 +#define KEY_F8 66 +#define KEY_F9 67 +#define KEY_F10 68 +#define KEY_NUMLOCK 69 +#define KEY_SCROLLLOCK 70 +#define KEY_KP7 71 +#define KEY_KP8 72 +#define KEY_KP9 73 +#define KEY_KPMINUS 74 +#define KEY_KP4 75 +#define KEY_KP5 76 +#define KEY_KP6 77 +#define KEY_KPPLUS 78 +#define KEY_KP1 79 +#define KEY_KP2 80 +#define KEY_KP3 81 +#define KEY_KP0 82 +#define KEY_KPDOT 83 + +#define KEY_ZENKAKUHANKAKU 85 +#define KEY_102ND 86 +#define KEY_F11 87 +#define KEY_F12 88 +#define KEY_RO 89 +#define KEY_KATAKANA 90 +#define KEY_HIRAGANA 91 +#define KEY_HENKAN 92 +#define KEY_KATAKANAHIRAGANA 93 +#define KEY_MUHENKAN 94 +#define KEY_KPJPCOMMA 95 +#define KEY_KPENTER 96 +#define KEY_RIGHTCTRL 97 +#define KEY_KPSLASH 98 +#define KEY_SYSRQ 99 +#define KEY_RIGHTALT 100 +#define KEY_LINEFEED 101 +#define KEY_HOME 102 +#define KEY_UP 103 +#define KEY_PAGEUP 104 +#define KEY_LEFT 105 +#define KEY_RIGHT 106 +#define KEY_END 107 +#define KEY_DOWN 108 +#define KEY_PAGEDOWN 109 +#define KEY_INSERT 110 +#define KEY_DELETE 111 +#define KEY_MACRO 112 +#define KEY_MUTE 113 +#define KEY_VOLUMEDOWN 114 +#define KEY_VOLUMEUP 115 +#define KEY_POWER 116 /* SC System Power Down */ +#define KEY_KPEQUAL 117 +#define KEY_KPPLUSMINUS 118 +#define KEY_PAUSE 119 +#define KEY_SCALE 120 /* AL Compiz Scale (Expose) */ + +#define KEY_KPCOMMA 121 +#define KEY_HANGEUL 122 +#define KEY_HANGUEL KEY_HANGEUL +#define KEY_HANJA 123 +#define KEY_YEN 124 +#define KEY_LEFTMETA 125 +#define KEY_RIGHTMETA 126 +#define KEY_COMPOSE 127 + +#define KEY_STOP 128 /* AC Stop */ +#define KEY_AGAIN 129 +#define KEY_PROPS 130 /* AC Properties */ +#define KEY_UNDO 131 /* AC Undo */ +#define KEY_FRONT 132 +#define KEY_COPY 133 /* AC Copy */ +#define KEY_OPEN 134 /* AC Open */ +#define KEY_PASTE 135 /* AC Paste */ +#define KEY_FIND 136 /* AC Search */ +#define KEY_CUT 137 /* AC Cut */ +#define KEY_HELP 138 /* AL Integrated Help Center */ +#define KEY_MENU 139 /* Menu (show menu) */ +#define KEY_CALC 140 /* AL Calculator */ +#define KEY_SETUP 141 +#define KEY_SLEEP 142 /* SC System Sleep */ +#define KEY_WAKEUP 143 /* System Wake Up */ +#define KEY_FILE 144 /* AL Local Machine Browser */ +#define KEY_SENDFILE 145 +#define KEY_DELETEFILE 146 +#define KEY_XFER 147 +#define KEY_PROG1 148 +#define KEY_PROG2 149 +#define KEY_WWW 150 /* AL Internet Browser */ +#define KEY_MSDOS 151 +#define KEY_COFFEE 152 /* AL Terminal Lock/Screensaver */ +#define KEY_SCREENLOCK KEY_COFFEE +#define KEY_ROTATE_DISPLAY 153 /* Display orientation for e.g. tablets */ +#define KEY_DIRECTION KEY_ROTATE_DISPLAY +#define KEY_CYCLEWINDOWS 154 +#define KEY_MAIL 155 +#define KEY_BOOKMARKS 156 /* AC Bookmarks */ +#define KEY_COMPUTER 157 +#define KEY_BACK 158 /* AC Back */ +#define KEY_FORWARD 159 /* AC Forward */ +#define KEY_CLOSECD 160 +#define KEY_EJECTCD 161 +#define KEY_EJECTCLOSECD 162 +#define KEY_NEXTSONG 163 +#define KEY_PLAYPAUSE 164 +#define KEY_PREVIOUSSONG 165 +#define KEY_STOPCD 166 +#define KEY_RECORD 167 +#define KEY_REWIND 168 +#define KEY_PHONE 169 /* Media Select Telephone */ +#define KEY_ISO 170 +#define KEY_CONFIG 171 /* AL Consumer Control Configuration */ +#define KEY_HOMEPAGE 172 /* AC Home */ +#define KEY_REFRESH 173 /* AC Refresh */ +#define KEY_EXIT 174 /* AC Exit */ +#define KEY_MOVE 175 +#define KEY_EDIT 176 +#define KEY_SCROLLUP 177 +#define KEY_SCROLLDOWN 178 +#define KEY_KPLEFTPAREN 179 +#define KEY_KPRIGHTPAREN 180 +#define KEY_NEW 181 /* AC New */ +#define KEY_REDO 182 /* AC Redo/Repeat */ + +#define KEY_F13 183 +#define KEY_F14 184 +#define KEY_F15 185 +#define KEY_F16 186 +#define KEY_F17 187 +#define KEY_F18 188 +#define KEY_F19 189 +#define KEY_F20 190 +#define KEY_F21 191 +#define KEY_F22 192 +#define KEY_F23 193 +#define KEY_F24 194 + +#define KEY_PLAYCD 200 +#define KEY_PAUSECD 201 +#define KEY_PROG3 202 +#define KEY_PROG4 203 +#define KEY_ALL_APPLICATIONS 204 /* AC Desktop Show All Applications */ +#define KEY_DASHBOARD KEY_ALL_APPLICATIONS +#define KEY_SUSPEND 205 +#define KEY_CLOSE 206 /* AC Close */ +#define KEY_PLAY 207 +#define KEY_FASTFORWARD 208 +#define KEY_BASSBOOST 209 +#define KEY_PRINT 210 /* AC Print */ +#define KEY_HP 211 +#define KEY_CAMERA 212 +#define KEY_SOUND 213 +#define KEY_QUESTION 214 +#define KEY_EMAIL 215 +#define KEY_CHAT 216 +#define KEY_SEARCH 217 +#define KEY_CONNECT 218 +#define KEY_FINANCE 219 /* AL Checkbook/Finance */ +#define KEY_SPORT 220 +#define KEY_SHOP 221 +#define KEY_ALTERASE 222 +#define KEY_CANCEL 223 /* AC Cancel */ +#define KEY_BRIGHTNESSDOWN 224 +#define KEY_BRIGHTNESSUP 225 +#define KEY_MEDIA 226 + +#define KEY_SWITCHVIDEOMODE 227 /* Cycle between available video outputs (Monitor/LCD/TV-out/etc) */ +#define KEY_KBDILLUMTOGGLE 228 +#define KEY_KBDILLUMDOWN 229 +#define KEY_KBDILLUMUP 230 + +#define KEY_SEND 231 /* AC Send */ +#define KEY_REPLY 232 /* AC Reply */ +#define KEY_FORWARDMAIL 233 /* AC Forward Msg */ +#define KEY_SAVE 234 /* AC Save */ +#define KEY_DOCUMENTS 235 + +#define KEY_BATTERY 236 + +#define KEY_BLUETOOTH 237 +#define KEY_WLAN 238 +#define KEY_UWB 239 + +#define KEY_UNKNOWN 240 + +#define KEY_VIDEO_NEXT 241 /* Drive next video source */ +#define KEY_VIDEO_PREV 242 /* Drive previous video source */ +#define KEY_BRIGHTNESS_CYCLE 243 /* Brightness up, after max is min */ +#define KEY_BRIGHTNESS_AUTO 244 /* Set Auto Brightness: manual brightness control is off, rely on ambient */ +#define KEY_BRIGHTNESS_ZERO KEY_BRIGHTNESS_AUTO +#define KEY_DISPLAY_OFF 245 /* Display device to off state */ + +#define KEY_WWAN 246 /* Wireless WAN (LTE, UMTS, GSM, etc.) */ +#define KEY_WIMAX KEY_WWAN +#define KEY_RFKILL 247 /* Key that controls all radios */ + +#define KEY_MICMUTE 248 /* Mute / unmute the microphone */ + +/* Code 255 is reserved for special needs of AT keyboard driver */ +#define BTN_MISC 0x100 +#define BTN_0 0x100 +#define BTN_1 0x101 +#define BTN_2 0x102 +#define BTN_3 0x103 +#define BTN_4 0x104 +#define BTN_5 0x105 +#define BTN_6 0x106 +#define BTN_7 0x107 +#define BTN_8 0x108 +#define BTN_9 0x109 + +#define BTN_MOUSE 0x110 +#define BTN_LEFT 0x110 +#define BTN_RIGHT 0x111 +#define BTN_MIDDLE 0x112 +#define BTN_SIDE 0x113 +#define BTN_EXTRA 0x114 +#define BTN_FORWARD 0x115 +#define BTN_BACK 0x116 +#define BTN_TASK 0x117 + +#define BTN_JOYSTICK 0x120 +#define BTN_TRIGGER 0x120 +#define BTN_THUMB 0x121 +#define BTN_THUMB2 0x122 +#define BTN_TOP 0x123 +#define BTN_TOP2 0x124 +#define BTN_PINKIE 0x125 +#define BTN_BASE 0x126 +#define BTN_BASE2 0x127 +#define BTN_BASE3 0x128 +#define BTN_BASE4 0x129 +#define BTN_BASE5 0x12a +#define BTN_BASE6 0x12b +#define BTN_DEAD 0x12f + +#define BTN_GAMEPAD 0x130 +#define BTN_SOUTH 0x130 +#define BTN_A BTN_SOUTH +#define BTN_EAST 0x131 +#define BTN_B BTN_EAST +#define BTN_C 0x132 +#define BTN_NORTH 0x133 +#define BTN_X BTN_NORTH +#define BTN_WEST 0x134 +#define BTN_Y BTN_WEST +#define BTN_Z 0x135 +#define BTN_TL 0x136 +#define BTN_TR 0x137 +#define BTN_TL2 0x138 +#define BTN_TR2 0x139 +#define BTN_SELECT 0x13a +#define BTN_START 0x13b +#define BTN_MODE 0x13c +#define BTN_THUMBL 0x13d +#define BTN_THUMBR 0x13e + +#define BTN_DIGI 0x140 +#define BTN_TOOL_PEN 0x140 +#define BTN_TOOL_RUBBER 0x141 +#define BTN_TOOL_BRUSH 0x142 +#define BTN_TOOL_PENCIL 0x143 +#define BTN_TOOL_AIRBRUSH 0x144 +#define BTN_TOOL_FINGER 0x145 +#define BTN_TOOL_MOUSE 0x146 +#define BTN_TOOL_LENS 0x147 +#define BTN_TOOL_QUINTTAP 0x148 /* Five fingers on trackpad */ +#define BTN_STYLUS3 0x149 +#define BTN_TOUCH 0x14a +#define BTN_STYLUS 0x14b +#define BTN_STYLUS2 0x14c +#define BTN_TOOL_DOUBLETAP 0x14d +#define BTN_TOOL_TRIPLETAP 0x14e +#define BTN_TOOL_QUADTAP 0x14f /* Four fingers on trackpad */ + +#define BTN_WHEEL 0x150 +#define BTN_GEAR_DOWN 0x150 +#define BTN_GEAR_UP 0x151 + +#define KEY_OK 0x160 +#define KEY_SELECT 0x161 +#define KEY_GOTO 0x162 +#define KEY_CLEAR 0x163 +#define KEY_POWER2 0x164 +#define KEY_OPTION 0x165 +#define KEY_INFO 0x166 /* AL OEM Features/Tips/Tutorial */ +#define KEY_TIME 0x167 +#define KEY_VENDOR 0x168 +#define KEY_ARCHIVE 0x169 +#define KEY_PROGRAM 0x16a /* Media Select Program Guide */ +#define KEY_CHANNEL 0x16b +#define KEY_FAVORITES 0x16c +#define KEY_EPG 0x16d +#define KEY_PVR 0x16e /* Media Select Home */ +#define KEY_MHP 0x16f +#define KEY_LANGUAGE 0x170 +#define KEY_TITLE 0x171 +#define KEY_SUBTITLE 0x172 +#define KEY_ANGLE 0x173 +#define KEY_FULL_SCREEN 0x174 /* AC View Toggle */ +#define KEY_ZOOM KEY_FULL_SCREEN +#define KEY_MODE 0x175 +#define KEY_KEYBOARD 0x176 +#define KEY_ASPECT_RATIO 0x177 /* HUTRR37: Aspect */ +#define KEY_SCREEN KEY_ASPECT_RATIO +#define KEY_PC 0x178 /* Media Select Computer */ +#define KEY_TV 0x179 /* Media Select TV */ +#define KEY_TV2 0x17a /* Media Select Cable */ +#define KEY_VCR 0x17b /* Media Select VCR */ +#define KEY_VCR2 0x17c /* VCR Plus */ +#define KEY_SAT 0x17d /* Media Select Satellite */ +#define KEY_SAT2 0x17e +#define KEY_CD 0x17f /* Media Select CD */ +#define KEY_TAPE 0x180 /* Media Select Tape */ +#define KEY_RADIO 0x181 +#define KEY_TUNER 0x182 /* Media Select Tuner */ +#define KEY_PLAYER 0x183 +#define KEY_TEXT 0x184 +#define KEY_DVD 0x185 /* Media Select DVD */ +#define KEY_AUX 0x186 +#define KEY_MP3 0x187 +#define KEY_AUDIO 0x188 /* AL Audio Browser */ +#define KEY_VIDEO 0x189 /* AL Movie Browser */ +#define KEY_DIRECTORY 0x18a +#define KEY_LIST 0x18b +#define KEY_MEMO 0x18c /* Media Select Messages */ +#define KEY_CALENDAR 0x18d +#define KEY_RED 0x18e +#define KEY_GREEN 0x18f +#define KEY_YELLOW 0x190 +#define KEY_BLUE 0x191 +#define KEY_CHANNELUP 0x192 /* Channel Increment */ +#define KEY_CHANNELDOWN 0x193 /* Channel Decrement */ +#define KEY_FIRST 0x194 +#define KEY_LAST 0x195 /* Recall Last */ +#define KEY_AB 0x196 +#define KEY_NEXT 0x197 +#define KEY_RESTART 0x198 +#define KEY_SLOW 0x199 +#define KEY_SHUFFLE 0x19a +#define KEY_BREAK 0x19b +#define KEY_PREVIOUS 0x19c +#define KEY_DIGITS 0x19d +#define KEY_TEEN 0x19e +#define KEY_TWEN 0x19f +#define KEY_VIDEOPHONE 0x1a0 /* Media Select Video Phone */ +#define KEY_GAMES 0x1a1 /* Media Select Games */ +#define KEY_ZOOMIN 0x1a2 /* AC Zoom In */ +#define KEY_ZOOMOUT 0x1a3 /* AC Zoom Out */ +#define KEY_ZOOMRESET 0x1a4 /* AC Zoom */ +#define KEY_WORDPROCESSOR 0x1a5 /* AL Word Processor */ +#define KEY_EDITOR 0x1a6 /* AL Text Editor */ +#define KEY_SPREADSHEET 0x1a7 /* AL Spreadsheet */ +#define KEY_GRAPHICSEDITOR 0x1a8 /* AL Graphics Editor */ +#define KEY_PRESENTATION 0x1a9 /* AL Presentation App */ +#define KEY_DATABASE 0x1aa /* AL Database App */ +#define KEY_NEWS 0x1ab /* AL Newsreader */ +#define KEY_VOICEMAIL 0x1ac /* AL Voicemail */ +#define KEY_ADDRESSBOOK 0x1ad /* AL Contacts/Address Book */ +#define KEY_MESSENGER 0x1ae /* AL Instant Messaging */ +#define KEY_DISPLAYTOGGLE 0x1af /* Turn display (LCD) on and off */ +#define KEY_BRIGHTNESS_TOGGLE KEY_DISPLAYTOGGLE +#define KEY_SPELLCHECK 0x1b0 /* AL Spell Check */ +#define KEY_LOGOFF 0x1b1 /* AL Logoff */ + +#define KEY_DOLLAR 0x1b2 +#define KEY_EURO 0x1b3 + +#define KEY_FRAMEBACK 0x1b4 /* Consumer - transport controls */ +#define KEY_FRAMEFORWARD 0x1b5 +#define KEY_CONTEXT_MENU 0x1b6 /* GenDesc - system context menu */ +#define KEY_MEDIA_REPEAT 0x1b7 /* Consumer - transport control */ +#define KEY_10CHANNELSUP 0x1b8 /* 10 channels up (10+) */ +#define KEY_10CHANNELSDOWN 0x1b9 /* 10 channels down (10-) */ +#define KEY_IMAGES 0x1ba /* AL Image Browser */ +#define KEY_NOTIFICATION_CENTER 0x1bc /* Show/hide the notification center */ +#define KEY_PICKUP_PHONE 0x1bd /* Answer incoming call */ +#define KEY_HANGUP_PHONE 0x1be /* Decline incoming call */ + +#define KEY_DEL_EOL 0x1c0 +#define KEY_DEL_EOS 0x1c1 +#define KEY_INS_LINE 0x1c2 +#define KEY_DEL_LINE 0x1c3 + +#define KEY_FN 0x1d0 +#define KEY_FN_ESC 0x1d1 +#define KEY_FN_F1 0x1d2 +#define KEY_FN_F2 0x1d3 +#define KEY_FN_F3 0x1d4 +#define KEY_FN_F4 0x1d5 +#define KEY_FN_F5 0x1d6 +#define KEY_FN_F6 0x1d7 +#define KEY_FN_F7 0x1d8 +#define KEY_FN_F8 0x1d9 +#define KEY_FN_F9 0x1da +#define KEY_FN_F10 0x1db +#define KEY_FN_F11 0x1dc +#define KEY_FN_F12 0x1dd +#define KEY_FN_1 0x1de +#define KEY_FN_2 0x1df +#define KEY_FN_D 0x1e0 +#define KEY_FN_E 0x1e1 +#define KEY_FN_F 0x1e2 +#define KEY_FN_S 0x1e3 +#define KEY_FN_B 0x1e4 +#define KEY_FN_RIGHT_SHIFT 0x1e5 + +#define KEY_BRL_DOT1 0x1f1 +#define KEY_BRL_DOT2 0x1f2 +#define KEY_BRL_DOT3 0x1f3 +#define KEY_BRL_DOT4 0x1f4 +#define KEY_BRL_DOT5 0x1f5 +#define KEY_BRL_DOT6 0x1f6 +#define KEY_BRL_DOT7 0x1f7 +#define KEY_BRL_DOT8 0x1f8 +#define KEY_BRL_DOT9 0x1f9 +#define KEY_BRL_DOT10 0x1fa + +#define KEY_NUMERIC_0 0x200 /* Used by phones, remote controls, and other keypads */ +#define KEY_NUMERIC_1 0x201 +#define KEY_NUMERIC_2 0x202 +#define KEY_NUMERIC_3 0x203 +#define KEY_NUMERIC_4 0x204 +#define KEY_NUMERIC_5 0x205 +#define KEY_NUMERIC_6 0x206 +#define KEY_NUMERIC_7 0x207 +#define KEY_NUMERIC_8 0x208 +#define KEY_NUMERIC_9 0x209 +#define KEY_NUMERIC_STAR 0x20a +#define KEY_NUMERIC_POUND 0x20b +#define KEY_NUMERIC_A 0x20c /* Phone key A - HUT Telephony 0xb9 */ +#define KEY_NUMERIC_B 0x20d +#define KEY_NUMERIC_C 0x20e +#define KEY_NUMERIC_D 0x20f + +#define KEY_CAMERA_FOCUS 0x210 +#define KEY_WPS_BUTTON 0x211 /* WiFi Protected Setup key */ + +#define KEY_TOUCHPAD_TOGGLE 0x212 /* Request switch touchpad on or off */ +#define KEY_TOUCHPAD_ON 0x213 +#define KEY_TOUCHPAD_OFF 0x214 + +#define KEY_CAMERA_ZOOMIN 0x215 +#define KEY_CAMERA_ZOOMOUT 0x216 +#define KEY_CAMERA_UP 0x217 +#define KEY_CAMERA_DOWN 0x218 +#define KEY_CAMERA_LEFT 0x219 +#define KEY_CAMERA_RIGHT 0x21a + +#define KEY_ATTENDANT_ON 0x21b +#define KEY_ATTENDANT_OFF 0x21c +#define KEY_ATTENDANT_TOGGLE 0x21d /* Attendant call on or off */ +#define KEY_LIGHTS_TOGGLE 0x21e /* Reading light on or off */ + +#define BTN_DPAD_UP 0x220 +#define BTN_DPAD_DOWN 0x221 +#define BTN_DPAD_LEFT 0x222 +#define BTN_DPAD_RIGHT 0x223 + +#define KEY_ALS_TOGGLE 0x230 /* Ambient light sensor */ +#define KEY_ROTATE_LOCK_TOGGLE 0x231 /* Display rotation lock */ + +#define KEY_BUTTONCONFIG 0x240 /* AL Button Configuration */ +#define KEY_TASKMANAGER 0x241 /* AL Task/Project Manager */ +#define KEY_JOURNAL 0x242 /* AL Log/Journal/Timecard */ +#define KEY_CONTROLPANEL 0x243 /* AL Control Panel */ +#define KEY_APPSELECT 0x244 /* AL Select Task/Application */ +#define KEY_SCREENSAVER 0x245 /* AL Screen Saver */ +#define KEY_VOICECOMMAND 0x246 /* Listening Voice Command */ +#define KEY_ASSISTANT 0x247 /* AL Context-aware desktop assistant */ +#define KEY_KBD_LAYOUT_NEXT 0x248 /* AC Next Keyboard Layout Select */ +#define KEY_EMOJI_PICKER 0x249 /* Show/hide emoji picker (HUTRR101) */ +#define KEY_DICTATE 0x24a /* Start or Stop Voice Dictation Session (HUTRR99) */ + +#define KEY_BRIGHTNESS_MIN 0x250 /* Set Brightness to Minimum */ +#define KEY_BRIGHTNESS_MAX 0x251 /* Set Brightness to Maximum */ + +#define KEY_KBDINPUTASSIST_PREV 0x260 +#define KEY_KBDINPUTASSIST_NEXT 0x261 +#define KEY_KBDINPUTASSIST_PREVGROUP 0x262 +#define KEY_KBDINPUTASSIST_NEXTGROUP 0x263 +#define KEY_KBDINPUTASSIST_ACCEPT 0x264 +#define KEY_KBDINPUTASSIST_CANCEL 0x265 + +/* Diagonal movement keys */ +#define KEY_RIGHT_UP 0x266 +#define KEY_RIGHT_DOWN 0x267 +#define KEY_LEFT_UP 0x268 +#define KEY_LEFT_DOWN 0x269 + +#define KEY_ROOT_MENU 0x26a /* Show Device's Root Menu */ +/* Show Top Menu of the Media (e.g. DVD) */ +#define KEY_MEDIA_TOP_MENU 0x26b +#define KEY_NUMERIC_11 0x26c +#define KEY_NUMERIC_12 0x26d +/* + * Toggle Audio Description: refers to an audio service that helps blind and + * visually impaired consumers understand the action in a program. Note: in + * some countries this is referred to as "Video Description". + */ +#define KEY_AUDIO_DESC 0x26e +#define KEY_3D_MODE 0x26f +#define KEY_NEXT_FAVORITE 0x270 +#define KEY_STOP_RECORD 0x271 +#define KEY_PAUSE_RECORD 0x272 +#define KEY_VOD 0x273 /* Video on Demand */ +#define KEY_UNMUTE 0x274 +#define KEY_FASTREVERSE 0x275 +#define KEY_SLOWREVERSE 0x276 +/* + * Control a data application associated with the currently viewed channel, + * e.g. teletext or data broadcast application (MHEG, MHP, HbbTV, etc.) + */ +#define KEY_DATA 0x277 +#define KEY_ONSCREEN_KEYBOARD 0x278 +/* Electronic privacy screen control */ +#define KEY_PRIVACY_SCREEN_TOGGLE 0x279 + +/* Select an area of screen to be copied */ +#define KEY_SELECTIVE_SCREENSHOT 0x27a + +/* Move the focus to the next or previous user controllable element within a UI container */ +#define KEY_NEXT_ELEMENT 0x27b +#define KEY_PREVIOUS_ELEMENT 0x27c + +/* Toggle Autopilot engagement */ +#define KEY_AUTOPILOT_ENGAGE_TOGGLE 0x27d + +/* Shortcut Keys */ +#define KEY_MARK_WAYPOINT 0x27e +#define KEY_SOS 0x27f +#define KEY_NAV_CHART 0x280 +#define KEY_FISHING_CHART 0x281 +#define KEY_SINGLE_RANGE_RADAR 0x282 +#define KEY_DUAL_RANGE_RADAR 0x283 +#define KEY_RADAR_OVERLAY 0x284 +#define KEY_TRADITIONAL_SONAR 0x285 +#define KEY_CLEARVU_SONAR 0x286 +#define KEY_SIDEVU_SONAR 0x287 +#define KEY_NAV_INFO 0x288 +#define KEY_BRIGHTNESS_MENU 0x289 + +/* + * Some keyboards have keys which do not have a defined meaning, these keys + * are intended to be programmed / bound to macros by the user. For most + * keyboards with these macro-keys the key-sequence to inject, or action to + * take, is all handled by software on the host side. So from the kernel's + * point of view these are just normal keys. + * + * The KEY_MACRO# codes below are intended for such keys, which may be labeled + * e.g. G1-G18, or S1 - S30. The KEY_MACRO# codes MUST NOT be used for keys + * where the marking on the key does indicate a defined meaning / purpose. + * + * The KEY_MACRO# codes MUST also NOT be used as fallback for when no existing + * KEY_FOO define matches the marking / purpose. In this case a new KEY_FOO + * define MUST be added. + */ +#define KEY_MACRO1 0x290 +#define KEY_MACRO2 0x291 +#define KEY_MACRO3 0x292 +#define KEY_MACRO4 0x293 +#define KEY_MACRO5 0x294 +#define KEY_MACRO6 0x295 +#define KEY_MACRO7 0x296 +#define KEY_MACRO8 0x297 +#define KEY_MACRO9 0x298 +#define KEY_MACRO10 0x299 +#define KEY_MACRO11 0x29a +#define KEY_MACRO12 0x29b +#define KEY_MACRO13 0x29c +#define KEY_MACRO14 0x29d +#define KEY_MACRO15 0x29e +#define KEY_MACRO16 0x29f +#define KEY_MACRO17 0x2a0 +#define KEY_MACRO18 0x2a1 +#define KEY_MACRO19 0x2a2 +#define KEY_MACRO20 0x2a3 +#define KEY_MACRO21 0x2a4 +#define KEY_MACRO22 0x2a5 +#define KEY_MACRO23 0x2a6 +#define KEY_MACRO24 0x2a7 +#define KEY_MACRO25 0x2a8 +#define KEY_MACRO26 0x2a9 +#define KEY_MACRO27 0x2aa +#define KEY_MACRO28 0x2ab +#define KEY_MACRO29 0x2ac +#define KEY_MACRO30 0x2ad + +/* + * Some keyboards with the macro-keys described above have some extra keys + * for controlling the host-side software responsible for the macro handling: + * -A macro recording start/stop key. Note that not all keyboards which emit + * KEY_MACRO_RECORD_START will also emit KEY_MACRO_RECORD_STOP if + * KEY_MACRO_RECORD_STOP is not advertised, then KEY_MACRO_RECORD_START + * should be interpreted as a recording start/stop toggle; + * -Keys for switching between different macro (pre)sets, either a key for + * cycling through the configured presets or keys to directly select a preset. + */ +#define KEY_MACRO_RECORD_START 0x2b0 +#define KEY_MACRO_RECORD_STOP 0x2b1 +#define KEY_MACRO_PRESET_CYCLE 0x2b2 +#define KEY_MACRO_PRESET1 0x2b3 +#define KEY_MACRO_PRESET2 0x2b4 +#define KEY_MACRO_PRESET3 0x2b5 + +/* + * Some keyboards have a buildin LCD panel where the contents are controlled + * by the host. Often these have a number of keys directly below the LCD + * intended for controlling a menu shown on the LCD. These keys often don't + * have any labeling so we just name them KEY_KBD_LCD_MENU# + */ +#define KEY_KBD_LCD_MENU1 0x2b8 +#define KEY_KBD_LCD_MENU2 0x2b9 +#define KEY_KBD_LCD_MENU3 0x2ba +#define KEY_KBD_LCD_MENU4 0x2bb +#define KEY_KBD_LCD_MENU5 0x2bc + +#define BTN_TRIGGER_HAPPY 0x2c0 +#define BTN_TRIGGER_HAPPY1 0x2c0 +#define BTN_TRIGGER_HAPPY2 0x2c1 +#define BTN_TRIGGER_HAPPY3 0x2c2 +#define BTN_TRIGGER_HAPPY4 0x2c3 +#define BTN_TRIGGER_HAPPY5 0x2c4 +#define BTN_TRIGGER_HAPPY6 0x2c5 +#define BTN_TRIGGER_HAPPY7 0x2c6 +#define BTN_TRIGGER_HAPPY8 0x2c7 +#define BTN_TRIGGER_HAPPY9 0x2c8 +#define BTN_TRIGGER_HAPPY10 0x2c9 +#define BTN_TRIGGER_HAPPY11 0x2ca +#define BTN_TRIGGER_HAPPY12 0x2cb +#define BTN_TRIGGER_HAPPY13 0x2cc +#define BTN_TRIGGER_HAPPY14 0x2cd +#define BTN_TRIGGER_HAPPY15 0x2ce +#define BTN_TRIGGER_HAPPY16 0x2cf +#define BTN_TRIGGER_HAPPY17 0x2d0 +#define BTN_TRIGGER_HAPPY18 0x2d1 +#define BTN_TRIGGER_HAPPY19 0x2d2 +#define BTN_TRIGGER_HAPPY20 0x2d3 +#define BTN_TRIGGER_HAPPY21 0x2d4 +#define BTN_TRIGGER_HAPPY22 0x2d5 +#define BTN_TRIGGER_HAPPY23 0x2d6 +#define BTN_TRIGGER_HAPPY24 0x2d7 +#define BTN_TRIGGER_HAPPY25 0x2d8 +#define BTN_TRIGGER_HAPPY26 0x2d9 +#define BTN_TRIGGER_HAPPY27 0x2da +#define BTN_TRIGGER_HAPPY28 0x2db +#define BTN_TRIGGER_HAPPY29 0x2dc +#define BTN_TRIGGER_HAPPY30 0x2dd +#define BTN_TRIGGER_HAPPY31 0x2de +#define BTN_TRIGGER_HAPPY32 0x2df +#define BTN_TRIGGER_HAPPY33 0x2e0 +#define BTN_TRIGGER_HAPPY34 0x2e1 +#define BTN_TRIGGER_HAPPY35 0x2e2 +#define BTN_TRIGGER_HAPPY36 0x2e3 +#define BTN_TRIGGER_HAPPY37 0x2e4 +#define BTN_TRIGGER_HAPPY38 0x2e5 +#define BTN_TRIGGER_HAPPY39 0x2e6 +#define BTN_TRIGGER_HAPPY40 0x2e7 + +/* We avoid low common keys in module aliases so they don't get huge. */ +#define KEY_MIN_INTERESTING KEY_MUTE +#define KEY_MAX 0x2ff +#define KEY_CNT (KEY_MAX + 1) + +/* Relative axes */ +#define REL_X 0x00 +#define REL_Y 0x01 +#define REL_Z 0x02 +#define REL_RX 0x03 +#define REL_RY 0x04 +#define REL_RZ 0x05 +#define REL_HWHEEL 0x06 +#define REL_DIAL 0x07 +#define REL_WHEEL 0x08 +#define REL_MISC 0x09 +/* + * 0x0a is reserved and should not be used in input drivers. + * It was used by HID as REL_MISC + 1 and userspace needs to detect if + * the next REL_* event is correct or is just REL_MISC + n. + * We define here REL_RESERVED so userspace can rely on it and detect + * the situation described above. + */ +#define REL_RESERVED 0x0a +#define REL_WHEEL_HI_RES 0x0b +#define REL_HWHEEL_HI_RES 0x0c +#define REL_MAX 0x0f +#define REL_CNT (REL_MAX + 1) + +/* Absolute axes */ +#define ABS_X 0x00 +#define ABS_Y 0x01 +#define ABS_Z 0x02 +#define ABS_RX 0x03 +#define ABS_RY 0x04 +#define ABS_RZ 0x05 +#define ABS_THROTTLE 0x06 +#define ABS_RUDDER 0x07 +#define ABS_WHEEL 0x08 +#define ABS_GAS 0x09 +#define ABS_BRAKE 0x0a +#define ABS_HAT0X 0x10 +#define ABS_HAT0Y 0x11 +#define ABS_HAT1X 0x12 +#define ABS_HAT1Y 0x13 +#define ABS_HAT2X 0x14 +#define ABS_HAT2Y 0x15 +#define ABS_HAT3X 0x16 +#define ABS_HAT3Y 0x17 +#define ABS_PRESSURE 0x18 +#define ABS_DISTANCE 0x19 +#define ABS_TILT_X 0x1a +#define ABS_TILT_Y 0x1b +#define ABS_TOOL_WIDTH 0x1c + +#define ABS_VOLUME 0x20 + +#define ABS_MISC 0x28 + +/* + * 0x2e is reserved and should not be used in input drivers. + * It was used by HID as ABS_MISC + 6 and userspace needs to detect if + * the next ABS_* event is correct or is just ABS_MISC + n. + * We define here ABS_RESERVED so userspace can rely on it and detect + * the situation described above. + */ +#define ABS_RESERVED 0x2e + +#define ABS_MT_SLOT 0x2f /* MT slot being modified */ +#define ABS_MT_TOUCH_MAJOR 0x30 /* Major axis of touching ellipse */ +#define ABS_MT_TOUCH_MINOR 0x31 /* Minor axis (omit if circular) */ +#define ABS_MT_WIDTH_MAJOR 0x32 /* Major axis of approaching ellipse */ +#define ABS_MT_WIDTH_MINOR 0x33 /* Minor axis (omit if circular) */ +#define ABS_MT_ORIENTATION 0x34 /* Ellipse orientation */ +#define ABS_MT_POSITION_X 0x35 /* Center X touch position */ +#define ABS_MT_POSITION_Y 0x36 /* Center Y touch position */ +#define ABS_MT_TOOL_TYPE 0x37 /* Type of touching device */ +#define ABS_MT_BLOB_ID 0x38 /* Group a set of packets as a blob */ +#define ABS_MT_TRACKING_ID 0x39 /* Unique ID of initiated contact */ +#define ABS_MT_PRESSURE 0x3a /* Pressure on contact area */ +#define ABS_MT_DISTANCE 0x3b /* Contact hover distance */ +#define ABS_MT_TOOL_X 0x3c /* Center X tool position */ +#define ABS_MT_TOOL_Y 0x3d /* Center Y tool position */ + + +#define ABS_MAX 0x3f +#define ABS_CNT (ABS_MAX + 1) + +/* Switch events */ +#define SW_LID 0x00 /* Set = lid shut */ +#define SW_TABLET_MODE 0x01 /* Set = tablet mode */ +#define SW_HEADPHONE_INSERT 0x02 /* Set = inserted */ +#define SW_RFKILL_ALL 0x03 /* rfkill master switch, type "any" set = radio enabled */ +#define SW_RADIO SW_RFKILL_ALL /* deprecated */ +#define SW_MICROPHONE_INSERT 0x04 /* Set = inserted */ +#define SW_DOCK 0x05 /* Set = plugged into dock */ +#define SW_LINEOUT_INSERT 0x06 /* Set = inserted */ +#define SW_JACK_PHYSICAL_INSERT 0x07 /* Set = mechanical switch set */ +#define SW_VIDEOOUT_INSERT 0x08 /* Set = inserted */ +#define SW_CAMERA_LENS_COVER 0x09 /* Set = lens covered */ +#define SW_KEYPAD_SLIDE 0x0a /* Set = keypad slide out */ +#define SW_FRONT_PROXIMITY 0x0b /* Set = front proximity sensor active */ +#define SW_ROTATE_LOCK 0x0c /* Set = rotate locked/disabled */ +#define SW_LINEIN_INSERT 0x0d /* Set = inserted */ +#define SW_MUTE_DEVICE 0x0e /* Set = device disabled */ +#define SW_PEN_INSERTED 0x0f /* Set = pen inserted */ +#define SW_MACHINE_COVER 0x10 /* Set = cover closed */ +#define SW_MAX 0x10 +#define SW_CNT (SW_MAX + 1) + +/* Misc events */ +#define MSC_SERIAL 0x00 +#define MSC_PULSELED 0x01 +#define MSC_GESTURE 0x02 +#define MSC_RAW 0x03 +#define MSC_SCAN 0x04 +#define MSC_TIMESTAMP 0x05 +#define MSC_MAX 0x07 +#define MSC_CNT (MSC_MAX + 1) + +/* LEDs */ +#define LED_NUML 0x00 +#define LED_CAPSL 0x01 +#define LED_SCROLLL 0x02 +#define LED_COMPOSE 0x03 +#define LED_KANA 0x04 +#define LED_SLEEP 0x05 +#define LED_SUSPEND 0x06 +#define LED_MUTE 0x07 +#define LED_MISC 0x08 +#define LED_MAIL 0x09 +#define LED_CHARGING 0x0a +#define LED_MAX 0x0f +#define LED_CNT (LED_MAX + 1) + +/* Autorepeat values */ +#define REP_DELAY 0x00 +#define REP_PERIOD 0x01 +#define REP_MAX 0x01 +#define REP_CNT (REP_MAX + 1) + +/* Sounds */ +#define SND_CLICK 0x00 +#define SND_BELL 0x01 +#define SND_TONE 0x02 +#define SND_MAX 0x07 +#define SND_CNT (SND_MAX + 1) + +#endif /* __VIRTIO_INPUT_EVENT_CODES__ */ diff --git a/bsp/qemu-virt64-aarch64/driver/virtio/virtio_net.c b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_net.c new file mode 100644 index 0000000000..af56409c62 --- /dev/null +++ b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_net.c @@ -0,0 +1,308 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-11-11 GuEe-GUI the first version + */ + +#include <rthw.h> +#include <rtthread.h> +#include <cpuport.h> + +#ifdef BSP_USING_VIRTIO_NET + +#include <virtio_net.h> + +static rt_err_t virtio_net_tx(rt_device_t dev, struct pbuf *p) +{ + rt_uint16_t id; + struct virtio_net_device *virtio_net_dev = (struct virtio_net_device *)dev; + struct virtio_device *virtio_dev = &virtio_net_dev->virtio_dev; + struct virtq *queue_tx = &virtio_dev->queues[VIRTIO_NET_QUEUE_TX]; + + while (p != RT_NULL) + { +#ifdef RT_USING_SMP + rt_base_t level = rt_spin_lock_irqsave(&virtio_dev->spinlock); +#endif + id = (queue_tx->avail->idx * 2) % queue_tx->num; + + virtio_net_dev->info[id].hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM; + virtio_net_dev->info[id].hdr.gso_type = VIRTIO_NET_HDR_GSO_NONE; + virtio_net_dev->info[id].hdr.hdr_len = 0; + virtio_net_dev->info[id].hdr.gso_size = 0; + virtio_net_dev->info[id].hdr.csum_start = 0; + virtio_net_dev->info[id].hdr.csum_offset = p->tot_len + sizeof(virtio_net_dev->info[id].hdr); + + virtio_free_desc(virtio_dev, VIRTIO_NET_QUEUE_TX, id); + virtio_free_desc(virtio_dev, VIRTIO_NET_QUEUE_TX, id + 1); + + virtio_fill_desc(virtio_dev, VIRTIO_NET_QUEUE_TX, id, + VIRTIO_VA2PA(&virtio_net_dev->info[id].hdr), VIRTIO_NET_HDR_SIZE, VIRTQ_DESC_F_NEXT, id + 1); + + virtio_fill_desc(virtio_dev, VIRTIO_NET_QUEUE_TX, id + 1, + VIRTIO_VA2PA(p->payload), p->tot_len, 0, 0); + + virtio_submit_chain(virtio_dev, VIRTIO_NET_QUEUE_TX, id); + + virtio_queue_notify(virtio_dev, VIRTIO_NET_QUEUE_TX); + + virtio_alloc_desc(virtio_dev, VIRTIO_NET_QUEUE_TX); + virtio_alloc_desc(virtio_dev, VIRTIO_NET_QUEUE_TX); + +#ifdef RT_USING_SMP + rt_spin_unlock_irqrestore(&virtio_dev->spinlock, level); +#endif + p = p->next; + } + + return RT_EOK; +} + +static struct pbuf *virtio_net_rx(rt_device_t dev) +{ + rt_uint16_t id; + rt_uint32_t len; + struct pbuf *p = RT_NULL, *new, *ret = RT_NULL; + struct virtio_net_device *virtio_net_dev = (struct virtio_net_device *)dev; + struct virtio_device *virtio_dev = &virtio_net_dev->virtio_dev; + struct virtq *queue_rx = &virtio_dev->queues[VIRTIO_NET_QUEUE_RX]; + + while (queue_rx->used_idx != queue_rx->used->idx) + { +#ifdef RT_USING_SMP + rt_base_t level = rt_spin_lock_irqsave(&virtio_dev->spinlock); +#endif + id = (queue_rx->used->ring[queue_rx->used_idx % queue_rx->num].id + 1) % queue_rx->num; + len = queue_rx->used->ring[queue_rx->used_idx % queue_rx->num].len - VIRTIO_NET_HDR_SIZE; + +#ifdef RT_USING_SMP + rt_spin_unlock_irqrestore(&virtio_dev->spinlock, level); +#endif + if (len > VIRTIO_NET_PAYLOAD_MAX_SIZE) + { + rt_kprintf("%s: Receive buffer's size = %u is too big!\n", virtio_net_dev->parent.parent.parent.name, len); + len = VIRTIO_NET_PAYLOAD_MAX_SIZE; + } + + new = pbuf_alloc(PBUF_RAW, len, PBUF_RAM); + + if (p != RT_NULL) + { + p->next = new; + p = p->next; + } + else + { + p = new; + ret = p; + } + + if (p != RT_NULL) + { +#ifdef RT_USING_SMP + level = rt_spin_lock_irqsave(&virtio_dev->spinlock); +#endif + rt_memcpy(p->payload, (void *)VIRTIO_PA2VA(queue_rx->desc[id].addr), len); + + queue_rx->used_idx++; + + virtio_submit_chain(virtio_dev, VIRTIO_NET_QUEUE_RX, id - 1); + + virtio_queue_notify(virtio_dev, VIRTIO_NET_QUEUE_RX); + +#ifdef RT_USING_SMP + rt_spin_unlock_irqrestore(&virtio_dev->spinlock, level); +#endif + } + else + { + break; + } + } + + return ret; +} + +static rt_err_t virtio_net_init(rt_device_t dev) +{ + int i; + rt_uint16_t idx[VIRTIO_NET_RTX_QUEUE_SIZE]; + struct virtio_net_device *virtio_net_dev = (struct virtio_net_device *)dev; + struct virtio_device *virtio_dev = &virtio_net_dev->virtio_dev; + struct virtq *queue_rx, *queue_tx; + + queue_rx = &virtio_dev->queues[VIRTIO_NET_QUEUE_RX]; + queue_tx = &virtio_dev->queues[VIRTIO_NET_QUEUE_TX]; + + virtio_alloc_desc_chain(virtio_dev, VIRTIO_NET_QUEUE_RX, queue_rx->num, idx); + virtio_alloc_desc_chain(virtio_dev, VIRTIO_NET_QUEUE_TX, queue_tx->num, idx); + + for (i = 0; i < queue_rx->num; ++i) + { + rt_uint16_t id = (i * 2) % queue_rx->num; + void *addr = virtio_net_dev->info[i].buffer; + + /* Descriptor for net_hdr */ + virtio_fill_desc(virtio_dev, VIRTIO_NET_QUEUE_RX, id, + VIRTIO_VA2PA(addr), VIRTIO_NET_HDR_SIZE, VIRTQ_DESC_F_NEXT | VIRTQ_DESC_F_WRITE, id + 1); + + /* Descriptor for data */ + virtio_fill_desc(virtio_dev, VIRTIO_NET_QUEUE_RX, id + 1, + VIRTIO_VA2PA(addr) + VIRTIO_NET_HDR_SIZE, VIRTIO_NET_MSS, VIRTQ_DESC_F_WRITE, 0); + + queue_rx->avail->ring[i] = id; + } + rt_hw_dsb(); + + queue_rx->avail->flags = 0; + queue_rx->avail->idx = queue_rx->num; + + queue_rx->used_idx = queue_rx->used->idx; + + queue_tx->avail->flags = VIRTQ_AVAIL_F_NO_INTERRUPT; + queue_tx->avail->idx = 0; + + virtio_queue_notify(virtio_dev, VIRTIO_NET_QUEUE_RX); + + return eth_device_linkchange(&virtio_net_dev->parent, RT_TRUE); +} + +static rt_err_t virtio_net_control(rt_device_t dev, int cmd, void *args) +{ + rt_err_t status = RT_EOK; + struct virtio_net_device *virtio_net_dev = (struct virtio_net_device *)dev; + + switch (cmd) + { + case NIOCTL_GADDR: + if (args == RT_NULL) + { + status = -RT_ERROR; + break; + } + + rt_memcpy(args, virtio_net_dev->mac, sizeof(virtio_net_dev->mac)); + break; + default: + status = -RT_EINVAL; + break; + } + + return status; +} + +const static struct rt_device_ops virtio_net_ops = +{ + virtio_net_init, + RT_NULL, + RT_NULL, + RT_NULL, + RT_NULL, + virtio_net_control +}; + +static void virtio_net_isr(int irqno, void *param) +{ + struct virtio_net_device *virtio_net_dev = (struct virtio_net_device *)param; + struct virtio_device *virtio_dev = &virtio_net_dev->virtio_dev; + struct virtq *queue_rx = &virtio_dev->queues[VIRTIO_NET_QUEUE_RX]; + +#ifdef RT_USING_SMP + rt_base_t level = rt_spin_lock_irqsave(&virtio_dev->spinlock); +#endif + + virtio_interrupt_ack(virtio_dev); + rt_hw_dsb(); + + if (queue_rx->used_idx != queue_rx->used->idx) + { + rt_hw_dsb(); + + eth_device_ready(&virtio_net_dev->parent); + } + +#ifdef RT_USING_SMP + rt_spin_unlock_irqrestore(&virtio_dev->spinlock, level); +#endif +} + +rt_err_t rt_virtio_net_init(rt_ubase_t *mmio_base, rt_uint32_t irq) +{ + int i; + static int dev_no = 0; + char dev_name[RT_NAME_MAX]; + struct virtio_device *virtio_dev; + struct virtio_net_device *virtio_net_dev; + + virtio_net_dev = rt_malloc(sizeof(struct virtio_net_device)); + + if (virtio_net_dev == RT_NULL) + { + goto _alloc_fail; + } + + virtio_dev = &virtio_net_dev->virtio_dev; + virtio_dev->irq = irq; + virtio_dev->mmio_base = mmio_base; + +#ifdef RT_USING_SMP + rt_spin_lock_init(&virtio_dev->spinlock); +#endif + + virtio_reset_device(virtio_dev); + virtio_status_acknowledge_driver(virtio_dev); + + virtio_dev->mmio_config->driver_features = virtio_dev->mmio_config->device_features & ~( + (1 << VIRTIO_NET_F_CTRL_VQ) | + (1 << VIRTIO_NET_F_GUEST_TSO4) | + (1 << VIRTIO_NET_F_GUEST_TSO6) | + (1 << VIRTIO_NET_F_GUEST_UFO) | + (1 << VIRTIO_NET_F_MRG_RXBUF) | + (1 << VIRTIO_F_RING_EVENT_IDX)) & + (1 << VIRTIO_NET_F_CSUM) & + (1 << VIRTIO_NET_F_GUEST_CSUM) & + (1 << VIRTIO_NET_F_MAC); + + virtio_status_driver_ok(virtio_dev); + + if (virtio_queue_init(virtio_dev, VIRTIO_NET_QUEUE_RX, VIRTIO_NET_RTX_QUEUE_SIZE) != RT_EOK) + { + goto _alloc_fail; + } + + if (virtio_queue_init(virtio_dev, VIRTIO_NET_QUEUE_TX, VIRTIO_NET_RTX_QUEUE_SIZE) != RT_EOK) + { + virtio_queue_destroy(virtio_dev, VIRTIO_NET_QUEUE_RX); + goto _alloc_fail; + } + + for (i = 0; i < sizeof(virtio_net_dev->mac) / sizeof(virtio_net_dev->mac[0]); ++i) + { + virtio_net_dev->mac[i] = virtio_dev->mmio_config->config[i]; + } + + virtio_net_dev->parent.parent.type = RT_Device_Class_NetIf; + virtio_net_dev->parent.parent.ops = &virtio_net_ops; + virtio_net_dev->parent.eth_tx = virtio_net_tx; + virtio_net_dev->parent.eth_rx = virtio_net_rx; + + rt_snprintf(dev_name, RT_NAME_MAX, "virtio-net%d", dev_no++); + + rt_hw_interrupt_install(irq, virtio_net_isr, virtio_net_dev, dev_name); + rt_hw_interrupt_umask(irq); + + return eth_device_init(&virtio_net_dev->parent, dev_name); + +_alloc_fail: + + if (virtio_net_dev != RT_NULL) + { + rt_free(virtio_net_dev); + } + return -RT_ENOMEM; +} +#endif /* BSP_USING_VIRTIO_NET */ diff --git a/bsp/qemu-virt64-aarch64/driver/virtio/virtio_net.h b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_net.h new file mode 100644 index 0000000000..ab41ccfead --- /dev/null +++ b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_net.h @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-11-11 GuEe-GUI the first version + */ + +#ifndef __VIRTIO_NET_H__ +#define __VIRTIO_NET_H__ + +#include <rtdef.h> +#include <netif/ethernetif.h> + +#include <virtio.h> + +#define VIRTIO_NET_QUEUE_RX 0 +#define VIRTIO_NET_QUEUE_TX 1 +#define VIRTIO_NET_RTX_QUEUE_SIZE 16 +#define VIRTIO_NET_RTX_BUF_SIZE 2048 + +#define VIRTIO_NET_F_CSUM 0 /* Host handles pkts w/ partial csum */ +#define VIRTIO_NET_F_GUEST_CSUM 1 /* Guest handles pkts w/ partial csum */ +#define VIRTIO_NET_F_CTRL_GUEST_OFFLOADS 2 /* Dynamic offload configuration */ +#define VIRTIO_NET_F_MTU 3 /* Initial MTU advice */ +#define VIRTIO_NET_F_MAC 5 /* Host has given MAC address */ +#define VIRTIO_NET_F_GUEST_TSO4 7 /* Guest can handle TSOv4 in */ +#define VIRTIO_NET_F_GUEST_TSO6 8 /* Guest can handle TSOv6 in */ +#define VIRTIO_NET_F_GUEST_ECN 9 /* Guest can handle TSO[6] w/ ECN in */ +#define VIRTIO_NET_F_GUEST_UFO 10 /* Guest can handle UFO in */ +#define VIRTIO_NET_F_HOST_TSO4 11 /* Host can handle TSOv4 in */ +#define VIRTIO_NET_F_HOST_TSO6 12 /* Host can handle TSOv6 in */ +#define VIRTIO_NET_F_HOST_ECN 13 /* Host can handle TSO[6] w/ ECN in */ +#define VIRTIO_NET_F_HOST_UFO 14 /* Host can handle UFO in */ +#define VIRTIO_NET_F_MRG_RXBUF 15 /* Host can merge receive buffers. */ +#define VIRTIO_NET_F_STATUS 16 /* virtio_net_config.status available */ +#define VIRTIO_NET_F_CTRL_VQ 17 /* Control channel available */ +#define VIRTIO_NET_F_CTRL_RX 18 /* Control channel RX mode support */ +#define VIRTIO_NET_F_CTRL_VLAN 19 /* Control channel VLAN filtering */ +#define VIRTIO_NET_F_CTRL_RX_EXTRA 20 /* Extra RX mode control support */ +#define VIRTIO_NET_F_GUEST_ANNOUNCE 21 /* Guest can announce device on the network */ +#define VIRTIO_NET_F_MQ 22 /* Device supports Receive Flow Steering */ +#define VIRTIO_NET_F_CTRL_MAC_ADDR 23 /* Set MAC address */ + +#define VIRTIO_NET_F_HASH_REPORT 57 /* Supports hash report */ +#define VIRTIO_NET_F_RSS 60 /* Supports RSS RX steering */ +#define VIRTIO_NET_F_RSC_EXT 61 /* Extended coalescing info */ +#define VIRTIO_NET_F_STANDBY 62 /* Act as standby for another device with the same MAC */ +#define VIRTIO_NET_F_SPEED_DUPLEX 63 /* Device set linkspeed and duplex */ + +#define VIRTIO_NET_S_LINK_UP (1 << 0) +#define VIRTIO_NET_S_ANNOUNCE (1 << 1) + +#define VIRTIO_NET_HDR_F_NEEDS_CSUM 1 +#define VIRTIO_NET_HDR_F_DATA_VALID 2 +#define VIRTIO_NET_HDR_F_RSC_INFO 4 + +#define VIRTIO_NET_HDR_GSO_NONE 0 +#define VIRTIO_NET_HDR_GSO_TCPV4 1 +#define VIRTIO_NET_HDR_GSO_UDP 3 +#define VIRTIO_NET_HDR_GSO_TCPV6 4 +#define VIRTIO_NET_HDR_GSO_ECN 0x80 + +struct virtio_net_hdr +{ + rt_uint8_t flags; + rt_uint8_t gso_type; + rt_uint16_t hdr_len; + rt_uint16_t gso_size; + rt_uint16_t csum_start; + rt_uint16_t csum_offset; + rt_uint16_t num_buffers; /* Only if VIRTIO_NET_F_MRG_RXBUF */ +} __attribute__ ((packed)); + +#define VIRTIO_NET_MSS 1514 +/* Disable VIRTIO_NET_F_MRG_RXBUF */ +#define VIRTIO_NET_HDR_SIZE (sizeof(struct virtio_net_hdr) - sizeof(rt_uint16_t)) +#define VIRTIO_NET_PAYLOAD_MAX_SIZE (VIRTIO_NET_HDR_SIZE + VIRTIO_NET_MSS) + +struct virtio_net_device +{ + struct eth_device parent; + + struct virtio_device virtio_dev; + + rt_uint8_t mac[6]; + + struct + { + /* Transmit hdr */ + struct virtio_net_hdr hdr; + /* Receive buffer */ + rt_uint8_t buffer[VIRTIO_NET_PAYLOAD_MAX_SIZE]; + } info[VIRTIO_NET_RTX_QUEUE_SIZE]; +}; + +rt_err_t rt_virtio_net_init(rt_ubase_t *mmio_base, rt_uint32_t irq); + +#endif /* __VIRTIO_NET_H__ */ diff --git a/bsp/qemu-virt64-aarch64/driver/virtio/virtio_queue.h b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_queue.h index ba8d5d4268..af133b4a53 100644 --- a/bsp/qemu-virt64-aarch64/driver/virtio/virtio_queue.h +++ b/bsp/qemu-virt64-aarch64/driver/virtio/virtio_queue.h @@ -80,6 +80,7 @@ struct virtq /* Helper of driver */ rt_uint32_t used_idx; rt_bool_t *free; + rt_size_t free_count; }; #define VIRTQ_DESC_TOTAL_SIZE(ring_size) (sizeof(struct virtq_desc) * (ring_size)) @@ -91,4 +92,6 @@ struct virtq #define VIRTQ_AVAIL_RES_SIZE (sizeof(rt_uint16_t)) /* used_event */ #define VIRTQ_USED_RES_SIZE (sizeof(rt_uint16_t)) /* avail_event */ +#define VIRTQ_INVALID_DESC_ID RT_UINT16_MAX + #endif /* __VIRTIO_QUEUE_H__ */ diff --git a/bsp/qemu-virt64-aarch64/qemu-graphic.bat b/bsp/qemu-virt64-aarch64/qemu-graphic.bat new file mode 100644 index 0000000000..d60f35916b --- /dev/null +++ b/bsp/qemu-virt64-aarch64/qemu-graphic.bat @@ -0,0 +1,12 @@ +@echo off
+if exist sd.bin goto run
+qemu-img create -f raw sd.bin 64M
+
+:run
+qemu-system-aarch64 -M virt,gic-version=2 -cpu cortex-a53 -smp 4 -kernel rtthread.elf -serial stdio ^
+-drive if=none,file=sd.bin,format=raw,id=blk0 -device virtio-blk-device,drive=blk0,bus=virtio-mmio-bus.0 ^
+-netdev user,id=net0 -device virtio-net-device,netdev=net0,bus=virtio-mmio-bus.1 ^
+-device virtio-gpu-device,xres=800,yres=600,bus=virtio-mmio-bus.2 ^
+-device virtio-keyboard-device,bus=virtio-mmio-bus.3 ^
+-device virtio-mouse-device,bus=virtio-mmio-bus.4 ^
+-device virtio-tablet-device,bus=virtio-mmio-bus.5
diff --git a/bsp/qemu-virt64-aarch64/qemu-graphic.sh b/bsp/qemu-virt64-aarch64/qemu-graphic.sh new file mode 100644 index 0000000000..b3243a147f --- /dev/null +++ b/bsp/qemu-virt64-aarch64/qemu-graphic.sh @@ -0,0 +1,10 @@ +if [ ! -f "sd.bin" ]; then +dd if=/dev/zero of=sd.bin bs=1024 count=65536 +fi +qemu-system-aarch64 -M virt,gic-version=2 -cpu cortex-a53 -smp 4 -kernel rtthread.elf -serial stdio \ +-drive if=none,file=sd.bin,format=raw,id=blk0 -device virtio-blk-device,drive=blk0,bus=virtio-mmio-bus.0 \ +-netdev user,id=net0 -device virtio-net-device,netdev=net0,bus=virtio-mmio-bus.1 \ +-device virtio-gpu-device,xres=800,yres=600,bus=virtio-mmio-bus.2 \ +-device virtio-keyboard-device,bus=virtio-mmio-bus.3 \ +-device virtio-mouse-device,bus=virtio-mmio-bus.4 \ +-device virtio-tablet-device,bus=virtio-mmio-bus.5 diff --git a/bsp/qemu-virt64-aarch64/rtconfig.h b/bsp/qemu-virt64-aarch64/rtconfig.h index a3411e736e..97d3ce481e 100644 --- a/bsp/qemu-virt64-aarch64/rtconfig.h +++ b/bsp/qemu-virt64-aarch64/rtconfig.h @@ -7,6 +7,8 @@ /* RT-Thread Kernel */ #define RT_NAME_MAX 16 +#define RT_USING_SMP +#define RT_CPUS_NR 4 #define RT_ALIGN_SIZE 4 #define RT_THREAD_PRIORITY_32 #define RT_THREAD_PRIORITY_MAX 32 @@ -17,12 +19,14 @@ #define RT_USING_IDLE_HOOK #define RT_IDLE_HOOK_LIST_SIZE 4 #define IDLE_THREAD_STACK_SIZE 4096 +#define SYSTEM_THREAD_STACK_SIZE 4096 #define RT_USING_TIMER_SOFT #define RT_TIMER_THREAD_PRIO 4 #define RT_TIMER_THREAD_STACK_SIZE 4096 /* kservice optimization */ +#define RT_KPRINTF_USING_LONGLONG #define RT_DEBUG #define RT_DEBUG_COLOR @@ -51,7 +55,7 @@ #define RT_USING_CONSOLE #define RT_CONSOLEBUF_SIZE 128 #define RT_CONSOLE_DEVICE_NAME "uart0" -#define RT_VER_NUM 0x40100 +#define RT_VER_NUM 0x40101 #define ARCH_CPU_64BIT #define ARCH_ARMV8 @@ -101,7 +105,7 @@ #define RT_USING_DEVICE_IPC #define RT_USING_SYSTEM_WORKQUEUE -#define RT_SYSTEM_WORKQUEUE_STACKSIZE 2048 +#define RT_SYSTEM_WORKQUEUE_STACKSIZE 4096 #define RT_SYSTEM_WORKQUEUE_PRIORITY 23 #define RT_USING_SERIAL #define RT_USING_SERIAL_V1 @@ -128,6 +132,62 @@ /* Network */ +#define RT_USING_SAL +#define SAL_INTERNET_CHECK + +/* Docking with protocol stacks */ + +#define SAL_USING_LWIP +#define SAL_USING_POSIX +#define RT_USING_NETDEV +#define NETDEV_USING_IFCONFIG +#define NETDEV_USING_PING +#define NETDEV_USING_NETSTAT +#define NETDEV_USING_AUTO_DEFAULT +#define NETDEV_IPV4 1 +#define NETDEV_IPV6 0 +#define RT_USING_LWIP +#define RT_USING_LWIP203 +#define RT_USING_LWIP_VER_NUM 0x20003 +#define RT_LWIP_MEM_ALIGNMENT 4 +#define RT_LWIP_ICMP +#define RT_LWIP_DNS +#define RT_LWIP_DHCP +#define IP_SOF_BROADCAST 1 +#define IP_SOF_BROADCAST_RECV 1 + +/* Static IPv4 Address */ + +#define RT_LWIP_IPADDR "192.168.1.30" +#define RT_LWIP_GWADDR "192.168.1.1" +#define RT_LWIP_MSKADDR "255.255.255.0" +#define RT_LWIP_UDP +#define RT_LWIP_TCP +#define RT_LWIP_RAW +#define RT_MEMP_NUM_NETCONN 8 +#define RT_LWIP_PBUF_NUM 16 +#define RT_LWIP_RAW_PCB_NUM 4 +#define RT_LWIP_UDP_PCB_NUM 4 +#define RT_LWIP_TCP_PCB_NUM 4 +#define RT_LWIP_TCP_SEG_NUM 40 +#define RT_LWIP_TCP_SND_BUF 8196 +#define RT_LWIP_TCP_WND 8196 +#define RT_LWIP_TCPTHREAD_PRIORITY 10 +#define RT_LWIP_TCPTHREAD_MBOX_SIZE 8 +#define RT_LWIP_TCPTHREAD_STACKSIZE 4096 +#define RT_LWIP_ETHTHREAD_PRIORITY 12 +#define RT_LWIP_ETHTHREAD_STACKSIZE 4096 +#define RT_LWIP_ETHTHREAD_MBOX_SIZE 8 +#define RT_LWIP_REASSEMBLY_FRAG +#define LWIP_NETIF_STATUS_CALLBACK 1 +#define LWIP_NETIF_LINK_CALLBACK 1 +#define SO_REUSE 1 +#define LWIP_SO_RCVTIMEO 1 +#define LWIP_SO_SNDTIMEO 1 +#define LWIP_SO_RCVBUF 1 +#define LWIP_SO_LINGER 0 +#define LWIP_NETIF_LOOPBACK 0 +#define RT_LWIP_USING_PING /* Utilities */ @@ -217,6 +277,9 @@ #define BSP_USING_RTC #define BSP_USING_ALARM #define BSP_USING_VIRTIO_BLK +#define BSP_USING_VIRTIO_NET +#define BSP_USING_VIRTIO_GPU +#define BSP_USING_VIRTIO_INPUT #define BSP_USING_GIC #define BSP_USING_GICV2 diff --git a/bsp/qemu-virt64-aarch64/rtconfig.py b/bsp/qemu-virt64-aarch64/rtconfig.py index 6432212bf3..c9e4424358 100644 --- a/bsp/qemu-virt64-aarch64/rtconfig.py +++ b/bsp/qemu-virt64-aarch64/rtconfig.py @@ -39,7 +39,7 @@ if PLATFORM == 'gcc': OBJCPY = PREFIX + 'objcopy' DEVICE = ' -g -march=armv8-a -mtune=cortex-a53' - CFLAGS = DEVICE + ' -Wall -Werror' + CFLAGS = DEVICE + ' -Wall ' AFLAGS = ' -c' + ' -x assembler-with-cpp -D__ASSEMBLY__' LFLAGS = DEVICE + ' -nostartfiles -Wl,--gc-sections,-Map=rtthread.map,-cref,-u,system_vectors -T link.lds' CPATH = '' |