[people/ms/u-boot.git] / drivers / block / blk-uclass.c

/*
 * 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>
#include <dm/uclass-internal.h>

static const char *if_typename_str[IF_TYPE_COUNT] = {
	[IF_TYPE_IDE]		= "ide",
	[IF_TYPE_SCSI]		= "scsi",
	[IF_TYPE_ATAPI]		= "atapi",
	[IF_TYPE_USB]		= "usb",
	[IF_TYPE_DOC]		= "doc",
	[IF_TYPE_MMC]		= "mmc",
	[IF_TYPE_SD]		= "sd",
	[IF_TYPE_SATA]		= "sata",
	[IF_TYPE_HOST]		= "host",
	[IF_TYPE_NVME]		= "nvme",
	[IF_TYPE_EFI]		= "efi",
};

static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
	[IF_TYPE_IDE]		= UCLASS_IDE,
	[IF_TYPE_SCSI]		= UCLASS_SCSI,
	[IF_TYPE_ATAPI]		= UCLASS_INVALID,
	[IF_TYPE_USB]		= UCLASS_MASS_STORAGE,
	[IF_TYPE_DOC]		= UCLASS_INVALID,
	[IF_TYPE_MMC]		= UCLASS_MMC,
	[IF_TYPE_SD]		= UCLASS_INVALID,
	[IF_TYPE_SATA]		= UCLASS_AHCI,
	[IF_TYPE_HOST]		= UCLASS_ROOT,
	[IF_TYPE_NVME]		= UCLASS_NVME,
	[IF_TYPE_EFI]		= UCLASS_EFI,
};

static enum if_type if_typename_to_iftype(const char *if_typename)
{
	int i;

	for (i = 0; i < IF_TYPE_COUNT; i++) {
		if (if_typename_str[i] &&
		    !strcmp(if_typename, if_typename_str[i]))
			return i;
	}

	return IF_TYPE_UNKNOWN;
}

static enum uclass_id if_type_to_uclass_id(enum if_type if_type)
{
	return if_type_uclass_id[if_type];
}

const char *blk_get_if_type_name(enum if_type if_type)
{
	return if_typename_str[if_type];
}

struct blk_desc *blk_get_devnum_by_type(enum if_type if_type, int devnum)
{
	struct blk_desc *desc;
	struct udevice *dev;
	int ret;

	ret = blk_get_device(if_type, devnum, &dev);
	if (ret)
		return NULL;
	desc = dev_get_uclass_platdata(dev);

	return desc;
}

/*
 * This function is complicated with driver model. We look up the interface
 * name in a local table. This gives us an interface type which we can match
 * against the uclass of the block device's parent.
 */
struct blk_desc *blk_get_devnum_by_typename(const char *if_typename, int devnum)
{
	enum uclass_id uclass_id;
	enum if_type if_type;
	struct udevice *dev;
	struct uclass *uc;
	int ret;

	if_type = if_typename_to_iftype(if_typename);
	if (if_type == IF_TYPE_UNKNOWN) {
		debug("%s: Unknown interface type '%s'\n", __func__,
		      if_typename);
		return NULL;
	}
	uclass_id = if_type_to_uclass_id(if_type);
	if (uclass_id == UCLASS_INVALID) {
		debug("%s: Unknown uclass for interface type'\n",
		      if_typename_str[if_type]);
		return NULL;
	}

	ret = uclass_get(UCLASS_BLK, &uc);
	if (ret)
		return NULL;
	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->devnum != devnum)
			continue;

		/* Find out the parent device uclass */
		if (device_get_uclass_id(dev->parent) != uclass_id) {
			debug("%s: parent uclass %d, this dev %d\n", __func__,
			      device_get_uclass_id(dev->parent), uclass_id);
			continue;
		}

		if (device_probe(dev))
			return NULL;

		debug("%s: Device desc %p\n", __func__, desc);
		return desc;
	}
	debug("%s: No device found\n", __func__);

	return NULL;
}

/**
 * get_desc() - Get the block device descriptor for the given device number
 *
 * @if_type:	Interface type
 * @devnum:	Device number (0 = first)
 * @descp:	Returns block device descriptor on success
 * @return 0 on success, -ENODEV if there is no such device and no device
 * with a higher device number, -ENOENT if there is no such device but there
 * is one with a higher number, or other -ve on other error.
 */
