Djam/u-boot
1
0
Fork 0
mirror of https://github.com/u-boot/u-boot.git synced 2025-05-08 19:11:53 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge git://git.denx.de/u-boot-dm

Browse source
This commit is contained in:
Tom Rini 2016-03-14 19:21:44 -04:00
commit 88033d737d
121 changed files with 1738 additions and 1022 deletions
Download patch file Download diff file Expand all files Collapse all files

2
api/api.c
View file

@ -189,7 +189,7 @@ static int API_get_timer(va_list ap)
* *
* - net: &eth_device struct address from list pointed to by eth_devices * - net: &eth_device struct address from list pointed to by eth_devices
* *
* - storage: block_dev_desc_t struct address from &ide_dev_desc[n], * - storage: struct blk_desc struct address from &ide_dev_desc[n],
* &scsi_dev_desc[n] and similar tables * &scsi_dev_desc[n] and similar tables
* *
****************************************************************************/ ****************************************************************************/

26
api/api_storage.c
View file

@ -103,10 +103,10 @@ static int dev_stor_get(int type, int first, int *more, struct device_info *di)
int i; int i;
block_dev_desc_t *dd; struct blk_desc *dd;
if (first) { if (first) {
di->cookie = (void *)get_dev(specs[type].name, 0); di->cookie = (void *)blk_get_dev(specs[type].name, 0);
if (di->cookie == NULL) if (di->cookie == NULL)
return 0; return 0;
else else
@ -119,7 +119,8 @@ static int dev_stor_get(int type, int first, int *more, struct device_info *di)
} else { } else {
for (i = 0; i < specs[type].max_dev; i++) for (i = 0; i < specs[type].max_dev; i++)
if (di->cookie == (void *)get_dev(specs[type].name, i)) { if (di->cookie ==
(void *)blk_get_dev(specs[type].name, i)) {
/* previous cookie found -- advance to the /* previous cookie found -- advance to the
* next device, if possible */ * next device, if possible */
@ -129,7 +130,8 @@ static int dev_stor_get(int type, int first, int *more, struct device_info *di)
break; break;
} }
di->cookie = (void *)get_dev(specs[type].name, i); di->cookie = (void *)blk_get_dev(
specs[type].name, i);
if (di->cookie == NULL) if (di->cookie == NULL)
return 0; return 0;
else else
@ -148,7 +150,7 @@ static int dev_stor_get(int type, int first, int *more, struct device_info *di)
di->type = specs[type].type; di->type = specs[type].type;
if (di->cookie != NULL) { if (di->cookie != NULL) {
dd = (block_dev_desc_t *)di->cookie; dd = (struct blk_desc *)di->cookie;
if (dd->type == DEV_TYPE_UNKNOWN) { if (dd->type == DEV_TYPE_UNKNOWN) {
debugf("device instance exists, but is not active.."); debugf("device instance exists, but is not active..");
found = 0; found = 0;
@ -166,15 +168,15 @@ static int dev_stor_get(int type, int first, int *more, struct device_info *di)
/* /*
* returns: ENUM_IDE, ENUM_USB etc. based on block_dev_desc_t * returns: ENUM_IDE, ENUM_USB etc. based on struct blk_desc
*/ */
static int dev_stor_type(block_dev_desc_t *dd) static int dev_stor_type(struct blk_desc *dd)
{ {
int i, j; int i, j;
for (i = ENUM_IDE; i < ENUM_MAX; i++) for (i = ENUM_IDE; i < ENUM_MAX; i++)
for (j = 0; j < specs[i].max_dev; j++) for (j = 0; j < specs[i].max_dev; j++)
if (dd == get_dev(specs[i].name, j)) if (dd == blk_get_dev(specs[i].name, j))
return i; return i;
return ENUM_MAX; return ENUM_MAX;
@ -308,12 +310,12 @@ int dev_enum_storage(struct device_info *di)
return 0; return 0;
} }
static int dev_stor_is_valid(int type, block_dev_desc_t *dd) static int dev_stor_is_valid(int type, struct blk_desc *dd)
{ {
int i; int i;
for (i = 0; i < specs[type].max_dev; i++) for (i = 0; i < specs[type].max_dev; i++)
if (dd == get_dev(specs[type].name, i)) if (dd == blk_get_dev(specs[type].name, i))
if (dd->type != DEV_TYPE_UNKNOWN) if (dd->type != DEV_TYPE_UNKNOWN)
return 1; return 1;
@ -328,7 +330,7 @@ int dev_open_stor(void *cookie)
if (type == ENUM_MAX) if (type == ENUM_MAX)
return API_ENODEV; return API_ENODEV;
if (dev_stor_is_valid(type, (block_dev_desc_t *)cookie)) if (dev_stor_is_valid(type, (struct blk_desc *)cookie))
return 0; return 0;
return API_ENODEV; return API_ENODEV;
@ -348,7 +350,7 @@ int dev_close_stor(void *cookie)
lbasize_t dev_read_stor(void *cookie, void *buf, lbasize_t len, lbastart_t start) lbasize_t dev_read_stor(void *cookie, void *buf, lbasize_t len, lbastart_t start)
{ {
int type; int type;
block_dev_desc_t *dd = (block_dev_desc_t *)cookie; struct blk_desc *dd = (struct blk_desc *)cookie;
if ((type = dev_stor_type(dd)) == ENUM_MAX) if ((type = dev_stor_type(dd)) == ENUM_MAX)
return 0; return 0;

2
arch/arm/mach-rockchip/rk3288/sdram_rk3288.c
View file

@ -756,7 +756,7 @@ static int veyron_init(struct dram_info *priv)
struct udevice *pmic; struct udevice *pmic;
int ret; int ret;
ret = uclass_first_device(UCLASS_PMIC, &pmic); ret = uclass_first_device_err(UCLASS_PMIC, &pmic);
if (ret) if (ret)
return ret; return ret;

4
arch/nios2/cpu/cpu.c
View file

@ -63,11 +63,9 @@ int arch_cpu_init_dm(void)
struct udevice *dev; struct udevice *dev;
int ret; int ret;
ret = uclass_first_device(UCLASS_CPU, &dev); ret = uclass_first_device_err(UCLASS_CPU, &dev);
if (ret) if (ret)
return ret; return ret;
if (!dev)
return -ENODEV;
gd->ram_size = CONFIG_SYS_SDRAM_SIZE; gd->ram_size = CONFIG_SYS_SDRAM_SIZE;
#ifndef CONFIG_ROM_STUBS #ifndef CONFIG_ROM_STUBS

2
arch/x86/cpu/interrupts.c
View file

@ -249,7 +249,7 @@ int interrupt_init(void)
int ret; int ret;
/* Try to set up the interrupt router, but don't require one */ /* Try to set up the interrupt router, but don't require one */
ret = uclass_first_device(UCLASS_IRQ, &dev); ret = uclass_first_device_err(UCLASS_IRQ, &dev);
if (ret && ret != -ENODEV) if (ret && ret != -ENODEV)
return ret; return ret;

14
arch/x86/cpu/ivybridge/cpu.c
View file

@ -104,9 +104,9 @@ int arch_cpu_init_dm(void)
/* TODO(sjg@chromium.org): Get rid of gd->hose */ /* TODO(sjg@chromium.org): Get rid of gd->hose */
gd->hose = hose; gd->hose = hose;
ret = uclass_first_device(UCLASS_LPC, &dev); ret = uclass_first_device_err(UCLASS_LPC, &dev);
if (!dev) if (ret)
return -ENODEV; return ret;
/* /*
* We should do as little as possible before the serial console is * We should do as little as possible before the serial console is
@ -210,11 +210,9 @@ int print_cpuinfo(void)
/* Early chipset init required before RAM init can work */ /* Early chipset init required before RAM init can work */
uclass_first_device(UCLASS_NORTHBRIDGE, &dev); uclass_first_device(UCLASS_NORTHBRIDGE, &dev);
ret = uclass_first_device(UCLASS_LPC, &lpc); ret = uclass_first_device_err(UCLASS_LPC, &lpc);
if (ret) if (ret)
return ret; return ret;
if (!dev)
return -ENODEV;
/* Cause the SATA device to do its early init */ /* Cause the SATA device to do its early init */
uclass_first_device(UCLASS_DISK, &dev); uclass_first_device(UCLASS_DISK, &dev);
@ -236,11 +234,9 @@ int print_cpuinfo(void)
post_code(POST_EARLY_INIT); post_code(POST_EARLY_INIT);
/* Enable SPD ROMs and DDR-III DRAM */ /* Enable SPD ROMs and DDR-III DRAM */
ret = uclass_first_device(UCLASS_I2C, &dev); ret = uclass_first_device_err(UCLASS_I2C, &dev);
if (ret) if (ret)
return ret; return ret;
if (!dev)
return -ENODEV;
/* Prepare USB controller early in S3 resume */ /* Prepare USB controller early in S3 resume */
if (boot_mode == PEI_BOOT_RESUME) if (boot_mode == PEI_BOOT_RESUME)

6
arch/x86/cpu/ivybridge/gma.c
View file

@ -812,9 +812,9 @@ int gma_func0_init(struct udevice *dev)
writew(0x0010, RCB_REG(DISPBDF)); writew(0x0010, RCB_REG(DISPBDF));
setbits_le32(RCB_REG(FD2), PCH_ENABLE_DBDF); setbits_le32(RCB_REG(FD2), PCH_ENABLE_DBDF);
ret = uclass_first_device(UCLASS_NORTHBRIDGE, &nbridge); ret = uclass_first_device_err(UCLASS_NORTHBRIDGE, &nbridge);
if (!nbridge) if (ret)
return -ENODEV; return ret;
rev = bridge_silicon_revision(nbridge); rev = bridge_silicon_revision(nbridge);
sandybridge_setup_graphics(nbridge, dev); sandybridge_setup_graphics(nbridge, dev);

4
arch/x86/cpu/ivybridge/sata.c
View file

@ -229,11 +229,9 @@ static int bd82x6x_sata_probe(struct udevice *dev)
struct udevice *pch; struct udevice *pch;
int ret; int ret;
ret = uclass_first_device(UCLASS_PCH, &pch); ret = uclass_first_device_err(UCLASS_PCH, &pch);
if (ret) if (ret)
return ret; return ret;
if (!pch)
return -ENODEV;
if (!(gd->flags & GD_FLG_RELOC)) if (!(gd->flags & GD_FLG_RELOC))
bd82x6x_sata_enable(dev); bd82x6x_sata_enable(dev);

4
arch/x86/cpu/ivybridge/sdram.c
View file

@ -736,11 +736,9 @@ int dram_init(void)
struct udevice *dev, *me_dev; struct udevice *dev, *me_dev;
int ret; int ret;
ret = uclass_first_device(UCLASS_NORTHBRIDGE, &dev); ret = uclass_first_device_err(UCLASS_NORTHBRIDGE, &dev);
if (ret) if (ret)
return ret; return ret;
if (!dev)
return -ENODEV;
ret = syscon_get_by_driver_data(X86_SYSCON_ME, &me_dev); ret = syscon_get_by_driver_data(X86_SYSCON_ME, &me_dev);
if (ret) if (ret)
return ret; return ret;

2
arch/x86/lib/mpspec.c
View file

@ -297,7 +297,7 @@ static int mptable_add_intsrc(struct mp_config_table *mc,
const u32 *cell; const u32 *cell;
int i, ret; int i, ret;
ret = uclass_first_device(UCLASS_IRQ, &dev); ret = uclass_first_device_err(UCLASS_IRQ, &dev);
if (ret && ret != -ENODEV) { if (ret && ret != -ENODEV) {
debug("%s: Cannot find irq router node\n", __func__); debug("%s: Cannot find irq router node\n", __func__);
return ret; return ret;

4
board/cm5200/fwupdate.c
View file

@ -81,7 +81,7 @@ static int load_rescue_image(ulong addr)
char dev[7]; char dev[7];
char addr_str[16]; char addr_str[16];
char * const argv[6] = { "fatload", "usb", dev, addr_str, nxri, NULL }; char * const argv[6] = { "fatload", "usb", dev, addr_str, nxri, NULL };
block_dev_desc_t *stor_dev = NULL; struct blk_desc *stor_dev = NULL;
cmd_tbl_t *bcmd; cmd_tbl_t *bcmd;
/* Get name of firmware directory */ /* Get name of firmware directory */
@ -117,7 +117,7 @@ static int load_rescue_image(ulong addr)
/* Detect partition */ /* Detect partition */
for (partno = -1, i = 0; i < 6; i++) { for (partno = -1, i = 0; i < 6; i++) {
if (get_partition_info(stor_dev, i, &info) == 0) { if (part_get_info(stor_dev, i, &info) == 0) {
if (fat_register_device(stor_dev, i) == 0) { if (fat_register_device(stor_dev, i) == 0) {
/* Check if rescue image is present */ /* Check if rescue image is present */
FW_DEBUG("Looking for firmware directory '%s'" FW_DEBUG("Looking for firmware directory '%s'"

4
board/mpl/pip405/README
View file

@ -217,8 +217,8 @@ Added files:
Block device changes: Block device changes:
--------------------- ---------------------
To allow the use of dos_part.c, mac_part.c and iso_part.c, the parameter To allow the use of dos_part.c, mac_part.c and iso_part.c, the parameter
block_dev_desc will be used when accessing the functions in these files. The block blk_desc will be used when accessing the functions in these files. The block
device descriptor (block_dev_desc) contains a pointer to the read routine of the device descriptor (blk_desc) contains a pointer to the read routine of the
device, which will be used to read blocks from the device. device, which will be used to read blocks from the device.
Renamed function ide_print to dev_print and moved it to the file disk/part.c to use Renamed function ide_print to dev_print and moved it to the file disk/part.c to use
it for IDE ATAPI and SCSI devices. it for IDE ATAPI and SCSI devices.

4
board/sunxi/board.c
View file

@ -337,8 +337,8 @@ int board_mmc_init(bd_t *bis)
if (!sunxi_mmc_has_egon_boot_signature(mmc0) && if (!sunxi_mmc_has_egon_boot_signature(mmc0) &&
sunxi_mmc_has_egon_boot_signature(mmc1)) { sunxi_mmc_has_egon_boot_signature(mmc1)) {
/* Booting from emmc / mmc2, swap */ /* Booting from emmc / mmc2, swap */
mmc0->block_dev.dev = 1; mmc0->block_dev.devnum = 1;
mmc1->block_dev.dev = 0; mmc1->block_dev.devnum = 0;
} }
#endif #endif

12
cmd/bmp.c
View file

@ -246,18 +246,14 @@ int bmp_display(ulong addr, int x, int y)
addr = map_to_sysmem(bmp); addr = map_to_sysmem(bmp);
#ifdef CONFIG_DM_VIDEO #ifdef CONFIG_DM_VIDEO
ret = uclass_first_device(UCLASS_VIDEO, &dev); ret = uclass_first_device_err(UCLASS_VIDEO, &dev);
if (!ret) { if (!ret) {
if (!dev) bool align = false;
ret = -ENODEV;
if (!ret) {
bool align = false;
# ifdef CONFIG_SPLASH_SCREEN_ALIGN # ifdef CONFIG_SPLASH_SCREEN_ALIGN
align = true; align = true;
# endif /* CONFIG_SPLASH_SCREEN_ALIGN */ # endif /* CONFIG_SPLASH_SCREEN_ALIGN */
ret = video_bmp_display(dev, addr, x, y, align); ret = video_bmp_display(dev, addr, x, y, align);
}
} }
#elif defined(CONFIG_LCD) #elif defined(CONFIG_LCD)
ret = lcd_display_bitmap(addr, x, y); ret = lcd_display_bitmap(addr, x, y);

5
cmd/cbfs.c
View file

@ -103,7 +103,7 @@ int do_cbfs_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
printf(" size type name\n"); printf(" size type name\n");
printf("------------------------------------------\n"); printf("------------------------------------------\n");
while (file) { while (file) {
u32 type = file_cbfs_type(file); int type = file_cbfs_type(file);
char *type_name = NULL; char *type_name = NULL;
const char *filename = file_cbfs_name(file); const char *filename = file_cbfs_name(file);
@ -140,7 +140,8 @@ int do_cbfs_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
case CBFS_COMPONENT_CMOS_LAYOUT: case CBFS_COMPONENT_CMOS_LAYOUT:
type_name = "cmos layout"; type_name = "cmos layout";
break; break;
case -1UL: case -1:
case 0:
type_name = "null"; type_name = "null";
break; break;
} }

5
cmd/cramfs.c
View file

@ -29,7 +29,6 @@
# define DEBUGF(fmt, args...) # define DEBUGF(fmt, args...)
#endif #endif
#ifdef CONFIG_CRAMFS_CMDLINE
#include <flash.h> #include <flash.h>
#ifdef CONFIG_SYS_NO_FLASH #ifdef CONFIG_SYS_NO_FLASH
@ -201,7 +200,3 @@ U_BOOT_CMD(
"[ directory ]\n" "[ directory ]\n"
" - list files in a directory.\n" " - list files in a directory.\n"
); );
#endif /* #ifdef CONFIG_CRAMFS_CMDLINE */
/***************************************************/

12
cmd/disk.c
View file

@ -20,7 +20,7 @@ int common_diskboot(cmd_tbl_t *cmdtp, const char *intf, int argc,
#if defined(CONFIG_IMAGE_FORMAT_LEGACY) #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
image_header_t *hdr; image_header_t *hdr;
#endif #endif
block_dev_desc_t *dev_desc; struct blk_desc *dev_desc;
#if CONFIG_IS_ENABLED(FIT) #if CONFIG_IS_ENABLED(FIT)
const void *fit_hdr = NULL; const void *fit_hdr = NULL;
@ -38,14 +38,14 @@ int common_diskboot(cmd_tbl_t *cmdtp, const char *intf, int argc,
bootstage_mark(BOOTSTAGE_ID_IDE_BOOT_DEVICE); bootstage_mark(BOOTSTAGE_ID_IDE_BOOT_DEVICE);
part = get_device_and_partition(intf, (argc == 3) ? argv[2] : NULL, part = blk_get_device_part_str(intf, (argc == 3) ? argv[2] : NULL,
&dev_desc, &info, 1); &dev_desc, &info, 1);
if (part < 0) { if (part < 0) {
bootstage_error(BOOTSTAGE_ID_IDE_TYPE); bootstage_error(BOOTSTAGE_ID_IDE_TYPE);
return 1; return 1;
} }
dev = dev_desc->dev; dev = dev_desc->devnum;
bootstage_mark(BOOTSTAGE_ID_IDE_TYPE); bootstage_mark(BOOTSTAGE_ID_IDE_TYPE);
printf("\nLoading from %s device %d, partition %d: " printf("\nLoading from %s device %d, partition %d: "
@ -56,7 +56,7 @@ int common_diskboot(cmd_tbl_t *cmdtp, const char *intf, int argc,
", Block Size: %ld\n", ", Block Size: %ld\n",
info.start, info.size, info.blksz); 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); printf("** Read error on %d:%d\n", dev, part);
bootstage_error(BOOTSTAGE_ID_IDE_PART_READ); bootstage_error(BOOTSTAGE_ID_IDE_PART_READ);
return 1; return 1;
@ -100,8 +100,8 @@ int common_diskboot(cmd_tbl_t *cmdtp, const char *intf, int argc,
cnt /= info.blksz; cnt /= info.blksz;
cnt -= 1; cnt -= 1;
if (dev_desc->block_read(dev_desc, info.start + 1, cnt, if (blk_dread(dev_desc, info.start + 1, cnt,
(ulong *)(addr + info.blksz)) != cnt) { (ulong *)(addr + info.blksz)) != cnt) {
printf("** Read error on %d:%d\n", dev, part); printf("** Read error on %d:%d\n", dev, part);
bootstage_error(BOOTSTAGE_ID_IDE_READ); bootstage_error(BOOTSTAGE_ID_IDE_READ);
return 1; return 1;

12
cmd/fat.c
View file

@ -69,7 +69,7 @@ static int do_fat_fsinfo(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[]) char * const argv[])
{ {
int dev, part; int dev, part;
block_dev_desc_t *dev_desc; struct blk_desc *dev_desc;
disk_partition_t info; disk_partition_t info;
if (argc < 2) { if (argc < 2) {
@ -77,11 +77,11 @@ static int do_fat_fsinfo(cmd_tbl_t *cmdtp, int flag, int argc,
return 0; return 0;
} }
part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); part = blk_get_device_part_str(argv[1], argv[2], &dev_desc, &info, 1);
if (part < 0) if (part < 0)
return 1; return 1;
dev = dev_desc->dev; dev = dev_desc->devnum;
if (fat_set_blk_dev(dev_desc, &info) != 0) { if (fat_set_blk_dev(dev_desc, &info) != 0) {
printf("\n** Unable to use %s %d:%d for fatinfo **\n", printf("\n** Unable to use %s %d:%d for fatinfo **\n",
argv[1], dev, part); argv[1], dev, part);
@ -105,7 +105,7 @@ static int do_fat_fswrite(cmd_tbl_t *cmdtp, int flag,
int ret; int ret;
unsigned long addr; unsigned long addr;
unsigned long count; unsigned long count;
block_dev_desc_t *dev_desc = NULL; struct blk_desc *dev_desc = NULL;
disk_partition_t info; disk_partition_t info;
int dev = 0; int dev = 0;
int part = 1; int part = 1;
@ -114,11 +114,11 @@ static int do_fat_fswrite(cmd_tbl_t *cmdtp, int flag,
if (argc < 5) if (argc < 5)
return cmd_usage(cmdtp); return cmd_usage(cmdtp);
part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); part = blk_get_device_part_str(argv[1], argv[2], &dev_desc, &info, 1);
if (part < 0) if (part < 0)
return 1; return 1;
dev = dev_desc->dev; dev = dev_desc->devnum;
if (fat_set_blk_dev(dev_desc, &info) != 0) { if (fat_set_blk_dev(dev_desc, &info) != 0) {
printf("\n** Unable to use %s %d:%d for fatwrite **\n", printf("\n** Unable to use %s %d:%d for fatwrite **\n",

10
cmd/gpt.c
View file

@ -168,7 +168,7 @@ static bool found_key(const char *str, const char *key)
* @return - zero on success, otherwise error * @return - zero on success, otherwise error
* *
*/ */
static int set_gpt_info(block_dev_desc_t *dev_desc, static int set_gpt_info(struct blk_desc *dev_desc,
const char *str_part, const char *str_part,
char **str_disk_guid, char **str_disk_guid,
disk_partition_t **partitions, disk_partition_t **partitions,
@ -328,7 +328,7 @@ err:
return errno; return errno;
} }
static int gpt_default(block_dev_desc_t *blk_dev_desc, const char *str_part) static int gpt_default(struct blk_desc *blk_dev_desc, const char *str_part)
{ {
int ret; int ret;
char *str_disk_guid; char *str_disk_guid;
@ -356,7 +356,7 @@ static int gpt_default(block_dev_desc_t *blk_dev_desc, const char *str_part)
return ret; return ret;
} }
static int gpt_verify(block_dev_desc_t *blk_dev_desc, const char *str_part) static int gpt_verify(struct blk_desc *blk_dev_desc, const char *str_part)
{ {
ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1,
blk_dev_desc->blksz); blk_dev_desc->blksz);
@ -408,7 +408,7 @@ static int do_gpt(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
int ret = CMD_RET_SUCCESS; int ret = CMD_RET_SUCCESS;
int dev = 0; int dev = 0;
char *ep; char *ep;
block_dev_desc_t *blk_dev_desc = NULL; struct blk_desc *blk_dev_desc = NULL;
if (argc < 4 || argc > 5) if (argc < 4 || argc > 5)
return CMD_RET_USAGE; return CMD_RET_USAGE;
@ -418,7 +418,7 @@ static int do_gpt(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
printf("'%s' is not a number\n", argv[3]); printf("'%s' is not a number\n", argv[3]);
return CMD_RET_USAGE; return CMD_RET_USAGE;
} }
blk_dev_desc = get_dev(argv[2], dev); blk_dev_desc = blk_get_dev(argv[2], dev);
if (!blk_dev_desc) { if (!blk_dev_desc) {
printf("%s: %s dev %d NOT available\n", printf("%s: %s dev %d NOT available\n",
__func__, argv[2], dev); __func__, argv[2], dev);

13
cmd/host.c
View file

@ -5,6 +5,7 @@
*/ */
#include <common.h> #include <common.h>
#include <dm.h>
#include <fs.h> #include <fs.h>
#include <part.h> #include <part.h>
#include <sandboxblockdev.h> #include <sandboxblockdev.h>
@ -67,7 +68,7 @@ static int do_host_info(cmd_tbl_t *cmdtp, int flag, int argc,
int dev; int dev;
printf("%3s %12s %s\n", "dev", "blocks", "path"); printf("%3s %12s %s\n", "dev", "blocks", "path");
for (dev = min_dev; dev <= max_dev; dev++) { for (dev = min_dev; dev <= max_dev; dev++) {
block_dev_desc_t *blk_dev; struct blk_desc *blk_dev;
int ret; int ret;
printf("%3d ", dev); printf("%3d ", dev);
@ -80,7 +81,13 @@ static int do_host_info(cmd_tbl_t *cmdtp, int flag, int argc,
continue; continue;
} }
struct host_block_dev *host_dev = blk_dev->priv; struct host_block_dev *host_dev;
#ifdef CONFIG_BLK
host_dev = dev_get_priv(blk_dev->bdev);
#else
host_dev = blk_dev->priv;
#endif
printf("%12lu %s\n", (unsigned long)blk_dev->lba, printf("%12lu %s\n", (unsigned long)blk_dev->lba,
host_dev->filename); host_dev->filename);
} }
@ -92,7 +99,7 @@ static int do_host_dev(cmd_tbl_t *cmdtp, int flag, int argc,
{ {
int dev; int dev;
char *ep; char *ep;
block_dev_desc_t *blk_dev; struct blk_desc *blk_dev;
int ret; int ret;
if (argc < 1 || argc > 3) if (argc < 1 || argc > 3)

44
cmd/ide.c
View file

@ -10,6 +10,7 @@
*/ */
#include <common.h> #include <common.h>
#include <blk.h>
#include <config.h> #include <config.h>
#include <watchdog.h> #include <watchdog.h>
#include <command.h> #include <command.h>
@ -53,7 +54,7 @@ ulong ide_bus_offset[CONFIG_SYS_IDE_MAXBUS] = {
static int ide_bus_ok[CONFIG_SYS_IDE_MAXBUS]; static int ide_bus_ok[CONFIG_SYS_IDE_MAXBUS];
block_dev_desc_t ide_dev_desc[CONFIG_SYS_IDE_MAXDEVICE]; struct blk_desc ide_dev_desc[CONFIG_SYS_IDE_MAXDEVICE];
/* ------------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
#ifdef CONFIG_IDE_RESET #ifdef CONFIG_IDE_RESET
@ -62,7 +63,7 @@ static void ide_reset (void);
#define ide_reset() /* dummy */ #define ide_reset() /* dummy */
#endif #endif
static void ide_ident (block_dev_desc_t *dev_desc); static void ide_ident(struct blk_desc *dev_desc);
static uchar ide_wait (int dev, ulong t); static uchar ide_wait (int dev, ulong t);
#define IDE_TIME_OUT 2000 /* 2 sec timeout */ #define IDE_TIME_OUT 2000 /* 2 sec timeout */
@ -78,8 +79,8 @@ static void ident_cpy (unsigned char *dest, unsigned char *src, unsigned int len
#endif #endif
#ifdef CONFIG_ATAPI #ifdef CONFIG_ATAPI
static void atapi_inquiry(block_dev_desc_t *dev_desc); static void atapi_inquiry(struct blk_desc *dev_desc);
static ulong atapi_read(block_dev_desc_t *block_dev, lbaint_t blknr, static ulong atapi_read(struct blk_desc *block_dev, lbaint_t blknr,
lbaint_t blkcnt, void *buffer); lbaint_t blkcnt, void *buffer);
#endif #endif
@ -137,7 +138,7 @@ int do_ide(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
++ok; ++ok;
if (dev) if (dev)
putc('\n'); putc('\n');
print_part(&ide_dev_desc[dev]); part_print(&ide_dev_desc[dev]);
} }
} }
if (!ok) { if (!ok) {
@ -171,7 +172,7 @@ int do_ide(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
int dev = (int) simple_strtoul(argv[2], NULL, 10); int dev = (int) simple_strtoul(argv[2], NULL, 10);
if (ide_dev_desc[dev].part_type != PART_TYPE_UNKNOWN) { if (ide_dev_desc[dev].part_type != PART_TYPE_UNKNOWN) {
print_part(&ide_dev_desc[dev]); part_print(&ide_dev_desc[dev]);
} else { } else {
printf("\nIDE device %d not available\n", printf("\nIDE device %d not available\n",
dev); dev);
@ -187,7 +188,7 @@ int do_ide(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
if (strcmp(argv[1], "read") == 0) { if (strcmp(argv[1], "read") == 0) {
ulong addr = simple_strtoul(argv[2], NULL, 16); ulong addr = simple_strtoul(argv[2], NULL, 16);
ulong cnt = simple_strtoul(argv[4], NULL, 16); ulong cnt = simple_strtoul(argv[4], NULL, 16);
block_dev_desc_t *dev_desc; struct blk_desc *dev_desc;
ulong n; ulong n;
#ifdef CONFIG_SYS_64BIT_LBA #ifdef CONFIG_SYS_64BIT_LBA
@ -203,8 +204,7 @@ int do_ide(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
#endif #endif
dev_desc = &ide_dev_desc[curr_device]; dev_desc = &ide_dev_desc[curr_device];
n = dev_desc->block_read(dev_desc, blk, cnt, n = blk_dread(dev_desc, blk, cnt, (ulong *)addr);
(ulong *)addr);
/* flush cache after read */ /* flush cache after read */
flush_cache(addr, flush_cache(addr,
cnt * ide_dev_desc[curr_device].blksz); cnt * ide_dev_desc[curr_device].blksz);
@ -418,7 +418,7 @@ void ide_init(void)
int led = (IDE_BUS(i) == 0) ? LED_IDE1 : LED_IDE2; int led = (IDE_BUS(i) == 0) ? LED_IDE1 : LED_IDE2;
ide_dev_desc[i].type = DEV_TYPE_UNKNOWN; ide_dev_desc[i].type = DEV_TYPE_UNKNOWN;
ide_dev_desc[i].if_type = IF_TYPE_IDE; ide_dev_desc[i].if_type = IF_TYPE_IDE;
ide_dev_desc[i].dev = i; ide_dev_desc[i].devnum = i;
ide_dev_desc[i].part_type = PART_TYPE_UNKNOWN; ide_dev_desc[i].part_type = PART_TYPE_UNKNOWN;
ide_dev_desc[i].blksz = 0; ide_dev_desc[i].blksz = 0;
ide_dev_desc[i].log2blksz = ide_dev_desc[i].log2blksz =
@ -435,7 +435,7 @@ void ide_init(void)
if ((ide_dev_desc[i].lba > 0) && (ide_dev_desc[i].blksz > 0)) { if ((ide_dev_desc[i].lba > 0) && (ide_dev_desc[i].blksz > 0)) {
/* initialize partition type */ /* initialize partition type */
init_part(&ide_dev_desc[i]); part_init(&ide_dev_desc[i]);
if (curr_device < 0) if (curr_device < 0)
curr_device = i; curr_device = i;
} }
@ -446,7 +446,7 @@ void ide_init(void)
/* ------------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
#ifdef CONFIG_PARTITIONS #ifdef CONFIG_PARTITIONS
block_dev_desc_t *ide_get_dev(int dev) struct blk_desc *ide_get_dev(int dev)
{ {
return (dev < CONFIG_SYS_IDE_MAXDEVICE) ? &ide_dev_desc[dev] : NULL; return (dev < CONFIG_SYS_IDE_MAXDEVICE) ? &ide_dev_desc[dev] : NULL;
} }
@ -541,7 +541,7 @@ __weak void ide_input_data(int dev, ulong *sect_buf, int words)
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
*/ */
static void ide_ident(block_dev_desc_t *dev_desc) static void ide_ident(struct blk_desc *dev_desc)
{ {
unsigned char c; unsigned char c;
hd_driveid_t iop; hd_driveid_t iop;
@ -551,7 +551,7 @@ static void ide_ident(block_dev_desc_t *dev_desc)
#endif #endif
int device; int device;
device = dev_desc->dev; device = dev_desc->devnum;
printf(" Device %d: ", device); printf(" Device %d: ", device);
ide_led(DEVICE_LED(device), 1); /* LED on */ ide_led(DEVICE_LED(device), 1); /* LED on */
@ -713,10 +713,10 @@ static void ide_ident(block_dev_desc_t *dev_desc)
/* ------------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
ulong ide_read(block_dev_desc_t *block_dev, lbaint_t blknr, lbaint_t blkcnt, ulong ide_read(struct blk_desc *block_dev, lbaint_t blknr, lbaint_t blkcnt,
void *buffer) void *buffer)
{ {
int device = block_dev->dev; int device = block_dev->devnum;
ulong n = 0; ulong n = 0;
unsigned char c; unsigned char c;
unsigned char pwrsave = 0; /* power save */ unsigned char pwrsave = 0; /* power save */
@ -839,10 +839,10 @@ IDE_READ_E:
/* ------------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
ulong ide_write(block_dev_desc_t *block_dev, lbaint_t blknr, lbaint_t blkcnt, ulong ide_write(struct blk_desc *block_dev, lbaint_t blknr, lbaint_t blkcnt,
const void *buffer) const void *buffer)
{ {
int device = block_dev->dev; int device = block_dev->devnum;
ulong n = 0; ulong n = 0;
unsigned char c; unsigned char c;
@ -1301,14 +1301,14 @@ error:
} }
static void atapi_inquiry(block_dev_desc_t *dev_desc) static void atapi_inquiry(struct blk_desc *dev_desc)
{ {
unsigned char ccb[12]; /* Command descriptor block */ unsigned char ccb[12]; /* Command descriptor block */
unsigned char iobuf[64]; /* temp buf */ unsigned char iobuf[64]; /* temp buf */
unsigned char c; unsigned char c;
int device; int device;
device = dev_desc->dev; device = dev_desc->devnum;
dev_desc->type = DEV_TYPE_UNKNOWN; /* not yet valid */ dev_desc->type = DEV_TYPE_UNKNOWN; /* not yet valid */
dev_desc->block_read = atapi_read; dev_desc->block_read = atapi_read;
@ -1394,10 +1394,10 @@ static void atapi_inquiry(block_dev_desc_t *dev_desc)
#define ATAPI_READ_BLOCK_SIZE 2048 /* assuming CD part */ #define ATAPI_READ_BLOCK_SIZE 2048 /* assuming CD part */
#define ATAPI_READ_MAX_BLOCK (ATAPI_READ_MAX_BYTES/ATAPI_READ_BLOCK_SIZE) #define ATAPI_READ_MAX_BLOCK (ATAPI_READ_MAX_BYTES/ATAPI_READ_BLOCK_SIZE)
ulong atapi_read(block_dev_desc_t *block_dev, lbaint_t blknr, lbaint_t blkcnt, ulong atapi_read(struct blk_desc *block_dev, lbaint_t blknr, lbaint_t blkcnt,
void *buffer) void *buffer)
{ {
int device = block_dev->dev; int device = block_dev->devnum;
ulong n = 0; ulong n = 0;
unsigned char ccb[12]; /* Command descriptor block */ unsigned char ccb[12]; /* Command descriptor block */
ulong cnt; ulong cnt;

4
cmd/mmc.c
View file

@ -424,7 +424,7 @@ static int do_mmc_rescan(cmd_tbl_t *cmdtp, int flag,
static int do_mmc_part(cmd_tbl_t *cmdtp, int flag, static int do_mmc_part(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[]) int argc, char * const argv[])
{ {
block_dev_desc_t *mmc_dev; struct blk_desc *mmc_dev;
struct mmc *mmc; struct mmc *mmc;
mmc = init_mmc_device(curr_device, false); mmc = init_mmc_device(curr_device, false);
@ -433,7 +433,7 @@ static int do_mmc_part(cmd_tbl_t *cmdtp, int flag,
mmc_dev = mmc_get_dev(curr_device); mmc_dev = mmc_get_dev(curr_device);
if (mmc_dev != NULL && mmc_dev->type != DEV_TYPE_UNKNOWN) { if (mmc_dev != NULL && mmc_dev->type != DEV_TYPE_UNKNOWN) {
print_part(mmc_dev); part_print(mmc_dev);
return CMD_RET_SUCCESS; return CMD_RET_SUCCESS;
} }

4
cmd/mmc_spi.c
View file

@ -72,8 +72,8 @@ static int do_mmc_spi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
printf("Failed to create MMC Device\n"); printf("Failed to create MMC Device\n");
return 1; return 1;
} }
printf("%s: %d at %u:%u hz %u mode %u\n", mmc->cfg->name, mmc->block_dev.dev, printf("%s: %d at %u:%u hz %u mode %u\n", mmc->cfg->name,
bus, cs, speed, mode); mmc->block_dev.devnum, bus, cs, speed, mode);
mmc_init(mmc); mmc_init(mmc);
return 0; return 0;

24
cmd/part.c
View file

@ -29,7 +29,7 @@
static int do_part_uuid(int argc, char * const argv[]) static int do_part_uuid(int argc, char * const argv[])
{ {
int part; int part;
block_dev_desc_t *dev_desc; struct blk_desc *dev_desc;
disk_partition_t info; disk_partition_t info;
if (argc < 2) if (argc < 2)
@ -37,7 +37,7 @@ static int do_part_uuid(int argc, char * const argv[])
if (argc > 3) if (argc > 3)
return CMD_RET_USAGE; return CMD_RET_USAGE;
part = get_device_and_partition(argv[0], argv[1], &dev_desc, &info, 0); part = blk_get_device_part_str(argv[0], argv[1], &dev_desc, &info, 0);
if (part < 0) if (part < 0)
return 1; return 1;
@ -52,7 +52,7 @@ static int do_part_uuid(int argc, char * const argv[])
static int do_part_list(int argc, char * const argv[]) static int do_part_list(int argc, char * const argv[])
{ {
int ret; int ret;
block_dev_desc_t *desc; struct blk_desc *desc;
char *var = NULL; char *var = NULL;
bool bootable = false; bool bootable = false;
int i; int i;
@ -81,7 +81,7 @@ static int do_part_list(int argc, char * const argv[])
return CMD_RET_USAGE; return CMD_RET_USAGE;
} }
ret = get_device(argv[0], argv[1], &desc); ret = blk_get_device_by_str(argv[0], argv[1], &desc);
if (ret < 0) if (ret < 0)
return 1; return 1;
@ -92,7 +92,7 @@ static int do_part_list(int argc, char * const argv[])
for (p = 1; p < 128; p++) { for (p = 1; p < 128; p++) {
char t[5]; char t[5];
int r = get_partition_info(desc, p, &info); int r = part_get_info(desc, p, &info);
if (r != 0) if (r != 0)
continue; continue;
@ -107,14 +107,14 @@ static int do_part_list(int argc, char * const argv[])
return 0; return 0;
} }
print_part(desc); part_print(desc);
return 0; return 0;
} }
static int do_part_start(int argc, char * const argv[]) static int do_part_start(int argc, char * const argv[])
{ {
block_dev_desc_t *desc; struct blk_desc *desc;
disk_partition_t info; disk_partition_t info;
char buf[512] = { 0 }; char buf[512] = { 0 };
int part; int part;
@ -128,11 +128,11 @@ static int do_part_start(int argc, char * const argv[])
part = simple_strtoul(argv[2], NULL, 0); part = simple_strtoul(argv[2], NULL, 0);
ret = get_device(argv[0], argv[1], &desc); ret = blk_get_device_by_str(argv[0], argv[1], &desc);
if (ret < 0) if (ret < 0)
return 1; return 1;
err = get_partition_info(desc, part, &info); err = part_get_info(desc, part, &info);
if (err) if (err)
return 1; return 1;
@ -148,7 +148,7 @@ static int do_part_start(int argc, char * const argv[])
static int do_part_size(int argc, char * const argv[]) static int do_part_size(int argc, char * const argv[])
{ {
block_dev_desc_t *desc; struct blk_desc *desc;
disk_partition_t info; disk_partition_t info;
char buf[512] = { 0 }; char buf[512] = { 0 };
int part; int part;
@ -162,11 +162,11 @@ static int do_part_size(int argc, char * const argv[])
part = simple_strtoul(argv[2], NULL, 0); part = simple_strtoul(argv[2], NULL, 0);
ret = get_device(argv[0], argv[1], &desc); ret = blk_get_device_by_str(argv[0], argv[1], &desc);
if (ret < 0) if (ret < 0)
return 1; return 1;
err = get_partition_info(desc, part, &info); err = part_get_info(desc, part, &info);
if (err) if (err)
return 1; return 1;

10
cmd/read.c
View file

@ -15,7 +15,7 @@
int do_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) int do_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{ {
char *ep; char *ep;
block_dev_desc_t *dev_desc = NULL; struct blk_desc *dev_desc = NULL;
int dev; int dev;
int part = 0; int part = 0;
disk_partition_t part_info; disk_partition_t part_info;
@ -39,7 +39,7 @@ int do_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
part = (int)simple_strtoul(++ep, NULL, 16); part = (int)simple_strtoul(++ep, NULL, 16);
} }
dev_desc = get_dev(argv[1], dev); dev_desc = blk_get_dev(argv[1], dev);
if (dev_desc == NULL) { if (dev_desc == NULL) {
printf("Block device %s %d not supported\n", argv[1], dev); printf("Block device %s %d not supported\n", argv[1], dev);
return 1; return 1;
@ -50,14 +50,14 @@ int do_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
cnt = simple_strtoul(argv[5], NULL, 16); cnt = simple_strtoul(argv[5], NULL, 16);
if (part != 0) { if (part != 0) {
if (get_partition_info(dev_desc, part, &part_info)) { if (part_get_info(dev_desc, part, &part_info)) {
printf("Cannot find partition %d\n", part); printf("Cannot find partition %d\n", part);
return 1; return 1;
} }
offset = part_info.start; offset = part_info.start;
limit = part_info.size; limit = part_info.size;
} else { } else {
/* Largest address not available in block_dev_desc_t. */ /* Largest address not available in struct blk_desc. */
limit = ~0; limit = ~0;
} }
@ -66,7 +66,7 @@ int do_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
return 1; 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"); printf("Error reading blocks\n");
return 1; return 1;
} }

12
cmd/reiser.c
View file

@ -34,13 +34,13 @@ int do_reiserls (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{ {
char *filename = "/"; char *filename = "/";
int dev, part; int dev, part;
block_dev_desc_t *dev_desc=NULL; struct blk_desc *dev_desc = NULL;
disk_partition_t info; disk_partition_t info;
if (argc < 3) if (argc < 3)
return CMD_RET_USAGE; return CMD_RET_USAGE;
part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); part = blk_get_device_part_str(argv[1], argv[2], &dev_desc, &info, 1);
if (part < 0) if (part < 0)
return 1; return 1;
@ -48,7 +48,7 @@ int do_reiserls (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
filename = argv[3]; filename = argv[3];
} }
dev = dev_desc->dev; dev = dev_desc->devnum;
PRINTF("Using device %s %d:%d, directory: %s\n", argv[1], dev, part, filename); PRINTF("Using device %s %d:%d, directory: %s\n", argv[1], dev, part, filename);
reiserfs_set_blk_dev(dev_desc, &info); reiserfs_set_blk_dev(dev_desc, &info);
@ -82,7 +82,7 @@ int do_reiserload (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
int dev, part; int dev, part;
ulong addr = 0, filelen; ulong addr = 0, filelen;
disk_partition_t info; disk_partition_t info;
block_dev_desc_t *dev_desc = NULL; struct blk_desc *dev_desc = NULL;
unsigned long count; unsigned long count;
char *addr_str; char *addr_str;
@ -122,11 +122,11 @@ int do_reiserload (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
return 1; return 1;
} }
part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); part = blk_get_device_part_str(argv[1], argv[2], &dev_desc, &info, 1);
if (part < 0) if (part < 0)
return 1; return 1;
dev = dev_desc->dev; dev = dev_desc->devnum;
printf("Loading file \"%s\" from %s device %d%c%c\n", printf("Loading file \"%s\" from %s device %d%c%c\n",
filename, argv[1], dev, filename, argv[1], dev,

22
cmd/sata.c
View file

@ -16,18 +16,18 @@
#include <sata.h> #include <sata.h>
static int sata_curr_device = -1; static int sata_curr_device = -1;
block_dev_desc_t sata_dev_desc[CONFIG_SYS_SATA_MAX_DEVICE]; struct blk_desc sata_dev_desc[CONFIG_SYS_SATA_MAX_DEVICE];
static unsigned long sata_bread(block_dev_desc_t *block_dev, lbaint_t start, static unsigned long sata_bread(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt, void *dst) lbaint_t blkcnt, void *dst)
{ {
return sata_read(block_dev->dev, start, blkcnt, dst); return sata_read(block_dev->devnum, start, blkcnt, dst);
} }
static unsigned long sata_bwrite(block_dev_desc_t *block_dev, lbaint_t start, static unsigned long sata_bwrite(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt, const void *buffer) lbaint_t blkcnt, const void *buffer)
{ {
return sata_write(block_dev->dev, start, blkcnt, buffer); return sata_write(block_dev->devnum, start, blkcnt, buffer);
} }
int __sata_initialize(void) int __sata_initialize(void)
@ -36,9 +36,9 @@ int __sata_initialize(void)
int i; int i;
for (i = 0; i < CONFIG_SYS_SATA_MAX_DEVICE; i++) { for (i = 0; i < CONFIG_SYS_SATA_MAX_DEVICE; i++) {
memset(&sata_dev_desc[i], 0, sizeof(struct block_dev_desc)); memset(&sata_dev_desc[i], 0, sizeof(struct blk_desc));
sata_dev_desc[i].if_type = IF_TYPE_SATA; sata_dev_desc[i].if_type = IF_TYPE_SATA;
sata_dev_desc[i].dev = i; sata_dev_desc[i].devnum = i;
sata_dev_desc[i].part_type = PART_TYPE_UNKNOWN; sata_dev_desc[i].part_type = PART_TYPE_UNKNOWN;
sata_dev_desc[i].type = DEV_TYPE_HARDDISK; sata_dev_desc[i].type = DEV_TYPE_HARDDISK;
sata_dev_desc[i].lba = 0; sata_dev_desc[i].lba = 0;
@ -52,7 +52,7 @@ int __sata_initialize(void)
rc = scan_sata(i); rc = scan_sata(i);
if (!rc && (sata_dev_desc[i].lba > 0) && if (!rc && (sata_dev_desc[i].lba > 0) &&
(sata_dev_desc[i].blksz > 0)) (sata_dev_desc[i].blksz > 0))
init_part(&sata_dev_desc[i]); part_init(&sata_dev_desc[i]);
} }
} }
sata_curr_device = 0; sata_curr_device = 0;
@ -75,7 +75,7 @@ __weak int __sata_stop(void)
int sata_stop(void) __attribute__((weak, alias("__sata_stop"))); int sata_stop(void) __attribute__((weak, alias("__sata_stop")));
#ifdef CONFIG_PARTITIONS #ifdef CONFIG_PARTITIONS
block_dev_desc_t *sata_get_dev(int dev) struct blk_desc *sata_get_dev(int dev)
{ {
return (dev < CONFIG_SYS_SATA_MAX_DEVICE) ? &sata_dev_desc[dev] : NULL; return (dev < CONFIG_SYS_SATA_MAX_DEVICE) ? &sata_dev_desc[dev] : NULL;
} }
@ -131,7 +131,7 @@ static int do_sata(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
++ok; ++ok;
if (dev) if (dev)
putc ('\n'); putc ('\n');
print_part(&sata_dev_desc[dev]); part_print(&sata_dev_desc[dev]);
} }
} }
if (!ok) { if (!ok) {
@ -164,7 +164,7 @@ static int do_sata(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
int dev = (int)simple_strtoul(argv[2], NULL, 10); int dev = (int)simple_strtoul(argv[2], NULL, 10);
if (sata_dev_desc[dev].part_type != PART_TYPE_UNKNOWN) { if (sata_dev_desc[dev].part_type != PART_TYPE_UNKNOWN) {
print_part(&sata_dev_desc[dev]); part_print(&sata_dev_desc[dev]);
} else { } else {
printf("\nSATA device %d not available\n", dev); printf("\nSATA device %d not available\n", dev);
rc = 1; rc = 1;

24
cmd/scsi.c
View file

@ -48,7 +48,7 @@ static int scsi_max_devs; /* number of highest available scsi device */
static int scsi_curr_dev; /* current device */ static int scsi_curr_dev; /* current device */
static block_dev_desc_t scsi_dev_desc[CONFIG_SYS_SCSI_MAX_DEVICE]; static struct blk_desc scsi_dev_desc[CONFIG_SYS_SCSI_MAX_DEVICE];
/******************************************************************************** /********************************************************************************
* forward declerations of some Setup Routines * forward declerations of some Setup Routines
@ -66,9 +66,9 @@ void scsi_ident_cpy (unsigned char *dest, unsigned char *src, unsigned int len);
static int scsi_read_capacity(ccb *pccb, lbaint_t *capacity, static int scsi_read_capacity(ccb *pccb, lbaint_t *capacity,
unsigned long *blksz); unsigned long *blksz);
static ulong scsi_read(block_dev_desc_t *block_dev, lbaint_t blknr, static ulong scsi_read(struct blk_desc *block_dev, lbaint_t blknr,
lbaint_t blkcnt, void *buffer); lbaint_t blkcnt, void *buffer);
static ulong scsi_write(block_dev_desc_t *block_dev, lbaint_t blknr, static ulong scsi_write(struct blk_desc *block_dev, lbaint_t blknr,
lbaint_t blkcnt, const void *buffer); lbaint_t blkcnt, const void *buffer);
@ -99,7 +99,7 @@ void scsi_scan(int mode)
scsi_dev_desc[i].revision[0]=0; scsi_dev_desc[i].revision[0]=0;
scsi_dev_desc[i].removable = false; scsi_dev_desc[i].removable = false;
scsi_dev_desc[i].if_type=IF_TYPE_SCSI; scsi_dev_desc[i].if_type=IF_TYPE_SCSI;
scsi_dev_desc[i].dev=i; scsi_dev_desc[i].devnum = i;
scsi_dev_desc[i].part_type=PART_TYPE_UNKNOWN; scsi_dev_desc[i].part_type=PART_TYPE_UNKNOWN;
scsi_dev_desc[i].block_read=scsi_read; scsi_dev_desc[i].block_read=scsi_read;
scsi_dev_desc[i].block_write = scsi_write; scsi_dev_desc[i].block_write = scsi_write;
@ -156,7 +156,7 @@ void scsi_scan(int mode)
scsi_dev_desc[scsi_max_devs].log2blksz = scsi_dev_desc[scsi_max_devs].log2blksz =
LOG2(scsi_dev_desc[scsi_max_devs].blksz); LOG2(scsi_dev_desc[scsi_max_devs].blksz);
scsi_dev_desc[scsi_max_devs].type=perq; scsi_dev_desc[scsi_max_devs].type=perq;
init_part(&scsi_dev_desc[scsi_max_devs]); part_init(&scsi_dev_desc[scsi_max_devs]);
removable: removable:
if(mode==1) { if(mode==1) {
printf (" Device %d: ", scsi_max_devs); printf (" Device %d: ", scsi_max_devs);
@ -239,7 +239,7 @@ void scsi_init(void)
#endif #endif
#ifdef CONFIG_PARTITIONS #ifdef CONFIG_PARTITIONS
block_dev_desc_t * scsi_get_dev(int dev) struct blk_desc *scsi_get_dev(int dev)
{ {
return (dev < CONFIG_SYS_SCSI_MAX_DEVICE) ? &scsi_dev_desc[dev] : NULL; return (dev < CONFIG_SYS_SCSI_MAX_DEVICE) ? &scsi_dev_desc[dev] : NULL;
} }
@ -301,7 +301,7 @@ int do_scsi (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
if (dev) if (dev)
printf("\n"); printf("\n");
debug ("print_part of %x\n",dev); debug ("print_part of %x\n",dev);
print_part(&scsi_dev_desc[dev]); part_print(&scsi_dev_desc[dev]);
} }
} }
if (!ok) if (!ok)
@ -329,7 +329,7 @@ int do_scsi (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
if (strncmp(argv[1],"part",4) == 0) { if (strncmp(argv[1],"part",4) == 0) {
int dev = (int)simple_strtoul(argv[2], NULL, 10); int dev = (int)simple_strtoul(argv[2], NULL, 10);
if(scsi_dev_desc[dev].type != DEV_TYPE_UNKNOWN) { if(scsi_dev_desc[dev].type != DEV_TYPE_UNKNOWN) {
print_part(&scsi_dev_desc[dev]); part_print(&scsi_dev_desc[dev]);
} }
else { else {
printf ("\nSCSI device %d not available\n", dev); printf ("\nSCSI device %d not available\n", dev);
@ -376,10 +376,10 @@ int do_scsi (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
#define SCSI_MAX_READ_BLK 0xFFFF #define SCSI_MAX_READ_BLK 0xFFFF
#define SCSI_LBA48_READ 0xFFFFFFF #define SCSI_LBA48_READ 0xFFFFFFF
static ulong scsi_read(block_dev_desc_t *block_dev, lbaint_t blknr, static ulong scsi_read(struct blk_desc *block_dev, lbaint_t blknr,
lbaint_t blkcnt, void *buffer) lbaint_t blkcnt, void *buffer)
{ {
int device = block_dev->dev; int device = block_dev->devnum;
lbaint_t start, blks; lbaint_t start, blks;
uintptr_t buf_addr; uintptr_t buf_addr;
unsigned short smallblks = 0; unsigned short smallblks = 0;
@ -443,10 +443,10 @@ static ulong scsi_read(block_dev_desc_t *block_dev, lbaint_t blknr,
/* Almost the maximum amount of the scsi_ext command.. */ /* Almost the maximum amount of the scsi_ext command.. */
#define SCSI_MAX_WRITE_BLK 0xFFFF #define SCSI_MAX_WRITE_BLK 0xFFFF
static ulong scsi_write(block_dev_desc_t *block_dev, lbaint_t blknr, static ulong scsi_write(struct blk_desc *block_dev, lbaint_t blknr,
lbaint_t blkcnt, const void *buffer) lbaint_t blkcnt, const void *buffer)
{ {
int device = block_dev->dev; int device = block_dev->devnum;
lbaint_t start, blks; lbaint_t start, blks;
uintptr_t buf_addr; uintptr_t buf_addr;
unsigned short smallblks; unsigned short smallblks;

4
cmd/tpm.c
View file

@ -447,8 +447,8 @@ static int get_tpm(struct udevice **devp)
{ {
int rc; int rc;
rc = uclass_first_device(UCLASS_TPM, devp); rc = uclass_first_device_err(UCLASS_TPM, devp);
if (rc || !*devp) { if (rc) {
printf("Could not find TPM (ret=%d)\n", rc); printf("Could not find TPM (ret=%d)\n", rc);
return CMD_RET_FAILURE; return CMD_RET_FAILURE;
} }

4
cmd/unzip.c
View file

@ -43,7 +43,7 @@ U_BOOT_CMD(
static int do_gzwrite(cmd_tbl_t *cmdtp, int flag, static int do_gzwrite(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[]) int argc, char * const argv[])
{ {
block_dev_desc_t *bdev; struct blk_desc *bdev;
int ret; int ret;
unsigned char *addr; unsigned char *addr;
unsigned long length; unsigned long length;
@ -53,7 +53,7 @@ static int do_gzwrite(cmd_tbl_t *cmdtp, int flag,
if (argc < 5) if (argc < 5)
return CMD_RET_USAGE; return CMD_RET_USAGE;
ret = get_device(argv[1], argv[2], &bdev); ret = blk_get_device_by_str(argv[1], argv[2], &bdev);
if (ret < 0) if (ret < 0)
return CMD_RET_FAILURE; return CMD_RET_FAILURE;

12
cmd/usb.c
View file

@ -625,7 +625,7 @@ static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
int i; int i;
extern char usb_started; extern char usb_started;
#ifdef CONFIG_USB_STORAGE #ifdef CONFIG_USB_STORAGE
block_dev_desc_t *stor_dev; struct blk_desc *stor_dev;
#endif #endif
if (argc < 2) if (argc < 2)
@ -727,7 +727,7 @@ static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
if (devno) if (devno)
printf("\n"); printf("\n");
debug("print_part of %x\n", devno); debug("print_part of %x\n", devno);
print_part(stor_dev); part_print(stor_dev);
} }
} }
} else { } else {
@ -737,7 +737,7 @@ static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
stor_dev->type != DEV_TYPE_UNKNOWN) { stor_dev->type != DEV_TYPE_UNKNOWN) {
ok++; ok++;
debug("print_part of %x\n", devno); debug("print_part of %x\n", devno);
print_part(stor_dev); part_print(stor_dev);
} }
} }
if (!ok) { if (!ok) {
@ -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" printf("\nUSB read: device %d block # %ld, count %ld"
" ... ", usb_stor_curr_dev, blk, cnt); " ... ", usb_stor_curr_dev, blk, cnt);
stor_dev = usb_stor_get_dev(usb_stor_curr_dev); stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
n = stor_dev->block_read(stor_dev, blk, cnt, n = blk_dread(stor_dev, blk, cnt, (ulong *)addr);
(ulong *)addr);
printf("%ld blocks read: %s\n", n, printf("%ld blocks read: %s\n", n,
(n == cnt) ? "OK" : "ERROR"); (n == cnt) ? "OK" : "ERROR");
if (n == cnt) 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" printf("\nUSB write: device %d block # %ld, count %ld"
" ... ", usb_stor_curr_dev, blk, cnt); " ... ", usb_stor_curr_dev, blk, cnt);
stor_dev = usb_stor_get_dev(usb_stor_curr_dev); stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
n = stor_dev->block_write(stor_dev, blk, cnt, n = blk_dwrite(stor_dev, blk, cnt, (ulong *)addr);
(ulong *)addr);
printf("%ld blocks write: %s\n", n, printf("%ld blocks write: %s\n", n,
(n == cnt) ? "OK" : "ERROR"); (n == cnt) ? "OK" : "ERROR");
if (n == cnt) if (n == cnt)

10
cmd/usb_mass_storage.c
View file

@ -19,7 +19,7 @@
static int ums_read_sector(struct ums *ums_dev, static int ums_read_sector(struct ums *ums_dev,
ulong start, lbaint_t blkcnt, void *buf) ulong start, lbaint_t blkcnt, void *buf)
{ {
block_dev_desc_t *block_dev = &ums_dev->block_dev; struct blk_desc *block_dev = &ums_dev->block_dev;
lbaint_t blkstart = start + ums_dev->start_sector; lbaint_t blkstart = start + ums_dev->start_sector;
return block_dev->block_read(block_dev, blkstart, blkcnt, buf); return block_dev->block_read(block_dev, blkstart, blkcnt, buf);
@ -28,7 +28,7 @@ static int ums_read_sector(struct ums *ums_dev,
static int ums_write_sector(struct ums *ums_dev, static int ums_write_sector(struct ums *ums_dev,
ulong start, lbaint_t blkcnt, const void *buf) ulong start, lbaint_t blkcnt, const void *buf)
{ {
block_dev_desc_t *block_dev = &ums_dev->block_dev; struct blk_desc *block_dev = &ums_dev->block_dev;
lbaint_t blkstart = start + ums_dev->start_sector; lbaint_t blkstart = start + ums_dev->start_sector;
return block_dev->block_write(block_dev, blkstart, blkcnt, buf); return block_dev->block_write(block_dev, blkstart, blkcnt, buf);
@ -53,7 +53,7 @@ static void ums_fini(void)
static int ums_init(const char *devtype, const char *devnums) static int ums_init(const char *devtype, const char *devnums)
{ {
char *s, *t, *devnum, *name; char *s, *t, *devnum, *name;
block_dev_desc_t *block_dev; struct blk_desc *block_dev;
int ret; int ret;
struct ums *ums_new; struct ums *ums_new;
@ -69,7 +69,7 @@ static int ums_init(const char *devtype, const char *devnums)
if (!devnum) if (!devnum)
break; break;
ret = get_device(devtype, devnum, &block_dev); ret = blk_get_device_by_str(devtype, devnum, &block_dev);
if (ret < 0) if (ret < 0)
goto cleanup; goto cleanup;
@ -100,7 +100,7 @@ static int ums_init(const char *devtype, const char *devnums)
ums[ums_count].block_dev = *block_dev; ums[ums_count].block_dev = *block_dev;
printf("UMS: LUN %d, dev %d, hwpart %d, sector %#x, count %#x\n", printf("UMS: LUN %d, dev %d, hwpart %d, sector %#x, count %#x\n",
ums_count, ums[ums_count].block_dev.dev, ums_count, ums[ums_count].block_dev.devnum,
ums[ums_count].block_dev.hwpart, ums[ums_count].block_dev.hwpart,
ums[ums_count].start_sector, ums[ums_count].start_sector,
ums[ums_count].num_sectors); ums[ums_count].num_sectors);

10
cmd/zfs.c
View file

@ -39,7 +39,7 @@ static int do_zfs_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]
int part; int part;
ulong addr = 0; ulong addr = 0;
disk_partition_t info; disk_partition_t info;
block_dev_desc_t *dev_desc; struct blk_desc *dev_desc;
char buf[12]; char buf[12];
unsigned long count; unsigned long count;
const char *addr_str; const char *addr_str;
@ -80,11 +80,11 @@ static int do_zfs_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]
return 1; return 1;
} }
part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); part = blk_get_device_part_str(argv[1], argv[2], &dev_desc, &info, 1);
if (part < 0) if (part < 0)
return 1; return 1;
dev = dev_desc->dev; dev = dev_desc->devnum;
printf("Loading file \"%s\" from %s device %d%c%c\n", printf("Loading file \"%s\" from %s device %d%c%c\n",
filename, argv[1], dev, filename, argv[1], dev,
part ? ':' : ' ', part ? part + '0' : ' '); part ? ':' : ' ', part ? part + '0' : ' ');
@ -135,7 +135,7 @@ static int do_zfs_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{ {
const char *filename = "/"; const char *filename = "/";
int part; int part;
block_dev_desc_t *dev_desc; struct blk_desc *dev_desc;
disk_partition_t info; disk_partition_t info;
struct device_s vdev; struct device_s vdev;
@ -145,7 +145,7 @@ static int do_zfs_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
if (argc == 4) if (argc == 4)
filename = argv[3]; filename = argv[3];
part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); part = blk_get_device_part_str(argv[1], argv[2], &dev_desc, &info, 1);
if (part < 0) if (part < 0)
return 1; return 1;

12
common/env_fat.c
View file

@ -38,7 +38,7 @@ int env_init(void)
int saveenv(void) int saveenv(void)
{ {
env_t env_new; env_t env_new;
block_dev_desc_t *dev_desc = NULL; struct blk_desc *dev_desc = NULL;
disk_partition_t info; disk_partition_t info;
int dev, part; int dev, part;
int err; int err;
@ -48,13 +48,13 @@ int saveenv(void)
if (err) if (err)
return err; return err;
part = get_device_and_partition(FAT_ENV_INTERFACE, part = blk_get_device_part_str(FAT_ENV_INTERFACE,
FAT_ENV_DEVICE_AND_PART, FAT_ENV_DEVICE_AND_PART,
&dev_desc, &info, 1); &dev_desc, &info, 1);
if (part < 0) if (part < 0)
return 1; return 1;
dev = dev_desc->dev; dev = dev_desc->devnum;
if (fat_set_blk_dev(dev_desc, &info) != 0) { if (fat_set_blk_dev(dev_desc, &info) != 0) {
printf("\n** Unable to use %s %d:%d for saveenv **\n", printf("\n** Unable to use %s %d:%d for saveenv **\n",
FAT_ENV_INTERFACE, dev, part); FAT_ENV_INTERFACE, dev, part);
@ -77,18 +77,18 @@ int saveenv(void)
void env_relocate_spec(void) void env_relocate_spec(void)
{ {
ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE); ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
block_dev_desc_t *dev_desc = NULL; struct blk_desc *dev_desc = NULL;
disk_partition_t info; disk_partition_t info;
int dev, part; int dev, part;
int err; int err;
part = get_device_and_partition(FAT_ENV_INTERFACE, part = blk_get_device_part_str(FAT_ENV_INTERFACE,
FAT_ENV_DEVICE_AND_PART, FAT_ENV_DEVICE_AND_PART,
&dev_desc, &info, 1); &dev_desc, &info, 1);
if (part < 0) if (part < 0)
goto err_env_relocate; goto err_env_relocate;
dev = dev_desc->dev; dev = dev_desc->devnum;
if (fat_set_blk_dev(dev_desc, &info) != 0) { if (fat_set_blk_dev(dev_desc, &info) != 0) {
printf("\n** Unable to use %s %d:%d for loading the env **\n", printf("\n** Unable to use %s %d:%d for loading the env **\n",
FAT_ENV_INTERFACE, dev, part); FAT_ENV_INTERFACE, dev, part);

33
common/fb_mmc.c
View file

@ -6,6 +6,7 @@
#include <config.h> #include <config.h>
#include <common.h> #include <common.h>
#include <blk.h>
#include <errno.h> #include <errno.h>
#include <fastboot.h> #include <fastboot.h>
#include <fb_mmc.h> #include <fb_mmc.h>
@ -22,15 +23,15 @@
static char *response_str; static char *response_str;
struct fb_mmc_sparse { struct fb_mmc_sparse {
block_dev_desc_t *dev_desc; struct blk_desc *dev_desc;
}; };
static int get_partition_info_efi_by_name_or_alias(block_dev_desc_t *dev_desc, static int part_get_info_efi_by_name_or_alias(struct blk_desc *dev_desc,
const char *name, disk_partition_t *info) const char *name, disk_partition_t *info)
{ {
int ret; int ret;
ret = get_partition_info_efi_by_name(dev_desc, name, info); ret = part_get_info_efi_by_name(dev_desc, name, info);
if (ret) { if (ret) {
/* strlen("fastboot_partition_alias_") + 32(part_name) + 1 */ /* strlen("fastboot_partition_alias_") + 32(part_name) + 1 */
char env_alias_name[25 + 32 + 1]; char env_alias_name[25 + 32 + 1];
@ -41,7 +42,7 @@ static int get_partition_info_efi_by_name_or_alias(block_dev_desc_t *dev_desc,
strncat(env_alias_name, name, 32); strncat(env_alias_name, name, 32);
aliased_part_name = getenv(env_alias_name); aliased_part_name = getenv(env_alias_name);
if (aliased_part_name != NULL) if (aliased_part_name != NULL)
ret = get_partition_info_efi_by_name(dev_desc, ret = part_get_info_efi_by_name(dev_desc,
aliased_part_name, info); aliased_part_name, info);
} }
return ret; return ret;
@ -55,17 +56,17 @@ static int fb_mmc_sparse_write(struct sparse_storage *storage,
char *data) char *data)
{ {
struct fb_mmc_sparse *sparse = priv; struct fb_mmc_sparse *sparse = priv;
block_dev_desc_t *dev_desc = sparse->dev_desc; struct blk_desc *dev_desc = sparse->dev_desc;
int ret; int ret;
ret = dev_desc->block_write(dev_desc, offset, size, data); ret = blk_dwrite(dev_desc, offset, size, data);
if (!ret) if (!ret)
return -EIO; return -EIO;
return ret; return ret;
} }
static void write_raw_image(block_dev_desc_t *dev_desc, disk_partition_t *info, static void write_raw_image(struct blk_desc *dev_desc, disk_partition_t *info,
const char *part_name, void *buffer, const char *part_name, void *buffer,
unsigned int download_bytes) unsigned int download_bytes)
{ {
@ -84,9 +85,9 @@ static void write_raw_image(block_dev_desc_t *dev_desc, disk_partition_t *info,
puts("Flashing Raw Image\n"); 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) { if (blks != blkcnt) {
error("failed writing to device %d\n", dev_desc->dev); error("failed writing to device %d\n", dev_desc->devnum);
fastboot_fail(response_str, "failed writing to device"); fastboot_fail(response_str, "failed writing to device");
return; return;
} }
@ -100,13 +101,13 @@ void fb_mmc_flash_write(const char *cmd, unsigned int session_id,
void *download_buffer, unsigned int download_bytes, void *download_buffer, unsigned int download_bytes,
char *response) char *response)
{ {
block_dev_desc_t *dev_desc; struct blk_desc *dev_desc;
disk_partition_t info; disk_partition_t info;
/* initialize the response buffer */ /* initialize the response buffer */
response_str = response; response_str = response;
dev_desc = get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV); dev_desc = blk_get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) { if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
error("invalid mmc device\n"); error("invalid mmc device\n");
fastboot_fail(response_str, "invalid mmc device"); fastboot_fail(response_str, "invalid mmc device");
@ -131,7 +132,7 @@ void fb_mmc_flash_write(const char *cmd, unsigned int session_id,
printf("........ success\n"); printf("........ success\n");
fastboot_okay(response_str, ""); fastboot_okay(response_str, "");
return; return;
} else if (get_partition_info_efi_by_name_or_alias(dev_desc, cmd, &info)) { } else if (part_get_info_efi_by_name_or_alias(dev_desc, cmd, &info)) {
error("cannot find partition: '%s'\n", cmd); error("cannot find partition: '%s'\n", cmd);
fastboot_fail(response_str, "cannot find partition"); fastboot_fail(response_str, "cannot find partition");
return; return;
@ -165,7 +166,7 @@ void fb_mmc_flash_write(const char *cmd, unsigned int session_id,
void fb_mmc_erase(const char *cmd, char *response) void fb_mmc_erase(const char *cmd, char *response)
{ {
int ret; int ret;
block_dev_desc_t *dev_desc; struct blk_desc *dev_desc;
disk_partition_t info; disk_partition_t info;
lbaint_t blks, blks_start, blks_size, grp_size; lbaint_t blks, blks_start, blks_size, grp_size;
struct mmc *mmc = find_mmc_device(CONFIG_FASTBOOT_FLASH_MMC_DEV); struct mmc *mmc = find_mmc_device(CONFIG_FASTBOOT_FLASH_MMC_DEV);
@ -179,14 +180,14 @@ void fb_mmc_erase(const char *cmd, char *response)
/* initialize the response buffer */ /* initialize the response buffer */
response_str = response; response_str = response;
dev_desc = get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV); dev_desc = blk_get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) { if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
error("invalid mmc device"); error("invalid mmc device");
fastboot_fail(response_str, "invalid mmc device"); fastboot_fail(response_str, "invalid mmc device");
return; return;
} }
ret = get_partition_info_efi_by_name_or_alias(dev_desc, cmd, &info); ret = part_get_info_efi_by_name_or_alias(dev_desc, cmd, &info);
if (ret) { if (ret) {
error("cannot find partition: '%s'", cmd); error("cannot find partition: '%s'", cmd);
fastboot_fail(response_str, "cannot find partition"); fastboot_fail(response_str, "cannot find partition");
@ -207,7 +208,7 @@ void fb_mmc_erase(const char *cmd, char *response)
blks = dev_desc->block_erase(dev_desc, blks_start, blks_size); blks = dev_desc->block_erase(dev_desc, blks_start, blks_size);
if (blks != blks_size) { if (blks != blks_size) {
error("failed erasing from device %d", dev_desc->dev); error("failed erasing from device %d", dev_desc->devnum);
fastboot_fail(response_str, "failed erasing from device"); fastboot_fail(response_str, "failed erasing from device");
return; return;
} }

12
common/spl/spl_ext.c
View file

@ -10,7 +10,7 @@
#include <image.h> #include <image.h>
#ifdef CONFIG_SPL_EXT_SUPPORT #ifdef CONFIG_SPL_EXT_SUPPORT
int spl_load_image_ext(block_dev_desc_t *block_dev, int spl_load_image_ext(struct blk_desc *block_dev,
int partition, int partition,
const char *filename) const char *filename)
{ {
@ -22,8 +22,7 @@ int spl_load_image_ext(block_dev_desc_t *block_dev,
header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
sizeof(struct image_header)); sizeof(struct image_header));
if (get_partition_info(block_dev, if (part_get_info(block_dev, partition, &part_info)) {
partition, &part_info)) {
printf("spl: no partition table found\n"); printf("spl: no partition table found\n");
return -1; return -1;
} }
@ -64,15 +63,14 @@ end:
} }
#ifdef CONFIG_SPL_OS_BOOT #ifdef CONFIG_SPL_OS_BOOT
int spl_load_image_ext_os(block_dev_desc_t *block_dev, int partition) int spl_load_image_ext_os(struct blk_desc *block_dev, int partition)
{ {
int err; int err;
__maybe_unused loff_t filelen, actlen; __maybe_unused loff_t filelen, actlen;
disk_partition_t part_info = {}; disk_partition_t part_info = {};
__maybe_unused char *file; __maybe_unused char *file;
if (get_partition_info(block_dev, if (part_get_info(block_dev, partition, &part_info)) {
partition, &part_info)) {
printf("spl: no partition table found\n"); printf("spl: no partition table found\n");
return -1; return -1;
} }
@ -137,7 +135,7 @@ defaults:
CONFIG_SPL_FS_LOAD_KERNEL_NAME); CONFIG_SPL_FS_LOAD_KERNEL_NAME);
} }
#else #else
int spl_load_image_ext_os(block_dev_desc_t *block_dev, int partition) int spl_load_image_ext_os(struct blk_desc *block_dev, int partition)
{ {
return -ENOSYS; return -ENOSYS;
} }

8
common/spl/spl_fat.c
View file

@ -19,7 +19,7 @@
static int fat_registered; static int fat_registered;
#ifdef CONFIG_SPL_FAT_SUPPORT #ifdef CONFIG_SPL_FAT_SUPPORT
static int spl_register_fat_device(block_dev_desc_t *block_dev, int partition) static int spl_register_fat_device(struct blk_desc *block_dev, int partition)
{ {
int err = 0; int err = 0;
@ -39,7 +39,7 @@ static int spl_register_fat_device(block_dev_desc_t *block_dev, int partition)
return err; return err;
} }
int spl_load_image_fat(block_dev_desc_t *block_dev, int spl_load_image_fat(struct blk_desc *block_dev,
int partition, int partition,
const char *filename) const char *filename)
{ {
@ -72,7 +72,7 @@ end:
} }
#ifdef CONFIG_SPL_OS_BOOT #ifdef CONFIG_SPL_OS_BOOT
int spl_load_image_fat_os(block_dev_desc_t *block_dev, int partition) int spl_load_image_fat_os(struct blk_desc *block_dev, int partition)
{ {
int err; int err;
__maybe_unused char *file; __maybe_unused char *file;
@ -121,7 +121,7 @@ defaults:
CONFIG_SPL_FS_LOAD_KERNEL_NAME); CONFIG_SPL_FS_LOAD_KERNEL_NAME);
} }
#else #else
int spl_load_image_fat_os(block_dev_desc_t *block_dev, int partition) int spl_load_image_fat_os(struct blk_desc *block_dev, int partition)
{ {
return -ENOSYS; return -ENOSYS;
} }

2
common/spl/spl_mmc.c
View file

@ -161,7 +161,7 @@ static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
disk_partition_t info; disk_partition_t info;
int err; int err;
err = get_partition_info(&mmc->block_dev, partition, &info); err = part_get_info(&mmc->block_dev, partition, &info);
if (err) { if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
puts("spl: partition error\n"); puts("spl: partition error\n");

2
common/spl/spl_sata.c
View file

@ -23,7 +23,7 @@ DECLARE_GLOBAL_DATA_PTR;
int spl_sata_load_image(void) int spl_sata_load_image(void)
{ {
int err; int err;
block_dev_desc_t *stor_dev; struct blk_desc *stor_dev;
err = init_sata(CONFIG_SPL_SATA_BOOT_DEVICE); err = init_sata(CONFIG_SPL_SATA_BOOT_DEVICE);
if (err) { if (err) {

2
common/spl/spl_usb.c
View file

@ -25,7 +25,7 @@ static int usb_stor_curr_dev = -1; /* current device */
int spl_usb_load_image(void) int spl_usb_load_image(void)
{ {
int err; int err;
block_dev_desc_t *stor_dev; struct blk_desc *stor_dev;
usb_stop(); usb_stop();
err = usb_init(); err = usb_init();

272
common/usb_storage.c
View file

@ -43,6 +43,7 @@
#include <asm/byteorder.h> #include <asm/byteorder.h>
#include <asm/processor.h> #include <asm/processor.h>
#include <dm/device-internal.h> #include <dm/device-internal.h>
#include <dm/lists.h>
#include <part.h> #include <part.h>
#include <usb.h> #include <usb.h>
@ -67,7 +68,9 @@ static __u32 CBWTag;
static int usb_max_devs; /* number of highest available usb device */ static int usb_max_devs; /* number of highest available usb device */
static block_dev_desc_t usb_dev_desc[USB_MAX_STOR_DEV]; #ifndef CONFIG_BLK
static struct blk_desc usb_dev_desc[USB_MAX_STOR_DEV];
#endif
struct us_data; struct us_data;
typedef int (*trans_cmnd)(ccb *cb, struct us_data *data); typedef int (*trans_cmnd)(ccb *cb, struct us_data *data);
@ -108,26 +111,45 @@ struct us_data {
#define USB_MAX_XFER_BLK 20 #define USB_MAX_XFER_BLK 20
#endif #endif
#ifndef CONFIG_BLK
static struct us_data usb_stor[USB_MAX_STOR_DEV]; static struct us_data usb_stor[USB_MAX_STOR_DEV];
#endif
#define USB_STOR_TRANSPORT_GOOD 0 #define USB_STOR_TRANSPORT_GOOD 0
#define USB_STOR_TRANSPORT_FAILED -1 #define USB_STOR_TRANSPORT_FAILED -1
#define USB_STOR_TRANSPORT_ERROR -2 #define USB_STOR_TRANSPORT_ERROR -2
int usb_stor_get_info(struct usb_device *dev, struct us_data *us, int usb_stor_get_info(struct usb_device *dev, struct us_data *us,
block_dev_desc_t *dev_desc); struct blk_desc *dev_desc);
int usb_storage_probe(struct usb_device *dev, unsigned int ifnum, int usb_storage_probe(struct usb_device *dev, unsigned int ifnum,
struct us_data *ss); struct us_data *ss);
static unsigned long usb_stor_read(block_dev_desc_t *block_dev, lbaint_t blknr, #ifdef CONFIG_BLK
static unsigned long usb_stor_read(struct udevice *dev, lbaint_t blknr,
lbaint_t blkcnt, void *buffer); lbaint_t blkcnt, void *buffer);
static unsigned long usb_stor_write(block_dev_desc_t *block_dev, lbaint_t blknr, static unsigned long usb_stor_write(struct udevice *dev, lbaint_t blknr,
lbaint_t blkcnt, const void *buffer); lbaint_t blkcnt, const void *buffer);
#else
static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr,
lbaint_t blkcnt, void *buffer);
static unsigned long usb_stor_write(struct blk_desc *block_dev, lbaint_t blknr,
lbaint_t blkcnt, const void *buffer);
#endif
void uhci_show_temp_int_td(void); void uhci_show_temp_int_td(void);
#ifdef CONFIG_PARTITIONS #ifdef CONFIG_PARTITIONS
block_dev_desc_t *usb_stor_get_dev(int index) struct blk_desc *usb_stor_get_dev(int index)
{ {
#ifdef CONFIG_BLK
struct udevice *dev;
int ret;
ret = blk_get_device(IF_TYPE_USB, index, &dev);
if (ret)
return NULL;
return dev_get_uclass_platdata(dev);
#else
return (index < usb_max_devs) ? &usb_dev_desc[index] : NULL; return (index < usb_max_devs) ? &usb_dev_desc[index] : NULL;
#endif
} }
#endif #endif
@ -142,6 +164,20 @@ static void usb_show_progress(void)
*/ */
int usb_stor_info(void) int usb_stor_info(void)
{ {
int count = 0;
#ifdef CONFIG_BLK
struct udevice *dev;
for (blk_first_device(IF_TYPE_USB, &dev);
dev;
blk_next_device(&dev)) {
struct blk_desc *desc = dev_get_uclass_platdata(dev);
printf(" Device %d: ", desc->devnum);
dev_print(desc);
count++;
}
#else
int i; int i;
if (usb_max_devs > 0) { if (usb_max_devs > 0) {
@ -151,8 +187,12 @@ int usb_stor_info(void)
} }
return 0; return 0;
} }
#endif
if (!count) {
printf("No storage devices, perhaps not 'usb start'ed..?\n");
return 1;
}
printf("No storage devices, perhaps not 'usb start'ed..?\n");
return 1; return 1;
} }
@ -171,52 +211,110 @@ static unsigned int usb_get_max_lun(struct us_data *us)
return (len > 0) ? *result : 0; return (len > 0) ? *result : 0;
} }
static int usb_stor_probe_device(struct usb_device *dev) static int usb_stor_probe_device(struct usb_device *udev)
{ {
if (dev == NULL) int lun, max_lun;
#ifdef CONFIG_BLK
struct us_data *data;
char dev_name[30], *str;
int ret;
#else
int start;
if (udev == NULL)
return -ENOENT; /* no more devices available */ return -ENOENT; /* no more devices available */
#endif
debug("\n\nProbing for storage\n"); debug("\n\nProbing for storage\n");
if (usb_storage_probe(dev, 0, &usb_stor[usb_max_devs])) { #ifdef CONFIG_BLK
/* OK, it's a storage device. Iterate over its LUNs /*
* and populate `usb_dev_desc'. * We store the us_data in the mass storage device's platdata. It
*/ * is shared by all LUNs (block devices) attached to this mass storage
int lun, max_lun, start = usb_max_devs; * device.
*/
data = dev_get_platdata(udev->dev);
if (!usb_storage_probe(udev, 0, data))
return 0;
max_lun = usb_get_max_lun(data);
for (lun = 0; lun <= max_lun; lun++) {
struct blk_desc *blkdev;
struct udevice *dev;
max_lun = usb_get_max_lun(&usb_stor[usb_max_devs]); snprintf(dev_name, sizeof(dev_name), "%s.lun%d",
for (lun = 0; udev->dev->name, lun);
lun <= max_lun && usb_max_devs < USB_MAX_STOR_DEV; str = strdup(dev_name);
lun++) { if (!str)
struct block_dev_desc *blkdev; return -ENOMEM;
ret = blk_create_device(udev->dev, "usb_storage_blk", str,
IF_TYPE_USB, usb_max_devs, 512, 0, &dev);
if (ret) {
debug("Cannot bind driver\n");
return ret;
}
blkdev = &usb_dev_desc[usb_max_devs]; blkdev = dev_get_uclass_platdata(dev);
memset(blkdev, '\0', sizeof(block_dev_desc_t)); blkdev->target = 0xff;
blkdev->if_type = IF_TYPE_USB; blkdev->lun = lun;
blkdev->dev = usb_max_devs;
blkdev->part_type = PART_TYPE_UNKNOWN;
blkdev->target = 0xff;
blkdev->type = DEV_TYPE_UNKNOWN;
blkdev->block_read = usb_stor_read;
blkdev->block_write = usb_stor_write;
blkdev->lun = lun;
blkdev->priv = dev;
if (usb_stor_get_info(dev, &usb_stor[start], ret = usb_stor_get_info(udev, data, blkdev);
&usb_dev_desc[usb_max_devs]) == if (ret == 1)
1) { ret = blk_prepare_device(dev);
usb_max_devs++; if (!ret) {
debug("%s: Found device %p\n", __func__, dev); usb_max_devs++;
} debug("%s: Found device %p\n", __func__, udev);
} else {
debug("usb_stor_get_info: Invalid device\n");
ret = device_unbind(dev);
if (ret)
return ret;
} }
} }
#else
/* if storage device */ /* We don't have space to even probe if we hit the maximum */
if (usb_max_devs == USB_MAX_STOR_DEV) { if (usb_max_devs == USB_MAX_STOR_DEV) {
printf("max USB Storage Device reached: %d stopping\n", printf("max USB Storage Device reached: %d stopping\n",
usb_max_devs); usb_max_devs);
return -ENOSPC; return -ENOSPC;
} }
if (!usb_storage_probe(udev, 0, &usb_stor[usb_max_devs]))
return 0;
/*
* OK, it's a storage device. Iterate over its LUNs and populate
* usb_dev_desc'
*/
start = usb_max_devs;
max_lun = usb_get_max_lun(&usb_stor[usb_max_devs]);
for (lun = 0; lun <= max_lun && usb_max_devs < USB_MAX_STOR_DEV;
lun++) {
struct blk_desc *blkdev;
blkdev = &usb_dev_desc[usb_max_devs];
memset(blkdev, '\0', sizeof(struct blk_desc));
blkdev->if_type = IF_TYPE_USB;
blkdev->devnum = usb_max_devs;
blkdev->part_type = PART_TYPE_UNKNOWN;
blkdev->target = 0xff;
blkdev->type = DEV_TYPE_UNKNOWN;
blkdev->block_read = usb_stor_read;
blkdev->block_write = usb_stor_write;
blkdev->lun = lun;
blkdev->priv = udev;
if (usb_stor_get_info(udev, &usb_stor[start],
&usb_dev_desc[usb_max_devs]) == 1) {
debug("partype: %d\n", blkdev->part_type);
part_init(blkdev);
debug("partype: %d\n", blkdev->part_type);
usb_max_devs++;
debug("%s: Found device %p\n", __func__, udev);
}
}
#endif
return 0; return 0;
} }
@ -1011,7 +1109,7 @@ static int usb_write_10(ccb *srb, struct us_data *ss, unsigned long start,
* device with proper values (as reported by 'usb info'). * device with proper values (as reported by 'usb info').
* *
* Vendor and product length limits are taken from the definition of * Vendor and product length limits are taken from the definition of
* block_dev_desc_t in include/part.h. * struct blk_desc in include/part.h.
*/ */
static void usb_bin_fixup(struct usb_device_descriptor descriptor, static void usb_bin_fixup(struct usb_device_descriptor descriptor,
unsigned char vendor[], unsigned char vendor[],
@ -1026,39 +1124,50 @@ static void usb_bin_fixup(struct usb_device_descriptor descriptor,
} }
#endif /* CONFIG_USB_BIN_FIXUP */ #endif /* CONFIG_USB_BIN_FIXUP */
static unsigned long usb_stor_read(block_dev_desc_t *block_dev, lbaint_t blknr, #ifdef CONFIG_BLK
static unsigned long usb_stor_read(struct udevice *dev, lbaint_t blknr,
lbaint_t blkcnt, void *buffer) lbaint_t blkcnt, void *buffer)
#else
static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr,
lbaint_t blkcnt, void *buffer)
#endif
{ {
int device = block_dev->dev;
lbaint_t start, blks; lbaint_t start, blks;
uintptr_t buf_addr; uintptr_t buf_addr;
unsigned short smallblks; unsigned short smallblks;
struct usb_device *dev; struct usb_device *udev;
struct us_data *ss; struct us_data *ss;
int retry; int retry;
ccb *srb = &usb_ccb; ccb *srb = &usb_ccb;
#ifdef CONFIG_BLK
struct blk_desc *block_dev;
#endif
if (blkcnt == 0) if (blkcnt == 0)
return 0; return 0;
device &= 0xff;
/* Setup device */ /* Setup device */
debug("\nusb_read: dev %d\n", device); #ifdef CONFIG_BLK
dev = usb_dev_desc[device].priv; block_dev = dev_get_uclass_platdata(dev);
if (!dev) { udev = dev_get_parent_priv(dev_get_parent(dev));
debug("\nusb_read: udev %d\n", block_dev->devnum);
#else
debug("\nusb_read: udev %d\n", block_dev->devnum);
udev = usb_dev_desc[block_dev->devnum].priv;
if (!udev) {
debug("%s: No device\n", __func__); debug("%s: No device\n", __func__);
return 0; return 0;
} }
ss = (struct us_data *)dev->privptr; #endif
ss = (struct us_data *)udev->privptr;
usb_disable_asynch(1); /* asynch transfer not allowed */ usb_disable_asynch(1); /* asynch transfer not allowed */
srb->lun = usb_dev_desc[device].lun; srb->lun = block_dev->lun;
buf_addr = (uintptr_t)buffer; buf_addr = (uintptr_t)buffer;
start = blknr; start = blknr;
blks = blkcnt; blks = blkcnt;
debug("\nusb_read: dev %d startblk " LBAF ", blccnt " LBAF debug("\nusb_read: dev %d startblk " LBAF ", blccnt " LBAF " buffer %"
" buffer %" PRIxPTR "\n", device, start, blks, buf_addr); PRIxPTR "\n", block_dev->devnum, start, blks, buf_addr);
do { do {
/* XXX need some comment here */ /* XXX need some comment here */
@ -1071,7 +1180,7 @@ static unsigned long usb_stor_read(block_dev_desc_t *block_dev, lbaint_t blknr,
retry_it: retry_it:
if (smallblks == USB_MAX_XFER_BLK) if (smallblks == USB_MAX_XFER_BLK)
usb_show_progress(); usb_show_progress();
srb->datalen = usb_dev_desc[device].blksz * smallblks; srb->datalen = block_dev->blksz * smallblks;
srb->pdata = (unsigned char *)buf_addr; srb->pdata = (unsigned char *)buf_addr;
if (usb_read_10(srb, ss, start, smallblks)) { if (usb_read_10(srb, ss, start, smallblks)) {
debug("Read ERROR\n"); debug("Read ERROR\n");
@ -1097,38 +1206,52 @@ retry_it:
return blkcnt; return blkcnt;
} }
static unsigned long usb_stor_write(block_dev_desc_t *block_dev, lbaint_t blknr, #ifdef CONFIG_BLK
static unsigned long usb_stor_write(struct udevice *dev, lbaint_t blknr,
lbaint_t blkcnt, const void *buffer) lbaint_t blkcnt, const void *buffer)
#else
static unsigned long usb_stor_write(struct blk_desc *block_dev, lbaint_t blknr,
lbaint_t blkcnt, const void *buffer)
#endif
{ {
int device = block_dev->dev;
lbaint_t start, blks; lbaint_t start, blks;
uintptr_t buf_addr; uintptr_t buf_addr;
unsigned short smallblks; unsigned short smallblks;
struct usb_device *dev; struct usb_device *udev;
struct us_data *ss; struct us_data *ss;
int retry; int retry;
ccb *srb = &usb_ccb; ccb *srb = &usb_ccb;
#ifdef CONFIG_BLK
struct blk_desc *block_dev;
#endif
if (blkcnt == 0) if (blkcnt == 0)
return 0; return 0;
device &= 0xff;
/* Setup device */ /* Setup device */
debug("\nusb_write: dev %d\n", device); #ifdef CONFIG_BLK
dev = usb_dev_desc[device].priv; block_dev = dev_get_uclass_platdata(dev);
if (!dev) udev = dev_get_parent_priv(dev_get_parent(dev));
debug("\nusb_read: udev %d\n", block_dev->devnum);
#else
debug("\nusb_read: udev %d\n", block_dev->devnum);
udev = usb_dev_desc[block_dev->devnum].priv;
if (!udev) {
debug("%s: No device\n", __func__);
return 0; return 0;
ss = (struct us_data *)dev->privptr; }
#endif
ss = (struct us_data *)udev->privptr;
usb_disable_asynch(1); /* asynch transfer not allowed */ usb_disable_asynch(1); /* asynch transfer not allowed */
srb->lun = usb_dev_desc[device].lun; srb->lun = block_dev->lun;
buf_addr = (uintptr_t)buffer; buf_addr = (uintptr_t)buffer;
start = blknr; start = blknr;
blks = blkcnt; blks = blkcnt;
debug("\nusb_write: dev %d startblk " LBAF ", blccnt " LBAF debug("\nusb_write: dev %d startblk " LBAF ", blccnt " LBAF " buffer %"
" buffer %" PRIxPTR "\n", device, start, blks, buf_addr); PRIxPTR "\n", block_dev->devnum, start, blks, buf_addr);
do { do {
/* If write fails retry for max retry count else /* If write fails retry for max retry count else
@ -1143,7 +1266,7 @@ static unsigned long usb_stor_write(block_dev_desc_t *block_dev, lbaint_t blknr,
retry_it: retry_it:
if (smallblks == USB_MAX_XFER_BLK) if (smallblks == USB_MAX_XFER_BLK)
usb_show_progress(); usb_show_progress();
srb->datalen = usb_dev_desc[device].blksz * smallblks; srb->datalen = block_dev->blksz * smallblks;
srb->pdata = (unsigned char *)buf_addr; srb->pdata = (unsigned char *)buf_addr;
if (usb_write_10(srb, ss, start, smallblks)) { if (usb_write_10(srb, ss, start, smallblks)) {
debug("Write ERROR\n"); debug("Write ERROR\n");
@ -1289,7 +1412,7 @@ int usb_storage_probe(struct usb_device *dev, unsigned int ifnum,
} }
int usb_stor_get_info(struct usb_device *dev, struct us_data *ss, int usb_stor_get_info(struct usb_device *dev, struct us_data *ss,
block_dev_desc_t *dev_desc) struct blk_desc *dev_desc)
{ {
unsigned char perq, modi; unsigned char perq, modi;
ALLOC_CACHE_ALIGN_BUFFER(u32, cap, 2); ALLOC_CACHE_ALIGN_BUFFER(u32, cap, 2);
@ -1372,11 +1495,7 @@ int usb_stor_get_info(struct usb_device *dev, struct us_data *ss,
dev_desc->log2blksz = LOG2(dev_desc->blksz); dev_desc->log2blksz = LOG2(dev_desc->blksz);
dev_desc->type = perq; dev_desc->type = perq;
debug(" address %d\n", dev_desc->target); debug(" address %d\n", dev_desc->target);
debug("partype: %d\n", dev_desc->part_type);
init_part(dev_desc);
debug("partype: %d\n", dev_desc->part_type);
return 1; return 1;
} }
@ -1404,6 +1523,9 @@ U_BOOT_DRIVER(usb_mass_storage) = {
.id = UCLASS_MASS_STORAGE, .id = UCLASS_MASS_STORAGE,
.of_match = usb_mass_storage_ids, .of_match = usb_mass_storage_ids,
.probe = usb_mass_storage_probe, .probe = usb_mass_storage_probe,
#ifdef CONFIG_BLK
.platdata_auto_alloc_size = sizeof(struct us_data),
#endif
}; };
UCLASS_DRIVER(usb_mass_storage) = { UCLASS_DRIVER(usb_mass_storage) = {
@ -1420,5 +1542,17 @@ static const struct usb_device_id mass_storage_id_table[] = {
}; };
U_BOOT_USB_DEVICE(usb_mass_storage, mass_storage_id_table); U_BOOT_USB_DEVICE(usb_mass_storage, mass_storage_id_table);
#endif
#ifdef CONFIG_BLK
static const struct blk_ops usb_storage_ops = {
.read = usb_stor_read,
.write = usb_stor_write,
};
U_BOOT_DRIVER(usb_storage_blk) = {
.name = "usb_storage_blk",
.id = UCLASS_BLK,
.ops = &usb_storage_ops,
};
#endif #endif

230
disk/part.c
View file

@ -7,6 +7,7 @@
#include <common.h> #include <common.h>
#include <command.h> #include <command.h>
#include <errno.h>
#include <ide.h> #include <ide.h>
#include <malloc.h> #include <malloc.h>
#include <part.h> #include <part.h>
@ -22,7 +23,7 @@
struct block_drvr { struct block_drvr {
char *name; char *name;
block_dev_desc_t* (*get_dev)(int dev); struct blk_desc* (*get_dev)(int dev);
int (*select_hwpart)(int dev_num, int hwpart); int (*select_hwpart)(int dev_num, int hwpart);
}; };
@ -58,10 +59,26 @@ static const struct block_drvr block_drvr[] = {
DECLARE_GLOBAL_DATA_PTR; DECLARE_GLOBAL_DATA_PTR;
#ifdef HAVE_BLOCK_DEVICE #ifdef HAVE_BLOCK_DEVICE
static block_dev_desc_t *get_dev_hwpart(const char *ifname, int dev, int hwpart) static struct part_driver *part_driver_lookup_type(int part_type)
{
struct part_driver *drv =
ll_entry_start(struct part_driver, part_driver);
const int n_ents = ll_entry_count(struct part_driver, part_driver);
struct part_driver *entry;
for (entry = drv; entry != drv + n_ents; entry++) {
if (part_type == entry->part_type)
return entry;
}
/* Not found */
return NULL;
}
static struct blk_desc *get_dev_hwpart(const char *ifname, int dev, int hwpart)
{ {
const struct block_drvr *drvr = block_drvr; const struct block_drvr *drvr = block_drvr;
block_dev_desc_t* (*reloc_get_dev)(int dev); struct blk_desc* (*reloc_get_dev)(int dev);
int (*select_hwpart)(int dev_num, int hwpart); int (*select_hwpart)(int dev_num, int hwpart);
char *name; char *name;
int ret; int ret;
@ -84,14 +101,14 @@ static block_dev_desc_t *get_dev_hwpart(const char *ifname, int dev, int hwpart)
select_hwpart += gd->reloc_off; select_hwpart += gd->reloc_off;
#endif #endif
if (strncmp(ifname, name, strlen(name)) == 0) { if (strncmp(ifname, name, strlen(name)) == 0) {
block_dev_desc_t *dev_desc = reloc_get_dev(dev); struct blk_desc *dev_desc = reloc_get_dev(dev);
if (!dev_desc) if (!dev_desc)
return NULL; return NULL;
if (hwpart == 0 && !select_hwpart) if (hwpart == 0 && !select_hwpart)
return dev_desc; return dev_desc;
if (!select_hwpart) if (!select_hwpart)
return NULL; return NULL;
ret = select_hwpart(dev_desc->dev, hwpart); ret = select_hwpart(dev_desc->devnum, hwpart);
if (ret < 0) if (ret < 0)
return NULL; return NULL;
return dev_desc; return dev_desc;
@ -101,17 +118,17 @@ static block_dev_desc_t *get_dev_hwpart(const char *ifname, int dev, int hwpart)
return NULL; return NULL;
} }
block_dev_desc_t *get_dev(const char *ifname, int dev) struct blk_desc *blk_get_dev(const char *ifname, int dev)
{ {
return get_dev_hwpart(ifname, dev, 0); return get_dev_hwpart(ifname, dev, 0);
} }
#else #else
block_dev_desc_t *get_dev_hwpart(const char *ifname, int dev, int hwpart) struct blk_desc *get_dev_hwpart(const char *ifname, int dev, int hwpart)
{ {
return NULL; return NULL;
} }
block_dev_desc_t *get_dev(const char *ifname, int dev) struct blk_desc *blk_get_dev(const char *ifname, int dev)
{ {
return NULL; return NULL;
} }
@ -144,7 +161,7 @@ static lba512_t lba512_muldiv(lba512_t block_count, lba512_t mul_by, lba512_t di
return bc_quot * mul_by + (bc_rem * mul_by) / div_by; return bc_quot * mul_by + (bc_rem * mul_by) / div_by;
} }
void dev_print (block_dev_desc_t *dev_desc) void dev_print (struct blk_desc *dev_desc)
{ {
lba512_t lba512; /* number of blocks if 512bytes block size */ lba512_t lba512; /* number of blocks if 512bytes block size */
@ -250,55 +267,33 @@ void dev_print (block_dev_desc_t *dev_desc)
#ifdef HAVE_BLOCK_DEVICE #ifdef HAVE_BLOCK_DEVICE
void init_part(block_dev_desc_t *dev_desc) void part_init(struct blk_desc *dev_desc)
{ {
#ifdef CONFIG_ISO_PARTITION struct part_driver *drv =
if (test_part_iso(dev_desc) == 0) { ll_entry_start(struct part_driver, part_driver);
dev_desc->part_type = PART_TYPE_ISO; const int n_ents = ll_entry_count(struct part_driver, part_driver);
return; struct part_driver *entry;
}
#endif
#ifdef CONFIG_MAC_PARTITION
if (test_part_mac(dev_desc) == 0) {
dev_desc->part_type = PART_TYPE_MAC;
return;
}
#endif
/* must be placed before DOS partition detection */
#ifdef CONFIG_EFI_PARTITION
if (test_part_efi(dev_desc) == 0) {
dev_desc->part_type = PART_TYPE_EFI;
return;
}
#endif
#ifdef CONFIG_DOS_PARTITION
if (test_part_dos(dev_desc) == 0) {
dev_desc->part_type = PART_TYPE_DOS;
return;
}
#endif
#ifdef CONFIG_AMIGA_PARTITION
if (test_part_amiga(dev_desc) == 0) {
dev_desc->part_type = PART_TYPE_AMIGA;
return;
}
#endif
dev_desc->part_type = PART_TYPE_UNKNOWN; dev_desc->part_type = PART_TYPE_UNKNOWN;
for (entry = drv; entry != drv + n_ents; entry++) {
int ret;
ret = entry->test(dev_desc);
debug("%s: try '%s': ret=%d\n", __func__, entry->name, ret);
if (!ret) {
dev_desc->part_type = entry->part_type;
break;
}
}
} }
static void print_part_header(const char *type, struct blk_desc *dev_desc)
{
#if defined(CONFIG_MAC_PARTITION) || \ #if defined(CONFIG_MAC_PARTITION) || \
defined(CONFIG_DOS_PARTITION) || \ defined(CONFIG_DOS_PARTITION) || \
defined(CONFIG_ISO_PARTITION) || \ defined(CONFIG_ISO_PARTITION) || \
defined(CONFIG_AMIGA_PARTITION) || \ defined(CONFIG_AMIGA_PARTITION) || \
defined(CONFIG_EFI_PARTITION) defined(CONFIG_EFI_PARTITION)
static void print_part_header(const char *type, block_dev_desc_t *dev_desc)
{
puts ("\nPartition Map for "); puts ("\nPartition Map for ");
switch (dev_desc->if_type) { switch (dev_desc->if_type) {
case IF_TYPE_IDE: case IF_TYPE_IDE:
@ -330,63 +325,34 @@ static void print_part_header(const char *type, block_dev_desc_t *dev_desc)
break; break;
} }
printf (" device %d -- Partition Type: %s\n\n", printf (" device %d -- Partition Type: %s\n\n",
dev_desc->dev, type); dev_desc->devnum, type);
#endif /* any CONFIG_..._PARTITION */
} }
#endif /* any CONFIG_..._PARTITION */ void part_print(struct blk_desc *dev_desc)
void print_part(block_dev_desc_t * dev_desc)
{ {
struct part_driver *drv;
switch (dev_desc->part_type) { drv = part_driver_lookup_type(dev_desc->part_type);
#ifdef CONFIG_MAC_PARTITION if (!drv) {
case PART_TYPE_MAC: printf("## Unknown partition table type %x\n",
PRINTF ("## Testing for valid MAC partition ##\n"); dev_desc->part_type);
print_part_header ("MAC", dev_desc);
print_part_mac (dev_desc);
return; return;
#endif
#ifdef CONFIG_DOS_PARTITION
case PART_TYPE_DOS:
PRINTF ("## Testing for valid DOS partition ##\n");
print_part_header ("DOS", dev_desc);
print_part_dos (dev_desc);
return;
#endif
#ifdef CONFIG_ISO_PARTITION
case PART_TYPE_ISO:
PRINTF ("## Testing for valid ISO Boot partition ##\n");
print_part_header ("ISO", dev_desc);
print_part_iso (dev_desc);
return;
#endif
#ifdef CONFIG_AMIGA_PARTITION
case PART_TYPE_AMIGA:
PRINTF ("## Testing for a valid Amiga partition ##\n");
print_part_header ("AMIGA", dev_desc);
print_part_amiga (dev_desc);
return;
#endif
#ifdef CONFIG_EFI_PARTITION
case PART_TYPE_EFI:
PRINTF ("## Testing for valid EFI partition ##\n");
print_part_header ("EFI", dev_desc);
print_part_efi (dev_desc);
return;
#endif
} }
puts ("## Unknown partition table\n");
PRINTF("## Testing for valid %s partition ##\n", drv->name);
print_part_header(drv->name, dev_desc);
if (drv->print)
drv->print(dev_desc);
} }
#endif /* HAVE_BLOCK_DEVICE */ #endif /* HAVE_BLOCK_DEVICE */
int get_partition_info(block_dev_desc_t *dev_desc, int part, int part_get_info(struct blk_desc *dev_desc, int part,
disk_partition_t *info) disk_partition_t *info)
{ {
#ifdef HAVE_BLOCK_DEVICE #ifdef HAVE_BLOCK_DEVICE
struct part_driver *drv;
#ifdef CONFIG_PARTITION_UUIDS #ifdef CONFIG_PARTITION_UUIDS
/* The common case is no UUID support */ /* The common case is no UUID support */
@ -396,61 +362,27 @@ int get_partition_info(block_dev_desc_t *dev_desc, int part,
info->type_guid[0] = 0; info->type_guid[0] = 0;
#endif #endif
switch (dev_desc->part_type) { drv = part_driver_lookup_type(dev_desc->part_type);
#ifdef CONFIG_MAC_PARTITION if (!drv) {
case PART_TYPE_MAC: debug("## Unknown partition table type %x\n",
if (get_partition_info_mac(dev_desc, part, info) == 0) { dev_desc->part_type);
PRINTF("## Valid MAC partition found ##\n"); return -EPROTONOSUPPORT;
return 0; }
} if (!drv->get_info) {
break; PRINTF("## Driver %s does not have the get_info() method\n");
#endif return -ENOSYS;
}
#ifdef CONFIG_DOS_PARTITION if (drv->get_info(dev_desc, part, info) == 0) {
case PART_TYPE_DOS: PRINTF("## Valid %s partition found ##\n", drv->name);
if (get_partition_info_dos(dev_desc, part, info) == 0) { return 0;
PRINTF("## Valid DOS partition found ##\n");
return 0;
}
break;
#endif
#ifdef CONFIG_ISO_PARTITION
case PART_TYPE_ISO:
if (get_partition_info_iso(dev_desc, part, info) == 0) {
PRINTF("## Valid ISO boot partition found ##\n");
return 0;
}
break;
#endif
#ifdef CONFIG_AMIGA_PARTITION
case PART_TYPE_AMIGA:
if (get_partition_info_amiga(dev_desc, part, info) == 0) {
PRINTF("## Valid Amiga partition found ##\n");
return 0;
}
break;
#endif
#ifdef CONFIG_EFI_PARTITION
case PART_TYPE_EFI:
if (get_partition_info_efi(dev_desc, part, info) == 0) {
PRINTF("## Valid EFI partition found ##\n");
return 0;
}
break;
#endif
default:
break;
} }
#endif /* HAVE_BLOCK_DEVICE */ #endif /* HAVE_BLOCK_DEVICE */
return -1; return -1;
} }
int get_device(const char *ifname, const char *dev_hwpart_str, int blk_get_device_by_str(const char *ifname, const char *dev_hwpart_str,
block_dev_desc_t **dev_desc) struct blk_desc **dev_desc)
{ {
char *ep; char *ep;
char *dup_str = NULL; char *dup_str = NULL;
@ -500,7 +432,7 @@ int get_device(const char *ifname, const char *dev_hwpart_str,
* already loaded. * already loaded.
*/ */
if(hwpart != 0) if(hwpart != 0)
init_part(*dev_desc); part_init(*dev_desc);
#endif #endif
cleanup: cleanup:
@ -511,8 +443,8 @@ cleanup:
#define PART_UNSPECIFIED -2 #define PART_UNSPECIFIED -2
#define PART_AUTO -1 #define PART_AUTO -1
#define MAX_SEARCH_PARTITIONS 16 #define MAX_SEARCH_PARTITIONS 16
int get_device_and_partition(const char *ifname, const char *dev_part_str, int blk_get_device_part_str(const char *ifname, const char *dev_part_str,
block_dev_desc_t **dev_desc, struct blk_desc **dev_desc,
disk_partition_t *info, int allow_whole_dev) disk_partition_t *info, int allow_whole_dev)
{ {
int ret = -1; int ret = -1;
@ -525,10 +457,6 @@ int get_device_and_partition(const char *ifname, const char *dev_part_str,
int part; int part;
disk_partition_t tmpinfo; disk_partition_t tmpinfo;
#if defined CONFIG_SANDBOX && defined CONFIG_CMD_UBIFS
#error Only one of CONFIG_SANDBOX and CONFIG_CMD_UBIFS may be selected
#endif
#ifdef CONFIG_SANDBOX #ifdef CONFIG_SANDBOX
/* /*
* Special-case a pseudo block device "hostfs", to allow access to the * Special-case a pseudo block device "hostfs", to allow access to the
@ -598,7 +526,7 @@ int get_device_and_partition(const char *ifname, const char *dev_part_str,
} }
/* Look up the device */ /* Look up the device */
dev = get_device(ifname, dev_str, dev_desc); dev = blk_get_device_by_str(ifname, dev_str, dev_desc);
if (dev < 0) if (dev < 0)
goto cleanup; goto cleanup;
@ -675,7 +603,7 @@ int get_device_and_partition(const char *ifname, const char *dev_part_str,
* other than "auto", use that partition number directly. * other than "auto", use that partition number directly.
*/ */
if (part != PART_AUTO) { if (part != PART_AUTO) {
ret = get_partition_info(*dev_desc, part, info); ret = part_get_info(*dev_desc, part, info);
if (ret) { if (ret) {
printf("** Invalid partition %d **\n", part); printf("** Invalid partition %d **\n", part);
goto cleanup; goto cleanup;
@ -687,7 +615,7 @@ int get_device_and_partition(const char *ifname, const char *dev_part_str,
*/ */
part = 0; part = 0;
for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) { for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
ret = get_partition_info(*dev_desc, p, info); ret = part_get_info(*dev_desc, p, info);
if (ret) if (ret)
continue; continue;

47
disk/part_amiga.c
View file

@ -126,7 +126,7 @@ static void print_part_info(struct partition_block *p)
* the ID AMIGA_ID_RDISK ('RDSK') and needs to have a valid * the ID AMIGA_ID_RDISK ('RDSK') and needs to have a valid
* sum-to-zero checksum * sum-to-zero checksum
*/ */
struct rigid_disk_block *get_rdisk(block_dev_desc_t *dev_desc) struct rigid_disk_block *get_rdisk(struct blk_desc *dev_desc)
{ {
int i; int i;
int limit; int limit;
@ -140,7 +140,7 @@ struct rigid_disk_block *get_rdisk(block_dev_desc_t *dev_desc)
for (i=0; i<limit; i++) 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) if (res == 1)
{ {
struct rigid_disk_block *trdb = (struct rigid_disk_block *)block_buffer; struct rigid_disk_block *trdb = (struct rigid_disk_block *)block_buffer;
@ -166,7 +166,7 @@ struct rigid_disk_block *get_rdisk(block_dev_desc_t *dev_desc)
* Ridgid disk block * Ridgid disk block
*/ */
struct bootcode_block *get_bootcode(block_dev_desc_t *dev_desc) struct bootcode_block *get_bootcode(struct blk_desc *dev_desc)
{ {
int i; int i;
int limit; int limit;
@ -182,7 +182,7 @@ struct bootcode_block *get_bootcode(block_dev_desc_t *dev_desc)
for (i = 0; i < limit; i++) 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) if (res == 1)
{ {
struct bootcode_block *boot = (struct bootcode_block *)block_buffer; struct bootcode_block *boot = (struct bootcode_block *)block_buffer;
@ -207,27 +207,27 @@ struct bootcode_block *get_bootcode(block_dev_desc_t *dev_desc)
* Test if the given partition has an Amiga partition table/Rigid * Test if the given partition has an Amiga partition table/Rigid
* Disk block * Disk block
*/ */
int test_part_amiga(block_dev_desc_t *dev_desc) static int part_test_amiga(struct blk_desc *dev_desc)
{ {
struct rigid_disk_block *rdb; struct rigid_disk_block *rdb;
struct bootcode_block *bootcode; struct bootcode_block *bootcode;
PRINTF("test_part_amiga: Testing for an Amiga RDB partition\n"); PRINTF("part_test_amiga: Testing for an Amiga RDB partition\n");
rdb = get_rdisk(dev_desc); rdb = get_rdisk(dev_desc);
if (rdb) if (rdb)
{ {
bootcode = get_bootcode(dev_desc); bootcode = get_bootcode(dev_desc);
if (bootcode) if (bootcode)
PRINTF("test_part_amiga: bootable Amiga disk\n"); PRINTF("part_test_amiga: bootable Amiga disk\n");
else else
PRINTF("test_part_amiga: non-bootable Amiga disk\n"); PRINTF("part_test_amiga: non-bootable Amiga disk\n");
return 0; return 0;
} }
else else
{ {
PRINTF("test_part_amiga: no RDB found\n"); PRINTF("part_test_amiga: no RDB found\n");
return -1; return -1;
} }
@ -236,7 +236,8 @@ int test_part_amiga(block_dev_desc_t *dev_desc)
/* /*
* Find partition number partnum on the given drive. * Find partition number partnum on the given drive.
*/ */
static struct partition_block *find_partition(block_dev_desc_t *dev_desc, int partnum) static struct partition_block *find_partition(struct blk_desc *dev_desc,
int partnum)
{ {
struct rigid_disk_block *rdb; struct rigid_disk_block *rdb;
struct partition_block *p; struct partition_block *p;
@ -257,8 +258,7 @@ static struct partition_block *find_partition(block_dev_desc_t *dev_desc, int pa
while (block != 0xFFFFFFFF) while (block != 0xFFFFFFFF)
{ {
ulong res = dev_desc->block_read(dev_desc, block, 1, ulong res = blk_dread(dev_desc, block, 1, (ulong *)block_buffer);
(ulong *)block_buffer);
if (res == 1) if (res == 1)
{ {
p = (struct partition_block *)block_buffer; p = (struct partition_block *)block_buffer;
@ -290,7 +290,8 @@ static struct partition_block *find_partition(block_dev_desc_t *dev_desc, int pa
/* /*
* Get info about a partition * Get info about a partition
*/ */
int get_partition_info_amiga (block_dev_desc_t *dev_desc, int part, disk_partition_t *info) static int part_get_info_amiga(struct blk_desc *dev_desc, int part,
disk_partition_t *info)
{ {
struct partition_block *p = find_partition(dev_desc, part-1); struct partition_block *p = find_partition(dev_desc, part-1);
struct amiga_part_geometry *g; struct amiga_part_geometry *g;
@ -302,7 +303,7 @@ int get_partition_info_amiga (block_dev_desc_t *dev_desc, int part, disk_partiti
info->start = g->low_cyl * g->block_per_track * g->surfaces; info->start = g->low_cyl * g->block_per_track * g->surfaces;
info->size = (g->high_cyl - g->low_cyl + 1) * g->block_per_track * g->surfaces - 1; info->size = (g->high_cyl - g->low_cyl + 1) * g->block_per_track * g->surfaces - 1;
info->blksz = rdb.block_bytes; info->blksz = rdb.block_bytes;
bcpl_strcpy(info->name, p->drive_name); bcpl_strcpy((char *)info->name, p->drive_name);
disk_type = g->dos_type; disk_type = g->dos_type;
@ -317,7 +318,7 @@ int get_partition_info_amiga (block_dev_desc_t *dev_desc, int part, disk_partiti
return 0; return 0;
} }
void print_part_amiga (block_dev_desc_t *dev_desc) static void part_print_amiga(struct blk_desc *dev_desc)
{ {
struct rigid_disk_block *rdb; struct rigid_disk_block *rdb;
struct bootcode_block *boot; struct bootcode_block *boot;
@ -328,14 +329,14 @@ void print_part_amiga (block_dev_desc_t *dev_desc)
rdb = get_rdisk(dev_desc); rdb = get_rdisk(dev_desc);
if (!rdb) if (!rdb)
{ {
PRINTF("print_part_amiga: no rdb found\n"); PRINTF("part_print_amiga: no rdb found\n");
return; return;
} }
PRINTF("print_part_amiga: Scanning partition list\n"); PRINTF("part_print_amiga: Scanning partition list\n");
block = rdb->partition_list; block = rdb->partition_list;
PRINTF("print_part_amiga: partition list at 0x%x\n", block); PRINTF("part_print_amiga: partition list at 0x%x\n", block);
printf("Summary: DiskBlockSize: %d\n" printf("Summary: DiskBlockSize: %d\n"
" Cylinders : %d\n" " Cylinders : %d\n"
@ -353,7 +354,7 @@ void print_part_amiga (block_dev_desc_t *dev_desc)
PRINTF("Trying to load block #0x%X\n", block); 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) if (res == 1)
{ {
p = (struct partition_block *)block_buffer; p = (struct partition_block *)block_buffer;
@ -377,4 +378,12 @@ void print_part_amiga (block_dev_desc_t *dev_desc)
} }
} }
U_BOOT_PART_TYPE(amiga) = {
.name = "AMIGA",
.part_type = PART_TYPE_AMIGA,
.get_info = part_get_info_amiga,
.print = part_print_amiga,
.test = part_test_amiga,
};
#endif #endif

66
disk/part_dos.c
View file

@ -87,11 +87,11 @@ static int test_block_type(unsigned char *buffer)
} }
int test_part_dos (block_dev_desc_t *dev_desc) static int part_test_dos(struct blk_desc *dev_desc)
{ {
ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, dev_desc->blksz); 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; return -1;
if (test_block_type(buffer) != DOS_MBR) if (test_block_type(buffer) != DOS_MBR)
@ -102,7 +102,7 @@ int test_part_dos (block_dev_desc_t *dev_desc)
/* Print a partition that is relative to its Extended partition table /* Print a partition that is relative to its Extended partition table
*/ */
static void print_partition_extended(block_dev_desc_t *dev_desc, static void print_partition_extended(struct blk_desc *dev_desc,
lbaint_t ext_part_sector, lbaint_t ext_part_sector,
lbaint_t relative, lbaint_t relative,
int part_num, unsigned int disksig) int part_num, unsigned int disksig)
@ -111,10 +111,9 @@ static void print_partition_extended(block_dev_desc_t *dev_desc,
dos_partition_t *pt; dos_partition_t *pt;
int i; int i;
if (dev_desc->block_read(dev_desc, ext_part_sector, 1, if (blk_dread(dev_desc, ext_part_sector, 1, (ulong *)buffer) != 1) {
(ulong *)buffer) != 1) {
printf ("** Can't read partition table on %d:" LBAFU " **\n", printf ("** Can't read partition table on %d:" LBAFU " **\n",
dev_desc->dev, ext_part_sector); dev_desc->devnum, ext_part_sector);
return; return;
} }
i=test_block_type(buffer); i=test_block_type(buffer);
@ -167,21 +166,19 @@ static void print_partition_extended(block_dev_desc_t *dev_desc,
/* Print a partition that is relative to its Extended partition table /* Print a partition that is relative to its Extended partition table
*/ */
static int get_partition_info_extended (block_dev_desc_t *dev_desc, static int part_get_info_extended(struct blk_desc *dev_desc,
lbaint_t ext_part_sector, lbaint_t ext_part_sector, lbaint_t relative,
lbaint_t relative, int part_num, int part_num, int which_part,
int which_part, disk_partition_t *info, disk_partition_t *info, unsigned int disksig)
unsigned int disksig)
{ {
ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, dev_desc->blksz); ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, dev_desc->blksz);
dos_partition_t *pt; dos_partition_t *pt;
int i; int i;
int dos_type; int dos_type;
if (dev_desc->block_read(dev_desc, ext_part_sector, 1, if (blk_dread(dev_desc, ext_part_sector, 1, (ulong *)buffer) != 1) {
(ulong *)buffer) != 1) {
printf ("** Can't read partition table on %d:" LBAFU " **\n", printf ("** Can't read partition table on %d:" LBAFU " **\n",
dev_desc->dev, ext_part_sector); dev_desc->devnum, ext_part_sector);
return -1; return -1;
} }
if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 || if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 ||
@ -216,24 +213,29 @@ static int get_partition_info_extended (block_dev_desc_t *dev_desc,
case IF_TYPE_IDE: case IF_TYPE_IDE:
case IF_TYPE_SATA: case IF_TYPE_SATA:
case IF_TYPE_ATAPI: case IF_TYPE_ATAPI:
sprintf ((char *)info->name, "hd%c%d", sprintf((char *)info->name, "hd%c%d",
'a' + dev_desc->dev, part_num); 'a' + dev_desc->devnum,
part_num);
break; break;
case IF_TYPE_SCSI: case IF_TYPE_SCSI:
sprintf ((char *)info->name, "sd%c%d", sprintf((char *)info->name, "sd%c%d",
'a' + dev_desc->dev, part_num); 'a' + dev_desc->devnum,
part_num);
break; break;
case IF_TYPE_USB: case IF_TYPE_USB:
sprintf ((char *)info->name, "usbd%c%d", sprintf((char *)info->name, "usbd%c%d",
'a' + dev_desc->dev, part_num); 'a' + dev_desc->devnum,
part_num);
break; break;
case IF_TYPE_DOC: case IF_TYPE_DOC:
sprintf ((char *)info->name, "docd%c%d", sprintf((char *)info->name, "docd%c%d",
'a' + dev_desc->dev, part_num); 'a' + dev_desc->devnum,
part_num);
break; break;
default: default:
sprintf ((char *)info->name, "xx%c%d", sprintf((char *)info->name, "xx%c%d",
'a' + dev_desc->dev, part_num); 'a' + dev_desc->devnum,
part_num);
break; break;
} }
/* sprintf(info->type, "%d, pt->sys_ind); */ /* sprintf(info->type, "%d, pt->sys_ind); */
@ -259,7 +261,7 @@ static int get_partition_info_extended (block_dev_desc_t *dev_desc,
lbaint_t lba_start lbaint_t lba_start
= le32_to_int (pt->start4) + relative; = le32_to_int (pt->start4) + relative;
return get_partition_info_extended (dev_desc, lba_start, return part_get_info_extended(dev_desc, lba_start,
ext_part_sector == 0 ? lba_start : relative, ext_part_sector == 0 ? lba_start : relative,
part_num, which_part, info, disksig); part_num, which_part, info, disksig);
} }
@ -283,16 +285,24 @@ static int get_partition_info_extended (block_dev_desc_t *dev_desc,
return -1; return -1;
} }
void print_part_dos (block_dev_desc_t *dev_desc) void part_print_dos(struct blk_desc *dev_desc)
{ {
printf("Part\tStart Sector\tNum Sectors\tUUID\t\tType\n"); printf("Part\tStart Sector\tNum Sectors\tUUID\t\tType\n");
print_partition_extended(dev_desc, 0, 0, 1, 0); print_partition_extended(dev_desc, 0, 0, 1, 0);
} }
int get_partition_info_dos (block_dev_desc_t *dev_desc, int part, disk_partition_t * info) int part_get_info_dos(struct blk_desc *dev_desc, int part,
disk_partition_t *info)
{ {
return get_partition_info_extended(dev_desc, 0, 0, 1, part, info, 0); return part_get_info_extended(dev_desc, 0, 0, 1, part, info, 0);
} }
U_BOOT_PART_TYPE(dos) = {
.name = "DOS",
.part_type = PART_TYPE_DOS,
.get_info = part_get_info_ptr(part_get_info_dos),
.print = part_print_ptr(part_print_dos),
.test = part_test_dos,
};
#endif #endif

101
disk/part_efi.c
View file

@ -41,10 +41,10 @@ static inline u32 efi_crc32(const void *buf, u32 len)
static int pmbr_part_valid(struct partition *part); static int pmbr_part_valid(struct partition *part);
static int is_pmbr_valid(legacy_mbr * mbr); static int is_pmbr_valid(legacy_mbr * mbr);
static int is_gpt_valid(block_dev_desc_t *dev_desc, u64 lba, static int is_gpt_valid(struct blk_desc *dev_desc, u64 lba,
gpt_header *pgpt_head, gpt_entry **pgpt_pte); gpt_header *pgpt_head, gpt_entry **pgpt_pte);
static gpt_entry *alloc_read_gpt_entries(block_dev_desc_t * dev_desc, static gpt_entry *alloc_read_gpt_entries(struct blk_desc *dev_desc,
gpt_header * pgpt_head); gpt_header *pgpt_head);
static int is_pte_valid(gpt_entry * pte); static int is_pte_valid(gpt_entry * pte);
static char *print_efiname(gpt_entry *pte) static char *print_efiname(gpt_entry *pte)
@ -176,7 +176,7 @@ static void prepare_backup_gpt_header(gpt_header *gpt_h)
* Public Functions (include/part.h) * Public Functions (include/part.h)
*/ */
void print_part_efi(block_dev_desc_t * dev_desc) void part_print_efi(struct blk_desc *dev_desc)
{ {
ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz); ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz);
gpt_entry *gpt_pte = NULL; gpt_entry *gpt_pte = NULL;
@ -237,8 +237,8 @@ void print_part_efi(block_dev_desc_t * dev_desc)
return; return;
} }
int get_partition_info_efi(block_dev_desc_t * dev_desc, int part, int part_get_info_efi(struct blk_desc *dev_desc, int part,
disk_partition_t * info) disk_partition_t *info)
{ {
ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz); ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz);
gpt_entry *gpt_pte = NULL; gpt_entry *gpt_pte = NULL;
@ -300,13 +300,13 @@ int get_partition_info_efi(block_dev_desc_t * dev_desc, int part,
return 0; return 0;
} }
int get_partition_info_efi_by_name(block_dev_desc_t *dev_desc, int part_get_info_efi_by_name(struct blk_desc *dev_desc,
const char *name, disk_partition_t *info) const char *name, disk_partition_t *info)
{ {
int ret; int ret;
int i; int i;
for (i = 1; i < GPT_ENTRY_NUMBERS; i++) { for (i = 1; i < GPT_ENTRY_NUMBERS; i++) {
ret = get_partition_info_efi(dev_desc, i, info); ret = part_get_info_efi(dev_desc, i, info);
if (ret != 0) { if (ret != 0) {
/* no more entries in table */ /* no more entries in table */
return -1; return -1;
@ -319,12 +319,12 @@ int get_partition_info_efi_by_name(block_dev_desc_t *dev_desc,
return -2; return -2;
} }
int test_part_efi(block_dev_desc_t * dev_desc) static int part_test_efi(struct blk_desc *dev_desc)
{ {
ALLOC_CACHE_ALIGN_BUFFER_PAD(legacy_mbr, legacymbr, 1, dev_desc->blksz); ALLOC_CACHE_ALIGN_BUFFER_PAD(legacy_mbr, legacymbr, 1, dev_desc->blksz);
/* Read legacy MBR from block 0 and validate it */ /* 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)) { || (is_pmbr_valid(legacymbr) != 1)) {
return -1; return -1;
} }
@ -337,7 +337,7 @@ int test_part_efi(block_dev_desc_t * dev_desc)
* *
* @return - zero on success, otherwise error * @return - zero on success, otherwise error
*/ */
static int set_protective_mbr(block_dev_desc_t *dev_desc) static int set_protective_mbr(struct blk_desc *dev_desc)
{ {
/* Setup the Protective MBR */ /* Setup the Protective MBR */
ALLOC_CACHE_ALIGN_BUFFER(legacy_mbr, p_mbr, 1); ALLOC_CACHE_ALIGN_BUFFER(legacy_mbr, p_mbr, 1);
@ -354,16 +354,16 @@ static int set_protective_mbr(block_dev_desc_t *dev_desc)
p_mbr->partition_record[0].nr_sects = (u32) dev_desc->lba - 1; p_mbr->partition_record[0].nr_sects = (u32) dev_desc->lba - 1;
/* Write MBR sector to the MMC device */ /* 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", printf("** Can't write to device %d **\n",
dev_desc->dev); dev_desc->devnum);
return -1; return -1;
} }
return 0; return 0;
} }
int write_gpt_table(block_dev_desc_t *dev_desc, int write_gpt_table(struct blk_desc *dev_desc,
gpt_header *gpt_h, gpt_entry *gpt_e) gpt_header *gpt_h, gpt_entry *gpt_e)
{ {
const int pte_blk_cnt = BLOCK_CNT((gpt_h->num_partition_entries const int pte_blk_cnt = BLOCK_CNT((gpt_h->num_partition_entries
@ -386,31 +386,28 @@ int write_gpt_table(block_dev_desc_t *dev_desc,
gpt_h->header_crc32 = cpu_to_le32(calc_crc32); gpt_h->header_crc32 = cpu_to_le32(calc_crc32);
/* Write the First GPT to the block right after the Legacy MBR */ /* 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; 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) != pte_blk_cnt)
goto err; goto err;
prepare_backup_gpt_header(gpt_h); prepare_backup_gpt_header(gpt_h);
if (dev_desc->block_write(dev_desc, if (blk_dwrite(dev_desc, (lbaint_t)le64_to_cpu(gpt_h->last_usable_lba)
(lbaint_t)le64_to_cpu(gpt_h->last_usable_lba) + 1, pte_blk_cnt, gpt_e) != pte_blk_cnt)
+ 1,
pte_blk_cnt, gpt_e) != pte_blk_cnt)
goto err; goto err;
if (dev_desc->block_write(dev_desc, if (blk_dwrite(dev_desc, (lbaint_t)le64_to_cpu(gpt_h->my_lba), 1,
(lbaint_t)le64_to_cpu(gpt_h->my_lba), 1, gpt_h) != 1)
gpt_h) != 1)
goto err; goto err;
debug("GPT successfully written to block device!\n"); debug("GPT successfully written to block device!\n");
return 0; return 0;
err: err:
printf("** Can't write to device %d **\n", dev_desc->dev); printf("** Can't write to device %d **\n", dev_desc->devnum);
return -1; return -1;
} }
@ -517,7 +514,7 @@ int gpt_fill_pte(gpt_header *gpt_h, gpt_entry *gpt_e,
return 0; return 0;
} }
int gpt_fill_header(block_dev_desc_t *dev_desc, gpt_header *gpt_h, int gpt_fill_header(struct blk_desc *dev_desc, gpt_header *gpt_h,
char *str_guid, int parts_count) char *str_guid, int parts_count)
{ {
gpt_h->signature = cpu_to_le64(GPT_HEADER_SIGNATURE); gpt_h->signature = cpu_to_le64(GPT_HEADER_SIGNATURE);
@ -539,7 +536,7 @@ int gpt_fill_header(block_dev_desc_t *dev_desc, gpt_header *gpt_h,
return 0; return 0;
} }
int gpt_restore(block_dev_desc_t *dev_desc, char *str_disk_guid, int gpt_restore(struct blk_desc *dev_desc, char *str_disk_guid,
disk_partition_t *partitions, int parts_count) disk_partition_t *partitions, int parts_count)
{ {
int ret; int ret;
@ -595,7 +592,7 @@ static void gpt_convert_efi_name_to_char(char *s, efi_char16_t *es, int n)
} }
} }
int gpt_verify_headers(block_dev_desc_t *dev_desc, gpt_header *gpt_head, int gpt_verify_headers(struct blk_desc *dev_desc, gpt_header *gpt_head,
gpt_entry **gpt_pte) gpt_entry **gpt_pte)
{ {
/* /*
@ -619,7 +616,7 @@ int gpt_verify_headers(block_dev_desc_t *dev_desc, gpt_header *gpt_head,
return 0; return 0;
} }
int gpt_verify_partitions(block_dev_desc_t *dev_desc, int gpt_verify_partitions(struct blk_desc *dev_desc,
disk_partition_t *partitions, int parts, disk_partition_t *partitions, int parts,
gpt_header *gpt_head, gpt_entry **gpt_pte) gpt_header *gpt_head, gpt_entry **gpt_pte)
{ {
@ -658,11 +655,13 @@ int gpt_verify_partitions(block_dev_desc_t *dev_desc,
gpt_part_size = le64_to_cpu(gpt_e[i].ending_lba) - gpt_part_size = le64_to_cpu(gpt_e[i].ending_lba) -
le64_to_cpu(gpt_e[i].starting_lba) + 1; le64_to_cpu(gpt_e[i].starting_lba) + 1;
debug("size(LBA) - GPT: %8llu, ENV: %8llu ", debug("size(LBA) - GPT: %8llu, ENV: %8llu ",
gpt_part_size, (u64) partitions[i].size); (unsigned long long)gpt_part_size,
(unsigned long long)partitions[i].size);
if (le64_to_cpu(gpt_part_size) != partitions[i].size) { if (le64_to_cpu(gpt_part_size) != partitions[i].size) {
error("Partition %s size: %llu does not match %llu!\n", error("Partition %s size: %llu does not match %llu!\n",
efi_str, gpt_part_size, (u64) partitions[i].size); efi_str, (unsigned long long)gpt_part_size,
(unsigned long long)partitions[i].size);
return -1; return -1;
} }
@ -678,12 +677,12 @@ int gpt_verify_partitions(block_dev_desc_t *dev_desc,
/* Check if GPT and ENV start LBAs match */ /* Check if GPT and ENV start LBAs match */
debug("start LBA - GPT: %8llu, ENV: %8llu\n", debug("start LBA - GPT: %8llu, ENV: %8llu\n",
le64_to_cpu(gpt_e[i].starting_lba), le64_to_cpu(gpt_e[i].starting_lba),
(u64) partitions[i].start); (unsigned long long)partitions[i].start);
if (le64_to_cpu(gpt_e[i].starting_lba) != partitions[i].start) { if (le64_to_cpu(gpt_e[i].starting_lba) != partitions[i].start) {
error("Partition %s start: %llu does not match %llu!\n", error("Partition %s start: %llu does not match %llu!\n",
efi_str, le64_to_cpu(gpt_e[i].starting_lba), efi_str, le64_to_cpu(gpt_e[i].starting_lba),
(u64) partitions[i].start); (unsigned long long)partitions[i].start);
return -1; return -1;
} }
} }
@ -691,7 +690,7 @@ int gpt_verify_partitions(block_dev_desc_t *dev_desc,
return 0; return 0;
} }
int is_valid_gpt_buf(block_dev_desc_t *dev_desc, void *buf) int is_valid_gpt_buf(struct blk_desc *dev_desc, void *buf)
{ {
gpt_header *gpt_h; gpt_header *gpt_h;
gpt_entry *gpt_e; gpt_entry *gpt_e;
@ -712,7 +711,7 @@ int is_valid_gpt_buf(block_dev_desc_t *dev_desc, void *buf)
return 0; return 0;
} }
int write_mbr_and_gpt_partitions(block_dev_desc_t *dev_desc, void *buf) int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf)
{ {
gpt_header *gpt_h; gpt_header *gpt_h;
gpt_entry *gpt_e; gpt_entry *gpt_e;
@ -737,7 +736,7 @@ int write_mbr_and_gpt_partitions(block_dev_desc_t *dev_desc, void *buf)
/* write MBR */ /* write MBR */
lba = 0; /* MBR is always at 0 */ lba = 0; /* MBR is always at 0 */
cnt = 1; /* MBR (1 block) */ 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", printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
__func__, "MBR", cnt, lba); __func__, "MBR", cnt, lba);
return 1; return 1;
@ -746,7 +745,7 @@ int write_mbr_and_gpt_partitions(block_dev_desc_t *dev_desc, void *buf)
/* write Primary GPT */ /* write Primary GPT */
lba = GPT_PRIMARY_PARTITION_TABLE_LBA; lba = GPT_PRIMARY_PARTITION_TABLE_LBA;
cnt = 1; /* GPT Header (1 block) */ 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", printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
__func__, "Primary GPT Header", cnt, lba); __func__, "Primary GPT Header", cnt, lba);
return 1; return 1;
@ -754,7 +753,7 @@ int write_mbr_and_gpt_partitions(block_dev_desc_t *dev_desc, void *buf)
lba = le64_to_cpu(gpt_h->partition_entry_lba); lba = le64_to_cpu(gpt_h->partition_entry_lba);
cnt = gpt_e_blk_cnt; 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", printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
__func__, "Primary GPT Entries", cnt, lba); __func__, "Primary GPT Entries", cnt, lba);
return 1; return 1;
@ -765,7 +764,7 @@ int write_mbr_and_gpt_partitions(block_dev_desc_t *dev_desc, void *buf)
/* write Backup GPT */ /* write Backup GPT */
lba = le64_to_cpu(gpt_h->partition_entry_lba); lba = le64_to_cpu(gpt_h->partition_entry_lba);
cnt = gpt_e_blk_cnt; 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", printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
__func__, "Backup GPT Entries", cnt, lba); __func__, "Backup GPT Entries", cnt, lba);
return 1; return 1;
@ -773,7 +772,7 @@ int write_mbr_and_gpt_partitions(block_dev_desc_t *dev_desc, void *buf)
lba = le64_to_cpu(gpt_h->my_lba); lba = le64_to_cpu(gpt_h->my_lba);
cnt = 1; /* GPT Header (1 block) */ 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", printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
__func__, "Backup GPT Header", cnt, lba); __func__, "Backup GPT Header", cnt, lba);
return 1; return 1;
@ -834,7 +833,7 @@ static int is_pmbr_valid(legacy_mbr * mbr)
* Description: returns 1 if valid, 0 on error. * Description: returns 1 if valid, 0 on error.
* If valid, returns pointers to PTEs. * If valid, returns pointers to PTEs.
*/ */
static int is_gpt_valid(block_dev_desc_t *dev_desc, u64 lba, static int is_gpt_valid(struct blk_desc *dev_desc, u64 lba,
gpt_header *pgpt_head, gpt_entry **pgpt_pte) gpt_header *pgpt_head, gpt_entry **pgpt_pte)
{ {
if (!dev_desc || !pgpt_head) { if (!dev_desc || !pgpt_head) {
@ -843,7 +842,7 @@ static int is_gpt_valid(block_dev_desc_t *dev_desc, u64 lba,
} }
/* Read GPT Header from device */ /* 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"); printf("*** ERROR: Can't read GPT header ***\n");
return 0; return 0;
} }
@ -876,8 +875,8 @@ static int is_gpt_valid(block_dev_desc_t *dev_desc, u64 lba,
* Allocates space for PTEs based on information found in @gpt. * Allocates space for PTEs based on information found in @gpt.
* Notes: remember to free pte when you're done! * Notes: remember to free pte when you're done!
*/ */
static gpt_entry *alloc_read_gpt_entries(block_dev_desc_t * dev_desc, static gpt_entry *alloc_read_gpt_entries(struct blk_desc *dev_desc,
gpt_header * pgpt_head) gpt_header *pgpt_head)
{ {
size_t count = 0, blk_cnt; size_t count = 0, blk_cnt;
lbaint_t blk; lbaint_t blk;
@ -911,8 +910,7 @@ static gpt_entry *alloc_read_gpt_entries(block_dev_desc_t * dev_desc,
/* Read GPT Entries from device */ /* Read GPT Entries from device */
blk = le64_to_cpu(pgpt_head->partition_entry_lba); blk = le64_to_cpu(pgpt_head->partition_entry_lba);
blk_cnt = BLOCK_CNT(count, dev_desc); blk_cnt = BLOCK_CNT(count, dev_desc);
if (dev_desc->block_read(dev_desc, blk, (lbaint_t)blk_cnt, pte) if (blk_dread(dev_desc, blk, (lbaint_t)blk_cnt, pte) != blk_cnt) {
!= blk_cnt) {
printf("*** ERROR: Can't read GPT Entries ***\n"); printf("*** ERROR: Can't read GPT Entries ***\n");
free(pte); free(pte);
return NULL; return NULL;
@ -951,4 +949,17 @@ static int is_pte_valid(gpt_entry * pte)
return 1; return 1;
} }
} }
/*
* Add an 'a_' prefix so it comes before 'dos' in the linker list. We need to
* check EFI first, since a DOS partition is often used as a 'protective MBR'
* with EFI.
*/
U_BOOT_PART_TYPE(a_efi) = {
.name = "EFI",
.part_type = PART_TYPE_EFI,
.get_info = part_get_info_ptr(part_get_info_efi),
.print = part_print_ptr(part_print_efi),
.test = part_test_efi,
};
#endif #endif

72
disk/part_iso.c
View file

@ -46,7 +46,8 @@ static inline unsigned short le16_to_int(unsigned char *le16)
/* only boot records will be listed as valid partitions */ /* only boot records will be listed as valid partitions */
int get_partition_info_iso_verb(block_dev_desc_t * dev_desc, int part_num, disk_partition_t * info, int verb) int part_get_info_iso_verb(struct blk_desc *dev_desc, int part_num,
disk_partition_t *info, int verb)
{ {
int i,offset,entry_num; int i,offset,entry_num;
unsigned short *chksumbuf; unsigned short *chksumbuf;
@ -62,18 +63,18 @@ int get_partition_info_iso_verb(block_dev_desc_t * dev_desc, int part_num, disk_
/* the first sector (sector 0x10) must be a primary volume desc */ /* the first sector (sector 0x10) must be a primary volume desc */
blkaddr=PVD_OFFSET; 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; return -1;
if(ppr->desctype!=0x01) { if(ppr->desctype!=0x01) {
if(verb) if(verb)
printf ("** First descriptor is NOT a primary desc on %d:%d **\n", printf ("** First descriptor is NOT a primary desc on %d:%d **\n",
dev_desc->dev, part_num); dev_desc->devnum, part_num);
return (-1); return (-1);
} }
if(strncmp((char *)ppr->stand_ident,"CD001",5)!=0) { if(strncmp((char *)ppr->stand_ident,"CD001",5)!=0) {
if(verb) if(verb)
printf ("** Wrong ISO Ident: %s on %d:%d **\n", printf ("** Wrong ISO Ident: %s on %d:%d **\n",
ppr->stand_ident,dev_desc->dev, part_num); ppr->stand_ident, dev_desc->devnum, part_num);
return (-1); return (-1);
} }
lastsect= ((ppr->firstsek_LEpathtab1_LE & 0x000000ff)<<24) + lastsect= ((ppr->firstsek_LEpathtab1_LE & 0x000000ff)<<24) +
@ -84,14 +85,14 @@ int get_partition_info_iso_verb(block_dev_desc_t * dev_desc, int part_num, disk_
PRINTF(" Lastsect:%08lx\n",lastsect); PRINTF(" Lastsect:%08lx\n",lastsect);
for(i=blkaddr;i<lastsect;i++) { for(i=blkaddr;i<lastsect;i++) {
PRINTF("Reading block %d\n", 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; return -1;
if(ppr->desctype==0x00) if(ppr->desctype==0x00)
break; /* boot entry found */ break; /* boot entry found */
if(ppr->desctype==0xff) { if(ppr->desctype==0xff) {
if(verb) if(verb)
printf ("** No valid boot catalog found on %d:%d **\n", printf ("** No valid boot catalog found on %d:%d **\n",
dev_desc->dev, part_num); dev_desc->devnum, part_num);
return (-1); return (-1);
} }
} }
@ -99,15 +100,15 @@ int get_partition_info_iso_verb(block_dev_desc_t * dev_desc, int part_num, disk_
if(strncmp(pbr->ident_str,"EL TORITO SPECIFICATION",23)!=0) { if(strncmp(pbr->ident_str,"EL TORITO SPECIFICATION",23)!=0) {
if(verb) if(verb)
printf ("** Wrong El Torito ident: %s on %d:%d **\n", printf ("** Wrong El Torito ident: %s on %d:%d **\n",
pbr->ident_str,dev_desc->dev, part_num); pbr->ident_str, dev_desc->devnum, part_num);
return (-1); return (-1);
} }
bootaddr=le32_to_int(pbr->pointer); bootaddr=le32_to_int(pbr->pointer);
PRINTF(" Boot Entry at: %08lX\n",bootaddr); 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) if(verb)
printf ("** Can't read Boot Entry at %lX on %d:%d **\n", printf ("** Can't read Boot Entry at %lX on %d:%d **\n",
bootaddr,dev_desc->dev, part_num); bootaddr, dev_desc->devnum, part_num);
return (-1); return (-1);
} }
chksum=0; chksum=0;
@ -116,21 +117,21 @@ int get_partition_info_iso_verb(block_dev_desc_t * dev_desc, int part_num, disk_
chksum+=((chksumbuf[i] &0xff)<<8)+((chksumbuf[i] &0xff00)>>8); chksum+=((chksumbuf[i] &0xff)<<8)+((chksumbuf[i] &0xff00)>>8);
if(chksum!=0) { if(chksum!=0) {
if(verb) if(verb)
printf ("** Checksum Error in booting catalog validation entry on %d:%d **\n", printf("** Checksum Error in booting catalog validation entry on %d:%d **\n",
dev_desc->dev, part_num); dev_desc->devnum, part_num);
return (-1); return (-1);
} }
if((pve->key[0]!=0x55)||(pve->key[1]!=0xAA)) { if((pve->key[0]!=0x55)||(pve->key[1]!=0xAA)) {
if(verb) if(verb)
printf ("** Key 0x55 0xAA error on %d:%d **\n", printf ("** Key 0x55 0xAA error on %d:%d **\n",
dev_desc->dev, part_num); dev_desc->devnum, part_num);
return(-1); return(-1);
} }
#ifdef CHECK_FOR_POWERPC_PLATTFORM #ifdef CHECK_FOR_POWERPC_PLATTFORM
if(pve->platform!=0x01) { if(pve->platform!=0x01) {
if(verb) if(verb)
printf ("** No PowerPC platform CD on %d:%d **\n", printf ("** No PowerPC platform CD on %d:%d **\n",
dev_desc->dev, part_num); dev_desc->devnum, part_num);
return(-1); return(-1);
} }
#endif #endif
@ -143,23 +144,23 @@ int get_partition_info_iso_verb(block_dev_desc_t * dev_desc, int part_num, disk_
case IF_TYPE_SATA: case IF_TYPE_SATA:
case IF_TYPE_ATAPI: case IF_TYPE_ATAPI:
sprintf ((char *)info->name, "hd%c%d", sprintf ((char *)info->name, "hd%c%d",
'a' + dev_desc->dev, part_num); 'a' + dev_desc->devnum, part_num);
break; break;
case IF_TYPE_SCSI: case IF_TYPE_SCSI:
sprintf ((char *)info->name, "sd%c%d", sprintf ((char *)info->name, "sd%c%d",
'a' + dev_desc->dev, part_num); 'a' + dev_desc->devnum, part_num);
break; break;
case IF_TYPE_USB: case IF_TYPE_USB:
sprintf ((char *)info->name, "usbd%c%d", sprintf ((char *)info->name, "usbd%c%d",
'a' + dev_desc->dev, part_num); 'a' + dev_desc->devnum, part_num);
break; break;
case IF_TYPE_DOC: case IF_TYPE_DOC:
sprintf ((char *)info->name, "docd%c%d", sprintf ((char *)info->name, "docd%c%d",
'a' + dev_desc->dev, part_num); 'a' + dev_desc->devnum, part_num);
break; break;
default: default:
sprintf ((char *)info->name, "xx%c%d", sprintf ((char *)info->name, "xx%c%d",
'a' + dev_desc->dev, part_num); 'a' + dev_desc->devnum, part_num);
break; break;
} }
/* the bootcatalog (including validation Entry) is limited to 2048Bytes /* the bootcatalog (including validation Entry) is limited to 2048Bytes
@ -183,7 +184,7 @@ int get_partition_info_iso_verb(block_dev_desc_t * dev_desc, int part_num, disk_
else { else {
if(verb) if(verb)
printf ("** Partition %d not found on device %d **\n", printf ("** Partition %d not found on device %d **\n",
part_num,dev_desc->dev); part_num, dev_desc->devnum);
return(-1); return(-1);
} }
} }
@ -191,13 +192,13 @@ int get_partition_info_iso_verb(block_dev_desc_t * dev_desc, int part_num, disk_
* searched w/o succsess */ * searched w/o succsess */
if(verb) if(verb)
printf ("** Partition %d not found on device %d **\n", printf ("** Partition %d not found on device %d **\n",
part_num,dev_desc->dev); part_num, dev_desc->devnum);
return(-1); return(-1);
found: found:
if(pide->boot_ind!=0x88) { if(pide->boot_ind!=0x88) {
if(verb) if(verb)
printf ("** Partition %d is not bootable on device %d **\n", printf("** Partition %d is not bootable on device %d **\n",
part_num,dev_desc->dev); part_num, dev_desc->devnum);
return (-1); return (-1);
} }
switch(pide->boot_media) { switch(pide->boot_media) {
@ -216,18 +217,20 @@ found:
return 0; return 0;
} }
int get_partition_info_iso(block_dev_desc_t * dev_desc, int part_num, disk_partition_t * info) static int part_get_info_iso(struct blk_desc *dev_desc, int part_num,
disk_partition_t *info)
{ {
return(get_partition_info_iso_verb(dev_desc, part_num, info, 1)); return part_get_info_iso_verb(dev_desc, part_num, info, 1);
} }
static void part_print_iso(struct blk_desc *dev_desc)
void print_part_iso(block_dev_desc_t * dev_desc)
{ {
disk_partition_t info; disk_partition_t info;
int i; int i;
if(get_partition_info_iso_verb(dev_desc,0,&info,0)==-1) {
printf("** No boot partition found on device %d **\n",dev_desc->dev); if (part_get_info_iso_verb(dev_desc, 0, &info, 0) == -1) {
printf("** No boot partition found on device %d **\n",
dev_desc->devnum);
return; return;
} }
printf("Part Start Sect x Size Type\n"); printf("Part Start Sect x Size Type\n");
@ -236,14 +239,21 @@ void print_part_iso(block_dev_desc_t * dev_desc)
printf(" %2d " LBAFU " " LBAFU " %6ld %.32s\n", printf(" %2d " LBAFU " " LBAFU " %6ld %.32s\n",
i, info.start, info.size, info.blksz, info.type); i, info.start, info.size, info.blksz, info.type);
i++; i++;
} while (get_partition_info_iso_verb(dev_desc,i,&info,0)!=-1); } while (part_get_info_iso_verb(dev_desc, i, &info, 0) != -1);
} }
int test_part_iso (block_dev_desc_t *dev_desc) static int part_test_iso(struct blk_desc *dev_desc)
{ {
disk_partition_t info; disk_partition_t info;
return(get_partition_info_iso_verb(dev_desc,0,&info,0)); return part_get_info_iso_verb(dev_desc, 0, &info, 0);
} }
U_BOOT_PART_TYPE(iso) = {
.name = "ISO",
.part_type = PART_TYPE_ISO,
.get_info = part_get_info_iso,
.print = part_print_iso,
.test = part_test_iso,
};
#endif #endif

58
disk/part_mac.c
View file

@ -32,13 +32,15 @@ extern ldiv_t ldiv (long int __numer, long int __denom);
#endif #endif
static int part_mac_read_ddb (block_dev_desc_t *dev_desc, mac_driver_desc_t *ddb_p); static int part_mac_read_ddb(struct blk_desc *dev_desc,
static int part_mac_read_pdb (block_dev_desc_t *dev_desc, int part, mac_partition_t *pdb_p); mac_driver_desc_t *ddb_p);
static int part_mac_read_pdb(struct blk_desc *dev_desc, int part,
mac_partition_t *pdb_p);
/* /*
* Test for a valid MAC partition * Test for a valid MAC partition
*/ */
int test_part_mac (block_dev_desc_t *dev_desc) static int part_test_mac(struct blk_desc *dev_desc)
{ {
ALLOC_CACHE_ALIGN_BUFFER(mac_driver_desc_t, ddesc, 1); ALLOC_CACHE_ALIGN_BUFFER(mac_driver_desc_t, ddesc, 1);
ALLOC_CACHE_ALIGN_BUFFER(mac_partition_t, mpart, 1); ALLOC_CACHE_ALIGN_BUFFER(mac_partition_t, mpart, 1);
@ -51,8 +53,7 @@ int test_part_mac (block_dev_desc_t *dev_desc)
n = 1; /* assuming at least one partition */ n = 1; /* assuming at least one partition */
for (i=1; i<=n; ++i) { for (i=1; i<=n; ++i) {
if ((dev_desc->block_read(dev_desc, i, 1, if ((blk_dread(dev_desc, i, 1, (ulong *)mpart) != 1) ||
(ulong *)mpart) != 1) ||
(mpart->signature != MAC_PARTITION_MAGIC) ) { (mpart->signature != MAC_PARTITION_MAGIC) ) {
return (-1); return (-1);
} }
@ -62,8 +63,7 @@ int test_part_mac (block_dev_desc_t *dev_desc)
return (0); return (0);
} }
static void part_print_mac(struct blk_desc *dev_desc)
void print_part_mac (block_dev_desc_t *dev_desc)
{ {
ulong i, n; ulong i, n;
ALLOC_CACHE_ALIGN_BUFFER(mac_driver_desc_t, ddesc, 1); ALLOC_CACHE_ALIGN_BUFFER(mac_driver_desc_t, ddesc, 1);
@ -105,16 +105,16 @@ void print_part_mac (block_dev_desc_t *dev_desc)
char c; char c;
printf ("%4ld: ", i); 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", printf ("** Can't read Partition Map on %d:%ld **\n",
dev_desc->dev, i); dev_desc->devnum, i);
return; return;
} }
if (mpart->signature != MAC_PARTITION_MAGIC) { if (mpart->signature != MAC_PARTITION_MAGIC) {
printf ("** Bad Signature on %d:%ld - " printf("** Bad Signature on %d:%ld - expected 0x%04x, got 0x%04x\n",
"expected 0x%04x, got 0x%04x\n", dev_desc->devnum, i, MAC_PARTITION_MAGIC,
dev_desc->dev, i, MAC_PARTITION_MAGIC, mpart->signature); mpart->signature);
return; return;
} }
@ -149,9 +149,10 @@ void print_part_mac (block_dev_desc_t *dev_desc)
/* /*
* Read Device Descriptor Block * Read Device Descriptor Block
*/ */
static int part_mac_read_ddb (block_dev_desc_t *dev_desc, mac_driver_desc_t *ddb_p) 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"); printf ("** Can't read Driver Desriptor Block **\n");
return (-1); return (-1);
} }
@ -169,7 +170,8 @@ static int part_mac_read_ddb (block_dev_desc_t *dev_desc, mac_driver_desc_t *ddb
/* /*
* Read Partition Descriptor Block * Read Partition Descriptor Block
*/ */
static int part_mac_read_pdb (block_dev_desc_t *dev_desc, int part, mac_partition_t *pdb_p) static int part_mac_read_pdb(struct blk_desc *dev_desc, int part,
mac_partition_t *pdb_p)
{ {
int n = 1; int n = 1;
@ -179,16 +181,16 @@ static int part_mac_read_pdb (block_dev_desc_t *dev_desc, int part, mac_partitio
* partition 1 first since this is the only way to * partition 1 first since this is the only way to
* know how many partitions we have. * 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", printf ("** Can't read Partition Map on %d:%d **\n",
dev_desc->dev, n); dev_desc->devnum, n);
return (-1); return (-1);
} }
if (pdb_p->signature != MAC_PARTITION_MAGIC) { if (pdb_p->signature != MAC_PARTITION_MAGIC) {
printf ("** Bad Signature on %d:%d: " printf("** Bad Signature on %d:%d: expected 0x%04x, got 0x%04x\n",
"expected 0x%04x, got 0x%04x\n", dev_desc->devnum, n, MAC_PARTITION_MAGIC,
dev_desc->dev, n, MAC_PARTITION_MAGIC, pdb_p->signature); pdb_p->signature);
return (-1); return (-1);
} }
@ -197,9 +199,9 @@ static int part_mac_read_pdb (block_dev_desc_t *dev_desc, int part, mac_partitio
if ((part < 1) || (part > pdb_p->map_count)) { if ((part < 1) || (part > pdb_p->map_count)) {
printf ("** Invalid partition %d:%d [%d:1...%d:%d only]\n", printf ("** Invalid partition %d:%d [%d:1...%d:%d only]\n",
dev_desc->dev, part, dev_desc->devnum, part,
dev_desc->dev, dev_desc->devnum,
dev_desc->dev, pdb_p->map_count); dev_desc->devnum, pdb_p->map_count);
return (-1); return (-1);
} }
@ -210,7 +212,8 @@ static int part_mac_read_pdb (block_dev_desc_t *dev_desc, int part, mac_partitio
/* NOTREACHED */ /* NOTREACHED */
} }
int get_partition_info_mac (block_dev_desc_t *dev_desc, int part, disk_partition_t *info) static int part_get_info_mac(struct blk_desc *dev_desc, int part,
disk_partition_t *info)
{ {
ALLOC_CACHE_ALIGN_BUFFER(mac_driver_desc_t, ddesc, 1); ALLOC_CACHE_ALIGN_BUFFER(mac_driver_desc_t, ddesc, 1);
ALLOC_CACHE_ALIGN_BUFFER(mac_partition_t, mpart, 1); ALLOC_CACHE_ALIGN_BUFFER(mac_partition_t, mpart, 1);
@ -233,4 +236,11 @@ int get_partition_info_mac (block_dev_desc_t *dev_desc, int part, disk_partition
return (0); return (0);
} }
U_BOOT_PART_TYPE(mac) = {
.name = "MAC",
.part_type = PART_TYPE_MAC,
.get_info = part_get_info_mac,
.print = part_print_mac,
.test = part_test_mac,
};
#endif #endif

11
drivers/block/Kconfig
View file

@ -1,3 +1,14 @@
config BLK
bool "Support block devices"
depends on DM
help
Enable support for block devices, such as SCSI, MMC and USB
flash sticks. These provide a block-level interface which permits
reading, writing and (in some cases) erasing blocks. Block
devices often have a partition table which allows the device to
be partitioned into several areas, called 'partitions' in U-Boot.
A filesystem can be placed in each partition.
config DISK config DISK
bool "Support disk controllers with driver model" bool "Support disk controllers with driver model"
depends on DM depends on DM

2
drivers/block/Makefile
View file

@ -5,6 +5,8 @@
# SPDX-License-Identifier: GPL-2.0+ # SPDX-License-Identifier: GPL-2.0+
# #
obj-$(CONFIG_BLK) += blk-uclass.o
obj-$(CONFIG_DISK) += disk-uclass.o obj-$(CONFIG_DISK) += disk-uclass.o
obj-$(CONFIG_SCSI_AHCI) += ahci.o obj-$(CONFIG_SCSI_AHCI) += ahci.o
obj-$(CONFIG_DWC_AHSATA) += dwc_ahsata.o obj-$(CONFIG_DWC_AHSATA) += dwc_ahsata.o

175
drivers/block/blk-uclass.c Normal file
View file

@ -0,0 +1,175 @@
/*
* Copyright (C) 2016 Google, Inc
* Written by Simon Glass <sjg@chromium.org>
*
* SPDX-License-Identifier: GPL-2.0+
*/
#include <common.h>
#include <blk.h>
#include <dm.h>
#include <dm/device-internal.h>
#include <dm/lists.h>
int blk_first_device(int if_type, struct udevice **devp)
{
struct blk_desc *desc;
int ret;
ret = uclass_first_device(UCLASS_BLK, devp);
if (ret)
return ret;
if (!*devp)
return -ENODEV;
do {
desc = dev_get_uclass_platdata(*devp);
if (desc->if_type == if_type)
return 0;
ret = uclass_next_device(devp);
if (ret)
return ret;
} while (*devp);
return -ENODEV;
}
int blk_next_device(struct udevice **devp)
{
struct blk_desc *desc;
int ret, if_type;
desc = dev_get_uclass_platdata(*devp);
if_type = desc->if_type;
do {
ret = uclass_next_device(devp);
if (ret)
return ret;
if (!*devp)
return -ENODEV;
desc = dev_get_uclass_platdata(*devp);
if (desc->if_type == if_type)
return 0;
} while (1);
}
int blk_get_device(int if_type, int devnum, struct udevice **devp)
{
struct uclass *uc;
struct udevice *dev;
int ret;
ret = uclass_get(UCLASS_BLK, &uc);
if (ret)
return ret;
uclass_foreach_dev(dev, uc) {
struct blk_desc *desc = dev_get_uclass_platdata(dev);
debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
if_type, devnum, dev->name, desc->if_type, desc->devnum);
if (desc->if_type == if_type && desc->devnum == devnum) {
*devp = dev;
return device_probe(dev);
}
}
return -ENODEV;
}
unsigned long blk_dread(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt, void *buffer)
{
struct udevice *dev = block_dev->bdev;
const struct blk_ops *ops = blk_get_ops(dev);
if (!ops->read)
return -ENOSYS;
return ops->read(dev, start, blkcnt, buffer);
}
unsigned long blk_dwrite(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt, const void *buffer)
{
struct udevice *dev = block_dev->bdev;
const struct blk_ops *ops = blk_get_ops(dev);
if (!ops->write)
return -ENOSYS;
return ops->write(dev, start, blkcnt, buffer);
}
unsigned long blk_derase(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt)
{
struct udevice *dev = block_dev->bdev;
const struct blk_ops *ops = blk_get_ops(dev);
if (!ops->erase)
return -ENOSYS;
return ops->erase(dev, start, blkcnt);
}
int blk_prepare_device(struct udevice *dev)
{
struct blk_desc *desc = dev_get_uclass_platdata(dev);
part_init(desc);
return 0;
}
int blk_create_device(struct udevice *parent, const char *drv_name,
const char *name, int if_type, int devnum, int blksz,
lbaint_t size, struct udevice **devp)
{
struct blk_desc *desc;
struct udevice *dev;
int ret;
ret = device_bind_driver(parent, drv_name, name, &dev);
if (ret)
return ret;
desc = dev_get_uclass_platdata(dev);
desc->if_type = if_type;
desc->blksz = blksz;
desc->lba = size / blksz;
desc->part_type = PART_TYPE_UNKNOWN;
desc->bdev = dev;
desc->devnum = devnum;
*devp = dev;
return 0;
}
int blk_unbind_all(int if_type)
{
struct uclass *uc;
struct udevice *dev, *next;
int ret;
ret = uclass_get(UCLASS_BLK, &uc);
if (ret)
return ret;
uclass_foreach_dev_safe(dev, next, uc) {
struct blk_desc *desc = dev_get_uclass_platdata(dev);
if (desc->if_type == if_type) {
ret = device_remove(dev);
if (ret)
return ret;
ret = device_unbind(dev);
if (ret)
return ret;
}
}
return 0;
}
UCLASS_DRIVER(blk) = {
.id = UCLASS_BLK,
.name = "blk",
.per_device_platdata_auto_alloc_size = sizeof(struct blk_desc),
};

4
drivers/block/dwc_ahsata.c
View file

@ -620,7 +620,7 @@ int reset_sata(int dev)
static void dwc_ahsata_print_info(int dev) static void dwc_ahsata_print_info(int dev)
{ {
block_dev_desc_t *pdev = &(sata_dev_desc[dev]); struct blk_desc *pdev = &(sata_dev_desc[dev]);
printf("SATA Device Info:\n\r"); printf("SATA Device Info:\n\r");
#ifdef CONFIG_SYS_64BIT_LBA #ifdef CONFIG_SYS_64BIT_LBA
@ -956,7 +956,7 @@ int scan_sata(int dev)
struct ahci_probe_ent *probe_ent = struct ahci_probe_ent *probe_ent =
(struct ahci_probe_ent *)sata_dev_desc[dev].priv; (struct ahci_probe_ent *)sata_dev_desc[dev].priv;
u8 port = probe_ent->hard_port_no; u8 port = probe_ent->hard_port_no;
block_dev_desc_t *pdev = &(sata_dev_desc[dev]); struct blk_desc *pdev = &(sata_dev_desc[dev]);
id = (u16 *)memalign(ARCH_DMA_MINALIGN, id = (u16 *)memalign(ARCH_DMA_MINALIGN,
roundup(ARCH_DMA_MINALIGN, roundup(ARCH_DMA_MINALIGN,

2
drivers/block/pata_bfin.c
View file

@ -965,7 +965,7 @@ int scan_sata(int dev)
/* Probe device and set xfer mode */ /* Probe device and set xfer mode */
bfin_ata_identify(ap, dev%PATA_DEV_NUM_PER_PORT); bfin_ata_identify(ap, dev%PATA_DEV_NUM_PER_PORT);
bfin_ata_set_Feature_cmd(ap, dev%PATA_DEV_NUM_PER_PORT); bfin_ata_set_Feature_cmd(ap, dev%PATA_DEV_NUM_PER_PORT);
init_part(&sata_dev_desc[dev]); part_init(&sata_dev_desc[dev]);
return 0; return 0;
} }

166
drivers/block/sandbox.c
View file

@ -4,14 +4,20 @@
* SPDX-License-Identifier: GPL-2.0+ * SPDX-License-Identifier: GPL-2.0+
*/ */
#include <config.h>
#include <common.h> #include <common.h>
#include <blk.h>
#include <dm.h>
#include <fdtdec.h>
#include <part.h> #include <part.h>
#include <os.h> #include <os.h>
#include <malloc.h> #include <malloc.h>
#include <sandboxblockdev.h> #include <sandboxblockdev.h>
#include <asm/errno.h> #include <asm/errno.h>
#include <dm/device-internal.h>
DECLARE_GLOBAL_DATA_PTR;
#ifndef CONFIG_BLK
static struct host_block_dev host_devices[CONFIG_HOST_MAX_DEVICES]; static struct host_block_dev host_devices[CONFIG_HOST_MAX_DEVICES];
static struct host_block_dev *find_host_device(int dev) static struct host_block_dev *find_host_device(int dev)
@ -21,48 +27,130 @@ static struct host_block_dev *find_host_device(int dev)
return NULL; return NULL;
} }
#endif
static unsigned long host_block_read(block_dev_desc_t *block_dev, #ifdef CONFIG_BLK
static unsigned long host_block_read(struct udevice *dev,
unsigned long start, lbaint_t blkcnt, unsigned long start, lbaint_t blkcnt,
void *buffer) void *buffer)
{ {
int dev = block_dev->dev; struct host_block_dev *host_dev = dev_get_priv(dev);
struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
#else
static unsigned long host_block_read(struct blk_desc *block_dev,
unsigned long start, lbaint_t blkcnt,
void *buffer)
{
int dev = block_dev->devnum;
struct host_block_dev *host_dev = find_host_device(dev); struct host_block_dev *host_dev = find_host_device(dev);
if (!host_dev) if (!host_dev)
return -1; return -1;
if (os_lseek(host_dev->fd, #endif
start * host_dev->blk_dev.blksz,
OS_SEEK_SET) == -1) { if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
printf("ERROR: Invalid position\n"); -1) {
printf("ERROR: Invalid block %lx\n", start);
return -1; return -1;
} }
ssize_t len = os_read(host_dev->fd, buffer, ssize_t len = os_read(host_dev->fd, buffer, blkcnt * block_dev->blksz);
blkcnt * host_dev->blk_dev.blksz);
if (len >= 0) if (len >= 0)
return len / host_dev->blk_dev.blksz; return len / block_dev->blksz;
return -1; return -1;
} }
static unsigned long host_block_write(block_dev_desc_t *block_dev, #ifdef CONFIG_BLK
static unsigned long host_block_write(struct udevice *dev,
unsigned long start, lbaint_t blkcnt, unsigned long start, lbaint_t blkcnt,
const void *buffer) const void *buffer)
{ {
int dev = block_dev->dev; struct host_block_dev *host_dev = dev_get_priv(dev);
struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
#else
static unsigned long host_block_write(struct blk_desc *block_dev,
unsigned long start, lbaint_t blkcnt,
const void *buffer)
{
int dev = block_dev->devnum;
struct host_block_dev *host_dev = find_host_device(dev); struct host_block_dev *host_dev = find_host_device(dev);
if (os_lseek(host_dev->fd, #endif
start * host_dev->blk_dev.blksz,
OS_SEEK_SET) == -1) { if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
printf("ERROR: Invalid position\n"); -1) {
printf("ERROR: Invalid block %lx\n", start);
return -1; return -1;
} }
ssize_t len = os_write(host_dev->fd, buffer, blkcnt * ssize_t len = os_write(host_dev->fd, buffer, blkcnt * block_dev->blksz);
host_dev->blk_dev.blksz);
if (len >= 0) if (len >= 0)
return len / host_dev->blk_dev.blksz; return len / block_dev->blksz;
return -1; return -1;
} }
#ifdef CONFIG_BLK
int host_dev_bind(int devnum, char *filename)
{
struct host_block_dev *host_dev;
struct udevice *dev;
char dev_name[20], *str, *fname;
int ret, fd;
/* Remove and unbind the old device, if any */
ret = blk_get_device(IF_TYPE_HOST, devnum, &dev);
if (ret == 0) {
ret = device_remove(dev);
if (ret)
return ret;
ret = device_unbind(dev);
if (ret)
return ret;
} else if (ret != -ENODEV) {
return ret;
}
if (!filename)
return 0;
snprintf(dev_name, sizeof(dev_name), "host%d", devnum);
str = strdup(dev_name);
if (!str)
return -ENOMEM;
fname = strdup(filename);
if (!fname) {
free(str);
return -ENOMEM;
}
fd = os_open(filename, OS_O_RDWR);
if (fd == -1) {
printf("Failed to access host backing file '%s'\n", filename);
ret = -ENOENT;
goto err;
}
ret = blk_create_device(gd->dm_root, "sandbox_host_blk", str,
IF_TYPE_HOST, devnum, 512,
os_lseek(fd, 0, OS_SEEK_END), &dev);
if (ret)
goto err_file;
ret = device_probe(dev);
if (ret) {
device_unbind(dev);
goto err_file;
}
host_dev = dev_get_priv(dev);
host_dev->fd = fd;
host_dev->filename = fname;
return blk_prepare_device(dev);
err_file:
os_close(fd);
err:
free(fname);
free(str);
return ret;
}
#else
int host_dev_bind(int dev, char *filename) int host_dev_bind(int dev, char *filename)
{ {
struct host_block_dev *host_dev = find_host_device(dev); struct host_block_dev *host_dev = find_host_device(dev);
@ -89,23 +177,33 @@ int host_dev_bind(int dev, char *filename)
return 1; return 1;
} }
block_dev_desc_t *blk_dev = &host_dev->blk_dev; struct blk_desc *blk_dev = &host_dev->blk_dev;
blk_dev->if_type = IF_TYPE_HOST; blk_dev->if_type = IF_TYPE_HOST;
blk_dev->priv = host_dev; blk_dev->priv = host_dev;
blk_dev->blksz = 512; blk_dev->blksz = 512;
blk_dev->lba = os_lseek(host_dev->fd, 0, OS_SEEK_END) / blk_dev->blksz; blk_dev->lba = os_lseek(host_dev->fd, 0, OS_SEEK_END) / blk_dev->blksz;
blk_dev->block_read = host_block_read; blk_dev->block_read = host_block_read;
blk_dev->block_write = host_block_write; blk_dev->block_write = host_block_write;
blk_dev->dev = dev; blk_dev->devnum = dev;
blk_dev->part_type = PART_TYPE_UNKNOWN; blk_dev->part_type = PART_TYPE_UNKNOWN;
init_part(blk_dev); part_init(blk_dev);
return 0; return 0;
} }
#endif
int host_get_dev_err(int dev, block_dev_desc_t **blk_devp) int host_get_dev_err(int devnum, struct blk_desc **blk_devp)
{ {
struct host_block_dev *host_dev = find_host_device(dev); #ifdef CONFIG_BLK
struct udevice *dev;
int ret;
ret = blk_get_device(IF_TYPE_HOST, devnum, &dev);
if (ret)
return ret;
*blk_devp = dev_get_uclass_platdata(dev);
#else
struct host_block_dev *host_dev = find_host_device(devnum);
if (!host_dev) if (!host_dev)
return -ENODEV; return -ENODEV;
@ -114,15 +212,31 @@ int host_get_dev_err(int dev, block_dev_desc_t **blk_devp)
return -ENOENT; return -ENOENT;
*blk_devp = &host_dev->blk_dev; *blk_devp = &host_dev->blk_dev;
#endif
return 0; return 0;
} }
block_dev_desc_t *host_get_dev(int dev) struct blk_desc *host_get_dev(int dev)
{ {
block_dev_desc_t *blk_dev; struct blk_desc *blk_dev;
if (host_get_dev_err(dev, &blk_dev)) if (host_get_dev_err(dev, &blk_dev))
return NULL; return NULL;
return blk_dev; return blk_dev;
} }
#ifdef CONFIG_BLK
static const struct blk_ops sandbox_host_blk_ops = {
.read = host_block_read,
.write = host_block_write,
};
U_BOOT_DRIVER(sandbox_host_blk) = {
.name = "sandbox_host_blk",
.id = UCLASS_BLK,
.ops = &sandbox_host_blk_ops,
.priv_auto_alloc_size = sizeof(struct host_block_dev),
};
#endif

12
drivers/block/systemace.c
View file

@ -69,11 +69,11 @@ static u16 ace_readw(unsigned off)
return in16(base + off); return in16(base + off);
} }
static unsigned long systemace_read(block_dev_desc_t *block_dev, static unsigned long systemace_read(struct blk_desc *block_dev,
unsigned long start, lbaint_t blkcnt, unsigned long start, lbaint_t blkcnt,
void *buffer); void *buffer);
static block_dev_desc_t systemace_dev = { 0 }; static struct blk_desc systemace_dev = { 0 };
static int get_cf_lock(void) static int get_cf_lock(void)
{ {
@ -105,13 +105,13 @@ static void release_cf_lock(void)
} }
#ifdef CONFIG_PARTITIONS #ifdef CONFIG_PARTITIONS
block_dev_desc_t *systemace_get_dev(int dev) struct blk_desc *systemace_get_dev(int dev)
{ {
/* The first time through this, the systemace_dev object is /* The first time through this, the systemace_dev object is
not yet initialized. In that case, fill it in. */ not yet initialized. In that case, fill it in. */
if (systemace_dev.blksz == 0) { if (systemace_dev.blksz == 0) {
systemace_dev.if_type = IF_TYPE_UNKNOWN; systemace_dev.if_type = IF_TYPE_UNKNOWN;
systemace_dev.dev = 0; systemace_dev.devnum = 0;
systemace_dev.part_type = PART_TYPE_UNKNOWN; systemace_dev.part_type = PART_TYPE_UNKNOWN;
systemace_dev.type = DEV_TYPE_HARDDISK; systemace_dev.type = DEV_TYPE_HARDDISK;
systemace_dev.blksz = 512; systemace_dev.blksz = 512;
@ -124,7 +124,7 @@ block_dev_desc_t *systemace_get_dev(int dev)
*/ */
ace_writew(width == 8 ? 0 : 0x0001, 0); ace_writew(width == 8 ? 0 : 0x0001, 0);
init_part(&systemace_dev); part_init(&systemace_dev);
} }
@ -137,7 +137,7 @@ block_dev_desc_t *systemace_get_dev(int dev)
* the dev_desc) to read blocks of data. The return value is the * the dev_desc) to read blocks of data. The return value is the
* number of blocks read. A zero return indicates an error. * number of blocks read. A zero return indicates an error.
*/ */
static unsigned long systemace_read(block_dev_desc_t *block_dev, static unsigned long systemace_read(struct blk_desc *block_dev,
unsigned long start, lbaint_t blkcnt, unsigned long start, lbaint_t blkcnt,
void *buffer) void *buffer)
{ {

1
drivers/core/simple-bus.c
View file

@ -53,6 +53,7 @@ UCLASS_DRIVER(simple_bus) = {
static const struct udevice_id generic_simple_bus_ids[] = { static const struct udevice_id generic_simple_bus_ids[] = {
{ .compatible = "simple-bus" }, { .compatible = "simple-bus" },
{ .compatible = "simple-mfd" },
{ } { }
}; };

13
drivers/core/uclass.c
View file

@ -401,6 +401,19 @@ int uclass_first_device(enum uclass_id id, struct udevice **devp)
return uclass_get_device_tail(dev, ret, devp); return uclass_get_device_tail(dev, ret, devp);
} }
int uclass_first_device_err(enum uclass_id id, struct udevice **devp)
{
int ret;
ret = uclass_first_device(id, devp);
if (ret)
return ret;
else if (!*devp)
return -ENODEV;
return 0;
}
int uclass_next_device(struct udevice **devp) int uclass_next_device(struct udevice **devp)
{ {
struct udevice *dev = *devp; struct udevice *dev = *devp;

4
drivers/dfu/dfu_mmc.c
View file

@ -351,11 +351,11 @@ int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s)
} else if (!strcmp(entity_type, "part")) { } else if (!strcmp(entity_type, "part")) {
disk_partition_t partinfo; disk_partition_t partinfo;
block_dev_desc_t *blk_dev = &mmc->block_dev; struct blk_desc *blk_dev = &mmc->block_dev;
int mmcdev = second_arg; int mmcdev = second_arg;
int mmcpart = third_arg; int mmcpart = third_arg;
if (get_partition_info(blk_dev, mmcpart, &partinfo) != 0) { if (part_get_info(blk_dev, mmcpart, &partinfo) != 0) {
error("Couldn't find part #%d on mmc device #%d\n", error("Couldn't find part #%d on mmc device #%d\n",
mmcpart, mmcdev); mmcpart, mmcdev);
return -ENODEV; return -ENODEV;

4
drivers/gpio/rk_gpio.c
View file

@ -116,11 +116,9 @@ static int rockchip_gpio_probe(struct udevice *dev)
/* This only supports RK3288 at present */ /* This only supports RK3288 at present */
priv->regs = (struct rockchip_gpio_regs *)dev_get_addr(dev); priv->regs = (struct rockchip_gpio_regs *)dev_get_addr(dev);
ret = uclass_first_device(UCLASS_PINCTRL, &priv->pinctrl); ret = uclass_first_device_err(UCLASS_PINCTRL, &priv->pinctrl);
if (ret) if (ret)
return ret; return ret;
if (!priv->pinctrl)
return -ENODEV;
uc_priv->gpio_count = ROCKCHIP_GPIOS_PER_BANK; uc_priv->gpio_count = ROCKCHIP_GPIOS_PER_BANK;
end = strrchr(dev->name, '@'); end = strrchr(dev->name, '@');

4
drivers/misc/altera_sysid.c
View file

@ -32,11 +32,9 @@ void display_sysid(void)
int ret; int ret;
/* the first misc device will be used */ /* the first misc device will be used */
ret = uclass_first_device(UCLASS_MISC, &dev); ret = uclass_first_device_err(UCLASS_MISC, &dev);
if (ret) if (ret)
return; return;
if (!dev)
return;
ret = misc_read(dev, 0, &sysid, sizeof(sysid)); ret = misc_read(dev, 0, &sysid, sizeof(sysid));
if (ret) if (ret)
return; return;

2
drivers/mmc/arm_pl180_mmci.c
View file

@ -375,7 +375,7 @@ int arm_pl180_mmci_init(struct pl180_mmc_host *host)
if (mmc == NULL) if (mmc == NULL)
return -1; return -1;
debug("registered mmc interface number is:%d\n", mmc->block_dev.dev); debug("registered mmc interface number is:%d\n", mmc->block_dev.devnum);
return 0; return 0;
} }

14
drivers/mmc/mmc.c
View file

@ -182,7 +182,7 @@ struct mmc *find_mmc_device(int dev_num)
list_for_each(entry, &mmc_devices) { list_for_each(entry, &mmc_devices) {
m = list_entry(entry, struct mmc, link); m = list_entry(entry, struct mmc, link);
if (m->block_dev.dev == dev_num) if (m->block_dev.devnum == dev_num)
return m; return m;
} }
@ -234,10 +234,10 @@ static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start,
return blkcnt; return blkcnt;
} }
static ulong mmc_bread(block_dev_desc_t *block_dev, lbaint_t start, static ulong mmc_bread(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt, void *dst) lbaint_t blkcnt, void *dst)
{ {
int dev_num = block_dev->dev; int dev_num = block_dev->devnum;
int err; int err;
lbaint_t cur, blocks_todo = blkcnt; lbaint_t cur, blocks_todo = blkcnt;
@ -1495,7 +1495,7 @@ static int mmc_startup(struct mmc *mmc)
mmc->block_dev.revision[0] = 0; mmc->block_dev.revision[0] = 0;
#endif #endif
#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT) #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT)
init_part(&mmc->block_dev); part_init(&mmc->block_dev);
#endif #endif
return 0; return 0;
@ -1556,7 +1556,7 @@ struct mmc *mmc_create(const struct mmc_config *cfg, void *priv)
mmc->dsr = 0xffffffff; mmc->dsr = 0xffffffff;
/* Setup the universal parts of the block interface just once */ /* Setup the universal parts of the block interface just once */
mmc->block_dev.if_type = IF_TYPE_MMC; mmc->block_dev.if_type = IF_TYPE_MMC;
mmc->block_dev.dev = cur_dev_num++; mmc->block_dev.devnum = cur_dev_num++;
mmc->block_dev.removable = 1; mmc->block_dev.removable = 1;
mmc->block_dev.block_read = mmc_bread; mmc->block_dev.block_read = mmc_bread;
mmc->block_dev.block_write = mmc_bwrite; mmc->block_dev.block_write = mmc_bwrite;
@ -1579,7 +1579,7 @@ void mmc_destroy(struct mmc *mmc)
} }
#ifdef CONFIG_PARTITIONS #ifdef CONFIG_PARTITIONS
block_dev_desc_t *mmc_get_dev(int dev) struct blk_desc *mmc_get_dev(int dev)
{ {
struct mmc *mmc = find_mmc_device(dev); struct mmc *mmc = find_mmc_device(dev);
if (!mmc || mmc_init(mmc)) if (!mmc || mmc_init(mmc))
@ -1728,7 +1728,7 @@ void print_mmc_devices(char separator)
else else
mmc_type = NULL; mmc_type = NULL;
printf("%s: %d", m->cfg->name, m->block_dev.dev); printf("%s: %d", m->cfg->name, m->block_dev.devnum);
if (mmc_type) if (mmc_type)
printf(" (%s)", mmc_type); printf(" (%s)", mmc_type);

8
drivers/mmc/mmc_private.h
View file

@ -22,23 +22,23 @@ void mmc_adapter_card_type_ident(void);
#ifndef CONFIG_SPL_BUILD #ifndef CONFIG_SPL_BUILD
unsigned long mmc_berase(block_dev_desc_t *block_dev, lbaint_t start, unsigned long mmc_berase(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt); lbaint_t blkcnt);
unsigned long mmc_bwrite(block_dev_desc_t *block_dev, lbaint_t start, unsigned long mmc_bwrite(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt, const void *src); lbaint_t blkcnt, const void *src);
#else /* CONFIG_SPL_BUILD */ #else /* CONFIG_SPL_BUILD */
/* SPL will never write or erase, declare dummies to reduce code size. */ /* SPL will never write or erase, declare dummies to reduce code size. */
static inline unsigned long mmc_berase(block_dev_desc_t *block_dev, static inline unsigned long mmc_berase(struct blk_desc *block_dev,
lbaint_t start, lbaint_t blkcnt) lbaint_t start, lbaint_t blkcnt)
{ {
return 0; return 0;
} }
static inline ulong mmc_bwrite(block_dev_desc_t *block_dev, lbaint_t start, static inline ulong mmc_bwrite(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt, const void *src) lbaint_t blkcnt, const void *src)
{ {
return 0; return 0;

8
drivers/mmc/mmc_write.c
View file

@ -65,10 +65,10 @@ err_out:
return err; return err;
} }
unsigned long mmc_berase(block_dev_desc_t *block_dev, lbaint_t start, unsigned long mmc_berase(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt) lbaint_t blkcnt)
{ {
int dev_num = block_dev->dev; int dev_num = block_dev->devnum;
int err = 0; int err = 0;
u32 start_rem, blkcnt_rem; u32 start_rem, blkcnt_rem;
struct mmc *mmc = find_mmc_device(dev_num); struct mmc *mmc = find_mmc_device(dev_num);
@ -171,10 +171,10 @@ static ulong mmc_write_blocks(struct mmc *mmc, lbaint_t start,
return blkcnt; return blkcnt;
} }
ulong mmc_bwrite(block_dev_desc_t *block_dev, lbaint_t start, lbaint_t blkcnt, ulong mmc_bwrite(struct blk_desc *block_dev, lbaint_t start, lbaint_t blkcnt,
const void *src) const void *src)
{ {
int dev_num = block_dev->dev; int dev_num = block_dev->devnum;
lbaint_t cur, blocks_todo = blkcnt; lbaint_t cur, blocks_todo = blkcnt;
int err; int err;

24
drivers/mmc/mxsmmc.c
View file

@ -142,7 +142,7 @@ mxsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
uint32_t ctrl0; uint32_t ctrl0;
int ret; int ret;
debug("MMC%d: CMD%d\n", mmc->block_dev.dev, cmd->cmdidx); debug("MMC%d: CMD%d\n", mmc->block_dev.devnum, cmd->cmdidx);
/* Check bus busy */ /* Check bus busy */
timeout = MXSMMC_MAX_TIMEOUT; timeout = MXSMMC_MAX_TIMEOUT;
@ -157,13 +157,13 @@ mxsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
} }
if (!timeout) { if (!timeout) {
printf("MMC%d: Bus busy timeout!\n", mmc->block_dev.dev); printf("MMC%d: Bus busy timeout!\n", mmc->block_dev.devnum);
return TIMEOUT; return TIMEOUT;
} }
/* See if card is present */ /* See if card is present */
if (!mxsmmc_cd(priv)) { if (!mxsmmc_cd(priv)) {
printf("MMC%d: No card detected!\n", mmc->block_dev.dev); printf("MMC%d: No card detected!\n", mmc->block_dev.devnum);
return NO_CARD_ERR; return NO_CARD_ERR;
} }
@ -200,9 +200,9 @@ mxsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
if (data->flags & MMC_DATA_READ) { if (data->flags & MMC_DATA_READ) {
ctrl0 |= SSP_CTRL0_READ; ctrl0 |= SSP_CTRL0_READ;
} else if (priv->mmc_is_wp && } else if (priv->mmc_is_wp &&
priv->mmc_is_wp(mmc->block_dev.dev)) { priv->mmc_is_wp(mmc->block_dev.devnum)) {
printf("MMC%d: Can not write a locked card!\n", printf("MMC%d: Can not write a locked card!\n",
mmc->block_dev.dev); mmc->block_dev.devnum);
return UNUSABLE_ERR; return UNUSABLE_ERR;
} }
@ -243,21 +243,21 @@ mxsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
if (!timeout) { if (!timeout) {
printf("MMC%d: Command %d busy\n", printf("MMC%d: Command %d busy\n",
mmc->block_dev.dev, cmd->cmdidx); mmc->block_dev.devnum, cmd->cmdidx);
return TIMEOUT; return TIMEOUT;
} }
/* Check command timeout */ /* Check command timeout */
if (reg & SSP_STATUS_RESP_TIMEOUT) { if (reg & SSP_STATUS_RESP_TIMEOUT) {
printf("MMC%d: Command %d timeout (status 0x%08x)\n", printf("MMC%d: Command %d timeout (status 0x%08x)\n",
mmc->block_dev.dev, cmd->cmdidx, reg); mmc->block_dev.devnum, cmd->cmdidx, reg);
return TIMEOUT; return TIMEOUT;
} }
/* Check command errors */ /* Check command errors */
if (reg & (SSP_STATUS_RESP_CRC_ERR | SSP_STATUS_RESP_ERR)) { if (reg & (SSP_STATUS_RESP_CRC_ERR | SSP_STATUS_RESP_ERR)) {
printf("MMC%d: Command %d error (status 0x%08x)!\n", printf("MMC%d: Command %d error (status 0x%08x)!\n",
mmc->block_dev.dev, cmd->cmdidx, reg); mmc->block_dev.devnum, cmd->cmdidx, reg);
return COMM_ERR; return COMM_ERR;
} }
@ -279,14 +279,14 @@ mxsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
if (ret) { if (ret) {
printf("MMC%d: Data timeout with command %d " printf("MMC%d: Data timeout with command %d "
"(status 0x%08x)!\n", "(status 0x%08x)!\n",
mmc->block_dev.dev, cmd->cmdidx, reg); mmc->block_dev.devnum, cmd->cmdidx, reg);
return ret; return ret;
} }
} else { } else {
ret = mxsmmc_send_cmd_dma(priv, data); ret = mxsmmc_send_cmd_dma(priv, data);
if (ret) { if (ret) {
printf("MMC%d: DMA transfer failed\n", printf("MMC%d: DMA transfer failed\n",
mmc->block_dev.dev); mmc->block_dev.devnum);
return ret; return ret;
} }
} }
@ -297,7 +297,7 @@ mxsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
(SSP_STATUS_TIMEOUT | SSP_STATUS_DATA_CRC_ERR | (SSP_STATUS_TIMEOUT | SSP_STATUS_DATA_CRC_ERR |
SSP_STATUS_FIFO_OVRFLW | SSP_STATUS_FIFO_UNDRFLW)) { SSP_STATUS_FIFO_OVRFLW | SSP_STATUS_FIFO_UNDRFLW)) {
printf("MMC%d: Data error with command %d (status 0x%08x)!\n", printf("MMC%d: Data error with command %d (status 0x%08x)!\n",
mmc->block_dev.dev, cmd->cmdidx, reg); mmc->block_dev.devnum, cmd->cmdidx, reg);
return COMM_ERR; return COMM_ERR;
} }
@ -330,7 +330,7 @@ static void mxsmmc_set_ios(struct mmc *mmc)
SSP_CTRL0_BUS_WIDTH_MASK, priv->buswidth); SSP_CTRL0_BUS_WIDTH_MASK, priv->buswidth);
debug("MMC%d: Set %d bits bus width\n", debug("MMC%d: Set %d bits bus width\n",
mmc->block_dev.dev, mmc->bus_width); mmc->block_dev.devnum, mmc->bus_width);
} }
static int mxsmmc_init(struct mmc *mmc) static int mxsmmc_init(struct mmc *mmc)

4
drivers/mmc/omap_hsmmc.c
View file

@ -177,11 +177,11 @@ static unsigned char mmc_board_init(struct mmc *mmc)
#if defined(CONFIG_OMAP44XX) && defined(CONFIG_TWL6030_POWER) #if defined(CONFIG_OMAP44XX) && defined(CONFIG_TWL6030_POWER)
/* PBIAS config needed for MMC1 only */ /* PBIAS config needed for MMC1 only */
if (mmc->block_dev.dev == 0) if (mmc->block_dev.devnum == 0)
omap4_vmmc_pbias_config(mmc); omap4_vmmc_pbias_config(mmc);
#endif #endif
#if defined(CONFIG_OMAP54XX) && defined(CONFIG_PALMAS_POWER) #if defined(CONFIG_OMAP54XX) && defined(CONFIG_PALMAS_POWER)
if (mmc->block_dev.dev == 0) if (mmc->block_dev.devnum == 0)
omap5_pbias_config(mmc); omap5_pbias_config(mmc);
#endif #endif

2
drivers/mmc/sdhci.c
View file

@ -137,7 +137,7 @@ static int sdhci_send_command(struct mmc *mmc, struct mmc_cmd *cmd,
int trans_bytes = 0, is_aligned = 1; int trans_bytes = 0, is_aligned = 1;
u32 mask, flags, mode; u32 mask, flags, mode;
unsigned int time = 0, start_addr = 0; unsigned int time = 0, start_addr = 0;
int mmc_dev = mmc->block_dev.dev; int mmc_dev = mmc->block_dev.devnum;
unsigned start = get_timer(0); unsigned start = get_timer(0);
/* Timeout unit - ms */ /* Timeout unit - ms */

4
drivers/pci/pci-uclass.c
View file

@ -30,11 +30,9 @@ int pci_get_bus(int busnum, struct udevice **busp)
/* Since buses may not be numbered yet try a little harder with bus 0 */ /* Since buses may not be numbered yet try a little harder with bus 0 */
if (ret == -ENODEV) { if (ret == -ENODEV) {
ret = uclass_first_device(UCLASS_PCI, busp); ret = uclass_first_device_err(UCLASS_PCI, busp);
if (ret) if (ret)
return ret; return ret;
else if (!*busp)
return -ENODEV;
ret = uclass_get_device_by_seq(UCLASS_PCI, busnum, busp); ret = uclass_get_device_by_seq(UCLASS_PCI, busnum, busp);
} }

51
drivers/pci/pci_auto_common.c
View file

@ -62,6 +62,17 @@ int pciauto_region_allocate(struct pci_region *res, pci_size_t size,
return -1; return -1;
} }
static void pciauto_show_region(const char *name, struct pci_region *region)
{
pciauto_region_init(region);
debug("PCI Autoconfig: Bus %s region: [%llx-%llx],\n"
"\t\tPhysical Memory [%llx-%llxx]\n", name,
(unsigned long long)region->bus_start,
(unsigned long long)(region->bus_start + region->size - 1),
(unsigned long long)region->phys_start,
(unsigned long long)(region->phys_start + region->size - 1));
}
void pciauto_config_init(struct pci_controller *hose) void pciauto_config_init(struct pci_controller *hose)
{ {
int i; int i;
@ -91,38 +102,10 @@ void pciauto_config_init(struct pci_controller *hose)
} }
if (hose->pci_mem) { if (hose->pci_mem)
pciauto_region_init(hose->pci_mem); pciauto_show_region("Memory", hose->pci_mem);
if (hose->pci_prefetch)
debug("PCI Autoconfig: Bus Memory region: [0x%llx-0x%llx],\n" pciauto_show_region("Prefetchable Mem", hose->pci_prefetch);
"\t\tPhysical Memory [%llx-%llxx]\n", if (hose->pci_io)
(u64)hose->pci_mem->bus_start, pciauto_show_region("I/O", hose->pci_io);
(u64)(hose->pci_mem->bus_start + hose->pci_mem->size - 1),
(u64)hose->pci_mem->phys_start,
(u64)(hose->pci_mem->phys_start + hose->pci_mem->size - 1));
}
if (hose->pci_prefetch) {
pciauto_region_init(hose->pci_prefetch);
debug("PCI Autoconfig: Bus Prefetchable Mem: [0x%llx-0x%llx],\n"
"\t\tPhysical Memory [%llx-%llx]\n",
(u64)hose->pci_prefetch->bus_start,
(u64)(hose->pci_prefetch->bus_start +
hose->pci_prefetch->size - 1),
(u64)hose->pci_prefetch->phys_start,
(u64)(hose->pci_prefetch->phys_start +
hose->pci_prefetch->size - 1));
}
if (hose->pci_io) {
pciauto_region_init(hose->pci_io);
debug("PCI Autoconfig: Bus I/O region: [0x%llx-0x%llx],\n"
"\t\tPhysical Memory: [%llx-%llx]\n",
(u64)hose->pci_io->bus_start,
(u64)(hose->pci_io->bus_start + hose->pci_io->size - 1),
(u64)hose->pci_io->phys_start,
(u64)(hose->pci_io->phys_start + hose->pci_io->size - 1));
}
} }

2
drivers/power/regulator/regulator-uclass.c
View file

@ -325,7 +325,7 @@ int regulators_enable_boot_on(bool verbose)
if (ret) if (ret)
return ret; return ret;
for (uclass_first_device(UCLASS_REGULATOR, &dev); for (uclass_first_device(UCLASS_REGULATOR, &dev);
dev && !ret; dev;
uclass_next_device(&dev)) { uclass_next_device(&dev)) {
ret = regulator_autoset(dev); ret = regulator_autoset(dev);
if (ret == -EMEDIUMTYPE) { if (ret == -EMEDIUMTYPE) {

5
drivers/serial/serial-uclass.c
View file

@ -123,11 +123,12 @@ static void _serial_putc(struct udevice *dev, char ch)
struct dm_serial_ops *ops = serial_get_ops(dev); struct dm_serial_ops *ops = serial_get_ops(dev);
int err; int err;
if (ch == '\n')
_serial_putc(dev, '\r');
do { do {
err = ops->putc(dev, ch); err = ops->putc(dev, ch);
} while (err == -EAGAIN); } while (err == -EAGAIN);
if (ch == '\n')
_serial_putc(dev, '\r');
} }
static void _serial_puts(struct udevice *dev, const char *str) static void _serial_puts(struct udevice *dev, const char *str)

3
drivers/serial/serial_arc.c
View file

@ -68,9 +68,6 @@ static int arc_serial_putc(struct udevice *dev, const char c)
struct arc_serial_platdata *plat = dev->platdata; struct arc_serial_platdata *plat = dev->platdata;
struct arc_serial_regs *const regs = plat->reg; struct arc_serial_regs *const regs = plat->reg;
if (c == '\n')
arc_serial_putc(dev, '\r');
while (!(readb(&regs->status) & UART_TXEMPTY)) while (!(readb(&regs->status) & UART_TXEMPTY))
; ;

6
drivers/serial/serial_lpuart.c
View file

@ -77,9 +77,6 @@ static int _lpuart_serial_getc(struct lpuart_fsl *base)
static void _lpuart_serial_putc(struct lpuart_fsl *base, const char c) static void _lpuart_serial_putc(struct lpuart_fsl *base, const char c)
{ {
if (c == '\n')
_lpuart_serial_putc(base, '\r');
while (!(__raw_readb(&base->us1) & US1_TDRE)) while (!(__raw_readb(&base->us1) & US1_TDRE))
WATCHDOG_RESET(); WATCHDOG_RESET();
@ -198,9 +195,6 @@ static int _lpuart32_serial_getc(struct lpuart_fsl *base)
static void _lpuart32_serial_putc(struct lpuart_fsl *base, const char c) static void _lpuart32_serial_putc(struct lpuart_fsl *base, const char c)
{ {
if (c == '\n')
_lpuart32_serial_putc(base, '\r');
while (!(in_be32(&base->stat) & STAT_TDRE)) while (!(in_be32(&base->stat) & STAT_TDRE))
WATCHDOG_RESET(); WATCHDOG_RESET();

8
drivers/serial/serial_mxc.c
View file

@ -164,15 +164,15 @@ static int mxc_serial_getc(void)
static void mxc_serial_putc(const char c) static void mxc_serial_putc(const char c)
{ {
/* If \n, also do \r */
if (c == '\n')
serial_putc('\r');
__REG(UART_PHYS + UTXD) = c; __REG(UART_PHYS + UTXD) = c;
/* wait for transmitter to be ready */ /* wait for transmitter to be ready */
while (!(__REG(UART_PHYS + UTS) & UTS_TXEMPTY)) while (!(__REG(UART_PHYS + UTS) & UTS_TXEMPTY))
WATCHDOG_RESET(); WATCHDOG_RESET();
/* If \n, also do \r */
if (c == '\n')
serial_putc ('\r');
} }
/* /*

8
drivers/serial/serial_pxa.c
View file

@ -156,6 +156,10 @@ void pxa_putc_dev(unsigned int uart_index, const char c)
{ {
struct pxa_uart_regs *uart_regs; struct pxa_uart_regs *uart_regs;
/* If \n, also do \r */
if (c == '\n')
pxa_putc_dev(uart_index, '\r');
uart_regs = pxa_uart_index_to_regs(uart_index); uart_regs = pxa_uart_index_to_regs(uart_index);
if (!uart_regs) if (!uart_regs)
hang(); hang();
@ -163,10 +167,6 @@ void pxa_putc_dev(unsigned int uart_index, const char c)
while (!(readl(&uart_regs->lsr) & LSR_TEMT)) while (!(readl(&uart_regs->lsr) & LSR_TEMT))
WATCHDOG_RESET(); WATCHDOG_RESET();
writel(c, &uart_regs->thr); writel(c, &uart_regs->thr);
/* If \n, also do \r */
if (c == '\n')
pxa_putc_dev (uart_index,'\r');
} }
/* /*

8
drivers/serial/serial_s3c24x0.c
View file

@ -135,14 +135,14 @@ static void _serial_putc(const char c, const int dev_index)
{ {
struct s3c24x0_uart *uart = s3c24x0_get_base_uart(dev_index); struct s3c24x0_uart *uart = s3c24x0_get_base_uart(dev_index);
/* If \n, also do \r */
if (c == '\n')
serial_putc('\r');
while (!(readl(&uart->utrstat) & 0x2)) while (!(readl(&uart->utrstat) & 0x2))
/* wait for room in the tx FIFO */ ; /* wait for room in the tx FIFO */ ;
writeb(c, &uart->utxh); writeb(c, &uart->utxh);
/* If \n, also do \r */
if (c == '\n')
serial_putc('\r');
} }
static inline void serial_putc_dev(unsigned int dev_index, const char c) static inline void serial_putc_dev(unsigned int dev_index, const char c)

7
drivers/serial/usbtty.c
View file

@ -434,11 +434,12 @@ void usbtty_putc(struct stdio_dev *dev, const char c)
if (!usbtty_configured ()) if (!usbtty_configured ())
return; return;
buf_push (&usbtty_output, &c, 1);
/* If \n, also do \r */ /* If \n, also do \r */
if (c == '\n') if (c == '\n')
buf_push (&usbtty_output, "\r", 1); buf_push (&usbtty_output, "\r", 1);
buf_push(&usbtty_output, &c, 1);
/* Poll at end to handle new data... */ /* Poll at end to handle new data... */
if ((usbtty_output.size + 2) >= usbtty_output.totalsize) { if ((usbtty_output.size + 2) >= usbtty_output.totalsize) {
usbtty_poll (); usbtty_poll ();
@ -498,8 +499,8 @@ void usbtty_puts(struct stdio_dev *dev, const char *str)
n = next_nl_pos (str); n = next_nl_pos (str);
if (str[n] == '\n') { if (str[n] == '\n') {
__usbtty_puts (str, n + 1); __usbtty_puts("\r", 1);
__usbtty_puts ("\r", 1); __usbtty_puts(str, n + 1);
str += (n + 1); str += (n + 1);
len -= (n + 1); len -= (n + 1);
} else { } else {

4
drivers/timer/timer-uclass.c
View file

@ -82,11 +82,9 @@ int notrace dm_timer_init(void)
node = fdtdec_get_chosen_node(blob, "tick-timer"); node = fdtdec_get_chosen_node(blob, "tick-timer");
if (node < 0) { if (node < 0) {
/* No chosen timer, trying first available timer */ /* No chosen timer, trying first available timer */
ret = uclass_first_device(UCLASS_TIMER, &dev); ret = uclass_first_device_err(UCLASS_TIMER, &dev);
if (ret) if (ret)
return ret; return ret;
if (!dev)
return -ENODEV;
} else { } else {
if (uclass_get_device_by_of_offset(UCLASS_TIMER, node, &dev)) { if (uclass_get_device_by_of_offset(UCLASS_TIMER, node, &dev)) {
/* /*

6
drivers/video/vidconsole-uclass.c
View file

@ -240,8 +240,7 @@ static int do_video_setcursor(cmd_tbl_t *cmdtp, int flag, int argc,
if (argc != 3) if (argc != 3)
return CMD_RET_USAGE; return CMD_RET_USAGE;
uclass_first_device(UCLASS_VIDEO_CONSOLE, &dev); if (uclass_first_device_err(UCLASS_VIDEO_CONSOLE, &dev))
if (!dev)
return CMD_RET_FAILURE; return CMD_RET_FAILURE;
col = simple_strtoul(argv[1], NULL, 10); col = simple_strtoul(argv[1], NULL, 10);
row = simple_strtoul(argv[2], NULL, 10); row = simple_strtoul(argv[2], NULL, 10);
@ -259,8 +258,7 @@ static int do_video_puts(cmd_tbl_t *cmdtp, int flag, int argc,
if (argc != 2) if (argc != 2)
return CMD_RET_USAGE; return CMD_RET_USAGE;
uclass_first_device(UCLASS_VIDEO_CONSOLE, &dev); if (uclass_first_device_err(UCLASS_VIDEO_CONSOLE, &dev))
if (!dev)
return CMD_RET_FAILURE; return CMD_RET_FAILURE;
for (s = argv[1]; *s; s++) for (s = argv[1]; *s; s++)
vidconsole_put_char(dev, *s); vidconsole_put_char(dev, *s);

54
fs/ext4/dev.c
View file

@ -24,6 +24,7 @@
*/ */
#include <common.h> #include <common.h>
#include <blk.h>
#include <config.h> #include <config.h>
#include <memalign.h> #include <memalign.h>
#include <ext4fs.h> #include <ext4fs.h>
@ -32,13 +33,13 @@
lbaint_t part_offset; lbaint_t part_offset;
static block_dev_desc_t *ext4fs_block_dev_desc; static struct blk_desc *ext4fs_blk_desc;
static disk_partition_t *part_info; static disk_partition_t *part_info;
void ext4fs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info) void ext4fs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
{ {
assert(rbdd->blksz == (1 << rbdd->log2blksz)); assert(rbdd->blksz == (1 << rbdd->log2blksz));
ext4fs_block_dev_desc = rbdd; ext4fs_blk_desc = rbdd;
get_fs()->dev_desc = rbdd; get_fs()->dev_desc = rbdd;
part_info = info; part_info = info;
part_offset = info->start; part_offset = info->start;
@ -49,11 +50,11 @@ void ext4fs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info)
int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf) int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf)
{ {
unsigned block_len; unsigned block_len;
int log2blksz = ext4fs_block_dev_desc->log2blksz; int log2blksz = ext4fs_blk_desc->log2blksz;
ALLOC_CACHE_ALIGN_BUFFER(char, sec_buf, (ext4fs_block_dev_desc ? ALLOC_CACHE_ALIGN_BUFFER(char, sec_buf, (ext4fs_blk_desc ?
ext4fs_block_dev_desc->blksz : ext4fs_blk_desc->blksz :
0)); 0));
if (ext4fs_block_dev_desc == NULL) { if (ext4fs_blk_desc == NULL) {
printf("** Invalid Block Device Descriptor (NULL)\n"); printf("** Invalid Block Device Descriptor (NULL)\n");
return 0; return 0;
} }
@ -69,21 +70,19 @@ int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf)
/* Get the read to the beginning of a partition */ /* Get the read to the beginning of a partition */
sector += byte_offset >> log2blksz; sector += byte_offset >> log2blksz;
byte_offset &= ext4fs_block_dev_desc->blksz - 1; byte_offset &= ext4fs_blk_desc->blksz - 1;
debug(" <" LBAFU ", %d, %d>\n", sector, byte_offset, byte_len); debug(" <" LBAFU ", %d, %d>\n", sector, byte_offset, byte_len);
if (byte_offset != 0) { if (byte_offset != 0) {
int readlen; int readlen;
/* read first part which isn't aligned with start of sector */ /* read first part which isn't aligned with start of sector */
if (ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc, if (blk_dread(ext4fs_blk_desc, part_info->start + sector, 1,
part_info->start + sector, (void *)sec_buf) != 1) {
1, (void *)sec_buf)
!= 1) {
printf(" ** ext2fs_devread() read error **\n"); printf(" ** ext2fs_devread() read error **\n");
return 0; return 0;
} }
readlen = min((int)ext4fs_block_dev_desc->blksz - byte_offset, readlen = min((int)ext4fs_blk_desc->blksz - byte_offset,
byte_len); byte_len);
memcpy(buf, sec_buf + byte_offset, readlen); memcpy(buf, sec_buf + byte_offset, readlen);
buf += readlen; buf += readlen;
@ -95,38 +94,33 @@ int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf)
return 1; return 1;
/* read sector aligned part */ /* read sector aligned part */
block_len = byte_len & ~(ext4fs_block_dev_desc->blksz - 1); block_len = byte_len & ~(ext4fs_blk_desc->blksz - 1);
if (block_len == 0) { if (block_len == 0) {
ALLOC_CACHE_ALIGN_BUFFER(u8, p, ext4fs_block_dev_desc->blksz); ALLOC_CACHE_ALIGN_BUFFER(u8, p, ext4fs_blk_desc->blksz);
block_len = ext4fs_block_dev_desc->blksz; block_len = ext4fs_blk_desc->blksz;
ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc, blk_dread(ext4fs_blk_desc, part_info->start + sector, 1,
part_info->start + sector, (void *)p);
1, (void *)p);
memcpy(buf, p, byte_len); memcpy(buf, p, byte_len);
return 1; return 1;
} }
if (ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc, if (blk_dread(ext4fs_blk_desc, part_info->start + sector,
part_info->start + sector, block_len >> log2blksz, (void *)buf) !=
block_len >> log2blksz, block_len >> log2blksz) {
(void *)buf) !=
block_len >> log2blksz) {
printf(" ** %s read error - block\n", __func__); printf(" ** %s read error - block\n", __func__);
return 0; return 0;
} }
block_len = byte_len & ~(ext4fs_block_dev_desc->blksz - 1); block_len = byte_len & ~(ext4fs_blk_desc->blksz - 1);
buf += block_len; buf += block_len;
byte_len -= block_len; byte_len -= block_len;
sector += block_len / ext4fs_block_dev_desc->blksz; sector += block_len / ext4fs_blk_desc->blksz;
if (byte_len != 0) { if (byte_len != 0) {
/* read rest of data which are not in whole sector */ /* read rest of data which are not in whole sector */
if (ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc, if (blk_dread(ext4fs_blk_desc, part_info->start + sector, 1,
part_info->start + sector, (void *)sec_buf) != 1) {
1, (void *)sec_buf)
!= 1) {
printf("* %s read error - last part\n", __func__); printf("* %s read error - last part\n", __func__);
return 0; return 0;
} }

27
fs/ext4/ext4_common.c
View file

@ -81,29 +81,20 @@ void put_ext4(uint64_t off, void *buf, uint32_t size)
} }
if (remainder) { if (remainder) {
if (fs->dev_desc->block_read) { blk_dread(fs->dev_desc, startblock, 1, sec_buf);
fs->dev_desc->block_read(fs->dev_desc, temp_ptr = sec_buf;
startblock, 1, sec_buf); memcpy((temp_ptr + remainder), (unsigned char *)buf, size);
temp_ptr = sec_buf; blk_dwrite(fs->dev_desc, startblock, 1, sec_buf);
memcpy((temp_ptr + remainder),
(unsigned char *)buf, size);
fs->dev_desc->block_write(fs->dev_desc,
startblock, 1, sec_buf);
}
} else { } else {
if (size >> log2blksz != 0) { if (size >> log2blksz != 0) {
fs->dev_desc->block_write(fs->dev_desc, blk_dwrite(fs->dev_desc, startblock, size >> log2blksz,
startblock, (unsigned long *)buf);
size >> log2blksz,
(unsigned long *)buf);
} else { } else {
fs->dev_desc->block_read(fs->dev_desc, blk_dread(fs->dev_desc, startblock, 1, sec_buf);
startblock, 1, sec_buf);
temp_ptr = sec_buf; temp_ptr = sec_buf;
memcpy(temp_ptr, buf, size); memcpy(temp_ptr, buf, size);
fs->dev_desc->block_write(fs->dev_desc, blk_dwrite(fs->dev_desc, startblock, 1,
startblock, 1, (unsigned long *)sec_buf);
(unsigned long *)sec_buf);
} }
} }
} }

2
fs/ext4/ext4fs.c
View file

@ -198,7 +198,7 @@ int ext4fs_read(char *buf, loff_t len, loff_t *actread)
return ext4fs_read_file(ext4fs_file, 0, len, buf, actread); return ext4fs_read_file(ext4fs_file, 0, len, buf, actread);
} }
int ext4fs_probe(block_dev_desc_t *fs_dev_desc, int ext4fs_probe(struct blk_desc *fs_dev_desc,
disk_partition_t *fs_partition) disk_partition_t *fs_partition)
{ {
ext4fs_set_blk_dev(fs_dev_desc, fs_partition); ext4fs_set_blk_dev(fs_dev_desc, fs_partition);

18
fs/fat/fat.c
View file

@ -10,6 +10,7 @@
*/ */
#include <common.h> #include <common.h>
#include <blk.h>
#include <config.h> #include <config.h>
#include <exports.h> #include <exports.h>
#include <fat.h> #include <fat.h>
@ -37,7 +38,7 @@ static void downcase(char *str)
} }
} }
static block_dev_desc_t *cur_dev; static struct blk_desc *cur_dev;
static disk_partition_t cur_part_info; static disk_partition_t cur_part_info;
#define DOS_BOOT_MAGIC_OFFSET 0x1fe #define DOS_BOOT_MAGIC_OFFSET 0x1fe
@ -48,11 +49,10 @@ static int disk_read(__u32 block, __u32 nr_blocks, void *buf)
{ {
ulong ret; ulong ret;
if (!cur_dev || !cur_dev->block_read) if (!cur_dev)
return -1; return -1;
ret = cur_dev->block_read(cur_dev, cur_part_info.start + block, ret = blk_dread(cur_dev, cur_part_info.start + block, nr_blocks, buf);
nr_blocks, buf);
if (nr_blocks && ret == 0) if (nr_blocks && ret == 0)
return -1; return -1;
@ -60,7 +60,7 @@ static int disk_read(__u32 block, __u32 nr_blocks, void *buf)
return ret; return ret;
} }
int fat_set_blk_dev(block_dev_desc_t *dev_desc, disk_partition_t *info) int fat_set_blk_dev(struct blk_desc *dev_desc, disk_partition_t *info)
{ {
ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, dev_desc->blksz); ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, dev_desc->blksz);
@ -89,7 +89,7 @@ int fat_set_blk_dev(block_dev_desc_t *dev_desc, disk_partition_t *info)
return -1; return -1;
} }
int fat_register_device(block_dev_desc_t *dev_desc, int part_no) int fat_register_device(struct blk_desc *dev_desc, int part_no)
{ {
disk_partition_t info; disk_partition_t info;
@ -97,10 +97,10 @@ int fat_register_device(block_dev_desc_t *dev_desc, int part_no)
cur_dev = NULL; cur_dev = NULL;
/* Read the partition table, if present */ /* Read the partition table, if present */
if (get_partition_info(dev_desc, part_no, &info)) { if (part_get_info(dev_desc, part_no, &info)) {
if (part_no != 0) { if (part_no != 0) {
printf("** Partition %d not valid on device %d **\n", printf("** Partition %d not valid on device %d **\n",
part_no, dev_desc->dev); part_no, dev_desc->devnum);
return -1; return -1;
} }
@ -1284,7 +1284,7 @@ int file_fat_detectfs(void)
printf("Unknown"); printf("Unknown");
} }
printf("\n Device %d: ", cur_dev->dev); printf("\n Device %d: ", cur_dev->devnum);
dev_print(cur_dev); dev_print(cur_dev);
#endif #endif

5
fs/fat/fat_write.c
View file

@ -32,7 +32,7 @@ static int disk_write(__u32 block, __u32 nr_blocks, void *buf)
{ {
ulong ret; ulong ret;
if (!cur_dev || !cur_dev->block_write) if (!cur_dev)
return -1; return -1;
if (cur_part_info.start + block + nr_blocks > 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; return -1;
} }
ret = cur_dev->block_write(cur_dev, cur_part_info.start + block, ret = blk_dwrite(cur_dev, cur_part_info.start + block, nr_blocks, buf);
nr_blocks, buf);
if (nr_blocks && ret == 0) if (nr_blocks && ret == 0)
return -1; return -1;

8
fs/fs.c
View file

@ -20,11 +20,11 @@
DECLARE_GLOBAL_DATA_PTR; DECLARE_GLOBAL_DATA_PTR;
static block_dev_desc_t *fs_dev_desc; static struct blk_desc *fs_dev_desc;
static disk_partition_t fs_partition; static disk_partition_t fs_partition;
static int fs_type = FS_TYPE_ANY; static int fs_type = FS_TYPE_ANY;
static inline int fs_probe_unsupported(block_dev_desc_t *fs_dev_desc, static inline int fs_probe_unsupported(struct blk_desc *fs_dev_desc,
disk_partition_t *fs_partition) disk_partition_t *fs_partition)
{ {
printf("** Unrecognized filesystem type **\n"); printf("** Unrecognized filesystem type **\n");
@ -81,7 +81,7 @@ struct fstype_info {
* filesystem. * filesystem.
*/ */
bool null_dev_desc_ok; bool null_dev_desc_ok;
int (*probe)(block_dev_desc_t *fs_dev_desc, int (*probe)(struct blk_desc *fs_dev_desc,
disk_partition_t *fs_partition); disk_partition_t *fs_partition);
int (*ls)(const char *dirname); int (*ls)(const char *dirname);
int (*exists)(const char *filename); int (*exists)(const char *filename);
@ -213,7 +213,7 @@ int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
} }
#endif #endif
part = get_device_and_partition(ifname, dev_part_str, &fs_dev_desc, part = blk_get_device_part_str(ifname, dev_part_str, &fs_dev_desc,
&fs_partition, 1); &fs_partition, 1);
if (part < 0) if (part < 0)
return -1; return -1;

33
fs/reiserfs/dev.c
View file

@ -12,13 +12,13 @@
#include "reiserfs_private.h" #include "reiserfs_private.h"
static block_dev_desc_t *reiserfs_block_dev_desc; static struct blk_desc *reiserfs_blk_desc;
static disk_partition_t *part_info; static disk_partition_t *part_info;
void reiserfs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info) void reiserfs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
{ {
reiserfs_block_dev_desc = rbdd; reiserfs_blk_desc = rbdd;
part_info = info; part_info = info;
} }
@ -53,17 +53,15 @@ int reiserfs_devread (int sector, int byte_offset, int byte_len, char *buf)
#endif #endif
if (reiserfs_block_dev_desc == NULL) if (reiserfs_blk_desc == NULL)
return 0; return 0;
if (byte_offset != 0) { if (byte_offset != 0) {
/* read first part which isn't aligned with start of sector */ /* read first part which isn't aligned with start of sector */
if (reiserfs_block_dev_desc->block_read(reiserfs_block_dev_desc, if (reiserfs_blk_desc->block_read(reiserfs_blk_desc,
part_info->start + part_info->start + sector,
sector, 1, (void *)sec_buf) != 1) {
1, (void *)sec_buf)
!= 1) {
printf (" ** reiserfs_devread() read error\n"); printf (" ** reiserfs_devread() read error\n");
return 0; return 0;
} }
@ -75,11 +73,10 @@ int reiserfs_devread (int sector, int byte_offset, int byte_len, char *buf)
/* read sector aligned part */ /* read sector aligned part */
block_len = byte_len & ~(SECTOR_SIZE-1); block_len = byte_len & ~(SECTOR_SIZE-1);
if (reiserfs_block_dev_desc->block_read(reiserfs_block_dev_desc, if (reiserfs_blk_desc->block_read(reiserfs_blk_desc,
part_info->start + sector, part_info->start + sector,
block_len / SECTOR_SIZE, block_len / SECTOR_SIZE, (void *)buf)
(void *)buf) != block_len/SECTOR_SIZE) {
!= block_len/SECTOR_SIZE) {
printf (" ** reiserfs_devread() read error - block\n"); printf (" ** reiserfs_devread() read error - block\n");
return 0; return 0;
} }
@ -89,11 +86,9 @@ int reiserfs_devread (int sector, int byte_offset, int byte_len, char *buf)
if ( byte_len != 0 ) { if ( byte_len != 0 ) {
/* read rest of data which are not in whole sector */ /* read rest of data which are not in whole sector */
if (reiserfs_block_dev_desc->block_read(reiserfs_block_dev_desc, if (reiserfs_blk_desc->block_read(reiserfs_blk_desc,
part_info->start + part_info->start + sector,
sector, 1, (void *)sec_buf) != 1) {
1, (void *)sec_buf)
!= 1) {
printf (" ** reiserfs_devread() read error - last part\n"); printf (" ** reiserfs_devread() read error - last part\n");
return 0; return 0;
} }

4
fs/sandbox/sandboxfs.c
View file

@ -8,10 +8,10 @@
#include <fs.h> #include <fs.h>
#include <os.h> #include <os.h>
int sandbox_fs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info) int sandbox_fs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
{ {
/* /*
* Only accept a NULL block_dev_desc_t for the sandbox, which is when * Only accept a NULL struct blk_desc for the sandbox, which is when
* hostfs interface is used * hostfs interface is used
*/ */
return rbdd != NULL; return rbdd != NULL;

4
fs/ubifs/ubifs.c
View file

@ -561,7 +561,7 @@ static unsigned long ubifs_findfile(struct super_block *sb, char *filename)
return 0; return 0;
} }
int ubifs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info) int ubifs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
{ {
if (rbdd) { if (rbdd) {
debug("UBIFS cannot be used with normal block devices\n"); debug("UBIFS cannot be used with normal block devices\n");
@ -569,7 +569,7 @@ int ubifs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info)
} }
/* /*
* Should never happen since get_device_and_partition() already checks * Should never happen since blk_get_device_part_str() already checks
* this, but better safe then sorry. * this, but better safe then sorry.
*/ */
if (!ubifs_is_mounted()) { if (!ubifs_is_mounted()) {

35
fs/zfs/dev.c
View file

@ -13,12 +13,12 @@
#include <config.h> #include <config.h>
#include <zfs_common.h> #include <zfs_common.h>
static block_dev_desc_t *zfs_block_dev_desc; static struct blk_desc *zfs_blk_desc;
static disk_partition_t *part_info; static disk_partition_t *part_info;
void zfs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info) void zfs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
{ {
zfs_block_dev_desc = rbdd; zfs_blk_desc = rbdd;
part_info = info; part_info = info;
} }
@ -48,17 +48,16 @@ int zfs_devread(int sector, int byte_offset, int byte_len, char *buf)
debug(" <%d, %d, %d>\n", sector, byte_offset, byte_len); debug(" <%d, %d, %d>\n", sector, byte_offset, byte_len);
if (zfs_block_dev_desc == NULL) { if (zfs_blk_desc == NULL) {
printf("** Invalid Block Device Descriptor (NULL)\n"); printf("** Invalid Block Device Descriptor (NULL)\n");
return 1; return 1;
} }
if (byte_offset != 0) { if (byte_offset != 0) {
/* read first part which isn't aligned with start of sector */ /* read first part which isn't aligned with start of sector */
if (zfs_block_dev_desc->block_read(zfs_block_dev_desc, if (zfs_blk_desc->block_read(zfs_blk_desc,
part_info->start + sector, 1, part_info->start + sector, 1,
(void *)sec_buf) (void *)sec_buf) != 1) {
!= 1) {
printf(" ** zfs_devread() read error **\n"); printf(" ** zfs_devread() read error **\n");
return 1; return 1;
} }
@ -79,18 +78,16 @@ int zfs_devread(int sector, int byte_offset, int byte_len, char *buf)
u8 p[SECTOR_SIZE]; u8 p[SECTOR_SIZE];
block_len = SECTOR_SIZE; block_len = SECTOR_SIZE;
zfs_block_dev_desc->block_read(zfs_block_dev_desc, zfs_blk_desc->block_read(zfs_blk_desc,
part_info->start + sector, part_info->start + sector,
1, (void *)p); 1, (void *)p);
memcpy(buf, p, byte_len); memcpy(buf, p, byte_len);
return 0; return 0;
} }
if (zfs_block_dev_desc->block_read(zfs_block_dev_desc, if (zfs_blk_desc->block_read(zfs_blk_desc, part_info->start + sector,
part_info->start + sector, block_len / SECTOR_SIZE,
block_len / SECTOR_SIZE, (void *)buf) != block_len / SECTOR_SIZE) {
(void *)buf)
!= block_len / SECTOR_SIZE) {
printf(" ** zfs_devread() read error - block\n"); printf(" ** zfs_devread() read error - block\n");
return 1; return 1;
} }
@ -102,9 +99,9 @@ int zfs_devread(int sector, int byte_offset, int byte_len, char *buf)
if (byte_len != 0) { if (byte_len != 0) {
/* read rest of data which are not in whole sector */ /* read rest of data which are not in whole sector */
if (zfs_block_dev_desc->block_read(zfs_block_dev_desc, if (zfs_blk_desc->block_read(zfs_blk_desc,
part_info->start + sector, part_info->start + sector,
1, (void *)sec_buf) != 1) { 1, (void *)sec_buf) != 1) {
printf(" ** zfs_devread() read error - last part\n"); printf(" ** zfs_devread() read error - last part\n");
return 1; return 1;
} }

2
fs/zfs/zfs.c
View file

@ -20,7 +20,7 @@
#include "zfs_common.h" #include "zfs_common.h"
#include "div64.h" #include "div64.h"
block_dev_desc_t *zfs_dev_desc; struct blk_desc *zfs_dev_desc;
/* /*
* The zfs plug-in routines for GRUB are: * The zfs plug-in routines for GRUB are:

248
include/blk.h Normal file
View file

@ -0,0 +1,248 @@
/*
* (C) Copyright 2000-2004
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
*
* SPDX-License-Identifier: GPL-2.0+
*/
#ifndef BLK_H
#define BLK_H
#ifdef CONFIG_SYS_64BIT_LBA
typedef uint64_t lbaint_t;
#define LBAFlength "ll"
#else
typedef ulong lbaint_t;
#define LBAFlength "l"
#endif
#define LBAF "%" LBAFlength "x"
#define LBAFU "%" LBAFlength "u"
/* Interface types: */
enum if_type {
IF_TYPE_UNKNOWN = 0,
IF_TYPE_IDE,
IF_TYPE_SCSI,
IF_TYPE_ATAPI,
IF_TYPE_USB,
IF_TYPE_DOC,
IF_TYPE_MMC,
IF_TYPE_SD,
IF_TYPE_SATA,
IF_TYPE_HOST,
IF_TYPE_COUNT, /* Number of interface types */
};
/*
* With driver model (CONFIG_BLK) this is uclass platform data, accessible
* with dev_get_uclass_platdata(dev)
*/
struct blk_desc {
/*
* TODO: With driver model we should be able to use the parent
* device's uclass instead.
*/
enum if_type if_type; /* type of the interface */
int devnum; /* device number */
unsigned char part_type; /* partition type */
unsigned char target; /* target SCSI ID */
unsigned char lun; /* target LUN */
unsigned char hwpart; /* HW partition, e.g. for eMMC */
unsigned char type; /* device type */
unsigned char removable; /* removable device */
#ifdef CONFIG_LBA48
/* device can use 48bit addr (ATA/ATAPI v7) */
unsigned char lba48;
#endif
lbaint_t lba; /* number of blocks */
unsigned long blksz; /* block size */
int log2blksz; /* for convenience: log2(blksz) */
char vendor[40+1]; /* IDE model, SCSI Vendor */
char product[20+1]; /* IDE Serial no, SCSI product */
char revision[8+1]; /* firmware revision */
#ifdef CONFIG_BLK
struct udevice *bdev;
#else
unsigned long (*block_read)(struct blk_desc *block_dev,
lbaint_t start,
lbaint_t blkcnt,
void *buffer);
unsigned long (*block_write)(struct blk_desc *block_dev,
lbaint_t start,
lbaint_t blkcnt,
const void *buffer);
unsigned long (*block_erase)(struct blk_desc *block_dev,
lbaint_t start,
lbaint_t blkcnt);
void *priv; /* driver private struct pointer */
#endif
};
#define BLOCK_CNT(size, blk_desc) (PAD_COUNT(size, blk_desc->blksz))
#define PAD_TO_BLOCKSIZE(size, blk_desc) \
(PAD_SIZE(size, blk_desc->blksz))
#ifdef CONFIG_BLK
struct udevice;
/* Operations on block devices */
struct blk_ops {
/**
* read() - read from a block device
*
* @dev: Device to read from
* @start: Start block number to read (0=first)
* @blkcnt: Number of blocks to read
* @buffer: Destination buffer for data read
* @return number of blocks read, or -ve error number (see the
* IS_ERR_VALUE() macro
*/
unsigned long (*read)(struct udevice *dev, lbaint_t start,
lbaint_t blkcnt, void *buffer);
/**
* write() - write to a block device
*
* @dev: Device to write to
* @start: Start block number to write (0=first)
* @blkcnt: Number of blocks to write
* @buffer: Source buffer for data to write
* @return number of blocks written, or -ve error number (see the
* IS_ERR_VALUE() macro
*/
unsigned long (*write)(struct udevice *dev, lbaint_t start,
lbaint_t blkcnt, const void *buffer);
/**
* erase() - erase a section of a block device
*
* @dev: Device to (partially) erase
* @start: Start block number to erase (0=first)
* @blkcnt: Number of blocks to erase
* @return number of blocks erased, or -ve error number (see the
* IS_ERR_VALUE() macro
*/
unsigned long (*erase)(struct udevice *dev, lbaint_t start,
lbaint_t blkcnt);
};
#define blk_get_ops(dev) ((struct blk_ops *)(dev)->driver->ops)
/*
* 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.
*/
unsigned long blk_dread(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt, void *buffer);
unsigned long blk_dwrite(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt, const void *buffer);
unsigned long blk_derase(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt);
/**
* blk_get_device() - Find and probe a block device ready for use
*
* @if_type: Interface type (enum if_type_t)
* @devnum: Device number (specific to each interface type)
* @devp: the device, if found
* @return - if found, -ENODEV if no device found, or other -ve error value
*/
int blk_get_device(int if_type, int devnum, struct udevice **devp);
/**
* blk_first_device() - Find the first device for a given interface
*
* The device is probed ready for use
*
* @devnum: Device number (specific to each interface type)
* @devp: the device, if found
* @return 0 if found, -ENODEV if no device, or other -ve error value
*/
int blk_first_device(int if_type, struct udevice **devp);
/**
* blk_next_device() - Find the next device for a given interface
*
* This can be called repeatedly after blk_first_device() to iterate through
* all devices of the given interface type.
*
* The device is probed ready for use
*
* @devp: On entry, the previous device returned. On exit, the next
* device, if found
* @return 0 if found, -ENODEV if no device, or other -ve error value
*/
int blk_next_device(struct udevice **devp);
/**
* blk_create_device() - Create a new block device
*
* @parent: Parent of the new device
* @drv_name: Driver name to use for the block device
* @name: Name for the device
* @if_type: Interface type (enum if_type_t)
* @devnum: Device number, specific to the interface type
* @blksz: Block size of the device in bytes (typically 512)
* @size: Total size of the device in bytes
* @devp: the new device (which has not been probed)
*/
int blk_create_device(struct udevice *parent, const char *drv_name,
const char *name, int if_type, int devnum, int blksz,
lbaint_t size, struct udevice **devp);
/**
* blk_prepare_device() - Prepare a block device for use
*
* This reads partition information from the device if supported.
*
* @dev: Device to prepare
* @return 0 if ok, -ve on error
*/
int blk_prepare_device(struct udevice *dev);
/**
* blk_unbind_all() - Unbind all device of the given interface type
*
* The devices are removed and then unbound.
*
* @if_type: Interface type to unbind
* @return 0 if OK, -ve on error
*/
int blk_unbind_all(int if_type);
#else
#include <errno.h>
/*
* 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 /* !CONFIG_BLK */
#endif

2
include/common.h
View file

@ -807,7 +807,7 @@ void gzwrite_progress_finish(int retcode,
* for files under 4GiB * for files under 4GiB
*/ */
int gzwrite(unsigned char *src, int len, int gzwrite(unsigned char *src, int len,
struct block_dev_desc *dev, struct blk_desc *dev,
unsigned long szwritebuf, unsigned long szwritebuf,
u64 startoffs, u64 startoffs,
u64 szexpected); u64 szexpected);

1
include/configs/UCP1020.h
View file

@ -484,7 +484,6 @@
#define CONFIG_CMD_REGINFO #define CONFIG_CMD_REGINFO
#define CONFIG_CMD_ERRATA #define CONFIG_CMD_ERRATA
#define CONFIG_CMD_CRAMFS #define CONFIG_CMD_CRAMFS
#define CONFIG_CRAMFS_CMDLINE
/* /*
* USB * USB

1
include/configs/km/keymile-common.h
View file

@ -83,7 +83,6 @@
#define CONFIG_MTD_CONCAT #define CONFIG_MTD_CONCAT
#define CONFIG_CMD_CRAMFS #define CONFIG_CMD_CRAMFS
#define CONFIG_CRAMFS_CMDLINE
#ifndef CONFIG_KM_DEF_ENV_BOOTPARAMS #ifndef CONFIG_KM_DEF_ENV_BOOTPARAMS
#define CONFIG_KM_DEF_ENV_BOOTPARAMS \ #define CONFIG_KM_DEF_ENV_BOOTPARAMS \

7
include/configs/sandbox.h
View file

@ -43,6 +43,8 @@
#define CONFIG_CMD_FAT #define CONFIG_CMD_FAT
#define CONFIG_CMD_EXT4 #define CONFIG_CMD_EXT4
#define CONFIG_CMD_EXT4_WRITE #define CONFIG_CMD_EXT4_WRITE
#define CONFIG_CMD_CBFS
#define CONFIG_CMD_CRAMFS
#define CONFIG_CMD_PART #define CONFIG_CMD_PART
#define CONFIG_DOS_PARTITION #define CONFIG_DOS_PARTITION
#define CONFIG_HOST_MAX_DEVICES 4 #define CONFIG_HOST_MAX_DEVICES 4
@ -52,8 +54,11 @@
#define CONFIG_CMD_GPT #define CONFIG_CMD_GPT
#define CONFIG_PARTITION_UUIDS #define CONFIG_PARTITION_UUIDS
#define CONFIG_EFI_PARTITION #define CONFIG_AMIGA_PARTITION
#define CONFIG_DOS_PARTITION #define CONFIG_DOS_PARTITION
#define CONFIG_EFI_PARTITION
#define CONFIG_ISO_PARTITION
#define CONFIG_MAC_PARTITION
/* /*
* Size of malloc() pool, before and after relocation * Size of malloc() pool, before and after relocation

4
include/debug_uart.h
View file

@ -117,13 +117,15 @@ void printhex8(uint value);
#define DEBUG_UART_FUNCS \ #define DEBUG_UART_FUNCS \
void printch(int ch) \ void printch(int ch) \
{ \ { \
if (ch == '\n') \
_debug_uart_putc('\r'); \
_debug_uart_putc(ch); \ _debug_uart_putc(ch); \
} \ } \
\ \
void printascii(const char *str) \ void printascii(const char *str) \
{ \ { \
while (*str) \ while (*str) \
_debug_uart_putc(*str++); \ printch(*str++); \
} \ } \
\ \
static inline void printhex1(uint digit) \ static inline void printhex1(uint digit) \

1
include/dm/uclass-id.h
View file

@ -26,6 +26,7 @@ enum uclass_id {
/* U-Boot uclasses start here - in alphabetical order */ /* U-Boot uclasses start here - in alphabetical order */
UCLASS_ADC, /* Analog-to-digital converter */ UCLASS_ADC, /* Analog-to-digital converter */
UCLASS_BLK, /* Block device */
UCLASS_CLK, /* Clock source, e.g. used by peripherals */ UCLASS_CLK, /* Clock source, e.g. used by peripherals */
UCLASS_CPU, /* CPU, typically part of an SoC */ UCLASS_CPU, /* CPU, typically part of an SoC */
UCLASS_CROS_EC, /* Chrome OS EC */ UCLASS_CROS_EC, /* Chrome OS EC */

15
include/dm/uclass.h
View file

@ -200,10 +200,21 @@ int uclass_get_device_by_phandle(enum uclass_id id, struct udevice *parent,
* *
* @id: Uclass ID to look up * @id: Uclass ID to look up
* @devp: Returns pointer to the first device in that uclass, or NULL if none * @devp: Returns pointer to the first device in that uclass, or NULL if none
* @return 0 if OK (found or not found), -1 on error * @return 0 if OK (found or not found), other -ve on error
*/ */
int uclass_first_device(enum uclass_id id, struct udevice **devp); int uclass_first_device(enum uclass_id id, struct udevice **devp);
/**
* uclass_first_device_err() - Get the first device in a uclass
*
* The device returned is probed if necessary, and ready for use
*
* @id: Uclass ID to look up
* @devp: Returns pointer to the first device in that uclass, or NULL if none
* @return 0 if found, -ENODEV if not found, other -ve on error
*/
int uclass_first_device_err(enum uclass_id id, struct udevice **devp);
/** /**
* uclass_next_device() - Get the next device in a uclass * uclass_next_device() - Get the next device in a uclass
* *
@ -211,7 +222,7 @@ int uclass_first_device(enum uclass_id id, struct udevice **devp);
* *
* @devp: On entry, pointer to device to lookup. On exit, returns pointer * @devp: On entry, pointer to device to lookup. On exit, returns pointer
* to the next device in the same uclass, or NULL if none * to the next device in the same uclass, or NULL if none
* @return 0 if OK (found or not found), -1 on error * @return 0 if OK (found or not found), other -ve on error
*/ */
int uclass_next_device(struct udevice **devp); int uclass_next_device(struct udevice **devp);

6
include/ext4fs.h
View file

@ -110,7 +110,7 @@ struct ext_filesystem {
/* Journal Related */ /* Journal Related */
/* Block Device Descriptor */ /* Block Device Descriptor */
block_dev_desc_t *dev_desc; struct blk_desc *dev_desc;
}; };
extern struct ext2_data *ext4fs_root; extern struct ext2_data *ext4fs_root;
@ -141,9 +141,9 @@ int ext4fs_exists(const char *filename);
int ext4fs_size(const char *filename, loff_t *size); int ext4fs_size(const char *filename, loff_t *size);
void ext4fs_free_node(struct ext2fs_node *node, struct ext2fs_node *currroot); void ext4fs_free_node(struct ext2fs_node *node, struct ext2fs_node *currroot);
int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf); int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf);
void ext4fs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info); void ext4fs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info);
long int read_allocated_block(struct ext2_inode *inode, int fileblock); long int read_allocated_block(struct ext2_inode *inode, int fileblock);
int ext4fs_probe(block_dev_desc_t *fs_dev_desc, int ext4fs_probe(struct blk_desc *fs_dev_desc,
disk_partition_t *fs_partition); disk_partition_t *fs_partition);
int ext4_read_file(const char *filename, void *buf, loff_t offset, loff_t len, int ext4_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
loff_t *actread); loff_t *actread);

4
include/fat.h
View file

@ -203,8 +203,8 @@ int file_fat_read_at(const char *filename, loff_t pos, void *buffer,
loff_t maxsize, loff_t *actread); loff_t maxsize, loff_t *actread);
int file_fat_read(const char *filename, void *buffer, int maxsize); int file_fat_read(const char *filename, void *buffer, int maxsize);
const char *file_getfsname(int idx); const char *file_getfsname(int idx);
int fat_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info); int fat_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info);
int fat_register_device(block_dev_desc_t *dev_desc, int part_no); int fat_register_device(struct blk_desc *dev_desc, int part_no);
int file_fat_write(const char *filename, void *buf, loff_t offset, loff_t len, int file_fat_write(const char *filename, void *buf, loff_t offset, loff_t len,
loff_t *actwrite); loff_t *actwrite);

18
include/ide.h
View file

@ -8,6 +8,8 @@
#ifndef _IDE_H #ifndef _IDE_H
#define _IDE_H #define _IDE_H
#include <blk.h>
#define IDE_BUS(dev) (dev / (CONFIG_SYS_IDE_MAXDEVICE / CONFIG_SYS_IDE_MAXBUS)) #define IDE_BUS(dev) (dev / (CONFIG_SYS_IDE_MAXDEVICE / CONFIG_SYS_IDE_MAXBUS))
#define ATA_CURR_BASE(dev) (CONFIG_SYS_ATA_BASE_ADDR+ide_bus_offset[IDE_BUS(dev)]) #define ATA_CURR_BASE(dev) (CONFIG_SYS_ATA_BASE_ADDR+ide_bus_offset[IDE_BUS(dev)])
@ -26,25 +28,15 @@ extern ulong ide_bus_offset[];
void ide_led(uchar led, uchar status); void ide_led(uchar led, uchar status);
#endif /* CONFIG_IDE_LED */ #endif /* CONFIG_IDE_LED */
#ifdef CONFIG_SYS_64BIT_LBA
typedef uint64_t lbaint_t;
#define LBAFlength "ll"
#else
typedef ulong lbaint_t;
#define LBAFlength "l"
#endif
#define LBAF "%" LBAFlength "x"
#define LBAFU "%" LBAFlength "u"
/* /*
* Function Prototypes * Function Prototypes
*/ */
void ide_init(void); void ide_init(void);
typedef struct block_dev_desc block_dev_desc_t; struct blk_desc;
ulong ide_read(block_dev_desc_t *block_dev, lbaint_t blknr, lbaint_t blkcnt, ulong ide_read(struct blk_desc *block_dev, lbaint_t blknr, lbaint_t blkcnt,
void *buffer); void *buffer);
ulong ide_write(block_dev_desc_t *block_dev, lbaint_t blknr, lbaint_t blkcnt, ulong ide_write(struct blk_desc *block_dev, lbaint_t blknr, lbaint_t blkcnt,
const void *buffer); const void *buffer);
#ifdef CONFIG_IDE_PREINIT #ifdef CONFIG_IDE_PREINIT

Some files were not shown because too many files have changed in this diff Show more