[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",
};

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

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_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);
	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_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;
}

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) {
		ret = blk_find_max_devnum(if_type);
		if (ret == -ENODEV)
			devnum = 0;
		else if (ret < 0)
			return ret;
		else
			devnum = ret + 1;
	}
	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 ret;
}

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