summaryrefslogtreecommitdiff
path: root/components
diff options
context:
space:
mode:
authorCYFS <[email protected]>2026-09-07 11:18:41 +0800
committerGitHub <[email protected]>2026-09-07 11:18:41 +0800
commit280bcfeec362f2164140606860b22026e5031c3d (patch)
tree70567c4bf1a10a35ad660982b2da832ad9d7e53a /components
parent163d178e29dfc72a30ed837267a8249f2a5771a1 (diff)
[device][mmcsd] Fix Arm Compiler 5 build compatibility #11690
Diffstat (limited to 'components')
-rw-r--r--components/drivers/block/blk.c96
-rw-r--r--components/drivers/block/blk_dfs.c27
-rw-r--r--components/drivers/block/partitions/efi.c69
-rw-r--r--components/drivers/include/drivers/blk.h23
-rw-r--r--components/drivers/include/drivers/mmcsd_card.h238
-rw-r--r--components/drivers/include/drivers/mmcsd_cmd.h130
-rw-r--r--components/drivers/sdio/dev_block.c78
-rw-r--r--components/drivers/sdio/dev_mmc.c75
-rw-r--r--components/drivers/sdio/dev_mmcsd_core.c304
-rw-r--r--components/drivers/sdio/dev_sd.c222
10 files changed, 865 insertions, 397 deletions
diff --git a/components/drivers/block/blk.c b/components/drivers/block/blk.c
index 313f50cdeb..5f0d6b1f82 100644
--- a/components/drivers/block/blk.c
+++ b/components/drivers/block/blk.c
@@ -15,13 +15,19 @@
#include "blk_dev.h"
#include "blk_dfs.h"
+#ifdef RT_USING_DFS
+#include <dfs_fs.h>
+#endif
+
static void blk_remove_all(struct rt_blk_disk *disk)
{
- struct rt_blk_device *blk, *blk_next;
+ rt_list_t *node, *next;
+ struct rt_blk_device *blk;
/* Remove all partitions */
- rt_list_for_each_entry_safe(blk, blk_next, &disk->part_nodes, list)
+ rt_list_for_each_safe(node, next, &disk->part_nodes)
{
+ blk = rt_list_entry(node, struct rt_blk_device, list);
disk_remove_blk_dev(blk, RT_TRUE);
}
}
@@ -44,7 +50,7 @@ static rt_err_t blk_close(rt_device_t dev)
}
static rt_ssize_t blk_read(rt_device_t dev, rt_off_t sector,
- void *buffer, rt_size_t sector_count)
+ void *buffer, rt_size_t sector_count)
{
rt_ssize_t res;
struct rt_blk_disk *disk = to_blk_disk(dev);
@@ -59,7 +65,7 @@ static rt_ssize_t blk_read(rt_device_t dev, rt_off_t sector,
}
static rt_ssize_t blk_write(rt_device_t dev, rt_off_t sector,
- const void *buffer, rt_size_t sector_count)
+ const void *buffer, rt_size_t sector_count)
{
rt_ssize_t res;
struct rt_blk_disk *disk = to_blk_disk(dev);
@@ -79,7 +85,7 @@ static rt_ssize_t blk_write(rt_device_t dev, rt_off_t sector,
}
static rt_ssize_t blk_parallel_read(rt_device_t dev, rt_off_t sector,
- void *buffer, rt_size_t sector_count)
+ void *buffer, rt_size_t sector_count)
{
struct rt_blk_disk *disk = to_blk_disk(dev);
@@ -87,7 +93,7 @@ static rt_ssize_t blk_parallel_read(rt_device_t dev, rt_off_t sector,
}
static rt_ssize_t blk_parallel_write(rt_device_t dev, rt_off_t sector,
- const void *buffer, rt_size_t sector_count)
+ const void *buffer, rt_size_t sector_count)
{
struct rt_blk_disk *disk = to_blk_disk(dev);
@@ -206,8 +212,7 @@ static rt_err_t blk_control(rt_device_t dev, int cmd, void *args)
}
#ifdef RT_USING_DEVICE_OPS
-const static struct rt_device_ops blk_ops =
-{
+const static struct rt_device_ops blk_ops = {
.open = blk_open,
.close = blk_close,
.read = blk_read,
@@ -215,8 +220,7 @@ const static struct rt_device_ops blk_ops =
.control = blk_control,
};
-const static struct rt_device_ops blk_parallel_ops =
-{
+const static struct rt_device_ops blk_parallel_ops = {
.open = blk_open,
.close = blk_close,
.read = blk_parallel_read,
@@ -269,9 +273,9 @@ rt_err_t rt_hw_blk_disk_register(struct rt_blk_disk *disk)
if (err)
{
- #ifdef RT_USING_DM
+#ifdef RT_USING_DM
rt_dm_ida_free(disk->ida, device_id);
- #endif
+#endif
LOG_E("%s: Init user mutex error = %s", rt_strerror(err));
@@ -427,6 +431,7 @@ rt_ssize_t rt_blk_disk_get_logical_block_size(struct rt_blk_disk *disk)
static int blk_dfs_mnt_table(void)
{
rt_ubase_t level;
+ rt_list_t *node, *part_node;
struct rt_object *obj;
struct rt_device *dev;
struct rt_blk_disk *disk;
@@ -435,8 +440,9 @@ static int blk_dfs_mnt_table(void)
level = rt_hw_interrupt_disable();
- rt_list_for_each_entry(obj, &info->object_list, list)
+ rt_list_for_each(node, &info->object_list)
{
+ obj = rt_list_entry(node, struct rt_object, list);
dev = rt_container_of(obj, struct rt_device, parent);
if (dev->type != RT_Device_Class_Block)
@@ -457,8 +463,9 @@ static int blk_dfs_mnt_table(void)
continue;
}
- rt_list_for_each_entry(blk_dev, &disk->part_nodes, list)
+ rt_list_for_each(part_node, &disk->part_nodes)
{
+ blk_dev = rt_list_entry(part_node, struct rt_blk_device, list);
dfs_mount_device(&blk_dev->parent);
}
}
@@ -471,8 +478,19 @@ INIT_ENV_EXPORT(blk_dfs_mnt_table);
#endif /* RT_USING_DFS_MNTTABLE */
#if defined(RT_USING_CONSOLE) && defined(RT_USING_MSH)
+static const char *blk_get_mounted_path(struct rt_device *device)
+{
+#ifdef RT_USING_DFS
+ return dfs_filesystem_get_mounted_path(device);
+#else
+ RT_UNUSED(device);
+
+ return RT_NULL;
+#endif
+}
+
const char *convert_size(struct rt_device_blk_geometry *geome,
- rt_size_t sector_count, rt_size_t *out_cap, rt_size_t *out_minor)
+ rt_size_t sector_count, rt_size_t *out_cap, rt_size_t *out_minor)
{
rt_size_t cap, minor = 0;
int size_index = 0;
@@ -498,10 +516,11 @@ const char *convert_size(struct rt_device_blk_geometry *geome,
return size_name[size_index];
}
-static int list_blk(int argc, char**argv)
+static int list_blk(int argc, char **argv)
{
rt_ubase_t level;
rt_size_t cap, minor;
+ rt_list_t *node, *part_node;
const char *size_name;
struct rt_object *obj;
struct rt_device *dev;
@@ -514,8 +533,9 @@ static int list_blk(int argc, char**argv)
rt_kprintf("%-*.s MAJ:MIN RM SIZE\tRO TYPE MOUNTPOINT\n", RT_NAME_MAX, "NAME");
- rt_list_for_each_entry(obj, &info->object_list, list)
+ rt_list_for_each(node, &info->object_list)
{
+ obj = rt_list_entry(node, struct rt_object, list);
dev = rt_container_of(obj, struct rt_device, parent);
if (dev->type != RT_Device_Class_Block)
@@ -538,33 +558,33 @@ static int list_blk(int argc, char**argv)
size_name = convert_size(&geome, geome.sector_count, &cap, &minor);
const char *mnt_path;
- mnt_path = dfs_filesystem_get_mounted_path(&disk->parent);
+ mnt_path = blk_get_mounted_path(&disk->parent);
rt_kprintf("%-*.s %3u.%-3u %u %u.%u%s\t%u disk %s\n",
- RT_NAME_MAX, to_disk_name(disk),
- #ifdef RT_USING_DM
- disk->parent.master_id, disk->parent.device_id,
- #else
- 0, 0,
- #endif
- disk->removable, cap, minor, size_name, disk->read_only,
- disk->max_partitions != RT_BLK_PARTITION_NONE ? "\b" :
- (mnt_path ? mnt_path : "\b"));
+ RT_NAME_MAX, to_disk_name(disk),
+#ifdef RT_USING_DM
+ disk->parent.master_id, disk->parent.device_id,
+#else
+ 0, 0,
+#endif
+ disk->removable, cap, minor, size_name, disk->read_only,
+ disk->max_partitions != RT_BLK_PARTITION_NONE ? "\b" : (mnt_path ? mnt_path : "\b"));
- rt_list_for_each_entry(blk_dev, &disk->part_nodes, list)
+ rt_list_for_each(part_node, &disk->part_nodes)
{
+ blk_dev = rt_list_entry(part_node, struct rt_blk_device, list);
size_name = convert_size(&geome, blk_dev->sector_count, &cap, &minor);
- mnt_path = dfs_filesystem_get_mounted_path(&blk_dev->parent);
+ mnt_path = blk_get_mounted_path(&blk_dev->parent);
rt_kprintf("%c--%-*.s %3u.%-3u %u %u.%u%s\t%u part %s\n",
- blk_dev->list.next != &disk->part_nodes ? '|' : '`',
- RT_NAME_MAX - 3, to_blk_name(blk_dev),
- #ifdef RT_USING_DM
- blk_dev->parent.master_id, blk_dev->parent.device_id,
- #else
- 0, 0,
- #endif
- disk->removable, cap, minor, size_name, disk->read_only,
- mnt_path ? mnt_path : "");
+ blk_dev->list.next != &disk->part_nodes ? '|' : '`',
+ RT_NAME_MAX - 3, to_blk_name(blk_dev),
+#ifdef RT_USING_DM
+ blk_dev->parent.master_id, blk_dev->parent.device_id,
+#else
+ 0, 0,
+#endif
+ disk->removable, cap, minor, size_name, disk->read_only,
+ mnt_path ? mnt_path : "");
}
}
diff --git a/components/drivers/block/blk_dfs.c b/components/drivers/block/blk_dfs.c
index 1b5797b0a3..ce637b687c 100644
--- a/components/drivers/block/blk_dfs.c
+++ b/components/drivers/block/blk_dfs.c
@@ -8,12 +8,15 @@
* 2023-08-08 GuEe-GUI first version
*/
+#include <rtthread.h>
+
#include "blk_dfs.h"
-#include <dfs_file.h>
#include <drivers/classes/block.h>
#if defined(RT_USING_POSIX_DEVIO) && defined(RT_USING_DFS_V2)
+#include <dfs_file.h>
+
struct blk_fops_data
{
struct rt_device_blk_geometry geometry;
@@ -55,7 +58,8 @@ static int blk_fops_ioctl(struct dfs_file *file, int cmd, void *arg)
static ssize_t blk_fops_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
{
- void *rbuf;
+ rt_uint8_t *rbuf;
+ rt_uint8_t *read_buf = buf;
rt_ssize_t res = 0;
int bytes_per_sector, blk_pos, first_offs, rsize = 0;
struct rt_device *dev = file->vnode->data;
@@ -82,7 +86,7 @@ static ssize_t blk_fops_read(struct dfs_file *file, void *buf, size_t count, off
{
rsize = count;
}
- rt_memcpy(buf, rbuf + first_offs, rsize);
+ rt_memcpy(read_buf, rbuf + first_offs, rsize);
++blk_pos;
/*
@@ -99,12 +103,12 @@ static ssize_t blk_fops_read(struct dfs_file *file, void *buf, size_t count, off
if (count - rsize >= bytes_per_sector)
{
- rt_memcpy(buf + rsize, rbuf, bytes_per_sector);
+ rt_memcpy(read_buf + rsize, rbuf, bytes_per_sector);
rsize += bytes_per_sector;
}
else
{
- rt_memcpy(buf + rsize, rbuf, count - rsize);
+ rt_memcpy(read_buf + rsize, rbuf, count - rsize);
rsize = count;
}
}
@@ -120,7 +124,8 @@ static ssize_t blk_fops_read(struct dfs_file *file, void *buf, size_t count, off
static ssize_t blk_fops_write(struct dfs_file *file, const void *buf, size_t count, off_t *pos)
{
- void *rbuf;
+ rt_uint8_t *rbuf;
+ const rt_uint8_t *write_buf = buf;
rt_ssize_t res = 0;
int bytes_per_sector, blk_pos, first_offs, wsize = 0;
struct rt_device *dev = file->vnode->data;
@@ -150,7 +155,7 @@ static ssize_t blk_fops_write(struct dfs_file *file, const void *buf, size_t cou
if (res == 1)
{
- rt_memcpy(rbuf + first_offs, buf, wsize);
+ rt_memcpy(rbuf + first_offs, write_buf, wsize);
res = rt_device_write(dev, blk_pos, (const void *)rbuf, 1);
if (res == 1)
@@ -174,7 +179,8 @@ _goon:
*/
if ((count - wsize) / bytes_per_sector != 0)
{
- res = rt_device_write(dev, blk_pos, buf + wsize, (count - wsize) / bytes_per_sector);
+ res = rt_device_write(dev, blk_pos, write_buf + wsize,
+ (count - wsize) / bytes_per_sector);
if (res != (count - wsize) / bytes_per_sector)
{
@@ -198,7 +204,7 @@ _goon:
if (res == 1)
{
- rt_memcpy(rbuf, buf + wsize, count - wsize);
+ rt_memcpy(rbuf, write_buf + wsize, count - wsize);
res = rt_device_write(dev, blk_pos, (const void *)rbuf, 1);
if (res == 1)
@@ -229,8 +235,7 @@ static int blk_fops_poll(struct dfs_file *file, struct rt_pollreq *req)
return mask;
}
-const static struct dfs_file_ops blk_fops =
-{
+const static struct dfs_file_ops blk_fops = {
.open = blk_fops_open,
.close = blk_fops_close,
.ioctl = blk_fops_ioctl,
diff --git a/components/drivers/block/partitions/efi.c b/components/drivers/block/partitions/efi.c
index 58c68cc98b..522d5f6076 100644
--- a/components/drivers/block/partitions/efi.c
+++ b/components/drivers/block/partitions/efi.c
@@ -93,8 +93,11 @@ rt_inline int pmbr_part_valid(gpt_mbr_record *part)
*/
static int is_pmbr_valid(legacy_mbr *mbr, rt_size_t total_sectors)
{
- rt_uint32_t sz = 0;
- int part = 0, ret = 0; /* invalid by default */
+ rt_uint32_t sz = 0;
+ rt_uint32_t disk_size;
+ int part = 0, ret = 0; /* invalid by default */
+
+ disk_size = total_sectors - 1 > RT_UINT32_MAX ? RT_UINT32_MAX : (rt_uint32_t)(total_sectors - 1);
if (!mbr || rt_le16_to_cpu(mbr->signature) != MSDOS_MBR_SIGNATURE)
{
@@ -148,10 +151,10 @@ _check_hybrid:
{
sz = rt_le32_to_cpu(mbr->partition_record[part].size_in_lba);
- if (sz != (rt_uint32_t)total_sectors - 1 && sz != 0xffffffff)
+ if (sz != disk_size && sz != RT_UINT32_MAX)
{
LOG_W("GPT: mbr size in lba (%u) different than whole disk (%u)",
- sz, rt_min_t(rt_uint32_t, total_sectors - 1, 0xffffffff));
+ sz, disk_size);
}
}
@@ -172,9 +175,9 @@ static rt_size_t read_lba(struct rt_blk_disk *disk,
rt_uint64_t lba, rt_uint8_t *buffer, rt_size_t count)
{
rt_uint32_t lbs;
- rt_ssize_t cap_ss, lbs_ss;
- rt_size_t totalreadcount = 0;
- rt_uint8_t *secbuf = RT_NULL;
+ rt_ssize_t cap_ss, lbs_ss;
+ rt_size_t totalreadcount = 0;
+ rt_uint8_t *secbuf = RT_NULL;
rt_uint64_t capacity, disk_bytes, n512;
if (!buffer || count == 0)
@@ -189,7 +192,7 @@ static rt_size_t read_lba(struct rt_blk_disk *disk,
return 0;
}
- lbs = (rt_uint32_t)lbs_ss;
+ lbs = (rt_uint32_t)lbs_ss;
capacity = (rt_uint64_t)cap_ss;
if (lbs < 512 || (lbs % 512) != 0)
@@ -203,7 +206,7 @@ static rt_size_t read_lba(struct rt_blk_disk *disk,
}
disk_bytes = capacity * (rt_uint64_t)lbs;
- n512 = lba * ((rt_uint64_t)lbs / 512);
+ n512 = lba * ((rt_uint64_t)lbs / 512);
secbuf = rt_malloc(lbs);
if (!secbuf)
@@ -213,8 +216,8 @@ static rt_size_t read_lba(struct rt_blk_disk *disk,
while (count > 0)
{
- int copied = 512;
- rt_ssize_t rd;
+ int copied = 512;
+ rt_ssize_t rd;
rt_uint32_t off;
rt_uint64_t log_sec, byte_off = n512 * 512;
@@ -234,7 +237,7 @@ static rt_size_t read_lba(struct rt_blk_disk *disk,
}
log_sec = byte_off / lbs;
- off = (rt_uint32_t)(byte_off % lbs);
+ off = (rt_uint32_t)(byte_off % lbs);
if (off + (rt_uint32_t)copied <= lbs)
{
@@ -264,9 +267,9 @@ static rt_size_t read_lba(struct rt_blk_disk *disk,
rt_memcpy(buffer + first, secbuf, copied - first);
}
- buffer += copied;
+ buffer += copied;
totalreadcount += copied;
- count -= copied;
+ count -= copied;
++n512;
}
@@ -282,10 +285,10 @@ static rt_size_t read_lba(struct rt_blk_disk *disk,
* @return ptes on success, null on error.
*/
static gpt_entry *alloc_read_gpt_entries(struct rt_blk_disk *disk,
- gpt_header *gpt)
+ gpt_header *gpt)
{
- rt_size_t count;
- gpt_entry *pte;
+ rt_size_t count;
+ gpt_entry *pte;
rt_uint64_t entry_lba;
if (!gpt)
@@ -333,7 +336,7 @@ static gpt_header *alloc_read_gpt_header(struct rt_blk_disk *disk, rt_uint64_t l
{
gpt_header *gpt;
rt_uint32_t ssz;
- rt_ssize_t lbs_ss = rt_blk_disk_get_logical_block_size(disk);
+ rt_ssize_t lbs_ss = rt_blk_disk_get_logical_block_size(disk);
if (lbs_ss <= 0)
{
@@ -375,7 +378,7 @@ static rt_bool_t is_gpt_valid(struct rt_blk_disk *disk,
{
rt_uint32_t crc, origcrc;
rt_uint64_t lastlba, pt_size;
- rt_ssize_t logical_block_size;
+ rt_ssize_t logical_block_size;
if (!ptes)
{
@@ -427,9 +430,9 @@ static rt_bool_t is_gpt_valid(struct rt_blk_disk *disk,
}
/* Check the GUID Partition Table CRC */
- origcrc = rt_le32_to_cpu((*gpt)->header_crc32);
+ origcrc = rt_le32_to_cpu((*gpt)->header_crc32);
(*gpt)->header_crc32 = 0;
- crc = efi_crc32((const rt_uint8_t *)(*gpt), rt_le32_to_cpu((*gpt)->header_size));
+ crc = efi_crc32((const rt_uint8_t *)(*gpt), rt_le32_to_cpu((*gpt)->header_size));
if (crc != origcrc)
{
@@ -695,13 +698,13 @@ static void compare_gpts(struct rt_blk_disk *disk,
static rt_bool_t find_valid_gpt(struct rt_blk_disk *disk,
gpt_header **gpt, gpt_entry **ptes)
{
- int good_pgpt = 0, good_agpt = 0, good_pmbr = 0;
+ int good_pgpt = 0, good_agpt = 0, good_pmbr = 0;
gpt_header *pgpt = RT_NULL, *agpt = RT_NULL;
- gpt_entry *pptes = RT_NULL, *aptes = RT_NULL;
+ gpt_entry *pptes = RT_NULL, *aptes = RT_NULL;
legacy_mbr *legacymbr;
- rt_ssize_t cap_ss = rt_blk_disk_get_capacity(disk);
- rt_size_t total_sectors;
- rt_size_t lastlba;
+ rt_ssize_t cap_ss = rt_blk_disk_get_capacity(disk);
+ rt_size_t total_sectors;
+ rt_size_t lastlba;
if (!ptes)
{
@@ -766,7 +769,7 @@ static rt_bool_t find_valid_gpt(struct rt_blk_disk *disk,
/* The good cases */
if (good_pgpt)
{
- *gpt = pgpt;
+ *gpt = pgpt;
*ptes = pptes;
rt_free(agpt);
rt_free(aptes);
@@ -780,7 +783,7 @@ static rt_bool_t find_valid_gpt(struct rt_blk_disk *disk,
}
else if (good_agpt)
{
- *gpt = agpt;
+ *gpt = agpt;
*ptes = aptes;
rt_free(pgpt);
rt_free(pptes);
@@ -796,7 +799,7 @@ _fail:
rt_free(pptes);
rt_free(aptes);
- *gpt = RT_NULL;
+ *gpt = RT_NULL;
*ptes = RT_NULL;
return RT_FALSE;
@@ -805,8 +808,8 @@ _fail:
rt_err_t efi_partition(struct rt_blk_disk *disk)
{
rt_uint32_t entries_nr;
- gpt_header *gpt = RT_NULL;
- gpt_entry *ptes = RT_NULL;
+ gpt_header *gpt = RT_NULL;
+ gpt_entry *ptes = RT_NULL;
if (!find_valid_gpt(disk, &gpt, &ptes) || !gpt || !ptes)
{
@@ -821,8 +824,8 @@ rt_err_t efi_partition(struct rt_blk_disk *disk)
for (int i = 0; i < entries_nr && i < disk->max_partitions; ++i)
{
rt_uint64_t start = rt_le64_to_cpu(ptes[i].starting_lba);
- rt_uint64_t size = rt_le64_to_cpu(ptes[i].ending_lba) -
- rt_le64_to_cpu(ptes[i].starting_lba) + 1ULL;
+ rt_uint64_t size = rt_le64_to_cpu(ptes[i].ending_lba) -
+ rt_le64_to_cpu(ptes[i].starting_lba) + 1ULL;
if (!is_pte_valid(&ptes[i], last_lba(disk)))
{
diff --git a/components/drivers/include/drivers/blk.h b/components/drivers/include/drivers/blk.h
index 95c1932456..cec39e33b8 100644
--- a/components/drivers/include/drivers/blk.h
+++ b/components/drivers/include/drivers/blk.h
@@ -40,9 +40,9 @@ struct rt_blk_disk
struct rt_dm_ida *ida;
#endif
- rt_uint32_t read_only:1;
- rt_uint32_t parallel_io:1;
- rt_uint32_t removable:1;
+ rt_uint32_t read_only : 1;
+ rt_uint32_t parallel_io : 1;
+ rt_uint32_t removable : 1;
#define RT_BLK_DISK_MAGIC 0xbdaabdaa
rt_uint32_t __magic;
@@ -62,9 +62,9 @@ struct rt_blk_disk
struct rt_blk_disk_ops
{
rt_ssize_t (*read)(struct rt_blk_disk *disk, rt_off_t sector, void *buffer,
- rt_size_t sector_count);
+ rt_size_t sector_count);
rt_ssize_t (*write)(struct rt_blk_disk *disk, rt_off_t sector, const void *buffer,
- rt_size_t sector_count);
+ rt_size_t sector_count);
rt_err_t (*getgeome)(struct rt_blk_disk *disk, struct rt_device_blk_geometry *geometry);
rt_err_t (*sync)(struct rt_blk_disk *disk);
rt_err_t (*erase)(struct rt_blk_disk *disk);
@@ -73,7 +73,18 @@ struct rt_blk_disk_ops
};
#ifndef __DFS_H__
+#ifdef RT_USING_DFS
#include <dfs_fs.h>
+#else
+/* Keep the legacy name available when the block layer is used without DFS. */
+struct dfs_partition
+{
+ rt_uint8_t type;
+ rt_off_t offset;
+ rt_size_t size;
+ rt_sem_t lock;
+};
+#endif /* RT_USING_DFS */
/**
* @brief Logical blk device, if you don't used DFS it will be defined by default.
@@ -132,4 +143,4 @@ rt_ssize_t rt_blk_disk_get_logical_block_size(struct rt_blk_disk *disk);
/*! @}*/
-#endif /* __BLK_H__ */ \ No newline at end of file
+#endif /* __BLK_H__ */
diff --git a/components/drivers/include/drivers/mmcsd_card.h b/components/drivers/include/drivers/mmcsd_card.h
index 6d86760a78..feab5a5724 100644
--- a/components/drivers/include/drivers/mmcsd_card.h
+++ b/components/drivers/include/drivers/mmcsd_card.h
@@ -19,128 +19,144 @@
extern "C" {
#endif
-#define SD_SCR_BUS_WIDTH_1 (1 << 0)
-#define SD_SCR_BUS_WIDTH_4 (1 << 2)
+#define SD_SCR_BUS_WIDTH_1 (1 << 0)
+#define SD_SCR_BUS_WIDTH_4 (1 << 2)
-struct rt_mmcsd_cid {
- rt_uint8_t mid; /* ManufacturerID */
- rt_uint8_t prv; /* Product Revision */
+struct rt_mmcsd_cid
+{
+ rt_uint8_t mid; /* ManufacturerID */
+ rt_uint8_t prv; /* Product Revision */
rt_uint16_t oid; /* OEM/Application ID */
rt_uint32_t psn; /* Product Serial Number */
- rt_uint8_t pnm[5]; /* Product Name */
- rt_uint8_t reserved1;/* reserved */
+ rt_uint8_t pnm[5]; /* Product Name */
+ rt_uint8_t reserved1;/* reserved */
rt_uint16_t mdt; /* Manufacturing Date */
- rt_uint8_t crc; /* CID CRC */
- rt_uint8_t reserved2;/* not used, always 1 */
+ rt_uint8_t crc; /* CID CRC */
+ rt_uint8_t reserved2;/* not used, always 1 */
};
-struct rt_mmcsd_csd {
- rt_uint8_t csd_structure; /* CSD register version */
- rt_uint8_t taac;
- rt_uint8_t nsac;
- rt_uint8_t tran_speed; /* max data transfer rate */
- rt_uint16_t card_cmd_class; /* card command classes */
- rt_uint8_t rd_blk_len; /* max read data block length */
- rt_uint8_t rd_blk_part;
- rt_uint8_t wr_blk_misalign;
- rt_uint8_t rd_blk_misalign;
- rt_uint8_t dsr_imp; /* DSR implemented */
- rt_uint8_t c_size_mult; /* CSD 1.0 , device size multiplier */
- rt_uint32_t c_size; /* device size */
- rt_uint8_t r2w_factor;
- rt_uint8_t wr_blk_len; /* max wtire data block length */
- rt_uint8_t wr_blk_partial;
- rt_uint8_t csd_crc;
-
+struct rt_mmcsd_csd
+{
+ rt_uint8_t csd_structure; /* CSD register version */
+ rt_uint8_t taac;
+ rt_uint8_t nsac;
+ rt_uint8_t tran_speed; /* max data transfer rate */
+ rt_uint16_t card_cmd_class; /* card command classes */
+ rt_uint8_t rd_blk_len; /* max read data block length */
+ rt_uint8_t rd_blk_part;
+ rt_uint8_t wr_blk_misalign;
+ rt_uint8_t rd_blk_misalign;
+ rt_uint8_t dsr_imp; /* DSR implemented */
+ rt_uint8_t c_size_mult; /* CSD 1.0 , device size multiplier */
+ rt_uint32_t c_size; /* device size */
+ rt_uint8_t r2w_factor;
+ rt_uint8_t wr_blk_len; /* max wtire data block length */
+ rt_uint8_t wr_blk_partial;
+ rt_uint8_t csd_crc;
};
-struct rt_sd_scr {
- rt_uint8_t sd_version;
- rt_uint8_t sd_bus_widths;
+struct rt_sd_scr
+{
+ rt_uint8_t sd_version;
+ rt_uint8_t sd_bus_widths;
};
-struct rt_sdio_cccr {
- rt_uint8_t sdio_version;
- rt_uint8_t sd_version;
- rt_uint8_t direct_cmd:1, /* Card Supports Direct Commands during data transfer
+struct rt_sdio_cccr
+{
+ rt_uint8_t sdio_version;
+ rt_uint8_t sd_version;
+ rt_uint8_t direct_cmd : 1, /* Card Supports Direct Commands during data transfer
only SD mode, not used for SPI mode */
- multi_block:1, /* Card Supports Multi-Block */
- read_wait:1, /* Card Supports Read Wait
+ multi_block : 1, /* Card Supports Multi-Block */
+ read_wait : 1, /* Card Supports Read Wait
only SD mode, not used for SPI mode */
- suspend_resume:1, /* Card supports Suspend/Resume
+ suspend_resume : 1, /* Card supports Suspend/Resume
only SD mode, not used for SPI mode */
- s4mi:1, /* generate interrupts during a 4-bit
+ s4mi : 1, /* generate interrupts during a 4-bit
multi-block data transfer */
- e4mi:1, /* Enable the multi-block IRQ during
+ e4mi : 1, /* Enable the multi-block IRQ during
4-bit transfer for the SDIO card */
- low_speed:1, /* Card is a Low-Speed card */
- low_speed_4:1; /* 4-bit support for Low-Speed cards */
+ low_speed : 1, /* Card is a Low-Speed card */
+ low_speed_4 : 1; /* 4-bit support for Low-Speed cards */
- rt_uint8_t bus_width:1, /* Support SDIO bus width, 1:4bit, 0:1bit */
- cd_disable:1, /* Connect[0]/Disconnect[1] the 10K-90K ohm pull-up
+ rt_uint8_t bus_width : 1, /* Support SDIO bus width, 1:4bit, 0:1bit */
+ cd_disable : 1, /* Connect[0]/Disconnect[1] the 10K-90K ohm pull-up
resistor on CD/DAT[3] (pin 1) of the card */
- power_ctrl:1, /* Support Master Power Control */
- high_speed:1; /* Support High-Speed */
-
-
+ power_ctrl : 1, /* Support Master Power Control */
+ high_speed : 1; /* Support High-Speed */
};
/*
* SD Status
*/
-union rt_sd_status {
+union rt_sd_status
+{
rt_uint32_t status_words[16];
- struct {
+ struct
+ {
rt_uint32_t reserved[12];
- rt_uint64_t : 8;
- rt_uint64_t uhs_au_size: 4;
- rt_uint64_t uhs_speed_grade: 4;
- rt_uint64_t erase_offset: 2;
- rt_uint64_t erase_timeout: 6;
- rt_uint64_t erase_size: 16;
- rt_uint64_t : 4;
- rt_uint64_t au_size: 4;
- rt_uint64_t performance_move: 8;
- rt_uint64_t speed_class: 8;
+ rt_uint64_t : 8;
+ rt_uint64_t uhs_au_size : 4;
+ rt_uint64_t uhs_speed_grade : 4;
+ rt_uint64_t erase_offset : 2;
+ rt_uint64_t erase_timeout : 6;
+ rt_uint64_t erase_size : 16;
+ rt_uint64_t : 4;
+ rt_uint64_t au_size : 4;
+ rt_uint64_t performance_move : 8;
+ rt_uint64_t speed_class : 8;
rt_uint32_t size_of_protected_area;
- rt_uint32_t sd_card_type: 16;
- rt_uint32_t : 6;
- rt_uint32_t : 7;
- rt_uint32_t secured_mode: 1;
- rt_uint32_t data_bus_width: 2;
+ rt_uint32_t sd_card_type : 16;
+ rt_uint32_t : 6;
+ rt_uint32_t : 7;
+ rt_uint32_t secured_mode : 1;
+ rt_uint32_t data_bus_width : 2;
+ /* Arm Compiler 5 does not support anonymous structs in strict C99 mode. */
+#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 6000000)
+ } fields;
+#else
};
+#endif
};
+#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 6000000)
+#define RT_SD_STATUS_FIELD(status, field) ((status).fields.field)
+#else
+#define RT_SD_STATUS_FIELD(status, field) ((status).field)
+#endif
+
/*
* SD Speed Class
*/
-#define SD_SPEED_CLASS_0 0
-#define SD_SPEED_CLASS_2 1
-#define SD_SPEED_CLASS_4 2
-#define SD_SPEED_CLASS_6 3
-#define SD_SPEED_CLASS_10 4
+#define SD_SPEED_CLASS_0 0
+#define SD_SPEED_CLASS_2 1
+#define SD_SPEED_CLASS_4 2
+#define SD_SPEED_CLASS_6 3
+#define SD_SPEED_CLASS_10 4
/*
* UHS Speed Grade
*/
-#define UHS_SPEED_GRADE_0 0
-#define UHS_SPEED_GRADE_1 1
-#define UHS_SPEED_GRADE_3 3
+#define UHS_SPEED_GRADE_0 0
+#define UHS_SPEED_GRADE_1 1
+#define UHS_SPEED_GRADE_3 3
-struct rt_sdio_cis {
- rt_uint16_t manufacturer;
- rt_uint16_t product;
- rt_uint16_t func0_blk_size;
- rt_uint32_t max_tran_speed;
+struct rt_sdio_cis
+{
+ rt_uint16_t manufacturer;
+ rt_uint16_t product;
+ rt_uint16_t func0_blk_size;
+ rt_uint32_t max_tran_speed;
};
/*
* SDIO function CIS tuple (unknown to the core)
*/
-struct rt_sdio_function_tuple {
+struct rt_sdio_function_tuple
+{
struct rt_sdio_function_tuple *next;
rt_uint8_t code;
rt_uint8_t size;
@@ -148,31 +164,32 @@ struct rt_sdio_function_tuple {
};
struct rt_sdio_function;
-typedef void (rt_sdio_irq_handler_t)(struct rt_sdio_function *);
+typedef void(rt_sdio_irq_handler_t)(struct rt_sdio_function *);
/*
* SDIO function devices
*/
-struct rt_sdio_function {
- struct rt_mmcsd_card *card; /* the card this device belongs to */
- rt_sdio_irq_handler_t *irq_handler; /* IRQ callback */
- rt_uint8_t num; /* function number */
+struct rt_sdio_function
+{
+ struct rt_mmcsd_card *card; /* the card this device belongs to */
+ rt_sdio_irq_handler_t *irq_handler; /* IRQ callback */
+ rt_uint8_t num; /* function number */
- rt_uint8_t func_code; /* Standard SDIO Function interface code */
- rt_uint16_t manufacturer; /* manufacturer id */
- rt_uint16_t product; /* product id */
+ rt_uint8_t func_code; /* Standard SDIO Function interface code */
+ rt_uint16_t manufacturer; /* manufacturer id */
+ rt_uint16_t product; /* product id */
- rt_uint32_t max_blk_size; /* maximum block size */
- rt_uint32_t cur_blk_size; /* current block size */
+ rt_uint32_t max_blk_size; /* maximum block size */
+ rt_uint32_t cur_blk_size; /* current block size */
- rt_uint32_t enable_timeout_val; /* max enable timeout in msec */
+ rt_uint32_t enable_timeout_val; /* max enable timeout in msec */
struct rt_sdio_function_tuple *tuples;
- void *priv;
+ void *priv;
};
-#define SDIO_MAX_FUNCTIONS 7
+#define SDIO_MAX_FUNCTIONS 7
struct rt_mmc_ext_csd
{
@@ -180,7 +197,8 @@ struct rt_mmc_ext_csd
rt_uint32_t enhanced_data_strobe;
};
-struct rt_mmcsd_card {
+struct rt_mmcsd_card
+{
struct rt_mmcsd_host *host;
rt_uint32_t rca; /* card addr */
rt_uint32_t resp_cid[4]; /* card CID register */
@@ -195,28 +213,28 @@ struct rt_mmcsd_card {
rt_uint32_t card_sec_cnt; /* card sector count*/
rt_uint32_t erase_size; /* erase size in sectors */
rt_uint16_t card_type;
-#define CARD_TYPE_MMC 0 /* MMC card */
-#define CARD_TYPE_SD 1 /* SD card */
-#define CARD_TYPE_SDIO 2 /* SDIO card */
-#define CARD_TYPE_SDIO_COMBO 3 /* SD combo (IO+mem) card */
+#define CARD_TYPE_MMC 0 /* MMC card */
+#define CARD_TYPE_SD 1 /* SD card */
+#define CARD_TYPE_SDIO 2 /* SDIO card */
+#define CARD_TYPE_SDIO_COMBO 3 /* SD combo (IO+mem) card */
rt_uint16_t flags;
-#define CARD_FLAG_HIGHSPEED (1 << 0) /* SDIO bus speed 50MHz */
-#define CARD_FLAG_SDHC (1 << 1) /* SDHC card */
-#define CARD_FLAG_SDXC (1 << 2) /* SDXC card */
-#define CARD_FLAG_HIGHSPEED_DDR (1 << 3) /* HIGH SPEED DDR */
-#define CARD_FLAG_HS200 (1 << 4) /* BUS SPEED 200MHz */
-#define CARD_FLAG_HS400 (1 << 5) /* BUS SPEED 400MHz */
-#define CARD_FLAG_SDR50 (1 << 6) /* BUS SPEED 100MHz */
-#define CARD_FLAG_SDR104 (1 << 7) /* BUS SPEED 200MHz */
-#define CARD_FLAG_DDR50 (1 << 8) /* DDR50, works on 1.8V only */
- struct rt_sd_scr scr;
+#define CARD_FLAG_HIGHSPEED (1 << 0) /* SDIO bus speed 50MHz */
+#define CARD_FLAG_SDHC (1 << 1) /* SDHC card */
+#define CARD_FLAG_SDXC (1 << 2) /* SDXC card */
+#define CARD_FLAG_HIGHSPEED_DDR (1 << 3) /* HIGH SPEED DDR */
+#define CARD_FLAG_HS200 (1 << 4) /* BUS SPEED 200MHz */
+#define CARD_FLAG_HS400 (1 << 5) /* BUS SPEED 400MHz */
+#define CARD_FLAG_SDR50 (1 << 6) /* BUS SPEED 100MHz */
+#define CARD_FLAG_SDR104 (1 << 7) /* BUS SPEED 200MHz */
+#define CARD_FLAG_DDR50 (1 << 8) /* DDR50, works on 1.8V only */
+ struct rt_sd_scr scr;
struct rt_mmcsd_csd csd;
- rt_uint32_t hs_max_data_rate; /* max data transfer rate in high speed mode */
+ rt_uint32_t hs_max_data_rate; /* max data transfer rate in high speed mode */
- rt_uint8_t sdio_function_num; /* total number of SDIO functions */
- struct rt_sdio_cccr cccr; /* common card info */
- struct rt_sdio_cis cis; /* common tuple info */
+ rt_uint8_t sdio_function_num; /* total number of SDIO functions */
+ struct rt_sdio_cccr cccr; /* common card info */
+ struct rt_sdio_cis cis; /* common tuple info */
struct rt_sdio_function *sdio_function[SDIO_MAX_FUNCTIONS + 1]; /* SDIO functions (devices) */
void *blk_dev;
diff --git a/components/drivers/include/drivers/mmcsd_cmd.h b/components/drivers/include/drivers/mmcsd_cmd.h
index 06212c5162..d8cd28db41 100644
--- a/components/drivers/include/drivers/mmcsd_cmd.h
+++ b/components/drivers/include/drivers/mmcsd_cmd.h
@@ -17,28 +17,28 @@ extern "C" {
#endif
/* class 1 */
-#define GO_IDLE_STATE 0 /* bc */
-#define SEND_OP_COND 1 /* bcr [31:0] OCR R3 */
-#define ALL_SEND_CID 2 /* bcr R2 */
-#define SET_RELATIVE_ADDR 3 /* ac [31:16] RCA R1 */
-#define SET_DSR 4 /* bc [31:16] RCA */
-#define SWITCH 6 /* ac [31:0] See below R1b */
-#define SELECT_CARD 7 /* ac [31:16] RCA R1 */
-#define SEND_EXT_CSD 8 /* adtc R1 */
-#define SEND_CSD 9 /* ac [31:16] RCA R2 */
-#define SEND_CID 10 /* ac [31:16] RCA R2 */
-#define VOLTAGE_SWITCH 11 /* ac [31:0] R1 */
-#define STOP_TRANSMISSION 12 /* ac R1b */
-#define SEND_STATUS 13 /* ac [31:16] RCA R1 */
-#define GO_INACTIVE_STATE 15 /* ac [31:16] RCA */
-#define SPI_READ_OCR 58 /* spi spi_R3 */
-#define SPI_CRC_ON_OFF 59 /* spi [0:0] flag spi_R1 */
+#define GO_IDLE_STATE 0 /* bc */
+#define SEND_OP_COND 1 /* bcr [31:0] OCR R3 */
+#define ALL_SEND_CID 2 /* bcr R2 */
+#define SET_RELATIVE_ADDR 3 /* ac [31:16] RCA R1 */
+#define SET_DSR 4 /* bc [31:16] RCA */
+#define MMC_SWITCH 6 /* ac [31:0] See below R1b */
+#define SELECT_CARD 7 /* ac [31:16] RCA R1 */
+#define SEND_EXT_CSD 8 /* adtc R1 */
+#define SEND_CSD 9 /* ac [31:16] RCA R2 */
+#define SEND_CID 10 /* ac [31:16] RCA R2 */
+#define VOLTAGE_SWITCH 11 /* ac [31:0] R1 */
+#define STOP_TRANSMISSION 12 /* ac R1b */
+#define SEND_STATUS 13 /* ac [31:16] RCA R1 */
+#define GO_INACTIVE_STATE 15 /* ac [31:16] RCA */
+#define SPI_READ_OCR 58 /* spi spi_R3 */
+#define SPI_CRC_ON_OFF 59 /* spi [0:0] flag spi_R1 */
/* class 2 */
-#define SET_BLOCKLEN 16 /* ac [31:0] block len R1 */
-#define READ_SINGLE_BLOCK 17 /* adtc [31:0] data addr R1 */
-#define READ_MULTIPLE_BLOCK 18 /* adtc [31:0] data addr R1 */
-#define SEND_TUNING_BLOCK 19 /* adtc R1 */
+#define SET_BLOCKLEN 16 /* ac [31:0] block len R1 */
+#define READ_SINGLE_BLOCK 17 /* adtc [31:0] data addr R1 */
+#define READ_MULTIPLE_BLOCK 18 /* adtc [31:0] data addr R1 */
+#define SEND_TUNING_BLOCK 19 /* adtc R1 */
#define SEND_TUNING_BLOCK_HS200 21 /* adtc R1*/
/* class 3 */
#define WRITE_DAT_UNTIL_STOP 20 /* adtc [31:0] data addr R1 */
@@ -51,77 +51,77 @@ extern "C" {
#define PROGRAM_CSD 27 /* adtc R1 */
/* class 6 */
-#define SET_WRITE_PROT 28 /* ac [31:0] data addr R1b */
-#define CLR_WRITE_PROT 29 /* ac [31:0] data addr R1b */
-#define SEND_WRITE_PROT 30 /* adtc [31:0] wpdata addr R1 */
+#define SET_WRITE_PROT 28 /* ac [31:0] data addr R1b */
+#define CLR_WRITE_PROT 29 /* ac [31:0] data addr R1b */
+#define SEND_WRITE_PROT 30 /* adtc [31:0] wpdata addr R1 */
/* class 5 */
-#define ERASE_GROUP_START 35 /* ac [31:0] data addr R1 */
-#define ERASE_GROUP_END 36 /* ac [31:0] data addr R1 */
-#define ERASE 38 /* ac R1b */
+#define ERASE_GROUP_START 35 /* ac [31:0] data addr R1 */
+#define ERASE_GROUP_END 36 /* ac [31:0] data addr R1 */
+#define ERASE 38 /* ac R1b */
/* class 9 */
-#define FAST_IO 39 /* ac <Complex> R4 */
-#define GO_IRQ_STATE 40 /* bcr R5 */
+#define FAST_IO 39 /* ac <Complex> R4 */
+#define GO_IRQ_STATE 40 /* bcr R5 */
/* class 7 */
-#define LOCK_UNLOCK 42 /* adtc R1b */
+#define LOCK_UNLOCK 42 /* adtc R1b */
/* class 8 */
-#define APP_CMD 55 /* ac [31:16] RCA R1 */
-#define GEN_CMD 56 /* adtc [0] RD/WR R1 */
+#define APP_CMD 55 /* ac [31:16] RCA R1 */
+#define GEN_CMD 56 /* adtc [0] RD/WR R1 */
/* SD commands type argument response */
/* class 0 */
/* This is basically the same command as for MMC with some quirks. */
-#define SD_SEND_RELATIVE_ADDR 3 /* bcr R6 */
-#define SD_SEND_IF_COND 8 /* bcr [11:0] See below R7 */
+#define SD_SEND_RELATIVE_ADDR 3 /* bcr R6 */
+#define SD_SEND_IF_COND 8 /* bcr [11:0] See below R7 */
/* class 10 */
-#define SD_SWITCH 6 /* adtc [31:0] See below R1 */
+#define SD_SWITCH 6 /* adtc [31:0] See below R1 */
/* Application commands */
-#define SD_APP_SET_BUS_WIDTH 6 /* ac [1:0] bus width R1 */
-#define SD_APP_SEND_NUM_WR_BLKS 22 /* adtc R1 */
-#define SD_APP_OP_COND 41 /* bcr [31:0] OCR R3 */
-#define SD_APP_SEND_SCR 51 /* adtc R1 */
+#define SD_APP_SET_BUS_WIDTH 6 /* ac [1:0] bus width R1 */
+#define SD_APP_SEND_NUM_WR_BLKS 22 /* adtc R1 */
+#define SD_APP_OP_COND 41 /* bcr [31:0] OCR R3 */
+#define SD_APP_SEND_SCR 51 /* adtc R1 */
-#define SCR_SPEC_VER_0 0 /* Implements system specification 1.0 - 1.01 */
-#define SCR_SPEC_VER_1 1 /* Implements system specification 1.10 */
-#define SCR_SPEC_VER_2 2 /* Implements system specification 2.00 */
+#define SCR_SPEC_VER_0 0 /* Implements system specification 1.0 - 1.01 */
+#define SCR_SPEC_VER_1 1 /* Implements system specification 1.10 */
+#define SCR_SPEC_VER_2 2 /* Implements system specification 2.00 */
/* SDIO commands type argument response */
-#define SD_IO_SEND_OP_COND 5 /* bcr [23:0] OCR R4 */
-#define SD_IO_RW_DIRECT 52 /* ac [31:0] See below R5 */
-#define SD_IO_RW_EXTENDED 53 /* adtc [31:0] See below R5 */
+#define SD_IO_SEND_OP_COND 5 /* bcr [23:0] OCR R4 */
+#define SD_IO_RW_DIRECT 52 /* ac [31:0] See below R5 */
+#define SD_IO_RW_EXTENDED 53 /* adtc [31:0] See below R5 */
/* CMD52 arguments */
-#define SDIO_ARG_CMD52_READ (0<<31)
-#define SDIO_ARG_CMD52_WRITE (1u<<31)
-#define SDIO_ARG_CMD52_FUNC_SHIFT 28
-#define SDIO_ARG_CMD52_FUNC_MASK 0x7
-#define SDIO_ARG_CMD52_RAW_FLAG (1u<<27)
-#define SDIO_ARG_CMD52_REG_SHIFT 9
-#define SDIO_ARG_CMD52_REG_MASK 0x1ffff
-#define SDIO_ARG_CMD52_DATA_SHIFT 0
-#define SDIO_ARG_CMD52_DATA_MASK 0xff
-#define SDIO_R5_DATA(resp) ((resp)[0] & 0xff)
+#define SDIO_ARG_CMD52_READ (0 << 31)
+#define SDIO_ARG_CMD52_WRITE (1u << 31)
+#define SDIO_ARG_CMD52_FUNC_SHIFT 28
+#define SDIO_ARG_CMD52_FUNC_MASK 0x7
+#define SDIO_ARG_CMD52_RAW_FLAG (1u << 27)
+#define SDIO_ARG_CMD52_REG_SHIFT 9
+#define SDIO_ARG_CMD52_REG_MASK 0x1ffff
+#define SDIO_ARG_CMD52_DATA_SHIFT 0
+#define SDIO_ARG_CMD52_DATA_MASK 0xff
+#define SDIO_R5_DATA(resp) ((resp)[0] & 0xff)
/* CMD53 arguments */
-#define SDIO_ARG_CMD53_READ (0<<31)
-#define SDIO_ARG_CMD53_WRITE (1u<<31)
-#define SDIO_ARG_CMD53_FUNC_SHIFT 28
-#define SDIO_ARG_CMD53_FUNC_MASK 0x7
-#define SDIO_ARG_CMD53_BLOCK_MODE (1u<<27)
-#define SDIO_ARG_CMD53_INCREMENT (1u<<26)
-#define SDIO_ARG_CMD53_REG_SHIFT 9
-#define SDIO_ARG_CMD53_REG_MASK 0x1ffff
-#define SDIO_ARG_CMD53_LENGTH_SHIFT 0
-#define SDIO_ARG_CMD53_LENGTH_MASK 0x1ff
-#define SDIO_ARG_CMD53_LENGTH_MAX 511
+#define SDIO_ARG_CMD53_READ (0 << 31)
+#define SDIO_ARG_CMD53_WRITE (1u << 31)
+#define SDIO_ARG_CMD53_FUNC_SHIFT 28
+#define SDIO_ARG_CMD53_FUNC_MASK 0x7
+#define SDIO_ARG_CMD53_BLOCK_MODE (1u << 27)
+#define SDIO_ARG_CMD53_INCREMENT (1u << 26)
+#define SDIO_ARG_CMD53_REG_SHIFT 9
+#define SDIO_ARG_CMD53_REG_MASK 0x1ffff
+#define SDIO_ARG_CMD53_LENGTH_SHIFT 0
+#define SDIO_ARG_CMD53_LENGTH_MASK 0x1ff
+#define SDIO_ARG_CMD53_LENGTH_MAX 511
#ifdef __cplusplus
diff --git a/components/drivers/sdio/dev_block.c b/components/drivers/sdio/dev_block.c
index d4f8f62885..f0437c10c2 100644
--- a/components/drivers/sdio/dev_block.c
+++ b/components/drivers/sdio/dev_block.c
@@ -14,11 +14,11 @@
#include <drivers/misc.h>
#include <drivers/dev_mmcsd_core.h>
-#define DBG_TAG "SDIO"
+#define DBG_TAG "SDIO"
#ifdef RT_SDIO_DEBUG
-#define DBG_LVL DBG_LOG
+#define DBG_LVL DBG_LOG
#else
-#define DBG_LVL DBG_INFO
+#define DBG_LVL DBG_INFO
#endif /* RT_SDIO_DEBUG */
#include <rtdbg.h>
@@ -26,6 +26,8 @@
#define RT_MMCSD_MAX_PARTITION 16
#endif
+#define MMCSD_SECTOR_SIZE 512U
+
struct mmcsd_blk_device
{
struct rt_blk_disk parent;
@@ -52,10 +54,14 @@ static int __send_status(struct rt_mmcsd_card *card, rt_uint32_t *status, unsign
cmd.flags = RESP_R1 | CMD_AC;
err = mmcsd_send_cmd(card->host, &cmd, retries);
if (err)
+ {
return err;
+ }
if (status)
+ {
*status = cmd.resp[0];
+ }
return 0;
}
@@ -82,7 +88,9 @@ static int card_busy_detect(struct rt_mmcsd_card *card, unsigned int timeout_ms,
/* Accumulate any response error bits seen */
if (resp_errs)
+ {
*resp_errs |= status;
+ }
if (out)
{
@@ -94,9 +102,8 @@ static int card_busy_detect(struct rt_mmcsd_card *card, unsigned int timeout_ms,
* so make sure to check both the busy
* indication and the card state.
*/
- }
- while (!(status & R1_READY_FOR_DATA) ||
- (R1_CURRENT_STATE(status) == 7));
+ } while (!(status & R1_READY_FOR_DATA) ||
+ (R1_CURRENT_STATE(status) == 7));
return err;
}
@@ -119,9 +126,13 @@ rt_int32_t mmcsd_num_wr_blocks(struct rt_mmcsd_card *card)
err = mmcsd_send_cmd(card->host, &cmd, 0);
if (err)
+ {
return -RT_ERROR;
+ }
if (!controller_is_spi(card->host) && !(cmd.resp[0] & R1_APP_CMD))
+ {
return -RT_ERROR;
+ }
rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
@@ -157,20 +168,22 @@ rt_int32_t mmcsd_num_wr_blocks(struct rt_mmcsd_card *card)
mmcsd_send_request(card->host, &req);
if (cmd.err || data.err)
+ {
return -RT_ERROR;
+ }
return blocks;
}
static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
- rt_uint32_t sector,
- void *buf,
- rt_size_t blks,
- rt_uint8_t dir)
+ rt_uint32_t sector,
+ void *buf,
+ rt_size_t blks,
+ rt_uint8_t dir)
{
- struct rt_mmcsd_cmd cmd, stop;
- struct rt_mmcsd_data data;
- struct rt_mmcsd_req req;
+ struct rt_mmcsd_cmd cmd, stop;
+ struct rt_mmcsd_data data;
+ struct rt_mmcsd_req req;
struct rt_mmcsd_host *host = card->host;
rt_uint32_t r_cmd, w_cmd;
@@ -189,8 +202,8 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
}
cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_ADTC;
- data.blksize = SECTOR_SIZE;
- data.blks = blks;
+ data.blksize = MMCSD_SECTOR_SIZE;
+ data.blks = blks;
if (blks > 1)
{
@@ -256,11 +269,13 @@ static rt_int32_t mmcsd_set_blksize(struct rt_mmcsd_card *card)
/* Block-addressed cards ignore MMC_SET_BLOCKLEN. */
if (card->flags & CARD_FLAG_SDHC)
+ {
return 0;
+ }
mmcsd_host_lock(card->host);
cmd.cmd_code = SET_BLOCKLEN;
- cmd.arg = 512;
+ cmd.arg = MMCSD_SECTOR_SIZE;
cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_AC;
err = mmcsd_send_cmd(card->host, &cmd, 5);
mmcsd_host_unlock(card->host);
@@ -276,7 +291,7 @@ static rt_int32_t mmcsd_set_blksize(struct rt_mmcsd_card *card)
}
static rt_ssize_t mmcsd_blk_read(struct rt_blk_disk *disk, rt_off_t sector,
- void *buffer, rt_size_t sector_count)
+ void *buffer, rt_size_t sector_count)
{
rt_err_t err;
rt_size_t offset = 0;
@@ -287,7 +302,7 @@ static rt_ssize_t mmcsd_blk_read(struct rt_blk_disk *disk, rt_off_t sector,
while (remain_size)
{
- req_size = rt_min_t(rt_size_t, remain_size, blk_dev->max_req_size);
+ req_size = remain_size < blk_dev->max_req_size ? remain_size : blk_dev->max_req_size;
err = rt_mmcsd_req_blk(blk_dev->card, sector + offset, rd_ptr, req_size, 0);
@@ -297,7 +312,7 @@ static rt_ssize_t mmcsd_blk_read(struct rt_blk_disk *disk, rt_off_t sector,
}
offset += req_size;
- rd_ptr = (void *)((rt_uint8_t *)rd_ptr + (req_size << 9));
+ rd_ptr = (void *)((rt_uint8_t *)rd_ptr + req_size * MMCSD_SECTOR_SIZE);
remain_size -= req_size;
}
@@ -305,7 +320,7 @@ static rt_ssize_t mmcsd_blk_read(struct rt_blk_disk *disk, rt_off_t sector,
}
static rt_ssize_t mmcsd_blk_write(struct rt_blk_disk *disk, rt_off_t sector,
- const void *buffer, rt_size_t sector_count)
+ const void *buffer, rt_size_t sector_count)
{
rt_err_t err;
rt_size_t offset = 0;
@@ -316,7 +331,7 @@ static rt_ssize_t mmcsd_blk_write(struct rt_blk_disk *disk, rt_off_t sector,
while (remain_size)
{
- req_size = rt_min_t(rt_size_t, remain_size, blk_dev->max_req_size);
+ req_size = remain_size < blk_dev->max_req_size ? remain_size : blk_dev->max_req_size;
err = rt_mmcsd_req_blk(blk_dev->card, sector + offset, wr_ptr, req_size, 1);
@@ -326,7 +341,7 @@ static rt_ssize_t mmcsd_blk_write(struct rt_blk_disk *disk, rt_off_t sector,
}
offset += req_size;
- wr_ptr = (void *)((rt_uint8_t *)wr_ptr + (req_size << 9));
+ wr_ptr = (void *)((rt_uint8_t *)wr_ptr + req_size * MMCSD_SECTOR_SIZE);
remain_size -= req_size;
}
@@ -334,7 +349,7 @@ static rt_ssize_t mmcsd_blk_write(struct rt_blk_disk *disk, rt_off_t sector,
}
static rt_err_t mmcsd_blk_getgeome(struct rt_blk_disk *disk,
- struct rt_device_blk_geometry *geometry)
+ struct rt_device_blk_geometry *geometry)
{
struct mmcsd_blk_device *blk_dev = raw_to_mmcsd_blk(disk);
@@ -343,8 +358,7 @@ static rt_err_t mmcsd_blk_getgeome(struct rt_blk_disk *disk,
return RT_EOK;
}
-static const struct rt_blk_disk_ops mmcsd_blk_ops =
-{
+static const struct rt_blk_disk_ops mmcsd_blk_ops = {
.read = mmcsd_blk_read,
.write = mmcsd_blk_write,
.getgeome = mmcsd_blk_getgeome,
@@ -353,6 +367,8 @@ static const struct rt_blk_disk_ops mmcsd_blk_ops =
rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
{
rt_err_t err;
+ rt_size_t max_dma_size;
+ rt_size_t max_blk_size;
struct rt_mmcsd_host *host = card->host;
struct mmcsd_blk_device *blk_dev = rt_calloc(1, sizeof(*blk_dev));
@@ -371,12 +387,12 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
blk_dev->parent.max_partitions = RT_MMCSD_MAX_PARTITION;
blk_dev->card = card;
- blk_dev->max_req_size = rt_min_t(rt_size_t,
- host->max_dma_segs * host->max_seg_size,
- host->max_blk_count * host->max_blk_size) >> 9;
- blk_dev->geometry.bytes_per_sector = 1 << 9;
+ max_dma_size = host->max_dma_segs * host->max_seg_size;
+ max_blk_size = host->max_blk_count * host->max_blk_size;
+ blk_dev->max_req_size = (max_dma_size < max_blk_size ? max_dma_size : max_blk_size) / MMCSD_SECTOR_SIZE;
+ blk_dev->geometry.bytes_per_sector = MMCSD_SECTOR_SIZE;
blk_dev->geometry.block_size = card->card_blksize;
- blk_dev->geometry.sector_count = card->card_capacity * (1024 / 512);
+ blk_dev->geometry.sector_count = card->card_capacity * (1024 / MMCSD_SECTOR_SIZE);
/* Set blk size before partitions probe, Why? */
if ((err = mmcsd_set_blksize(card)))
@@ -400,7 +416,7 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
_fail:
card->blk_dev = RT_NULL;
- free(blk_dev);
+ rt_free(blk_dev);
return err;
}
diff --git a/components/drivers/sdio/dev_mmc.c b/components/drivers/sdio/dev_mmc.c
index 8a09aa937d..a3f42576e8 100644
--- a/components/drivers/sdio/dev_mmc.c
+++ b/components/drivers/sdio/dev_mmc.c
@@ -87,7 +87,9 @@ rt_inline rt_uint32_t GET_BITS(rt_uint32_t *resp,
__res = resp[__off] >> __shft;
if (__size + __shft > 32)
+ {
__res |= resp[__off - 1] << ((32 - __shft) % 32);
+ }
return __res & __mask;
}
@@ -157,7 +159,9 @@ static int mmc_get_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t **new_ext_csd)
*new_ext_csd = RT_NULL;
if (GET_BITS(card->resp_csd, 122, 4) < 4)
+ {
return 0;
+ }
/*
* As the ext_csd is so large and mostly unused, we don't store the
@@ -204,9 +208,13 @@ static int mmc_get_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t **new_ext_csd)
mmcsd_send_request(card->host, &req);
if (cmd.err)
+ {
return cmd.err;
+ }
if (data.err)
+ {
return data.err;
+ }
*new_ext_csd = ext_csd;
return 0;
@@ -284,10 +292,14 @@ static int mmc_send_status(struct rt_mmcsd_card *card, rt_uint32_t *status, unsi
cmd.flags = RESP_R1 | CMD_AC;
err = mmcsd_send_cmd(card->host, &cmd, retries);
if (err)
+ {
return err;
+ }
if (status)
+ {
*status = cmd.resp[0];
+ }
return 0;
}
@@ -321,9 +333,8 @@ static int mmc_poll_for_busy(struct rt_mmcsd_card *card, rt_uint32_t timeout_ms,
LOG_E("error %d requesting status", err);
return err;
}
- }
- while (!(status & R1_READY_FOR_DATA) ||
- (R1_CURRENT_STATE(status) == R1_STATE_PRG));
+ } while (!(status & R1_READY_FOR_DATA) ||
+ (R1_CURRENT_STATE(status) == R1_STATE_PRG));
return err;
}
@@ -344,21 +355,25 @@ static int mmc_switch(struct rt_mmcsd_card *card, rt_uint8_t set,
struct rt_mmcsd_host *host = card->host;
struct rt_mmcsd_cmd cmd = { 0 };
- cmd.cmd_code = SWITCH;
+ cmd.cmd_code = MMC_SWITCH;
cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
(index << 16) | (value << 8) | set;
cmd.flags = RESP_R1B | CMD_AC;
err = mmcsd_send_cmd(host, &cmd, 3);
if (err)
+ {
return err;
+ }
/*
* Poll the card status using CMD13 with a timeout of 500ms and a polling interval of 1ms.
*/
err = mmc_poll_for_busy(card, 500, 3);
if (err)
+ {
return err;
+ }
return 0;
}
@@ -370,7 +385,9 @@ static int mmc_compare_ext_csds(struct rt_mmcsd_card *card,
int err;
if (bus_width == MMCSD_BUS_WIDTH_1)
+ {
return 0;
+ }
err = mmc_get_ext_csd(card, &bw_ext_csd);
@@ -409,7 +426,9 @@ static int mmc_compare_ext_csds(struct rt_mmcsd_card *card,
(ext_csd[EXT_CSD_PWR_CL_DDR_200_360] == bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360]));
if (err)
+ {
err = -RT_ERROR;
+ }
out:
rt_free(bw_ext_csd);
@@ -438,7 +457,9 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
int err = 0, ddr = 0;
if (GET_BITS(card->resp_csd, 122, 4) < 4)
+ {
return 0;
+ }
if (card->flags & CARD_FLAG_HIGHSPEED_DDR)
{
@@ -471,7 +492,9 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
ext_csd_bits[idx][0]);
if (err)
+ {
continue;
+ }
mmcsd_set_bus_width(host, bus_width);
err = mmc_compare_ext_csds(card, ext_csd, bus_width);
@@ -535,22 +558,30 @@ rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host,
{
err = mmcsd_send_cmd(host, &cmd, 3);
if (err)
+ {
break;
+ }
/* if we're just probing, do a single pass */
if (ocr == 0)
+ {
break;
+ }
/* otherwise wait until reset completes */
if (controller_is_spi(host))
{
if (!(cmd.resp[0] & R1_SPI_IDLE))
+ {
break;
+ }
}
else
{
if (cmd.resp[0] & CARD_BUSY)
+ {
break;
+ }
}
err = -RT_ETIMEOUT;
@@ -559,7 +590,9 @@ rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host,
}
if (rocr && !controller_is_spi(host))
+ {
*rocr = cmd.resp[0];
+ }
return err;
}
@@ -577,7 +610,9 @@ static rt_err_t mmc_set_card_addr(struct rt_mmcsd_host *host, rt_uint32_t rca)
err = mmcsd_send_cmd(host, &cmd, 3);
if (err)
+ {
return err;
+ }
return 0;
}
@@ -589,7 +624,9 @@ static int mmc_select_hs200(struct rt_mmcsd_card *card)
ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS200);
if (ret)
+ {
return ret;
+ }
mmcsd_set_timing(card->host, MMCSD_TIMING_MMC_HS200);
mmcsd_set_clock(card->host, card->max_data_rate);
@@ -714,21 +751,31 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
/* The extra bit indicates that we support high capacity */
err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
if (err)
+ {
goto err;
+ }
if (controller_is_spi(host))
{
err = mmcsd_spi_use_crc(host, 1);
if (err)
+ {
goto err1;
+ }
}
if (controller_is_spi(host))
+ {
err = mmcsd_get_cid(host, resp);
+ }
else
+ {
err = mmcsd_all_get_cid(host, resp);
+ }
if (err)
+ {
goto err;
+ }
card = rt_malloc(sizeof(struct rt_mmcsd_card));
if (!card)
@@ -751,24 +798,32 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
{
err = mmc_set_card_addr(host, card->rca);
if (err)
+ {
goto err1;
+ }
mmcsd_set_bus_mode(host, MMCSD_BUSMODE_PUSHPULL);
}
err = mmcsd_get_csd(card, card->resp_csd);
if (err)
+ {
goto err1;
+ }
err = mmcsd_parse_csd(card);
if (err)
+ {
goto err1;
+ }
if (!controller_is_spi(host))
{
err = mmcsd_select_card(card);
if (err)
+ {
goto err1;
+ }
}
/*
@@ -777,10 +832,14 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
err = mmc_get_ext_csd(card, &ext_csd);
if (err)
+ {
goto err1;
+ }
err = mmc_parse_ext_csd(card, ext_csd);
if (err)
+ {
goto err1;
+ }
/* If doing byte addressing, check if required to do sector
* addressing. Handle the case of <2GB cards needing sector
@@ -788,7 +847,9 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
* ocr register has bit 30 set for sector addressing.
*/
if (!(card->flags & CARD_FLAG_SDHC) && (rocr & (1 << 30)))
+ {
card->flags |= CARD_FLAG_SDHC;
+ }
/*switch bus width and bus mode*/
err = mmc_select_bus_width(card, ext_csd);
@@ -839,7 +900,9 @@ rt_int32_t init_mmc(struct rt_mmcsd_host *host, rt_uint32_t ocr)
{
err = mmcsd_spi_read_ocr(host, 0, &ocr);
if (err)
+ {
goto err;
+ }
}
current_ocr = mmcsd_select_voltage(host, ocr);
@@ -858,13 +921,17 @@ rt_int32_t init_mmc(struct rt_mmcsd_host *host, rt_uint32_t ocr)
*/
err = mmcsd_mmc_init_card(host, current_ocr);
if (err)
+ {
goto err;
+ }
mmcsd_host_unlock(host);
err = rt_mmcsd_blk_probe(host->card);
if (err)
+ {
goto remove_card;
+ }
mmcsd_host_lock(host);
return 0;
diff --git a/components/drivers/sdio/dev_mmcsd_core.c b/components/drivers/sdio/dev_mmcsd_core.c
index 9f80bb9b60..31fdea978c 100644
--- a/components/drivers/sdio/dev_mmcsd_core.c
+++ b/components/drivers/sdio/dev_mmcsd_core.c
@@ -15,11 +15,11 @@
#include <drivers/dev_sdio.h>
#include <string.h>
-#define DBG_TAG "SDIO"
+#define DBG_TAG "SDIO"
#ifdef RT_SDIO_DEBUG
-#define DBG_LVL DBG_LOG
+#define DBG_LVL DBG_LOG
#else
-#define DBG_LVL DBG_INFO
+#define DBG_LVL DBG_INFO
#endif /* RT_SDIO_DEBUG */
#include <rtdbg.h>
@@ -28,16 +28,16 @@
#endif
#ifndef RT_MMCSD_THREAD_PRIORITY
#if (RT_THREAD_PRIORITY_MAX == 32)
-#define RT_MMCSD_THREAD_PRIORITY 0x16
+#define RT_MMCSD_THREAD_PRIORITY 0x16
#else
-#define RT_MMCSD_THREAD_PRIORITY 0x40
+#define RT_MMCSD_THREAD_PRIORITY 0x40
#endif
#endif
//static struct rt_semaphore mmcsd_sem;
static struct rt_thread mmcsd_detect_thread;
static rt_uint8_t mmcsd_stack[RT_MMCSD_STACK_SIZE];
-static struct rt_mailbox mmcsd_detect_mb;
+static struct rt_mailbox mmcsd_detect_mb;
static rt_uint32_t mmcsd_detect_mb_pool[4];
static struct rt_mailbox mmcsd_hotpluge_mb;
static rt_uint32_t mmcsd_hotpluge_mb_pool[4];
@@ -80,15 +80,12 @@ void mmcsd_send_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req)
rt_sem_take(&host->sem_ack, RT_WAITING_FOREVER);
- }
- while (req->cmd->err && (req->cmd->retries > 0));
-
-
+ } while (req->cmd->err && (req->cmd->retries > 0));
}
rt_int32_t mmcsd_send_cmd(struct rt_mmcsd_host *host,
- struct rt_mmcsd_cmd *cmd,
- int retries)
+ struct rt_mmcsd_cmd *cmd,
+ int retries)
{
struct rt_mmcsd_req req;
@@ -135,8 +132,8 @@ rt_int32_t mmcsd_go_idle(struct rt_mmcsd_host *host)
}
rt_int32_t mmcsd_spi_read_ocr(struct rt_mmcsd_host *host,
- rt_int32_t high_capacity,
- rt_uint32_t *ocr)
+ rt_int32_t high_capacity,
+ rt_uint32_t *ocr)
{
struct rt_mmcsd_cmd cmd;
rt_int32_t err;
@@ -167,7 +164,9 @@ rt_int32_t mmcsd_all_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid)
err = mmcsd_send_cmd(host, &cmd, 3);
if (err)
+ {
return err;
+ }
rt_memcpy(cid, cmd.resp, sizeof(rt_uint32_t) * 4);
@@ -185,7 +184,9 @@ rt_int32_t mmcsd_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid)
if (!controller_is_spi(host))
{
if (!host->card)
+ {
return -RT_ERROR;
+ }
rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
cmd.cmd_code = SEND_CID;
@@ -193,7 +194,9 @@ rt_int32_t mmcsd_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid)
cmd.flags = RESP_R2 | CMD_AC;
err = mmcsd_send_cmd(host, &cmd, 3);
if (err)
+ {
return err;
+ }
rt_memcpy(cid, cmd.resp, sizeof(rt_uint32_t) * 4);
@@ -246,7 +249,9 @@ rt_int32_t mmcsd_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid)
}
for (i = 0; i < 4; i++)
+ {
cid[i] = buf[i];
+ }
rt_free(buf);
return 0;
@@ -269,7 +274,9 @@ rt_int32_t mmcsd_get_csd(struct rt_mmcsd_card *card, rt_uint32_t *csd)
cmd.flags = RESP_R2 | CMD_AC;
err = mmcsd_send_cmd(card->host, &cmd, 3);
if (err)
+ {
return err;
+ }
rt_memcpy(csd, cmd.resp, sizeof(rt_uint32_t) * 4);
@@ -323,7 +330,9 @@ rt_int32_t mmcsd_get_csd(struct rt_mmcsd_card *card, rt_uint32_t *csd)
}
for (i = 0; i < 4; i++)
+ {
csd[i] = buf[i];
+ }
rt_free(buf);
return 0;
@@ -352,7 +361,9 @@ static rt_int32_t _mmcsd_select_card(struct rt_mmcsd_host *host,
err = mmcsd_send_cmd(host, &cmd, 3);
if (err)
+ {
return err;
+ }
return 0;
}
@@ -380,7 +391,9 @@ rt_int32_t mmcsd_spi_use_crc(struct rt_mmcsd_host *host, rt_int32_t use_crc)
err = mmcsd_send_cmd(host, &cmd, 0);
if (!err)
+ {
host->spi_use_crc = use_crc;
+ }
return err;
}
@@ -446,7 +459,7 @@ void mmcsd_set_timing(struct rt_mmcsd_host *host, rt_uint32_t timing)
mmcsd_set_iocfg(host);
}
-void mmcsd_set_data_timeout(struct rt_mmcsd_data *data,
+void mmcsd_set_data_timeout(struct rt_mmcsd_data *data,
const struct rt_mmcsd_card *card)
{
rt_uint32_t mult;
@@ -469,7 +482,9 @@ void mmcsd_set_data_timeout(struct rt_mmcsd_data *data,
* the r2w factor for writes.
*/
if (data->flags & DATA_DIR_WRITE)
+ {
mult <<= card->csd.r2w_factor;
+ }
data->timeout_ns = card->tacc_ns * mult;
data->timeout_clks = card->tacc_clks * mult;
@@ -486,13 +501,17 @@ void mmcsd_set_data_timeout(struct rt_mmcsd_data *data,
(card->host->io_cfg.clock / 1000);
if (data->flags & DATA_DIR_WRITE)
+ {
/*
* The limit is really 250 ms, but that is
* insufficient for some crappy cards.
*/
limit_us = 300000;
+ }
else
+ {
limit_us = 100000;
+ }
/*
* SDHC cards always use these fixed values.
@@ -509,12 +528,16 @@ void mmcsd_set_data_timeout(struct rt_mmcsd_data *data,
if (data->flags & DATA_DIR_WRITE)
{
if (data->timeout_ns < 1000000000)
+ {
data->timeout_ns = 1000000000; /* 1s */
+ }
}
else
{
if (data->timeout_ns < 100000000)
- data->timeout_ns = 100000000; /* 100ms */
+ {
+ data->timeout_ns = 100000000; /* 100ms */
+ }
}
}
}
@@ -683,36 +706,202 @@ power_cycle:
return err;
}
-static const rt_uint8_t tuning_blk_pattern_4bit[] =
-{
- 0xff, 0x0f, 0xff, 0x00, 0xff, 0xcc, 0xc3, 0xcc,
- 0xc3, 0x3c, 0xcc, 0xff, 0xfe, 0xff, 0xfe, 0xef,
- 0xff, 0xdf, 0xff, 0xdd, 0xff, 0xfb, 0xff, 0xfb,
- 0xbf, 0xff, 0x7f, 0xff, 0x77, 0xf7, 0xbd, 0xef,
- 0xff, 0xf0, 0xff, 0xf0, 0x0f, 0xfc, 0xcc, 0x3c,
- 0xcc, 0x33, 0xcc, 0xcf, 0xff, 0xef, 0xff, 0xee,
- 0xff, 0xfd, 0xff, 0xfd, 0xdf, 0xff, 0xbf, 0xff,
- 0xbb, 0xff, 0xf7, 0xff, 0xf7, 0x7f, 0x7b, 0xde,
+static const rt_uint8_t tuning_blk_pattern_4bit[] = {
+ 0xff,
+ 0x0f,
+ 0xff,
+ 0x00,
+ 0xff,
+ 0xcc,
+ 0xc3,
+ 0xcc,
+ 0xc3,
+ 0x3c,
+ 0xcc,
+ 0xff,
+ 0xfe,
+ 0xff,
+ 0xfe,
+ 0xef,
+ 0xff,
+ 0xdf,
+ 0xff,
+ 0xdd,
+ 0xff,
+ 0xfb,
+ 0xff,
+ 0xfb,
+ 0xbf,
+ 0xff,
+ 0x7f,
+ 0xff,
+ 0x77,
+ 0xf7,
+ 0xbd,
+ 0xef,
+ 0xff,
+ 0xf0,
+ 0xff,
+ 0xf0,
+ 0x0f,
+ 0xfc,
+ 0xcc,
+ 0x3c,
+ 0xcc,
+ 0x33,
+ 0xcc,
+ 0xcf,
+ 0xff,
+ 0xef,
+ 0xff,
+ 0xee,
+ 0xff,
+ 0xfd,
+ 0xff,
+ 0xfd,
+ 0xdf,
+ 0xff,
+ 0xbf,
+ 0xff,
+ 0xbb,
+ 0xff,
+ 0xf7,
+ 0xff,
+ 0xf7,
+ 0x7f,
+ 0x7b,
+ 0xde,
};
-static const rt_uint8_t tuning_blk_pattern_8bit[] =
-{
- 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00,
- 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 0xcc,
- 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 0xff,
- 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, 0xff,
- 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 0xdd,
- 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb,
- 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff,
- 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, 0xff,
- 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc,
- 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff,
- 0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee,
- 0xff, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd,
- 0xdd, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff,
- 0xbb, 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff,
- 0xff, 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee,
+static const rt_uint8_t tuning_blk_pattern_8bit[] = {
+ 0xff,
+ 0xff,
+ 0x00,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0x00,
+ 0x00,
+ 0xff,
+ 0xff,
+ 0xcc,
+ 0xcc,
+ 0xcc,
+ 0x33,
+ 0xcc,
+ 0xcc,
+ 0xcc,
+ 0x33,
+ 0x33,
+ 0xcc,
+ 0xcc,
+ 0xcc,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0xee,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0xee,
+ 0xee,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0xdd,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0xdd,
+ 0xdd,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0xbb,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0xbb,
+ 0xbb,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0x77,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0x77,
+ 0x77,
+ 0xff,
+ 0x77,
+ 0xbb,
+ 0xdd,
+ 0xee,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0x00,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0x00,
+ 0x00,
+ 0xff,
+ 0xff,
+ 0xcc,
+ 0xcc,
+ 0xcc,
+ 0x33,
+ 0xcc,
+ 0xcc,
+ 0xcc,
+ 0x33,
+ 0x33,
+ 0xcc,
+ 0xcc,
+ 0xcc,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0xee,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0xee,
+ 0xee,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0xdd,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0xdd,
+ 0xdd,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0xbb,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0xbb,
+ 0xbb,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0x77,
+ 0xff,
+ 0xff,
+ 0xff,
+ 0x77,
+ 0x77,
+ 0xff,
+ 0x77,
+ 0xbb,
+ 0xdd,
+ 0xee,
};
rt_err_t mmcsd_send_tuning(struct rt_mmcsd_host *host, rt_uint32_t opcode, rt_err_t *cmd_error)
@@ -721,9 +910,9 @@ rt_err_t mmcsd_send_tuning(struct rt_mmcsd_host *host, rt_uint32_t opcode, rt_er
int size;
rt_uint8_t *data_buf;
const rt_uint8_t *tuning_block_pattern;
- struct rt_mmcsd_req req = {};
- struct rt_mmcsd_cmd cmd = {};
- struct rt_mmcsd_data data = {};
+ struct rt_mmcsd_req req;
+ struct rt_mmcsd_cmd cmd;
+ struct rt_mmcsd_data data;
struct rt_mmcsd_io_cfg *io_cfg = &host->io_cfg;
if (io_cfg->bus_width == MMCSD_BUS_WIDTH_8)
@@ -801,7 +990,7 @@ out_free:
rt_err_t mmcsd_send_abort_tuning(struct rt_mmcsd_host *host, rt_uint32_t opcode)
{
- struct rt_mmcsd_cmd cmd = {};
+ struct rt_mmcsd_cmd cmd = { 0 };
/*
* eMMC specification specifies that CMD12 can be used to stop a tuning
@@ -913,8 +1102,8 @@ void mmcsd_change(struct rt_mmcsd_host *host)
void mmcsd_detect(void *param)
{
struct rt_mmcsd_host *host;
- rt_uint32_t ocr;
- rt_int32_t err;
+ rt_uint32_t ocr;
+ rt_int32_t err;
while (1)
{
@@ -932,7 +1121,9 @@ void mmcsd_detect(void *param)
if (!err)
{
if (init_sdio(host, ocr))
+ {
mmcsd_power_off(host);
+ }
mmcsd_host_unlock(host);
continue;
}
@@ -944,7 +1135,9 @@ void mmcsd_detect(void *param)
if (!err)
{
if (init_sd(host, ocr))
+ {
mmcsd_power_off(host);
+ }
mmcsd_host_unlock(host);
rt_mb_send(&mmcsd_hotpluge_mb, (rt_ubase_t)host);
continue;
@@ -957,7 +1150,9 @@ void mmcsd_detect(void *param)
if (!err)
{
if (init_mmc(host, ocr))
+ {
mmcsd_power_off(host);
+ }
mmcsd_host_unlock(host);
rt_mb_send(&mmcsd_hotpluge_mb, (rt_ubase_t)host);
continue;
@@ -1029,14 +1224,21 @@ rt_int32_t mmcsd_excute_tuning(struct rt_mmcsd_card *card)
rt_int32_t opcode;
if (!host->ops->execute_tuning)
+ {
return RT_EOK;
+ }
if (card->card_type == CARD_TYPE_MMC)
+ {
opcode = SEND_TUNING_BLOCK_HS200;
+ }
else
+ {
opcode = SEND_TUNING_BLOCK;
+ }
- return host->ops->execute_tuning(host, opcode);;
+ return host->ops->execute_tuning(host, opcode);
+ ;
}
int rt_mmcsd_core_init(void)
diff --git a/components/drivers/sdio/dev_sd.c b/components/drivers/sdio/dev_sd.c
index d0193bdd1d..634e42998e 100644
--- a/components/drivers/sdio/dev_sd.c
+++ b/components/drivers/sdio/dev_sd.c
@@ -12,52 +12,85 @@
#include <drivers/dev_mmcsd_core.h>
#include <drivers/dev_sd.h>
-#define DBG_TAG "SDIO"
+#define DBG_TAG "SDIO"
#ifdef RT_SDIO_DEBUG
-#define DBG_LVL DBG_LOG
+#define DBG_LVL DBG_LOG
#else
-#define DBG_LVL DBG_INFO
+#define DBG_LVL DBG_INFO
#endif /* RT_SDIO_DEBUG */
#include <rtdbg.h>
-static const rt_uint32_t tran_unit[] =
-{
+static const rt_uint32_t tran_unit[] = {
10000, 100000, 1000000, 10000000,
- 0, 0, 0, 0
+ 0, 0, 0, 0
};
-static const rt_uint8_t tran_value[] =
-{
- 0, 10, 12, 13, 15, 20, 25, 30,
- 35, 40, 45, 50, 55, 60, 70, 80,
+static const rt_uint8_t tran_value[] = {
+ 0,
+ 10,
+ 12,
+ 13,
+ 15,
+ 20,
+ 25,
+ 30,
+ 35,
+ 40,
+ 45,
+ 50,
+ 55,
+ 60,
+ 70,
+ 80,
};
-static const rt_uint32_t tacc_uint[] =
-{
- 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
+static const rt_uint32_t tacc_uint[] = {
+ 1,
+ 10,
+ 100,
+ 1000,
+ 10000,
+ 100000,
+ 1000000,
+ 10000000,
};
-static const rt_uint8_t tacc_value[] =
-{
- 0, 10, 12, 13, 15, 20, 25, 30,
- 35, 40, 45, 50, 55, 60, 70, 80,
+static const rt_uint8_t tacc_value[] = {
+ 0,
+ 10,
+ 12,
+ 13,
+ 15,
+ 20,
+ 25,
+ 30,
+ 35,
+ 40,
+ 45,
+ 50,
+ 55,
+ 60,
+ 70,
+ 80,
};
rt_inline rt_uint32_t GET_BITS(rt_uint32_t *resp,
- rt_uint32_t start,
- rt_uint32_t size)
+ rt_uint32_t start,
+ rt_uint32_t size)
{
- const rt_int32_t __size = size;
- const rt_uint32_t __mask = (__size < 32 ? 1U << __size : 0) - 1;
- const rt_int32_t __off = 3 - ((start) / 32);
- const rt_int32_t __shft = (start) & 31;
- rt_uint32_t __res;
+ const rt_int32_t __size = size;
+ const rt_uint32_t __mask = (__size < 32 ? 1U << __size : 0) - 1;
+ const rt_int32_t __off = 3 - ((start) / 32);
+ const rt_int32_t __shft = (start) & 31;
+ rt_uint32_t __res;
- __res = resp[__off] >> __shft;
- if (__size + __shft > 32)
- __res |= resp[__off-1] << ((32 - __shft) % 32);
+ __res = resp[__off] >> __shft;
+ if (__size + __shft > 32)
+ {
+ __res |= resp[__off - 1] << ((32 - __shft) % 32);
+ }
- return __res & __mask;
+ return __res & __mask;
}
static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
@@ -91,8 +124,8 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
card->card_capacity *= card->card_blksize;
card->card_capacity >>= 10; /* unit:KB */
card->tacc_clks = csd->nsac * 100;
- card->tacc_ns = (tacc_uint[csd->taac&0x07] * tacc_value[(csd->taac&0x78)>>3] + 9) / 10;
- card->max_data_rate = tran_unit[csd->tran_speed&0x07] * tran_value[(csd->tran_speed&0x78)>>3];
+ card->tacc_ns = (tacc_uint[csd->taac & 0x07] * tacc_value[(csd->taac & 0x78) >> 3] + 9) / 10;
+ card->max_data_rate = tran_unit[csd->tran_speed & 0x07] * tran_value[(csd->tran_speed & 0x78) >> 3];
break;
case 1:
@@ -123,7 +156,7 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
card->card_sec_cnt = card->card_capacity * 2;
card->tacc_clks = 0;
card->tacc_ns = 0;
- card->max_data_rate = tran_unit[csd->tran_speed&0x07] * tran_value[(csd->tran_speed&0x78)>>3];
+ card->max_data_rate = tran_unit[csd->tran_speed & 0x07] * tran_value[(csd->tran_speed & 0x78) >> 3];
break;
default:
@@ -158,7 +191,7 @@ static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card)
struct rt_mmcsd_data data;
rt_uint8_t *buf;
- buf = (rt_uint8_t*)rt_malloc(64);
+ buf = (rt_uint8_t *)rt_malloc(64);
if (!buf)
{
LOG_E("alloc memory failed!");
@@ -167,9 +200,13 @@ static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card)
}
if (card->card_type != CARD_TYPE_SD)
+ {
goto err;
+ }
if (card->scr.sd_version < SCR_SPEC_VER_1)
+ {
goto err;
+ }
rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
@@ -199,7 +236,9 @@ static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card)
}
if (buf[13] & 0x02)
+ {
card->hs_max_data_rate = 50000000;
+ }
rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
@@ -252,7 +291,7 @@ static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card)
goto err;
}
- switch(switch_func_timing)
+ switch (switch_func_timing)
{
case SD_SWITCH_FUNC_TIMING_SDR104:
card->flags |= CARD_FLAG_SDR104;
@@ -307,9 +346,13 @@ err:
err1:
if (cmd.err)
+ {
err = cmd.err;
+ }
if (data.err)
+ {
err = data.err;
+ }
return err;
}
@@ -318,7 +361,7 @@ static rt_err_t mmcsd_app_cmd(struct rt_mmcsd_host *host,
struct rt_mmcsd_card *card)
{
rt_err_t err;
- struct rt_mmcsd_cmd cmd = {0};
+ struct rt_mmcsd_cmd cmd = { 0 };
cmd.cmd_code = APP_CMD;
@@ -335,11 +378,15 @@ static rt_err_t mmcsd_app_cmd(struct rt_mmcsd_host *host,
err = mmcsd_send_cmd(host, &cmd, 0);
if (err)
+ {
return err;
+ }
/* Check that card supported application commands */
if (!controller_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD))
+ {
return -RT_ERROR;
+ }
return RT_EOK;
}
@@ -347,8 +394,8 @@ static rt_err_t mmcsd_app_cmd(struct rt_mmcsd_host *host,
rt_err_t mmcsd_send_app_cmd(struct rt_mmcsd_host *host,
struct rt_mmcsd_card *card,
- struct rt_mmcsd_cmd *cmd,
- int retry)
+ struct rt_mmcsd_cmd *cmd,
+ int retry)
{
struct rt_mmcsd_req req;
int i;
@@ -371,7 +418,9 @@ rt_err_t mmcsd_send_app_cmd(struct rt_mmcsd_host *host,
if (controller_is_spi(host))
{
if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
+ {
break;
+ }
}
continue;
}
@@ -387,13 +436,17 @@ rt_err_t mmcsd_send_app_cmd(struct rt_mmcsd_host *host,
err = cmd->err;
if (!cmd->err)
+ {
break;
+ }
/* no point in retrying illegal APP commands */
if (controller_is_spi(host))
{
if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
+ {
break;
+ }
}
}
@@ -424,14 +477,16 @@ rt_err_t mmcsd_app_set_bus_width(struct rt_mmcsd_card *card, rt_int32_t width)
err = mmcsd_send_app_cmd(card->host, card, &cmd, 3);
if (err)
+ {
return err;
+ }
return RT_EOK;
}
rt_err_t mmcsd_send_app_op_cond(struct rt_mmcsd_host *host,
- rt_uint32_t ocr,
- rt_uint32_t *rocr)
+ rt_uint32_t ocr,
+ rt_uint32_t *rocr)
{
struct rt_mmcsd_cmd cmd;
rt_uint32_t i;
@@ -441,31 +496,43 @@ rt_err_t mmcsd_send_app_op_cond(struct rt_mmcsd_host *host,
cmd.cmd_code = SD_APP_OP_COND;
if (controller_is_spi(host))
+ {
cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
+ }
else
+ {
cmd.arg = ocr;
+ }
cmd.flags = RESP_SPI_R1 | RESP_R3 | CMD_BCR;
for (i = 1000; i; i--)
{
err = mmcsd_send_app_cmd(host, RT_NULL, &cmd, 3);
if (err)
+ {
break;
+ }
/* if we're just probing, do a single pass */
if (ocr == 0)
+ {
break;
+ }
/* otherwise wait until reset completes */
if (controller_is_spi(host))
{
if (!(cmd.resp[0] & R1_SPI_IDLE))
+ {
break;
+ }
}
else
{
if (cmd.resp[0] & CARD_BUSY)
+ {
break;
+ }
}
err = -RT_ETIMEOUT;
@@ -474,7 +541,9 @@ rt_err_t mmcsd_send_app_op_cond(struct rt_mmcsd_host *host,
}
if (rocr && !controller_is_spi(host))
+ {
*rocr = cmd.resp[0];
+ }
return err;
}
@@ -496,15 +565,23 @@ rt_err_t mmcsd_send_if_cond(struct rt_mmcsd_host *host, rt_uint32_t ocr)
err = mmcsd_send_cmd(host, &cmd, 0);
if (err)
+ {
return err;
+ }
if (controller_is_spi(host))
+ {
pattern = cmd.resp[1] & 0xFF;
+ }
else
+ {
pattern = cmd.resp[0] & 0xFF;
+ }
if (pattern != 0xAA)
+ {
return -RT_ERROR;
+ }
return RT_EOK;
}
@@ -522,18 +599,19 @@ rt_err_t mmcsd_get_card_addr(struct rt_mmcsd_host *host, rt_uint32_t *rca)
err = mmcsd_send_cmd(host, &cmd, 3);
if (err)
+ {
return err;
+ }
*rca = cmd.resp[0] >> 16;
return RT_EOK;
}
-#define be32_to_cpu(x) ((rt_uint32_t)( \
- (((rt_uint32_t)(x) & (rt_uint32_t)0x000000ffUL) << 24) | \
- (((rt_uint32_t)(x) & (rt_uint32_t)0x0000ff00UL) << 8) | \
- (((rt_uint32_t)(x) & (rt_uint32_t)0x00ff0000UL) >> 8) | \
- (((rt_uint32_t)(x) & (rt_uint32_t)0xff000000UL) >> 24)))
+#define be32_to_cpu(x) ((rt_uint32_t)((((rt_uint32_t)(x) & (rt_uint32_t)0x000000ffUL) << 24) | \
+ (((rt_uint32_t)(x) & (rt_uint32_t)0x0000ff00UL) << 8) | \
+ (((rt_uint32_t)(x) & (rt_uint32_t)0x00ff0000UL) >> 8) | \
+ (((rt_uint32_t)(x) & (rt_uint32_t)0xff000000UL) >> 24)))
rt_int32_t mmcsd_get_scr(struct rt_mmcsd_card *card, rt_uint32_t *scr)
{
@@ -544,7 +622,9 @@ rt_int32_t mmcsd_get_scr(struct rt_mmcsd_card *card, rt_uint32_t *scr)
err = mmcsd_app_cmd(card->host, card);
if (err)
+ {
return err;
+ }
rt_memset(&req, 0, sizeof(struct rt_mmcsd_req));
rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
@@ -567,9 +647,13 @@ rt_int32_t mmcsd_get_scr(struct rt_mmcsd_card *card, rt_uint32_t *scr)
mmcsd_send_request(card->host, &req);
if (cmd.err)
+ {
return cmd.err;
+ }
if (data.err)
+ {
return data.err;
+ }
scr[0] = be32_to_cpu(scr[0]);
scr[1] = be32_to_cpu(scr[1]);
@@ -586,7 +670,9 @@ static rt_err_t mmcsd_read_sd_status(struct rt_mmcsd_card *card, rt_uint32_t *sd
err = mmcsd_app_cmd(card->host, card);
if (err)
+ {
return err;
+ }
rt_memset(&req, 0, sizeof(struct rt_mmcsd_req));
rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
@@ -609,18 +695,22 @@ static rt_err_t mmcsd_read_sd_status(struct rt_mmcsd_card *card, rt_uint32_t *sd
mmcsd_send_request(card->host, &req);
if (cmd.err)
+ {
return cmd.err;
+ }
if (data.err)
+ {
return data.err;
+ }
/* Convert endian */
- for (uint32_t i=0; i < 8; i++)
+ for (uint32_t i = 0; i < 8; i++)
{
uint32_t tmp = sd_status[i];
sd_status[i] = sd_status[15 - i];
sd_status[15 - i] = tmp;
}
- for (uint32_t i=0; i < 16; i++)
+ for (uint32_t i = 0; i < 16; i++)
{
sd_status[i] = be32_to_cpu(sd_status[i]);
}
@@ -630,7 +720,7 @@ static rt_err_t mmcsd_read_sd_status(struct rt_mmcsd_card *card, rt_uint32_t *sd
}
static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
- rt_uint32_t ocr)
+ rt_uint32_t ocr)
{
struct rt_mmcsd_card *card;
rt_int32_t err;
@@ -647,7 +737,9 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
*/
err = mmcsd_send_if_cond(host, ocr);
if (!err)
+ {
ocr |= 1 << 30;
+ }
/* Switch to UHS voltage if both Host and the Card support this feature */
if (((host->valid_ocr & VDD_165_195) != 0) && (host->ops->signal_voltage_switch != RT_NULL))
@@ -656,7 +748,9 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
}
err = mmcsd_send_app_op_cond(host, ocr, &ocr);
if (err)
+ {
goto err2;
+ }
/* Select voltage */
if (ocr & OCR_S18R)
@@ -664,15 +758,23 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
ocr = VDD_165_195;
err = mmcsd_set_uhs_voltage(host, ocr);
if (err)
+ {
goto err2;
+ }
}
if (controller_is_spi(host))
+ {
err = mmcsd_get_cid(host, resp);
+ }
else
+ {
err = mmcsd_all_get_cid(host, resp);
+ }
if (err)
+ {
goto err2;
+ }
card = rt_malloc(sizeof(struct rt_mmcsd_card));
if (!card)
@@ -694,29 +796,39 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
{
err = mmcsd_get_card_addr(host, &card->rca);
if (err)
+ {
goto err1;
+ }
mmcsd_set_bus_mode(host, MMCSD_BUSMODE_PUSHPULL);
}
err = mmcsd_get_csd(card, card->resp_csd);
if (err)
+ {
goto err1;
+ }
err = mmcsd_parse_csd(card);
if (err)
+ {
goto err1;
+ }
if (!controller_is_spi(host))
{
err = mmcsd_select_card(card);
if (err)
+ {
goto err1;
+ }
}
err = mmcsd_get_scr(card, card->resp_scr);
if (err)
+ {
goto err1;
+ }
mmcsd_parse_scr(card);
@@ -724,7 +836,9 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
{
err = mmcsd_spi_use_crc(host, 1);
if (err)
+ {
goto err1;
+ }
}
mmcsd_set_timing(host, MMCSD_TIMING_LEGACY);
@@ -734,7 +848,9 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
{
err = mmcsd_app_set_bus_width(card, MMCSD_BUS_WIDTH_4);
if (err)
+ {
goto err1;
+ }
mmcsd_set_bus_width(host, MMCSD_BUS_WIDTH_4);
}
@@ -743,8 +859,10 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
union rt_sd_status sd_status;
err = mmcsd_read_sd_status(card, sd_status.status_words);
if (err)
+ {
goto err1;
- if ((sd_status.uhs_speed_grade > 0) && (ocr & VDD_165_195))
+ }
+ if ((RT_SD_STATUS_FIELD(sd_status, uhs_speed_grade) > 0) && (ocr & VDD_165_195))
{
/* Assume the card supports all UHS-I modes because we cannot find any mainstreaming card
* that can support only part of the following modes.
@@ -757,7 +875,9 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
*/
err = mmcsd_switch(card);
if (err)
+ {
goto err1;
+ }
/* set bus speed */
max_data_rate = 0U;
@@ -788,7 +908,7 @@ err2:
rt_int32_t init_sd(struct rt_mmcsd_host *host, rt_uint32_t ocr)
{
rt_int32_t err = -RT_EINVAL;
- rt_uint32_t current_ocr;
+ rt_uint32_t current_ocr;
/*
* We need to get OCR a different way for SPI.
*/
@@ -798,7 +918,9 @@ rt_int32_t init_sd(struct rt_mmcsd_host *host, rt_uint32_t ocr)
err = mmcsd_spi_read_ocr(host, 0, &ocr);
if (err)
+ {
goto _err;
+ }
}
current_ocr = mmcsd_select_voltage(host, ocr);
@@ -817,13 +939,17 @@ rt_int32_t init_sd(struct rt_mmcsd_host *host, rt_uint32_t ocr)
*/
err = mmcsd_sd_init_card(host, current_ocr);
if (err)
+ {
goto _err;
+ }
mmcsd_host_unlock(host);
err = rt_mmcsd_blk_probe(host->card);
if (err)
+ {
goto remove_card;
+ }
mmcsd_host_lock(host);
return 0;
generated by cgit v1.3.1 (git 2.54.0) at 2026-11-07 20:21:11 +0000