自学教程：C++ uclass_get_device函数代码示例

/** * check_vidconsole_output() - Run a text console test * * @uts:	Test state * @rot:	Console rotation (0, 90, 180, 270) * @wrap_size:	Expected size of compressed frame buffer for the wrap test * @scroll_size: Same for the scroll test * @return 0 on success */static int check_vidconsole_output(struct unit_test_state *uts, int rot,				   int wrap_size, int scroll_size){	struct udevice *dev, *con;	struct sandbox_sdl_plat *plat;	int i;	ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));	ut_assert(!device_active(dev));	plat = dev_get_platdata(dev);	plat->rot = rot;	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));	ut_asserteq(46, compress_frame_buffer(dev));	/* Check display wrap */	for (i = 0; i < 120; i++)		vidconsole_put_char(con, 'A' + i % 50);	ut_asserteq(wrap_size, compress_frame_buffer(dev));	/* Check display scrolling */	for (i = 0; i < SCROLL_LINES; i++) {		vidconsole_put_char(con, 'A' + i % 50);		vidconsole_put_char(con, '/n');	}	ut_asserteq(scroll_size, compress_frame_buffer(dev));	/* If we scroll enough, the screen becomes blank again */	for (i = 0; i < SCROLL_LINES; i++)		vidconsole_put_char(con, '/n');	ut_asserteq(46, compress_frame_buffer(dev));	return 0;}

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

/* Test text output works on the video console */static int dm_test_video_text(struct unit_test_state *uts){	struct udevice *dev, *con;	int i;#define WHITE		0xffff#define SCROLL_LINES	100	ut_assertok(select_vidconsole(uts, "vidconsole0"));	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));	ut_asserteq(46, compress_frame_buffer(dev));	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));	vidconsole_putc_xy(con, 0, 0, 'a');	ut_asserteq(79, compress_frame_buffer(dev));	vidconsole_putc_xy(con, 0, 0, ' ');	ut_asserteq(46, compress_frame_buffer(dev));	for (i = 0; i < 20; i++)		vidconsole_putc_xy(con, VID_TO_POS(i * 8), 0, ' ' + i);	ut_asserteq(273, compress_frame_buffer(dev));	vidconsole_set_row(con, 0, WHITE);	ut_asserteq(46, compress_frame_buffer(dev));	for (i = 0; i < 20; i++)		vidconsole_putc_xy(con, VID_TO_POS(i * 8), 0, ' ' + i);	ut_asserteq(273, compress_frame_buffer(dev));	return 0;}

void board_init_f(ulong dummy){	struct udevice *pinctrl;	struct udevice *dev;	int ret;	ret = spl_early_init();	if (ret) {		debug("spl_early_init() failed: %d/n", ret);		hang();	}	/* Set up our preloader console */	ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);	if (ret) {		pr_err("%s: pinctrl init failed: %d/n", __func__, ret);		hang();	}	ret = pinctrl_request_noflags(pinctrl, PERIPH_ID_UART0);	if (ret) {		pr_err("%s: failed to set up console UART/n", __func__);		hang();	}	preloader_console_init();	ret = uclass_get_device(UCLASS_RAM, 0, &dev);	if (ret) {		debug("DRAM init failed: %d/n", ret);		return;	}}

/* Check that two RTC devices can be used independently */static int dm_test_rtc_dual(struct dm_test_state *dms){	struct rtc_time now1, now2, cmp;	struct udevice *dev1, *dev2;	struct udevice *emul1, *emul2;	long offset;	ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev1));	ut_assertok(dm_rtc_get(dev1, &now1));	ut_assertok(uclass_get_device(UCLASS_RTC, 1, &dev2));	ut_assertok(dm_rtc_get(dev2, &now2));	ut_assertok(device_find_first_child(dev1, &emul1));	ut_assert(emul1 != NULL);	ut_assertok(device_find_first_child(dev2, &emul2));	ut_assert(emul2 != NULL);	offset = sandbox_i2c_rtc_set_offset(emul1, false, -1);	sandbox_i2c_rtc_set_offset(emul2, false, offset + 1);	memset(&cmp, '/0', sizeof(cmp));	ut_assertok(dm_rtc_get(dev2, &cmp));	ut_asserteq(-EINVAL, cmp_times(&now1, &cmp, false));	memset(&cmp, '/0', sizeof(cmp));	ut_assertok(dm_rtc_get(dev1, &cmp));	ut_assertok(cmp_times(&now1, &cmp, true));	return 0;}

