[STM32H7] 【银杏科技ARM+FPGA】分享iCore4T移植RT-Thread过程的点点滴滴

/*

 * Copyright (c) 2006-2018, RT-Thread Development Team

 *

 * SPDX-License-Identifier: Apache-2.0

 *

 * Change Logs:

 * Date           Author       Notes

 * 2018-11-27     zylx         first version

 */

 

#include <board.h>

#include <drv_qspi.h>

#include <rtdevice.h>

#include <rthw.h>

#include <finsh.h>



#ifdef BSP_USING_QSPI_FLASH



#include "spi_flash.h"

#include "spi_flash_sfud.h"



char w25qxx_read_status_register2(struct rt_qspi_device *device)

{

    /* 0x35 read status register2 */

    char instruction = 0x35, status;



    rt_qspi_send_then_recv(device, &instruction, 1, &status, 1);



    return status;

}



void w25qxx_write_enable(struct rt_qspi_device *device)

{

    /* 0x06 write enable */

    char instruction = 0x06;



    rt_qspi_send(device, &instruction, 1);

}



void w25qxx_enter_qspi_mode(struct rt_qspi_device *device)

{

    char status = 0;

    /* 0x38 enter qspi mode */

    char instruction = 0x38;

    char write_status2_buf[2] = {0};



    /* 0x31 write status register2 */

    write_status2_buf[0] = 0x31;



    status = w25qxx_read_status_register2(device);

    if (!(status & 0x02))

    {

        status |= 1 << 1;

        w25qxx_write_enable(device);

        write_status2_buf[1] = status;

        rt_qspi_send(device, &write_status2_buf, 2);

        rt_qspi_send(device, &instruction, 1);

        rt_kprintf("flash already enter qspi mode\n");

        rt_thread_mdelay(10);

    }

}



static int rt_hw_qspi_flash_with_sfud_init(void)

{

    stm32_qspi_bus_attach_device("qspi1", "qspi10", RT_NULL, 4, w25qxx_enter_qspi_mode, RT_NULL);

    

    /* init w25q64 */

    if (RT_NULL == rt_sfud_flash_probe("W25Q64", "qspi10"))

    {

        return -RT_ERROR;

    }



    return RT_EOK;

}

INIT_COMPONENT_EXPORT(rt_hw_qspi_flash_with_sfud_init);



#if defined(RT_USING_DFS_ELMFAT) && !defined(BSP_USING_SDCARD)

#include <dfs_fs.h>



#define BLK_DEV_NAME  "W25Q64"



int mnt_init(void)

{

    rt_thread_delay(RT_TICK_PER_SECOND);



    if (dfs_mount(BLK_DEV_NAME, "/", "elm", 0, 0) == 0)

    {

        rt_kprintf("file system initialization done!\n");

    }

    else

    {

        if(dfs_mkfs("elm", BLK_DEV_NAME) == 0)

        {

            if (dfs_mount(BLK_DEV_NAME, "/", "elm", 0, 0) == 0)

            {

                rt_kprintf("file system initialization done!\n");

            }

            else

            {

                rt_kprintf("file system initialization failed!\n");

            }

        }

    }



    return 0;

}

INIT_ENV_EXPORT(mnt_init);



#endif /* defined(RT_USING_DFS_ELMFAT) && !defined(BSP_USING_SDCARD) */

#endif /* BSP_USING_QSPI_FLASH */

/*

 * Copyright (c) 2006-2018, RT-Thread Development Team

 *

 * SPDX-License-Identifier: Apache-2.0

 *

 * Change Logs:

 * Date           Author       Notes

 * 2020-02-17     zh.          first version

 */

 

#include <board.h>

#include <drv_qspi.h>

#include <rtdevice.h>

#include <rthw.h>

#include <finsh.h>



#ifdef BSP_USING_I2C_AXP152



#define        AXP152_CHIP_VERSION                     0x03

#define        AXP152_DCDC1_VOLTAGE                    0x26

#define        AXP152_DCDC2_VOLTAGE                    0x23

#define        AXP152_DCDC3_VOLTAGE                    0x27

#define        AXP152_DCDC4_VOLTAGE                    0x2B

#define        AXP152_DLDO1_VOLTAGE                    0x29

#define        AXP152_DLDO2_VOLTAGE                    0x2A

#define        AXP152_ALDO1_ALD02_VOLTAGE              0x28

#define        AXP152_SHUTDOWN                         0x32



#define AXP152_POWEROFF                         (1 << 7)



/* For axp_gpio.c */

#define AXP152_ADDR                             (0x60 >> 1)

#define AXP_GPIO0_CTRL                          0x90

#define AXP_GPIO1_CTRL                          0x91

#define AXP_GPIO2_CTRL                          0x92

#define AXP_GPIO3_CTRL                          0x93

#define AXP_GPIO_CTRL_OUTPUT_LOW                0x00 /* Drive pin low */

#define AXP_GPIO_CTRL_OUTPUT_HIGH               0x01 /* Drive pin high */

