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