/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author            Notes
 * 2020-07-04     thread-liu        the first version
 */

#include "board.h"

#if defined(BSP_USING_SDCARD)
#include <dfs_fs.h>
#include <drv_gpio.h>
#include "stm32f4xx_hal.h"

#define DRV_DEBUG
//#define SDCARD_TX_DUMP
//#define SDCARD_RX_DUMP
#define LOG_TAG             "drv.sdcard"
#include <drv_log.h>

//#define SDCARD_DMA


static SD_HandleTypeDef        SDCARD_Handler = {0};
static HAL_SD_CardInfoTypeDef  SDCardInfo     = {0};

struct stm32_sd
{
    struct rt_device sdcard;
    struct rt_semaphore sd_lock;
    volatile rt_uint8_t write_flage;
    volatile rt_uint8_t read_flage;
    volatile rt_base_t level;
};
static struct stm32_sd sd_device;

#define SD_TIMEOUT      ((uint32_t)3 * 1000)
#define DETECT_PIN      GET_PIN(G, 1)
#define LDO_PIN         GET_PIN(F, 14)

struct rt_completion tx_comp;
struct rt_completion rx_comp;


#define SDIO_BUFF_SIZE       512
#define SDCARD_ADDR          0x2FFC0000

#if defined(__ARMCC_VERSION)
//__attribute__((at(SDCARD_ADDR))) 
static rt_uint32_t cache_buf[SDIO_BUFF_SIZE];
#elif defined ( __GNUC__ )
static rt_uint32_t cache_buf[SDIO_BUFF_SIZE] __attribute__((section(".SdCardSection")));
#elif defined(__ICCARM__)
#pragma location = SDCARD_ADDR
__no_init static rt_uint32_t cache_buf[SDIO_BUFF_SIZE];
#endif

#if defined(SDCARD_RX_DUMP) || defined(SDCARD_TX_DUMP)
#define __is_print(ch) ((unsigned int)((ch) - ' ') < 127u - ' ')
static void dump_hex(const rt_uint8_t *ptr, rt_size_t buflen)
{
    unsigned char *buf = (unsigned char *)ptr;
    int i, j;

    for (i = 0; i < buflen; i += 16)
    {
        rt_kprintf("%08X: ", i);

        for (j = 0; j < 16; j++)
            if (i + j < buflen)
                rt_kprintf("%02X ", buf[i + j]);
            else
                rt_kprintf("   ");
        rt_kprintf(" ");

        for (j = 0; j < 16; j++)
            if (i + j < buflen)
                rt_kprintf("%c", __is_print(buf[i + j]) ? buf[i + j] : '.');
        rt_kprintf("\n");
    }
}
#endif

static rt_err_t rt_hw_sd_is_detected(void)
{
   return rt_pin_read(DETECT_PIN);
}

static rt_err_t rt_hw_sd_init(void)
{
#if 0
    /* sd ldo*/
    rt_pin_mode(LDO_PIN, PIN_MODE_OUTPUT);
    /* sd detect */
    rt_pin_mode(DETECT_PIN, PIN_MODE_INPUT_PULLUP);

    if (rt_hw_sd_is_detected() != 0x00)
    {
        LOG_E("can't find sd card!");
        return -RT_ERROR;
    }
#endif

    SDCARD_Handler.Instance = SDIO;
    HAL_SD_DeInit(&SDCARD_Handler);
    
    SDCARD_Handler.Instance = SDIO;
    SDCARD_Handler.Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
    SDCARD_Handler.Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
    SDCARD_Handler.Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
    SDCARD_Handler.Init.BusWide = SDIO_BUS_WIDE_1B;
    SDCARD_Handler.Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
    SDCARD_Handler.Init.ClockDiv = 1;

    if (HAL_SD_Init(&SDCARD_Handler) != HAL_OK)
    {
        LOG_E("sd device init error!");
        return -RT_ERROR;
    }

    if (HAL_SD_ConfigWideBusOperation(&SDCARD_Handler, SDIO_BUS_WIDE_4B) != HAL_OK)
    {
        LOG_E("sd bus config error!");
        return -RT_ERROR;
    }

    if (HAL_SD_GetCardInfo(&SDCARD_Handler, &SDCardInfo) != HAL_OK)
    {
        LOG_E("sd get card info error!");
        return -RT_ERROR;
    }

    rt_thread_mdelay(100);

    if(HAL_SD_GetCardState(&SDCARD_Handler) != HAL_SD_CARD_TRANSFER)
    {
        LOG_E("sd get card state error!");
        return -RT_ERROR;
    }
#ifdef SDCARD_DMA
    HAL_NVIC_EnableIRQ(SDIO_IRQn);
#endif
    
    return RT_EOK;
}