static int get_desc(enum if_type if_type, int devnum, struct blk_desc **descp)
{
	bool found_more = false;
	struct udevice *dev;
	struct uclass *uc;
	int ret;

	*descp = NULL;
	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) {
			if (desc->devnum == devnum) {
				ret = device_probe(dev);
				if (ret)
					return ret;

				*descp = desc;
				return 0;
			} else if (desc->devnum > devnum) {
				found_more = true;
			}
		}
	}

	return found_more ? -ENOENT : -ENODEV;
}

int blk_select_hwpart_devnum(enum if_type if_type, int devnum, int hwpart)
{
	struct udevice *dev;
	int ret;

	ret = blk_get_device(if_type, devnum, &dev);
	if (ret)
		return ret;

	return blk_select_hwpart(dev, hwpart);
}

int blk_list_part(enum if_type if_type)
{
	struct blk_desc *desc;
	int devnum, ok;
	int ret;

	for (ok = 0, devnum = 0;; ++devnum) {
		ret = get_desc(if_type, devnum, &desc);
		if (ret == -ENODEV)
			break;
		else if (ret)
			continue;
		if (desc->part_type != PART_TYPE_UNKNOWN) {
			++ok;
			if (devnum)
				putc('\n');
			part_print(desc);
		}
	}
	if (!ok)
		return -ENODEV;

	return 0;
}

int blk_print_part_devnum(enum if_type if_type, int devnum)
{
	struct blk_desc *desc;
	int ret;

	ret = get_desc(if_type, devnum, &desc);
	if (ret)
		return ret;
	if (desc->type == DEV_TYPE_UNKNOWN)
		return -ENOENT;
	part_print(desc);

	return 0;
}

void blk_list_devices(enum if_type if_type)
{
	struct blk_desc *desc;
	int ret;
	int i;

	for (i = 0;; ++i) {
		ret = get_desc(if_type, i, &desc);
		if (ret == -ENODEV)
			break;
		else if (ret)
			continue;
		if (desc->type == DEV_TYPE_UNKNOWN)
			continue;  /* list only known devices */
		printf("Device %d: ", i);
		dev_print(desc);
	}
}

int blk_print_device_num(enum if_type if_type, int devnum)
{
	struct blk_desc *desc;
	int ret;

	ret = get_desc(if_type, devnum, &desc);
	if (ret)
		return ret;
	printf("\nIDE device %d: ", devnum);
	dev_print(desc);

	return 0;
}

int blk_show_device(enum if_type if_type, int devnum)
{
	struct blk_desc *desc;
	int ret;

	printf("\nDevice %d: ", devnum);
	ret = get_desc(if_type, devnum, &desc);
	if (ret == -ENODEV || ret == -ENOENT) {
		printf("unknown device\n");
		return -ENODEV;
	}
	if (ret)
		return ret;
	dev_print(desc);

	if (desc->type == DEV_TYPE_UNKNOWN)
		return -ENOENT;

	return 0;
}

ulong blk_read_devnum(enum if_type if_type, int devnum, lbaint_t start,
		      lbaint_t blkcnt, void *buffer)
{
	struct blk_desc *desc;
	ulong n;
	int ret;

	ret = get_desc(if_type, devnum, &desc);
	if (ret)
		return ret;
	n = blk_dread(desc, start, blkcnt, buffer);
	if (IS_ERR_VALUE(n))
		return n;

	return n;
}

ulong blk_write_devnum(enum if_type if_type, int devnum, lbaint_t start,
		       lbaint_t blkcnt, const void *buffer)
{
	struct blk_desc *desc;
	int ret;

	ret = get_desc(if_type, devnum, &desc);
	if (ret)
		return ret;
	return blk_dwrite(desc, start, blkcnt, buffer);
}

int blk_select_hwpart(struct udevice *dev, int hwpart)
{
	const struct blk_ops *ops = blk_get_ops(dev);

	if (!ops)
		return -ENOSYS;
	if (!ops->select_hwpart)
		return 0;

	return ops->select_hwpart(dev, hwpart);
}

int blk_dselect_hwpart(struct blk_desc *desc, int hwpart)
{
	return blk_select_hwpart(desc->bdev, hwpart);
}

int blk_first_device(int if_type, struct udevice **devp)
{
	struct blk_desc *desc;
	int ret;

	ret = uclass_find_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_find_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_find_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_find_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 0;
		}
	}

	return -ENODEV;
}

