drivers: media: pci: Add Hailo accelerator device drivers

Add version 4.17.1 of the Hailo PCIe device drivers.
Sourced from https://github.com/hailo-ai/hailort-drivers/

Signed-off-by: Naushir Patuck <naush@raspberrypi.com>

Author: naushir

arch/arm/configs/bcm2711_defconfig

@@ -923,6 +923,8 @@ CONFIG_VIDEO_EM28XX=m
 CONFIG_VIDEO_EM28XX_V4L2=m
 CONFIG_VIDEO_EM28XX_ALSA=m
 CONFIG_VIDEO_EM28XX_DVB=m
+CONFIG_MEDIA_PCI_SUPPORT=y
+CONFIG_MEDIA_PCI_HAILO=m
 CONFIG_RADIO_SAA7706H=m
 CONFIG_RADIO_SHARK=m
 CONFIG_RADIO_SHARK2=m

arch/arm64/configs/bcm2711_defconfig

@@ -951,6 +951,8 @@ CONFIG_VIDEO_EM28XX=m
 CONFIG_VIDEO_EM28XX_V4L2=m
 CONFIG_VIDEO_EM28XX_ALSA=m
 CONFIG_VIDEO_EM28XX_DVB=m
+CONFIG_MEDIA_PCI_SUPPORT=y
+CONFIG_MEDIA_PCI_HAILO=m
 CONFIG_RADIO_SAA7706H=m
 CONFIG_RADIO_SHARK=m
 CONFIG_RADIO_SHARK2=m

arch/arm64/configs/bcm2712_defconfig

@@ -954,6 +954,8 @@ CONFIG_VIDEO_EM28XX=m
 CONFIG_VIDEO_EM28XX_V4L2=m
 CONFIG_VIDEO_EM28XX_ALSA=m
 CONFIG_VIDEO_EM28XX_DVB=m
+CONFIG_MEDIA_PCI_SUPPORT=y
+CONFIG_MEDIA_PCI_HAILO=m
 CONFIG_RADIO_SAA7706H=m
 CONFIG_RADIO_SHARK=m
 CONFIG_RADIO_SHARK2=m

drivers/media/pci/Kconfig

@@ -74,6 +74,7 @@ config VIDEO_PCI_SKELETON
 	  when developing new drivers.
 
 source "drivers/media/pci/intel/Kconfig"
+source "drivers/media/pci/hailo/Kconfig"
 
 endif #MEDIA_PCI_SUPPORT
 endif #PCI

drivers/media/pci/Makefile

@@ -17,7 +17,8 @@ obj-y        +=	ttpci/		\
 		saa7146/	\
 		smipcie/	\
 		netup_unidvb/	\
-		intel/
+		intel/		\
+		hailo/
 
 # Please keep it alphabetically sorted by Kconfig name
 # (e. g. LC_ALL=C sort Makefile)

drivers/media/pci/hailo/Kconfig

@@ -0,0 +1,6 @@
+
+config MEDIA_PCI_HAILO
+	tristate "Hailo AI accelerator PCIe driver"
+	depends on PCI
+	help
+	  Enable build of Hailo AI accelerator PCIe driver.

drivers/media/pci/hailo/Makefile

@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: GPL-2.0
+
+COMMON_SRC_DIRECTORY=common
+VDMA_SRC_DIRECTORY=vdma
+UTILS_SRC_DIRECTORY=utils
+
+obj-$(CONFIG_MEDIA_PCI_HAILO) := hailo_pci.o
+
+hailo_pci-objs += src/pcie.o
+hailo_pci-objs += src/fops.o
+hailo_pci-objs += src/utils.o
+hailo_pci-objs += src/sysfs.o
+
+hailo_pci-objs += $(COMMON_SRC_DIRECTORY)/fw_validation.o
+hailo_pci-objs += $(COMMON_SRC_DIRECTORY)/fw_operation.o
+hailo_pci-objs += $(COMMON_SRC_DIRECTORY)/pcie_common.o
+hailo_pci-objs += $(COMMON_SRC_DIRECTORY)/vdma_common.o
+hailo_pci-objs += $(COMMON_SRC_DIRECTORY)/hailo_resource.o
+
+hailo_pci-objs += $(UTILS_SRC_DIRECTORY)/logs.o
+
+hailo_pci-objs += $(VDMA_SRC_DIRECTORY)/vdma.o
+hailo_pci-objs += $(VDMA_SRC_DIRECTORY)/memory.o
+hailo_pci-objs += $(VDMA_SRC_DIRECTORY)/ioctl.o
+
+ccflags-y      += -Werror
+ccflags-y      += -DHAILO_RASBERRY_PIE
+ccflags-y      += -I$(srctree)/$(src)
+ccflags-y      += -I$(srctree)/$(src)/include
+ccflags-y      += -I$(srctree)/$(src)/common
+
+clean-files := $(hailo_pci-objs)

