esp-idf/components/esp_driver_jpeg/jpeg_common.c

/*
 * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <stdlib.h>
#include "esp_err.h"
#include "hal/jpeg_ll.h"
#include "esp_private/periph_ctrl.h"
#include "jpeg_private.h"
#include "hal/jpeg_hal.h"
#include "esp_memory_utils.h"
#include "driver/jpeg_types.h"
#include "sys/lock.h"
#include "sys/queue.h"
#include "sdkconfig.h"
#if CONFIG_JPEG_ENABLE_DEBUG_LOG
// The local log level must be defined before including esp_log.h
// Set the maximum log level for this source file
#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
#endif
#include "esp_log.h"
#include "esp_check.h"

static const char *TAG = "jpeg.common";

typedef struct jpeg_platform_t {
    _lock_t mutex;                       // platform level mutex lock.
    jpeg_codec_handle_t jpeg_codec;      // JPEG codec instances.
    uint32_t count;                      // reference count used to protect group install/uninstall.
} jpeg_platform_t;

static jpeg_platform_t s_jpeg_platform = {};  // singleton platform

esp_err_t jpeg_acquire_codec_handle(jpeg_codec_handle_t *jpeg_new_codec)
{
#if CONFIG_JPEG_ENABLE_DEBUG_LOG
    esp_log_level_set(TAG, ESP_LOG_DEBUG);
#endif
    esp_err_t ret = ESP_OK;
    bool new_codec = false;
    jpeg_codec_t *codec = NULL;
    _lock_acquire(&s_jpeg_platform.mutex);
    if (!s_jpeg_platform.jpeg_codec) {
        codec = heap_caps_calloc(1, sizeof(jpeg_codec_t), JPEG_MEM_ALLOC_CAPS);
        if (codec) {
            new_codec = true;
            s_jpeg_platform.jpeg_codec = codec;
            codec->intr_priority = -1;
            codec->spinlock = (portMUX_TYPE)portMUX_INITIALIZER_UNLOCKED;
            codec->codec_mutex = xSemaphoreCreateBinaryWithCaps(JPEG_MEM_ALLOC_CAPS);
            ESP_RETURN_ON_FALSE(codec->codec_mutex, ESP_ERR_NO_MEM, TAG, "No memory for codec mutex");
            SLIST_INIT(&codec->jpeg_isr_handler_list);
            xSemaphoreGive(codec->codec_mutex);
            // init the clock
            PERIPH_RCC_ATOMIC() {
                jpeg_ll_enable_bus_clock(true);
                jpeg_ll_reset_module_register();
            }
#if CONFIG_PM_ENABLE
            ESP_RETURN_ON_ERROR(esp_pm_lock_create(ESP_PM_CPU_FREQ_MAX, 0, "jpeg_codec", &codec->pm_lock), TAG, "create pm lock failed");
#endif
            jpeg_hal_init(&codec->hal);
        } else {
            ESP_LOGE(TAG, "No more memory for acquiring JPEG codec module");
            ret = ESP_ERR_NO_MEM;
        }
    }

    if (s_jpeg_platform.jpeg_codec) {
        s_jpeg_platform.count++;
    }
    if (new_codec) {
        ESP_LOGD(TAG, "new jpeg module has been acquired at (%p)", codec);
    }

    *jpeg_new_codec = s_jpeg_platform.jpeg_codec;
    _lock_release(&s_jpeg_platform.mutex);
    return ret;
}

esp_err_t jpeg_release_codec_handle(jpeg_codec_handle_t jpeg_codec)
{
    bool do_deinitialize = false;
    _lock_acquire(&s_jpeg_platform.mutex);

    if (s_jpeg_platform.jpeg_codec) {
        s_jpeg_platform.count--;
        if (s_jpeg_platform.count == 0) {
            do_deinitialize = true;
            s_jpeg_platform.jpeg_codec = NULL;

            if (jpeg_codec->codec_mutex) {
                vSemaphoreDeleteWithCaps(jpeg_codec->codec_mutex);
                jpeg_codec->codec_mutex = NULL;
            }
            if (jpeg_codec->pm_lock) {
                esp_pm_lock_delete(jpeg_codec->pm_lock);
            }
            PERIPH_RCC_ATOMIC() {
                jpeg_ll_enable_bus_clock(false);
            }
            free(jpeg_codec);
        }
    }

    if (do_deinitialize) {
        ESP_LOGD(TAG, "delete codec");
    }
    _lock_release(&s_jpeg_platform.mutex);

    return ESP_OK;
}

/*---------------------------------------------------------------
                    JPEG INTERRUPT HANDLER
---------------------------------------------------------------*/