int blk_get_device(int if_type, int devnum, struct udevice **devp)
{
	int ret;

	ret = blk_find_device(if_type, devnum, devp);
	if (ret)
		return ret;

	return device_probe(*devp);
}

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);
	ulong blks_read;

	if (!ops->read)
		return -ENOSYS;

	if (blkcache_read(block_dev->if_type, block_dev->devnum,
			  start, blkcnt, block_dev->blksz, buffer))
		return blkcnt;
	blks_read = ops->read(dev, start, blkcnt, buffer);
	if (blks_read == blkcnt)
		blkcache_fill(block_dev->if_type, block_dev->devnum,
			      start, blkcnt, block_dev->blksz, buffer);

	return blks_read;
}

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;

	blkcache_invalidate(block_dev->if_type, block_dev->devnum);
	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;

	blkcache_invalidate(block_dev->if_type, block_dev->devnum);
	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_get_from_parent(struct udevice *parent, struct udevice **devp)
{
	struct udevice *dev;
	enum uclass_id id;
	int ret;

	device_find_first_child(parent, &dev);
	if (!dev) {
		debug("%s: No block device found for parent '%s'\n", __func__,
		      parent->name);
		return -ENODEV;
	}
	id = device_get_uclass_id(dev);
	if (id != UCLASS_BLK) {
		debug("%s: Incorrect uclass %s for block device '%s'\n",
		      __func__, uclass_get_name(id), dev->name);
		return -ENOTBLK;
	}
	ret = device_probe(dev);
	if (ret)
		return ret;
	*devp = dev;

	return 0;
}

int blk_find_max_devnum(enum if_type if_type)
{
	struct udevice *dev;
	int max_devnum = -ENODEV;
	struct uclass *uc;
	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);

		if (desc->if_type == if_type && desc->devnum > max_devnum)
			max_devnum = desc->devnum;
	}

	return max_devnum;
}

static int blk_next_free_devnum(enum if_type if_type)
{
	int ret;

	ret = blk_find_max_devnum(if_type);
	if (ret == -ENODEV)
		return 0;
	if (ret < 0)
		return ret;

	return ret + 1;
}

static int blk_claim_devnum(enum if_type if_type, int devnum)
{
	struct udevice *dev;
	struct uclass *uc;
	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);

		if (desc->if_type == if_type && desc->devnum == devnum) {
			int next = blk_next_free_devnum(if_type);

			if (next < 0)
				return next;
			desc->devnum = next;
			return 0;
		}
	}

	return -ENOENT;
}

int blk_create_device(struct udevice *parent, const char *drv_name,
		      const char *name, int if_type, int devnum, int blksz,
		      lbaint_t lba, struct udevice **devp)
{
	struct blk_desc *desc;
	struct udevice *dev;
	int ret;

	if (devnum == -1) {
		devnum = blk_next_free_devnum(if_type);
	} else {
		ret = blk_claim_devnum(if_type, devnum);
		if (ret < 0 && ret != -ENOENT)
			return ret;
	}
	if (devnum < 0)
		return devnum;
	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 = lba;
	desc->part_type = PART_TYPE_UNKNOWN;
	desc->bdev = dev;
	desc->devnum = devnum;
	*devp = dev;

	return 0;
}

int blk_create_devicef(struct udevice *parent, const char *drv_name,
		       const char *name, int if_type, int devnum, int blksz,
		       lbaint_t lba, struct udevice **devp)
{
	char dev_name[30], *str;
	int ret;

	snprintf(dev_name, sizeof(dev_name), "%s.%s", parent->name, name);
	str = strdup(dev_name);
	if (!str)
		return -ENOMEM;

	ret = blk_create_device(parent, drv_name, str, if_type, devnum,
				blksz, lba, devp);
	if (ret) {
		free(str);
		return ret;
	}
	device_set_name_alloced(*devp);

	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, DM_REMOVE_NORMAL);
			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),
};
Commit	Line	Data
09d71aac SG	1	/*
	2	* Copyright (C) 2016 Google, Inc
	3	* Written by Simon Glass <sjg@chromium.org>
	4	*
	5	* SPDX-License-Identifier: GPL-2.0+
	6	*/
	7
	8	#include <common.h>
	9	#include <blk.h>
	10	#include <dm.h>
	11	#include <dm/device-internal.h>
	12	#include <dm/lists.h>