static void rt_hw_sd_deinit(void)
{
    HAL_SD_DeInit(&SDCARD_Handler);
}

static rt_err_t sdcard_wait_ok(void)
{
    rt_uint32_t tick_start = 0;

    tick_start = rt_tick_get();
    while ((rt_tick_get() - tick_start) < SD_TIMEOUT)
    {
        if (HAL_SD_GetCardState(&SDCARD_Handler) == HAL_SD_CARD_TRANSFER)
        {
            return HAL_OK;
        }
    }
    return HAL_ERROR;
}


static rt_err_t rt_sdcard_init(rt_device_t dev)
{
    RT_ASSERT(dev != RT_NULL);
    struct stm32_sd *sd = (struct stm32_sd *)dev;

    if (rt_sem_init(&sd->sd_lock, "sdlock", 1, RT_IPC_FLAG_FIFO) != RT_EOK)
    {
        LOG_E("init sd lock semaphore failed\n");
    }

    return RT_EOK;
}

static rt_err_t rt_sdcard_open(rt_device_t dev, rt_uint16_t oflag)
{
    RT_ASSERT(dev != RT_NULL);
    return RT_EOK;
}

static rt_err_t rt_sdcard_close(rt_device_t dev)
{
    RT_ASSERT(dev != RT_NULL);
    return RT_EOK;
}

/**
  * @brief  Reads Sector(s)
  * @param  dev : sd dev
  * @param  sector: Sector address (LBA) Data buffer to store read data
  * @param  *buffer: Data buffer to store read data
  * @param  count: Number of sectors to read (1..128)
  * @retval DRESULT: Operation result
  */

static rt_ssize_t rt_sdcard_read(rt_device_t dev, rt_off_t sector, void *buffer, rt_size_t count)
{
    RT_ASSERT(dev != RT_NULL);
    struct stm32_sd *sd = (struct stm32_sd *)dev;

    rt_uint8_t ret = RT_EOK;
    volatile uint32_t tickstart = 0;
    sd->read_flage  = 0;

    rt_memset(cache_buf, 0x00, BLOCKSIZE * count);

    ret = sdcard_wait_ok();
    if (ret != RT_EOK)
    {
        LOG_D("sdcard busy!");
        return 0;
    }

    
#ifdef SDCARD_DMA
    rt_sem_take(&sd->sd_lock, RT_WAITING_FOREVER);
    ret = HAL_SD_ReadBlocks_DMA(&SDCARD_Handler, (rt_uint8_t *)cache_buf, (uint32_t)sector, count);
    rt_sem_release(&sd->sd_lock);

    /* Wait that writing process is completed or a timeout occurs */
    tickstart = rt_tick_get();
    if (ret == HAL_OK)
    {
        while ((sd->read_flage == 0) && (rt_tick_get() - tickstart) < SD_TIMEOUT)
        {
        }
        /* over time */
        if (sd->read_flage == 0)
        {
            return 0;
        }
        else
        {
            sd->read_flage = 0;
            tickstart = rt_tick_get();
            while ((rt_tick_get() - tickstart) < SD_TIMEOUT)
            {
                if (sdcard_wait_ok() == RT_EOK)
                {
                    sd->level=rt_hw_interrupt_disable();
                    rt_memcpy((rt_uint8_t *)(buffer), cache_buf, BLOCKSIZE * count);
                    rt_hw_interrupt_enable(sd->level);
    #if defined(SDCARD_RX_DUMP)
                    rt_kprintf("\nsd rx: \n");
                    dump_hex(cache_buf, BLOCKSIZE * count);
    #endif
                    return count;
                }
            }
        }
    }
#else
    ret = HAL_SD_ReadBlocks(&SDCARD_Handler, (uint8_t *)cache_buf, (uint32_t)sector, count, SD_TIMEOUT);
    ret = sdcard_wait_ok();
    if (ret == RT_EOK) {
        return count;
    }
    else {
        LOG_D("sdcard busy!");
    }
#endif
    

    return 0;
}