/* Test that we can use particular sysreset devices */static int dm_test_sysreset_base(struct unit_test_state *uts){	struct sandbox_state *state = state_get_current();	struct udevice *dev;	/* Device 0 is the platform data device - it should never respond */	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 0, &dev));	ut_asserteq(-ENODEV, sysreset_request(dev, SYSRESET_WARM));	ut_asserteq(-ENODEV, sysreset_request(dev, SYSRESET_COLD));	ut_asserteq(-ENODEV, sysreset_request(dev, SYSRESET_POWER));	/* Device 1 is the warm sysreset device */	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 1, &dev));	ut_asserteq(-EACCES, sysreset_request(dev, SYSRESET_WARM));	ut_asserteq(-ENOSYS, sysreset_request(dev, SYSRESET_COLD));	ut_asserteq(-ENOSYS, sysreset_request(dev, SYSRESET_POWER));	state->sysreset_allowed[SYSRESET_WARM] = true;	ut_asserteq(-EINPROGRESS, sysreset_request(dev, SYSRESET_WARM));	state->sysreset_allowed[SYSRESET_WARM] = false;	/* Device 2 is the cold sysreset device */	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 2, &dev));	ut_asserteq(-ENOSYS, sysreset_request(dev, SYSRESET_WARM));	ut_asserteq(-EACCES, sysreset_request(dev, SYSRESET_COLD));	state->sysreset_allowed[SYSRESET_POWER] = false;	ut_asserteq(-EACCES, sysreset_request(dev, SYSRESET_POWER));	state->sysreset_allowed[SYSRESET_POWER] = true;	return 0;}

void board_init_f(ulong dummy){	struct udevice *pinctrl;	struct udevice *dev;	struct rk3399_pmusgrf_regs *sgrf;	struct rk3399_grf_regs *grf;	int ret;#define EARLY_UART#ifdef EARLY_UART	/*	 * Debug UART can be used from here if required:	 *	 * debug_uart_init();	 * printch('a');	 * printhex8(0x1234);	 * printascii("string");	 */	debug_uart_init();	printascii("U-Boot SPL board init");#endif	ret = spl_early_init();	if (ret) {		debug("spl_early_init() failed: %d/n", ret);		hang();	}	/*	 * Disable DDR and SRAM security regions.	 *	 * As we are entered from the BootROM, the region from	 * 0x0 through 0xfffff (i.e. the first MB of memory) will	 * be protected. This will cause issues with the DW_MMC	 * driver, which tries to DMA from/to the stack (likely)	 * located in this range.	 */	sgrf = syscon_get_first_range(ROCKCHIP_SYSCON_PMUSGRF);	rk_clrsetreg(&sgrf->ddr_rgn_con[16], 0x1ff, 0);	rk_clrreg(&sgrf->slv_secure_con4, 0x2000);	/*  eMMC clock generator: disable the clock multipilier */	grf = syscon_get_first_range(ROCKCHIP_SYSCON_GRF);	rk_clrreg(&grf->emmccore_con[11], 0x0ff);	secure_timer_init();	ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);	if (ret) {		debug("Pinctrl init failed: %d/n", ret);		return;	}	ret = uclass_get_device(UCLASS_RAM, 0, &dev);	if (ret) {		debug("DRAM init failed: %d/n", ret);		return;	}}

/* Simple RTC sanity check */static int dm_test_rtc_base(struct dm_test_state *dms){	struct udevice *dev;	ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_RTC, 2, &dev));	ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));	ut_assertok(uclass_get_device(UCLASS_RTC, 1, &dev));	return 0;}

