[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>

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_SYSTEMACE]	= "ace",
	[IF_TYPE_NVME]		= "nvme",
};

static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
	[IF_TYPE_IDE]		= UCLASS_INVALID,
	[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_SYSTEMACE]	= UCLASS_INVALID,
};

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;

	/* flush cache after read */
	flush_cache((ulong)buffer, blkcnt * desc->blksz);

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