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

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2013 Henrik Nordstrom <[email protected]>
 */

#include <common.h>
#include <blk.h>
#include <dm.h>
#include <fdtdec.h>
#include <part.h>
#include <os.h>
#include <malloc.h>
#include <sandboxblockdev.h>
#include <dm/device_compat.h>
#include <linux/errno.h>
#include <dm/device-internal.h>

DECLARE_GLOBAL_DATA_PTR;

#ifndef CONFIG_BLK
static struct host_block_dev host_devices[CONFIG_HOST_MAX_DEVICES];

static struct host_block_dev *find_host_device(int dev)
{
	if (dev >= 0 && dev < CONFIG_HOST_MAX_DEVICES)
		return &host_devices[dev];

	return NULL;
}
#endif

#ifdef CONFIG_BLK
static unsigned long host_block_read(struct udevice *dev,
				     unsigned long start, lbaint_t blkcnt,
				     void *buffer)
{
	struct host_block_dev *host_dev = dev_get_platdata(dev);
	struct blk_desc *block_dev = dev_get_uclass_platdata(dev);

#else
static unsigned long host_block_read(struct blk_desc *block_dev,
				     unsigned long start, lbaint_t blkcnt,
				     void *buffer)
{
	int dev = block_dev->devnum;
	struct host_block_dev *host_dev = find_host_device(dev);

	if (!host_dev)
		return -1;
#endif

	if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
			-1) {
		printf("ERROR: Invalid block %lx\n", start);
		return -1;
	}
	ssize_t len = os_read(host_dev->fd, buffer, blkcnt * block_dev->blksz);
	if (len >= 0)
		return len / block_dev->blksz;
	return -1;
}

#ifdef CONFIG_BLK
static unsigned long host_block_write(struct udevice *dev,
				      unsigned long start, lbaint_t blkcnt,
				      const void *buffer)
{
	struct host_block_dev *host_dev = dev_get_platdata(dev);
	struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
#else
static unsigned long host_block_write(struct blk_desc *block_dev,
				      unsigned long start, lbaint_t blkcnt,
				      const void *buffer)
{
	int dev = block_dev->devnum;
	struct host_block_dev *host_dev = find_host_device(dev);
#endif

	if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
			-1) {
		printf("ERROR: Invalid block %lx\n", start);
		return -1;
	}
	ssize_t len = os_write(host_dev->fd, buffer, blkcnt * block_dev->blksz);
	if (len >= 0)
		return len / block_dev->blksz;
	return -1;
}

#ifdef CONFIG_BLK
int host_dev_bind(int devnum, char *filename)
{
	struct host_block_dev *host_dev;
	struct udevice *dev;
	char dev_name[20], *str, *fname;
	int ret, fd;

	/* Remove and unbind the old device, if any */
	ret = blk_get_device(IF_TYPE_HOST, devnum, &dev);
	if (ret == 0) {
		ret = device_remove(dev, DM_REMOVE_NORMAL);
		if (ret)
			return ret;
		ret = device_unbind(dev);
		if (ret)
			return ret;
	} else if (ret != -ENODEV) {
		return ret;
	}

	if (!filename)
		return 0;

	snprintf(dev_name, sizeof(dev_name), "host%d", devnum);
	str = strdup(dev_name);
	if (!str)
		return -ENOMEM;
	fname = strdup(filename);
	if (!fname) {
		free(str);
		return -ENOMEM;
	}

	fd = os_open(filename, OS_O_RDWR);
	if (fd == -1) {
		printf("Failed to access host backing file '%s'\n", filename);
		ret = -ENOENT;
		goto err;
	}
	ret = blk_create_device(gd->dm_root, "sandbox_host_blk", str,
				IF_TYPE_HOST, devnum, 512,
				os_lseek(fd, 0, OS_SEEK_END) / 512, &dev);
	if (ret)
		goto err_file;

	host_dev = dev_get_platdata(dev);
	host_dev->fd = fd;
	host_dev->filename = fname;

	ret = device_probe(dev);
	if (ret) {
		device_unbind(dev);
		goto err_file;
	}

	return 0;
err_file:
	os_close(fd);
err:
	free(fname);
	free(str);
	return ret;
}
#else
int host_dev_bind(int dev, char *filename)
{
	struct host_block_dev *host_dev = find_host_device(dev);

	if (!host_dev)
		return -1;
	if (host_dev->blk_dev.priv) {
		os_close(host_dev->fd);
		host_dev->blk_dev.priv = NULL;
	}
	if (host_dev->filename)
		free(host_dev->filename);
	if (filename && *filename) {
		host_dev->filename = strdup(filename);
	} else {
		host_dev->filename = NULL;
		return 0;
	}

	host_dev->fd = os_open(host_dev->filename, OS_O_RDWR);
	if (host_dev->fd == -1) {
		printf("Failed to access host backing file '%s'\n",
		       host_dev->filename);
		return 1;
	}

	struct blk_desc *blk_dev = &host_dev->blk_dev;
	blk_dev->if_type = IF_TYPE_HOST;
	blk_dev->priv = host_dev;
	blk_dev->blksz = 512;
	blk_dev->lba = os_lseek(host_dev->fd, 0, OS_SEEK_END) / blk_dev->blksz;
	blk_dev->block_read = host_block_read;
	blk_dev->block_write = host_block_write;
	blk_dev->devnum = dev;
	blk_dev->part_type = PART_TYPE_UNKNOWN;
	part_init(blk_dev);

	return 0;
}
#endif