static int video_show_board_logo_info(void){	ulong dram_size, nand_size;	int i;	u32 len = 0;	char buf[255];	char *corp = "2017 Microchip Technology Inc./n";	char temp[32];	struct udevice *dev, *con;	const char *s;	vidinfo_t logo_info;	int ret;	get_microchip_logo_info(&logo_info);	len += sprintf(&buf[len], "%s/n", U_BOOT_VERSION);	memcpy(&buf[len], corp, strlen(corp));	len += strlen(corp);	len += sprintf(&buf[len], "%s CPU at %s MHz/n", get_cpu_name(),			strmhz(temp, get_cpu_clk_rate()));	dram_size = 0;	for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++)		dram_size += gd->bd->bi_dram[i].size;	nand_size = 0;#ifdef CONFIG_NAND_ATMEL	for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++)		nand_size += nand_info[i]->size;#endif	len += sprintf(&buf[len], "%ld MB SDRAM, %ld MB NAND/n",		       dram_size >> 20, nand_size >> 20);	ret = uclass_get_device(UCLASS_VIDEO, 0, &dev);	if (ret)		return ret;	ret = video_bmp_display(dev, logo_info.logo_addr,				logo_info.logo_x_offset,				logo_info.logo_y_offset, false);	if (ret)		return ret;	ret = uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con);	if (ret)		return ret;	vidconsole_position_cursor(con, 0, logo_info.logo_height);	for (s = buf, i = 0; i < len; s++, i++)		vidconsole_put_char(con, *s);	return 0;}

/* Base test of the led uclass */static int dm_test_led_base(struct unit_test_state *uts){	struct udevice *dev;	/* Get the top-level device */	ut_assertok(uclass_get_device(UCLASS_LED, 0, &dev));	ut_assertok(uclass_get_device(UCLASS_LED, 1, &dev));	ut_assertok(uclass_get_device(UCLASS_LED, 2, &dev));	ut_asserteq(-ENODEV, uclass_get_device(UCLASS_LED, 3, &dev));	return 0;}

/* Test that sequence numbers are allocated properly */static int dm_test_fdt_uclass_seq(struct unit_test_state *uts){	struct udevice *dev;	/* A few basic santiy tests */	ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 3, true, &dev));	ut_asserteq_str("b-test", dev->name);	ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 8, true, &dev));	ut_asserteq_str("a-test", dev->name);	ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 5,						       true, &dev));	ut_asserteq_ptr(NULL, dev);	/* Test aliases */	ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 6, &dev));	ut_asserteq_str("e-test", dev->name);	ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 7,						       true, &dev));	/*	 * Note that c-test nodes are not probed since it is not a top-level	 * node	 */	ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 3, &dev));	ut_asserteq_str("b-test", dev->name);	/*	 * d-test wants sequence number 3 also, but it can't have it because	 * b-test gets it first.	 */	ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 2, &dev));	ut_asserteq_str("d-test", dev->name);	/* d-test actually gets 0 */	ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 0, &dev));	ut_asserteq_str("d-test", dev->name);	/* initially no one wants seq 1 */	ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_TEST_FDT, 1,						      &dev));	ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));	ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 4, &dev));	/* But now that it is probed, we can find it */	ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 1, &dev));	ut_asserteq_str("f-test", dev->name);	return 0;}

/* Base test of system controllers */static int dm_test_syscon_base(struct unit_test_state *uts){	struct udevice *dev;	ut_assertok(uclass_get_device(UCLASS_SYSCON, 0, &dev));	ut_asserteq(SYSCON0, dev->driver_data);	ut_assertok(uclass_get_device(UCLASS_SYSCON, 1, &dev));	ut_asserteq(SYSCON1, dev->driver_data);	ut_asserteq(-ENODEV, uclass_get_device(UCLASS_SYSCON, 2, &dev));	return 0;}

/* Test TrueType console */static int dm_test_video_truetype(struct unit_test_state *uts){	struct udevice *dev, *con;	const char *test_string = "Criticism may not be agreeable, but it is necessary. It fulfils the same function as pain in the human body. It calls attention to an unhealthy state of things. Some see private enterprise as a predatory target to be shot, others as a cow to be milked, but few are those who see it as a sturdy horse pulling the wagon. The /aprice OF/b/bof greatness/n/tis responsibility./n/nBye";	const char *s;	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));	for (s = test_string; *s; s++)		vidconsole_put_char(con, *s);	ut_asserteq(12619, compress_frame_buffer(dev));	return 0;}