#define AXP_GPIO_CTRL_INPUT                     0x02 /* Input */

#define AXP_GPIO_STATE                          0x97

#define AXP_GPIO_STATE_OFFSET                   0x00



/* For axp152 i2c bus*/

#define AXP152_I2CBUS_NAME     "i2c1"



static struct rt_i2c_bus_device *axp152_i2c_bus = RT_NULL;



static rt_err_t i2c_write_nbyte(rt_uint8_t slave_addr, rt_uint8_t cmd, rt_uint8_t *value, rt_uint32_t len)

{

    rt_uint32_t i;

    rt_uint8_t *buffer;

    rt_size_t result;

        

    buffer = rt_malloc(len + 1);

    buffer[0] = cmd;

        for(i  = 0;i < len;i ++)

        {

                buffer[i+1] = value[i];

        }        

    result = rt_i2c_master_send(axp152_i2c_bus, slave_addr, RT_I2C_WR, buffer, len+1);

        rt_free(buffer);

        

    if (result == (len+1))

    {

        return RT_EOK;       

    }

    else

    {

        return -RT_ERROR;       

    }

}



static rt_err_t i2c_read_nbyte(rt_uint8_t slave_addr, rt_uint8_t cmd, rt_uint8_t *buf, rt_uint32_t len)

{

    rt_i2c_master_send(axp152_i2c_bus, slave_addr, RT_I2C_WR, &cmd, 1);

    

    rt_i2c_master_recv(axp152_i2c_bus, slave_addr, RT_I2C_RD, buf, len);

    

    return RT_EOK;

}



static rt_uint8_t axp152_mvolt_to_target(rt_uint32_t mvolt, rt_uint32_t min, rt_uint32_t max, rt_uint32_t div)

{

    if(mvolt < min)                mvolt = min;

    else if (mvolt > max)                mvolt = max;



    return (mvolt - min) / div;

}



rt_err_t axp152_set_dcdc1(rt_uint32_t mvolt)

{

    rt_uint8_t target = axp152_mvolt_to_target(mvolt, 1700, 3500, 100);

        

    if(mvolt >= 2400 || mvolt <= 2800)target = target - 2;

    if(mvolt >= 3000 || mvolt <= 3500)target = target - 3;



    return i2c_write_nbyte(AXP152_ADDR,AXP152_DCDC1_VOLTAGE,&target,1);

}



rt_err_t axp152_set_dcdc2(rt_uint32_t mvolt)

{

    rt_uint8_t target = axp152_mvolt_to_target(mvolt, 700, 2275, 25);



    return i2c_write_nbyte(AXP152_ADDR,AXP152_DCDC2_VOLTAGE,&target,1);

}



rt_err_t axp152_set_dcdc3(rt_uint32_t mvolt)

{

     rt_uint8_t target = axp152_mvolt_to_target(mvolt, 700, 3500, 50);



     return i2c_write_nbyte(AXP152_ADDR,AXP152_DCDC3_VOLTAGE,&target,1);

}



rt_err_t axp152_set_dcdc4(rt_uint32_t mvolt)

{

    rt_uint8_t target = axp152_mvolt_to_target(mvolt, 700, 3500, 25);



    return i2c_write_nbyte(AXP152_ADDR,AXP152_DCDC4_VOLTAGE,&target,1);

}



rt_err_t axp152_set_dldo1(rt_uint32_t mvolt)

{

    rt_uint8_t target = axp152_mvolt_to_target(mvolt, 700, 3500, 100);



    return i2c_write_nbyte(AXP152_ADDR,AXP152_DLDO1_VOLTAGE,&target,1);        

}



rt_err_t axp152_set_dldo2(rt_uint32_t mvolt)

{

    rt_uint8_t target = axp152_mvolt_to_target(mvolt, 700, 3500, 100);



    return i2c_write_nbyte(AXP152_ADDR,AXP152_DLDO2_VOLTAGE,&target,1);

}



rt_err_t axp152_set_aldo1(rt_uint32_t mvolt)

{

    rt_uint8_t data;

    rt_uint8_t target;



    if(mvolt >= 1200 && mvolt <= 2000)

    {

        target = axp152_mvolt_to_target(mvolt, 1200, 2000, 100);

    }

    else if(mvolt == 2500) 

    {

        target = 0x09;

    }

    else if(mvolt == 2700)

    {

        target = 0x0A;

    }

    else if(mvolt == 2800)

    {

        target = 0x0B;

    }

    else if(mvolt >= 3000 || mvolt <= 3300)

    {

        target = axp152_mvolt_to_target(mvolt, 3000, 3300, 100);

        target += 0x0C;

    }



    i2c_read_nbyte(AXP152_ADDR,AXP152_ALDO1_ALD02_VOLTAGE,&data,1);



    data &= 0x0F;

    target = target << 4;

    target &= 0xF0;

    target = data | target;



    return i2c_write_nbyte(AXP152_ADDR,AXP152_ALDO1_ALD02_VOLTAGE,&target,1);

}



