Eric Lee / smarc-uboot

Download as
Browse Code ยป

Commit 7c4213f6a52f35ff6ba2d97aa4eb04cbfc963b86

Authored by Stephen Warren
Committed by Tom Rini
1 parent adc421e4ce
Exists in v2017.01-smarct4x and in 30 other branches 8qm-imx_v2020.04_5.4.70_2.3.0, emb_lf_v2022.04, pitx_8mp_lf_v2020.04, smarc-8m-android-10.0.0_2.6.0, smarc-8m-android-11.0.0_2.0.0, smarc-8mp-android-11.0.0_2.0.0, smarc-imx6_v2018.03_4.14.98_2.0.0_ga, smarc-imx7_v2017.03_4.9.11_1.0.0_ga, smarc-imx7_v2018.03_4.14.98_2.0.0_ga, smarc-imx_v2017.03_4.9.11_1.0.0_ga, smarc-imx_v2017.03_4.9.88_2.0.0_ga, smarc-imx_v2017.03_o8.1.0_1.3.0_8m, smarc-imx_v2018.03_4.14.78_1.0.0_ga, smarc-n7.1.2_2.0.0-ga, smarc-rel_imx_4.1.15_2.0.0_ga, smarc_8m-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8m-imx_v2019.04_4.19.35_1.1.0, smarc_8m_00d0-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8mm-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8mm-imx_v2019.04_4.19.35_1.1.0, smarc_8mm-imx_v2020.04_5.4.24_2.1.0, smarc_8mp_lf_v2020.04, smarc_8mq-imx_v2020.04_5.4.24_2.1.0, smarc_8mq_lf_v2020.04, v2016.05-dlt, v2016.05-smarct3x, v2016.05-smarct3x-emmc, v2016.05-smarct4x, v2017.01-smarct3x, v2017.01-smarct3x-emmc

block: pass block dev not num to read/write/erase() 

This will allow the implementation to make use of data in the block_dev
structure beyond the base device number. This will be useful so that eMMC
block devices can encompass the HW partition ID rather than treating this
out-of-band. Equally, the existence of the priv field is crying out for
this patch to exist.

Signed-off-by: Stephen Warren <swarren@nvidia.com>
Reviewed-by: Tom Rini <trini@konsulko.com>

Showing 41 changed files with 224 additions and 194 deletions Side-by-side Diff

... ... @@ -345,19 +345,6 @@
345 345 }
346 346  
347 347  
348   -static int dev_stor_index(block_dev_desc_t *dd)
349   -{
350   - int i, type;
351   -
352   - type = dev_stor_type(dd);
353   - for (i = 0; i < specs[type].max_dev; i++)
354   - if (dd == get_dev(specs[type].name, i))
355   - return i;
356   -
357   - return (specs[type].max_dev);
358   -}
359   -
360   -
361 348 lbasize_t dev_read_stor(void *cookie, void *buf, lbasize_t len, lbastart_t start)
362 349 {
363 350 int type;
... ... @@ -374,6 +361,6 @@
374 361 return 0;
375 362 }
376 363  
377   - return (dd->block_read(dev_stor_index(dd), start, len, buf));
  364 + return dd->block_read(dd, start, len, buf);
378 365 }
board/freescale/common/sdhc_boot.c
Diff comments   View file @ 7c4213f
... ... @@ -29,7 +29,7 @@
29 29 return 1;
30 30  
31 31 /* read out the first block, get the config data information */
32   - n = mmc->block_dev.block_read(mmc->block_dev.dev, 0, 1, tmp_buf);
  32 + n = mmc->block_dev.block_read(&mmc->block_dev, 0, 1, tmp_buf);
