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

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2016 Google, Inc
 * Written by Simon Glass <[email protected]>
 */

#include <common.h>
#include <linux/err.h>

struct blk_driver *blk_driver_lookup_type(int if_type)
{
	struct blk_driver *drv = ll_entry_start(struct blk_driver, blk_driver);
	const int n_ents = ll_entry_count(struct blk_driver, blk_driver);
	struct blk_driver *entry;

	for (entry = drv; entry != drv + n_ents; entry++) {
		if (if_type == entry->if_type)
			return entry;
	}

	/* Not found */
	return NULL;
}

static struct blk_driver *blk_driver_lookup_typename(const char *if_typename)
{
	struct blk_driver *drv = ll_entry_start(struct blk_driver, blk_driver);
	const int n_ents = ll_entry_count(struct blk_driver, blk_driver);
	struct blk_driver *entry;

	for (entry = drv; entry != drv + n_ents; entry++) {
		if (!strcmp(if_typename, entry->if_typename))
			return entry;
	}

	/* Not found */
	return NULL;
}

const char *blk_get_if_type_name(enum if_type if_type)
{
	struct blk_driver *drv = blk_driver_lookup_type(if_type);

	return drv ? drv->if_typename : NULL;
}

/**
 * get_desc() - Get the block device descriptor for the given device number
 *
 * @drv:	Legacy block driver
 * @devnum:	Device number (0 = first)
 * @descp:	Returns block device descriptor on success
 * @return 0 on success, -ENODEV if there is no such device, -ENOSYS if the
 * driver does not provide a way to find a device, or other -ve on other
 * error.
 */
static int get_desc(struct blk_driver *drv, int devnum, struct blk_desc **descp)
{
	if (drv->desc) {
		if (devnum < 0 || devnum >= drv->max_devs)
			return -ENODEV;
		*descp = &drv->desc[devnum];
		return 0;
	}
	if (!drv->get_dev)
		return -ENOSYS;

	return drv->get_dev(devnum, descp);
}

#ifdef CONFIG_HAVE_BLOCK_DEVICE
int blk_list_part(enum if_type if_type)
{
	struct blk_driver *drv;
	struct blk_desc *desc;
	int devnum, ok;
	bool first = true;

	drv = blk_driver_lookup_type(if_type);
	if (!drv)
		return -ENOSYS;
	for (ok = 0, devnum = 0; devnum < drv->max_devs; ++devnum) {
		if (get_desc(drv, devnum, &desc))
			continue;
		if (desc->part_type != PART_TYPE_UNKNOWN) {
			++ok;
			if (!first)
				putc('\n');
			part_print(desc);
			first = false;
		}
	}
	if (!ok)
		return -ENODEV;

	return 0;
}