8a5cbc06	13	#include <dm/uclass-internal.h>
09d71aac	14
d508c82b SG	15	static const char *if_typename_str[IF_TYPE_COUNT] = {
	16	[IF_TYPE_IDE] = "ide",
	17	[IF_TYPE_SCSI] = "scsi",
	18	[IF_TYPE_ATAPI] = "atapi",
	19	[IF_TYPE_USB] = "usb",
	20	[IF_TYPE_DOC] = "doc",
	21	[IF_TYPE_MMC] = "mmc",
	22	[IF_TYPE_SD] = "sd",
	23	[IF_TYPE_SATA] = "sata",
	24	[IF_TYPE_HOST] = "host",
ffab6945	25	[IF_TYPE_NVME] = "nvme",
05ef48a2	26	[IF_TYPE_EFI] = "efi",
d508c82b SG	27	};
	28
	29	static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
68e6f221	30	[IF_TYPE_IDE] = UCLASS_IDE,
e8a016b5	31	[IF_TYPE_SCSI] = UCLASS_SCSI,
d508c82b SG	32	[IF_TYPE_ATAPI] = UCLASS_INVALID,
	33	[IF_TYPE_USB] = UCLASS_MASS_STORAGE,
	34	[IF_TYPE_DOC] = UCLASS_INVALID,
	35	[IF_TYPE_MMC] = UCLASS_MMC,
	36	[IF_TYPE_SD] = UCLASS_INVALID,
	37	[IF_TYPE_SATA] = UCLASS_AHCI,
	38	[IF_TYPE_HOST] = UCLASS_ROOT,
05ef48a2 HS	39	[IF_TYPE_NVME] = UCLASS_NVME,
05ef48a2 HS	40	[IF_TYPE_EFI] = UCLASS_EFI,
d508c82b SG	41	};
	42
	43	static enum if_type if_typename_to_iftype(const char *if_typename)
	44	{
	45	int i;
	46
	47	for (i = 0; i < IF_TYPE_COUNT; i++) {
	48	if (if_typename_str[i] &&
	49	!strcmp(if_typename, if_typename_str[i]))
	50	return i;
	51	}
	52
	53	return IF_TYPE_UNKNOWN;
	54	}
	55
	56	static enum uclass_id if_type_to_uclass_id(enum if_type if_type)
	57	{
	58	return if_type_uclass_id[if_type];
	59	}
	60
6faa4ed7 SG	61	const char *blk_get_if_type_name(enum if_type if_type)
	62	{
	63	return if_typename_str[if_type];
	64	}
	65
d508c82b SG	66	struct blk_desc *blk_get_devnum_by_type(enum if_type if_type, int devnum)
	67	{
	68	struct blk_desc *desc;
	69	struct udevice *dev;
	70	int ret;
	71
	72	ret = blk_get_device(if_type, devnum, &dev);
	73	if (ret)
	74	return NULL;
	75	desc = dev_get_uclass_platdata(dev);
	76
	77	return desc;
	78	}
	79
	80	/*
	81	* This function is complicated with driver model. We look up the interface
	82	* name in a local table. This gives us an interface type which we can match
	83	* against the uclass of the block device's parent.
	84	*/
	85	struct blk_desc blk_get_devnum_by_typename(const char if_typename, int devnum)
	86	{
	87	enum uclass_id uclass_id;
	88	enum if_type if_type;
	89	struct udevice *dev;
	90	struct uclass *uc;
	91	int ret;
	92
	93	if_type = if_typename_to_iftype(if_typename);
	94	if (if_type == IF_TYPE_UNKNOWN) {
	95	debug("%s: Unknown interface type '%s'\n", __func__,
	96	if_typename);
	97	return NULL;
	98	}
	99	uclass_id = if_type_to_uclass_id(if_type);
	100	if (uclass_id == UCLASS_INVALID) {
	101	debug("%s: Unknown uclass for interface type'\n",
	102	if_typename_str[if_type]);
	103	return NULL;
	104	}
	105
	106	ret = uclass_get(UCLASS_BLK, &uc);
	107	if (ret)
	108	return NULL;
	109	uclass_foreach_dev(dev, uc) {
	110	struct blk_desc *desc = dev_get_uclass_platdata(dev);
	111
	112	debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
	113	if_type, devnum, dev->name, desc->if_type, desc->devnum);
	114	if (desc->devnum != devnum)
	115	continue;
	116
	117	/* Find out the parent device uclass */
	118	if (device_get_uclass_id(dev->parent) != uclass_id) {
	119	debug("%s: parent uclass %d, this dev %d\n", __func__,
	120	device_get_uclass_id(dev->parent), uclass_id);
	121	continue;
	122	}
	123
	124	if (device_probe(dev))
	125	return NULL;
	126
	127	debug("%s: Device desc %p\n", __func__, desc);
	128	return desc;
	129	}
