RTOS/rtems
1
0
Fork 0
forked from Imagelibrary/rtems
Code Pull Requests Activity

2008-08-20 Sebastian Huber <sebastian.huber@embedded-brains.de>

Browse Source 
* libchip/i2c/spi-sd-card.c: Fixed integer conversion warnings.
This commit is contained in:
Joel Sherrill
2008-08-20 17:30:07 +00:00
parent 85bca3f228
commit dccd35192f
2 changed files with 49 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
c/src/ChangeLog
View File

@@ -1,3 +1,7 @@
2008-08-20 Sebastian Huber <sebastian.huber@embedded-brains.de>
* libchip/i2c/spi-sd-card.c: Fixed integer conversion warnings.
2008-08-19 Joel Sherrill <joel.sherrill@OARcorp.com> 2008-08-19 Joel Sherrill <joel.sherrill@OARcorp.com>
* libchip/display/disp_hcms29xx.c: Initialize softc_ptr to NULL. * libchip/display/disp_hcms29xx.c: Initialize softc_ptr to NULL.

86
c/src/libchip/i2c/spi-sd-card.c
View File

@@ -36,26 +36,26 @@
static inline uint16_t sd_card_get_uint16( const uint8_t *s) static inline uint16_t sd_card_get_uint16( const uint8_t *s)
{ {
return ((uint16_t) s [0] << 8) | ((uint16_t) s [1]); return (uint16_t) ((s [0] << 8) | s [1]);
} }
static inline uint32_t sd_card_get_uint32( const uint8_t *s) static inline uint32_t sd_card_get_uint32( const uint8_t *s)
{ {
return ((uint32_t) s [0] << 24) | ((uint32_t) s [1] << 16) | ((uint32_t) s [2] << 8) | ((uint32_t) s [3]); return ((uint32_t) s [0] << 24) | ((uint32_t) s [1] << 16) | ((uint32_t) s [2] << 8) | (uint32_t) s [3];
} }
static inline void sd_card_put_uint16( uint16_t v, uint8_t *s) static inline void sd_card_put_uint16( uint16_t v, uint8_t *s)
{ {
*s++ = v >> 8; *s++ = (uint8_t) (v >> 8);
*s = v; *s = (uint8_t) (v);
} }
static inline void sd_card_put_uint32( uint32_t v, uint8_t *s) static inline void sd_card_put_uint32( uint32_t v, uint8_t *s)
{ {
*s++ = v >> 24; *s++ = (uint8_t) (v >> 24);
*s++ = v >> 16; *s++ = (uint8_t) (v >> 16);
*s++ = v >> 8; *s++ = (uint8_t) (v >> 8);
*s = v; *s = (uint8_t) (v);
} }
/** @} */ /** @} */
@@ -116,7 +116,7 @@ static inline void sd_card_put_uint32( uint32_t v, uint8_t *s)
* @{ * @{
*/ */
#define SD_CARD_COMMAND_SET_COMMAND( c, cmd) (c) [1] = 0x40 + ((cmd) & 0x3f) #define SD_CARD_COMMAND_SET_COMMAND( c, cmd) (c) [1] = (uint8_t) (0x40 + ((cmd) & 0x3f))
#define SD_CARD_COMMAND_SET_ARGUMENT( c, arg) sd_card_put_uint32( (arg), &((c) [2])) #define SD_CARD_COMMAND_SET_ARGUMENT( c, arg) sd_card_put_uint32( (arg), &((c) [2]))
#define SD_CARD_COMMAND_SET_CRC7( c, crc7) ((c) [6] = (crc7) << 1) #define SD_CARD_COMMAND_SET_CRC7( c, crc7) ((c) [6] = (crc7) << 1)
@@ -168,11 +168,11 @@ static inline void sd_card_put_uint32( uint32_t v, uint8_t *s)
#define SD_CARD_CSD_GET_CSD_STRUCTURE( csd) ((csd) [0] >> 6) #define SD_CARD_CSD_GET_CSD_STRUCTURE( csd) ((csd) [0] >> 6)
#define SD_CARD_CSD_GET_SPEC_VERS( csd) (((csd) [0] >> 2) & 0xf) #define SD_CARD_CSD_GET_SPEC_VERS( csd) (((csd) [0] >> 2) & 0xf)
#define SD_CARD_CSD_GET_TAAC( csd) ((csd) [1]) #define SD_CARD_CSD_GET_TAAC( csd) ((csd) [1])
#define SD_CARD_CSD_GET_NSAC( csd) ((csd) [2]) #define SD_CARD_CSD_GET_NSAC( csd) ((uint32_t) (csd) [2])
#define SD_CARD_CSD_GET_TRAN_SPEED( csd) ((csd) [3]) #define SD_CARD_CSD_GET_TRAN_SPEED( csd) ((csd) [3])
#define SD_CARD_CSD_GET_C_SIZE( csd) ((((csd) [6] & 0x3) << 10) + ((csd) [7] << 2) + (((csd) [8] >> 6) & 0x3)) #define SD_CARD_CSD_GET_C_SIZE( csd) ((((uint32_t) (csd) [6] & 0x3) << 10) + ((uint32_t) (csd) [7] << 2) + (((uint32_t) (csd) [8] >> 6) & 0x3))
#define SD_CARD_CSD_GET_C_SIZE_MULT( csd) ((((csd) [9] & 0x3) << 1) + (((csd) [10] >> 7) & 0x1)) #define SD_CARD_CSD_GET_C_SIZE_MULT( csd) ((((csd) [9] & 0x3) << 1) + (((csd) [10] >> 7) & 0x1))
#define SD_CARD_CSD_GET_READ_BLK_LEN( csd) ((csd) [5] & 0xf) #define SD_CARD_CSD_GET_READ_BLK_LEN( csd) ((uint32_t) (csd) [5] & 0xf)
#define SD_CARD_CSD_GET_WRITE_BLK_LEN( csd) ((((csd) [12] & 0x3) << 2) + (((csd) [13] >> 6) & 0x3)) #define SD_CARD_CSD_GET_WRITE_BLK_LEN( csd) ((((csd) [12] & 0x3) << 2) + (((csd) [13] >> 6) & 0x3))
/** @} */ /** @} */
@@ -200,13 +200,13 @@ static inline void sd_card_put_uint32( uint32_t v, uint8_t *s)
static inline uint32_t sd_card_block_number( const uint8_t *csd) static inline uint32_t sd_card_block_number( const uint8_t *csd)
{ {
uint32_t size = SD_CARD_CSD_GET_C_SIZE( csd); uint32_t size = SD_CARD_CSD_GET_C_SIZE( csd);
uint32_t mult = 1 << (SD_CARD_CSD_GET_C_SIZE_MULT( csd) + 2); uint32_t mult = 1U << (SD_CARD_CSD_GET_C_SIZE_MULT( csd) + 2);
return (size + 1) * mult; return (size + 1) * mult;
} }
static inline uint32_t sd_card_capacity( const uint8_t *csd) static inline uint32_t sd_card_capacity( const uint8_t *csd)
{ {
uint32_t block_size = 1 << SD_CARD_CSD_GET_READ_BLK_LEN( csd); uint32_t block_size = 1U << SD_CARD_CSD_GET_READ_BLK_LEN( csd);
return sd_card_block_number( csd) * block_size; return sd_card_block_number( csd) * block_size;
} }
@@ -283,9 +283,9 @@ static inline uint32_t sd_card_access_time( const uint8_t *csd)
static inline uint32_t sd_card_max_access_time( const uint8_t *csd, uint32_t transfer_speed) static inline uint32_t sd_card_max_access_time( const uint8_t *csd, uint32_t transfer_speed)
{ {
uint64_t ac = sd_card_access_time( csd); uint64_t ac = sd_card_access_time( csd);
ac = (ac * (uint64_t) transfer_speed) / 8000000000ULL;
uint32_t n = SD_CARD_CSD_GET_NSAC( csd) * 100; uint32_t n = SD_CARD_CSD_GET_NSAC( csd) * 100;
return n + ac; ac = (ac * transfer_speed) / 8000000000ULL;
return n + (uint32_t) ac;
} }
/** @} */ /** @} */
@@ -330,7 +330,11 @@ static int sd_card_wait( sd_card_driver_entry *e)
static int sd_card_send_command( sd_card_driver_entry *e, uint32_t command, uint32_t argument) static int sd_card_send_command( sd_card_driver_entry *e, uint32_t command, uint32_t argument)
{ {
int rv = 0; int rv = 0;
rtems_libi2c_read_write_t rw = { rd_buf : e->response, wr_buf : e->command, byte_cnt : SD_CARD_COMMAND_SIZE }; rtems_libi2c_read_write_t rw = {
.rd_buf = e->response,
.wr_buf = e->command,
.byte_cnt = SD_CARD_COMMAND_SIZE
};
int r = 0; int r = 0;
SD_CARD_INVALIDATE_RESPONSE_INDEX( e); SD_CARD_INVALIDATE_RESPONSE_INDEX( e);
@@ -594,7 +598,7 @@ static int sd_card_disk_block_read( sd_card_driver_entry *e, rtems_blkdev_reques
/* Single block read */ /* Single block read */
rv = sd_card_send_command( e, SD_CARD_CMD_READ_SINGLE_BLOCK, start_address); rv = sd_card_send_command( e, SD_CARD_CMD_READ_SINGLE_BLOCK, start_address);
CLEANUP_RV( rv, sd_card_disk_block_read_cleanup, "Send: SD_CARD_CMD_READ_SINGLE_BLOCK"); CLEANUP_RV( rv, sd_card_disk_block_read_cleanup, "Send: SD_CARD_CMD_READ_SINGLE_BLOCK");
rv = sd_card_read( e, SD_CARD_START_BLOCK_SINGLE_BLOCK_READ, (uint8_t *) r->bufs [0].buffer, e->block_size); rv = sd_card_read( e, SD_CARD_START_BLOCK_SINGLE_BLOCK_READ, (uint8_t *) r->bufs [0].buffer, (int) e->block_size);
CLEANUP_RV( rv, sd_card_disk_block_read_cleanup, "Read: SD_CARD_CMD_READ_SINGLE_BLOCK"); CLEANUP_RV( rv, sd_card_disk_block_read_cleanup, "Read: SD_CARD_CMD_READ_SINGLE_BLOCK");
} else { } else {
/* Start multiple block read */ /* Start multiple block read */
@@ -611,7 +615,7 @@ static int sd_card_disk_block_read( sd_card_driver_entry *e, rtems_blkdev_reques
DEBUG_PRINT( "[%02u]: buffer = 0x%08x, size = %u\n", i, r->bufs [i].buffer, r->bufs [i].length); DEBUG_PRINT( "[%02u]: buffer = 0x%08x, size = %u\n", i, r->bufs [i].buffer, r->bufs [i].length);
#endif /* DEBUG */ #endif /* DEBUG */
rv = sd_card_read( e, SD_CARD_START_BLOCK_MULTIPLE_BLOCK_READ, (uint8_t *) r->bufs [i].buffer, e->block_size); rv = sd_card_read( e, SD_CARD_START_BLOCK_MULTIPLE_BLOCK_READ, (uint8_t *) r->bufs [i].buffer, (int) e->block_size);
CLEANUP_RV( rv, sd_card_disk_block_read_stop_cleanup, "Read block"); CLEANUP_RV( rv, sd_card_disk_block_read_stop_cleanup, "Read block");
} }
@@ -681,7 +685,7 @@ static int sd_card_disk_block_write( sd_card_driver_entry *e, rtems_blkdev_reque
/* Single block write */ /* Single block write */
rv = sd_card_send_command( e, SD_CARD_CMD_WRITE_BLOCK, start_address); rv = sd_card_send_command( e, SD_CARD_CMD_WRITE_BLOCK, start_address);
CLEANUP_RV( rv, sd_card_disk_block_write_cleanup, "Send: SD_CARD_CMD_WRITE_BLOCK"); CLEANUP_RV( rv, sd_card_disk_block_write_cleanup, "Send: SD_CARD_CMD_WRITE_BLOCK");
rv = sd_card_write( e, SD_CARD_START_BLOCK_SINGLE_BLOCK_WRITE, (uint8_t *) r->bufs [0].buffer, e->block_size); rv = sd_card_write( e, SD_CARD_START_BLOCK_SINGLE_BLOCK_WRITE, (uint8_t *) r->bufs [0].buffer, (int) e->block_size);
CLEANUP_RV( rv, sd_card_disk_block_write_cleanup, "Write: SD_CARD_CMD_WRITE_BLOCK"); CLEANUP_RV( rv, sd_card_disk_block_write_cleanup, "Write: SD_CARD_CMD_WRITE_BLOCK");
} else { } else {
/* Start multiple block write */ /* Start multiple block write */
@@ -698,7 +702,7 @@ static int sd_card_disk_block_write( sd_card_driver_entry *e, rtems_blkdev_reque
DEBUG_PRINT( "[%02u]: buffer = 0x%08x, size = %u\n", i, r->bufs [i].buffer, r->bufs [i].length); DEBUG_PRINT( "[%02u]: buffer = 0x%08x, size = %u\n", i, r->bufs [i].buffer, r->bufs [i].length);
#endif /* DEBUG */ #endif /* DEBUG */
rv = sd_card_write( e, SD_CARD_START_BLOCK_MULTIPLE_BLOCK_WRITE, (uint8_t *) r->bufs [i].buffer, e->block_size); rv = sd_card_write( e, SD_CARD_START_BLOCK_MULTIPLE_BLOCK_WRITE, (uint8_t *) r->bufs [i].buffer, (int) e->block_size);
CLEANUP_RV( rv, sd_card_disk_block_write_stop_cleanup, "Write block"); CLEANUP_RV( rv, sd_card_disk_block_write_stop_cleanup, "Write block");
} }
@@ -916,9 +920,9 @@ static rtems_status_code sd_card_driver_init( rtems_device_major_number major, r
transfer_speed = sd_card_transfer_speed( block); transfer_speed = sd_card_transfer_speed( block);
e->transfer_mode.baudrate = transfer_speed; e->transfer_mode.baudrate = transfer_speed;
e->n_ac_max = sd_card_max_access_time( block, transfer_speed); e->n_ac_max = sd_card_max_access_time( block, transfer_speed);
read_block_size = 1 << SD_CARD_CSD_GET_READ_BLK_LEN( block); read_block_size = 1U << SD_CARD_CSD_GET_READ_BLK_LEN( block);
e->block_size_shift = SD_CARD_CSD_GET_READ_BLK_LEN( block); e->block_size_shift = SD_CARD_CSD_GET_READ_BLK_LEN( block);
write_block_size = 1 << e->block_size_shift; write_block_size = 1U << e->block_size_shift;
if (read_block_size < write_block_size) { if (read_block_size < write_block_size) {
SYSLOG_ERROR( "Read block size smaller than write block size\n"); SYSLOG_ERROR( "Read block size smaller than write block size\n");
return -RTEMS_IO_ERROR; return -RTEMS_IO_ERROR;
@@ -944,10 +948,10 @@ static rtems_status_code sd_card_driver_init( rtems_device_major_number major, r
CLEANUP_RVSC( rv, sc, sd_card_driver_init_cleanup, "Send: SD_CARD_CMD_SET_BLOCKLEN"); CLEANUP_RVSC( rv, sc, sd_card_driver_init_cleanup, "Send: SD_CARD_CMD_SET_BLOCKLEN");
/* Create disk device */ /* Create disk device */
dev = rtems_filesystem_make_dev_t( sd_card_disk_major, e->table_index); dev = rtems_filesystem_make_dev_t( sd_card_disk_major, (rtems_device_minor_number) e->table_index);
sc = rtems_disk_io_initialize(); sc = rtems_disk_io_initialize();
CLEANUP_SC( sc, sd_card_driver_init_cleanup, "Initialize RTEMS disk IO"); CLEANUP_SC( sc, sd_card_driver_init_cleanup, "Initialize RTEMS disk IO");
sc = rtems_disk_create_phys( dev, e->block_size, e->block_number, sd_card_disk_ioctl, e->disk_device_name); sc = rtems_disk_create_phys( dev, (int) e->block_size, (int) e->block_number, sd_card_disk_ioctl, e->disk_device_name);
CLEANUP_SC( sc, sd_card_driver_init_cleanup, "Create disk device"); CLEANUP_SC( sc, sd_card_driver_init_cleanup, "Create disk device");
/* Stop */ /* Stop */
@@ -988,8 +992,8 @@ static rtems_status_code sd_card_driver_read( rtems_device_major_number major, r
/* Check arguments */ /* Check arguments */
block_size_mask = e->block_size - 1; block_size_mask = e->block_size - 1;
block_count = rw->count >> e->block_size_shift; block_count = (uint32_t) rw->count >> e->block_size_shift;
start_block = rw->offset >> e->block_size_shift; start_block = (uint32_t) rw->offset >> e->block_size_shift;
if (rw->offset & block_size_mask) { if (rw->offset & block_size_mask) {
DO_CLEANUP_SC( RTEMS_INVALID_ADDRESS, sc, sd_card_driver_read_cleanup, "Invalid offset"); DO_CLEANUP_SC( RTEMS_INVALID_ADDRESS, sc, sd_card_driver_read_cleanup, "Invalid offset");
} else if ((rw->count & block_size_mask) || (start_block >= e->block_number) || (block_count > e->block_number - start_block)) { } else if ((rw->count & block_size_mask) || (start_block >= e->block_number) || (block_count > e->block_number - start_block)) {
@@ -1000,25 +1004,25 @@ static rtems_status_code sd_card_driver_read( rtems_device_major_number major, r
/* Do nothing */ /* Do nothing */
} else if (block_count == 1) { } else if (block_count == 1) {
/* Single block read */ /* Single block read */
rv = sd_card_send_command( e, SD_CARD_CMD_READ_SINGLE_BLOCK, rw->offset); rv = sd_card_send_command( e, SD_CARD_CMD_READ_SINGLE_BLOCK, (uint32_t) rw->offset);
CLEANUP_RVSC( rv, sc, sd_card_driver_read_cleanup, "Send: SD_CARD_CMD_READ_SINGLE_BLOCK"); CLEANUP_RVSC( rv, sc, sd_card_driver_read_cleanup, "Send: SD_CARD_CMD_READ_SINGLE_BLOCK");
rv = sd_card_read( e, SD_CARD_START_BLOCK_SINGLE_BLOCK_READ, (uint8_t *) rw->buffer, e->block_size); rv = sd_card_read( e, SD_CARD_START_BLOCK_SINGLE_BLOCK_READ, (uint8_t *) rw->buffer, (int) e->block_size);
CLEANUP_RVSC( rv, sc, sd_card_driver_read_cleanup, "Read: SD_CARD_CMD_READ_SINGLE_BLOCK"); CLEANUP_RVSC( rv, sc, sd_card_driver_read_cleanup, "Read: SD_CARD_CMD_READ_SINGLE_BLOCK");
/* Set moved bytes counter */ /* Set moved bytes counter */
rw->bytes_moved = rv; rw->bytes_moved = (uint32_t) rv;
} else { } else {
/* Start multiple block read */ /* Start multiple block read */
rv = sd_card_send_command( e, SD_CARD_CMD_READ_MULTIPLE_BLOCK, rw->offset); rv = sd_card_send_command( e, SD_CARD_CMD_READ_MULTIPLE_BLOCK, (uint32_t) rw->offset);
CLEANUP_RVSC( rv, sc, sd_card_driver_read_stop_cleanup, "Send: SD_CARD_CMD_READ_MULTIPLE_BLOCK"); CLEANUP_RVSC( rv, sc, sd_card_driver_read_stop_cleanup, "Send: SD_CARD_CMD_READ_MULTIPLE_BLOCK");
/* Multiple block read */ /* Multiple block read */
for (i = 0; i < block_count; ++i) { for (i = 0; i < block_count; ++i) {
rv = sd_card_read( e, SD_CARD_START_BLOCK_MULTIPLE_BLOCK_READ, (uint8_t *) rw->buffer + (i << e->block_size_shift), e->block_size); rv = sd_card_read( e, SD_CARD_START_BLOCK_MULTIPLE_BLOCK_READ, (uint8_t *) rw->buffer + (i << e->block_size_shift), (int) e->block_size);
CLEANUP_RVSC( rv, sc, sd_card_driver_read_stop_cleanup, "Read block"); CLEANUP_RVSC( rv, sc, sd_card_driver_read_stop_cleanup, "Read block");
/* Update moved bytes counter */ /* Update moved bytes counter */
rw->bytes_moved += rv; rw->bytes_moved += (uint32_t) rv;
} }
/* Stop multiple block read */ /* Stop multiple block read */
@@ -1069,8 +1073,8 @@ static rtems_status_code sd_card_driver_write( rtems_device_major_number major,
/* Check arguments */ /* Check arguments */
block_size_mask = e->block_size - 1; block_size_mask = e->block_size - 1;
block_count = rw->count >> e->block_size_shift; block_count = (uint32_t) rw->count >> e->block_size_shift;
start_block = rw->offset >> e->block_size_shift; start_block = (uint32_t) rw->offset >> e->block_size_shift;
if (rw->offset & block_size_mask) { if (rw->offset & block_size_mask) {
DO_CLEANUP_SC( RTEMS_INVALID_ADDRESS, sc, sd_card_driver_write_cleanup, "Invalid offset"); DO_CLEANUP_SC( RTEMS_INVALID_ADDRESS, sc, sd_card_driver_write_cleanup, "Invalid offset");
} else if ((rw->count & block_size_mask) || (start_block >= e->block_number) || (block_count > e->block_number - start_block)) { } else if ((rw->count & block_size_mask) || (start_block >= e->block_number) || (block_count > e->block_number - start_block)) {
@@ -1081,25 +1085,25 @@ static rtems_status_code sd_card_driver_write( rtems_device_major_number major,
/* Do nothing */ /* Do nothing */
} else if (block_count == 1) { } else if (block_count == 1) {
/* Single block write */ /* Single block write */
rv = sd_card_send_command( e, SD_CARD_CMD_WRITE_BLOCK, rw->offset); rv = sd_card_send_command( e, SD_CARD_CMD_WRITE_BLOCK, (uint32_t) rw->offset);
CLEANUP_RVSC( rv, sc, sd_card_driver_write_cleanup, "Send: SD_CARD_CMD_WRITE_BLOCK"); CLEANUP_RVSC( rv, sc, sd_card_driver_write_cleanup, "Send: SD_CARD_CMD_WRITE_BLOCK");
rv = sd_card_write( e, SD_CARD_START_BLOCK_SINGLE_BLOCK_WRITE, (uint8_t *) rw->buffer, e->block_size); rv = sd_card_write( e, SD_CARD_START_BLOCK_SINGLE_BLOCK_WRITE, (uint8_t *) rw->buffer, (int) e->block_size);
CLEANUP_RVSC( rv, sc, sd_card_driver_write_cleanup, "Write: SD_CARD_CMD_WRITE_BLOCK"); CLEANUP_RVSC( rv, sc, sd_card_driver_write_cleanup, "Write: SD_CARD_CMD_WRITE_BLOCK");
/* Set moved bytes counter */ /* Set moved bytes counter */
rw->bytes_moved = rv; rw->bytes_moved = (uint32_t) rv;
} else { } else {
/* Start multiple block write */ /* Start multiple block write */
rv = sd_card_send_command( e, SD_CARD_CMD_WRITE_MULTIPLE_BLOCK, rw->offset); rv = sd_card_send_command( e, SD_CARD_CMD_WRITE_MULTIPLE_BLOCK, (uint32_t) rw->offset);
CLEANUP_RVSC( rv, sc, sd_card_driver_write_stop_cleanup, "Send: SD_CARD_CMD_WRITE_MULTIPLE_BLOCK"); CLEANUP_RVSC( rv, sc, sd_card_driver_write_stop_cleanup, "Send: SD_CARD_CMD_WRITE_MULTIPLE_BLOCK");
/* Multiple block write */ /* Multiple block write */
for (i = 0; i < block_count; ++i) { for (i = 0; i < block_count; ++i) {
rv = sd_card_write( e, SD_CARD_START_BLOCK_MULTIPLE_BLOCK_WRITE, (uint8_t *) rw->buffer + (i << e->block_size_shift), e->block_size); rv = sd_card_write( e, SD_CARD_START_BLOCK_MULTIPLE_BLOCK_WRITE, (uint8_t *) rw->buffer + (i << e->block_size_shift), (int) e->block_size);
CLEANUP_RVSC( rv, sc, sd_card_driver_write_stop_cleanup, "Write: SD_CARD_CMD_WRITE_MULTIPLE_BLOCK"); CLEANUP_RVSC( rv, sc, sd_card_driver_write_stop_cleanup, "Write: SD_CARD_CMD_WRITE_MULTIPLE_BLOCK");
/* Update moved bytes counter */ /* Update moved bytes counter */
rw->bytes_moved += rv; rw->bytes_moved += (uint32_t) rv;
} }
/* Stop multiple block write */ /* Stop multiple block write */