int blk_print_part_devnum(enum if_type if_type, int devnum)
{
	struct blk_driver *drv = blk_driver_lookup_type(if_type);
	struct blk_desc *desc;
	int ret;

	if (!drv)
		return -ENOSYS;
	ret = get_desc(drv, 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_driver *drv = blk_driver_lookup_type(if_type);
	struct blk_desc *desc;
	int i;

	if (!drv)
		return;
	for (i = 0; i < drv->max_devs; ++i) {
		if (get_desc(drv, i, &desc))
			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_driver *drv = blk_driver_lookup_type(if_type);
	struct blk_desc *desc;
	int ret;

	if (!drv)
		return -ENOSYS;
	ret = get_desc(drv, devnum, &desc);
	if (ret)
		return ret;
	printf("\n%s device %d: ", drv->if_typename, devnum);
	dev_print(desc);

	return 0;
}

int blk_show_device(enum if_type if_type, int devnum)
{
	struct blk_driver *drv = blk_driver_lookup_type(if_type);
	struct blk_desc *desc;
	int ret;

	if (!drv)
		return -ENOSYS;
	printf("\nDevice %d: ", devnum);
	if (devnum >= drv->max_devs) {
		puts("unknown device\n");
		return -ENODEV;
	}
	ret = get_desc(drv, devnum, &desc);
	if (ret)
		return ret;
	dev_print(desc);

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

	return 0;
}
#endif /* CONFIG_HAVE_BLOCK_DEVICE */

struct blk_desc *blk_get_devnum_by_type(enum if_type if_type, int devnum)
{
	struct blk_driver *drv = blk_driver_lookup_type(if_type);
	struct blk_desc *desc;

	if (!drv)
		return NULL;

	if (get_desc(drv, devnum, &desc))
		return NULL;

	return desc;
}

int blk_dselect_hwpart(struct blk_desc *desc, int hwpart)
{
	struct blk_driver *drv = blk_driver_lookup_type(desc->if_type);

	if (!drv)
		return -ENOSYS;
	if (drv->select_hwpart)
		return drv->select_hwpart(desc, hwpart);

	return 0;
}

struct blk_desc *blk_get_devnum_by_typename(const char *if_typename, int devnum)
{
	struct blk_driver *drv = blk_driver_lookup_typename(if_typename);
	struct blk_desc *desc;

	if (!drv)
		return NULL;

	if (get_desc(drv, devnum, &desc))
		return NULL;

	return desc;
}

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

	if (!drv)
		return -ENOSYS;
	ret = get_desc(drv, devnum, &desc);
	if (ret)
		return ret;
	n = desc->block_read(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_driver *drv = blk_driver_lookup_type(if_type);
	struct blk_desc *desc;
	int ret;

	if (!drv)
		return -ENOSYS;
	ret = get_desc(drv, devnum, &desc);
	if (ret)
		return ret;
	return desc->block_write(desc, start, blkcnt, buffer);
}

int blk_select_hwpart_devnum(enum if_type if_type, int devnum, int hwpart)
{
	struct blk_driver *drv = blk_driver_lookup_type(if_type);
	struct blk_desc *desc;
	int ret;

	if (!drv)
		return -ENOSYS;
	ret = get_desc(drv, devnum, &desc);
	if (ret)
		return ret;
	return drv->select_hwpart(desc, hwpart);
}
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
6eef6eac SG	2	/*
	3	* Copyright (C) 2016 Google, Inc
	4	* Written by Simon Glass <[email protected]>
6eef6eac SG	5	*/
	6
	7	#include <common.h>
	8	#include <linux/err.h>
	9
	10	struct blk_driver *blk_driver_lookup_type(int if_type)
	11	{
	12	struct blk_driver *drv = ll_entry_start(struct blk_driver, blk_driver);
	13	const int n_ents = ll_entry_count(struct blk_driver, blk_driver);
	14	struct blk_driver *entry;
	15
	16	for (entry = drv; entry != drv + n_ents; entry++) {
	17	if (if_type == entry->if_type)
	18	return entry;
	19	}
	20
	21	/* Not found */
	22	return NULL;
	23	}
	24
	25	static struct blk_driver blk_driver_lookup_typename(const char if_typename)
	26	{
	27	struct blk_driver *drv = ll_entry_start(struct blk_driver, blk_driver);
	28	const int n_ents = ll_entry_count(struct blk_driver, blk_driver);
	29	struct blk_driver *entry;
	30
	31	for (entry = drv; entry != drv + n_ents; entry++) {
	32	if (!strcmp(if_typename, entry->if_typename))
	33	return entry;
	34	}
	35
	36	/* Not found */
	37	return NULL;
	38	}
	39
6faa4ed7 SG	40	const char *blk_get_if_type_name(enum if_type if_type)
	41	{
	42	struct blk_driver *drv = blk_driver_lookup_type(if_type);
	43
	44	return drv ? drv->if_typename : NULL;
	45	}
	46
6eef6eac SG	47	/**
	48	* get_desc() - Get the block device descriptor for the given device number
	49	*
	50	* @drv: Legacy block driver
	51	* @devnum: Device number (0 = first)
	52	* @descp: Returns block device descriptor on success
	53	* @return 0 on success, -ENODEV if there is no such device, -ENOSYS if the
	54	* driver does not provide a way to find a device, or other -ve on other
	55	* error.
	56	*/
	57	static int get_desc(struct blk_driver drv, int devnum, struct blk_desc *descp)
	58	{
	59	if (drv->desc) {
	60	if (devnum < 0 \|\| devnum >= drv->max_devs)
	61	return -ENODEV;
	62	*descp = &drv->desc[devnum];
	63	return 0;
	64	}
	65	if (!drv->get_dev)
	66	return -ENOSYS;
	67
	68	return drv->get_dev(devnum, descp);
	69	}
	70
1811a928	71	#ifdef CONFIG_HAVE_BLOCK_DEVICE
6eef6eac SG	72	int blk_list_part(enum if_type if_type)
	73	{
	74	struct blk_driver *drv;
	75	struct blk_desc *desc;
	76	int devnum, ok;
	77	bool first = true;
	78
	79	drv = blk_driver_lookup_type(if_type);
	80	if (!drv)
	81	return -ENOSYS;
	82	for (ok = 0, devnum = 0; devnum < drv->max_devs; ++devnum) {
	83	if (get_desc(drv, devnum, &desc))
	84	continue;
	85	if (desc->part_type != PART_TYPE_UNKNOWN) {
	86	++ok;
	87	if (!first)
	88	putc('\n');
	89	part_print(desc);
	90	first = false;
	91	}
	92	}
	93	if (!ok)
	94	return -ENODEV;
	95
	96	return 0;
	97	}
	98
	99	int blk_print_part_devnum(enum if_type if_type, int devnum)
	100	{
	101	struct blk_driver *drv = blk_driver_lookup_type(if_type);
	102	struct blk_desc *desc;
	103	int ret;
	104
	105	if (!drv)
	106	return -ENOSYS;
	107	ret = get_desc(drv, devnum, &desc);
	108	if (ret)
	109	return ret;
	110	if (desc->type == DEV_TYPE_UNKNOWN)
	111	return -ENOENT;
	112	part_print(desc);
	113
	114	return 0;
	115	}
	116
	117	void blk_list_devices(enum if_type if_type)
	118	{
	119	struct blk_driver *drv = blk_driver_lookup_type(if_type);
	120	struct blk_desc *desc;
	121	int i;
	122
	123	if (!drv)
	124	return;
	125	for (i = 0; i < drv->max_devs; ++i) {
	126	if (get_desc(drv, i, &desc))
	127	continue;
	128	if (desc->type == DEV_TYPE_UNKNOWN)
	129	continue; /* list only known devices */
	130	printf("Device %d: ", i);
	131	dev_print(desc);
	132	}
	133	}
	134
	135	int blk_print_device_num(enum if_type if_type, int devnum)
136	{
137	struct blk_driver *drv = blk_driver_lookup_type(if_type);
138	struct blk_desc *desc;
139	int ret;
140
141	if (!drv)
142	return -ENOSYS;
143	ret = get_desc(drv, devnum, &desc);
144	if (ret)
145	return ret;
146	printf("\n%s device %d: ", drv->if_typename, devnum);
147	dev_print(desc);
148
149	return 0;
150	}
151
152	int blk_show_device(enum if_type if_type, int devnum)
153	{
154	struct blk_driver *drv = blk_driver_lookup_type(if_type);
155	struct blk_desc *desc;
156	int ret;
157
158	if (!drv)
159	return -ENOSYS;
160	printf("\nDevice %d: ", devnum);
161	if (devnum >= drv->max_devs) {
162	puts("unknown device\n");
163	return -ENODEV;
164	}
165	ret = get_desc(drv, devnum, &desc);
166	if (ret)
167	return ret;
168	dev_print(desc);
169
170	if (desc->type == DEV_TYPE_UNKNOWN)
171	return -ENOENT;
172
173	return 0;
174	}
1811a928	175	#endif /* CONFIG_HAVE_BLOCK_DEVICE */
6eef6eac SG	176
	177	struct blk_desc *blk_get_devnum_by_type(enum if_type if_type, int devnum)
	178	{
	179	struct blk_driver *drv = blk_driver_lookup_type(if_type);
	180	struct blk_desc *desc;
	181
	182	if (!drv)
	183	return NULL;
	184
	185	if (get_desc(drv, devnum, &desc))
	186	return NULL;
	187
	188	return desc;
	189	}
	190
	191	int blk_dselect_hwpart(struct blk_desc *desc, int hwpart)
	192	{
	193	struct blk_driver *drv = blk_driver_lookup_type(desc->if_type);
	194
	195	if (!drv)
	196	return -ENOSYS;
	197	if (drv->select_hwpart)
	198	return drv->select_hwpart(desc, hwpart);
	199
	200	return 0;
	201	}
	202
	203	struct blk_desc blk_get_devnum_by_typename(const char if_typename, int devnum)
	204	{
	205	struct blk_driver *drv = blk_driver_lookup_typename(if_typename);
	206	struct blk_desc *desc;
	207
	208	if (!drv)
	209	return NULL;
	210
	211	if (get_desc(drv, devnum, &desc))
	212	return NULL;
	213
	214	return desc;
	215	}
	216
	217	ulong blk_read_devnum(enum if_type if_type, int devnum, lbaint_t start,
	218	lbaint_t blkcnt, void *buffer)
	219	{
	220	struct blk_driver *drv = blk_driver_lookup_type(if_type);
	221	struct blk_desc *desc;
	222	ulong n;
	223	int ret;
	224
	225	if (!drv)
	226	return -ENOSYS;
	227	ret = get_desc(drv, devnum, &desc);
	228	if (ret)
	229	return ret;
	230	n = desc->block_read(desc, start, blkcnt, buffer);
	231	if (IS_ERR_VALUE(n))
	232	return n;
	233
6eef6eac SG	234	return n;
	235	}
	236
	237	ulong blk_write_devnum(enum if_type if_type, int devnum, lbaint_t start,
	238	lbaint_t blkcnt, const void *buffer)
	239	{
	240	struct blk_driver *drv = blk_driver_lookup_type(if_type);
	241	struct blk_desc *desc;
	242	int ret;
	243
	244	if (!drv)
	245	return -ENOSYS;
	246	ret = get_desc(drv, devnum, &desc);
	247	if (ret)
	248	return ret;
	249	return desc->block_write(desc, start, blkcnt, buffer);
	250	}
	251
	252	int blk_select_hwpart_devnum(enum if_type if_type, int devnum, int hwpart)
	253	{
	254	struct blk_driver *drv = blk_driver_lookup_type(if_type);
	255	struct blk_desc *desc;
	256	int ret;
	257
	258	if (!drv)
	259	return -ENOSYS;
	260	ret = get_desc(drv, devnum, &desc);
	261	if (ret)
	262	return ret;
	263	return drv->select_hwpart(desc, hwpart);
	264	}