130	debug("%s: No device found\n", __func__);
131
132	return NULL;
133	}
134
135	/**
136	* get_desc() - Get the block device descriptor for the given device number
137	*
138	* @if_type: Interface type
139	* @devnum: Device number (0 = first)
140	* @descp: Returns block device descriptor on success
141	* @return 0 on success, -ENODEV if there is no such device and no device
142	* with a higher device number, -ENOENT if there is no such device but there
143	* is one with a higher number, or other -ve on other error.
144	*/
145	static int get_desc(enum if_type if_type, int devnum, struct blk_desc **descp)
146	{
147	bool found_more = false;
148	struct udevice *dev;
149	struct uclass *uc;
150	int ret;
151
152	*descp = NULL;
153	ret = uclass_get(UCLASS_BLK, &uc);
154	if (ret)
155	return ret;
156	uclass_foreach_dev(dev, uc) {
157	struct blk_desc *desc = dev_get_uclass_platdata(dev);
158
159	debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
160	if_type, devnum, dev->name, desc->if_type, desc->devnum);
161	if (desc->if_type == if_type) {
162	if (desc->devnum == devnum) {
163	ret = device_probe(dev);
164	if (ret)
165	return ret;
166
4408f6f4 MS	167	*descp = desc;
4408f6f4 MS	168	return 0;
d508c82b SG	169	} else if (desc->devnum > devnum) {
	170	found_more = true;
	171	}
	172	}
	173	}
	174
	175	return found_more ? -ENOENT : -ENODEV;
	176	}
	177
cd0fb55b SG	178	int blk_select_hwpart_devnum(enum if_type if_type, int devnum, int hwpart)
	179	{
	180	struct udevice *dev;
	181	int ret;
	182
	183	ret = blk_get_device(if_type, devnum, &dev);
	184	if (ret)
	185	return ret;
	186
	187	return blk_select_hwpart(dev, hwpart);
	188	}
	189
d508c82b SG	190	int blk_list_part(enum if_type if_type)
	191	{
	192	struct blk_desc *desc;
	193	int devnum, ok;
	194	int ret;
	195
	196	for (ok = 0, devnum = 0;; ++devnum) {
	197	ret = get_desc(if_type, devnum, &desc);
	198	if (ret == -ENODEV)
	199	break;
	200	else if (ret)
	201	continue;
	202	if (desc->part_type != PART_TYPE_UNKNOWN) {
	203	++ok;
	204	if (devnum)
	205	putc('\n');
	206	part_print(desc);
	207	}
	208	}
	209	if (!ok)
	210	return -ENODEV;
	211
	212	return 0;
	213	}
	214
	215	int blk_print_part_devnum(enum if_type if_type, int devnum)
	216	{
	217	struct blk_desc *desc;
	218	int ret;
	219
	220	ret = get_desc(if_type, devnum, &desc);
	221	if (ret)
	222	return ret;
	223	if (desc->type == DEV_TYPE_UNKNOWN)
	224	return -ENOENT;
	225	part_print(desc);
	226
	227	return 0;
	228	}
	229
	230	void blk_list_devices(enum if_type if_type)
	231	{
	232	struct blk_desc *desc;
	233	int ret;
	234	int i;
	235
	236	for (i = 0;; ++i) {
	237	ret = get_desc(if_type, i, &desc);
	238	if (ret == -ENODEV)
	239	break;
	240	else if (ret)
	241	continue;
	242	if (desc->type == DEV_TYPE_UNKNOWN)
	243	continue; /* list only known devices */
	244	printf("Device %d: ", i);
	245	dev_print(desc);
	246	}
	247	}
	248
	249	int blk_print_device_num(enum if_type if_type, int devnum)
	250	{
	251	struct blk_desc *desc;
	252	int ret;
	253
254	ret = get_desc(if_type, devnum, &desc);
255	if (ret)
256	return ret;
257	printf("\nIDE device %d: ", devnum);
258	dev_print(desc);
259
260	return 0;
261	}
262
263	int blk_show_device(enum if_type if_type, int devnum)
264	{
265	struct blk_desc *desc;
266	int ret;
267
268	printf("\nDevice %d: ", devnum);
269	ret = get_desc(if_type, devnum, &desc);
270	if (ret == -ENODEV \|\| ret == -ENOENT) {
271	printf("unknown device\n");
272	return -ENODEV;
273	}
274	if (ret)
275	return ret;
276	dev_print(desc);
277
278	if (desc->type == DEV_TYPE_UNKNOWN)
279	return -ENOENT;
280
281	return 0;
282	}
283
284	ulong blk_read_devnum(enum if_type if_type, int devnum, lbaint_t start,
285	lbaint_t blkcnt, void *buffer)
286	{
287	struct blk_desc *desc;
288	ulong n;
289	int ret;
290
291	ret = get_desc(if_type, devnum, &desc);
292	if (ret)
293	return ret;
294	n = blk_dread(desc, start, blkcnt, buffer);
295	if (IS_ERR_VALUE(n))
296	return n;
297
d508c82b SG	298	return n;
	299	}
	300
	301	ulong blk_write_devnum(enum if_type if_type, int devnum, lbaint_t start,
	302	lbaint_t blkcnt, const void *buffer)
	303	{
	304	struct blk_desc *desc;
	305	int ret;
	306
	307	ret = get_desc(if_type, devnum, &desc);
	308	if (ret)
	309	return ret;
	310	return blk_dwrite(desc, start, blkcnt, buffer);
	311	}
	312