rt_err_t axp152_set_aldo2(rt_uint32_t mvolt)

{

    rt_uint8_t data;

    rt_uint8_t target;



    if(mvolt >= 1200 && mvolt <= 2000)

    {

        target = axp152_mvolt_to_target(mvolt, 1200, 2000, 100);

    }

    else if(mvolt == 2500)

    {

        target = 0x09;

    }

    else if(mvolt == 2700)

    {

        target = 0x0A;

    }

    else if(mvolt == 2800)

    {

        target = 0x0B;

    }

    else if(mvolt >= 3000 || mvolt <= 3300)

    {

        target = axp152_mvolt_to_target(mvolt, 3000, 3300, 100);

        target += 0x0C;

    }



    i2c_read_nbyte(AXP152_ADDR,AXP152_ALDO1_ALD02_VOLTAGE,&data,1);

    data &= 0xF0;

    target = target & 0x0F;

    target = data | target;

    return i2c_write_nbyte(AXP152_ADDR,AXP152_ALDO1_ALD02_VOLTAGE,&target,1);

}



int axp152_init(void)

{

    rt_uint8_t version;



    axp152_i2c_bus = rt_i2c_bus_device_find(AXP152_I2CBUS_NAME);



    if(axp152_i2c_bus == RT_NULL)

    {

        rt_kprintf("i2c_bus %s for axp152 not found!\n", axp152_i2c_bus);

        return -RT_ERROR;                        

    }

    /* detect axp152 */

    i2c_read_nbyte(AXP152_ADDR, AXP152_CHIP_VERSION, &version, 1);

    if(version != 0x05)

    {

        rt_kprintf("[AXP152] probe fail!\n");

                return -RT_ERROR;

    }

    else

    {

        rt_kprintf("[AXP152] probe ok! Version is 0x%02X\n",version);

    }



    /* config axp152 */

    axp152_set_dcdc1(AXP_DCDC1_VOLT);

    axp152_set_dcdc2(AXP_DCDC2_VOLT);

    axp152_set_dcdc3(AXP_DCDC3_VOLT);

    axp152_set_dcdc4(AXP_DCDC4_VOLT);

    axp152_set_dldo1(AXP_DLDO1_VOLT);

    axp152_set_dldo2(AXP_DLDO2_VOLT);

    axp152_set_aldo1(AXP_ALDO1_VOLT);

    axp152_set_aldo2(AXP_ALDO2_VOLT);

                

    return RT_EOK;

}

INIT_DEVICE_EXPORT(axp152_init);



#endif /* BSP_USING_I2C_AXP152 */

/*

 * Copyright (c) 2006-2018, RT-Thread Development Team

 *

 * SPDX-License-Identifier: Apache-2.0

 *

 * Change Logs:

 * Date           Author       Notes

 * 2020-02-17     zh.          first version

 */

 

#include <board.h>

#include <drv_qspi.h>

#include <rtdevice.h>

#include <rthw.h>

#include <finsh.h>



#ifdef BSP_USING_I2C_LM75A



#define LM75A_ADDR                                                            (0x90 >> 1)



/* For lm75a i2c bus*/

#define LM75A_I2CBUS_NAME     "i2c1"



static struct rt_i2c_bus_device *lm75a_i2c_bus = RT_NULL;



static rt_err_t i2c_read_nbyte(rt_uint8_t slave_addr, rt_uint8_t cmd, rt_uint8_t *buf, rt_uint32_t len)

{

    rt_i2c_master_send(lm75a_i2c_bus, slave_addr, RT_I2C_WR, &cmd, 1);

    

    rt_i2c_master_recv(lm75a_i2c_bus, slave_addr, RT_I2C_RD, buf, len);

    

    return RT_EOK;

}



float lm75a_read(void)

{

        union

        {

                unsigned char buf[2];

                short int value;

        }temp;

        float f;

        unsigned char c;

        

    lm75a_i2c_bus = rt_i2c_bus_device_find(LM75A_I2CBUS_NAME);



    if(lm75a_i2c_bus == RT_NULL)

    {

        rt_kprintf("i2c_bus %s for lm75a not found!\n", lm75a_i2c_bus);

        return -RT_ERROR;                        

    }

        

        i2c_read_nbyte(LM75A_ADDR,0,temp.buf,2);



        c = temp.buf[0];

        temp.buf[0] = temp.buf[1];

        temp.buf[1] = c;



        f = temp.value;

        f /= (float)32.0;

        f *= (float)0.125;

        

        return f;

}

static int lm75a(int argc, char **argv)

{

        float tempture;

        int temp;

        

        tempture = lm75a_read();

        

        temp = tempture * 100;

        rt_kprintf("The current temperature is: %d.%02d°\n",temp/100,temp%100);

        

    return RT_EOK;

}

MSH_CMD_EXPORT(lm75a, show current temperature);

#endif /* BSP_USING_I2C_LM75A */