static void jpeg_isr(void* arg)
{
    jpeg_codec_handle_t jpeg_codec = (jpeg_codec_handle_t) arg;
    uint32_t status = jpeg_ll_get_intr_status(jpeg_codec->hal.dev);
    jpeg_isr_handler_t* it;
    SLIST_FOREACH(it, &jpeg_codec->jpeg_isr_handler_list, next) {
        if (it->mask & status) {
            (*it->handler)(it->handler_arg);
        }
    }
    jpeg_ll_clear_intr_mask(jpeg_codec->hal.dev, status);
}

esp_err_t jpeg_isr_register(jpeg_codec_handle_t jpeg_codec, intr_handler_t handler, void* handler_arg, uint32_t jpeg_intr_mask, uint32_t flags, jpeg_isr_handler_t** jpeg_intr_handler)
{
    if (jpeg_codec->intr_handle == NULL) {
        // The jpeg codec interrupt has not been allocated.
        esp_err_t err = esp_intr_alloc_intrstatus(ETS_JPEG_INTR_SOURCE, flags, (uint32_t)jpeg_ll_get_interrupt_status_reg(jpeg_codec->hal.dev), JPEG_LL_DECODER_EVENT_INTR | JPEG_LL_ENCODER_EVENT_INTR, &jpeg_isr, jpeg_codec, &jpeg_codec->intr_handle);
        if (err != ESP_OK) {
            return err;
        }
    }

    jpeg_isr_handler_t* item = heap_caps_calloc(1, sizeof(jpeg_isr_handler_t), JPEG_MEM_ALLOC_CAPS);
    if (item == NULL) {
        return ESP_ERR_NO_MEM;
    }
    item->handler = handler;
    item->handler_arg = handler_arg;
    item->mask = jpeg_intr_mask;
    item->flags = flags;
    SLIST_INSERT_HEAD(&jpeg_codec->jpeg_isr_handler_list, item, next);
    *jpeg_intr_handler = item;
    return ESP_OK;
}

esp_err_t jpeg_isr_deregister(jpeg_codec_handle_t jpeg_codec, jpeg_isr_handler_t *jpeg_intr_handler)
{
    jpeg_isr_handler_t* it;
    jpeg_isr_handler_t* prev = NULL;
    bool found = false;
    SLIST_FOREACH(it, &jpeg_codec->jpeg_isr_handler_list, next) {
        if (it == jpeg_intr_handler) {
            if (it == SLIST_FIRST(&jpeg_codec->jpeg_isr_handler_list)) {
                SLIST_REMOVE_HEAD(&jpeg_codec->jpeg_isr_handler_list, next);
            } else {
                SLIST_REMOVE_AFTER(prev, next);
            }
            found = true;
            break;
        }
        prev = it;
    }
    if (found) {
        free(it);
    }
    if (unlikely(found != true)) {
        return ESP_ERR_INVALID_STATE;
    }

    if (SLIST_EMPTY(&jpeg_codec->jpeg_isr_handler_list)) {
        // All interrupt is removed
        if (jpeg_codec->intr_handle) {
            esp_intr_free(jpeg_codec->intr_handle);
        }
    }
    return ESP_OK;
}

esp_err_t jpeg_check_intr_priority(jpeg_codec_handle_t jpeg_codec, int intr_priority)
{
    esp_err_t ret = ESP_OK;
    bool intr_priority_conflict = false;
    if (jpeg_codec->intr_priority == -1) {
        jpeg_codec->intr_priority = intr_priority;
    } else if (intr_priority != 0) {
        intr_priority_conflict = (jpeg_codec->intr_priority != intr_priority);
    }
    ESP_RETURN_ON_FALSE(!intr_priority_conflict, ESP_ERR_INVALID_STATE, TAG, "intr_priority conflict, already is %d but attempt to %d", jpeg_codec->intr_priority, intr_priority);
    return ret;
}