yemai/CherryUSB
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(platform): update platform support

Browse Source
This commit is contained in:
sakumisu
2024-05-23 23:14:53 +08:00
parent 3336919e0d
commit 865d2f5d96
25 changed files with 1431 additions and 365 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
third_party/fatfs-0.14/source/port/fatfs_usbh.c vendored
View File

@@ -1,62 +0,0 @@
#include "ff.h"
#include "diskio.h"
#include "usbh_core.h"
#include "usbh_msc.h"
struct usbh_msc *active_msc_class;
int USB_disk_status(void)
{
return 0;
}
int USB_disk_initialize(void)
{
active_msc_class = (struct usbh_msc *)usbh_find_class_instance("/dev/sda");
if (active_msc_class == NULL) {
printf("do not find /dev/sda\r\n");
return RES_NOTRDY;
}
return RES_OK;
}
int USB_disk_read(BYTE *buff, LBA_t sector, UINT count)
{
return usbh_msc_scsi_read10(active_msc_class, sector, buff, count);
}
int USB_disk_write(const BYTE *buff, LBA_t sector, UINT count)
{
return usbh_msc_scsi_write10(active_msc_class, sector, buff, count);
}
int USB_disk_ioctl(BYTE cmd, void *buff)
{
int result = 0;
switch (cmd) {
case CTRL_SYNC:
result = RES_OK;
break;
case GET_SECTOR_SIZE:
*(WORD *)buff = active_msc_class->blocksize;
result = RES_OK;
break;
case GET_BLOCK_SIZE:
*(DWORD *)buff = 1;
result = RES_OK;
break;
case GET_SECTOR_COUNT:
*(DWORD *)buff = active_msc_class->blocknum;
result = RES_OK;
break;
default:
result = RES_PARERR;
break;
}
return result;
}

241
third_party/rt-thread-5.0/dfs_usbh_msc.c vendored
View File

