[J-u-boot.git] / test / dm / blk.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2015 Google, Inc
 */

#include <common.h>
#include <dm.h>
#include <usb.h>
#include <asm/state.h>
#include <dm/test.h>
#include <test/ut.h>

DECLARE_GLOBAL_DATA_PTR;

/* Test that block devices can be created */
static int dm_test_blk_base(struct unit_test_state *uts)
{
	struct udevice *blk, *usb_blk, *dev;

	/* Make sure there are no block devices */
	ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_BLK, 0, &blk));

	/* Create two, one the parent of the other */
	ut_assertok(blk_create_device(gd->dm_root, "sandbox_host_blk", "test",
				      IF_TYPE_HOST, 1, 512, 2, &blk));
	ut_assertok(blk_create_device(blk, "usb_storage_blk", "test",
				      IF_TYPE_USB, 3, 512, 2, &usb_blk));

	/* Check we can find them */
	ut_asserteq(-ENODEV, blk_get_device(IF_TYPE_HOST, 0, &dev));
	ut_assertok(blk_get_device(IF_TYPE_HOST, 1, &dev));
	ut_asserteq_ptr(blk, dev);

	ut_asserteq(-ENODEV, blk_get_device(IF_TYPE_USB, 0, &dev));
	ut_assertok(blk_get_device(IF_TYPE_USB, 3, &dev));
	ut_asserteq_ptr(usb_blk, dev);

	/* Check we can iterate */
	ut_assertok(blk_first_device(IF_TYPE_HOST, &dev));
	ut_asserteq_ptr(blk, dev);
	ut_asserteq(-ENODEV, blk_next_device(&dev));

	ut_assertok(blk_first_device(IF_TYPE_USB, &dev));
	ut_asserteq_ptr(usb_blk, dev);
	ut_asserteq(-ENODEV, blk_next_device(&dev));

	return 0;
}
DM_TEST(dm_test_blk_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

static int count_blk_devices(void)
{
	struct udevice *blk;
	struct uclass *uc;
	int count = 0;
	int ret;

	ret = uclass_get(UCLASS_BLK, &uc);
	if (ret)
		return ret;

	uclass_foreach_dev(blk, uc)
		count++;

	return count;
}

/* Test that block devices work correctly with USB */
static int dm_test_blk_usb(struct unit_test_state *uts)
{
	struct udevice *usb_dev, *dev;
	struct blk_desc *dev_desc;

	/* Get a flash device */
	state_set_skip_delays(true);
	ut_assertok(usb_init());
	ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &usb_dev));
	ut_assertok(blk_get_device_by_str("usb", "0", &dev_desc));

	/* The parent should be a block device */
	ut_assertok(blk_get_device(IF_TYPE_USB, 0, &dev));
	ut_asserteq_ptr(usb_dev, dev_get_parent(dev));

	/* Check we have one block device for each mass storage device */
	ut_asserteq(6, count_blk_devices());

	/* Now go around again, making sure the old devices were unbound */
	ut_assertok(usb_stop());
	ut_assertok(usb_init());
	ut_asserteq(6, count_blk_devices());
	ut_assertok(usb_stop());

	return 0;
}
DM_TEST(dm_test_blk_usb, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Test that we can find block devices without probing them */
static int dm_test_blk_find(struct unit_test_state *uts)
{
	struct udevice *blk, *dev;

	ut_assertok(blk_create_device(gd->dm_root, "sandbox_host_blk", "test",
				      IF_TYPE_HOST, 1, 512, 2, &blk));
	ut_asserteq(-ENODEV, blk_find_device(IF_TYPE_HOST, 0, &dev));
	ut_assertok(blk_find_device(IF_TYPE_HOST, 1, &dev));
	ut_asserteq_ptr(blk, dev);
	ut_asserteq(false, device_active(dev));

	/* Now activate it */
	ut_assertok(blk_get_device(IF_TYPE_HOST, 1, &dev));
	ut_asserteq_ptr(blk, dev);
	ut_asserteq(true, device_active(dev));

	return 0;
}
DM_TEST(dm_test_blk_find, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Test that block device numbering works as expected */
static int dm_test_blk_devnum(struct unit_test_state *uts)
{
	struct udevice *dev, *mmc_dev, *parent;
	int i;

	/*
	 * Probe the devices, with the first one being probed last. This is the
	 * one with no alias / sequence numnber.
	 */
	ut_assertok(uclass_get_device(UCLASS_MMC, 1, &dev));
	ut_assertok(uclass_get_device(UCLASS_MMC, 2, &dev));
	ut_assertok(uclass_get_device(UCLASS_MMC, 0, &dev));
	for (i = 0; i < 3; i++) {
		struct blk_desc *desc;

		/* Check that the bblock device is attached */
		ut_assertok(uclass_get_device_by_seq(UCLASS_MMC, i, &mmc_dev));
		ut_assertok(blk_find_device(IF_TYPE_MMC, i, &dev));
		parent = dev_get_parent(dev);
		ut_asserteq_ptr(parent, mmc_dev);
		ut_asserteq(trailing_strtol(mmc_dev->name), i);

		/*
		 * Check that the block device devnum matches its parent's
		 * sequence number
		 */
		desc = dev_get_uclass_platdata(dev);
		ut_asserteq(desc->devnum, i);
	}

	return 0;
}
DM_TEST(dm_test_blk_devnum, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Test that we can get a block from its parent */
static int dm_test_blk_get_from_parent(struct unit_test_state *uts)
{
	struct udevice *dev, *blk;

	ut_assertok(uclass_get_device(UCLASS_MMC, 0, &dev));
	ut_assertok(blk_get_from_parent(dev, &blk));

	ut_assertok(uclass_get_device(UCLASS_I2C, 0, &dev));
	ut_asserteq(-ENOTBLK, blk_get_from_parent(dev, &blk));

	ut_assertok(uclass_get_device(UCLASS_GPIO, 0, &dev));
	ut_asserteq(-ENODEV, blk_get_from_parent(dev, &blk));

	return 0;
}
DM_TEST(dm_test_blk_get_from_parent, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
e4fb863f SG	2	/*
e4fb863f SG	3	* Copyright (C) 2015 Google, Inc
e4fb863f SG	4	*/
	5
	6	#include <common.h>
	7	#include <dm.h>
	8	#include <usb.h>
	9	#include <asm/state.h>
	10	#include <dm/test.h>
	11	#include <test/ut.h>
	12
	13	DECLARE_GLOBAL_DATA_PTR;
	14
	15	/* Test that block devices can be created */
	16	static int dm_test_blk_base(struct unit_test_state *uts)
	17	{
	18	struct udevice blk, usb_blk, *dev;
	19
	20	/* Make sure there are no block devices */
	21	ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_BLK, 0, &blk));
	22
	23	/* Create two, one the parent of the other */
	24	ut_assertok(blk_create_device(gd->dm_root, "sandbox_host_blk", "test",
5fe7702e	25	IF_TYPE_HOST, 1, 512, 2, &blk));
e4fb863f	26	ut_assertok(blk_create_device(blk, "usb_storage_blk", "test",
5fe7702e	27	IF_TYPE_USB, 3, 512, 2, &usb_blk));
e4fb863f SG	28
	29	/* Check we can find them */
	30	ut_asserteq(-ENODEV, blk_get_device(IF_TYPE_HOST, 0, &dev));
	31	ut_assertok(blk_get_device(IF_TYPE_HOST, 1, &dev));
	32	ut_asserteq_ptr(blk, dev);
	33
	34	ut_asserteq(-ENODEV, blk_get_device(IF_TYPE_USB, 0, &dev));
	35	ut_assertok(blk_get_device(IF_TYPE_USB, 3, &dev));
	36	ut_asserteq_ptr(usb_blk, dev);
	37
	38	/* Check we can iterate */
	39	ut_assertok(blk_first_device(IF_TYPE_HOST, &dev));
	40	ut_asserteq_ptr(blk, dev);
	41	ut_asserteq(-ENODEV, blk_next_device(&dev));
	42
	43	ut_assertok(blk_first_device(IF_TYPE_USB, &dev));
	44	ut_asserteq_ptr(usb_blk, dev);
	45	ut_asserteq(-ENODEV, blk_next_device(&dev));
	46
	47	return 0;
	48	}
	49	DM_TEST(dm_test_blk_base, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
	50
	51	static int count_blk_devices(void)
	52	{
	53	struct udevice *blk;
	54	struct uclass *uc;
	55	int count = 0;
	56	int ret;
	57
	58	ret = uclass_get(UCLASS_BLK, &uc);
	59	if (ret)
	60	return ret;
	61
	62	uclass_foreach_dev(blk, uc)
	63	count++;
	64
	65	return count;
	66	}
	67
	68	/* Test that block devices work correctly with USB */
	69	static int dm_test_blk_usb(struct unit_test_state *uts)
	70	{
	71	struct udevice usb_dev, dev;
	72	struct blk_desc *dev_desc;
	73
	74	/* Get a flash device */
	75	state_set_skip_delays(true);
	76	ut_assertok(usb_init());
	77	ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &usb_dev));
	78	ut_assertok(blk_get_device_by_str("usb", "0", &dev_desc));
	79
	80	/* The parent should be a block device */
	81	ut_assertok(blk_get_device(IF_TYPE_USB, 0, &dev));
	82	ut_asserteq_ptr(usb_dev, dev_get_parent(dev));
	83
	84	/* Check we have one block device for each mass storage device */
e48eeb9e	85	ut_asserteq(6, count_blk_devices());
e4fb863f SG	86
	87	/* Now go around again, making sure the old devices were unbound */
	88	ut_assertok(usb_stop());
	89	ut_assertok(usb_init());
e48eeb9e	90	ut_asserteq(6, count_blk_devices());
e4fb863f SG	91	ut_assertok(usb_stop());
	92
	93	return 0;
	94	}
	95	DM_TEST(dm_test_blk_usb, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
6139281a SG	96
	97	/* Test that we can find block devices without probing them */
	98	static int dm_test_blk_find(struct unit_test_state *uts)
	99	{
	100	struct udevice blk, dev;
	101
	102	ut_assertok(blk_create_device(gd->dm_root, "sandbox_host_blk", "test",
5fe7702e	103	IF_TYPE_HOST, 1, 512, 2, &blk));
6139281a SG	104	ut_asserteq(-ENODEV, blk_find_device(IF_TYPE_HOST, 0, &dev));
	105	ut_assertok(blk_find_device(IF_TYPE_HOST, 1, &dev));
	106	ut_asserteq_ptr(blk, dev);
	107	ut_asserteq(false, device_active(dev));
	108
	109	/* Now activate it */
	110	ut_assertok(blk_get_device(IF_TYPE_HOST, 1, &dev));
	111	ut_asserteq_ptr(blk, dev);
	112	ut_asserteq(true, device_active(dev));
	113
	114	return 0;
	115	}
	116	DM_TEST(dm_test_blk_find, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
e48eeb9e SG	117
	118	/* Test that block device numbering works as expected */
	119	static int dm_test_blk_devnum(struct unit_test_state *uts)
	120	{
	121	struct udevice dev, mmc_dev, *parent;
	122	int i;
	123
	124	/*
	125	* Probe the devices, with the first one being probed last. This is the
	126	* one with no alias / sequence numnber.
	127	*/
	128	ut_assertok(uclass_get_device(UCLASS_MMC, 1, &dev));
	129	ut_assertok(uclass_get_device(UCLASS_MMC, 2, &dev));
	130	ut_assertok(uclass_get_device(UCLASS_MMC, 0, &dev));
	131	for (i = 0; i < 3; i++) {
	132	struct blk_desc *desc;
	133
	134	/* Check that the bblock device is attached */
	135	ut_assertok(uclass_get_device_by_seq(UCLASS_MMC, i, &mmc_dev));
	136	ut_assertok(blk_find_device(IF_TYPE_MMC, i, &dev));
	137	parent = dev_get_parent(dev);
	138	ut_asserteq_ptr(parent, mmc_dev);
	139	ut_asserteq(trailing_strtol(mmc_dev->name), i);
	140
	141	/*
	142	* Check that the block device devnum matches its parent's
	143	* sequence number
	144	*/
	145	desc = dev_get_uclass_platdata(dev);
	146	ut_asserteq(desc->devnum, i);
	147	}
	148
	149	return 0;
	150	}
	151	DM_TEST(dm_test_blk_devnum, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
9f103b9c SG	152
	153	/* Test that we can get a block from its parent */
	154	static int dm_test_blk_get_from_parent(struct unit_test_state *uts)
	155	{
	156	struct udevice dev, blk;
	157
	158	ut_assertok(uclass_get_device(UCLASS_MMC, 0, &dev));
	159	ut_assertok(blk_get_from_parent(dev, &blk));
	160
	161	ut_assertok(uclass_get_device(UCLASS_I2C, 0, &dev));
	162	ut_asserteq(-ENOTBLK, blk_get_from_parent(dev, &blk));
	163
	164	ut_assertok(uclass_get_device(UCLASS_GPIO, 0, &dev));
	165	ut_asserteq(-ENODEV, blk_get_from_parent(dev, &blk));
	166
	167	return 0;
	168	}
	169	DM_TEST(dm_test_blk_get_from_parent, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);