cd0fb55b SG	313	int blk_select_hwpart(struct udevice *dev, int hwpart)
	314	{
	315	const struct blk_ops *ops = blk_get_ops(dev);
	316
	317	if (!ops)
	318	return -ENOSYS;
	319	if (!ops->select_hwpart)
	320	return 0;
	321
	322	return ops->select_hwpart(dev, hwpart);
	323	}
	324
	325	int blk_dselect_hwpart(struct blk_desc *desc, int hwpart)
	326	{
	327	return blk_select_hwpart(desc->bdev, hwpart);
	328	}
	329
09d71aac SG	330	int blk_first_device(int if_type, struct udevice **devp)
	331	{
	332	struct blk_desc *desc;
	333	int ret;
	334
8a5cbc06	335	ret = uclass_find_first_device(UCLASS_BLK, devp);
09d71aac SG	336	if (ret)
	337	return ret;
	338	if (!*devp)
	339	return -ENODEV;
	340	do {
	341	desc = dev_get_uclass_platdata(*devp);
	342	if (desc->if_type == if_type)
	343	return 0;
8a5cbc06	344	ret = uclass_find_next_device(devp);
09d71aac SG	345	if (ret)
	346	return ret;
	347	} while (*devp);
	348
	349	return -ENODEV;
	350	}
	351
	352	int blk_next_device(struct udevice **devp)
	353	{
	354	struct blk_desc *desc;
	355	int ret, if_type;
	356
	357	desc = dev_get_uclass_platdata(*devp);
	358	if_type = desc->if_type;
	359	do {
8a5cbc06	360	ret = uclass_find_next_device(devp);
09d71aac SG	361	if (ret)
	362	return ret;
	363	if (!*devp)
	364	return -ENODEV;
	365	desc = dev_get_uclass_platdata(*devp);
	366	if (desc->if_type == if_type)
	367	return 0;
	368	} while (1);
	369	}
	370
6139281a	371	int blk_find_device(int if_type, int devnum, struct udevice **devp)
09d71aac SG	372	{
	373	struct uclass *uc;
	374	struct udevice *dev;
	375	int ret;
	376
	377	ret = uclass_get(UCLASS_BLK, &uc);
	378	if (ret)
	379	return ret;
	380	uclass_foreach_dev(dev, uc) {
	381	struct blk_desc *desc = dev_get_uclass_platdata(dev);
	382
	383	debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
	384	if_type, devnum, dev->name, desc->if_type, desc->devnum);
	385	if (desc->if_type == if_type && desc->devnum == devnum) {
	386	*devp = dev;
6139281a	387	return 0;
09d71aac SG	388	}
	389	}
	390
	391	return -ENODEV;
	392	}
	393