drivers/media/pci/hailo/common/fw_operation.c

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: GPL-2.0
+/**
+ * Copyright (c) 2022 Hailo Technologies Ltd. All rights reserved.
+**/
+
+#include "fw_operation.h"
+
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/bug.h>
+
+typedef struct {
+    u32 host_offset;
+    u32 chip_offset;
+} FW_DEBUG_BUFFER_HEADER_t;
+
+#define DEBUG_BUFFER_DATA_SIZE (DEBUG_BUFFER_TOTAL_SIZE - sizeof(FW_DEBUG_BUFFER_HEADER_t))
+
+int hailo_read_firmware_notification(struct hailo_resource *resource, struct hailo_d2h_notification *notification)
+{
+    hailo_d2h_buffer_details_t d2h_buffer_details = {0, 0};
+    hailo_resource_read_buffer(resource, 0, sizeof(d2h_buffer_details),
+        &d2h_buffer_details);
+
+    if ((sizeof(notification->buffer) < d2h_buffer_details.buffer_len) || (0 == d2h_buffer_details.is_buffer_in_use)) {
+        return -EINVAL;
+    }
+
+    notification->buffer_len = d2h_buffer_details.buffer_len;
+    hailo_resource_read_buffer(resource, sizeof(d2h_buffer_details), notification->buffer_len, notification->buffer);
+
+    // Write is_buffer_in_use = false
+    hailo_resource_write16(resource, 0, 0);
+    return 0;
+}
+
+static inline size_t calculate_log_ready_to_read(FW_DEBUG_BUFFER_HEADER_t *header)
+{
+    size_t ready_to_read = 0;
+    size_t host_offset = header->host_offset;
+    size_t chip_offset = header->chip_offset;
+
+    if (chip_offset >= host_offset) {
+        ready_to_read = chip_offset - host_offset;
+    } else {
+        ready_to_read = DEBUG_BUFFER_DATA_SIZE - (host_offset - chip_offset);
+    }
+
+    return ready_to_read;
+}
+
+long hailo_read_firmware_log(struct hailo_resource *fw_logger_resource, struct hailo_read_log_params *params)
+{
+    FW_DEBUG_BUFFER_HEADER_t debug_buffer_header = {0};
+    size_t read_offset = 0;
+    size_t ready_to_read = 0;
+    size_t size_to_read = 0;
+    uintptr_t user_buffer = (uintptr_t)params->buffer;
+
+    if (params->buffer_size > ARRAY_SIZE(params->buffer)) {
+        return -EINVAL;
+    }
+
+    hailo_resource_read_buffer(fw_logger_resource, 0, sizeof(debug_buffer_header),
+        &debug_buffer_header);
+
+    /* Point to the start of the data buffer. */
+    ready_to_read = calculate_log_ready_to_read(&debug_buffer_header);
+    if (0 == ready_to_read) {
+        params->read_bytes = 0;
+        return 0;
+    }
+    /* If ready to read is bigger than the buffer size, read only buffer size bytes. */
+    ready_to_read = min(ready_to_read, params->buffer_size);
+    
+    /* Point to the data that is read to be read by the host. */
+    read_offset = sizeof(debug_buffer_header) + debug_buffer_header.host_offset;
+    /* Check if the offset should cycle back to beginning. */
+    if (DEBUG_BUFFER_DATA_SIZE <= debug_buffer_header.host_offset + ready_to_read) {
+        size_to_read = DEBUG_BUFFER_DATA_SIZE - debug_buffer_header.host_offset;
+        hailo_resource_read_buffer(fw_logger_resource, read_offset, size_to_read, (void*)user_buffer);
+
+        user_buffer += size_to_read;
+        size_to_read = ready_to_read - size_to_read;
+        /* Point back to the beginning of the data buffer. */
+        read_offset -= debug_buffer_header.host_offset;
+    }
+    else {
+        size_to_read = ready_to_read;
+    }
+
+    /* size_to_read may become 0 if the read reached DEBUG_BUFFER_DATA_SIZE exactly */
+    hailo_resource_read_buffer(fw_logger_resource, read_offset, size_to_read, (void*)user_buffer);
+
+    /* Change current_offset to represent the new host offset. */
+    read_offset += size_to_read;
+    hailo_resource_write32(fw_logger_resource, offsetof(FW_DEBUG_BUFFER_HEADER_t, host_offset),
+        (u32)(read_offset - sizeof(debug_buffer_header)));
+    
+    params->read_bytes = ready_to_read;
+    return 0;
+}

