[DM/FEATURE] Support SCSI bus (#9592)

* [DM/FEATURE] Support block for SCSI
1. Support SD and CD-ROM.
2. SD will port to UFS and ATA device.

Signed-off-by: GuEe-GUI <[email protected]>

8 files changed, 1563 insertions, 0 deletions

diff --git a/components/drivers/Kconfig b/components/drivers/Kconfig
index 53158d1353..b940c482e8 100755
--- a/components/drivers/Kconfig
+++ b/components/drivers/Kconfig
@@ -22,6 +22,7 @@ rsource "graphic/Kconfig"
 rsource "hwcrypto/Kconfig"
 rsource "wlan/Kconfig"
 rsource "block/Kconfig"
+rsource "scsi/Kconfig"
 rsource "virtio/Kconfig"
 rsource "dma/Kconfig"
 rsource "mfd/Kconfig"
diff --git a/components/drivers/include/drivers/scsi.h b/components/drivers/include/drivers/scsi.h
new file mode 100644
index 0000000000..7b6baaf54e
--- /dev/null
+++ b/components/drivers/include/drivers/scsi.h
@@ -0,0 +1,461 @@
+/*
+ * Copyright (c) 2006-2023, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2023-02-25     GuEe-GUI     the first version
+ */
+
+#ifndef __SCSI_H__
+#define __SCSI_H__
+
+#include <rthw.h>
+#include <rtthread.h>
+#include <drivers/byteorder.h>
+
+#define RT_SCSI_LUN_SHIFT       5
+
+rt_packed(struct rt_scsi_unknow
+{
+    rt_uint8_t opcode;
+});
+
+rt_packed(struct rt_scsi_test_unit_ready
+{
+    rt_uint8_t opcode;
+    rt_uint8_t reserved[4];
+    rt_uint8_t control;
+    rt_uint8_t pad[6];      /* To be ATAPI compatible */
+});
+
+rt_packed(struct rt_scsi_inquiry
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-2 Reserved, 1 Obsolete Formerly CMDDT, 0 EVPD */
+    rt_uint8_t page;        /* Page code if EVPD=1 */
+    rt_uint8_t reserved;
+    rt_uint8_t alloc_length;
+    rt_uint8_t control;
+    rt_uint8_t pad[6];      /* To be ATAPI compatible */
+});
+
+rt_packed(struct rt_scsi_inquiry_data
+{
+#define RT_SCSI_DEVTYPE_MASK  31
+    rt_uint8_t devtype;
+#define RT_SCSI_REMOVABLE_BIT 7
+    rt_uint8_t rmb;
+    rt_uint8_t reserved[2];
+    rt_uint8_t length;
+    rt_uint8_t reserved1[3];
+    char vendor[8];
+    char prodid[16];
+    char prodrev[4];
+});
+
+rt_packed(struct rt_scsi_request_sense
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-2 Reserved, 1 Obsolete, 0 SP */
+    rt_uint8_t reserved[2];
+    rt_uint8_t alloc_length;
+    rt_uint8_t control;
+    rt_uint8_t pad[6];      /* To be ATAPI compatible */
+});
+
+rt_packed(struct rt_scsi_request_sense_data
+{
+    rt_uint8_t error_code;  /* 7 Valid, 6-0 Err. code */
+    rt_uint8_t segment_number;
+    rt_uint8_t sense_key;   /* 7 FileMark, 6 EndOfMedia, 5 ILI, 4-0 sense key */
+    rt_be32_t information;
+    rt_uint8_t additional_sense_length;
+    rt_be32_t cmd_specific_info;
+    rt_uint8_t additional_sense_code;
+    rt_uint8_t additional_sense_code_qualifier;
+    rt_uint8_t field_replaceable_unit_code;
+    rt_uint8_t sense_key_specific[3];
+});
+
+rt_packed(struct rt_scsi_read_capacity10
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;              /* 7-1 Reserved, 0 Obsolete */
+    rt_be32_t logical_block_addr;   /* only if PMI=1 */
+    rt_uint8_t reserved[2];
+    rt_uint8_t pmi;
+    rt_uint8_t control;
+    rt_be16_t pad;                  /* To be ATAPI compatible */
+});
+
+rt_packed(struct rt_scsi_read_capacity10_data
+{
+    rt_be32_t last_block;
+    rt_be32_t block_size;
+});
+
+rt_packed(struct rt_scsi_read_capacity16
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;              /* 7-5 Reserved, 4-0 SERVICE ACTION 0x10 */
+    rt_be64_t logical_block_addr;   /* only if PMI=1 */
+    rt_be32_t alloc_len;
+    rt_uint8_t pmi;
+    rt_uint8_t control;
+});
+
+rt_packed(struct rt_scsi_read_capacity16_data
+{
+    rt_be64_t last_block;
+    rt_be32_t block_size;
+    rt_uint8_t pad[20];
+});
+
+rt_packed(struct rt_scsi_read10
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-5 RDPROTECT, 4 DPO, 3 FUA, 2 RARC, 1 Obsolete, 0 Obsolete */
+    rt_be32_t lba;
+    rt_uint8_t reserved;
+    rt_be16_t size;
+    rt_uint8_t reserved2;
+    rt_be16_t pad;
+});
+
+rt_packed(struct rt_scsi_read12
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-5 RDPROTECT, 4 DPO, 3 FUA, 2 RARC, 1 Obsolete, 0 Obsolete */
+    rt_be32_t lba;
+    rt_be32_t size;
+    rt_uint8_t reserved;
+    rt_uint8_t control;
+});
+
+rt_packed(struct rt_scsi_read16
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-5 RDPROTECT, 4 DPO, 3 FUA, 2 RARC, 1 Obsolete, 0 DLD2 */
+    rt_be64_t lba;
+    rt_be32_t size;
+    rt_uint8_t reserved;
+    rt_uint8_t control;
+});
+
+rt_packed(struct rt_scsi_write10
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-5 WRPROTECT, 4 DPO, 3 FUA, 2 Reserved, 1 Obsolete, 0 Obsolete */
+    rt_be32_t lba;
+    rt_uint8_t reserved;
+    rt_be16_t size;
+    rt_uint8_t reserved2;
+    rt_be16_t pad;
+});
+
+rt_packed(struct rt_scsi_write12
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-5 WRPROTECT, 4 DPO, 3 FUA, 2 Reserved, 1 Obsolete, 0 Obsolete */
+    rt_be32_t lba;
+    rt_be32_t size;
+    rt_uint8_t reserved;
+    rt_uint8_t control;
+});
+
+rt_packed(struct rt_scsi_write16
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-5 WRPROTECT, 4 DPO, 3 FUA, 2 Reserved, 1 Obsolete, 0 DLD2 */
+    rt_be64_t lba;
+    rt_be32_t size;
+    rt_uint8_t reserved;
+    rt_uint8_t control;
+});
+
+rt_packed(struct rt_scsi_synchronize_cache10
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-3 Reserved, 2 Obsolete, 1 IMMED, 0 Obsolete */
+    rt_be32_t lba;
+    rt_uint8_t reserved;
+    rt_be16_t size;
+    rt_uint8_t control;
+});
+
+rt_packed(struct rt_scsi_synchronize_cache16
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-3 Reserved, 2 Obsolete, 1 IMMED, 0 Obsolete */
+    rt_be64_t lba;
+    rt_be32_t size;
+    rt_uint8_t reserved;
+    rt_uint8_t control;
+});
+
+#define RT_SCSI_UNMAP_SHIFT     3
+
+rt_packed(struct rt_scsi_write_same10
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-5 WRPROTECT, 4 ANCHOR, 3 UNMAP, 2 Obsolete, 1 Obsolete, 0 Obsolete */
+    rt_be32_t lba;
+    rt_uint8_t reserved;
+    rt_be16_t size;
+    rt_uint8_t control;
+});
+
+rt_packed(struct rt_scsi_write_same16
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-5 WRPROTECT, 4 ANCHOR, 3 UNMAP, 2 Obsolete, 1 Obsolete, 0 NDOB */
+    rt_be64_t lba;
+    rt_be32_t size;
+    rt_uint8_t reserved;
+    rt_uint8_t control;
+});
+
+#define RT_SCSI_PF_SHIFT        4
+#define RT_SCSI_RTD_SHIFT       1
+#define RT_SCSI_SP_SHIFT        0
+
+rt_packed(struct rt_scsi_mode_select6
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-5 Reserved, 4 PF, 3-2 Reserved, 1 RTD, 0 SP */
+    rt_uint8_t reserved[2];
+    rt_uint8_t param_list_len;
+    rt_uint8_t control;
+});
+
+rt_packed(struct rt_scsi_mode_select10
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-5 Reserved, 4 PF, 3-1 Reserved, 0 SP */
+    rt_uint8_t reserved[5];
+    rt_be16_t param_list_len;
+    rt_uint8_t control;
+});
+
+struct rt_scsi_mode_select_data
+{
+    rt_uint32_t length;
+    rt_uint16_t block_descriptor_length;
+    rt_uint8_t medium_type;
+    rt_uint8_t device_specific;
+    rt_uint8_t header_length;
+    rt_uint8_t longlba:1;
+};
+
+#define RT_SCSI_DBD_SHIFT       3
+#define RT_SCSI_LLBAA_SHIFT     4
+#define RT_SCSI_PC_SHIFT        6
+#define RT_SCSI_PAGE_CODE_SHIFT 0
+
+rt_packed(struct rt_scsi_mode_sense6
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-4 Reserved, 3 DBD, 2-0 Reserved */
+    rt_uint8_t page_control_code;
+    rt_uint8_t subpage_code;
+    rt_uint8_t allocation_len;
+    rt_uint8_t control;
+});
+
+rt_packed(struct rt_scsi_mode_sense10
+{
+    rt_uint8_t opcode;
+    rt_uint8_t config;      /* 7-5 Reserved, 4 LLBAA, 3 DBD, 2-0 Reserved */
+    rt_uint8_t page_control_code;
+    rt_uint8_t subpage_code;
+    rt_uint8_t reserved[3];
+    rt_be16_t allocation_len;
+    rt_uint8_t control;
+});
+
+#define RT_SCSI_CMD_TEST_UNIT_READY     0x00
+#define RT_SCSI_CMD_REQUEST_SENSE       0x03
+#define RT_SCSI_CMD_INQUIRY             0x12
+#define RT_SCSI_CMD_MODE_SELECT         0x15
+#define RT_SCSI_CMD_MODE_SENSE          0x1a
+#define RT_SCSI_CMD_READ_CAPACITY10     0x25
+#define RT_SCSI_CMD_READ10              0x28
+#define RT_SCSI_CMD_WRITE10             0x2a
+#define RT_SCSI_CMD_SYNCHRONIZE_CACHE10 0x35
+#define RT_SCSI_CMD_WRITE_SAME10        0x41
+#define RT_SCSI_CMD_MODE_SELECT10       0x55
+#define RT_SCSI_CMD_MODE_SENSE10        0x5a
+#define RT_SCSI_CMD_READ16              0x88
+#define RT_SCSI_CMD_WRITE16             0x8a
+#define RT_SCSI_CMD_SYNCHRONIZE_CACHE16 0x91
+#define RT_SCSI_CMD_WRITE_SAME16        0x93
+#define RT_SCSI_CMD_READ_CAPACITY16     0x9e
+#define RT_SCSI_CMD_READ12              0xa8
+#define RT_SCSI_CMD_WRITE12             0xaa
+
+struct rt_scsi_cmd
+{
+    union
+    {
+        struct rt_scsi_unknow unknow;
+        struct rt_scsi_test_unit_ready test_unit_ready;
+        struct rt_scsi_inquiry inquiry;
+        struct rt_scsi_request_sense request_sense;
+        struct rt_scsi_read_capacity10 read_capacity10;
+        struct rt_scsi_read_capacity16 read_capacity16;
+        struct rt_scsi_read10 read10;
+        struct rt_scsi_read12 read12;
+        struct rt_scsi_read16 read16;
+        struct rt_scsi_write10 write10;
+        struct rt_scsi_write12 write12;
+        struct rt_scsi_write16 write16;
+        struct rt_scsi_synchronize_cache10 synchronize_cache10;
+        struct rt_scsi_synchronize_cache16 synchronize_cache16;
+        struct rt_scsi_write_same10 write_same10;
+        struct rt_scsi_write_same16 write_same16;
+        struct rt_scsi_mode_select6 mode_select6;
+        struct rt_scsi_mode_select10 mode_select10;
+        struct rt_scsi_mode_sense6 mode_sense6;
+        struct rt_scsi_mode_sense10 mode_sense10;
+    } op;
+    rt_size_t op_size;
+
+    union
+    {
+        struct
+        {
+            struct rt_scsi_inquiry_data inquiry;
+            struct rt_scsi_request_sense_data request_sense;
+            struct rt_scsi_read_capacity10_data read_capacity10;
+            struct rt_scsi_read_capacity16_data read_capacity16;
+        };
+        struct
+        {
+            void *ptr;
+            rt_size_t size;
+        };
+    } data;
+};
+
+enum
+{
+    SCSI_DEVICE_TYPE_DIRECT                     = 0x00, /* DiskPeripheral (GenDisk) */
+    SCSI_DEVICE_TYPE_SEQUENTIAL                 = 0x01, /* TapePeripheral */
+    SCSI_DEVICE_TYPE_PRINTER                    = 0x02, /* PrinterPeripheral (GenPrinter) */
+    SCSI_DEVICE_TYPE_PROCESSOR                  = 0x03, /* OtherPeripheral */
+    SCSI_DEVICE_TYPE_WRITE_ONCE_READ_MULTIPLE   = 0x04, /* WormPeripheral (GenWorm) */
+    SCSI_DEVICE_TYPE_CDROM                      = 0x05, /* CdRomPeripheral (GenCdRom) */
+    SCSI_DEVICE_TYPE_SCANNER                    = 0x06, /* ScannerPeripheral (GenScanner) */
+    SCSI_DEVICE_TYPE_OPTICAL                    = 0x07, /* OpticalDiskPeripheral (GenOptical) */
+    SCSI_DEVICE_TYPE_MEDIUM_CHANGER             = 0x08, /* MediumChangerPeripheral (ScsiChanger) */
+    SCSI_DEVICE_TYPE_COMMUNICATION              = 0x09, /* CommunicationsPeripheral (ScsiNet) */
+    SCSI_DEVICE_TYPE_ASC_PREPRESS_GRAPHICS10    = 0x0a, /* ASCPrePressGraphicsPeripheral (ScsiASCIT8) */
+    SCSI_DEVICE_TYPE_ASC_PREPRESS_GRAPHICS11    = 0x0b, /* ASCPrePressGraphicsPeripheral (ScsiASCIT8) */
+    SCSI_DEVICE_TYPE_ARRAY                      = 0x0c, /* ArrayPeripheral (ScsiArray) */
+    SCSI_DEVICE_TYPE_ENCLOSURE                  = 0x0d, /* EnclosurePeripheral (ScsiEnclosure) */
+    SCSI_DEVICE_TYPE_RBC                        = 0x0e, /* RBCPeripheral (ScsiRBC) */
+    SCSI_DEVICE_TYPE_CARDREADER                 = 0x0f, /* CardReaderPeripheral (ScsiCardReader) */
+    SCSI_DEVICE_TYPE_BRIDGE                     = 0x10, /* BridgePeripheral (ScsiBridge) */
+    SCSI_DEVICE_TYPE_OTHER                      = 0x11, /* OtherPeripheral (ScsiOther) */
+    SCSI_DEVICE_TYPE_MAX,
+};
+
+struct rt_scsi_ops;
+
+struct rt_scsi_host
+{
+    struct rt_device *dev;
+
+    const struct rt_scsi_ops *ops;
+
+    rt_size_t max_id;
+    rt_size_t max_lun;
+
+    rt_list_t lun_nodes;
+};
+
+struct rt_scsi_device
+{
+    struct rt_scsi_host *host;
+
+    rt_list_t list;
+
+    rt_size_t id;
+    rt_size_t lun;
+    rt_uint32_t devtype;
+    rt_uint32_t removable;
+    rt_size_t last_block;
+    rt_size_t block_size;
+
+    void *priv;
+};
+
+struct rt_scsi_ops
+{
+    rt_err_t (*reset)(struct rt_scsi_device *sdev);
+    rt_err_t (*transfer)(struct rt_scsi_device *sdev, struct rt_scsi_cmd *cmd);
+};
+
+rt_err_t rt_scsi_host_register(struct rt_scsi_host *scsi);
+rt_err_t rt_scsi_host_unregister(struct rt_scsi_host *scsi);
+
+rt_inline rt_bool_t rt_scsi_cmd_is_write(struct rt_scsi_cmd *cmd)
+{
+    return cmd->op.write10.opcode == RT_SCSI_CMD_WRITE10 ||
+            cmd->op.write12.opcode == RT_SCSI_CMD_WRITE16 ||
+            cmd->op.write16.opcode == RT_SCSI_CMD_WRITE12;
+}
+
+rt_err_t rt_scsi_request_sense(struct rt_scsi_device *sdev,
+        struct rt_scsi_request_sense_data *out_data);
+
+rt_err_t rt_scsi_test_unit_ready(struct rt_scsi_device *sdev);
+rt_err_t rt_scsi_inquiry(struct rt_scsi_device *sdev,
+        struct rt_scsi_inquiry_data *out_data);
+
+rt_err_t rt_scsi_read_capacity10(struct rt_scsi_device *sdev,
+        struct rt_scsi_read_capacity10_data *out_data);
+rt_err_t rt_scsi_read_capacity16(struct rt_scsi_device *sdev,
+        struct rt_scsi_read_capacity16_data *out_data);
+
+rt_err_t rt_scsi_read10(struct rt_scsi_device *sdev,
+        rt_off_t lba, void *buffer, rt_size_t size);
+rt_err_t rt_scsi_read12(struct rt_scsi_device *sdev,
+        rt_off_t lba, void *buffer, rt_size_t size);
+rt_err_t rt_scsi_read16(struct rt_scsi_device *sdev,
+        rt_off_t lba, void *buffer, rt_size_t size);
+
+rt_err_t rt_scsi_write10(struct rt_scsi_device *sdev,
+        rt_off_t lba, const void *buffer, rt_size_t size);
+rt_err_t rt_scsi_write12(struct rt_scsi_device *sdev,
+        rt_off_t lba, const void *buffer, rt_size_t size);
+rt_err_t rt_scsi_write16(struct rt_scsi_device *sdev,
+        rt_off_t lba, const void *buffer, rt_size_t size);
+
+rt_err_t rt_scsi_synchronize_cache10(struct rt_scsi_device *sdev,
+        rt_off_t lba, rt_size_t size);
+rt_err_t rt_scsi_synchronize_cache16(struct rt_scsi_device *sdev,
+        rt_off_t lba, rt_size_t size);
+
+rt_err_t rt_scsi_write_same10(struct rt_scsi_device *sdev,
+        rt_off_t lba, rt_size_t size);
+rt_err_t rt_scsi_write_same16(struct rt_scsi_device *sdev,
+        rt_off_t lba, rt_size_t size);
+
+rt_err_t rt_scsi_mode_select6(struct rt_scsi_device *sdev,
+        rt_uint8_t pf, rt_uint8_t sp, void *buffer, rt_size_t size,
+        struct rt_scsi_mode_select_data *data);
+rt_err_t rt_scsi_mode_select10(struct rt_scsi_device *sdev,
+        rt_uint8_t pf, rt_uint8_t sp, void *buffer, rt_size_t size,
+        struct rt_scsi_mode_select_data *data);
+
+rt_err_t rt_scsi_mode_sense6(struct rt_scsi_device *sdev,
+        rt_uint8_t dbd, rt_uint8_t modepage, rt_uint8_t subpage, void *buffer, rt_size_t size,
+        struct rt_scsi_mode_select_data *data);
+rt_err_t rt_scsi_mode_sense10(struct rt_scsi_device *sdev,
+        rt_uint8_t dbd, rt_uint8_t modepage, rt_uint8_t subpage, void *buffer, rt_size_t size,
+        struct rt_scsi_mode_select_data *data);
+
+#endif /* __SCSI_H__ */
diff --git a/components/drivers/include/rtdevice.h b/components/drivers/include/rtdevice.h
index f6a3cfb9cf..19e9de0467 100644
--- a/components/drivers/include/rtdevice.h
+++ b/components/drivers/include/rtdevice.h
@@ -67,6 +67,10 @@ extern "C" {
 #include "drivers/pic.h"
 #endif
 
+#ifdef RT_USING_SCSI
+#include "drivers/scsi.h"
+#endif
+
 #ifdef RT_MFD_SYSCON
 #include "drivers/syscon.h"
 #endif
diff --git a/components/drivers/scsi/Kconfig b/components/drivers/scsi/Kconfig
new file mode 100644
index 0000000000..ba221880c7
--- /dev/null
+++ b/components/drivers/scsi/Kconfig
@@ -0,0 +1,20 @@
+menuconfig RT_USING_SCSI
+    bool "Using Small Computer System Interface (SCSI)"
+    depends on RT_USING_DM
+    default n
+
+config RT_SCSI_SD
+    bool "SD device on SCSI"
+    depends on RT_USING_SCSI
+    depends on RT_USING_BLK
+    default y
+
+config RT_SCSI_CDROM
+    bool "CD-ROM device on SCSI"
+    depends on RT_USING_SCSI
+    depends on RT_USING_BLK
+    default y
+
+if RT_USING_SCSI
+    osource "$(SOC_DM_SCSI_DIR)/Kconfig"
+endif
diff --git a/components/drivers/scsi/SConscript b/components/drivers/scsi/SConscript
new file mode 100644
index 0000000000..328d929484
--- /dev/null
+++ b/components/drivers/scsi/SConscript
@@ -0,0 +1,21 @@
+from building import *
+
+group = []
+
+if not GetDepend(['RT_USING_SCSI']):
+    Return('group')
+
+cwd = GetCurrentDir()
+CPPPATH = [cwd + '/../include']
+
+src = ['scsi.c']
+
+if GetDepend(['RT_SCSI_SD']):
+    src += ['scsi_sd.c']
+
+if GetDepend(['RT_SCSI_CDROM']):
+    src += ['scsi_cdrom.c']
+
+group = DefineGroup('DeviceDrivers', src, depend = [''], CPPPATH = CPPPATH)
+
+Return('group')
diff --git a/components/drivers/scsi/scsi.c b/components/drivers/scsi/scsi.c
new file mode 100644
index 0000000000..f5ac977f8f
--- /dev/null
+++ b/components/drivers/scsi/scsi.c
@@ -0,0 +1,669 @@
+/*
+ * Copyright (c) 2006-2023, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2023-02-25     GuEe-GUI     the first version
+ */
+
+#include <rthw.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#define DBG_TAG "rtdm.scsi"
+#define DBG_LVL DBG_INFO
+#include <rtdbg.h>
+
+/*
+ * Since SCSI is used for storage (almost),
+ * we do not want to implement SCSI as a system DM bus.
+ */
+struct scsi_driver
+{
+    rt_err_t (*probe)(struct rt_scsi_device *sdev);
+    rt_err_t (*remove)(struct rt_scsi_device *sdev);
+};
+
+extern rt_err_t scsi_sd_probe(struct rt_scsi_device *sdev);
+extern rt_err_t scsi_sd_remove(struct rt_scsi_device *sdev);
+
+extern rt_err_t scsi_cdrom_probe(struct rt_scsi_device *sdev);
+extern rt_err_t scsi_cdrom_remove(struct rt_scsi_device *sdev);
+
+static struct scsi_driver driver_table[SCSI_DEVICE_TYPE_MAX] =
+{
+#ifdef RT_SCSI_SD
+    [SCSI_DEVICE_TYPE_DIRECT] =
+    {
+        .probe = scsi_sd_probe,
+        .remove = scsi_sd_remove,
+    },
+#endif /* RT_SCSI_SD */
+#ifdef RT_SCSI_CDROM
+    [SCSI_DEVICE_TYPE_CDROM] =
+    {
+        .probe = scsi_cdrom_probe,
+        .remove = scsi_cdrom_remove,
+    },
+#endif /* RT_SCSI_CDROM */
+};
+
+static rt_err_t scsi_device_setup(struct rt_scsi_device *sdev)
+{
+    rt_err_t err;
+    rt_tick_t timeout;
+
+    if (sdev->host->ops->reset)
+    {
+        if ((err = sdev->host->ops->reset(sdev)))
+        {
+            return err;
+        }
+    }
+
+    if (!driver_table[sdev->devtype].probe)
+    {
+        LOG_E("Device type %x is not supported", sdev->devtype);
+
+        return -RT_ENOSYS;
+    }
+
+    timeout = rt_tick_from_millisecond(5000);
+    timeout += rt_tick_get();
+
+    while ((err = rt_scsi_test_unit_ready(sdev)))
+    {
+        if (rt_tick_get() >= timeout)
+        {
+            return -RT_ETIMEOUT;
+        }
+    }
+
+    return driver_table[sdev->devtype].probe(sdev);
+}
+
+rt_err_t rt_scsi_host_register(struct rt_scsi_host *scsi)
+{
+    struct rt_scsi_device tmp_sdev, *sdev;
+
+    if (!scsi || !scsi->dev || !scsi->ops)
+    {
+        return -RT_EINVAL;
+    }
+
+    if (!scsi->max_id || !scsi->max_lun)
+    {
+        return -RT_EINVAL;
+    }
+
+    rt_list_init(&scsi->lun_nodes);
+
+    rt_memset(&tmp_sdev, 0, sizeof(tmp_sdev));
+    tmp_sdev.host = scsi;
+
+    for (rt_size_t id = 0; id < scsi->max_id; ++id)
+    {
+        for (rt_size_t lun = 0; lun < scsi->max_lun; ++lun)
+        {
+            tmp_sdev.id = id;
+            tmp_sdev.lun = lun;
+
+            if (rt_scsi_inquiry(&tmp_sdev, RT_NULL))
+            {
+                continue;
+            }
+
+            if (tmp_sdev.devtype >= SCSI_DEVICE_TYPE_MAX)
+            {
+                /*
+                 * This might seem odd, but we're only aiming to
+                 * support simple SCSI.
+                 * If devices appear on the bus out of order,
+                 * we won't perform additional scans.
+                 */
+                scsi->max_id = id;
+                scsi->max_lun = lun;
+
+                LOG_D("Scan is end of ID: %u LUN: %u", id, lun);
+                break;
+            }
+
+            if (!(sdev = rt_malloc(sizeof(*sdev))))
+            {
+                if (!rt_list_isempty(&scsi->lun_nodes))
+                {
+                    LOG_E("No memory to create device ID: %u, LUN: %u", id, lun);
+
+                    return RT_EOK;
+                }
+
+                return -RT_ENOMEM;
+            }
+
+            rt_memcpy(sdev, &tmp_sdev, sizeof(*sdev));
+            rt_list_init(&sdev->list);
+
+            if (scsi_device_setup(sdev))
+            {
+                rt_free(sdev);
+                continue;
+            }
+
+            rt_list_insert_before(&scsi->lun_nodes, &sdev->list);
+        }
+    }
+
+    return rt_list_isempty(&scsi->lun_nodes) ? -RT_EEMPTY : RT_EOK;
+}
+
+rt_err_t rt_scsi_host_unregister(struct rt_scsi_host *scsi)
+{
+    struct rt_scsi_device *sdev, *next_sdev;
+
+    if (!scsi)
+    {
+        return -RT_EINVAL;
+    }
+
+    rt_list_for_each_entry_safe(sdev, next_sdev, &scsi->lun_nodes, list)
+    {
+        rt_list_remove(&sdev->list);
+
+        if (sdev->host->ops->reset)
+        {
+            sdev->host->ops->reset(sdev);
+        }
+
+        if (!driver_table[sdev->devtype].remove)
+        {
+            driver_table[sdev->devtype].remove(sdev);
+        }
+
+        rt_free(sdev);
+    }
+
+    return RT_EOK;
+}
+
+rt_inline rt_err_t scsi_transfer(struct rt_scsi_device *sdev, struct rt_scsi_cmd *cmd)
+{
+    return sdev->host->ops->transfer(sdev, cmd);
+}
+
+rt_err_t rt_scsi_request_sense(struct rt_scsi_device *sdev,
+        struct rt_scsi_request_sense_data *out_data)
+{
+    rt_err_t err;
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.request_sense.opcode = RT_SCSI_CMD_REQUEST_SENSE;
+    cmd.op.request_sense.config = 0;
+    cmd.op.request_sense.alloc_length = 0x12;
+    cmd.op.request_sense.control = 0;
+    cmd.op_size = sizeof(cmd.op.request_sense);
+    cmd.data.ptr = &cmd.data.request_sense;
+    cmd.data.size = sizeof(cmd.data.request_sense);
+
+    err = scsi_transfer(sdev, &cmd);
+
+    if (!err && out_data)
+    {
+        rt_memcpy(out_data, &cmd.data.request_sense, sizeof(*out_data));
+    }
+
+    return err;
+}
+
+rt_err_t rt_scsi_test_unit_ready(struct rt_scsi_device *sdev)
+{
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.test_unit_ready.opcode = RT_SCSI_CMD_TEST_UNIT_READY;
+    cmd.op.test_unit_ready.control = 0;
+    cmd.op_size = sizeof(cmd.op.test_unit_ready);
+
+    return scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+}
+
+rt_err_t rt_scsi_inquiry(struct rt_scsi_device *sdev,
+        struct rt_scsi_inquiry_data *out_data)
+{
+    rt_err_t err;
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.inquiry.opcode = RT_SCSI_CMD_INQUIRY;
+    cmd.op.inquiry.config = 0;
+    cmd.op.inquiry.page = 0;
+    cmd.op.inquiry.alloc_length = 0x24;
+    cmd.op.inquiry.control = 0;
+    cmd.op_size = sizeof(cmd.op.inquiry);
+    cmd.data.ptr = &cmd.data.inquiry;
+    cmd.data.size = sizeof(cmd.data.inquiry);
+
+    err = scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+
+    if (!err)
+    {
+        sdev->devtype = cmd.data.inquiry.devtype & RT_SCSI_DEVTYPE_MASK;
+        sdev->removable = cmd.data.inquiry.rmb >> RT_SCSI_REMOVABLE_BIT;
+
+        if (out_data)
+        {
+            rt_memcpy(out_data, &cmd.data.inquiry, sizeof(*out_data));
+        }
+    }
+
+    return err;
+}
+
+rt_err_t rt_scsi_read_capacity10(struct rt_scsi_device *sdev,
+        struct rt_scsi_read_capacity10_data *out_data)
+{
+    rt_err_t err;
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.read_capacity10.opcode = RT_SCSI_CMD_READ_CAPACITY10;
+    cmd.op.read_capacity10.config = 0;
+    cmd.op.read_capacity10.logical_block_addr = 0;
+    cmd.op.read_capacity10.pmi = 0;
+    cmd.op.read_capacity10.control = 0;
+    cmd.op_size = sizeof(cmd.op.read_capacity10);
+    cmd.data.ptr = &cmd.data.read_capacity10;
+    cmd.data.size = sizeof(cmd.data.read_capacity10);
+
+    err = scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+
+    if (!err)
+    {
+        sdev->last_block = rt_be32_to_cpu(cmd.data.read_capacity10.last_block);
+        sdev->block_size = rt_be32_to_cpu(cmd.data.read_capacity10.block_size);
+
+        if (out_data)
+        {
+            rt_memcpy(out_data, &cmd.data.read_capacity10, sizeof(*out_data));
+        }
+    }
+
+    return err;
+}
+
+rt_err_t rt_scsi_read_capacity16(struct rt_scsi_device *sdev,
+        struct rt_scsi_read_capacity16_data *out_data)
+{
+    rt_err_t err;
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.read_capacity16.opcode = RT_SCSI_CMD_READ_CAPACITY16;
+    cmd.op.read_capacity16.config = 0x10;
+    cmd.op.read_capacity16.logical_block_addr = 0;
+    cmd.op.read_capacity16.alloc_len = rt_cpu_to_be32(sizeof(cmd.data.read_capacity16));
+    cmd.op.read_capacity16.pmi = 0;
+    cmd.op.read_capacity16.control = 0;
+    cmd.op_size = sizeof(cmd.op.read_capacity16);
+    cmd.data.ptr = &cmd.data.read_capacity16;
+    cmd.data.size = sizeof(cmd.data.read_capacity16);
+
+    err = scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+
+    if (!err)
+    {
+        sdev->last_block = rt_be64_to_cpu(cmd.data.read_capacity16.last_block);
+        sdev->block_size = rt_be32_to_cpu(cmd.data.read_capacity16.block_size);
+
+        if (out_data)
+        {
+            rt_memcpy(out_data, &cmd.data.read_capacity16, sizeof(*out_data));
+        }
+    }
+
+    return err;
+}
+
+rt_err_t rt_scsi_read10(struct rt_scsi_device *sdev,
+        rt_off_t lba, void *buffer, rt_size_t size)
+{
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.read10.opcode = RT_SCSI_CMD_READ10;
+    cmd.op.read10.config = 0;
+    cmd.op.read10.lba = rt_cpu_to_be32(lba);
+    cmd.op.read10.size = rt_cpu_to_be16(size);
+    cmd.op_size = sizeof(cmd.op.read10);
+    cmd.data.ptr = buffer;
+    cmd.data.size = size * sdev->block_size;
+
+    return scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+}
+
+rt_err_t rt_scsi_read12(struct rt_scsi_device *sdev,
+        rt_off_t lba, void *buffer, rt_size_t size)
+{
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.read12.opcode = RT_SCSI_CMD_READ12;
+    cmd.op.read12.config = 0;
+    cmd.op.read12.lba = rt_cpu_to_be32(lba);
+    cmd.op.read12.size = rt_cpu_to_be32(size);
+    cmd.op.read12.control = 0;
+    cmd.op_size = sizeof(cmd.op.read12);
+    cmd.data.ptr = buffer;
+    cmd.data.size = size * sdev->block_size;
+
+    return scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+}
+
+rt_err_t rt_scsi_read16(struct rt_scsi_device *sdev,
+        rt_off_t lba, void *buffer, rt_size_t size)
+{
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.read16.opcode = RT_SCSI_CMD_READ16;
+    cmd.op.read16.config = 0;
+    cmd.op.read16.lba = rt_cpu_to_be64(lba);
+    cmd.op.read16.size = rt_cpu_to_be32(size);
+    cmd.op.read16.control = 0;
+    cmd.op_size = sizeof(cmd.op.read16);
+    cmd.data.ptr = buffer;
+    cmd.data.size = size * sdev->block_size;
+
+    return scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+}
+
+rt_err_t rt_scsi_write10(struct rt_scsi_device *sdev,
+        rt_off_t lba, const void *buffer, rt_size_t size)
+{
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.write10.opcode = RT_SCSI_CMD_WRITE10;
+    cmd.op.write10.config = 0;
+    cmd.op.write10.lba = rt_cpu_to_be32(lba);
+    cmd.op.write10.size = rt_cpu_to_be16(size);
+    cmd.op_size = sizeof(cmd.op.write10);
+    cmd.data.ptr = (void *)buffer;
+    cmd.data.size = size * sdev->block_size;
+
+    return scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+}
+
+rt_err_t rt_scsi_write12(struct rt_scsi_device *sdev,
+        rt_off_t lba, const void *buffer, rt_size_t size)
+{
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.write12.opcode = RT_SCSI_CMD_WRITE12;
+    cmd.op.write12.config = 0;
+    cmd.op.write12.lba = rt_cpu_to_be32(lba);
+    cmd.op.write12.size = rt_cpu_to_be32(size);
+    cmd.op.write12.control = 0;
+    cmd.op_size = sizeof(cmd.op.write12);
+    cmd.data.ptr = (void *)buffer;
+    cmd.data.size = size * sdev->block_size;
+
+    return scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+}
+
+rt_err_t rt_scsi_write16(struct rt_scsi_device *sdev,
+        rt_off_t lba, const void *buffer, rt_size_t size)
+{
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.write16.opcode = RT_SCSI_CMD_WRITE16;
+    cmd.op.write16.config = 0;
+    cmd.op.write16.lba = rt_cpu_to_be64(lba);
+    cmd.op.write16.size = rt_cpu_to_be32(size);
+    cmd.op.write16.control = 0;
+    cmd.op_size = sizeof(cmd.op.write16);
+    cmd.data.ptr = (void *)buffer;
+    cmd.data.size = size * sdev->block_size;
+
+    return scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+}
+
+rt_err_t rt_scsi_synchronize_cache10(struct rt_scsi_device *sdev,
+        rt_off_t lba, rt_size_t size)
+{
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.synchronize_cache10.opcode = RT_SCSI_CMD_SYNCHRONIZE_CACHE10;
+    cmd.op.synchronize_cache10.config = 0;
+    cmd.op.synchronize_cache10.lba = rt_cpu_to_be32(lba);
+    cmd.op.synchronize_cache10.size = rt_cpu_to_be16(size);
+    cmd.op.synchronize_cache10.control = 0;
+    cmd.op_size = sizeof(cmd.op.synchronize_cache10);
+
+    return scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+}
+
+rt_err_t rt_scsi_synchronize_cache16(struct rt_scsi_device *sdev,
+        rt_off_t lba, rt_size_t size)
+{
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.synchronize_cache16.opcode = RT_SCSI_CMD_SYNCHRONIZE_CACHE16;
+    cmd.op.synchronize_cache16.config = 0;
+    cmd.op.synchronize_cache16.lba = rt_cpu_to_be64(lba);
+    cmd.op.synchronize_cache16.size = rt_cpu_to_be32(size);
+    cmd.op.synchronize_cache16.control = 0;
+    cmd.op_size = sizeof(cmd.op.synchronize_cache16);
+
+    return scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+}
+
+rt_err_t rt_scsi_write_same10(struct rt_scsi_device *sdev,
+        rt_off_t lba, rt_size_t size)
+{
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.write_same10.opcode = RT_SCSI_CMD_WRITE_SAME10;
+    cmd.op.write_same10.config = RT_BIT(RT_SCSI_UNMAP_SHIFT);
+    cmd.op.write_same10.lba = rt_cpu_to_be32(lba);
+    cmd.op.write_same10.size = rt_cpu_to_be16(size);
+    cmd.op.write_same10.control = 0;
+    cmd.op_size = sizeof(cmd.op.write_same10);
+
+    return scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+}
+
+rt_err_t rt_scsi_write_same16(struct rt_scsi_device *sdev,
+        rt_off_t lba, rt_size_t size)
+{
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.write_same16.opcode = RT_SCSI_CMD_WRITE_SAME16;
+    cmd.op.write_same16.config = RT_BIT(RT_SCSI_UNMAP_SHIFT);
+    cmd.op.write_same16.lba = rt_cpu_to_be64(lba);
+    cmd.op.write_same16.size = rt_cpu_to_be32(size);
+    cmd.op.write_same16.control = 0;
+    cmd.op_size = sizeof(cmd.op.write_same16);
+
+    return scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+}
+
+rt_err_t rt_scsi_mode_select6(struct rt_scsi_device *sdev,
+        rt_uint8_t pf, rt_uint8_t sp, void *buffer, rt_size_t size,
+        struct rt_scsi_mode_select_data *data)
+{
+    rt_err_t err;
+    rt_uint8_t *real_buffer;
+    struct rt_scsi_cmd cmd;
+
+    real_buffer = rt_malloc(4 + size);
+
+    if (!real_buffer)
+    {
+        return -RT_ENOMEM;
+    }
+
+    rt_memcpy(real_buffer + 4, buffer, size);
+    size += 4;
+    real_buffer[0] = 0;
+    real_buffer[1] = data->medium_type;
+    real_buffer[2] = data->device_specific;
+    real_buffer[3] = data->block_descriptor_length;
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.mode_select6.opcode = RT_SCSI_CMD_MODE_SELECT;
+    cmd.op.mode_select6.config = pf ? RT_BIT(RT_SCSI_PF_SHIFT) : 0;
+    cmd.op.mode_select6.config |= sp ? RT_BIT(RT_SCSI_SP_SHIFT) : 0;
+    cmd.op.mode_select6.param_list_len = (rt_uint8_t)size;
+    cmd.op.mode_select6.control = 0;
+    cmd.op_size = sizeof(cmd.op.mode_select6);
+    cmd.data.ptr = real_buffer;
+    cmd.data.size = size;
+
+    err = scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+
+    rt_free(real_buffer);
+
+    return err;
+}
+
+rt_err_t rt_scsi_mode_select10(struct rt_scsi_device *sdev,
+        rt_uint8_t pf, rt_uint8_t sp, void *buffer, rt_size_t size,
+        struct rt_scsi_mode_select_data *data)
+{
+    rt_err_t err;
+    rt_uint8_t *real_buffer;
+    struct rt_scsi_cmd cmd;
+
+    real_buffer = rt_malloc(8 + size);
+
+    if (!real_buffer)
+    {
+        return -RT_ENOMEM;
+    }
+
+    rt_memcpy(real_buffer + 8, buffer, size);
+    size += 8;
+    real_buffer[0] = 0;
+    real_buffer[1] = 0;
+    real_buffer[2] = data->medium_type;
+    real_buffer[3] = data->device_specific;
+    real_buffer[4] = data->longlba ? 0x01 : 0;
+    real_buffer[5] = 0;
+    real_buffer[6] = rt_cpu_to_be16(data->block_descriptor_length);
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.mode_select10.opcode = RT_SCSI_CMD_MODE_SELECT10;
+    cmd.op.mode_select10.config = pf ? RT_BIT(RT_SCSI_PF_SHIFT) : 0;
+    cmd.op.mode_select10.config |= sp ? RT_BIT(RT_SCSI_SP_SHIFT) : 0;
+    cmd.op.mode_select10.param_list_len = rt_cpu_to_be16(size);
+    cmd.op.mode_select10.control = 0;
+    cmd.op_size = sizeof(cmd.op.mode_select10);
+    cmd.data.ptr = real_buffer;
+    cmd.data.size = size;
+
+    err = scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+
+    rt_free(real_buffer);
+
+    return err;
+}
+
+static void scsi_mode_sense_fill(struct rt_scsi_mode_select_data *data,
+        rt_uint8_t modepage, rt_uint8_t *buffer, rt_bool_t use10)
+{
+    if (buffer[0] == 0x86 && buffer[1] == 0x0b && (modepage == 6 || modepage == 8))
+    {
+        data->header_length = 0;
+        data->length = 13;
+        data->medium_type = 0;
+        data->device_specific = 0;
+        data->longlba = 0;
+        data->block_descriptor_length = 0;
+    }
+    else if (use10)
+    {
+        data->length = rt_be16_to_cpu(buffer[0]) + 2;
+        data->medium_type = buffer[2];
+        data->device_specific = buffer[3];
+        data->longlba = buffer[4] & 0x01;
+        data->block_descriptor_length = rt_be16_to_cpu(buffer[6]);
+    }
+    else
+    {
+        data->length = buffer[0] + 1;
+        data->medium_type = buffer[1];
+        data->device_specific = buffer[2];
+        data->block_descriptor_length = buffer[3];
+    }
+}
+
+rt_err_t rt_scsi_mode_sense6(struct rt_scsi_device *sdev,
+        rt_uint8_t dbd, rt_uint8_t modepage, rt_uint8_t subpage, void *buffer, rt_size_t size,
+        struct rt_scsi_mode_select_data *data)
+{
+    rt_err_t err;
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(buffer, 0, size);
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.mode_sense6.opcode = RT_SCSI_CMD_MODE_SENSE;
+    cmd.op.mode_sense6.config = dbd & 0x18;
+    cmd.op.mode_sense6.page_control_code = modepage;
+    cmd.op.mode_sense6.subpage_code = subpage;
+    cmd.op.mode_sense6.allocation_len = (rt_uint8_t)size;
+    cmd.op.mode_sense6.control = 0;
+    cmd.op_size = sizeof(cmd.op.mode_sense6);
+    cmd.data.ptr = buffer;
+    cmd.data.size = size;
+
+    err = scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+
+    if (!err)
+    {
+        data->header_length = 4;
+        scsi_mode_sense_fill(data, modepage, buffer, RT_FALSE);
+    }
+
+    return err;
+}
+
+rt_err_t rt_scsi_mode_sense10(struct rt_scsi_device *sdev,
+        rt_uint8_t dbd, rt_uint8_t modepage, rt_uint8_t subpage, void *buffer, rt_size_t size,
+        struct rt_scsi_mode_select_data *data)
+{
+    rt_err_t err;
+    struct rt_scsi_cmd cmd;
+
+    rt_memset(buffer, 0, size);
+
+    rt_memset(&cmd, 0, sizeof(cmd));
+    cmd.op.mode_sense6.opcode = RT_SCSI_CMD_MODE_SENSE10;
+    cmd.op.mode_sense6.config = dbd & 0x18;
+    cmd.op.mode_sense6.page_control_code = modepage;
+    cmd.op.mode_sense6.subpage_code = subpage;
+    cmd.op.mode_sense6.allocation_len = rt_cpu_to_be16(size);
+    cmd.op.mode_sense6.control = 0;
+    cmd.op_size = sizeof(cmd.op.mode_sense6);
+    cmd.data.ptr = buffer;
+    cmd.data.size = size;
+
+    err = scsi_transfer(sdev, &cmd) ? : rt_scsi_request_sense(sdev, RT_NULL);
+
+    if (!err)
+    {
+        data->header_length = 8;
+        scsi_mode_sense_fill(data, modepage, buffer, RT_FALSE);
+    }
+
+    return err;
+}
diff --git a/components/drivers/scsi/scsi_cdrom.c b/components/drivers/scsi/scsi_cdrom.c
new file mode 100644
index 0000000000..93608d1e37
--- /dev/null
+++ b/components/drivers/scsi/scsi_cdrom.c
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2006-2023, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2023-02-25     GuEe-GUI     the first version
+ */
+
+#include <rthw.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#define DBG_TAG "scsi.blk"
+#define DBG_LVL DBG_INFO
+#include <rtdbg.h>
+
+struct scsi_cdrom
+{
+    struct rt_blk_disk parent;
+    struct rt_scsi_device *sdev;
+
+    int cdrom_id;
+    struct rt_device_blk_geometry geometry;
+};
+
+#define raw_to_scsi_cdrom(raw) rt_container_of(raw, struct scsi_cdrom, parent)
+
+static struct rt_dm_ida cdrom_ida = RT_DM_IDA_INIT(CUSTOM);
+static struct rt_dm_ida scsi_cdrom_ida = RT_DM_IDA_INIT(SCSI_CDROM);
+
+static rt_ssize_t scsi_cdrom_read(struct rt_blk_disk *disk, rt_off_t sector,
+        void *buffer, rt_size_t sector_count)
+{
+    rt_err_t err;
+    struct scsi_cdrom *scdrom = raw_to_scsi_cdrom(disk);
+    struct rt_scsi_device *sdev = scdrom->sdev;
+
+    sector_count &= RT_UINT32_MAX;
+
+    if (sector >> 32)
+    {
+        err = rt_scsi_read16(sdev, sector, buffer, sector_count);
+    }
+    else
+    {
+        err = rt_scsi_read12(sdev, sector, buffer, sector_count);
+    }
+
+    return !err ? sector_count : (rt_ssize_t)err;
+}
+
+static rt_err_t scsi_cdrom_getgeome(struct rt_blk_disk *disk,
+        struct rt_device_blk_geometry *geometry)
+{
+    struct scsi_cdrom *scdrom = raw_to_scsi_cdrom(disk);
+
+    rt_memcpy(geometry, &scdrom->geometry, sizeof(scdrom->geometry));
+
+    return RT_EOK;
+}
+
+static const struct rt_blk_disk_ops scsi_cdrom_ops =
+{
+    .read = scsi_cdrom_read,
+    .getgeome = scsi_cdrom_getgeome,
+};
+
+rt_err_t scsi_cdrom_probe(struct rt_scsi_device *sdev)
+{
+    rt_err_t err;
+    union
+    {
+        struct rt_scsi_read_capacity10_data capacity10;
+        struct rt_scsi_read_capacity16_data capacity16;
+    } data;
+    struct scsi_cdrom *scdrom = rt_calloc(1, sizeof(*scdrom));
+
+    if (!scdrom)
+    {
+        return -RT_ENOMEM;
+    }
+
+    if ((scdrom->cdrom_id = rt_dm_ida_alloc(&cdrom_ida)) < 0)
+    {
+        return -RT_EFULL;
+    }
+
+    sdev->priv = scdrom;
+    scdrom->sdev = sdev;
+    scdrom->parent.ida = &scsi_cdrom_ida;
+    scdrom->parent.read_only = RT_TRUE;
+    scdrom->parent.parallel_io = RT_FALSE;
+    scdrom->parent.ops = &scsi_cdrom_ops;
+    scdrom->parent.max_partitions = RT_BLK_PARTITION_NONE;
+
+    if ((err = rt_scsi_read_capacity10(sdev, &data.capacity10)))
+    {
+        goto _fail;
+    }
+    if (data.capacity10.last_block == 0xffffffff)
+    {
+        if ((err = rt_scsi_read_capacity16(sdev, &data.capacity16)))
+        {
+            goto _fail;
+        }
+    }
+    scdrom->geometry.bytes_per_sector = sdev->block_size;
+    scdrom->geometry.block_size = sdev->block_size;
+    scdrom->geometry.sector_count = sdev->last_block + 1;
+
+    rt_dm_dev_set_name(&scdrom->parent.parent, "cdrom%u", scdrom->cdrom_id);
+
+    if ((err = rt_hw_blk_disk_register(&scdrom->parent)))
+    {
+        goto _fail;
+    }
+
+    return RT_EOK;
+
+_fail:
+    rt_dm_ida_free(&cdrom_ida, scdrom->cdrom_id);
+    rt_free(scdrom);
+
+    return err;
+}
+
+rt_err_t scsi_cdrom_remove(struct rt_scsi_device *sdev)
+{
+    struct scsi_cdrom *scdrom = sdev->priv;
+
+    rt_dm_ida_free(&cdrom_ida, scdrom->cdrom_id);
+
+    return rt_hw_blk_disk_unregister(&scdrom->parent);
+}
diff --git a/components/drivers/scsi/scsi_sd.c b/components/drivers/scsi/scsi_sd.c
new file mode 100644
index 0000000000..cc509a7215
--- /dev/null
+++ b/components/drivers/scsi/scsi_sd.c
@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) 2006-2023, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2023-02-25     GuEe-GUI     the first version
+ */
+
+#include <rthw.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#define DBG_TAG "scsi.blk"
+#define DBG_LVL DBG_INFO
+#include <rtdbg.h>
+
+#include "../block/blk_dev.h"
+
+struct scsi_sd
+{
+    struct rt_blk_disk parent;
+    struct rt_scsi_device *sdev;
+
+    int sd_id;
+    rt_bool_t use16;
+    struct rt_device_blk_geometry geometry;
+};
+
+#define raw_to_scsi_sd(raw) rt_container_of(raw, struct scsi_sd, parent)
+
+static struct rt_dm_ida sd_ida = RT_DM_IDA_INIT(CUSTOM);
+static struct rt_dm_ida scsi_sd_ida = RT_DM_IDA_INIT(SCSI_SD);
+
+static rt_ssize_t scsi_sd_read(struct rt_blk_disk *disk, rt_off_t sector,
+        void *buffer, rt_size_t sector_count)
+{
+    rt_err_t err;
+    struct scsi_sd *ssd = raw_to_scsi_sd(disk);
+    struct rt_scsi_device *sdev = ssd->sdev;
+
+    sector_count &= RT_UINT32_MAX;
+
+    if (sector >> 32)
+    {
+        err = rt_scsi_read16(sdev, sector, buffer, sector_count);
+    }
+    else
+    {
+        err = rt_scsi_read10(sdev, sector, buffer, sector_count);
+    }
+
+    return !err ? sector_count : (rt_ssize_t)err;
+}
+
+static rt_ssize_t scsi_sd_write(struct rt_blk_disk *disk, rt_off_t sector,
+        const void *buffer, rt_size_t sector_count)
+{
+    rt_err_t err;
+    struct scsi_sd *ssd = raw_to_scsi_sd(disk);
+    struct rt_scsi_device *sdev = ssd->sdev;
+
+    sector_count &= RT_UINT32_MAX;
+
+    if (sector >> 32)
+    {
+        err = rt_scsi_write16(sdev, sector, buffer, sector_count);
+    }
+    else
+    {
+        err = rt_scsi_write10(sdev, sector, buffer, sector_count);
+    }
+
+    return !err ? sector_count : (rt_ssize_t)err;
+}
+
+static rt_err_t scsi_sd_getgeome(struct rt_blk_disk *disk,
+        struct rt_device_blk_geometry *geometry)
+{
+    struct scsi_sd *ssd = raw_to_scsi_sd(disk);
+
+    rt_memcpy(geometry, &ssd->geometry, sizeof(ssd->geometry));
+
+    return RT_EOK;
+}
+
+static rt_err_t scsi_sd_sync(struct rt_blk_disk *disk)
+{
+    rt_err_t err;
+    rt_size_t lba_count;
+    struct scsi_sd *ssd = raw_to_scsi_sd(disk);
+    struct rt_scsi_device *sdev = ssd->sdev;
+
+    lba_count = ssd->geometry.sector_count;
+
+    if (ssd->use16)
+    {
+        err = rt_scsi_synchronize_cache16(sdev, 0, lba_count);
+    }
+    else
+    {
+        err = rt_scsi_synchronize_cache10(sdev, 0, lba_count);
+    }
+
+    return err;
+}
+
+static rt_err_t scsi_sd_erase(struct rt_blk_disk *disk)
+{
+    rt_err_t err;
+    rt_size_t lba_count;
+    struct scsi_sd *ssd = raw_to_scsi_sd(disk);
+    struct rt_scsi_device *sdev = ssd->sdev;
+
+    lba_count = ssd->geometry.sector_count;
+
+    if (ssd->use16)
+    {
+        err = rt_scsi_write_same16(sdev, 0, lba_count);
+    }
+    else
+    {
+        err = rt_scsi_write_same10(sdev, 0, lba_count);
+    }
+
+    return err;
+}
+
+static rt_err_t scsi_sd_autorefresh(struct rt_blk_disk *disk, rt_bool_t is_auto)
+{
+    rt_err_t err;
+    int sp;
+    rt_size_t size;
+    rt_uint8_t buffer[64];
+    rt_uint8_t *buffer_data;
+    rt_bool_t use6 = RT_TRUE;
+    struct scsi_sd *ssd = raw_to_scsi_sd(disk);
+    struct rt_scsi_device *sdev = ssd->sdev;
+    struct rt_scsi_mode_select_data data;
+
+    err = rt_scsi_mode_sense6(sdev, 0x08, 8, 0, buffer, sizeof(buffer), &data);
+
+    if (err && err != -RT_ENOMEM)
+    {
+        use6 = RT_FALSE;
+        err = rt_scsi_mode_sense10(sdev, 0x08, 8, 0, buffer, sizeof(buffer), &data);
+    }
+    if (err)
+    {
+        return err;
+    }
+
+    size = rt_min_t(rt_size_t, sizeof(buffer),
+            data.length - data.header_length - data.block_descriptor_length);
+    buffer_data = buffer + data.header_length + data.block_descriptor_length;
+    buffer_data[2] &= ~0x05;
+    buffer_data[2] |= (!!is_auto) << 2 | (!!is_auto);
+    sp = buffer_data[0] & 0x80 ? 1 : 0;
+    buffer_data[0] &= ~0x80;
+    data.device_specific = 0;
+
+    if (use6)
+    {
+        err = rt_scsi_mode_select6(sdev, 1, sp, buffer_data, size, &data);
+    }
+    else
+    {
+        err = rt_scsi_mode_select10(sdev, 1, sp, buffer_data, size, &data);
+    }
+
+    return err;
+}
+
+static const struct rt_blk_disk_ops scsi_sd_ops =
+{
+    .read = scsi_sd_read,
+    .write = scsi_sd_write,
+    .getgeome = scsi_sd_getgeome,
+    .sync = scsi_sd_sync,
+    .erase = scsi_sd_erase,
+    .autorefresh = scsi_sd_autorefresh,
+};
+
+rt_err_t scsi_sd_probe(struct rt_scsi_device *sdev)
+{
+    rt_err_t err;
+    union
+    {
+        struct rt_scsi_read_capacity10_data capacity10;
+        struct rt_scsi_read_capacity16_data capacity16;
+    } data;
+    struct scsi_sd *ssd = rt_calloc(1, sizeof(*ssd));
+
+    if (!ssd)
+    {
+        return -RT_ENOMEM;
+    }
+
+    if ((ssd->sd_id = rt_dm_ida_alloc(&sd_ida)) < 0)
+    {
+        return -RT_EFULL;
+    }
+
+    sdev->priv = ssd;
+    ssd->sdev = sdev;
+    ssd->parent.ida = &scsi_sd_ida;
+    ssd->parent.parallel_io = RT_FALSE;
+    ssd->parent.ops = &scsi_sd_ops;
+    ssd->parent.max_partitions = RT_BLK_PARTITION_MAX;
+
+    if ((err = rt_scsi_read_capacity10(sdev, &data.capacity10)))
+    {
+        goto _fail;
+    }
+    if (data.capacity10.last_block == 0xffffffff)
+    {
+        if ((err = rt_scsi_read_capacity16(sdev, &data.capacity16)))
+        {
+            goto _fail;
+        }
+        ssd->use16 = RT_TRUE;
+    }
+    ssd->geometry.bytes_per_sector = sdev->block_size;
+    ssd->geometry.block_size = sdev->block_size;
+    ssd->geometry.sector_count = sdev->last_block + 1;
+
+    rt_dm_dev_set_name(&ssd->parent.parent, "sd%c%c", letter_name(ssd->sd_id));
+
+    if ((err = rt_hw_blk_disk_register(&ssd->parent)))
+    {
+        goto _fail;
+    }
+
+    return RT_EOK;
+
+_fail:
+    rt_dm_ida_free(&sd_ida, ssd->sd_id);
+    rt_free(ssd);
+
+    return err;
+}
+
+rt_err_t scsi_sd_remove(struct rt_scsi_device *sdev)
+{
+    struct scsi_sd *ssd = sdev->priv;
+
+    rt_dm_ida_free(&sd_ida, ssd->sd_id);
+
+    return rt_hw_blk_disk_unregister(&ssd->parent);
+}