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

/*
 * Copyright (C) 2016 Google, Inc
 * Written by Simon Glass <[email protected]>
 *
 * 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;

			} else if (desc->devnum > devnum) {
				found_more = true;
			}
		}
	}

	return found_more ? -ENOENT : -ENODEV;
}

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

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

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

	return blk_create_device(parent, drv_name, str, if_type, devnum,
				 blksz, size, devp);
}

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 <[email protected]>
	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,
	29	[IF_TYPE_SCSI] = UCLASS_INVALID,
	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
159	} else if (desc->devnum > devnum) {
160	found_more = true;
161	}
162	}
163	}
164
165	return found_more ? -ENOENT : -ENODEV;
166	}
167
168	int blk_list_part(enum if_type if_type)
169	{
170	struct blk_desc *desc;
171	int devnum, ok;
172	int ret;
173
174	for (ok = 0, devnum = 0;; ++devnum) {
175	ret = get_desc(if_type, devnum, &desc);
176	if (ret == -ENODEV)
177	break;
178	else if (ret)
179	continue;
180	if (desc->part_type != PART_TYPE_UNKNOWN) {
181	++ok;
182	if (devnum)
183	putc('\n');
184	part_print(desc);
185	}
186	}
187	if (!ok)
188	return -ENODEV;
189
190	return 0;
191	}
192
193	int blk_print_part_devnum(enum if_type if_type, int devnum)
194	{
195	struct blk_desc *desc;
196	int ret;
197
198	ret = get_desc(if_type, devnum, &desc);
199	if (ret)
200	return ret;
201	if (desc->type == DEV_TYPE_UNKNOWN)
202	return -ENOENT;
203	part_print(desc);
204
205	return 0;
206	}
207
208	void blk_list_devices(enum if_type if_type)
209	{
210	struct blk_desc *desc;
211	int ret;
212	int i;
213
214	for (i = 0;; ++i) {
215	ret = get_desc(if_type, i, &desc);
216	if (ret == -ENODEV)
217	break;
218	else if (ret)
219	continue;
220	if (desc->type == DEV_TYPE_UNKNOWN)
221	continue; /* list only known devices */
222	printf("Device %d: ", i);
223	dev_print(desc);
224	}
225	}
226
227	int blk_print_device_num(enum if_type if_type, int devnum)
228	{
229	struct blk_desc *desc;
230	int ret;
231
232	ret = get_desc(if_type, devnum, &desc);
233	if (ret)
234	return ret;
235	printf("\nIDE device %d: ", devnum);
236	dev_print(desc);
237
238	return 0;
239	}
240
241	int blk_show_device(enum if_type if_type, int devnum)
242	{
243	struct blk_desc *desc;
244	int ret;
245
246	printf("\nDevice %d: ", devnum);
247	ret = get_desc(if_type, devnum, &desc);
248	if (ret == -ENODEV \|\| ret == -ENOENT) {
249	printf("unknown device\n");
250	return -ENODEV;
251	}
252	if (ret)
253	return ret;
254	dev_print(desc);
255
256	if (desc->type == DEV_TYPE_UNKNOWN)
257	return -ENOENT;
258
259	return 0;
260	}
261
262	ulong blk_read_devnum(enum if_type if_type, int devnum, lbaint_t start,
263	lbaint_t blkcnt, void *buffer)
264	{
265	struct blk_desc *desc;
266	ulong n;
267	int ret;
268
269	ret = get_desc(if_type, devnum, &desc);
270	if (ret)
271	return ret;
272	n = blk_dread(desc, start, blkcnt, buffer);
273	if (IS_ERR_VALUE(n))
274	return n;
275
276	/* flush cache after read */
277	flush_cache((ulong)buffer, blkcnt * desc->blksz);
278
279	return n;
280	}
281
282	ulong blk_write_devnum(enum if_type if_type, int devnum, lbaint_t start,
283	lbaint_t blkcnt, const void *buffer)
284	{
285	struct blk_desc *desc;
286	int ret;
287
288	ret = get_desc(if_type, devnum, &desc);
289	if (ret)
290	return ret;
291	return blk_dwrite(desc, start, blkcnt, buffer);
292	}
293
09d71aac SG	294	int blk_first_device(int if_type, struct udevice **devp)
	295	{
	296	struct blk_desc *desc;
	297	int ret;
	298
	299	ret = uclass_first_device(UCLASS_BLK, devp);
	300	if (ret)
	301	return ret;
	302	if (!*devp)
	303	return -ENODEV;
	304	do {
	305	desc = dev_get_uclass_platdata(*devp);
	306	if (desc->if_type == if_type)
	307	return 0;
	308	ret = uclass_next_device(devp);
	309	if (ret)
	310	return ret;
	311	} while (*devp);
	312
	313	return -ENODEV;
	314	}
	315
	316	int blk_next_device(struct udevice **devp)
	317	{
	318	struct blk_desc *desc;
	319	int ret, if_type;
	320
	321	desc = dev_get_uclass_platdata(*devp);
	322	if_type = desc->if_type;
	323	do {
	324	ret = uclass_next_device(devp);
	325	if (ret)
	326	return ret;
	327	if (!*devp)
	328	return -ENODEV;
	329	desc = dev_get_uclass_platdata(*devp);
	330	if (desc->if_type == if_type)
	331	return 0;
	332	} while (1);
	333	}
	334
	335	int blk_get_device(int if_type, int devnum, struct udevice **devp)
	336	{
	337	struct uclass *uc;
	338	struct udevice *dev;
	339	int ret;
	340
	341	ret = uclass_get(UCLASS_BLK, &uc);
	342	if (ret)
	343	return ret;
	344	uclass_foreach_dev(dev, uc) {
	345	struct blk_desc *desc = dev_get_uclass_platdata(dev);
	346
	347	debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
	348	if_type, devnum, dev->name, desc->if_type, desc->devnum);
	349	if (desc->if_type == if_type && desc->devnum == devnum) {
	350	*devp = dev;
	351	return device_probe(dev);
	352	}
	353	}
	354
	355	return -ENODEV;
	356	}
	357