@@ -1,241 +0,0 @@
/*
* Copyright (c) 2024, sakumisu
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "usbh_core.h"
#include "usbh_msc.h"
#include "rtthread.h"
#include <dfs_fs.h>
#define DEV_FORMAT "/sd%c"
#ifndef CONFIG_USB_DFS_MOUNT_POINT
#define CONFIG_USB_DFS_MOUNT_POINT "/"
#endif
#if defined(SOC_SERIES_STM32H7) || defined(SOC_SERIES_STM32F7) || \
defined(SOC_HPM5000) || defined(SOC_HPM6000) || defined(BSP_USING_BL61X)
#ifndef RT_USING_CACHE
#error usbh msc must enable RT_USING_CACHE in this chip
#endif
#if RT_ALIGN_SIZE != 32 && RT_ALIGN_SIZE != 64
#error usbh msc must set cache line to 32 or 64
#endif
#endif
#if defined(BSP_USING_BL61X)
#include "bflb_l1c.h"
void rt_hw_cpu_dcache_ops(int ops, void *addr, int size)
{
if (ops == RT_HW_CACHE_FLUSH) {
bflb_l1c_dcache_clean_range(addr, size);
} else {
bflb_l1c_dcache_invalidate_range(addr, size);
}
}
#elif defined(SOC_HPM5000) || defined(SOC_HPM6000)
#include "hpm_l1c_drv.h"
void rt_hw_cpu_dcache_ops(int ops, void *addr, int size)
{
if (ops == RT_HW_CACHE_FLUSH) {
l1c_dc_flush((uint32_t)addr, size);
} else {
l1c_dc_invalidate((uint32_t)addr, size);
}
}
#endif
USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t msc_sector[512];
static rt_err_t rt_udisk_init(rt_device_t dev)
{
return RT_EOK;
}
static ssize_t rt_udisk_read(rt_device_t dev, rt_off_t pos, void *buffer,
rt_size_t size)
{
struct usbh_msc *msc_class = (struct usbh_msc *)dev->user_data;
int ret;
#ifdef RT_USING_CACHE
rt_uint32_t *align_buf;
if ((uint32_t)buffer & (RT_ALIGN_SIZE - 1)) {
align_buf = rt_malloc_align(size * msc_class->blocksize, RT_ALIGN_SIZE);
if (!align_buf) {
rt_kprintf("msc get align buf failed\n");
return 0;
}
} else {
align_buf = (rt_uint32_t *)buffer;
}
ret = usbh_msc_scsi_read10(msc_class, pos, (uint8_t *)align_buf, size);
if (ret < 0) {
rt_kprintf("usb mass_storage read failed\n");
return 0;
}
rt_hw_cpu_dcache_ops(RT_HW_CACHE_INVALIDATE, align_buf, size * msc_class->blocksize);
if ((uint32_t)buffer & (RT_ALIGN_SIZE - 1)) {
rt_memcpy(buffer, align_buf, size * msc_class->blocksize);
rt_free_align(align_buf);
}
#else
ret = usbh_msc_scsi_read10(msc_class, pos, buffer, size);
if (ret < 0) {
rt_kprintf("usb mass_storage read failed\n");
return 0;
}
#endif
return size;
}
static ssize_t rt_udisk_write(rt_device_t dev, rt_off_t pos, const void *buffer,
rt_size_t size)
{
struct usbh_msc *msc_class = (struct usbh_msc *)dev->user_data;
int ret;
#ifdef RT_USING_CACHE
rt_uint32_t *align_buf;
if ((uint32_t)buffer & (RT_ALIGN_SIZE - 1)) {
align_buf = rt_malloc_align(size * msc_class->blocksize, RT_ALIGN_SIZE);
if (!align_buf) {
rt_kprintf("msc get align buf failed\n");
return 0;
}
rt_memcpy(align_buf, buffer, size * msc_class->blocksize);
} else {
align_buf = (rt_uint32_t *)buffer;
}
rt_hw_cpu_dcache_ops(RT_HW_CACHE_FLUSH, align_buf, size * msc_class->blocksize);
ret = usbh_msc_scsi_write10(msc_class, pos, (uint8_t *)align_buf, size);
if (ret < 0) {
rt_kprintf("usb mass_storage write failed\n");
return 0;
}
if ((uint32_t)buffer & (RT_ALIGN_SIZE - 1)) {
rt_free_align(align_buf);
}
#else
ret = usbh_msc_scsi_write10(msc_class, pos, buffer, size);
if (ret < 0) {
rt_kprintf("usb mass_storage write failed\n");
return 0;
}
#endif
return size;
}
static rt_err_t rt_udisk_control(rt_device_t dev, int cmd, void *args)
{
/* check parameter */
RT_ASSERT(dev != RT_NULL);
struct usbh_msc *msc_class = (struct usbh_msc *)dev->user_data;
if (cmd == RT_DEVICE_CTRL_BLK_GETGEOME) {
struct rt_device_blk_geometry *geometry;
geometry = (struct rt_device_blk_geometry *)args;
if (geometry == RT_NULL)
return -RT_ERROR;
geometry->bytes_per_sector = msc_class->blocksize;
geometry->block_size = msc_class->blocksize;
geometry->sector_count = msc_class->blocknum;
}
return RT_EOK;
}
#ifdef RT_USING_DEVICE_OPS
const static struct rt_device_ops udisk_device_ops = {
rt_udisk_init,
RT_NULL,
RT_NULL,
rt_udisk_read,
rt_udisk_write,
rt_udisk_control
};
#endif
int udisk_init(struct usbh_msc *msc_class)
{
rt_err_t ret = 0;
rt_uint8_t i;
struct dfs_partition part0;
struct rt_device *dev;
char name[CONFIG_USBHOST_DEV_NAMELEN];
char mount_point[CONFIG_USBHOST_DEV_NAMELEN];
dev = rt_malloc(sizeof(struct rt_device));
memset(dev, 0, sizeof(struct rt_device));
snprintf(name, CONFIG_USBHOST_DEV_NAMELEN, DEV_FORMAT, msc_class->sdchar);
snprintf(mount_point, CONFIG_USBHOST_DEV_NAMELEN, CONFIG_USB_DFS_MOUNT_POINT, msc_class->sdchar);
ret = usbh_msc_scsi_read10(msc_class, 0, msc_sector, 1);
if (ret != RT_EOK) {
rt_kprintf("usb mass_storage read failed\n");
return ret;
}
for (i = 0; i < 16; i++) {
/* Get the first partition */
ret = dfs_filesystem_get_partition(&part0, msc_sector, i);
if (ret == RT_EOK) {
rt_kprintf("Found partition %d: type = %d, offet=0x%x, size=0x%x\n",
i, part0.type, part0.offset, part0.size);
} else {
break;
}
}
dev->type = RT_Device_Class_Block;
#ifdef RT_USING_DEVICE_OPS
dev->ops = &udisk_device_ops;
#else
dev->init = rt_udisk_init;
dev->read = rt_udisk_read;
dev->write = rt_udisk_write;
dev->control = rt_udisk_control;
#endif
dev->user_data = msc_class;
rt_device_register(dev, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
ret = dfs_mount(name, mount_point, "elm", 0, 0);
if (ret == 0) {
rt_kprintf("udisk: %s mount successfully\n", name);
} else {
rt_kprintf("udisk: %s mount failed, ret = %d\n", name, ret);
}
return ret;
}
void usbh_msc_run(struct usbh_msc *msc_class)
{
udisk_init(msc_class);
}
void usbh_msc_stop(struct usbh_msc *msc_class)
{
char name[CONFIG_USBHOST_DEV_NAMELEN];
char mount_point[CONFIG_USBHOST_DEV_NAMELEN];
snprintf(name, CONFIG_USBHOST_DEV_NAMELEN, DEV_FORMAT, msc_class->sdchar);
snprintf(mount_point, CONFIG_USBHOST_DEV_NAMELEN, CONFIG_USB_DFS_MOUNT_POINT, msc_class->sdchar);
dfs_unmount(mount_point);
rt_device_unregister(rt_device_find(name));
}

43
third_party/rt-thread-5.0/usb_check.c vendored
View File

@@ -1,43 +0,0 @@
#include "rtthread.h"
#ifdef PKG_CHERRYUSB_HOST
#ifndef RT_USING_TIMER_SOFT
#error must enable RT_USING_TIMER_SOFT to support timer callback in thread
#endif
#if IDLE_THREAD_STACK_SIZE < 2048
#error "IDLE_THREAD_STACK_SIZE must be greater than 2048"
#endif
#if RT_TIMER_THREAD_STACK_SIZE < 2048
#error "RT_TIMER_THREAD_STACK_SIZE must be greater than 2048"
#endif
#ifdef RT_USING_LWIP
#include "lwip/opt.h"
#ifndef RT_USING_LWIP212
#error must enable RT_USING_LWIP212
#endif
#ifndef LWIP_NO_RX_THREAD
#error must enable LWIP_NO_RX_THREAD, we do not use rtthread eth rx thread
#endif
#if LWIP_TCPIP_CORE_LOCKING_INPUT !=1
#warning suggest you to set LWIP_TCPIP_CORE_LOCKING_INPUT to 1, usb handles eth input with own thread
#endif
#if LWIP_TCPIP_CORE_LOCKING !=1
#error must set LWIP_TCPIP_CORE_LOCKING to 1
#endif
#if PBUF_POOL_BUFSIZE < 1514
#error PBUF_POOL_BUFSIZE must be larger than 1514
#endif
#endif
#endif

47
third_party/rt-thread-5.0/usb_msh.c vendored
View File

@@ -1,47 +0,0 @@
/*
* Copyright (c) 2024, sakumisu
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "rtthread.h"
#ifdef PKG_CHERRYUSB_HOST
#include "usbh_core.h"
int usbh_init(int argc, char **argv)
{
uint8_t busid;
uint32_t reg_base;
if (argc < 3) {
USB_LOG_ERR("please input correct command: usbh_init <busid> <reg_base>\r\n");
return -1;
}
busid = atoi(argv[1]);
reg_base = strtoll(argv[2], NULL, 16);
usbh_initialize(busid, reg_base);
return 0;
}
int usbh_deinit(int argc, char **argv)
{
uint8_t busid;
if (argc < 2) {
USB_LOG_ERR("please input correct command: usbh_deinit <busid>\r\n");
return -1;
}
busid = atoi(argv[1]);
usbh_deinitialize(busid);
return 0;
}
MSH_CMD_EXPORT(usbh_init, init usb host);
MSH_CMD_EXPORT(usbh_deinit, deinit usb host);
MSH_CMD_EXPORT(lsusb, ls usb devices);
#endif