int host_get_dev_err(int devnum, struct blk_desc **blk_devp)
{
#ifdef CONFIG_BLK
	struct udevice *dev;
	int ret;

	ret = blk_get_device(IF_TYPE_HOST, devnum, &dev);
	if (ret)
		return ret;
	*blk_devp = dev_get_uclass_platdata(dev);
#else
	struct host_block_dev *host_dev = find_host_device(devnum);

	if (!host_dev)
		return -ENODEV;

	if (!host_dev->blk_dev.priv)
		return -ENOENT;

	*blk_devp = &host_dev->blk_dev;
#endif

	return 0;
}

#ifdef CONFIG_BLK
static const struct blk_ops sandbox_host_blk_ops = {
	.read	= host_block_read,
	.write	= host_block_write,
};

U_BOOT_DRIVER(sandbox_host_blk) = {
	.name		= "sandbox_host_blk",
	.id		= UCLASS_BLK,
	.ops		= &sandbox_host_blk_ops,
	.platdata_auto	= sizeof(struct host_block_dev),
};
#else
U_BOOT_LEGACY_BLK(sandbox_host) = {
	.if_typename	= "host",
	.if_type	= IF_TYPE_HOST,
	.max_devs	= CONFIG_HOST_MAX_DEVICES,
	.get_dev	= host_get_dev_err,
};
#endif
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
f4d8de48 HN	2	/*
f4d8de48 HN	3	* Copyright (C) 2013 Henrik Nordstrom <[email protected]>
f4d8de48 HN	4	*/
f4d8de48 HN	5
f4d8de48	6	#include <common.h>
40fd0508 SG	7	#include <blk.h>
	8	#include <dm.h>
	9	#include <fdtdec.h>
f4d8de48 HN	10	#include <part.h>
	11	#include <os.h>
	12	#include <malloc.h>
	13	#include <sandboxblockdev.h>
336d4615	14	#include <dm/device_compat.h>
1221ce45	15	#include <linux/errno.h>
40fd0508	16	#include <dm/device-internal.h>
f4d8de48	17
40fd0508 SG	18	DECLARE_GLOBAL_DATA_PTR;
40fd0508 SG	19
e161356b SG	20	#ifndef CONFIG_BLK
	21	static struct host_block_dev host_devices[CONFIG_HOST_MAX_DEVICES];
	22
	23	static struct host_block_dev *find_host_device(int dev)
	24	{
	25	if (dev >= 0 && dev < CONFIG_HOST_MAX_DEVICES)
	26	return &host_devices[dev];
	27
	28	return NULL;
	29	}
	30	#endif
	31
	32	#ifdef CONFIG_BLK
