dm: block: Adjust device calls to go through helpers function

To ease conversion to driver model, add helper functions which deal with
calling each block device method. With driver model we can reimplement these
functions with the same arguments.

Use inline functions to avoid increasing code size on some boards.

Signed-off-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tested-by: Stephen Warren <swarren@nvidia.com>

diff --git a/cmd/disk.c b/cmd/disk.c
index 27ed115d2f55f28f880f5e78dfde875004d29c16..e0219f810e381d0dcd6584903b787ec7d38a80c1 100644 (file)
--- a/cmd/disk.c
+++ b/cmd/disk.c
@@ -56,7 +56,7 @@ int common_diskboot(cmd_tbl_t *cmdtp, const char *intf, int argc,
              ", Block Size: %ld\n",
              info.start, info.size, info.blksz);
 
-       if (dev_desc->block_read(dev_desc, info.start, 1, (ulong *)addr) != 1) {
+       if (blk_dread(dev_desc, info.start, 1, (ulong *)addr) != 1) {
                printf("** Read error on %d:%d\n", dev, part);
                bootstage_error(BOOTSTAGE_ID_IDE_PART_READ);
                return 1;
@@ -100,8 +100,8 @@ int common_diskboot(cmd_tbl_t *cmdtp, const char *intf, int argc,
        cnt /= info.blksz;
        cnt -= 1;
 
-       if (dev_desc->block_read(dev_desc, info.start + 1, cnt,
-                                (ulong *)(addr + info.blksz)) != cnt) {
+       if (blk_dread(dev_desc, info.start + 1, cnt,
+                     (ulong *)(addr + info.blksz)) != cnt) {
                printf("** Read error on %d:%d\n", dev, part);
                bootstage_error(BOOTSTAGE_ID_IDE_READ);
                return 1;

diff --git a/cmd/ide.c b/cmd/ide.c
index dfd55480b7c56d75315d6350d48e6ce07dd5f8cc..c4c08c8855d131f63e4f22b0266d75757d7f10aa 100644 (file)
--- a/cmd/ide.c
+++ b/cmd/ide.c
@@ -10,6 +10,7 @@
  */
 
 #include <common.h>
+#include <blk.h>
 #include <config.h>
 #include <watchdog.h>
 #include <command.h>
@@ -203,8 +204,7 @@ int do_ide(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 #endif
 
                        dev_desc = &ide_dev_desc[curr_device];
-                       n = dev_desc->block_read(dev_desc, blk, cnt,
-                                                (ulong *)addr);
+                       n = blk_dread(dev_desc, blk, cnt, (ulong *)addr);
                        /* flush cache after read */
                        flush_cache(addr,
                                    cnt * ide_dev_desc[curr_device].blksz);

diff --git a/cmd/read.c b/cmd/read.c
index f8d766a7139a8858eb39937a0d4021d0b7a04c85..61d8ce73e4932172502a0d5dc09d6c1369a4f08c 100644 (file)
--- a/cmd/read.c
+++ b/cmd/read.c
@@ -66,7 +66,7 @@ int do_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                return 1;
        }
 
-       if (dev_desc->block_read(dev_desc, offset + blk, cnt, addr) < 0) {
+       if (blk_read(dev_desc, offset + blk, cnt, addr) < 0) {
                printf("Error reading blocks\n");
                return 1;
        }

diff --git a/cmd/usb.c b/cmd/usb.c
index 53fd6adb00fccaf4129bf0b8b018cb21ca1d6ffb..9ed5dc61eab031fa5f78d34340a272f50ac5c447 100644 (file)
--- a/cmd/usb.c
+++ b/cmd/usb.c
@@ -759,8 +759,7 @@ static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                        printf("\nUSB read: device %d block # %ld, count %ld"
                                " ... ", usb_stor_curr_dev, blk, cnt);
                        stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
-                       n = stor_dev->block_read(stor_dev, blk, cnt,
-                                                (ulong *)addr);
+                       n = blk_dread(stor_dev, blk, cnt, (ulong *)addr);
                        printf("%ld blocks read: %s\n", n,
                                (n == cnt) ? "OK" : "ERROR");
                        if (n == cnt)
@@ -781,8 +780,7 @@ static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                        printf("\nUSB write: device %d block # %ld, count %ld"
                                " ... ", usb_stor_curr_dev, blk, cnt);
                        stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
-                       n = stor_dev->block_write(stor_dev, blk, cnt,
-                                               (ulong *)addr);
+                       n = blk_dwrite(stor_dev, blk, cnt, (ulong *)addr);
                        printf("%ld blocks write: %s\n", n,
                                (n == cnt) ? "OK" : "ERROR");
                        if (n == cnt)

diff --git a/common/fb_mmc.c b/common/fb_mmc.c
index da7949f6f03239e8cf5b223d2354a1a1191c7f4d..e3abcc85beea94dd26d5ee0a2cb51fd8616e7542 100644 (file)
--- a/common/fb_mmc.c
+++ b/common/fb_mmc.c
@@ -6,6 +6,7 @@
 
 #include <config.h>
 #include <common.h>
+#include <blk.h>
 #include <errno.h>
 #include <fastboot.h>
 #include <fb_mmc.h>
@@ -58,7 +59,7 @@ static int fb_mmc_sparse_write(struct sparse_storage *storage,
        struct blk_desc *dev_desc = sparse->dev_desc;
        int ret;
 
-       ret = dev_desc->block_write(dev_desc, offset, size, data);
+       ret = blk_dwrite(dev_desc, offset, size, data);
        if (!ret)
                return -EIO;
 
@@ -84,7 +85,7 @@ static void write_raw_image(struct blk_desc *dev_desc, disk_partition_t *info,
 
        puts("Flashing Raw Image\n");
 
-       blks = dev_desc->block_write(dev_desc, info->start, blkcnt, buffer);
+       blks = blk_dwrite(dev_desc, info->start, blkcnt, buffer);
        if (blks != blkcnt) {
                error("failed writing to device %d\n", dev_desc->devnum);
                fastboot_fail(response_str, "failed writing to device");

diff --git a/disk/part_amiga.c b/disk/part_amiga.c
index d323b4bc1eb6b1d21e6c2df6289b5c82aa568853..4a67689c75b34fc3462588e2e310b7a042b341a7 100644 (file)
--- a/disk/part_amiga.c
+++ b/disk/part_amiga.c
@@ -140,7 +140,7 @@ struct rigid_disk_block *get_rdisk(struct blk_desc *dev_desc)
 
     for (i=0; i<limit; i++)
     {
-       ulong res = dev_desc->block_read(dev_desc, i, 1, (ulong *)block_buffer);
+       ulong res = blk_dread(dev_desc, i, 1, (ulong *)block_buffer);
        if (res == 1)
        {
            struct rigid_disk_block *trdb = (struct rigid_disk_block *)block_buffer;
@@ -182,7 +182,7 @@ struct bootcode_block *get_bootcode(struct blk_desc *dev_desc)
 
     for (i = 0; i < limit; i++)
     {
-       ulong res = dev_desc->block_read(dev_desc, i, 1, (ulong *)block_buffer);
+       ulong res = blk_dread(dev_desc, i, 1, (ulong *)block_buffer);
        if (res == 1)
        {
            struct bootcode_block *boot = (struct bootcode_block *)block_buffer;
@@ -258,8 +258,7 @@ static struct partition_block *find_partition(struct blk_desc *dev_desc,
 
     while (block != 0xFFFFFFFF)
     {
-       ulong res = dev_desc->block_read(dev_desc, block, 1,
-                                        (ulong *)block_buffer);
+       ulong res = blk_dread(dev_desc, block, 1, (ulong *)block_buffer);
        if (res == 1)
        {
            p = (struct partition_block *)block_buffer;
@@ -355,7 +354,7 @@ static void print_part_amiga(struct blk_desc *dev_desc)
 
        PRINTF("Trying to load block #0x%X\n", block);
 
-       res = dev_desc->block_read(dev_desc, block, 1, (ulong *)block_buffer);
+       res = blk_dread(dev_desc, block, 1, (ulong *)block_buffer);
        if (res == 1)
        {
            p = (struct partition_block *)block_buffer;

diff --git a/disk/part_dos.c b/disk/part_dos.c
index 5f8d949b84c7a680c33ce29e296ea0174cf87727..0ed1374ab72a23ff46a4aae22eb0307845663445 100644 (file)
--- a/disk/part_dos.c
+++ b/disk/part_dos.c
@@ -91,7 +91,7 @@ static int test_part_dos(struct blk_desc *dev_desc)
 {
        ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, dev_desc->blksz);
 
-       if (dev_desc->block_read(dev_desc, 0, 1, (ulong *)buffer) != 1)
+       if (blk_dread(dev_desc, 0, 1, (ulong *)buffer) != 1)
                return -1;
 
        if (test_block_type(buffer) != DOS_MBR)
@@ -111,8 +111,7 @@ static void print_partition_extended(struct blk_desc *dev_desc,
        dos_partition_t *pt;
        int i;
 
-       if (dev_desc->block_read(dev_desc, ext_part_sector, 1,
-                                (ulong *)buffer) != 1) {
+       if (blk_dread(dev_desc, ext_part_sector, 1, (ulong *)buffer) != 1) {
                printf ("** Can't read partition table on %d:" LBAFU " **\n",
                        dev_desc->devnum, ext_part_sector);
                return;
@@ -177,8 +176,7 @@ static int part_get_info_extended(struct blk_desc *dev_desc,
        int i;
        int dos_type;
 
-       if (dev_desc->block_read(dev_desc, ext_part_sector, 1,
-                                (ulong *)buffer) != 1) {
+       if (blk_dread(dev_desc, ext_part_sector, 1, (ulong *)buffer) != 1) {
                printf ("** Can't read partition table on %d:" LBAFU " **\n",
                        dev_desc->devnum, ext_part_sector);
                return -1;

diff --git a/disk/part_efi.c b/disk/part_efi.c
index ae8cd7ea584a88d38e658267e2a356516bd74160..b20907b377191c75445eae3a08cbf00e46964736 100644 (file)
--- a/disk/part_efi.c
+++ b/disk/part_efi.c
@@ -324,7 +324,7 @@ static int test_part_efi(struct blk_desc *dev_desc)
        ALLOC_CACHE_ALIGN_BUFFER_PAD(legacy_mbr, legacymbr, 1, dev_desc->blksz);
 
        /* Read legacy MBR from block 0 and validate it */
-       if ((dev_desc->block_read(dev_desc, 0, 1, (ulong *)legacymbr) != 1)
+       if ((blk_dread(dev_desc, 0, 1, (ulong *)legacymbr) != 1)
                || (is_pmbr_valid(legacymbr) != 1)) {
                return -1;
        }
@@ -354,7 +354,7 @@ static int set_protective_mbr(struct blk_desc *dev_desc)
        p_mbr->partition_record[0].nr_sects = (u32) dev_desc->lba - 1;
 
        /* Write MBR sector to the MMC device */
-       if (dev_desc->block_write(dev_desc, 0, 1, p_mbr) != 1) {
+       if (blk_dwrite(dev_desc, 0, 1, p_mbr) != 1) {
                printf("** Can't write to device %d **\n",
                        dev_desc->devnum);
                return -1;
@@ -386,24 +386,21 @@ int write_gpt_table(struct blk_desc *dev_desc,
        gpt_h->header_crc32 = cpu_to_le32(calc_crc32);
 
        /* Write the First GPT to the block right after the Legacy MBR */
-       if (dev_desc->block_write(dev_desc, 1, 1, gpt_h) != 1)
+       if (blk_dwrite(dev_desc, 1, 1, gpt_h) != 1)
                goto err;
 
-       if (dev_desc->block_write(dev_desc, 2, pte_blk_cnt, gpt_e)
+       if (blk_dwrite(dev_desc, 2, pte_blk_cnt, gpt_e)
            != pte_blk_cnt)
                goto err;
 
        prepare_backup_gpt_header(gpt_h);
 
-       if (dev_desc->block_write(dev_desc,
-                                 (lbaint_t)le64_to_cpu(gpt_h->last_usable_lba)
-                                 + 1,
-                                 pte_blk_cnt, gpt_e) != pte_blk_cnt)
+       if (blk_dwrite(dev_desc, (lbaint_t)le64_to_cpu(gpt_h->last_usable_lba)
+                      + 1, pte_blk_cnt, gpt_e) != pte_blk_cnt)
                goto err;
 
-       if (dev_desc->block_write(dev_desc,
-                                 (lbaint_t)le64_to_cpu(gpt_h->my_lba), 1,
-                                 gpt_h) != 1)
+       if (blk_dwrite(dev_desc, (lbaint_t)le64_to_cpu(gpt_h->my_lba), 1,
+                      gpt_h) != 1)
                goto err;
 
        debug("GPT successfully written to block device!\n");
@@ -739,7 +736,7 @@ int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf)
        /* write MBR */
        lba = 0;        /* MBR is always at 0 */
        cnt = 1;        /* MBR (1 block) */
-       if (dev_desc->block_write(dev_desc, lba, cnt, buf) != cnt) {
+       if (blk_dwrite(dev_desc, lba, cnt, buf) != cnt) {
                printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
                       __func__, "MBR", cnt, lba);
                return 1;
@@ -748,7 +745,7 @@ int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf)
        /* write Primary GPT */
        lba = GPT_PRIMARY_PARTITION_TABLE_LBA;
        cnt = 1;        /* GPT Header (1 block) */
-       if (dev_desc->block_write(dev_desc, lba, cnt, gpt_h) != cnt) {
+       if (blk_dwrite(dev_desc, lba, cnt, gpt_h) != cnt) {
                printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
                       __func__, "Primary GPT Header", cnt, lba);
                return 1;
@@ -756,7 +753,7 @@ int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf)
 
        lba = le64_to_cpu(gpt_h->partition_entry_lba);
        cnt = gpt_e_blk_cnt;
-       if (dev_desc->block_write(dev_desc, lba, cnt, gpt_e) != cnt) {
+       if (blk_dwrite(dev_desc, lba, cnt, gpt_e) != cnt) {
                printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
                       __func__, "Primary GPT Entries", cnt, lba);
                return 1;
@@ -767,7 +764,7 @@ int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf)
        /* write Backup GPT */
        lba = le64_to_cpu(gpt_h->partition_entry_lba);
        cnt = gpt_e_blk_cnt;
-       if (dev_desc->block_write(dev_desc, lba, cnt, gpt_e) != cnt) {
+       if (blk_dwrite(dev_desc, lba, cnt, gpt_e) != cnt) {
                printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
                       __func__, "Backup GPT Entries", cnt, lba);
                return 1;
@@ -775,7 +772,7 @@ int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf)
 
        lba = le64_to_cpu(gpt_h->my_lba);
        cnt = 1;        /* GPT Header (1 block) */
-       if (dev_desc->block_write(dev_desc, lba, cnt, gpt_h) != cnt) {
+       if (blk_dwrite(dev_desc, lba, cnt, gpt_h) != cnt) {
                printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
                       __func__, "Backup GPT Header", cnt, lba);
                return 1;
@@ -845,7 +842,7 @@ static int is_gpt_valid(struct blk_desc *dev_desc, u64 lba,
        }
 
        /* Read GPT Header from device */
-       if (dev_desc->block_read(dev_desc, (lbaint_t)lba, 1, pgpt_head) != 1) {
+       if (blk_dread(dev_desc, (lbaint_t)lba, 1, pgpt_head) != 1) {
                printf("*** ERROR: Can't read GPT header ***\n");
                return 0;
        }
@@ -913,8 +910,7 @@ static gpt_entry *alloc_read_gpt_entries(struct blk_desc *dev_desc,
        /* Read GPT Entries from device */
        blk = le64_to_cpu(pgpt_head->partition_entry_lba);
        blk_cnt = BLOCK_CNT(count, dev_desc);
-       if (dev_desc->block_read(dev_desc, blk, (lbaint_t)blk_cnt, pte)
-           != blk_cnt) {
+       if (blk_dread(dev_desc, blk, (lbaint_t)blk_cnt, pte) != blk_cnt) {
                printf("*** ERROR: Can't read GPT Entries ***\n");
                free(pte);
                return NULL;

diff --git a/disk/part_iso.c b/disk/part_iso.c
index c78ae21bf32ca83e2650cf4612ace70f2a87029b..76eab3915f07fa0c83b10baa2414c04e50a8405f 100644 (file)
--- a/disk/part_iso.c
+++ b/disk/part_iso.c
@@ -63,7 +63,7 @@ int part_get_info_iso_verb(struct blk_desc *dev_desc, int part_num,
 
        /* the first sector (sector 0x10) must be a primary volume desc */
        blkaddr=PVD_OFFSET;
-       if (dev_desc->block_read(dev_desc, PVD_OFFSET, 1, (ulong *)tmpbuf) != 1)
+       if (blk_dread(dev_desc, PVD_OFFSET, 1, (ulong *)tmpbuf) != 1)
                return -1;
        if(ppr->desctype!=0x01) {
                if(verb)
@@ -85,7 +85,7 @@ int part_get_info_iso_verb(struct blk_desc *dev_desc, int part_num,
        PRINTF(" Lastsect:%08lx\n",lastsect);
        for(i=blkaddr;i<lastsect;i++) {
                PRINTF("Reading block %d\n", i);
-               if (dev_desc->block_read(dev_desc, i, 1, (ulong *)tmpbuf) != 1)
+               if (blk_dread(dev_desc, i, 1, (ulong *)tmpbuf) != 1)
                        return -1;
                if(ppr->desctype==0x00)
                        break; /* boot entry found */
@@ -105,7 +105,7 @@ int part_get_info_iso_verb(struct blk_desc *dev_desc, int part_num,
        }
        bootaddr=le32_to_int(pbr->pointer);
        PRINTF(" Boot Entry at: %08lX\n",bootaddr);
-       if (dev_desc->block_read(dev_desc, bootaddr, 1, (ulong *)tmpbuf) != 1) {
+       if (blk_dread(dev_desc, bootaddr, 1, (ulong *)tmpbuf) != 1) {
                if(verb)
                        printf ("** Can't read Boot Entry at %lX on %d:%d **\n",
                                bootaddr, dev_desc->devnum, part_num);

diff --git a/disk/part_mac.c b/disk/part_mac.c
index 07bbc1988ae6973cdcb682975a8d0c5ed8ae30c2..ce57b5739d354f8fcd14c4842b322b96cd8d3725 100644 (file)
--- a/disk/part_mac.c
+++ b/disk/part_mac.c
@@ -53,8 +53,7 @@ static int test_part_mac(struct blk_desc *dev_desc)
 
        n = 1;  /* assuming at least one partition */
        for (i=1; i<=n; ++i) {
-               if ((dev_desc->block_read(dev_desc, i, 1,
-                                         (ulong *)mpart) != 1) ||
+               if ((blk_dread(dev_desc, i, 1, (ulong *)mpart) != 1) ||
                    (mpart->signature != MAC_PARTITION_MAGIC) ) {
                        return (-1);
                }
@@ -106,7 +105,7 @@ static void print_part_mac(struct blk_desc *dev_desc)
                char c;
 
                printf ("%4ld: ", i);
-               if (dev_desc->block_read(dev_desc, i, 1, (ulong *)mpart) != 1) {
+               if (blk_dread(dev_desc, i, 1, (ulong *)mpart) != 1) {
                        printf ("** Can't read Partition Map on %d:%ld **\n",
                                dev_desc->devnum, i);
                        return;
@@ -153,7 +152,7 @@ static void print_part_mac(struct blk_desc *dev_desc)
 static int part_mac_read_ddb(struct blk_desc *dev_desc,
                             mac_driver_desc_t *ddb_p)
 {
-       if (dev_desc->block_read(dev_desc, 0, 1, (ulong *)ddb_p) != 1) {
+       if (blk_dread(dev_desc, 0, 1, (ulong *)ddb_p) != 1) {
                printf ("** Can't read Driver Desriptor Block **\n");
                return (-1);
        }
@@ -182,7 +181,7 @@ static int part_mac_read_pdb(struct blk_desc *dev_desc, int part,
                 * partition 1 first since this is the only way to
                 * know how many partitions we have.
                 */
-               if (dev_desc->block_read(dev_desc, n, 1, (ulong *)pdb_p) != 1) {
+               if (blk_dread(dev_desc, n, 1, (ulong *)pdb_p) != 1) {
                        printf ("** Can't read Partition Map on %d:%d **\n",
                                dev_desc->devnum, n);
                        return (-1);

diff --git a/fs/ext4/dev.c b/fs/ext4/dev.c
index 3eef66f84781a303b9277a88082da8a089f323e8..ee84d3fbe182675582c546de8b4bf4f3ad78fe02 100644 (file)
--- a/fs/ext4/dev.c
+++ b/fs/ext4/dev.c
@@ -24,6 +24,7 @@
  */
 
 #include <common.h>
+#include <blk.h>
 #include <config.h>
 #include <memalign.h>
 #include <ext4fs.h>
@@ -76,9 +77,8 @@ int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf)
        if (byte_offset != 0) {
                int readlen;
                /* read first part which isn't aligned with start of sector */
-               if (ext4fs_blk_desc->block_read(ext4fs_blk_desc,
-                                               part_info->start + sector,
-                                               1, (void *)sec_buf) != 1) {
+               if (blk_dread(ext4fs_blk_desc, part_info->start + sector, 1,
+                             (void *)sec_buf) != 1) {
                        printf(" ** ext2fs_devread() read error **\n");
                        return 0;
                }
@@ -100,17 +100,15 @@ int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf)
                ALLOC_CACHE_ALIGN_BUFFER(u8, p, ext4fs_blk_desc->blksz);
 
                block_len = ext4fs_blk_desc->blksz;
-               ext4fs_blk_desc->block_read(ext4fs_blk_desc,
-                                                 part_info->start + sector,
-                                                 1, (void *)p);
+               blk_dread(ext4fs_blk_desc, part_info->start + sector, 1,
+                         (void *)p);
                memcpy(buf, p, byte_len);
                return 1;
        }
 
-       if (ext4fs_blk_desc->block_read(ext4fs_blk_desc,
-                                       part_info->start + sector,
-                                       block_len >> log2blksz, (void *)buf)
-                               != block_len >> log2blksz) {
+       if (blk_dread(ext4fs_blk_desc, part_info->start + sector,
+                     block_len >> log2blksz, (void *)buf) !=
+                       block_len >> log2blksz) {
                printf(" ** %s read error - block\n", __func__);
                return 0;
        }
@@ -121,9 +119,8 @@ int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf)
 
        if (byte_len != 0) {
                /* read rest of data which are not in whole sector */
-               if (ext4fs_blk_desc->block_read(ext4fs_blk_desc,
-                                               part_info->start + sector,
-                                               1, (void *)sec_buf) != 1) {
+               if (blk_dread(ext4fs_blk_desc, part_info->start + sector, 1,
+                             (void *)sec_buf) != 1) {
                        printf("* %s read error - last part\n", __func__);
                        return 0;
                }

diff --git a/fs/ext4/ext4_common.c b/fs/ext4/ext4_common.c
index 294a46eadfded68c3da42f44477e6239a480131c..84fba767c1ad71e3a5df53c8bbd0696e2f690f81 100644 (file)
--- a/fs/ext4/ext4_common.c
+++ b/fs/ext4/ext4_common.c
@@ -81,29 +81,20 @@ void put_ext4(uint64_t off, void *buf, uint32_t size)
        }
 
        if (remainder) {
-               if (fs->dev_desc->block_read) {
-                       fs->dev_desc->block_read(fs->dev_desc,
-                                                startblock, 1, sec_buf);
-                       temp_ptr = sec_buf;
-                       memcpy((temp_ptr + remainder),
-                              (unsigned char *)buf, size);
-                       fs->dev_desc->block_write(fs->dev_desc,
-                                                 startblock, 1, sec_buf);
-               }
+               blk_dread(fs->dev_desc, startblock, 1, sec_buf);
+               temp_ptr = sec_buf;
+               memcpy((temp_ptr + remainder), (unsigned char *)buf, size);
+               blk_dwrite(fs->dev_desc, startblock, 1, sec_buf);
        } else {
                if (size >> log2blksz != 0) {
-                       fs->dev_desc->block_write(fs->dev_desc,
-                                                 startblock,
-                                                 size >> log2blksz,
-                                                 (unsigned long *)buf);
+                       blk_dwrite(fs->dev_desc, startblock, size >> log2blksz,
+                                  (unsigned long *)buf);
                } else {
-                       fs->dev_desc->block_read(fs->dev_desc,
-                                                startblock, 1, sec_buf);
+                       blk_dread(fs->dev_desc, startblock, 1, sec_buf);
                        temp_ptr = sec_buf;
                        memcpy(temp_ptr, buf, size);
-                       fs->dev_desc->block_write(fs->dev_desc,
-                                                 startblock, 1,
-                                                 (unsigned long *)sec_buf);
+                       blk_dwrite(fs->dev_desc, startblock, 1,
+                                  (unsigned long *)sec_buf);
                }
        }
 }

diff --git a/fs/fat/fat.c b/fs/fat/fat.c
index f87ddd7630c8e6e948ea20d5fba6740cc3dd62b0..600a90e30922621c03c1db8c65119b7fbe85f50a 100644 (file)
--- a/fs/fat/fat.c
+++ b/fs/fat/fat.c
@@ -10,6 +10,7 @@
  */
 
 #include <common.h>
+#include <blk.h>
 #include <config.h>
 #include <exports.h>
 #include <fat.h>
@@ -48,11 +49,10 @@ static int disk_read(__u32 block, __u32 nr_blocks, void *buf)
 {
        ulong ret;
 
-       if (!cur_dev || !cur_dev->block_read)
+       if (!cur_dev)
                return -1;
 
-       ret = cur_dev->block_read(cur_dev, cur_part_info.start + block,
-                                 nr_blocks, buf);
+       ret = blk_dread(cur_dev, cur_part_info.start + block, nr_blocks, buf);
 
        if (nr_blocks && ret == 0)
                return -1;

diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
index 5ed324ce1a022241a9a43c1a257f7f6ab11279d3..baa85ec3b44d8ce6515ada780038ab0af1d350f1 100644 (file)
--- a/fs/fat/fat_write.c
+++ b/fs/fat/fat_write.c
@@ -32,7 +32,7 @@ static int disk_write(__u32 block, __u32 nr_blocks, void *buf)
 {
        ulong ret;
 
-       if (!cur_dev || !cur_dev->block_write)
+       if (!cur_dev)
                return -1;
 
        if (cur_part_info.start + block + nr_blocks >
@@ -41,8 +41,7 @@ static int disk_write(__u32 block, __u32 nr_blocks, void *buf)
                return -1;
        }
 
-       ret = cur_dev->block_write(cur_dev, cur_part_info.start + block,
-                                  nr_blocks, buf);
+       ret = blk_dwrite(cur_dev, cur_part_info.start + block, nr_blocks, buf);
        if (nr_blocks && ret == 0)
                return -1;
 

diff --git a/include/blk.h b/include/blk.h
index 9c54842961f3e3a99abf2c3574104a2f8e6d7eb3..7b2e5e286f2a9abdba513783431093ee0909c46f 100644 (file)
--- a/include/blk.h
+++ b/include/blk.h
@@ -71,4 +71,33 @@ struct blk_desc {
 #define PAD_TO_BLOCKSIZE(size, blk_desc) \
        (PAD_SIZE(size, blk_desc->blksz))
 
+/*
+ * These functions should take struct udevice instead of struct blk_desc,
+ * but this is convenient for migration to driver model. Add a 'd' prefix
+ * to the function operations, so that blk_read(), etc. can be reserved for
+ * functions with the correct arguments.
+ */
+static inline ulong blk_dread(struct blk_desc *block_dev, lbaint_t start,
+                             lbaint_t blkcnt, void *buffer)
+{
+       /*
+        * We could check if block_read is NULL and return -ENOSYS. But this
+        * bloats the code slightly (cause some board to fail to build), and
+        * it would be an error to try an operation that does not exist.
+        */
+       return block_dev->block_read(block_dev, start, blkcnt, buffer);
+}
+
+static inline ulong blk_dwrite(struct blk_desc *block_dev, lbaint_t start,
+                              lbaint_t blkcnt, const void *buffer)
+{
+       return block_dev->block_write(block_dev, start, blkcnt, buffer);
+}
+
+static inline ulong blk_derase(struct blk_desc *block_dev, lbaint_t start,
+                              lbaint_t blkcnt)
+{
+       return block_dev->block_erase(block_dev, start, blkcnt);
+}
+
 #endif

diff --git a/test/dm/usb.c b/test/dm/usb.c
index 099618504914524dd69eaca6cc154ee65bd187f5..2d203541786264c91957c246b3916faceee3b97b 100644 (file)
--- a/test/dm/usb.c
+++ b/test/dm/usb.c
@@ -50,7 +50,7 @@ static int dm_test_usb_flash(struct unit_test_state *uts)
        /* Read a few blocks and look for the string we expect */
        ut_asserteq(512, dev_desc->blksz);
        memset(cmp, '\0', sizeof(cmp));
-       ut_asserteq(2, dev_desc->block_read(dev_desc, 0, 2, cmp));
+       ut_asserteq(2, blk_dread(dev_desc, 0, 2, cmp));
        ut_assertok(strcmp(cmp, "this is a test"));
 
        return 0;