static int dm_test_reset_bulk(struct unit_test_state *uts) { struct udevice *dev_reset; struct udevice *dev_test; ut_assertok(uclass_get_device_by_name(UCLASS_RESET, "reset-ctl", &dev_reset)); ut_asserteq(0, sandbox_reset_query(dev_reset, TEST_RESET_ID)); ut_asserteq(0, sandbox_reset_query(dev_reset, OTHER_RESET_ID)); ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "reset-ctl-test", &dev_test)); ut_assertok(sandbox_reset_test_get_bulk(dev_test)); ut_assertok(sandbox_reset_test_assert_bulk(dev_test)); ut_asserteq(1, sandbox_reset_query(dev_reset, TEST_RESET_ID)); ut_asserteq(1, sandbox_reset_query(dev_reset, OTHER_RESET_ID)); ut_assertok(sandbox_reset_test_deassert_bulk(dev_test)); ut_asserteq(0, sandbox_reset_query(dev_reset, TEST_RESET_ID)); ut_asserteq(0, sandbox_reset_query(dev_reset, OTHER_RESET_ID)); ut_assertok(sandbox_reset_test_release_bulk(dev_test)); ut_asserteq(1, sandbox_reset_query(dev_reset, TEST_RESET_ID)); ut_asserteq(1, sandbox_reset_query(dev_reset, OTHER_RESET_ID)); return 0; }
static int dm_test_clk_bulk(struct unit_test_state *uts) { struct udevice *dev_clk, *dev_test; ut_assertok(uclass_get_device_by_name(UCLASS_CLK, "clk-sbox", &dev_clk)); ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "clk-test", &dev_test)); ut_assertok(sandbox_clk_test_get_bulk(dev_test)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); /* Fixed clock does not support enable, thus should not fail */ ut_assertok(sandbox_clk_test_enable_bulk(dev_test)); ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); /* Fixed clock does not support disable, thus should not fail */ ut_assertok(sandbox_clk_test_disable_bulk(dev_test)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); /* Fixed clock does not support enable, thus should not fail */ ut_assertok(sandbox_clk_test_enable_bulk(dev_test)); ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); /* Fixed clock does not support disable, thus should not fail */ ut_assertok(sandbox_clk_test_release_bulk(dev_test)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); return 0; }
/* Check for vol- button - if pressed - stop autoboot */ int misc_init_r(void) { struct udevice *pon; struct gpio_desc resin; int node, ret; ret = uclass_get_device_by_name(UCLASS_GPIO, "pm8916_pon@800", &pon); if (ret < 0) { printf("Failed to find PMIC pon node. Check device tree\n"); return 0; } node = fdt_subnode_offset(gd->fdt_blob, dev_of_offset(pon), "key_vol_down"); if (node < 0) { printf("Failed to find key_vol_down node. Check device tree\n"); return 0; } if (gpio_request_by_name_nodev(offset_to_ofnode(node), "gpios", 0, &resin, 0)) { printf("Failed to request key_vol_down button.\n"); return 0; } if (dm_gpio_get_value(&resin)) { env_set("bootdelay", "-1"); printf("Power button pressed - dropping to console.\n"); } return 0; }
static bool disable_mcu_watchdog(void) { struct udevice *bus, *dev; int ret, retry = 3; uchar buf[1] = {0x0}; if (uclass_get_device_by_name(UCLASS_I2C, OMNIA_I2C_MCU_DM_NAME, &bus)) { puts("Cannot find MCU bus! Can not disable MCU WDT.\n"); return false; } ret = i2c_get_chip(bus, OMNIA_I2C_MCU, 1, &dev); if (ret) { puts("Cannot get MCU chip! Can not disable MCU WDT.\n"); return false; } for (; retry > 0; --retry) if (!dm_i2c_write(dev, OMNIA_I2C_MCU_WDT_ADDR, (uchar *) buf, 1)) break; if (retry <= 0) { puts("I2C MCU watchdog failed to disable!\n"); return false; } return true; }
int request_gpio_by_name(struct gpio_desc *gpio, const char *gpio_dev_name, uint offset, char *gpio_name) { struct udevice *gpio_dev = NULL; if (uclass_get_device_by_name(UCLASS_GPIO, gpio_dev_name, &gpio_dev)) return 1; gpio->dev = gpio_dev; gpio->offset = offset; gpio->flags = 0; return dm_gpio_request(gpio, gpio_name); }
static struct udevice *get_atsha204a_dev(void) { static struct udevice *dev = NULL; if (dev != NULL) return dev; if (uclass_get_device_by_name(UCLASS_MISC, "atsha204a@64", &dev)) { puts("Cannot find ATSHA204A on I2C bus!\n"); dev = NULL; } return dev; }
int msm_fixup_memory(void *blob) { u64 bank_start[MEMORY_BANKS_MAX]; u64 bank_size[MEMORY_BANKS_MAX]; size_t size; int i; int count = 0; struct udevice *smem; int ret; struct smem_ram_ptable *ram_ptable; struct smem_ram_ptn *p; ret = uclass_get_device_by_name(UCLASS_SMEM, "smem", &smem); if (ret < 0) { printf("Failed to find SMEM node. Check device tree\n"); return 0; } ram_ptable = smem_get(smem, -1, SMEM_USABLE_RAM_PARTITION_TABLE, &size); if (!ram_ptable) { printf("Failed to find SMEM partition.\n"); return -ENODEV; } /* Check validy of RAM */ for (i = 0; i < RAM_NUM_PART_ENTRIES; i++) { p = &ram_ptable->parts[i]; if (p->category == CATEGORY_SDRAM && p->type == TYPE_SYSMEM) { bank_start[count] = p->start; bank_size[count] = p->size; debug("Detected memory bank %u: start: 0x%llx size: 0x%llx\n", count, p->start, p->size); count++; } } if (!count) { printf("Failed to detect any memory bank\n"); return -ENODEV; } ret = fdt_fixup_memory_banks(blob, bank_start, bank_size, count); if (ret) return ret; return 0; }
static bool omnia_detect_sata(void) { struct udevice *bus, *dev; int ret, retry = 3; u16 mode; puts("SERDES0 card detect: "); if (uclass_get_device_by_name(UCLASS_I2C, OMNIA_I2C_MCU_DM_NAME, &bus)) { puts("Cannot find MCU bus!\n"); return false; } ret = i2c_get_chip(bus, OMNIA_I2C_MCU, 1, &dev); if (ret) { puts("Cannot get MCU chip!\n"); return false; } for (; retry > 0; --retry) { ret = dm_i2c_read(dev, OMNIA_I2C_MCU_ADDR_STATUS, (uchar *) &mode, 2); if (!ret) break; } if (!retry) { puts("I2C read failed! Default PEX\n"); return false; } if (!(mode & OMNIA_I2C_MCU_CARDDET)) { puts("NONE\n"); return false; } if (mode & OMNIA_I2C_MCU_SATA) { puts("SATA\n"); return true; } else { puts("PEX\n"); return false; } }
static bool omnia_read_eeprom(struct omnia_eeprom *oep) { struct udevice *bus, *dev; int ret, crc, retry = 3; if (uclass_get_device_by_name(UCLASS_I2C, OMNIA_I2C_EEPROM_DM_NAME, &bus)) { puts("Cannot find EEPROM bus\n"); return false; } ret = i2c_get_chip(bus, OMNIA_I2C_EEPROM, OMNIA_I2C_EEPROM_ADDRLEN, &dev); if (ret) { puts("Cannot get EEPROM chip\n"); return false; } for (; retry > 0; --retry) { ret = dm_i2c_read(dev, OMNIA_I2C_EEPROM_CONFIG_ADDR, (uchar *) oep, sizeof(struct omnia_eeprom)); if (ret) continue; if (oep->magic != OMNIA_I2C_EEPROM_MAGIC) { puts("I2C EEPROM missing magic number!\n"); continue; } crc = crc32(0, (unsigned char *) oep, sizeof(struct omnia_eeprom) - 4); if (crc == oep->crc) { break; } else { printf("CRC of EEPROM memory config failed! " "calc=0x%04x saved=0x%04x\n", crc, oep->crc); } } if (!retry) { puts("I2C EEPROM read failed!\n"); return false; } return true; }
static int dm_test_dma_rx(struct unit_test_state *uts) { struct udevice *dev; struct dma dma_tx, dma_rx; u8 src_buf[512]; u8 dst_buf[512]; void *dst_ptr; size_t len = 512; u32 meta1, meta2; int i; ut_assertok(uclass_get_device_by_name(UCLASS_DMA, "dma", &dev)); ut_assertok(dma_get_by_name(dev, "tx0", &dma_tx)); ut_assertok(dma_get_by_name(dev, "rx0", &dma_rx)); ut_assertok(dma_enable(&dma_tx)); ut_assertok(dma_enable(&dma_rx)); memset(dst_buf, 0, len); for (i = 0; i < len; i++) src_buf[i] = i; meta1 = 0xADADDEAD; meta2 = 0; dst_ptr = NULL; ut_assertok(dma_prepare_rcv_buf(&dma_tx, dst_buf, len)); ut_assertok(dma_send(&dma_tx, src_buf, len, &meta1)); ut_asserteq(len, dma_receive(&dma_rx, &dst_ptr, &meta2)); ut_asserteq(0xADADDEAD, meta2); ut_asserteq_ptr(dst_buf, dst_ptr); ut_assertok(dma_disable(&dma_tx)); ut_assertok(dma_disable(&dma_rx)); ut_assertok(dma_free(&dma_tx)); ut_assertok(dma_free(&dma_rx)); ut_assertok(memcmp(src_buf, dst_buf, len)); return 0; }
static int dm_test_uclass_devices_get_by_name(struct unit_test_state *uts) { struct udevice *finddev; struct udevice *testdev; int ret, findret; /* * For each test device found in fdt like: "a-test", "b-test", etc., * use its name and try to get it by uclass_get_device_by_name(). * On success check if: * - returned finddev' is active * - current 'testdev' name is equal to the returned 'finddev' name * - current 'testdev' pointer is equal to the returned 'finddev' * * We asserts that the 'testdev' is active on each loop entry, so we * could be sure that the 'finddev' is activated too, but for sure * we check it again. * * We assume that, each uclass's device name is unique, so if not, then * this will fail on checking condition: testdev == finddev, since the * uclass_get_device_by_name(), returns the first device by given name. */ for (ret = uclass_first_device(UCLASS_TEST_FDT, &testdev); testdev; ret = uclass_next_device(&testdev)) { ut_assertok(ret); ut_assert(testdev); ut_assert(device_active(testdev)); findret = uclass_get_device_by_name(UCLASS_TEST_FDT, testdev->name, &finddev); ut_assertok(findret); ut_assert(finddev); ut_assert(device_active(finddev)); ut_asserteq_str(testdev->name, finddev->name); ut_asserteq_ptr(testdev, finddev); } return 0; }
static int dm_test_dma_m2m(struct unit_test_state *uts) { struct udevice *dev; struct dma dma_m2m; u8 src_buf[512]; u8 dst_buf[512]; size_t len = 512; int i; ut_assertok(uclass_get_device_by_name(UCLASS_DMA, "dma", &dev)); ut_assertok(dma_get_by_name(dev, "m2m", &dma_m2m)); memset(dst_buf, 0, len); for (i = 0; i < len; i++) src_buf[i] = i; ut_assertok(dma_memcpy(dst_buf, src_buf, len)); ut_assertok(memcmp(src_buf, dst_buf, len)); return 0; }
int board_fix_fdt(void *rw_fdt_blob) { struct udevice *bus = NULL; uint k; char name[64]; int err; err = uclass_get_device_by_name(UCLASS_I2C, "i2c@11000", &bus); if (err) { printf("Could not get I2C bus.\n"); return err; } for (k = 0x21; k <= 0x26; k++) { snprintf(name, 64, "/soc/internal-regs/i2c@11000/pca9698@%02x", k); if (!dm_i2c_simple_probe(bus, k)) fdt_disable_by_ofname(rw_fdt_blob, name); } return 0; }
int board_prepare_usb(enum usb_init_type type) { static struct udevice *pmic_gpio; static struct gpio_desc hub_reset, usb_sel; int ret = 0, node; if (!pmic_gpio) { ret = uclass_get_device_by_name(UCLASS_GPIO, "pm8916_gpios@c000", &pmic_gpio); if (ret < 0) { printf("Failed to find pm8916_gpios@c000 node.\n"); return ret; } } /* Try to request gpios needed to start usb host on dragonboard */ if (!dm_gpio_is_valid(&hub_reset)) { node = fdt_subnode_offset(gd->fdt_blob, dev_of_offset(pmic_gpio), "usb_hub_reset_pm"); if (node < 0) { printf("Failed to find usb_hub_reset_pm dt node.\n"); return node; } ret = gpio_request_by_name_nodev(offset_to_ofnode(node), "gpios", 0, &hub_reset, 0); if (ret < 0) { printf("Failed to request usb_hub_reset_pm gpio.\n"); return ret; } } if (!dm_gpio_is_valid(&usb_sel)) { node = fdt_subnode_offset(gd->fdt_blob, dev_of_offset(pmic_gpio), "usb_sw_sel_pm"); if (node < 0) { printf("Failed to find usb_sw_sel_pm dt node.\n"); return 0; } ret = gpio_request_by_name_nodev(offset_to_ofnode(node), "gpios", 0, &usb_sel, 0); if (ret < 0) { printf("Failed to request usb_sw_sel_pm gpio.\n"); return ret; } } if (type == USB_INIT_HOST) { /* Start USB Hub */ dm_gpio_set_dir_flags(&hub_reset, GPIOD_IS_OUT | GPIOD_IS_OUT_ACTIVE); mdelay(100); /* Switch usb to host connectors */ dm_gpio_set_dir_flags(&usb_sel, GPIOD_IS_OUT | GPIOD_IS_OUT_ACTIVE); mdelay(100); } else { /* Device */ /* Disable hub */ dm_gpio_set_dir_flags(&hub_reset, GPIOD_IS_OUT); /* Switch back to device connector */ dm_gpio_set_dir_flags(&usb_sel, GPIOD_IS_OUT); } return 0; }
static int dm_test_clk(struct unit_test_state *uts) { struct udevice *dev_fixed, *dev_clk, *dev_test; ulong rate; ut_assertok(uclass_get_device_by_name(UCLASS_CLK, "clk-fixed", &dev_fixed)); ut_assertok(uclass_get_device_by_name(UCLASS_CLK, "clk-sbox", &dev_clk)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); ut_asserteq(0, sandbox_clk_query_rate(dev_clk, SANDBOX_CLK_ID_SPI)); ut_asserteq(0, sandbox_clk_query_rate(dev_clk, SANDBOX_CLK_ID_I2C)); ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "clk-test", &dev_test)); ut_assertok(sandbox_clk_test_get(dev_test)); ut_assertok(sandbox_clk_test_valid(dev_test)); ut_asserteq(1234, sandbox_clk_test_get_rate(dev_test, SANDBOX_CLK_TEST_ID_FIXED)); ut_asserteq(0, sandbox_clk_test_get_rate(dev_test, SANDBOX_CLK_TEST_ID_SPI)); ut_asserteq(0, sandbox_clk_test_get_rate(dev_test, SANDBOX_CLK_TEST_ID_I2C)); rate = sandbox_clk_test_set_rate(dev_test, SANDBOX_CLK_TEST_ID_FIXED, 12345); ut_assert(IS_ERR_VALUE(rate)); rate = sandbox_clk_test_get_rate(dev_test, SANDBOX_CLK_TEST_ID_FIXED); ut_asserteq(1234, rate); ut_asserteq(0, sandbox_clk_test_set_rate(dev_test, SANDBOX_CLK_TEST_ID_SPI, 1000)); ut_asserteq(0, sandbox_clk_test_set_rate(dev_test, SANDBOX_CLK_TEST_ID_I2C, 2000)); ut_asserteq(1000, sandbox_clk_test_get_rate(dev_test, SANDBOX_CLK_TEST_ID_SPI)); ut_asserteq(2000, sandbox_clk_test_get_rate(dev_test, SANDBOX_CLK_TEST_ID_I2C)); ut_asserteq(1000, sandbox_clk_test_set_rate(dev_test, SANDBOX_CLK_TEST_ID_SPI, 10000)); ut_asserteq(2000, sandbox_clk_test_set_rate(dev_test, SANDBOX_CLK_TEST_ID_I2C, 20000)); rate = sandbox_clk_test_set_rate(dev_test, SANDBOX_CLK_TEST_ID_SPI, 0); ut_assert(IS_ERR_VALUE(rate)); rate = sandbox_clk_test_set_rate(dev_test, SANDBOX_CLK_TEST_ID_I2C, 0); ut_assert(IS_ERR_VALUE(rate)); ut_asserteq(10000, sandbox_clk_test_get_rate(dev_test, SANDBOX_CLK_TEST_ID_SPI)); ut_asserteq(20000, sandbox_clk_test_get_rate(dev_test, SANDBOX_CLK_TEST_ID_I2C)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); ut_asserteq(10000, sandbox_clk_query_rate(dev_clk, SANDBOX_CLK_ID_SPI)); ut_asserteq(20000, sandbox_clk_query_rate(dev_clk, SANDBOX_CLK_ID_I2C)); ut_assertok(sandbox_clk_test_enable(dev_test, SANDBOX_CLK_TEST_ID_SPI)); ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); ut_assertok(sandbox_clk_test_enable(dev_test, SANDBOX_CLK_TEST_ID_I2C)); ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); ut_assertok(sandbox_clk_test_disable(dev_test, SANDBOX_CLK_TEST_ID_SPI)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); ut_assertok(sandbox_clk_test_disable(dev_test, SANDBOX_CLK_TEST_ID_I2C)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); ut_assertok(sandbox_clk_test_free(dev_test)); return 0; }
static int dm_test_misc(struct unit_test_state *uts) { struct udevice *dev; u8 buf[16]; int id; ulong last_ioctl; bool enabled; ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "misc-test", &dev)); /* Read / write tests */ ut_asserteq(4, misc_write(dev, 0, "TEST", 4)); ut_asserteq(5, misc_write(dev, 4, "WRITE", 5)); ut_asserteq(9, misc_read(dev, 0, buf, 9)); ut_assertok(memcmp(buf, "TESTWRITE", 9)); /* Call tests */ id = 0; ut_assertok(misc_call(dev, 0, &id, 4, buf, 16)); ut_assertok(memcmp(buf, "Zero", 4)); id = 2; ut_assertok(misc_call(dev, 0, &id, 4, buf, 16)); ut_assertok(memcmp(buf, "Two", 3)); ut_assertok(misc_call(dev, 1, &id, 4, buf, 16)); ut_assertok(memcmp(buf, "Forty-two", 9)); id = 1; ut_assertok(misc_call(dev, 1, &id, 4, buf, 16)); ut_assertok(memcmp(buf, "Forty-one", 9)); /* IOCTL tests */ ut_assertok(misc_ioctl(dev, 6, NULL)); /* Read back last issued ioctl */ ut_assertok(misc_call(dev, 2, NULL, 0, &last_ioctl, sizeof(last_ioctl))); ut_asserteq(6, last_ioctl) ut_assertok(misc_ioctl(dev, 23, NULL)); /* Read back last issued ioctl */ ut_assertok(misc_call(dev, 2, NULL, 0, &last_ioctl, sizeof(last_ioctl))); ut_asserteq(23, last_ioctl) /* Enable / disable tests */ /* Read back enable/disable status */ ut_assertok(misc_call(dev, 3, NULL, 0, &enabled, sizeof(enabled))); ut_asserteq(true, enabled); ut_assertok(misc_set_enabled(dev, false)); /* Read back enable/disable status */ ut_assertok(misc_call(dev, 3, NULL, 0, &enabled, sizeof(enabled))); ut_asserteq(false, enabled); ut_assertok(misc_set_enabled(dev, true)); /* Read back enable/disable status */ ut_assertok(misc_call(dev, 3, NULL, 0, &enabled, sizeof(enabled))); ut_asserteq(true, enabled); return 0; }