/* Test handling of special characters in the console */static int dm_test_video_chars(struct unit_test_state *uts){	struct udevice *dev, *con;	const char *test_string = "Well/b/b/b/bxhe is/r /n/ta very /amodest  /bman/n/t/tand Has much to/b/bto be modest about.";	const char *s;	ut_assertok(select_vidconsole(uts, "vidconsole0"));	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));	for (s = test_string; *s; s++)		vidconsole_put_char(con, *s);	ut_asserteq(466, compress_frame_buffer(dev));	return 0;}

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

/* Check that we can perform operations on devices */static int dm_test_operations(struct unit_test_state *uts){	struct udevice *dev;	int i;	/*	 * Now check that the ping adds are what we expect. This is using the	 * ping-add property in each node.	 */	for (i = 0; i < ARRAY_SIZE(test_pdata); i++) {		uint32_t base;		ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev));		/*		 * Get the 'reg' property, which tells us what the ping add		 * should be. We don't use the platdata because we want		 * to test the code that sets that up (testfdt_drv_probe()).		 */		base = test_pdata[i].ping_add;		debug("dev=%d, base=%d/n", i, base);		ut_assert(!dm_check_operations(uts, dev, base, dev->priv));	}	return 0;}

int board_late_init(void){#if !defined(CONFIG_SPL_BUILD) && defined(CONFIG_WDT)	watchdog_dev = NULL;	if (uclass_get_device_by_seq(UCLASS_WDT, 0, &watchdog_dev)) {		debug("Watchdog: Not found by seq!/n");		if (uclass_get_device(UCLASS_WDT, 0, &watchdog_dev)) {			puts("Watchdog: Not found!/n");			return 0;		}	}	wdt_start(watchdog_dev, 0, 0);	puts("Watchdog: Started/n");#endif /* !CONFIG_SPL_BUILD && CONFIG_WDT */#if !defined(CONFIG_SPL_BUILD) && defined(CONFIG_SYSRESET_MICROBLAZE)	int ret;	ret = device_bind_driver(gd->dm_root, "mb_soft_reset",				 "reset_soft", NULL);	if (ret)		printf("Warning: No reset driver: ret=%d/n", ret);#endif	return 0;}

static efi_status_t EFIAPI efi_get_time(struct efi_time *time,					struct efi_time_cap *capabilities){#if defined(CONFIG_CMD_DATE) && defined(CONFIG_DM_RTC)	struct rtc_time tm;	int r;	struct udevice *dev;	EFI_ENTRY("%p %p", time, capabilities);	r = uclass_get_device(UCLASS_RTC, 0, &dev);	if (r)		return EFI_EXIT(EFI_DEVICE_ERROR);	r = dm_rtc_get(dev, &tm);	if (r)		return EFI_EXIT(EFI_DEVICE_ERROR);	memset(time, 0, sizeof(*time));	time->year = tm.tm_year;	time->month = tm.tm_mon;	time->day = tm.tm_mday;	time->hour = tm.tm_hour;	time->minute = tm.tm_min;	time->daylight = tm.tm_isdst;	return EFI_EXIT(EFI_SUCCESS);#else	return EFI_DEVICE_ERROR;#endif}

void spl_board_init(void){	struct udevice *pinctrl;	int ret;	ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);	if (ret) {		debug("%s: Cannot find pinctrl device/n", __func__);		goto err;	}	/* Enable debug UART */	ret = pinctrl_request_noflags(pinctrl, PERIPH_ID_UART_DBG);	if (ret) {		debug("%s: Failed to set up console UART/n", __func__);		goto err;	}	preloader_console_init();	return;err:	printf("%s: Error %d/n", __func__, ret);	/* No way to report error here */	hang();}

int print_cpuinfo(void){	u32 cpurev;#if defined(CONFIG_MX6) && defined(CONFIG_IMX6_THERMAL)	struct udevice *thermal_dev;	int cpu_tmp, ret;#endif	cpurev = get_cpu_rev();	printf("CPU:   Freescale i.MX%s rev%d.%d at %d MHz/n",		get_imx_type((cpurev & 0xFF000) >> 12),		(cpurev & 0x000F0) >> 4,		(cpurev & 0x0000F) >> 0,		mxc_get_clock(MXC_ARM_CLK) / 1000000);#if defined(CONFIG_MX6) && defined(CONFIG_IMX6_THERMAL)	ret = uclass_get_device(UCLASS_THERMAL, 0, &thermal_dev);	if (!ret) {		ret = thermal_get_temp(thermal_dev, &cpu_tmp);		if (!ret)			printf("CPU:   Temperature %d C/n", cpu_tmp);		else			printf("CPU:   Temperature: invalid sensor data/n");	} else {		printf("CPU:   Temperature: Can't find sensor device/n");	}#endif	printf("Reset cause: %s/n", get_reset_cause());	return 0;}

/* * Test that the bus' uclass' child_pre_probe() is called before the * device's probe() method */static int dm_test_bus_child_pre_probe_uclass(struct unit_test_state *uts){	struct udevice *bus, *dev;	int child_count;	/*	 * See testfdt_drv_probe() which effectively checks that the uclass	 * flag is set before that method is called	 */	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));	for (device_find_first_child(bus, &dev), child_count = 0;	     dev;	     device_find_next_child(&dev)) {		struct dm_test_priv *priv = dev_get_priv(dev);		/* Check that things happened in the right order */		ut_asserteq_ptr(NULL, priv);		ut_assertok(device_probe(dev));		priv = dev_get_priv(dev);		ut_assert(priv != NULL);		ut_asserteq(1, priv->uclass_flag);		ut_asserteq(1, priv->uclass_total);		child_count++;	}	ut_asserteq(3, child_count);	return 0;}