358	unsigned long blk_dread(struct blk_desc *block_dev, lbaint_t start,
359	lbaint_t blkcnt, void *buffer)
360	{
361	struct udevice *dev = block_dev->bdev;
362	const struct blk_ops *ops = blk_get_ops(dev);
e40cf34a	363	ulong blks_read;
09d71aac SG	364
	365	if (!ops->read)
	366	return -ENOSYS;
	367
e40cf34a EN	368	if (blkcache_read(block_dev->if_type, block_dev->devnum,
	369	start, blkcnt, block_dev->blksz, buffer))
	370	return blkcnt;
	371	blks_read = ops->read(dev, start, blkcnt, buffer);
	372	if (blks_read == blkcnt)
	373	blkcache_fill(block_dev->if_type, block_dev->devnum,
	374	start, blkcnt, block_dev->blksz, buffer);
	375
	376	return blks_read;
09d71aac SG	377	}
	378
	379	unsigned long blk_dwrite(struct blk_desc *block_dev, lbaint_t start,
	380	lbaint_t blkcnt, const void *buffer)
	381	{
	382	struct udevice *dev = block_dev->bdev;
	383	const struct blk_ops *ops = blk_get_ops(dev);
	384
	385	if (!ops->write)
	386	return -ENOSYS;
	387
e40cf34a	388	blkcache_invalidate(block_dev->if_type, block_dev->devnum);
09d71aac SG	389	return ops->write(dev, start, blkcnt, buffer);
	390	}
	391
	392	unsigned long blk_derase(struct blk_desc *block_dev, lbaint_t start,
	393	lbaint_t blkcnt)
	394	{
	395	struct udevice *dev = block_dev->bdev;
	396	const struct blk_ops *ops = blk_get_ops(dev);
	397
	398	if (!ops->erase)
	399	return -ENOSYS;
	400
e40cf34a	401	blkcache_invalidate(block_dev->if_type, block_dev->devnum);
09d71aac SG	402	return ops->erase(dev, start, blkcnt);
	403	}
	404
	405	int blk_prepare_device(struct udevice *dev)
	406	{
	407	struct blk_desc *desc = dev_get_uclass_platdata(dev);
	408
	409	part_init(desc);
	410
	411	return 0;
	412	}
	413