40fd0508 SG	33	static unsigned long host_block_read(struct udevice *dev,
	34	unsigned long start, lbaint_t blkcnt,
	35	void *buffer)
	36	{
8f994c86	37	struct host_block_dev *host_dev = dev_get_platdata(dev);
40fd0508	38	struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
f4d8de48	39
e161356b SG	40	#else
	41	static unsigned long host_block_read(struct blk_desc *block_dev,
	42	unsigned long start, lbaint_t blkcnt,
	43	void *buffer)
	44	{
	45	int dev = block_dev->devnum;
	46	struct host_block_dev *host_dev = find_host_device(dev);
	47
	48	if (!host_dev)
	49	return -1;
	50	#endif
	51
7ded959e SG	52	if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
	53	-1) {
	54	printf("ERROR: Invalid block %lx\n", start);
f4d8de48 HN	55	return -1;
f4d8de48 HN	56	}
7ded959e	57	ssize_t len = os_read(host_dev->fd, buffer, blkcnt * block_dev->blksz);
f4d8de48	58	if (len >= 0)
7ded959e	59	return len / block_dev->blksz;
f4d8de48 HN	60	return -1;
	61	}
	62
e161356b	63	#ifdef CONFIG_BLK
40fd0508 SG	64	static unsigned long host_block_write(struct udevice *dev,
	65	unsigned long start, lbaint_t blkcnt,
	66	const void *buffer)
	67	{
8f994c86	68	struct host_block_dev *host_dev = dev_get_platdata(dev);
40fd0508	69	struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
e161356b SG	70	#else
	71	static unsigned long host_block_write(struct blk_desc *block_dev,
	72	unsigned long start, lbaint_t blkcnt,
	73	const void *buffer)
	74	{
	75	int dev = block_dev->devnum;
	76	struct host_block_dev *host_dev = find_host_device(dev);
	77	#endif
7ded959e SG	78
	79	if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
	80	-1) {
	81	printf("ERROR: Invalid block %lx\n", start);
f4d8de48 HN	82	return -1;
f4d8de48 HN	83	}
7ded959e	84	ssize_t len = os_write(host_dev->fd, buffer, blkcnt * block_dev->blksz);
f4d8de48	85	if (len >= 0)
7ded959e	86	return len / block_dev->blksz;
f4d8de48 HN	87	return -1;
	88	}
	89
e161356b	90	#ifdef CONFIG_BLK
40fd0508 SG	91	int host_dev_bind(int devnum, char *filename)
	92	{
	93	struct host_block_dev *host_dev;
	94	struct udevice *dev;
	95	char dev_name[20], str, fname;
	96	int ret, fd;
	97
	98	/* Remove and unbind the old device, if any */
	99	ret = blk_get_device(IF_TYPE_HOST, devnum, &dev);
	100	if (ret == 0) {
706865af	101	ret = device_remove(dev, DM_REMOVE_NORMAL);
40fd0508 SG	102	if (ret)
	103	return ret;
	104	ret = device_unbind(dev);
	105	if (ret)
	106	return ret;
	107	} else if (ret != -ENODEV) {
	108	return ret;
	109	}
	110
	111	if (!filename)
	112	return 0;
	113
	114	snprintf(dev_name, sizeof(dev_name), "host%d", devnum);
	115	str = strdup(dev_name);
	116	if (!str)
	117	return -ENOMEM;
	118	fname = strdup(filename);
	119	if (!fname) {
	120	free(str);
	121	return -ENOMEM;
	122	}
	123
	124	fd = os_open(filename, OS_O_RDWR);
	125	if (fd == -1) {
	126	printf("Failed to access host backing file '%s'\n", filename);
	127	ret = -ENOENT;
	128	goto err;
	129	}
	130	ret = blk_create_device(gd->dm_root, "sandbox_host_blk", str,
	131	IF_TYPE_HOST, devnum, 512,
5fe7702e	132	os_lseek(fd, 0, OS_SEEK_END) / 512, &dev);
40fd0508 SG	133	if (ret)
40fd0508 SG	134	goto err_file;
8f994c86 BM	135
	136	host_dev = dev_get_platdata(dev);
	137	host_dev->fd = fd;
	138	host_dev->filename = fname;
	139
40fd0508 SG	140	ret = device_probe(dev);
	141	if (ret) {
	142	device_unbind(dev);
	143	goto err_file;
	144	}
	145
d0851c89	146	return 0;
40fd0508 SG	147	err_file:
	148	os_close(fd);
	149	err:
	150	free(fname);
	151	free(str);
	152	return ret;
	153	}