33 33 if (!n) {
34 34 free(tmp_buf);
35 35 return 1;
board/gdsys/p1022/controlcenterd-id.c
Diff comments   View file @ 7c4213f
... ... @@ -232,7 +232,7 @@
232 232 ofs = src % blk_len;
233 233  
234 234 if (ofs) {
235   - n = mmc->block_dev.block_read(mmc->block_dev.dev, block_no++, 1,
  235 + n = mmc->block_dev.block_read(&mmc->block_dev, block_no++, 1,
236 236 tmp_buf);
237 237 if (!n)
238 238 goto failure;
... ... @@ -243,7 +243,7 @@
243 243 }
244 244 cnt = size / blk_len;
245 245 if (cnt) {
246   - n = mmc->block_dev.block_read(mmc->block_dev.dev, block_no, cnt,
  246 + n = mmc->block_dev.block_read(&mmc->block_dev, block_no, cnt,
247 247 dst);
248 248 if (n != cnt)
249 249 goto failure;
... ... @@ -253,7 +253,7 @@
253 253 block_no += cnt;
254 254 }
255 255 if (size) {
256   - n = mmc->block_dev.block_read(mmc->block_dev.dev, block_no++, 1,
  256 + n = mmc->block_dev.block_read(&mmc->block_dev, block_no++, 1,
257 257 tmp_buf);
258 258 if (!n)
259 259 goto failure;
board/gdsys/p1022/sdhc_boot.c
Diff comments   View file @ 7c4213f
... ... @@ -43,7 +43,7 @@
43 43 return 1;
44 44  
45 45 /* read out the first block, get the config data information */
46   - n = mmc->block_dev.block_read(mmc->block_dev.dev, 0, 1, tmp_buf);
  46 + n = mmc->block_dev.block_read(&mmc->block_dev, 0, 1, tmp_buf);
47 47 if (!n) {
48 48 free(tmp_buf);
49 49 return 1;
... ... @@ -56,7 +56,7 @@
56 56 ", Block Size: %ld\n",
57 57 info.start, info.size, info.blksz);
58 58  
59   - if (dev_desc->block_read(dev, info.start, 1, (ulong *) addr) != 1) {
  59 + if (dev_desc->block_read(dev_desc, info.start, 1, (ulong *)addr) != 1) {
60 60 printf("** Read error on %d:%d\n", dev, part);
61 61 bootstage_error(BOOTSTAGE_ID_IDE_PART_READ);
62 62 return 1;
... ... @@ -100,8 +100,8 @@
100 100 cnt /= info.blksz;
101 101 cnt -= 1;
102 102  
103   - if (dev_desc->block_read(dev, info.start + 1, cnt,
104   - (ulong *)(addr + info.blksz)) != cnt) {
  103 + if (dev_desc->block_read(dev_desc, info.start + 1, cnt,
  104 + (ulong *)(addr + info.blksz)) != cnt) {
105 105 printf("** Read error on %d:%d\n", dev, part);
106 106 bootstage_error(BOOTSTAGE_ID_IDE_READ);
107 107 return 1;
... ... @@ -79,8 +79,8 @@
79 79  
80 80 #ifdef CONFIG_ATAPI
81 81 static void atapi_inquiry(block_dev_desc_t *dev_desc);
82   -static ulong atapi_read(int device, lbaint_t blknr, lbaint_t blkcnt,
83   - void *buffer);
  82 +static ulong atapi_read(block_dev_desc_t *block_dev, lbaint_t blknr,
  83 + lbaint_t blkcnt, void *buffer);
84 84 #endif
85 85  
86 86  
... ... @@ -187,6 +187,7 @@
187 187 if (strcmp(argv[1], "read") == 0) {
188 188 ulong addr = simple_strtoul(argv[2], NULL, 16);
189 189 ulong cnt = simple_strtoul(argv[4], NULL, 16);
  190 + block_dev_desc_t *dev_desc;
190 191 ulong n;
191 192  
192 193 #ifdef CONFIG_SYS_64BIT_LBA
... ... @@ -201,9 +202,9 @@
201 202 curr_device, blk, cnt);
202 203 #endif
203 204  
204   - n = ide_dev_desc[curr_device].block_read(curr_device,
205   - blk, cnt,
206   - (ulong *)addr);
  205 + dev_desc = &ide_dev_desc[curr_device];
  206 + n = dev_desc->block_read(dev_desc, blk, cnt,
  207 + (ulong *)addr);
207 208 /* flush cache after read */
208 209 flush_cache(addr,
209 210 cnt * ide_dev_desc[curr_device].blksz);
... ... @@ -230,7 +231,8 @@
230 231 printf("\nIDE write: device %d block # %ld, count %ld ... ",
231 232 curr_device, blk, cnt);
232 233 #endif
233   - n = ide_write(curr_device, blk, cnt, (ulong *) addr);
  234 + n = ide_write(&ide_dev_desc[curr_device], blk, cnt,
  235 + (ulong *)addr);
234 236  
235 237 printf("%ld blocks written: %s\n",
236 238 n, (n == cnt) ? "OK" : "ERROR");
237 239  
... ... @@ -711,8 +713,10 @@
711 713  
712 714 /* ------------------------------------------------------------------------- */
713 715  
714   -ulong ide_read(int device, lbaint_t blknr, lbaint_t blkcnt, void *buffer)
  716 +ulong ide_read(block_dev_desc_t *block_dev, lbaint_t blknr, lbaint_t blkcnt,
  717 + void *buffer)
715 718 {
  719 + int device = block_dev->dev;
716 720 ulong n = 0;
717 721 unsigned char c;
718 722 unsigned char pwrsave = 0; /* power save */
719 723  
... ... @@ -835,8 +839,10 @@
835 839 /* ------------------------------------------------------------------------- */
836 840  
837 841  
838   -ulong ide_write(int device, lbaint_t blknr, lbaint_t blkcnt, const void *buffer)
  842 +ulong ide_write(block_dev_desc_t *block_dev, lbaint_t blknr, lbaint_t blkcnt,
  843 + const void *buffer)
839 844 {
  845 + int device = block_dev->dev;
840 846 ulong n = 0;
841 847 unsigned char c;
842 848  
843 849  
... ... @@ -1388,8 +1394,10 @@
1388 1394 #define ATAPI_READ_BLOCK_SIZE 2048 /* assuming CD part */
1389 1395 #define ATAPI_READ_MAX_BLOCK (ATAPI_READ_MAX_BYTES/ATAPI_READ_BLOCK_SIZE)
1390 1396  
1391   -ulong atapi_read(int device, lbaint_t blknr, lbaint_t blkcnt, void *buffer)
  1397 +ulong atapi_read(block_dev_desc_t *block_dev, lbaint_t blknr, lbaint_t blkcnt,
  1398 + void *buffer)
1392 1399 {
  1400 + int device = block_dev->dev;
1393 1401 ulong n = 0;
1394 1402 unsigned char ccb[12]; /* Command descriptor block */
1395 1403 ulong cnt;
... ... @@ -351,7 +351,7 @@
351 351 printf("\nMMC read: dev # %d, block # %d, count %d ... ",
352 352 curr_device, blk, cnt);
353 353  
354   - n = mmc->block_dev.block_read(curr_device, blk, cnt, addr);
  354 + n = mmc->block_dev.block_read(&mmc->block_dev, blk, cnt, addr);
355 355 /* flush cache after read */
356 356 flush_cache((ulong)addr, cnt * 512); /* FIXME */
357 357 printf("%d blocks read: %s\n", n, (n == cnt) ? "OK" : "ERROR");
... ... @@ -383,7 +383,7 @@
383 383 printf("Error: card is write protected!\n");
384 384 return CMD_RET_FAILURE;
385 385 }
386   - n = mmc->block_dev.block_write(curr_device, blk, cnt, addr);
  386 + n = mmc->block_dev.block_write(&mmc->block_dev, blk, cnt, addr);
387 387 printf("%d blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR");
388 388  
389 389 return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
... ... @@ -411,7 +411,7 @@
411 411 printf("Error: card is write protected!\n");
412 412 return CMD_RET_FAILURE;
413 413 }
414   - n = mmc->block_dev.block_erase(curr_device, blk, cnt);
  414 + n = mmc->block_dev.block_erase(&mmc->block_dev, blk, cnt);
415 415 printf("%d blocks erased: %s\n", n, (n == cnt) ? "OK" : "ERROR");
416 416  
417 417 return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
... ... @@ -66,7 +66,7 @@
66 66 return 1;
67 67 }
68 68  
69   - if (dev_desc->block_read(dev, offset + blk, cnt, addr) < 0) {
  69 + if (dev_desc->block_read(dev_desc, offset + blk, cnt, addr) < 0) {
70 70 printf("Error reading blocks\n");
71 71 return 1;
72 72 }
... ... @@ -18,6 +18,18 @@
18 18 static int sata_curr_device = -1;
19 19 block_dev_desc_t sata_dev_desc[CONFIG_SYS_SATA_MAX_DEVICE];
20 20  
  21 +static unsigned long sata_bread(block_dev_desc_t *block_dev, lbaint_t start,
  22 + lbaint_t blkcnt, void *dst)
  23 +{
  24 + return sata_read(block_dev->dev, start, blkcnt, dst);
  25 +}
  26 +
  27 +static unsigned long sata_bwrite(block_dev_desc_t *block_dev, lbaint_t start,
  28 + lbaint_t blkcnt, const void *buffer)
  29 +{
  30 + return sata_write(block_dev->dev, start, blkcnt, buffer);
  31 +}
  32 +
21 33 int __sata_initialize(void)
22 34 {
23 35 int rc;
... ... @@ -32,8 +44,8 @@
32 44 sata_dev_desc[i].lba = 0;
33 45 sata_dev_desc[i].blksz = 512;
34 46 sata_dev_desc[i].log2blksz = LOG2(sata_dev_desc[i].blksz);
35   - sata_dev_desc[i].block_read = sata_read;
36   - sata_dev_desc[i].block_write = sata_write;
  47 + sata_dev_desc[i].block_read = sata_bread;
  48 + sata_dev_desc[i].block_write = sata_bwrite;
37 49  
38 50 rc = init_sata(i);
39 51 if (!rc) {
... ... @@ -66,9 +66,9 @@
66 66  
67 67 static int scsi_read_capacity(ccb *pccb, lbaint_t *capacity,
68 68 unsigned long *blksz);
69   -static ulong scsi_read(int device, lbaint_t blknr, lbaint_t blkcnt,
70   - void *buffer);
71   -static ulong scsi_write(int device, lbaint_t blknr,
  69 +static ulong scsi_read(block_dev_desc_t *block_dev, lbaint_t blknr,
  70 + lbaint_t blkcnt, void *buffer);
  71 +static ulong scsi_write(block_dev_desc_t *block_dev, lbaint_t blknr,
72 72 lbaint_t blkcnt, const void *buffer);
73 73  
74 74  
... ... @@ -346,7 +346,8 @@
346 346 ulong n;
347 347 printf ("\nSCSI read: device %d block # %ld, count %ld ... ",
348 348 scsi_curr_dev, blk, cnt);
349   - n = scsi_read(scsi_curr_dev, blk, cnt, (ulong *)addr);
  349 + n = scsi_read(&scsi_dev_desc[scsi_curr_dev],
  350 + blk, cnt, (ulong *)addr);
350 351 printf ("%ld blocks read: %s\n",n,(n==cnt) ? "OK" : "ERROR");
351 352 return 0;
352 353 } else if (strcmp(argv[1], "write") == 0) {
... ... @@ -357,8 +358,8 @@
357 358 printf("\nSCSI write: device %d block # %ld, "
358 359 "count %ld ... ",
359 360 scsi_curr_dev, blk, cnt);
360   - n = scsi_write(scsi_curr_dev, blk, cnt,
361   - (ulong *)addr);
  361 + n = scsi_write(&scsi_dev_desc[scsi_curr_dev],
  362 + blk, cnt, (ulong *)addr);
362 363 printf("%ld blocks written: %s\n", n,
363 364 (n == cnt) ? "OK" : "ERROR");
364 365 return 0;
365 366  
... ... @@ -375,9 +376,10 @@
375 376 #define SCSI_MAX_READ_BLK 0xFFFF
376 377 #define SCSI_LBA48_READ 0xFFFFFFF
377 378  
378   -static ulong scsi_read(int device, lbaint_t blknr, lbaint_t blkcnt,
379   - void *buffer)
  379 +static ulong scsi_read(block_dev_desc_t *block_dev, lbaint_t blknr,
  380 + lbaint_t blkcnt, void *buffer)
380 381 {
  382 + int device = block_dev->dev;
381 383 lbaint_t start, blks;
382 384 uintptr_t buf_addr;
383 385 unsigned short smallblks = 0;
384 386  
... ... @@ -441,9 +443,10 @@
441 443 /* Almost the maximum amount of the scsi_ext command.. */
442 444 #define SCSI_MAX_WRITE_BLK 0xFFFF
443 445  
444   -static ulong scsi_write(int device, lbaint_t blknr,
  446 +static ulong scsi_write(block_dev_desc_t *block_dev, lbaint_t blknr,
445 447 lbaint_t blkcnt, const void *buffer)
446 448 {
  449 + int device = block_dev->dev;
447 450 lbaint_t start, blks;
448 451 uintptr_t buf_addr;
449 452 unsigned short smallblks;
... ... @@ -759,7 +759,7 @@
759 759 printf("\nUSB read: device %d block # %ld, count %ld"
760 760 " ... ", usb_stor_curr_dev, blk, cnt);
761 761 stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
762   - n = stor_dev->block_read(usb_stor_curr_dev, blk, cnt,
  762 + n = stor_dev->block_read(stor_dev, blk, cnt,
763 763 (ulong *)addr);
764 764 printf("%ld blocks read: %s\n", n,
765 765 (n == cnt) ? "OK" : "ERROR");
... ... @@ -781,7 +781,7 @@
781 781 printf("\nUSB write: device %d block # %ld, count %ld"
782 782 " ... ", usb_stor_curr_dev, blk, cnt);
783 783 stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
784   - n = stor_dev->block_write(usb_stor_curr_dev, blk, cnt,
  784 + n = stor_dev->block_write(stor_dev, blk, cnt,
785 785 (ulong *)addr);
786 786 printf("%ld blocks write: %s\n", n,
787 787 (n == cnt) ? "OK" : "ERROR");
common/cmd_usb_mass_storage.c
Diff comments   View file @ 7c4213f
... ... @@ -19,9 +19,8 @@
19 19 {
20 20 block_dev_desc_t *block_dev = ums_dev->block_dev;
21 21 lbaint_t blkstart = start + ums_dev->start_sector;
22   - int dev_num = block_dev->dev;
23 22  
24   - return block_dev->block_read(dev_num, blkstart, blkcnt, buf);
  23 + return block_dev->block_read(block_dev, blkstart, blkcnt, buf);
25 24 }
26 25  
27 26 static int ums_write_sector(struct ums *ums_dev,
28 27  
... ... @@ -29,9 +28,8 @@
29 28 {
30 29 block_dev_desc_t *block_dev = ums_dev->block_dev;
31 30 lbaint_t blkstart = start + ums_dev->start_sector;
32   - int dev_num = block_dev->dev;
33 31  
34   - return block_dev->block_write(dev_num, blkstart, blkcnt, buf);
  32 + return block_dev->block_write(block_dev, blkstart, blkcnt, buf);
35 33 }
36 34  
37 35 static struct ums ums_dev = {
... ... @@ -127,7 +127,7 @@
127 127 blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
128 128 blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
129 129  
130   - n = mmc->block_dev.block_write(CONFIG_SYS_MMC_ENV_DEV, blk_start,
  130 + n = mmc->block_dev.block_write(&mmc->block_dev, blk_start,
131 131 blk_cnt, (u_char *)buffer);
132 132  
133 133 return (n == blk_cnt) ? 0 : -1;
134 134  
135 135  
... ... @@ -192,16 +192,12 @@
192 192 unsigned long offset, const void *buffer)
193 193 {
194 194 uint blk_start, blk_cnt, n;
195   - int dev = CONFIG_SYS_MMC_ENV_DEV;
196 195  
197   -#ifdef CONFIG_SPL_BUILD
198   - dev = 0;
199   -#endif
200   -
201 196 blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
202 197 blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
203 198  
204   - n = mmc->block_dev.block_read(dev, blk_start, blk_cnt, (uchar *)buffer);
  199 + n = mmc->block_dev.block_read(&mmc->block_dev, blk_start, blk_cnt,
  200 + (uchar *)buffer);
205 201  
206 202 return (n == blk_cnt) ? 0 : -1;
207 203 }
... ... @@ -58,7 +58,7 @@
58 58 block_dev_desc_t *dev_desc = sparse->dev_desc;
59 59 int ret;
60 60  
61   - ret = dev_desc->block_write(dev_desc->dev, offset, size, data);
  61 + ret = dev_desc->block_write(dev_desc, offset, size, data);
62 62 if (!ret)
63 63 return -EIO;
64 64  
... ... @@ -84,8 +84,7 @@
84 84  
85 85 puts("Flashing Raw Image\n");
86 86  
87   - blks = dev_desc->block_write(dev_desc->dev, info->start, blkcnt,
88   - buffer);
  87 + blks = dev_desc->block_write(dev_desc, info->start, blkcnt, buffer);
89 88 if (blks != blkcnt) {
90 89 error("failed writing to device %d\n", dev_desc->dev);
91 90 fastboot_fail(response_str, "failed writing to device");
... ... @@ -206,7 +205,7 @@
206 205 printf("Erasing blocks " LBAFU " to " LBAFU " due to alignment\n",
207 206 blks_start, blks_start + blks_size);
208 207  
209   - blks = dev_desc->block_erase(dev_desc->dev, blks_start, blks_size);
  208 + blks = dev_desc->block_erase(dev_desc, blks_start, blks_size);
210 209 if (blks != blks_size) {
211 210 error("failed erasing from device %d", dev_desc->dev);
212 211 fastboot_fail(response_str, "failed erasing from device");
common/spl/spl_mmc.c
Diff comments   View file @ 7c4213f
... ... @@ -23,13 +23,12 @@
23 23 unsigned long count;
24 24 u32 image_size_sectors;
25 25 struct image_header *header;
26   - int dev_num = mmc->block_dev.dev;
27 26  
28 27 header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
29 28 sizeof(struct image_header));
30 29  
31 30 /* read image header to find the image size & load address */
32   - count = mmc->block_dev.block_read(dev_num, sector, 1, header);
  31 + count = mmc->block_dev.block_read(&mmc->block_dev, sector, 1, header);
33 32 debug("read sector %lx, count=%lu\n", sector, count);
34 33 if (count == 0)
35 34 goto end;
... ... @@ -46,7 +45,8 @@
46 45 mmc->read_bl_len;
47 46  
48 47 /* Read the header too to avoid extra memcpy */
49   - count = mmc->block_dev.block_read(dev_num, sector, image_size_sectors,
  48 + count = mmc->block_dev.block_read(&mmc->block_dev, sector,
  49 + image_size_sectors,
50 50 (void *)(ulong)spl_image.load_addr);
51 51 debug("read %x sectors to %x\n", image_size_sectors,
52 52 spl_image.load_addr);
... ... @@ -150,8 +150,7 @@
150 150 {
151 151 unsigned long count;
152 152  
153   - count = mmc->block_dev.block_read(
154   - mmc->block_dev.dev,
  153 + count = mmc->block_dev.block_read(&mmc->block_dev,
155 154 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR,
156 155 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS,
157 156 (void *) CONFIG_SYS_SPL_ARGS_ADDR);
common/usb_storage.c
Diff comments   View file @ 7c4213f
... ... @@ -119,10 +119,10 @@
119 119 block_dev_desc_t *dev_desc);
120 120 int usb_storage_probe(struct usb_device *dev, unsigned int ifnum,
121 121 struct us_data *ss);
122   -unsigned long usb_stor_read(int device, lbaint_t blknr,
123   - lbaint_t blkcnt, void *buffer);
124   -unsigned long usb_stor_write(int device, lbaint_t blknr,
125   - lbaint_t blkcnt, const void *buffer);
  122 +static unsigned long usb_stor_read(block_dev_desc_t *block_dev, lbaint_t blknr,
  123 + lbaint_t blkcnt, void *buffer);
  124 +static unsigned long usb_stor_write(block_dev_desc_t *block_dev, lbaint_t blknr,
  125 + lbaint_t blkcnt, const void *buffer);
126 126 void uhci_show_temp_int_td(void);
127 127  
128 128 #ifdef CONFIG_PARTITIONS
129 129  
... ... @@ -1027,9 +1027,10 @@
1027 1027 }
1028 1028 #endif /* CONFIG_USB_BIN_FIXUP */
1029 1029  
1030   -unsigned long usb_stor_read(int device, lbaint_t blknr,
1031   - lbaint_t blkcnt, void *buffer)
  1030 +static unsigned long usb_stor_read(block_dev_desc_t *block_dev, lbaint_t blknr,
  1031 + lbaint_t blkcnt, void *buffer)
1032 1032 {
  1033 + int device = block_dev->dev;
1033 1034 lbaint_t start, blks;
1034 1035 uintptr_t buf_addr;
1035 1036 unsigned short smallblks;
1036 1037  
... ... @@ -1097,9 +1098,10 @@
1097 1098 return blkcnt;
1098 1099 }
1099 1100  
1100   -unsigned long usb_stor_write(int device, lbaint_t blknr,
1101   - lbaint_t blkcnt, const void *buffer)
  1101 +static unsigned long usb_stor_write(block_dev_desc_t *block_dev, lbaint_t blknr,
  1102 + lbaint_t blkcnt, const void *buffer)
1102 1103 {
  1104 + int device = block_dev->dev;
1103 1105 lbaint_t start, blks;
1104 1106 uintptr_t buf_addr;
1105 1107 unsigned short smallblks;
... ... @@ -140,8 +140,7 @@
140 140  
141 141 for (i=0; i<limit; i++)
142 142 {
143   - ulong res = dev_desc->block_read(dev_desc->dev, i, 1,
144   - (ulong *)block_buffer);
  143 + ulong res = dev_desc->block_read(dev_desc, i, 1, (ulong *)block_buffer);
145 144 if (res == 1)
146 145 {
147 146 struct rigid_disk_block *trdb = (struct rigid_disk_block *)block_buffer;
... ... @@ -183,7 +182,7 @@
183 182  
184 183 for (i = 0; i < limit; i++)
185 184 {
186   - ulong res = dev_desc->block_read(dev_desc->dev, i, 1, (ulong *)block_buffer);
  185 + ulong res = dev_desc->block_read(dev_desc, i, 1, (ulong *)block_buffer);
187 186 if (res == 1)
188 187 {
189 188 struct bootcode_block *boot = (struct bootcode_block *)block_buffer;
... ... @@ -258,7 +257,7 @@
258 257  
259 258 while (block != 0xFFFFFFFF)
260 259 {
261   - ulong res = dev_desc->block_read(dev_desc->dev, block, 1,
  260 + ulong res = dev_desc->block_read(dev_desc, block, 1,
262 261 (ulong *)block_buffer);
263 262 if (res == 1)
264 263 {
... ... @@ -354,8 +353,7 @@
354 353  
355 354 PRINTF("Trying to load block #0x%X\n", block);
356 355  
357   - res = dev_desc->block_read(dev_desc->dev, block, 1,
358   - (ulong *)block_buffer);
  356 + res = dev_desc->block_read(dev_desc, block, 1, (ulong *)block_buffer);
359 357 if (res == 1)
360 358 {
361 359 p = (struct partition_block *)block_buffer;
... ... @@ -91,7 +91,7 @@
91 91 {
92 92 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, dev_desc->blksz);
93 93  
94   - if (dev_desc->block_read(dev_desc->dev, 0, 1, (ulong *) buffer) != 1)
  94 + if (dev_desc->block_read(dev_desc, 0, 1, (ulong *)buffer) != 1)
95 95 return -1;
96 96  
97 97 if (test_block_type(buffer) != DOS_MBR)
... ... @@ -111,7 +111,8 @@
111 111 dos_partition_t *pt;
112 112 int i;
113 113  
114   - if (dev_desc->block_read(dev_desc->dev, ext_part_sector, 1, (ulong *) buffer) != 1) {
  114 + if (dev_desc->block_read(dev_desc, ext_part_sector, 1,
  115 + (ulong *)buffer) != 1) {
115 116 printf ("** Can't read partition table on %d:" LBAFU " **\n",
116 117 dev_desc->dev, ext_part_sector);
117 118 return;
... ... @@ -177,7 +178,8 @@
177 178 int i;
178 179 int dos_type;
179 180  
180   - if (dev_desc->block_read (dev_desc->dev, ext_part_sector, 1, (ulong *) buffer) != 1) {
  181 + if (dev_desc->block_read(dev_desc, ext_part_sector, 1,
  182 + (ulong *)buffer) != 1) {
181 183 printf ("** Can't read partition table on %d:" LBAFU " **\n",
182 184 dev_desc->dev, ext_part_sector);
183 185 return -1;
... ... @@ -324,7 +324,7 @@
324 324 ALLOC_CACHE_ALIGN_BUFFER_PAD(legacy_mbr, legacymbr, 1, dev_desc->blksz);
325 325  
326 326 /* Read legacy MBR from block 0 and validate it */
327   - if ((dev_desc->block_read(dev_desc->dev, 0, 1, (ulong *)legacymbr) != 1)
  327 + if ((dev_desc->block_read(dev_desc, 0, 1, (ulong *)legacymbr) != 1)
328 328 || (is_pmbr_valid(legacymbr) != 1)) {
329 329 return -1;
330 330 }
... ... @@ -354,7 +354,7 @@
354 354 p_mbr->partition_record[0].nr_sects = (u32) dev_desc->lba - 1;
355 355  
356 356 /* Write MBR sector to the MMC device */
357   - if (dev_desc->block_write(dev_desc->dev, 0, 1, p_mbr) != 1) {
  357 + if (dev_desc->block_write(dev_desc, 0, 1, p_mbr) != 1) {
358 358 printf("** Can't write to device %d **\n",
359 359 dev_desc->dev);
360 360 return -1;
361 361  
362 362  
363 363  
... ... @@ -386,22 +386,22 @@
386 386 gpt_h->header_crc32 = cpu_to_le32(calc_crc32);
387 387  
388 388 /* Write the First GPT to the block right after the Legacy MBR */
389   - if (dev_desc->block_write(dev_desc->dev, 1, 1, gpt_h) != 1)
  389 + if (dev_desc->block_write(dev_desc, 1, 1, gpt_h) != 1)
390 390 goto err;
391 391  
392   - if (dev_desc->block_write(dev_desc->dev, 2, pte_blk_cnt, gpt_e)
  392 + if (dev_desc->block_write(dev_desc, 2, pte_blk_cnt, gpt_e)
393 393 != pte_blk_cnt)
394 394 goto err;
395 395  
396 396 prepare_backup_gpt_header(gpt_h);
397 397  
398   - if (dev_desc->block_write(dev_desc->dev,
  398 + if (dev_desc->block_write(dev_desc,
399 399 (lbaint_t)le64_to_cpu(gpt_h->last_usable_lba)
400 400 + 1,
401 401 pte_blk_cnt, gpt_e) != pte_blk_cnt)
402 402 goto err;
403 403  
404   - if (dev_desc->block_write(dev_desc->dev,
  404 + if (dev_desc->block_write(dev_desc,
405 405 (lbaint_t)le64_to_cpu(gpt_h->my_lba), 1,
406 406 gpt_h) != 1)
407 407 goto err;
... ... @@ -737,7 +737,7 @@
737 737 /* write MBR */
738 738 lba = 0; /* MBR is always at 0 */
739 739 cnt = 1; /* MBR (1 block) */
740   - if (dev_desc->block_write(dev_desc->dev, lba, cnt, buf) != cnt) {
  740 + if (dev_desc->block_write(dev_desc, lba, cnt, buf) != cnt) {
741 741 printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
742 742 __func__, "MBR", cnt, lba);
743 743 return 1;
... ... @@ -746,7 +746,7 @@
746 746 /* write Primary GPT */
747 747 lba = GPT_PRIMARY_PARTITION_TABLE_LBA;
748 748 cnt = 1; /* GPT Header (1 block) */
749   - if (dev_desc->block_write(dev_desc->dev, lba, cnt, gpt_h) != cnt) {
  749 + if (dev_desc->block_write(dev_desc, lba, cnt, gpt_h) != cnt) {
750 750 printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
751 751 __func__, "Primary GPT Header", cnt, lba);
752 752 return 1;
... ... @@ -754,7 +754,7 @@
754 754  
755 755 lba = le64_to_cpu(gpt_h->partition_entry_lba);
756 756 cnt = gpt_e_blk_cnt;
757   - if (dev_desc->block_write(dev_desc->dev, lba, cnt, gpt_e) != cnt) {
  757 + if (dev_desc->block_write(dev_desc, lba, cnt, gpt_e) != cnt) {
758 758 printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
759 759 __func__, "Primary GPT Entries", cnt, lba);
760 760 return 1;
... ... @@ -765,7 +765,7 @@
765 765 /* write Backup GPT */
766 766 lba = le64_to_cpu(gpt_h->partition_entry_lba);
767 767 cnt = gpt_e_blk_cnt;
768   - if (dev_desc->block_write(dev_desc->dev, lba, cnt, gpt_e) != cnt) {
  768 + if (dev_desc->block_write(dev_desc, lba, cnt, gpt_e) != cnt) {
769 769 printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
770 770 __func__, "Backup GPT Entries", cnt, lba);
771 771 return 1;
... ... @@ -773,7 +773,7 @@
773 773  
774 774 lba = le64_to_cpu(gpt_h->my_lba);
775 775 cnt = 1; /* GPT Header (1 block) */
776   - if (dev_desc->block_write(dev_desc->dev, lba, cnt, gpt_h) != cnt) {
  776 + if (dev_desc->block_write(dev_desc, lba, cnt, gpt_h) != cnt) {
777 777 printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
778 778 __func__, "Backup GPT Header", cnt, lba);
779 779 return 1;
... ... @@ -843,8 +843,7 @@
843 843 }
844 844  
845 845 /* Read GPT Header from device */
846   - if (dev_desc->block_read(dev_desc->dev, (lbaint_t)lba, 1, pgpt_head)
847   - != 1) {
  846 + if (dev_desc->block_read(dev_desc, (lbaint_t)lba, 1, pgpt_head) != 1) {
848 847 printf("*** ERROR: Can't read GPT header ***\n");
849 848 return 0;
850 849 }
... ... @@ -881,6 +880,7 @@
881 880 gpt_header * pgpt_head)
882 881 {
883 882 size_t count = 0, blk_cnt;
  883 + lbaint_t blk;
884 884 gpt_entry *pte = NULL;
885 885  
886 886 if (!dev_desc || !pgpt_head) {
887 887  
... ... @@ -909,12 +909,10 @@
909 909 }
910 910  
911 911 /* Read GPT Entries from device */
  912 + blk = le64_to_cpu(pgpt_head->partition_entry_lba);
912 913 blk_cnt = BLOCK_CNT(count, dev_desc);
913   - if (dev_desc->block_read (dev_desc->dev,
914   - (lbaint_t)le64_to_cpu(pgpt_head->partition_entry_lba),
915   - (lbaint_t) (blk_cnt), pte)
916   - != blk_cnt) {
917   -
  914 + if (dev_desc->block_read(dev_desc, blk, (lbaint_t)blk_cnt, pte)
  915 + != blk_cnt) {
918 916 printf("*** ERROR: Can't read GPT Entries ***\n");
919 917 free(pte);
920 918 return NULL;
... ... @@ -62,8 +62,8 @@
62 62  
63 63 /* the first sector (sector 0x10) must be a primary volume desc */
64 64 blkaddr=PVD_OFFSET;
65   - if (dev_desc->block_read (dev_desc->dev, PVD_OFFSET, 1, (ulong *) tmpbuf) != 1)
66   - return (-1);
  65 + if (dev_desc->block_read(dev_desc, PVD_OFFSET, 1, (ulong *)tmpbuf) != 1)
  66 + return -1;
67 67 if(ppr->desctype!=0x01) {
68 68 if(verb)
69 69 printf ("** First descriptor is NOT a primary desc on %d:%d **\n",
... ... @@ -84,8 +84,8 @@
84 84 PRINTF(" Lastsect:%08lx\n",lastsect);
85 85 for(i=blkaddr;i<lastsect;i++) {
86 86 PRINTF("Reading block %d\n", i);
87   - if (dev_desc->block_read (dev_desc->dev, i, 1, (ulong *) tmpbuf) != 1)
88   - return (-1);
  87 + if (dev_desc->block_read(dev_desc, i, 1, (ulong *)tmpbuf) != 1)
  88 + return -1;
89 89 if(ppr->desctype==0x00)
90 90 break; /* boot entry found */
91 91 if(ppr->desctype==0xff) {
... ... @@ -104,7 +104,7 @@
104 104 }
105 105 bootaddr=le32_to_int(pbr->pointer);
106 106 PRINTF(" Boot Entry at: %08lX\n",bootaddr);
107   - if (dev_desc->block_read (dev_desc->dev, bootaddr, 1, (ulong *) tmpbuf) != 1) {
  107 + if (dev_desc->block_read(dev_desc, bootaddr, 1, (ulong *)tmpbuf) != 1) {
108 108 if(verb)
109 109 printf ("** Can't read Boot Entry at %lX on %d:%d **\n",
110 110 bootaddr,dev_desc->dev, part_num);
... ... @@ -51,7 +51,8 @@
51 51  
52 52 n = 1; /* assuming at least one partition */
53 53 for (i=1; i<=n; ++i) {
54   - if ((dev_desc->block_read(dev_desc->dev, i, 1, (ulong *)mpart) != 1) ||
  54 + if ((dev_desc->block_read(dev_desc, i, 1,
  55 + (ulong *)mpart) != 1) ||
55 56 (mpart->signature != MAC_PARTITION_MAGIC) ) {
56 57 return (-1);
57 58 }
... ... @@ -104,7 +105,7 @@
104 105 char c;
105 106  
106 107 printf ("%4ld: ", i);
107   - if (dev_desc->block_read (dev_desc->dev, i, 1, (ulong *)mpart) != 1) {
  108 + if (dev_desc->block_read(dev_desc, i, 1, (ulong *)mpart) != 1) {
108 109 printf ("** Can't read Partition Map on %d:%ld **\n",
109 110 dev_desc->dev, i);
110 111 return;
... ... @@ -150,7 +151,7 @@
150 151 */
151 152 static int part_mac_read_ddb (block_dev_desc_t *dev_desc, mac_driver_desc_t *ddb_p)
152 153 {
153   - if (dev_desc->block_read(dev_desc->dev, 0, 1, (ulong *)ddb_p) != 1) {
  154 + if (dev_desc->block_read(dev_desc, 0, 1, (ulong *)ddb_p) != 1) {
154 155 printf ("** Can't read Driver Desriptor Block **\n");
155 156 return (-1);
156 157 }
... ... @@ -178,7 +179,7 @@
178 179 * partition 1 first since this is the only way to
179 180 * know how many partitions we have.
180 181 */
181   - if (dev_desc->block_read (dev_desc->dev, n, 1, (ulong *)pdb_p) != 1) {
  182 + if (dev_desc->block_read(dev_desc, n, 1, (ulong *)pdb_p) != 1) {
182 183 printf ("** Can't read Partition Map on %d:%d **\n",
183 184 dev_desc->dev, n);
184 185 return (-1);
drivers/block/sandbox.c
Diff comments   View file @ 7c4213f
... ... @@ -22,9 +22,11 @@
22 22 return NULL;
23 23 }
24 24  
25   -static unsigned long host_block_read(int dev, unsigned long start,
26   - lbaint_t blkcnt, void *buffer)
  25 +static unsigned long host_block_read(block_dev_desc_t *block_dev,
  26 + unsigned long start, lbaint_t blkcnt,
  27 + void *buffer)
27 28 {
  29 + int dev = block_dev->dev;
28 30 struct host_block_dev *host_dev = find_host_device(dev);
29 31  
30 32 if (!host_dev)
31 33  
... ... @@ -42,9 +44,11 @@
42 44 return -1;
43 45 }
44 46  
45   -static unsigned long host_block_write(int dev, unsigned long start,
46   - lbaint_t blkcnt, const void *buffer)
  47 +static unsigned long host_block_write(block_dev_desc_t *block_dev,
  48 + unsigned long start, lbaint_t blkcnt,
  49 + const void *buffer)
47 50 {
  51 + int dev = block_dev->dev;
48 52 struct host_block_dev *host_dev = find_host_device(dev);
49 53 if (os_lseek(host_dev->fd,
50 54 start * host_dev->blk_dev.blksz,
drivers/block/systemace.c
Diff comments   View file @ 7c4213f
... ... @@ -69,8 +69,9 @@
69 69 return in16(base + off);
70 70 }
71 71  
72   -static unsigned long systemace_read(int dev, unsigned long start,
73   - lbaint_t blkcnt, void *buffer);
  72 +static unsigned long systemace_read(block_dev_desc_t *block_dev,
  73 + unsigned long start, lbaint_t blkcnt,
  74 + void *buffer);
74 75  
75 76 static block_dev_desc_t systemace_dev = { 0 };
76 77  
... ... @@ -136,8 +137,9 @@
136 137 * the dev_desc) to read blocks of data. The return value is the
137 138 * number of blocks read. A zero return indicates an error.
138 139 */
139   -static unsigned long systemace_read(int dev, unsigned long start,
140   - lbaint_t blkcnt, void *buffer)
  140 +static unsigned long systemace_read(block_dev_desc_t *block_dev,
  141 + unsigned long start, lbaint_t blkcnt,
  142 + void *buffer)
141 143 {
142 144 int retry;
143 145 unsigned blk_countdown;
drivers/dfu/dfu_mmc.c
Diff comments   View file @ 7c4213f
... ... @@ -77,11 +77,11 @@
77 77 dfu->data.mmc.dev_num, blk_start, blk_count, buf);
78 78 switch (op) {
79 79 case DFU_OP_READ:
80   - n = mmc->block_dev.block_read(dfu->data.mmc.dev_num, blk_start,
  80 + n = mmc->block_dev.block_read(&mmc->block_dev, blk_start,
81 81 blk_count, buf);
82 82 break;
83 83 case DFU_OP_WRITE:
84   - n = mmc->block_dev.block_write(dfu->data.mmc.dev_num, blk_start,
  84 + n = mmc->block_dev.block_write(&mmc->block_dev, blk_start,
85 85 blk_count, buf);
86 86 break;
87 87 default:
drivers/mmc/fsl_esdhc_spl.c
Diff comments   View file @ 7c4213f
... ... @@ -38,7 +38,8 @@
38 38 blk_start = ALIGN(offs, mmc->read_bl_len) / mmc->read_bl_len;
39 39 blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
40 40  
41   - err = mmc->block_dev.block_read(0, blk_start, blk_cnt, vdst);
  41 + err = mmc->block_dev.block_read(&mmc->block_dev, blk_start, blk_cnt,
  42 + vdst);
42 43 if (err != blk_cnt) {
43 44 puts("spl: mmc read failed!!\n");
44 45 hang();
... ... @@ -85,7 +86,8 @@
85 86 /*
86 87 * Read source addr from sd card
87 88 */
88   - err = mmc->block_dev.block_read(0, CONFIG_CFG_DATA_SECTOR, 1, tmp_buf);
  89 + err = mmc->block_dev.block_read(&mmc->block_dev,
  90 + CONFIG_CFG_DATA_SECTOR, 1, tmp_buf);
89 91 if (err != 1) {
90 92 puts("spl: mmc read failed!!\n");
91 93 free(tmp_buf);
... ... @@ -126,7 +128,7 @@
126 128 #endif
127 129 blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
128 130 blk_cnt = ALIGN(code_len, mmc->read_bl_len) / mmc->read_bl_len;
129   - err = mmc->block_dev.block_read(0, blk_start, blk_cnt,
  131 + err = mmc->block_dev.block_read(&mmc->block_dev, blk_start, blk_cnt,
130 132 (uchar *)CONFIG_SYS_MMC_U_BOOT_DST);
131 133 if (err != blk_cnt) {
132 134 puts("spl: mmc read failed!!\n");
... ... @@ -234,8 +234,10 @@
234 234 return blkcnt;
235 235 }
236 236  
237   -static ulong mmc_bread(int dev_num, lbaint_t start, lbaint_t blkcnt, void *dst)
  237 +static ulong mmc_bread(block_dev_desc_t *block_dev, lbaint_t start,
  238 + lbaint_t blkcnt, void *dst)
238 239 {
  240 + int dev_num = block_dev->dev;
239 241 lbaint_t cur, blocks_todo = blkcnt;
240 242  
241 243 if (blkcnt == 0)
drivers/mmc/mmc_private.h
Diff comments   View file @ 7c4213f
... ... @@ -22,23 +22,24 @@
22 22  
23 23 #ifndef CONFIG_SPL_BUILD
24 24  
25   -extern unsigned long mmc_berase(int dev_num, lbaint_t start, lbaint_t blkcnt);
  25 +unsigned long mmc_berase(block_dev_desc_t *block_dev, lbaint_t start,
  26 + lbaint_t blkcnt);
26 27  
27   -extern ulong mmc_bwrite(int dev_num, lbaint_t start, lbaint_t blkcnt,
28   - const void *src);
  28 +unsigned long mmc_bwrite(block_dev_desc_t *block_dev, lbaint_t start,
  29 + lbaint_t blkcnt, const void *src);
29 30  
30 31 #else /* CONFIG_SPL_BUILD */
31 32  
32 33 /* SPL will never write or erase, declare dummies to reduce code size. */
33 34  
34   -static inline unsigned long mmc_berase(int dev_num, lbaint_t start,
35   - lbaint_t blkcnt)
  35 +static inline unsigned long mmc_berase(block_dev_desc_t *block_dev,
  36 + lbaint_t start, lbaint_t blkcnt)
36 37 {
37 38 return 0;
38 39 }
39 40  
40   -static inline ulong mmc_bwrite(int dev_num, lbaint_t start, lbaint_t blkcnt,
41   - const void *src)
  41 +static inline ulong mmc_bwrite(block_dev_desc_t *block_dev, lbaint_t start,
  42 + lbaint_t blkcnt, const void *src)
42 43 {
43 44 return 0;
44 45 }
drivers/mmc/mmc_write.c
Diff comments   View file @ 7c4213f
... ... @@ -65,8 +65,10 @@
65 65 return err;
66 66 }
67 67  
68   -unsigned long mmc_berase(int dev_num, lbaint_t start, lbaint_t blkcnt)
  68 +unsigned long mmc_berase(block_dev_desc_t *block_dev, lbaint_t start,
  69 + lbaint_t blkcnt)
69 70 {
  71 + int dev_num = block_dev->dev;
70 72 int err = 0;
71 73 u32 start_rem, blkcnt_rem;
72 74 struct mmc *mmc = find_mmc_device(dev_num);
73 75  
... ... @@ -165,8 +167,10 @@
165 167 return blkcnt;
166 168 }
167 169  
168   -ulong mmc_bwrite(int dev_num, lbaint_t start, lbaint_t blkcnt, const void *src)
  170 +ulong mmc_bwrite(block_dev_desc_t *block_dev, lbaint_t start, lbaint_t blkcnt,
  171 + const void *src)
169 172 {
  173 + int dev_num = block_dev->dev;
170 174 lbaint_t cur, blocks_todo = blkcnt;
171 175  
172 176 struct mmc *mmc = find_mmc_device(dev_num);
drivers/mmc/sunxi_mmc.c
Diff comments   View file @ 7c4213f
... ... @@ -454,7 +454,7 @@
454 454 panic("Failed to allocate memory\n");
455 455  
456 456 if (mmc_getcd(mmc) && mmc_init(mmc) == 0 &&
457   - mmc->block_dev.block_read(mmc->block_dev.dev, 16, 1, buf) == 1 &&
  457 + mmc->block_dev.block_read(&mmc->block_dev, 16, 1, buf) == 1 &&
458 458 strncmp(&buf[4], "eGON.BT0", 8) == 0)
459 459 valid_signature = 1;
460 460  
... ... @@ -395,7 +395,8 @@
395 395 printf("\nMMC read: dev # %u, block # %u, count %u ...\n",
396 396 dev, blk, cnt);
397 397 mmc_init(mmc);
398   - (void)mmc->block_dev.block_read(dev, blk, cnt, addr);
  398 + (void)mmc->block_dev.block_read(&mmc->block_dev, blk, cnt,
  399 + addr);
399 400 /* flush cache after read */
400 401 flush_cache((ulong)addr, cnt * 512);
401 402 }
drivers/net/phy/cortina.c
Diff comments   View file @ 7c4213f
... ... @@ -174,7 +174,8 @@
174 174 printf("MMC read: dev # %u, block # %u, count %u ...\n",
175 175 dev, blk, cnt);
176 176 mmc_init(mmc);
177   - (void)mmc->block_dev.block_read(dev, blk, cnt, addr);
  177 + (void)mmc->block_dev.block_read(&mmc->block_dev, blk, cnt,
  178 + addr);
178 179 /* flush cache after read */
179 180 flush_cache((ulong)addr, cnt * 512);
180 181 }
... ... @@ -76,10 +76,10 @@
76 76 if (byte_offset != 0) {
77 77 int readlen;
78 78 /* read first part which isn't aligned with start of sector */
79   - if (ext4fs_block_dev_desc->
80   - block_read(ext4fs_block_dev_desc->dev,
81   - part_info->start + sector, 1,
82   - (unsigned long *) sec_buf) != 1) {
  79 + if (ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc,
  80 + part_info->start + sector,
  81 + 1, (void *)sec_buf)
  82 + != 1) {
83 83 printf(" ** ext2fs_devread() read error **\n");
84 84 return 0;
85 85 }
86 86  
87 87  
... ... @@ -101,18 +101,18 @@
101 101 ALLOC_CACHE_ALIGN_BUFFER(u8, p, ext4fs_block_dev_desc->blksz);
102 102  
103 103 block_len = ext4fs_block_dev_desc->blksz;
104   - ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc->dev,
  104 + ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc,
105 105 part_info->start + sector,
106   - 1, (unsigned long *)p);
  106 + 1, (void *)p);
107 107 memcpy(buf, p, byte_len);
108 108 return 1;
109 109 }
110 110  
111   - if (ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc->dev,
112   - part_info->start + sector,
113   - block_len >> log2blksz,
114   - (unsigned long *) buf) !=
115   - block_len >> log2blksz) {
  111 + if (ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc,
  112 + part_info->start + sector,
  113 + block_len >> log2blksz,
  114 + (void *)buf) !=
  115 + block_len >> log2blksz) {
116 116 printf(" ** %s read error - block\n", __func__);
117 117 return 0;
118 118 }
... ... @@ -123,10 +123,10 @@
123 123  
124 124 if (byte_len != 0) {
125 125 /* read rest of data which are not in whole sector */
126   - if (ext4fs_block_dev_desc->
127   - block_read(ext4fs_block_dev_desc->dev,
128   - part_info->start + sector, 1,
129   - (unsigned long *) sec_buf) != 1) {
  126 + if (ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc,
  127 + part_info->start + sector,
  128 + 1, (void *)sec_buf)
  129 + != 1) {
130 130 printf("* %s read error - last part\n", __func__);
131 131 return 0;
132 132 }
fs/ext4/ext4_common.c
Diff comments   View file @ 7c4213f
... ... @@ -82,26 +82,26 @@
82 82  
83 83 if (remainder) {
84 84 if (fs->dev_desc->block_read) {
85   - fs->dev_desc->block_read(fs->dev_desc->dev,
  85 + fs->dev_desc->block_read(fs->dev_desc,
86 86 startblock, 1, sec_buf);
87 87 temp_ptr = sec_buf;
88 88 memcpy((temp_ptr + remainder),
89 89 (unsigned char *)buf, size);
90   - fs->dev_desc->block_write(fs->dev_desc->dev,
  90 + fs->dev_desc->block_write(fs->dev_desc,
91 91 startblock, 1, sec_buf);
92 92 }
93 93 } else {
94 94 if (size >> log2blksz != 0) {
95   - fs->dev_desc->block_write(fs->dev_desc->dev,
  95 + fs->dev_desc->block_write(fs->dev_desc,
96 96 startblock,
97 97 size >> log2blksz,
98 98 (unsigned long *)buf);
99 99 } else {
100   - fs->dev_desc->block_read(fs->dev_desc->dev,
  100 + fs->dev_desc->block_read(fs->dev_desc,
101 101 startblock, 1, sec_buf);
102 102 temp_ptr = sec_buf;
103 103 memcpy(temp_ptr, buf, size);
104   - fs->dev_desc->block_write(fs->dev_desc->dev,
  104 + fs->dev_desc->block_write(fs->dev_desc,
105 105 startblock, 1,
106 106 (unsigned long *)sec_buf);
107 107 }
... ... @@ -51,8 +51,8 @@
51 51 if (!cur_dev || !cur_dev->block_read)
52 52 return -1;
53 53  
54   - ret = cur_dev->block_read(cur_dev->dev,
55   - cur_part_info.start + block, nr_blocks, buf);
  54 + ret = cur_dev->block_read(cur_dev, cur_part_info.start + block,
  55 + nr_blocks, buf);
56 56  
57 57 if (nr_blocks && ret == 0)
58 58 return -1;
... ... @@ -41,8 +41,7 @@
41 41 return -1;
42 42 }
43 43  
44   - ret = cur_dev->block_write(cur_dev->dev,
45   - cur_part_info.start + block,
  44 + ret = cur_dev->block_write(cur_dev, cur_part_info.start + block,
46 45 nr_blocks, buf);
47 46 if (nr_blocks && ret == 0)
48 47 return -1;
... ... @@ -59,9 +59,11 @@
59 59  
60 60 if (byte_offset != 0) {
61 61 /* read first part which isn't aligned with start of sector */
62   - if (reiserfs_block_dev_desc->block_read(reiserfs_block_dev_desc->dev,
63   - part_info->start + sector, 1,
64   - (unsigned long *)sec_buf) != 1) {
  62 + if (reiserfs_block_dev_desc->block_read(reiserfs_block_dev_desc,
  63 + part_info->start +
  64 + sector,
  65 + 1, (void *)sec_buf)
  66 + != 1) {
65 67 printf (" ** reiserfs_devread() read error\n");
66 68 return 0;
67 69 }
... ... @@ -73,9 +75,11 @@
73 75  
74 76 /* read sector aligned part */
75 77 block_len = byte_len & ~(SECTOR_SIZE-1);
76   - if (reiserfs_block_dev_desc->block_read(reiserfs_block_dev_desc->dev,
77   - part_info->start + sector, block_len/SECTOR_SIZE,
78   - (unsigned long *)buf) != block_len/SECTOR_SIZE) {
  78 + if (reiserfs_block_dev_desc->block_read(reiserfs_block_dev_desc,
  79 + part_info->start + sector,
  80 + block_len / SECTOR_SIZE,
  81 + (void *)buf)
  82 + != block_len/SECTOR_SIZE) {
79 83 printf (" ** reiserfs_devread() read error - block\n");
80 84 return 0;
81 85 }
... ... @@ -85,9 +89,11 @@
85 89  
86 90 if ( byte_len != 0 ) {
87 91 /* read rest of data which are not in whole sector */
88   - if (reiserfs_block_dev_desc->block_read(reiserfs_block_dev_desc->dev,
89   - part_info->start + sector, 1,
90   - (unsigned long *)sec_buf) != 1) {
  92 + if (reiserfs_block_dev_desc->block_read(reiserfs_block_dev_desc,
  93 + part_info->start +
  94 + sector,
  95 + 1, (void *)sec_buf)
  96 + != 1) {
91 97 printf (" ** reiserfs_devread() read error - last part\n");
92 98 return 0;
93 99 }
... ... @@ -55,9 +55,10 @@
55 55  
56 56 if (byte_offset != 0) {
57 57 /* read first part which isn't aligned with start of sector */
58   - if (zfs_block_dev_desc->block_read(zfs_block_dev_desc->dev,
59   - part_info->start + sector, 1,
60   - (unsigned long *)sec_buf) != 1) {
  58 + if (zfs_block_dev_desc->block_read(zfs_block_dev_desc,
  59 + part_info->start + sector, 1,
  60 + (void *)sec_buf)
  61 + != 1) {
61 62 printf(" ** zfs_devread() read error **\n");
62 63 return 1;
63 64 }
64 65  
... ... @@ -78,16 +79,18 @@
78 79 u8 p[SECTOR_SIZE];
79 80  
80 81 block_len = SECTOR_SIZE;
81   - zfs_block_dev_desc->block_read(zfs_block_dev_desc->dev,
82   - part_info->start + sector,
83   - 1, (unsigned long *)p);
  82 + zfs_block_dev_desc->block_read(zfs_block_dev_desc,
  83 + part_info->start + sector,
  84 + 1, (void *)p);
84 85 memcpy(buf, p, byte_len);
85 86 return 0;
86 87 }
87 88  
88   - if (zfs_block_dev_desc->block_read(zfs_block_dev_desc->dev,
89   - part_info->start + sector, block_len / SECTOR_SIZE,
90   - (unsigned long *) buf) != block_len / SECTOR_SIZE) {
  89 + if (zfs_block_dev_desc->block_read(zfs_block_dev_desc,
  90 + part_info->start + sector,
  91 + block_len / SECTOR_SIZE,
  92 + (void *)buf)
  93 + != block_len / SECTOR_SIZE) {
91 94 printf(" ** zfs_devread() read error - block\n");
92 95 return 1;
93 96 }
... ... @@ -99,10 +102,9 @@
99 102  
100 103 if (byte_len != 0) {
101 104 /* read rest of data which are not in whole sector */
102   - if (zfs_block_dev_desc->
103   - block_read(zfs_block_dev_desc->dev,
104   - part_info->start + sector, 1,
105   - (unsigned long *) sec_buf) != 1) {
  105 + if (zfs_block_dev_desc->block_read(zfs_block_dev_desc,
  106 + part_info->start + sector,
  107 + 1, (void *)sec_buf) != 1) {
106 108 printf(" ** zfs_devread() read error - last part\n");
107 109 return 1;
108 110 }
... ... @@ -41,8 +41,10 @@
41 41 */
42 42  
43 43 void ide_init(void);
44   -ulong ide_read(int device, lbaint_t blknr, lbaint_t blkcnt, void *buffer);
45   -ulong ide_write(int device, lbaint_t blknr, lbaint_t blkcnt,
  44 +typedef struct block_dev_desc block_dev_desc_t;
  45 +ulong ide_read(block_dev_desc_t *block_dev, lbaint_t blknr, lbaint_t blkcnt,
  46 + void *buffer);
  47 +ulong ide_write(block_dev_desc_t *block_dev, lbaint_t blknr, lbaint_t blkcnt,
46 48 const void *buffer);
47 49  
48 50 #ifdef CONFIG_IDE_PREINIT
... ... @@ -10,7 +10,9 @@
10 10 #include <ide.h>
11 11 #include <common.h>
12 12  
13   -typedef struct block_dev_desc {
  13 +typedef struct block_dev_desc block_dev_desc_t;
  14 +
  15 +struct block_dev_desc {
14 16 int if_type; /* type of the interface */
15 17 int dev; /* device number */
16 18 unsigned char part_type; /* partition type */
17 19  
18 20  
19 21  
... ... @@ -27,19 +29,19 @@
27 29 char vendor [40+1]; /* IDE model, SCSI Vendor */
28 30 char product[20+1]; /* IDE Serial no, SCSI product */
29 31 char revision[8+1]; /* firmware revision */
30   - unsigned long (*block_read)(int dev,
  32 + unsigned long (*block_read)(block_dev_desc_t *block_dev,
31 33 lbaint_t start,
32 34 lbaint_t blkcnt,
33 35 void *buffer);
34   - unsigned long (*block_write)(int dev,
  36 + unsigned long (*block_write)(block_dev_desc_t *block_dev,
35 37 lbaint_t start,
36 38 lbaint_t blkcnt,
37 39 const void *buffer);
38   - unsigned long (*block_erase)(int dev,
  40 + unsigned long (*block_erase)(block_dev_desc_t *block_dev,
39 41 lbaint_t start,
40 42 lbaint_t blkcnt);
41 43 void *priv; /* driver private struct pointer */
42   -}block_dev_desc_t;
  44 +};
43 45  
44 46 #define BLOCK_CNT(size, block_dev_desc) (PAD_COUNT(size, block_dev_desc->blksz))
45 47 #define PAD_TO_BLOCKSIZE(size, block_dev_desc) \
... ... @@ -231,8 +231,7 @@
231 231 gzwrite_progress(iteration++,
232 232 totalfilled,
233 233 szexpected);
234   - blocks_written = dev->block_write(dev->dev,
235   - outblock,
  234 + blocks_written = dev->block_write(dev, outblock,
236 235 writeblocks,
237 236 writebuf);
238 237 outblock += blocks_written;
... ... @@ -50,7 +50,7 @@
50 50 /* Read a few blocks and look for the string we expect */
51 51 ut_asserteq(512, dev_desc->blksz);
52 52 memset(cmp, '\0', sizeof(cmp));
53   - ut_asserteq(2, dev_desc->block_read(dev_desc->dev, 0, 2, cmp));
  53 + ut_asserteq(2, dev_desc->block_read(dev_desc, 0, 2, cmp));
54 54 ut_assertok(strcmp(cmp, "this is a test"));
55 55  
56 56 return 0;