/**
  * @brief  Writes block(s) to a specified address in an SD card, in DMA mode.
  * @param  dev        SD device
  * @param  sector     Block index from where data is to be written P
  * @param  *buffer    Pointer to the buffer that will contain the data to transmit
  * @param  count      Number of SD blocks to write
  * @retval BSP status
  */
static rt_ssize_t rt_sdcard_write(rt_device_t dev, rt_off_t sector, const void *buffer, rt_size_t count)
{
    RT_ASSERT(dev != RT_NULL);
    struct stm32_sd *sd = (struct stm32_sd *)dev;
    rt_uint32_t i = 0;
    rt_uint8_t ret = RT_EOK;

    for (i = 0; i < count; i++)
    {
        sd->level = rt_hw_interrupt_disable();
        rt_memset(cache_buf, 0x00, BLOCKSIZE);
        rt_memcpy(cache_buf, (rt_uint32_t *)((uintptr_t)buffer + BLOCKSIZE * i), BLOCKSIZE);
        rt_hw_interrupt_enable(sd->level);

#if defined(SDCARD_TX_DUMP)
        rt_kprintf("\nsd tx: \n");
        dump_hex(cache_buf, BLOCKSIZE);
#endif
        ret = sdcard_wait_ok();
        if (ret != RT_EOK)
        {
            LOG_D("sdcard busy!");
            return 0;
        }
        
#ifdef SDCARD_DMA
        rt_completion_init(&tx_comp);
        ret = HAL_SD_WriteBlocks_DMA(&SDCARD_Handler, (rt_uint8_t *)cache_buf, (rt_uint32_t)(sector + i),  1);
        if (ret != HAL_OK)
        {
            rt_kprintf("sd write error!\n");
            return 0;
        }
        rt_completion_wait(&tx_comp,RT_WAITING_FOREVER);
#else
        HAL_SD_WriteBlocks(&SDCARD_Handler, (uint8_t *)cache_buf, (rt_uint32_t)(sector + i),  1, SD_TIMEOUT);
        ret = sdcard_wait_ok();
        if (ret != RT_EOK)
        {
            LOG_D("sdcard busy!");
            return 0;
        }
#endif
    }

    return count;
}

static rt_err_t rt_sdcard_control(rt_device_t dev, int cmd, void *args)
{
    RT_ASSERT(dev != RT_NULL);

    if (cmd == RT_DEVICE_CTRL_BLK_GETGEOME)
    {
        struct rt_device_blk_geometry *geometry;

        geometry = (struct rt_device_blk_geometry *)args;

        geometry->bytes_per_sector = 512;
        geometry->block_size       = SDCARD_Handler.SdCard.BlockSize;
        geometry->sector_count     = SDCARD_Handler.SdCard.BlockNbr;
    }

    return RT_EOK;
}

void SDIO_IRQHandler(void)
{
    rt_interrupt_enter();

    HAL_SD_IRQHandler(&SDCARD_Handler);

    rt_interrupt_leave();
}
void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
{
    if (hsd->Instance == SDCARD_Handler.Instance)
    {
        sd_device.read_flage = 1;
    }
}
void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
{
    if (hsd->Instance == SDCARD_Handler.Instance)
    {
        rt_completion_done(&tx_comp);
    }
}
void HAL_SD_DriveTransceiver_1_8V_Callback(FlagStatus status)
{
    if (status == SET)
    {
        rt_pin_write(LDO_PIN, PIN_HIGH);
    }
    else
    {
        rt_pin_write(LDO_PIN, PIN_LOW);
    }
}


int rt_hw_sdcard_init(void)
{
    if (rt_hw_sd_init() != RT_EOK)
    {
        rt_hw_sd_deinit();
        LOG_E("sdcard init failed");

        return -RT_ERROR;
    }
    /* register sdcard device */
    sd_device.sdcard.type    = RT_Device_Class_Block;
    sd_device.sdcard.init    = rt_sdcard_init;
    sd_device.sdcard.open    = rt_sdcard_open;
    sd_device.sdcard.close   = rt_sdcard_close;
    sd_device.sdcard.read    = rt_sdcard_read;
    sd_device.sdcard.write   = rt_sdcard_write;
    sd_device.sdcard.control = rt_sdcard_control;

    /* no private */
    sd_device.sdcard.user_data = &SDCardInfo;

    rt_device_register(&sd_device.sdcard, "sdcard", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);

    LOG_I("sd card init success!");

    return RT_EOK;
}
INIT_DEVICE_EXPORT(rt_hw_sdcard_init);

#endif