e161356b SG	154	#else
	155	int host_dev_bind(int dev, char *filename)
	156	{
	157	struct host_block_dev *host_dev = find_host_device(dev);
	158
	159	if (!host_dev)
	160	return -1;
	161	if (host_dev->blk_dev.priv) {
	162	os_close(host_dev->fd);
	163	host_dev->blk_dev.priv = NULL;
	164	}
	165	if (host_dev->filename)
	166	free(host_dev->filename);
	167	if (filename && *filename) {
	168	host_dev->filename = strdup(filename);
	169	} else {
	170	host_dev->filename = NULL;
	171	return 0;
	172	}
	173
	174	host_dev->fd = os_open(host_dev->filename, OS_O_RDWR);
	175	if (host_dev->fd == -1) {
	176	printf("Failed to access host backing file '%s'\n",
	177	host_dev->filename);
	178	return 1;
	179	}
	180
	181	struct blk_desc *blk_dev = &host_dev->blk_dev;
	182	blk_dev->if_type = IF_TYPE_HOST;
	183	blk_dev->priv = host_dev;
	184	blk_dev->blksz = 512;
	185	blk_dev->lba = os_lseek(host_dev->fd, 0, OS_SEEK_END) / blk_dev->blksz;
	186	blk_dev->block_read = host_block_read;
	187	blk_dev->block_write = host_block_write;
	188	blk_dev->devnum = dev;
	189	blk_dev->part_type = PART_TYPE_UNKNOWN;
	190	part_init(blk_dev);
	191
	192	return 0;
	193	}
	194	#endif
f4d8de48	195
7ded959e	196	int host_get_dev_err(int devnum, struct blk_desc **blk_devp)
f4d8de48	197	{
e161356b	198	#ifdef CONFIG_BLK
40fd0508 SG	199	struct udevice *dev;
	200	int ret;
	201
	202	ret = blk_get_device(IF_TYPE_HOST, devnum, &dev);
	203	if (ret)
	204	return ret;
	205	*blk_devp = dev_get_uclass_platdata(dev);
e161356b SG	206	#else
	207	struct host_block_dev *host_dev = find_host_device(devnum);
	208
	209	if (!host_dev)
	210	return -ENODEV;
	211
	212	if (!host_dev->blk_dev.priv)
	213	return -ENOENT;
	214
	215	*blk_devp = &host_dev->blk_dev;
	216	#endif
40fd0508	217
f4d8de48 HN	218	return 0;
	219	}
	220
e161356b	221	#ifdef CONFIG_BLK
40fd0508 SG	222	static const struct blk_ops sandbox_host_blk_ops = {
	223	.read = host_block_read,
	224	.write = host_block_write,
	225	};
	226
	227	U_BOOT_DRIVER(sandbox_host_blk) = {
	228	.name = "sandbox_host_blk",
	229	.id = UCLASS_BLK,
	230	.ops = &sandbox_host_blk_ops,
41575d8e	231	.platdata_auto = sizeof(struct host_block_dev),
40fd0508	232	};
0cc65a7c SG	233	#else
	234	U_BOOT_LEGACY_BLK(sandbox_host) = {
	235	.if_typename = "host",
	236	.if_type = IF_TYPE_HOST,
	237	.max_devs = CONFIG_HOST_MAX_DEVICES,
	238	.get_dev = host_get_dev_err,
	239	};
e161356b	240	#endif