6139281a SG	394	int blk_get_device(int if_type, int devnum, struct udevice **devp)
	395	{
	396	int ret;
	397
	398	ret = blk_find_device(if_type, devnum, devp);
	399	if (ret)
	400	return ret;
	401
	402	return device_probe(*devp);
	403	}
	404
09d71aac SG	405	unsigned long blk_dread(struct blk_desc *block_dev, lbaint_t start,
	406	lbaint_t blkcnt, void *buffer)
	407	{
	408	struct udevice *dev = block_dev->bdev;
	409	const struct blk_ops *ops = blk_get_ops(dev);
e40cf34a	410	ulong blks_read;
09d71aac SG	411
	412	if (!ops->read)
	413	return -ENOSYS;
	414
e40cf34a EN	415	if (blkcache_read(block_dev->if_type, block_dev->devnum,
	416	start, blkcnt, block_dev->blksz, buffer))
	417	return blkcnt;
	418	blks_read = ops->read(dev, start, blkcnt, buffer);
	419	if (blks_read == blkcnt)
	420	blkcache_fill(block_dev->if_type, block_dev->devnum,
	421	start, blkcnt, block_dev->blksz, buffer);
	422
	423	return blks_read;
09d71aac SG	424	}
	425
	426	unsigned long blk_dwrite(struct blk_desc *block_dev, lbaint_t start,
	427	lbaint_t blkcnt, const void *buffer)
	428	{
	429	struct udevice *dev = block_dev->bdev;
	430	const struct blk_ops *ops = blk_get_ops(dev);
	431
	432	if (!ops->write)
	433	return -ENOSYS;
	434
e40cf34a	435	blkcache_invalidate(block_dev->if_type, block_dev->devnum);
09d71aac SG	436	return ops->write(dev, start, blkcnt, buffer);
	437	}
	438
	439	unsigned long blk_derase(struct blk_desc *block_dev, lbaint_t start,
	440	lbaint_t blkcnt)
	441	{
	442	struct udevice *dev = block_dev->bdev;
	443	const struct blk_ops *ops = blk_get_ops(dev);
	444
	445	if (!ops->erase)
	446	return -ENOSYS;
	447
e40cf34a	448	blkcache_invalidate(block_dev->if_type, block_dev->devnum);
09d71aac SG	449	return ops->erase(dev, start, blkcnt);
	450	}
	451
	452	int blk_prepare_device(struct udevice *dev)
	453	{
	454	struct blk_desc *desc = dev_get_uclass_platdata(dev);
	455
	456	part_init(desc);
	457
	458	return 0;
	459	}
	460
9f103b9c SG	461	int blk_get_from_parent(struct udevice parent, struct udevice *devp)
	462	{
	463	struct udevice *dev;
	464	enum uclass_id id;
	465	int ret;
	466
	467	device_find_first_child(parent, &dev);
	468	if (!dev) {
	469	debug("%s: No block device found for parent '%s'\n", __func__,
	470	parent->name);
	471	return -ENODEV;
	472	}
	473	id = device_get_uclass_id(dev);
	474	if (id != UCLASS_BLK) {
	475	debug("%s: Incorrect uclass %s for block device '%s'\n",
	476	__func__, uclass_get_name(id), dev->name);
	477	return -ENOTBLK;
	478	}
	479	ret = device_probe(dev);
	480	if (ret)
	481	return ret;
	482	*devp = dev;
	483
	484	return 0;
	485	}
	486
52138fd4 SG	487	int blk_find_max_devnum(enum if_type if_type)
	488	{
	489	struct udevice *dev;
	490	int max_devnum = -ENODEV;
	491	struct uclass *uc;
	492	int ret;
	493
	494	ret = uclass_get(UCLASS_BLK, &uc);
	495	if (ret)
	496	return ret;
	497	uclass_foreach_dev(dev, uc) {
	498	struct blk_desc *desc = dev_get_uclass_platdata(dev);
	499
	500	if (desc->if_type == if_type && desc->devnum > max_devnum)
	501	max_devnum = desc->devnum;
	502	}
	503
	504	return max_devnum;
	505	}
	506