drivers/media/pci/hailo/common/fw_operation.h

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-2.0
+/**
+ * Copyright (c) 2022 Hailo Technologies Ltd. All rights reserved.
+**/
+
+#ifndef _HAILO_COMMON_FIRMWARE_OPERATION_H_
+#define _HAILO_COMMON_FIRMWARE_OPERATION_H_
+
+#include "hailo_resource.h"
+
+#define DEBUG_BUFFER_TOTAL_SIZE (4*1024)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int hailo_read_firmware_notification(struct hailo_resource *resource, struct hailo_d2h_notification *notification);
+
+long hailo_read_firmware_log(struct hailo_resource *fw_logger_resource, struct hailo_read_log_params *params);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _HAILO_COMMON_FIRMWARE_OPERATION_H_ */

drivers/media/pci/hailo/common/fw_validation.c

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: GPL-2.0
+/**
+ * Copyright (c) 2019-2022 Hailo Technologies Ltd. All rights reserved.
+ **/
+
+#include "fw_validation.h"
+#include <linux/errno.h>
+#include <linux/types.h>
+
+
+
+/* when reading the firmware we don't want to read past the firmware_size,
+   so we have a consumed_firmware_offset that is updated _before_ accessing data at that offset
+   of firmware_base_address */
+#define CONSUME_FIRMWARE(__size, __err) do {                                                    \
+        consumed_firmware_offset += (u32) (__size);                                        \
+        if ((firmware_size < (__size)) || (firmware_size < consumed_firmware_offset)) {         \
+            err = __err;                                                                        \
+            goto exit;                                                                          \
+        }                                                                                       \
+    } while(0)
+
+int FW_VALIDATION__validate_fw_header(uintptr_t firmware_base_address,
+    size_t firmware_size, u32 max_code_size, u32 *outer_consumed_firmware_offset,
+    firmware_header_t **out_firmware_header, enum hailo_board_type board_type)
+{
+    int err = -EINVAL;
+    firmware_header_t *firmware_header = NULL;
+    u32 consumed_firmware_offset = *outer_consumed_firmware_offset;
+    u32 expected_firmware_magic = 0;
+ 
+    firmware_header = (firmware_header_t *) (firmware_base_address + consumed_firmware_offset);
+    CONSUME_FIRMWARE(sizeof(firmware_header_t), -EINVAL);
+
+    switch (board_type) {
+    case HAILO_BOARD_TYPE_HAILO8:
+        expected_firmware_magic = FIRMWARE_HEADER_MAGIC_HAILO8; 
+        break;
+    case HAILO_BOARD_TYPE_HAILO15:
+        expected_firmware_magic = FIRMWARE_HEADER_MAGIC_HAILO15; 
+        break;
+    case HAILO_BOARD_TYPE_PLUTO:
+        expected_firmware_magic = FIRMWARE_HEADER_MAGIC_PLUTO;
+        break;
+    default:
+        err = -EINVAL;
+        goto exit;
+    }
+
+    if (expected_firmware_magic != firmware_header->magic) {
+        err = -EINVAL;
+        goto exit;
+    }
+
+    /* Validate that the firmware header version is supported */
+    switch(firmware_header->header_version) {
+        case FIRMWARE_HEADER_VERSION_INITIAL:
+            break;
+        default:
+            err = -EINVAL;
+            goto exit;
+            break;
+    }
+
+    if (MINIMUM_FIRMWARE_CODE_SIZE > firmware_header->code_size) {
+        err = -EINVAL;
+        goto exit;
+    }
+
+    if (max_code_size < firmware_header->code_size) {
+        err = -EINVAL;
+        goto exit;
+    }
+
+    CONSUME_FIRMWARE(firmware_header->code_size, -EINVAL);
+
+    *outer_consumed_firmware_offset = consumed_firmware_offset;
+    *out_firmware_header = firmware_header;
+    err = 0;
+
+exit:
+    return err;
+}
+
+int FW_VALIDATION__validate_cert_header(uintptr_t firmware_base_address,
+    size_t firmware_size, u32 *outer_consumed_firmware_offset, secure_boot_certificate_t **out_firmware_cert)
+{
+
+    secure_boot_certificate_t *firmware_cert = NULL;
+    int err = -EINVAL;
+    u32 consumed_firmware_offset = *outer_consumed_firmware_offset;
+
+    firmware_cert = (secure_boot_certificate_t *) (firmware_base_address + consumed_firmware_offset);
+    CONSUME_FIRMWARE(sizeof(secure_boot_certificate_t), -EINVAL);
+
+    if ((MAXIMUM_FIRMWARE_CERT_KEY_SIZE < firmware_cert->key_size) ||
+        (MAXIMUM_FIRMWARE_CERT_CONTENT_SIZE < firmware_cert->content_size)) {
+        err = -EINVAL;
+        goto exit;
+    }
+
+    CONSUME_FIRMWARE(firmware_cert->key_size, -EINVAL);
+    CONSUME_FIRMWARE(firmware_cert->content_size, -EINVAL);
+
+    *outer_consumed_firmware_offset = consumed_firmware_offset;
+    *out_firmware_cert = firmware_cert;
+    err = 0;
+
+exit:
+    return err;
+}
+