libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

[bsp/allwinner] feat: porting to RT_USING_DEVICE_OPS (#9142) 

* [bsp/allwinner] feat: porting to RT_USING_DEVICE_OPS

This patch ports the codebase to use the RT_USING_DEVICE_OPS structure,
which is required by v5.1.0 Smart kernel, improves modularity and makes
it easier to manage device operations by consolidating them into a
single structure, enhancing maintainability and future scalability.

Changes:
- Added RT_USING_DEVICE_OPS conditionals to partition.c and drv_sdmmc.c.
- Defined rt_device_ops structures for partition and sdmmc drivers.
- Updated device initialization to use the ops structure if defined.
- Replaced direct function calls with rt_dev_control, rt_dev_read, and
  rt_dev_write macros where applicable.
- Removed redundant us_delay function from os.c.

Signed-off-by: Shell <smokewood@qq.com>

* feat: update configuration

* feat: fixup compiler warning

---------

Signed-off-by: Shell <smokewood@qq.com>
This commit is contained in:
Shell 2024-07-09 13:35:03 +08:00 committed by GitHub
parent 3f6960b7f5
commit b73396681a
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 434 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

511
bsp/allwinner/d1s/.config
View File

File diff suppressed because it is too large Load Diff

8
bsp/allwinner/d1s/applications/mnt.c
View File

@ -24,7 +24,7 @@
#define SD_CHECK_PIN GET_PIN(GPIO_PORT_G, GPIO_PIN_3)
int sd_check_thread_entry(void *p)
void sd_check_thread_entry(void *p)
{
rt_uint8_t old_sd_check = 0;
@ -38,7 +38,7 @@ int sd_check_thread_entry(void *p)
else
{
rt_kprintf("Mount \"sd0p0\" on \"/\" fail\n");
return -1;
return ;
}
/* 挂载sd1分区 */
@ -105,7 +105,7 @@ int sd_check_thread_entry(void *p)
rt_thread_delay(RT_TICK_PER_SECOND);
}
}
return 0;
return ;
}
int mnt_init(void)
@ -116,7 +116,7 @@ int mnt_init(void)
rt_pin_mode(SD_CHECK_PIN, PIN_MODE_INPUT_PULLUP);
thread = rt_thread_create("sd", sd_check_thread_entry, NULL, 4096, 21, 10);
thread = rt_thread_create("sd", sd_check_thread_entry, NULL, RT_SYSTEM_WORKQUEUE_STACKSIZE, 21, 10);
if (thread == NULL)
{
return -1;

16
bsp/allwinner/d1s/ports/partition/partition.c
View File

@ -115,6 +115,18 @@ static rt_ssize_t partition_write(rt_device_t dev,
return 0;
}
#ifdef RT_USING_DEVICE_OPS
const static struct rt_device_ops _partition_ops =
{
.init = partition_init,
.open = partition_open,
.close = partition_close,
.read = partition_read,
.write = partition_write,
.control = partition_control,
};
#endif /* RT_USING_DEVICE_OPS */
int rt_partition_init(const char* flash_device, const struct rt_partition* parts, rt_size_t num)
{
struct rt_device *device;
@ -148,12 +160,16 @@ int rt_partition_init(const char* flash_device, const struct rt_partition* parts
/* register device */
part_dev->parent.type = RT_Device_Class_Block;
#ifndef RT_USING_DEVICE_OPS
part_dev->parent.init = partition_init;
part_dev->parent.open = partition_open;
part_dev->parent.close = partition_close;
part_dev->parent.read = partition_read;
part_dev->parent.write = partition_write;
part_dev->parent.control = partition_control;
#else
part_dev->parent.ops = &_partition_ops;
#endif /* RT_USING_DEVICE_OPS */
/* no private */
part_dev->parent.user_data = RT_NULL;

154
bsp/allwinner/d1s/rtconfig.h
View File

@ -1,9 +1,6 @@
#ifndef RT_CONFIG_H__
#define RT_CONFIG_H__
/* Automatically generated file; DO NOT EDIT. */
/* RT-Thread Project Configuration */
/* RT-Thread Kernel */
#define RT_NAME_MAX 20
@ -21,12 +18,18 @@
#define RT_USING_TIMER_SOFT
#define RT_TIMER_THREAD_PRIO 4
#define RT_TIMER_THREAD_STACK_SIZE 16384
#define RT_USING_CPU_USAGE_TRACER
/* kservice optimization */
#define RT_KSERVICE_USING_STDLIB
#define RT_KPRINTF_USING_LONGLONG
/* end of kservice optimization */
/* klibc optimization */
#define RT_KLIBC_USING_PRINTF_LONGLONG
/* end of klibc optimization */
#define RT_USING_DEBUG
#define RT_DEBUGING_ASSERT
#define RT_DEBUGING_COLOR
#define RT_DEBUGING_CONTEXT
@ -37,22 +40,28 @@
#define RT_USING_EVENT
#define RT_USING_MAILBOX
#define RT_USING_MESSAGEQUEUE
/* end of Inter-Thread communication */
/* Memory Management */
#define RT_PAGE_MAX_ORDER 11
#define RT_USING_MEMPOOL
#define RT_USING_SMALL_MEM
#define RT_USING_SMALL_MEM_AS_HEAP
#define RT_USING_MEMHEAP
#define RT_MEMHEAP_FAST_MODE
#define RT_USING_MEMHEAP_AS_HEAP
#define RT_USING_MEMHEAP_AUTO_BINDING
#define RT_USING_MEMTRACE
#define RT_USING_HEAP
/* end of Memory Management */
#define RT_USING_DEVICE
#define RT_USING_DEVICE_OPS
#define RT_USING_SCHED_THREAD_CTX
#define RT_USING_CONSOLE
#define RT_CONSOLEBUF_SIZE 256
#define RT_CONSOLE_DEVICE_NAME "uart0"
#define RT_VER_NUM 0x50100
#define RT_VER_NUM 0x50200
#define RT_USING_STDC_ATOMIC
#define RT_BACKTRACE_LEVEL_MAX_NR 32
/* end of RT-Thread Kernel */
#define ARCH_CPU_64BIT
#define RT_USING_CACHE
#define ARCH_MM_MMU
@ -103,7 +112,10 @@
#define RT_DFS_ELM_MAX_SECTOR_SIZE 512
#define RT_DFS_ELM_REENTRANT
#define RT_DFS_ELM_MUTEX_TIMEOUT 3000
/* end of elm-chan's FatFs, Generic FAT Filesystem Module */
#define RT_USING_DFS_DEVFS
#define RT_USING_DFS_PTYFS
#define RT_USING_DFS_TMPFS
#define RT_USING_PAGECACHE
/* page cache config */
@ -114,6 +126,8 @@
#define RT_PAGECACHE_HASH_NR 1024
#define RT_PAGECACHE_GC_WORK_LEVEL 90
#define RT_PAGECACHE_GC_STOP_LEVEL 70
/* end of page cache config */
/* end of DFS: device virtual file system */
#define RT_USING_FAL
#define FAL_DEBUG_CONFIG
#define FAL_DEBUG 1
@ -121,25 +135,22 @@
/* Device Drivers */
#define RT_USING_DEV_BUS
#define RT_USING_DEVICE_IPC
#define RT_UNAMED_PIPE_NUMBER 64
#define RT_USING_SYSTEM_WORKQUEUE
#define RT_SYSTEM_WORKQUEUE_STACKSIZE 4096
#define RT_SYSTEM_WORKQUEUE_STACKSIZE 16384
#define RT_SYSTEM_WORKQUEUE_PRIORITY 23
#define RT_USING_SERIAL
#define RT_USING_SERIAL_V2
#define RT_USING_TTY
#define RT_USING_NULL
#define RT_USING_ZERO
#define RT_USING_RANDOM
#define RT_USING_RTC
#define RT_USING_WDT
#define RT_USING_DEV_BUS
#define RT_USING_PIN
#define RT_USING_KTIME
/* Using USB */
/* end of Device Drivers */
/* C/C++ and POSIX layer */
@ -151,6 +162,8 @@
#define RT_LIBC_TZ_DEFAULT_HOUR 8
#define RT_LIBC_TZ_DEFAULT_MIN 0
#define RT_LIBC_TZ_DEFAULT_SEC 0
/* end of Timezone and Daylight Saving Time */
/* end of ISO-ANSI C layer */
/* POSIX (Portable Operating System Interface) layer */
@ -171,12 +184,17 @@
/* Socket is in the 'Network' category */
/* end of Interprocess Communication (IPC) */
/* end of POSIX (Portable Operating System Interface) layer */
/* end of C/C++ and POSIX layer */
/* Network */
/* end of Network */
/* Memory protection */
/* end of Memory protection */
/* Utilities */
@ -186,6 +204,7 @@
#define RT_USING_ADT_BITMAP
#define RT_USING_ADT_HASHMAP
#define RT_USING_ADT_REF
/* end of Utilities */
#define RT_USING_LWP
#define RT_LWP_MAX_NR 30
#define LWP_TASK_STACK_SIZE 16384
@ -194,12 +213,21 @@
#define LWP_TID_MAX_NR 64
#define RT_LWP_SHM_MAX_NR 64
#define RT_USING_LDSO
#define LWP_USING_TERMINAL
#define LWP_PTY_MAX_PARIS_LIMIT 64
/* Memory management */
/* end of Memory management */
/* Using USB legacy version */
/* end of Using USB legacy version */
/* end of RT-Thread Components */
/* RT-Thread Utestcases */
/* end of RT-Thread Utestcases */
/* RT-Thread online packages */
@ -210,124 +238,153 @@
/* Marvell WiFi */
/* end of Marvell WiFi */
/* Wiced WiFi */
/* CYW43012 WiFi */
/* BL808 WiFi */
/* CYW43439 WiFi */
/* end of Wiced WiFi */
/* end of Wi-Fi */
/* IoT Cloud */
/* end of IoT Cloud */
/* end of IoT - internet of things */
/* security packages */
/* end of security packages */
/* language packages */
/* JSON: JavaScript Object Notation, a lightweight data-interchange format */
/* end of JSON: JavaScript Object Notation, a lightweight data-interchange format */
/* XML: Extensible Markup Language */
/* end of XML: Extensible Markup Language */
/* end of language packages */
/* multimedia packages */
/* LVGL: powerful and easy-to-use embedded GUI library */
/* end of LVGL: powerful and easy-to-use embedded GUI library */
/* u8g2: a monochrome graphic library */
/* end of u8g2: a monochrome graphic library */
/* PainterEngine: A cross-platform graphics application framework written in C language */
/* end of PainterEngine: A cross-platform graphics application framework written in C language */
/* end of multimedia packages */
/* tools packages */
/* end of tools packages */
/* system packages */
/* enhanced kernel services */
/* end of enhanced kernel services */
/* acceleration: Assembly language or algorithmic acceleration packages */
/* end of acceleration: Assembly language or algorithmic acceleration packages */
/* CMSIS: ARM Cortex-M Microcontroller Software Interface Standard */
/* end of CMSIS: ARM Cortex-M Microcontroller Software Interface Standard */
/* Micrium: Micrium software products porting for RT-Thread */
/* end of Micrium: Micrium software products porting for RT-Thread */
/* end of system packages */
/* peripheral libraries and drivers */
/* HAL & SDK Drivers */
/* STM32 HAL & SDK Drivers */
/* Kendryte SDK */
/* sensors drivers */
/* touch drivers */
/* end of Kendryte SDK */
/* end of peripheral libraries and drivers */
/* AI packages */
/* Signal Processing and Control Algorithm Packages */
/* end of AI packages */
/* miscellaneous packages */
/* project laboratory */
/* end of project laboratory */
/* samples: kernel and components samples */
/* end of samples: kernel and components samples */
/* entertainment: terminal games and other interesting software packages */
/* end of entertainment: terminal games and other interesting software packages */
/* end of miscellaneous packages */
/* Arduino libraries */
/* Projects and Demos */
/* Projects */
/* end of Projects */
/* Sensors */
/* end of Sensors */
/* Display */
/* end of Display */
/* Timing */
/* end of Timing */
/* Data Processing */
/* end of Data Processing */
/* Data Storage */
/* Communication */
/* end of Communication */
/* Device Control */
/* end of Device Control */
/* Other */
/* Signal IO */
/* end of Signal IO */
/* Uncategorized */
/* end of Arduino libraries */
/* end of RT-Thread online packages */
/* Privated Packages of RealThread */
/* Network Utilities */
/* end of Network Utilities */
/* RT-Thread Smart */
/* end of RT-Thread Smart */
/* end of Privated Packages of RealThread */
#define BOARD_allwinnerd1s
#define __STACKSIZE__ 16384
@ -340,29 +397,36 @@
#define BSP_USING_UART0
#define UART0_TX_USING_GPIOE2
#define UART0_RX_USING_GPIOE3
/* end of General Purpose UARTs */
#define BSP_USING_SDMMC
#define SD_CARD_CHECK
#define BSP_USING_FS
/* Board extended module Drivers */
/* end of Board extended module Drivers */
/* end of General Drivers Configuration */
#define RT_USING_SUNXI_HAL
/* UART Devices */
/* end of UART Devices */
/* CCMU Devices */
#define DRIVERS_CCMU
#define DRIVERS_SUNXI_CCU
/* end of CCMU Devices */
/* DMA Devices */
#define DRIVERS_DMA
/* end of DMA Devices */
/* GPIO Devices */
#define DRIVERS_GPIO
/* end of GPIO Devices */
/* Video support for sunxi */
@ -375,18 +439,24 @@
#define LCD_SUPPORT_WILLIAMLCD
#define LCD_SUPPORT_LQ101R1SX03
#define LCD_SUPPORT_INET_DSI_PANEL
/* end of LCD panels select */
/* Display engine feature select */
#define DISP2_SUNXI_SUPPORT_ENAHNCE
/* end of Display engine feature select */
/* Soc and board select */
/* Board Select */
/* end of Board Select */
/* Soc Select */
/* end of Soc Select */
/* end of Soc and board select */
/* end of Video support for sunxi */
/* SDMMC Devices */
@ -398,25 +468,31 @@
#define SDIO_IRQ_SUPPORT
#define SDC_DMA_BUF_SIZE 64
#define DRIVERS_SDC_CDPIN_PRESENT_VAL 0
/* end of SDMMC Devices */
/* SPI Devices */
#define DRIVERS_SPI
/* end of SPI Devices */
/* TWI Devices */
#define DRIVERS_TWI
/* end of TWI Devices */
/* G2D Devices */
#define DRIVERS_G2D
/* end of G2D Devices */
/* CE Devices */
#define DRIVERS_CE
/* end of CE Devices */
/* EFUSE Devices */
#define DRIVERS_EFUSE
/* end of EFUSE Devices */
#endif

30
bsp/allwinner/libraries/drivers/sdmmc/drv_sdmmc.c
View File

@ -8,6 +8,9 @@
* 2021-10-29 JasonHu first version
*/
#define DBG_TAG "drv-sdmmc"
#include <rtdbg.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
@ -36,10 +39,6 @@
#include <sys/statfs.h> /* statfs() */
#include "partition.h"
#define DBG_LEVEL DBG_LOG
#define DBG_SECTION_NAME "drv-sdmmc"
#include <rtdbg.h>
#ifdef CONFIG_SUPPORT_SDMMC_CACHE
#include "sdmmc_cache.h"
#endif
@ -73,7 +72,7 @@ static int _register_blk_part_device(rt_device_t dev, const char *dev_name)
/* NOTICE: get block geometry fisrt time here, then you can read/write sdmmc. */
struct dev_sdmmc *dev_sdmmc = (struct dev_sdmmc *)dev->user_data;
if (dev->control(dev, RT_DEVICE_CTRL_BLK_GETGEOME, &dev_sdmmc->geometry) != RT_EOK)
if (rt_dev_control(dev, RT_DEVICE_CTRL_BLK_GETGEOME, &dev_sdmmc->geometry) != RT_EOK)
{
LOG_E("device get geometry failed!");
return -RT_EIO;
@ -95,7 +94,7 @@ static int _register_blk_part_device(rt_device_t dev, const char *dev_name)
return -RT_ENOMEM;
}
if (dev->read(dev, 0, mbr_buf, 1) != 1)
if (rt_dev_read(dev, 0, mbr_buf, 1) != 1)
{
LOG_E("device read mbr 1-sector failure\n");
ret = -RT_ERROR;
@ -429,6 +428,18 @@ static rt_err_t sdmmc_control(rt_device_t dev, int cmd, void *args)
return ret;
}
#ifdef RT_USING_DEVICE_OPS
const static struct rt_device_ops _sdmmc_ops =
{
.init = sdmmc_init,
.open = sdmmc_open,
.close = sdmmc_close,
.read = sdmmc_read,
.write = sdmmc_write,
.control = sdmmc_control
};
#endif /* RT_USING_DEVICE_OPS */
static int init_sdmmc_device(rt_device_t device, void *usr_data, char *dev_name)
{
int ret = -1;
@ -438,12 +449,17 @@ static int init_sdmmc_device(rt_device_t device, void *usr_data, char *dev_name)
{
return ret;
}
#ifndef RT_USING_DEVICE_OPS
device->init = sdmmc_init;
device->open = sdmmc_open;
device->close = sdmmc_close;
device->read = sdmmc_read;
device->write = sdmmc_write;
device->control = sdmmc_control;
#else
device->ops = &_sdmmc_ops;
#endif /* RT_USING_DEVICE_OPS */
device->user_data = usr_data;
ret = rt_device_register(device, dev_name, RT_DEVICE_FLAG_RDWR);
@ -463,7 +479,7 @@ static int init_sdmmc_device(rt_device_t device, void *usr_data, char *dev_name)
/* NOTICE: get block geometry fisrt time here, then you can read/write sdmmc. */
struct dev_sdmmc *dev_sdmmc = (struct dev_sdmmc *)device->user_data;
if (device->control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &dev_sdmmc->geometry) != RT_EOK)
if (rt_dev_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &dev_sdmmc->geometry) != RT_EOK)
{
LOG_E("device get geometry failed!");
ret = -ENOSYS;

14
bsp/allwinner/libraries/drivers/sdmmc/drv_sdmmc.h
View File

@ -27,4 +27,18 @@ struct dev_sdmmc
void sd_mmc1_init(void);
void sd_mmc1_deinit(void);
#ifdef RT_USING_DEVICE_OPS
#define rt_dev_has_control(dev) (dev)->ops->control
#define rt_dev_control(dev, cmd, args) (dev)->ops->control(dev, cmd, args)
#define rt_dev_read(dev, pos, buffer, size) (dev)->ops->read(dev, pos, buffer, size)
#define rt_dev_write(dev, pos, buffer, size) (dev)->ops->write(dev, pos, buffer, size)
#else
#define rt_dev_has_control(dev) (dev)->control
#define rt_dev_control(dev, cmd, args) (dev)->control(dev, cmd, args)
#define rt_dev_read(dev, pos, buffer, size) (dev)->read(dev, pos, buffer, size)
#define rt_dev_write(dev, pos, buffer, size) (dev)->write(dev, pos, buffer, size)
#endif
#endif

12
bsp/allwinner/libraries/libos/src/os.c
View File

@ -66,18 +66,6 @@ rt_weak int msleep(unsigned int msecs)
return 0;
}
void rt_hw_us_delay(rt_uint32_t us)
{
uint64_t start, target;
uint64_t frequency;
frequency = arch_timer_get_cntfrq();
start = arch_counter_get_cntpct();
target = frequency / 1000000ULL * us;
while (arch_counter_get_cntpct() - start <= target) ;
}
rt_weak int usleep(unsigned int usecs)
{
int tickDiv = 1000 * (1000 / CONFIG_HZ);

35
bsp/allwinner/libraries/sunxi-hal/hal/source/sdmmc/blkpart.c
View File

@ -9,6 +9,9 @@
#include <blkpart.h>
#include <rtthread.h>
#include <rtdevice.h>
#include <drv_sdmmc.h>
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define ALIGN_DOWN(x, a) __ALIGN_KERNEL((x) - ((a) - 1), (a))
#define __ALIGN_KERNEL(x, a) __ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1)
@ -247,7 +250,7 @@ rt_size_t part_read(rt_device_t dev, rt_off_t offset, void *data, rt_size_t size
offset, blk->blk_bytes);
pr_debug("step1: read page data from addr 0x%x\n", addr);
ret = spinor_dev->read(spinor_dev, addr / blk->page_bytes, page_buf, blk->page_bytes / blk->page_bytes);
ret = rt_dev_read(spinor_dev, addr / blk->page_bytes, page_buf, blk->page_bytes / blk->page_bytes);
ret *= blk->page_bytes;
if (ret != blk->blk_bytes)
{
@ -272,7 +275,7 @@ rt_size_t part_read(rt_device_t dev, rt_off_t offset, void *data, rt_size_t size
{
uint32_t len = (size/blk->page_bytes)*blk->page_bytes;
ret = spinor_dev->read(spinor_dev, offset / blk->blk_bytes, (char *)data, len / blk->blk_bytes);
ret = rt_dev_read(spinor_dev, offset / blk->blk_bytes, (char *)data, len / blk->blk_bytes);
ret *= blk->page_bytes;
if (ret != len)
{
@ -294,7 +297,7 @@ rt_size_t part_read(rt_device_t dev, rt_off_t offset, void *data, rt_size_t size
pr_debug("last size %u not align %u, read them\n", size, blk->blk_bytes);
pr_debug("step1: read page data from addr 0x%x\n", offset);
ret = spinor_dev->read(spinor_dev, offset / blk->blk_bytes, page_buf, blk->page_bytes / blk->page_bytes);
ret = rt_dev_read(spinor_dev, offset / blk->blk_bytes, page_buf, blk->page_bytes / blk->page_bytes);
ret *= blk->page_bytes;
if (ret != blk->page_bytes)
{
@ -325,7 +328,7 @@ out:
int do_write_without_erase(rt_device_t dev, struct blkpart *blk, uint32_t addr, uint32_t size, char *buf)
{
return dev->write(dev, addr, buf, size);
return rt_dev_write(dev, addr, buf, size);
}
static int do_erase_write_blk(rt_device_t dev, struct blkpart *blk, uint32_t addr, uint32_t size, char *buf)
{
@ -355,7 +358,7 @@ static int do_erase_write_blk(rt_device_t dev, struct blkpart *blk, uint32_t add
memset(&erase_sector, 0, sizeof(blk_dev_erase_t));
erase_sector.addr = align_addr;
erase_sector.len = blk->blk_bytes;
ret = dev->control(dev, BLOCK_DEVICE_CMD_ERASE_SECTOR, &erase_sector);
ret = rt_dev_control(dev, BLOCK_DEVICE_CMD_ERASE_SECTOR, &erase_sector);
if (ret)
{
free(read_buf);
@ -365,7 +368,7 @@ static int do_erase_write_blk(rt_device_t dev, struct blkpart *blk, uint32_t add
memcpy(read_buf + (addr - align_addr), buf, blk->page_bytes);
ret = dev->write(dev, align_addr, read_buf, blk->blk_bytes);
ret = rt_dev_write(dev, align_addr, read_buf, blk->blk_bytes);
free(read_buf);
if (ret == blk->blk_bytes)
{
@ -382,13 +385,13 @@ static int do_erase_write_blk(rt_device_t dev, struct blkpart *blk, uint32_t add
memset(&erase_sector, 0, sizeof(blk_dev_erase_t));
erase_sector.addr = addr;
erase_sector.len = size;
ret = dev->control(dev, BLOCK_DEVICE_CMD_ERASE_SECTOR, &erase_sector);
ret = rt_dev_control(dev, BLOCK_DEVICE_CMD_ERASE_SECTOR, &erase_sector);
if (ret)
{
return -EIO;
}
ret = dev->write(dev, addr, buf, size);
ret = rt_dev_write(dev, addr, buf, size);
if (ret == size)
{
return size;
@ -466,7 +469,7 @@ rt_size_t _part_write(rt_device_t dev, rt_off_t offset, const void *data, rt_siz
pr_debug("offset %u not align %u, fix them before align write\n",
offset, blk->blk_bytes);
pr_debug("step1: read page data from addr 0x%x\n", addr);
ret = spinor_dev->read(spinor_dev, addr / blk->blk_bytes, blk_buf, blk->blk_bytes / blk->blk_bytes);
ret = rt_dev_read(spinor_dev, addr / blk->blk_bytes, blk_buf, blk->blk_bytes / blk->blk_bytes);
ret *= blk->blk_bytes;
if (ret != blk->blk_bytes)
{
@ -513,7 +516,7 @@ rt_size_t _part_write(rt_device_t dev, rt_off_t offset, const void *data, rt_siz
pr_debug("step1: read page data from addr 0x%x\n", offset);
memset(blk_buf, 0x00, sizeof(blk->blk_bytes));
ret = spinor_dev->read(spinor_dev, offset / blk->blk_bytes, blk_buf, blk->blk_bytes);
ret = rt_dev_read(spinor_dev, offset / blk->blk_bytes, blk_buf, blk->blk_bytes);
if (ret != blk->blk_bytes)
{
goto err;
@ -582,15 +585,15 @@ rt_err_t part_control(rt_device_t dev, int cmd, void *args)
erase_sector->len = MIN(part->bytes - erase_sector->addr, erase_sector->len);
erase_sector->addr = erase_sector->addr + part->off;
if (spinor_dev && spinor_dev->control)
if (spinor_dev && rt_dev_has_control(spinor_dev))
{
ret = spinor_dev->control(spinor_dev, BLOCK_DEVICE_CMD_ERASE_SECTOR, erase_sector);
ret = rt_dev_control(spinor_dev, BLOCK_DEVICE_CMD_ERASE_SECTOR, erase_sector);
}
break;
case DEVICE_PART_CMD_GET_BLOCK_SIZE:
if (spinor_dev && spinor_dev->control)
if (spinor_dev && rt_dev_has_control(spinor_dev))
{
ret = spinor_dev->control(spinor_dev, BLOCK_DEVICE_CMD_GET_BLOCK_SIZE, args);
ret = rt_dev_control(spinor_dev, BLOCK_DEVICE_CMD_GET_BLOCK_SIZE, args);
}
else
{
@ -604,9 +607,9 @@ rt_err_t part_control(rt_device_t dev, int cmd, void *args)
case RT_DEVICE_CTRL_BLK_GETGEOME:
geometry = (struct rt_device_blk_geometry *)args;
memset(geometry, 0, sizeof(struct rt_device_blk_geometry));
if (spinor_dev && spinor_dev->control)
if (spinor_dev && rt_dev_has_control(spinor_dev))
{
ret = spinor_dev->control(spinor_dev, RT_DEVICE_CTRL_BLK_GETGEOME, args);
ret = rt_dev_control(spinor_dev, RT_DEVICE_CTRL_BLK_GETGEOME, args);
if (!ret)
{
geometry->sector_count = part->bytes / geometry->bytes_per_sector;