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

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

#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 <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_priv(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_priv(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);
		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), &dev);
	if (ret)
		goto err_file;
	ret = device_probe(dev);
	if (ret) {
		device_unbind(dev);
		goto err_file;
	}

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

	return blk_prepare_device(dev);
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,
	.priv_auto_alloc_size	= 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
f4d8de48 HN	1	/*
	2	* Copyright (C) 2013 Henrik Nordstrom <[email protected]>
	3	*
	4	* SPDX-License-Identifier: GPL-2.0+
	5	*/
	6
f4d8de48	7	#include <common.h>
40fd0508 SG	8	#include <blk.h>
	9	#include <dm.h>
	10	#include <fdtdec.h>
f4d8de48 HN	11	#include <part.h>
	12	#include <os.h>
	13	#include <malloc.h>
	14	#include <sandboxblockdev.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	{
	37	struct host_block_dev *host_dev = dev_get_priv(dev);
	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	{
	68	struct host_block_dev *host_dev = dev_get_priv(dev);
	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) {
	101	ret = device_remove(dev);
	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,
	132	os_lseek(fd, 0, OS_SEEK_END), &dev);
	133	if (ret)
	134	goto err_file;
	135	ret = device_probe(dev);
	136	if (ret) {
	137	device_unbind(dev);
	138	goto err_file;
	139	}
	140
	141	host_dev = dev_get_priv(dev);
	142	host_dev->fd = fd;
	143	host_dev->filename = fname;
	144
	145	return blk_prepare_device(dev);
	146	err_file:
	147	os_close(fd);
	148	err:
	149	free(fname);
	150	free(str);
	151	return ret;
	152	}
e161356b SG	153	#else
	154	int host_dev_bind(int dev, char *filename)
	155	{
	156	struct host_block_dev *host_dev = find_host_device(dev);
	157
	158	if (!host_dev)
	159	return -1;
	160	if (host_dev->blk_dev.priv) {
	161	os_close(host_dev->fd);
	162	host_dev->blk_dev.priv = NULL;
	163	}
	164	if (host_dev->filename)
	165	free(host_dev->filename);
	166	if (filename && *filename) {
	167	host_dev->filename = strdup(filename);
	168	} else {
	169	host_dev->filename = NULL;
	170	return 0;
	171	}
	172
	173	host_dev->fd = os_open(host_dev->filename, OS_O_RDWR);
	174	if (host_dev->fd == -1) {
	175	printf("Failed to access host backing file '%s'\n",
	176	host_dev->filename);
	177	return 1;
	178	}
	179
	180	struct blk_desc *blk_dev = &host_dev->blk_dev;
	181	blk_dev->if_type = IF_TYPE_HOST;
	182	blk_dev->priv = host_dev;
	183	blk_dev->blksz = 512;
	184	blk_dev->lba = os_lseek(host_dev->fd, 0, OS_SEEK_END) / blk_dev->blksz;
	185	blk_dev->block_read = host_block_read;
	186	blk_dev->block_write = host_block_write;
	187	blk_dev->devnum = dev;
	188	blk_dev->part_type = PART_TYPE_UNKNOWN;
	189	part_init(blk_dev);
	190
	191	return 0;
	192	}
	193	#endif
f4d8de48	194
7ded959e	195	int host_get_dev_err(int devnum, struct blk_desc **blk_devp)
f4d8de48	196	{
e161356b	197	#ifdef CONFIG_BLK
40fd0508 SG	198	struct udevice *dev;
	199	int ret;
	200
	201	ret = blk_get_device(IF_TYPE_HOST, devnum, &dev);
	202	if (ret)
	203	return ret;
	204	*blk_devp = dev_get_uclass_platdata(dev);
e161356b SG	205	#else
	206	struct host_block_dev *host_dev = find_host_device(devnum);
	207
	208	if (!host_dev)
	209	return -ENODEV;
	210
	211	if (!host_dev->blk_dev.priv)
	212	return -ENOENT;
	213
	214	*blk_devp = &host_dev->blk_dev;
	215	#endif
40fd0508	216
f4d8de48 HN	217	return 0;
	218	}
	219
e161356b	220	#ifdef CONFIG_BLK
40fd0508 SG	221	static const struct blk_ops sandbox_host_blk_ops = {
	222	.read = host_block_read,
	223	.write = host_block_write,
	224	};
	225
	226	U_BOOT_DRIVER(sandbox_host_blk) = {
	227	.name = "sandbox_host_blk",
	228	.id = UCLASS_BLK,
	229	.ops = &sandbox_host_blk_ops,
	230	.priv_auto_alloc_size = sizeof(struct host_block_dev),
	231	};
0cc65a7c SG	232	#else
	233	U_BOOT_LEGACY_BLK(sandbox_host) = {
	234	.if_typename = "host",
	235	.if_type = IF_TYPE_HOST,
	236	.max_devs = CONFIG_HOST_MAX_DEVICES,
	237	.get_dev = host_get_dev_err,
	238	};
e161356b	239	#endif