e8abbb53 SG	507	static int blk_next_free_devnum(enum if_type if_type)
	508	{
	509	int ret;
	510
	511	ret = blk_find_max_devnum(if_type);
	512	if (ret == -ENODEV)
	513	return 0;
	514	if (ret < 0)
	515	return ret;
	516
	517	return ret + 1;
	518	}
	519
e48eeb9e SG	520	static int blk_claim_devnum(enum if_type if_type, int devnum)
	521	{
	522	struct udevice *dev;
	523	struct uclass *uc;
	524	int ret;
	525
	526	ret = uclass_get(UCLASS_BLK, &uc);
	527	if (ret)
	528	return ret;
	529	uclass_foreach_dev(dev, uc) {
	530	struct blk_desc *desc = dev_get_uclass_platdata(dev);
	531
	532	if (desc->if_type == if_type && desc->devnum == devnum) {
	533	int next = blk_next_free_devnum(if_type);
	534
	535	if (next < 0)
	536	return next;
	537	desc->devnum = next;
	538	return 0;
	539	}
	540	}
	541
	542	return -ENOENT;
	543	}
	544
09d71aac SG	545	int blk_create_device(struct udevice parent, const char drv_name,
09d71aac SG	546	const char *name, int if_type, int devnum, int blksz,
5fe7702e	547	lbaint_t lba, struct udevice **devp)
09d71aac SG	548	{
	549	struct blk_desc *desc;
	550	struct udevice *dev;
	551	int ret;
	552
52138fd4	553	if (devnum == -1) {
e48eeb9e SG	554	devnum = blk_next_free_devnum(if_type);
	555	} else {
	556	ret = blk_claim_devnum(if_type, devnum);
	557	if (ret < 0 && ret != -ENOENT)
52138fd4	558	return ret;
52138fd4	559	}
e48eeb9e SG	560	if (devnum < 0)
e48eeb9e SG	561	return devnum;
72a85c0d SG	562	ret = device_bind_driver(parent, drv_name, name, &dev);
	563	if (ret)
	564	return ret;
	565	desc = dev_get_uclass_platdata(dev);
	566	desc->if_type = if_type;
	567	desc->blksz = blksz;
5fe7702e	568	desc->lba = lba;
72a85c0d SG	569	desc->part_type = PART_TYPE_UNKNOWN;
72a85c0d SG	570	desc->bdev = dev;
09d71aac SG	571	desc->devnum = devnum;
	572	*devp = dev;
	573
	574	return 0;
	575	}
	576
9107c973 SG	577	int blk_create_devicef(struct udevice parent, const char drv_name,
9107c973 SG	578	const char *name, int if_type, int devnum, int blksz,
5fe7702e	579	lbaint_t lba, struct udevice **devp)
9107c973 SG	580	{
9107c973 SG	581	char dev_name[30], *str;
d0773524	582	int ret;
9107c973 SG	583
	584	snprintf(dev_name, sizeof(dev_name), "%s.%s", parent->name, name);
	585	str = strdup(dev_name);
	586	if (!str)
	587	return -ENOMEM;
	588
d0773524	589	ret = blk_create_device(parent, drv_name, str, if_type, devnum,
5fe7702e	590	blksz, lba, devp);
d0773524 SG	591	if (ret) {
	592	free(str);
	593	return ret;
	594	}
	595	device_set_name_alloced(*devp);
	596
7074b2a3	597	return 0;
9107c973 SG	598	}
9107c973 SG	599
09d71aac SG	600	int blk_unbind_all(int if_type)
	601	{
	602	struct uclass *uc;
	603	struct udevice dev, next;
	604	int ret;
	605
	606	ret = uclass_get(UCLASS_BLK, &uc);
	607	if (ret)
	608	return ret;
	609	uclass_foreach_dev_safe(dev, next, uc) {
	610	struct blk_desc *desc = dev_get_uclass_platdata(dev);
	611
	612	if (desc->if_type == if_type) {
706865af	613	ret = device_remove(dev, DM_REMOVE_NORMAL);
09d71aac SG	614	if (ret)
	615	return ret;
	616	ret = device_unbind(dev);
	617	if (ret)
	618	return ret;
	619	}
	620	}
	621
	622	return 0;
	623	}
	624
	625	UCLASS_DRIVER(blk) = {
	626	.id = UCLASS_BLK,
	627	.name = "blk",
	628	.per_device_platdata_auto_alloc_size = sizeof(struct blk_desc),
	629	};