int dm_check_devices(struct unit_test_state *uts, int num_devices){	struct udevice *dev;	int ret;	int i;	/*	 * Now check that the ping adds are what we expect. This is using the	 * ping-add property in each node.	 */	for (i = 0; i < num_devices; i++) {		uint32_t base;		ret = uclass_get_device(UCLASS_TEST_FDT, i, &dev);		ut_assert(!ret);		/*		 * Get the 'ping-expect' property, which tells us what the		 * ping add should be. We don't use the platdata because we		 * want to test the code that sets that up		 * (testfdt_drv_probe()).		 */		base = fdtdec_get_addr(gd->fdt_blob, dev_of_offset(dev),				       "ping-expect");		debug("dev=%d, base=%d: %s/n", i, base,		      fdt_get_name(gd->fdt_blob, dev_of_offset(dev), NULL));		ut_assert(!dm_check_operations(uts, dev, base,					       dev_get_priv(dev)));	}	return 0;}

/* Test that the bus ops are called when a child is probed/removed */static int dm_test_bus_parent_ops(struct dm_test_state *dms){	struct dm_test_parent_data *parent_data;	struct udevice *bus, *dev;	struct uclass *uc;	test_state = dms;	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));	ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));	uclass_foreach_dev(dev, uc) {		/* Ignore these if they are not on this bus */		if (dev->parent != bus)			continue;		ut_asserteq_ptr(NULL, dev_get_parentdata(dev));		ut_assertok(device_probe(dev));		parent_data = dev_get_parentdata(dev);		ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);	}	uclass_foreach_dev(dev, uc) {		/* Ignore these if they are not on this bus */		if (dev->parent != bus)			continue;		parent_data = dev_get_parentdata(dev);		ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);		ut_assertok(device_remove(dev));		ut_asserteq_ptr(NULL, dev_get_parentdata(dev));		ut_asserteq_ptr(dms->removed, dev);	}	test_state = NULL;	return 0;}

/* Test that we can iterate through children */static int dm_test_bus_children_iterators(struct unit_test_state *uts){	struct udevice *bus, *dev, *child;	/* Walk through the children one by one */	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));	ut_assertok(device_find_first_child(bus, &dev));	ut_asserteq_str("[email
C++ ucln_i18n_registerCleanup函数代码示例
C++ uchar函数代码示例