diff --git a/cmd/disk.c b/cmd/disk.c
index 27ed115d2f..e0219f810e 100644
--- 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 dfd55480b7..c4c08c8855 100644
--- 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 f8d766a713..61d8ce73e4 100644
--- 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 53fd6adb00..9ed5dc61ea 100644
--- 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 da7949f6f0..e3abcc85be 100644
--- 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 d323b4bc1e..4a67689c75 100644
--- 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 5f8d949b84..0ed1374ab7 100644
--- 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 ae8cd7ea58..b20907b377 100644
--- 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 c78ae21bf3..76eab3915f 100644
--- 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 07bbc1988a..ce57b5739d 100644
--- 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 3eef66f847..ee84d3fbe1 100644
--- 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 294a46eadf..84fba767c1 100644
--- 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 f87ddd7630..600a90e309 100644
--- 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 5ed324ce1a..baa85ec3b4 100644
--- 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 9c54842961..7b2e5e286f 100644
--- 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 0996185049..2d20354178 100644
--- 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;