52138fd4 SG	414	int blk_find_max_devnum(enum if_type if_type)
	415	{
	416	struct udevice *dev;
	417	int max_devnum = -ENODEV;
	418	struct uclass *uc;
	419	int ret;
	420
	421	ret = uclass_get(UCLASS_BLK, &uc);
	422	if (ret)
	423	return ret;
	424	uclass_foreach_dev(dev, uc) {
	425	struct blk_desc *desc = dev_get_uclass_platdata(dev);
	426
	427	if (desc->if_type == if_type && desc->devnum > max_devnum)
	428	max_devnum = desc->devnum;
	429	}
	430
	431	return max_devnum;
	432	}
	433
09d71aac SG	434	int blk_create_device(struct udevice parent, const char drv_name,
	435	const char *name, int if_type, int devnum, int blksz,
	436	lbaint_t size, struct udevice **devp)
	437	{
	438	struct blk_desc *desc;
	439	struct udevice *dev;
	440	int ret;
	441
	442	ret = device_bind_driver(parent, drv_name, name, &dev);
	443	if (ret)
	444	return ret;
	445	desc = dev_get_uclass_platdata(dev);
	446	desc->if_type = if_type;
	447	desc->blksz = blksz;
	448	desc->lba = size / blksz;
	449	desc->part_type = PART_TYPE_UNKNOWN;
	450	desc->bdev = dev;
52138fd4 SG	451	if (devnum == -1) {
	452	ret = blk_find_max_devnum(if_type);
	453	if (ret == -ENODEV)
	454	devnum = 0;
	455	else if (ret < 0)
	456	return ret;
	457	else
	458	devnum = ret + 1;
	459	}
09d71aac SG	460	desc->devnum = devnum;
	461	*devp = dev;
	462
	463	return 0;
	464	}
	465
9107c973 SG	466	int blk_create_devicef(struct udevice parent, const char drv_name,
	467	const char *name, int if_type, int devnum, int blksz,
	468	lbaint_t size, struct udevice **devp)
	469	{
	470	char dev_name[30], *str;
	471
	472	snprintf(dev_name, sizeof(dev_name), "%s.%s", parent->name, name);
	473	str = strdup(dev_name);
	474	if (!str)
	475	return -ENOMEM;
	476
	477	return blk_create_device(parent, drv_name, str, if_type, devnum,
	478	blksz, size, devp);
	479	}
	480
09d71aac SG	481	int blk_unbind_all(int if_type)
	482	{
	483	struct uclass *uc;
	484	struct udevice dev, next;
	485	int ret;
	486
	487	ret = uclass_get(UCLASS_BLK, &uc);
	488	if (ret)
	489	return ret;
	490	uclass_foreach_dev_safe(dev, next, uc) {
	491	struct blk_desc *desc = dev_get_uclass_platdata(dev);
	492
	493	if (desc->if_type == if_type) {
	494	ret = device_remove(dev);
	495	if (ret)
	496	return ret;
	497	ret = device_unbind(dev);
	498	if (ret)
	499	return ret;
	500	}
	501	}
	502
	503	return 0;
	504	}
	505
	506	UCLASS_DRIVER(blk) = {
	507	.id = UCLASS_BLK,
	508	.name = "blk",
	509	.per_device_platdata_auto_alloc_size = sizeof(struct blk_desc),
	510	};