int main(int argc, char **argv) { DATATYPE *x; long *sizes; double *times, *bws, *percents; type = usage(argc, argv); assert(sizes = (long *)malloc(timeslots*sizeof(long))); memset(sizes,0x00,(timeslots*sizeof(long))); assert(times = (double *)malloc(timeslots*repeat_count*sizeof(double))); memset(times,0x00,(timeslots*repeat_count*sizeof(double))); assert(bws = (double *)malloc(timeslots*repeat_count*sizeof(double))); memset(bws,0x00,(timeslots*repeat_count*sizeof(double))); assert(percents = (double *)malloc(timeslots*repeat_count*sizeof(double))); memset(percents,0x00,(timeslots*repeat_count*sizeof(double))); assert(x = (DATATYPE *)malloc((size_t)memsize)); memset((void *)x,0x00,memsize); initialize_sizes(sizes); /* Measure cache */ if (type & MEMORYSET) { do_memory_set(sizes,x,times,bws,percents); } if (type & MEMORYCOPY) { do_memory_copy(sizes,x,times,bws,percents); } if (type & READONLY) { do_read_only(sizes,x,times,bws,percents); } if (type & WRITEONLY) { do_write_only(sizes,x,times,bws,percents); } if (type & READWRITE) { do_read_write(sizes,x,times,bws,percents); } FLUSHALL(0); exit(0); }
/*===========================================================================* * do_read * *===========================================================================*/ int do_read() { return(do_read_write(READING)); }
int main(int argc, char* argv[]) { if(argc < 3){ fprintf(stderr, "Usage: conv -flags --dim _nRow_x_nCol_ infile outfile\n" "flags: u -- uint32 input\n" " d -- double input\n" " f -- float input\n"); exit(-1); } char data_type = 'f'; std::string infile; std::string outfile; int nRow = 156; int nCol = 156; argc--; argv++; while (argc > 2) { std::string argument = argv[0]; // parse single character flags if (argument.size() > 1 && argument.at(0) == '-' && argument.at(1) != '-') { for (size_t j = 1; j < argument.size(); j++) { switch (argument.at(j)) { case 'u': std::cout << "Input type: uint32" << std::endl; data_type = 'u'; break; case 'd': std::cout << "Input type: double" << std::endl; data_type = 'd'; break; case 'f': std::cout << "Input type: float" << std::endl; data_type = 'f'; break; default: std::cerr << "Error, unrecognized flag: " << argument.at(j) << std::endl; exit(1); } } // end for j argc--; argv++; } else if (argument.size() > 2 && argument.substr(0,2) == "--") { std::string arg = argument.substr(2, argument.length() - 2); if (arg == "dim") { if (argc <= 2) { std::cerr << "\'dim\' argument must be followed by image dimensions" << std::endl; exit(1); } argc--; argv++; argument = argv[0]; auto split = argument.find("x", 0); if (split == std::string::npos) { std::cerr << "\'dim\' argument must be of the form _numRow_x_numCol_" << std::endl; exit(1); } nRow = stoi(argument.substr(0,split)); nCol = stoi(argument.substr(split + 1, argument.length() - split - 1)); std::cout << "Image dimension: " << nRow << ' ' << nCol << std::endl; argc--; argv++; } } else { std::cerr << "invalid flag: " << argument << std::endl; exit(1); } } infile = argv[0]; outfile = argv[1]; // primate scanner params, but doesn't really matter int nRsec = 24; int nCrystals = 13; if(data_type == 'd') { Sinogram<double> sinogram {nRsec * nCrystals, nRow, nCol}; do_read_write(sinogram, infile, outfile); } else if(data_type == 'u') { Sinogram<uint32_t> sinogram {nRsec * nCrystals, nRow, nCol}; do_read_write(sinogram, infile, outfile); } else if(data_type == 'f') { Sinogram<float> sinogram {nRsec * nCrystals, nRow, nCol}; do_read_write(sinogram, infile, outfile); } }
static int do_cros_ec(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { struct cros_ec_dev *dev; struct udevice *udev; const char *cmd; int ret = 0; if (argc < 2) return CMD_RET_USAGE; cmd = argv[1]; if (0 == strcmp("init", cmd)) { /* Remove any existing device */ ret = uclass_find_device(UCLASS_CROS_EC, 0, &udev); if (!ret) device_remove(udev); ret = uclass_get_device(UCLASS_CROS_EC, 0, &udev); if (ret) { printf("Could not init cros_ec device (err %d)\n", ret); return 1; } return 0; } ret = uclass_get_device(UCLASS_CROS_EC, 0, &udev); if (ret) { printf("Cannot get cros-ec device (err=%d)\n", ret); return 1; } dev = dev_get_uclass_priv(udev); if (0 == strcmp("id", cmd)) { char id[MSG_BYTES]; if (cros_ec_read_id(dev, id, sizeof(id))) { debug("%s: Could not read KBC ID\n", __func__); return 1; } printf("%s\n", id); } else if (0 == strcmp("info", cmd)) { struct ec_response_mkbp_info info; if (cros_ec_info(dev, &info)) { debug("%s: Could not read KBC info\n", __func__); return 1; } printf("rows = %u\n", info.rows); printf("cols = %u\n", info.cols); printf("switches = %#x\n", info.switches); } else if (0 == strcmp("curimage", cmd)) { enum ec_current_image image; if (cros_ec_read_current_image(dev, &image)) { debug("%s: Could not read KBC image\n", __func__); return 1; } printf("%d\n", image); } else if (0 == strcmp("hash", cmd)) { struct ec_response_vboot_hash hash; int i; if (cros_ec_read_hash(dev, &hash)) { debug("%s: Could not read KBC hash\n", __func__); return 1; } if (hash.hash_type == EC_VBOOT_HASH_TYPE_SHA256) printf("type: SHA-256\n"); else printf("type: %d\n", hash.hash_type); printf("offset: 0x%08x\n", hash.offset); printf("size: 0x%08x\n", hash.size); printf("digest: "); for (i = 0; i < hash.digest_size; i++) printf("%02x", hash.hash_digest[i]); printf("\n"); } else if (0 == strcmp("reboot", cmd)) { int region; enum ec_reboot_cmd cmd; if (argc >= 3 && !strcmp(argv[2], "cold")) cmd = EC_REBOOT_COLD; else { region = cros_ec_decode_region(argc - 2, argv + 2); if (region == EC_FLASH_REGION_RO) cmd = EC_REBOOT_JUMP_RO; else if (region == EC_FLASH_REGION_RW) cmd = EC_REBOOT_JUMP_RW; else return CMD_RET_USAGE; } if (cros_ec_reboot(dev, cmd, 0)) { debug("%s: Could not reboot KBC\n", __func__); return 1; } } else if (0 == strcmp("events", cmd)) { uint32_t events; if (cros_ec_get_host_events(dev, &events)) { debug("%s: Could not read host events\n", __func__); return 1; } printf("0x%08x\n", events); } else if (0 == strcmp("clrevents", cmd)) { uint32_t events = 0x7fffffff; if (argc >= 3) events = simple_strtol(argv[2], NULL, 0); if (cros_ec_clear_host_events(dev, events)) { debug("%s: Could not clear host events\n", __func__); return 1; } } else if (0 == strcmp("read", cmd)) { ret = do_read_write(dev, 0, argc, argv); if (ret > 0) return CMD_RET_USAGE; } else if (0 == strcmp("write", cmd)) { ret = do_read_write(dev, 1, argc, argv); if (ret > 0) return CMD_RET_USAGE; } else if (0 == strcmp("erase", cmd)) { int region = cros_ec_decode_region(argc - 2, argv + 2); uint32_t offset, size; if (region == -1) return CMD_RET_USAGE; if (cros_ec_flash_offset(dev, region, &offset, &size)) { debug("%s: Could not read region info\n", __func__); ret = -1; } else { ret = cros_ec_flash_erase(dev, offset, size); if (ret) { debug("%s: Could not erase region\n", __func__); } } } else if (0 == strcmp("regioninfo", cmd)) { int region = cros_ec_decode_region(argc - 2, argv + 2); uint32_t offset, size; if (region == -1) return CMD_RET_USAGE; ret = cros_ec_flash_offset(dev, region, &offset, &size); if (ret) { debug("%s: Could not read region info\n", __func__); } else { printf("Region: %s\n", region == EC_FLASH_REGION_RO ? "RO" : "RW"); printf("Offset: %x\n", offset); printf("Size: %x\n", size); } } else if (0 == strcmp("vbnvcontext", cmd)) { uint8_t block[EC_VBNV_BLOCK_SIZE]; char buf[3]; int i, len; unsigned long result; if (argc <= 2) { ret = cros_ec_read_vbnvcontext(dev, block); if (!ret) { printf("vbnv_block: "); for (i = 0; i < EC_VBNV_BLOCK_SIZE; i++) printf("%02x", block[i]); putc('\n'); } } else { /* * TODO(clchiou): Move this to a utility function as * cmd_spi might want to call it. */ memset(block, 0, EC_VBNV_BLOCK_SIZE); len = strlen(argv[2]); buf[2] = '\0'; for (i = 0; i < EC_VBNV_BLOCK_SIZE; i++) { if (i * 2 >= len) break; buf[0] = argv[2][i * 2]; if (i * 2 + 1 >= len) buf[1] = '0'; else buf[1] = argv[2][i * 2 + 1]; strict_strtoul(buf, 16, &result); block[i] = result; } ret = cros_ec_write_vbnvcontext(dev, block); } if (ret) { debug("%s: Could not %s VbNvContext\n", __func__, argc <= 2 ? "read" : "write"); } } else if (0 == strcmp("test", cmd)) { int result = cros_ec_test(dev); if (result) printf("Test failed with error %d\n", result); else puts("Test passed\n"); } else if (0 == strcmp("version", cmd)) { struct ec_response_get_version *p; char *build_string; ret = cros_ec_read_version(dev, &p); if (!ret) { /* Print versions */ printf("RO version: %1.*s\n", (int)sizeof(p->version_string_ro), p->version_string_ro); printf("RW version: %1.*s\n", (int)sizeof(p->version_string_rw), p->version_string_rw); printf("Firmware copy: %s\n", (p->current_image < ARRAY_SIZE(ec_current_image_name) ? ec_current_image_name[p->current_image] : "?")); ret = cros_ec_read_build_info(dev, &build_string); if (!ret) printf("Build info: %s\n", build_string); } } else if (0 == strcmp("ldo", cmd)) { uint8_t index, state; char *endp; if (argc < 3) return CMD_RET_USAGE; index = simple_strtoul(argv[2], &endp, 10); if (*argv[2] == 0 || *endp != 0) return CMD_RET_USAGE; if (argc > 3) { state = simple_strtoul(argv[3], &endp, 10); if (*argv[3] == 0 || *endp != 0) return CMD_RET_USAGE; ret = cros_ec_set_ldo(udev, index, state); } else { ret = cros_ec_get_ldo(udev, index, &state); if (!ret) { printf("LDO%d: %s\n", index, state == EC_LDO_STATE_ON ? "on" : "off"); } } if (ret) { debug("%s: Could not access LDO%d\n", __func__, index); return ret; } } else { return CMD_RET_USAGE; } if (ret < 0) { printf("Error: CROS-EC command failed (error %d)\n", ret); ret = 1; } return ret; }