BufferedWriter::BufferedWriter (const char* fname, bool append)
:
fhandle (-1),
buffer (NULL),
bufst (0),
cpos (0)
{
if (fname) sci_open (fname, append);
}
/*
* Enable/disable touchpad and trackpoint with HCI_ENABLE/HCI_DISABLE
*/
static ACPI_STATUS
valz_acpi_touchpad_toggle(struct valz_acpi_softc *sc)
{
ACPI_STATUS rv;
uint32_t result, status, value;
rv = sci_open(sc);
if (ACPI_FAILURE(rv))
aprint_error_dev(sc->sc_dev,
"Cannot open SCI: %s\n",
AcpiFormatException(rv));
rv = valz_acpi_hci_get(sc, SCI_GET, SCI_TOUCHPAD, &value, &result);
if (ACPI_FAILURE(rv))
aprint_error_dev(sc->sc_dev,
"Cannot get SCI touchpad status: %s\n",
AcpiFormatException(rv));
switch (value) {
case HCI_ENABLE:
status = HCI_DISABLE;
break;
case HCI_DISABLE:
status = HCI_ENABLE;
break;
default:
status = HCI_ENABLE;
break;
}
rv = valz_acpi_hci_set(sc, SCI_SET, SCI_TOUCHPAD, status, &result);
if (ACPI_FAILURE(rv))
aprint_error_dev(sc->sc_dev,
"Cannot set SCI touchpad status: %s\n",
AcpiFormatException(rv));
rv = sci_close(sc);
if (ACPI_FAILURE(rv))
aprint_error_dev(sc->sc_dev,
"Cannot close SCI: %s\n",
AcpiFormatException(rv));
return rv;
}
LineReader::LineReader (const char* fname)
:
fhandle_ (-1),
buffer_ (NULL),
cur_pos_ (-1L)
{
fhandle_ = sci_open (fname, O_BINARY|O_RDONLY|O_SEQUENTIAL);
if (fhandle_ == -1) ers << "Unable to open file " << fname << " for reading." << std::endl << strerror (errno) << Throw;
try
{
buffer_ = new char [LR_BUF_SIZE+1]; // +1 is needed because there may be a need to zero-terminate the full buffer
}
catch (std::bad_alloc&)
{
}
if (!buffer_) Error (MemoryRerror);
cur_line_beg_ = 0;
cur_line_end_ = 0;
buf_end_ = 0;
prev_char_ = 0;
}
/********************************************
TransmitTask - pends on the Transmit flag, when flag is posted
transmitts message typed.
uses: sci_write, sci_open, MessageCheckSum();
*********************************************/
static void TransmitTask(void *p_arg)
{
INT8U err;
INT8U var = 'M';
INT8U sourcea = '1';
INT8U sourceb = '1';
INT8U sourcec = '7';
INT8U send_message[16];
INT8U counter = 0x00;
INT8U checksum[2];
(void)p_arg;
sci_open();
FOREVER()
{
OSSemPend(TransmitFlag, 0, &err);
DBUG_PORT |= PP1;
sci_write(var);
sci_write(sourcea);
sci_write(sourceb);
sci_write(sourcec);
GetMessage(&send_message);
while(counter != 0x10)
{
sci_write(send_message[counter]);
counter++;
}
counter = 0x00;
MessageCheckSum(&checksum,sourcea,sourceb,sourcec);
sci_write(checksum[0]);
sci_write(checksum[1]);
DBUG_PORT &= ~PP1;
}
}
int
sci_test_view_type(resource_mgr_t *mgr)
{
int fh;
char filename[14];
int compression;
resource_t *res;
int i;
mgr->sci_version = SCI_VERSION_AUTODETECT;
for (i=0;i<1000;i++)
{
res = scir_test_resource(mgr, sci_view, i);
if (!res) continue;
if (res->file == SCI_RESOURCE_FILE_PATCH)
continue;
sprintf(filename, "resource.%03i", res->file);
fh = open(filename, O_RDONLY | O_BINARY);
if (!IS_VALID_FD(fh)) {
char *raiser = filename;
while (*raiser) {
*raiser = toupper(*raiser); /* Uppercasify */
++raiser;
}
fh = sci_open(filename, O_RDONLY|O_BINARY);
} /* Try case-insensitively name */
if (!IS_VALID_FD(fh)) continue;
lseek(fh, res->file_offset, SEEK_SET);
compression = sci0_get_compression_method(fh);
close(fh);
if (compression == 3)
return (mgr->sci_version = SCI_VERSION_01_VGA);
}
/* Try the same thing with pics */
for (i=0;i<1000;i++)
{
res = scir_test_resource(mgr, sci_pic, i);
if (!res) continue;
if (res->file == SCI_RESOURCE_FILE_PATCH)
continue;
sprintf(filename, "resource.%03i", res->file);
fh = open(filename, O_RDONLY | O_BINARY);
if (!IS_VALID_FD(fh)) {
char *raiser = filename;
while (*raiser) {
*raiser = toupper(*raiser); /* Uppercasify */
++raiser;
}
fh = sci_open(filename, O_RDONLY|O_BINARY);
} /* Try case-insensitively name */
if (!IS_VALID_FD(fh)) continue;
lseek(fh, res->file_offset, SEEK_SET);
compression = sci0_get_compression_method(fh);
close(fh);
if (compression == 3)
return (mgr->sci_version = SCI_VERSION_01_VGA);
}
return mgr->sci_version;
}
static void
_scir_load_resource(resource_mgr_t *mgr, resource_t *res, int protect)
{
char *cwd = sci_getcwd();
char filename[14];
int fh;
resource_t backup;
memcpy(&backup, res, sizeof(resource_t));
/* Enter resource directory */
chdir(mgr->resource_path);
/* First try lower-case name */
if (res->file == SCI_RESOURCE_FILE_PATCH) {
if (!patch_sprintfers[mgr->sci_version]) {
sciprintf("Resource manager's SCI version (%d) has no patch file name printers -> internal error!\n",
mgr->sci_version);
exit(1);
}
/* Get patch file name */
patch_sprintfers[mgr->sci_version](filename, res);
} else
sprintf(filename, "resource.%03i", res->file);
fh = open(filename, O_RDONLY | O_BINARY);
if (!IS_VALID_FD(fh)) {
char *raiser = filename;
while (*raiser) {
*raiser = toupper(*raiser); /* Uppercasify */
++raiser;
}
fh = sci_open(filename, O_RDONLY|O_BINARY);
} /* Try case-insensitively name */
if (!IS_VALID_FD(fh)) {
sciprintf("Failed to open %s/%s!\n",
mgr->resource_path, filename);
res->data = NULL;
res->status = SCI_STATUS_NOMALLOC;
res->size = 0;
chdir(cwd);
free(cwd);
return;
}
lseek(fh, res->file_offset, SEEK_SET);
if (res->file == SCI_RESOURCE_FILE_PATCH)
_scir_load_from_patch_file(fh, res, filename);
else if (!decompressors[mgr->sci_version]) {
/* Check whether we support this at all */
sciprintf("Resource manager's SCI version (%d) is invalid!\n",
mgr->sci_version);
exit(1);
} else {
int error = /* Decompress from regular resource file */
decompressors[mgr->sci_version](res, fh, mgr->sci_version);
if (error) {
sciprintf("Error %d occured while reading %s.%03d"
" from resource file: %s\n",
error, sci_resource_types[res->type], res->number,
sci_error_types[error]);
if (protect)
memcpy(res, &backup, sizeof(resource_t));
res->data = NULL;
res->status = SCI_STATUS_NOMALLOC;
res->size = 0;
chdir(cwd);
free(cwd);
return;
}
}
close(fh);
chdir(cwd);
free(cwd);
}
int statcoll_main(int argc, char **argv)
{
struct sci_config my_sci_config;
enum sci_err my_sci_err;
int c, option_index = 0;
static int longopt_flag;
unsigned int option_delay_us;
unsigned int option_overflow_delay_us;
unsigned int option_iterations;
unsigned int option_disable = 0;
unsigned int option_min_addr;
unsigned int option_max_addr;
unsigned int describe_loop;
// Default values of options
option_delay_us = 1000000; // 1 second
option_overflow_delay_us = 1000000; // 1 second
option_overflow_iterations = option_overflow_delay_us / option_delay_us;
option_accumulation_type = 2; // dump on terminal
option_iterations = 0; // infinite iterations
option_overflow_counter_index[0] = 0; // check counter 0 for overflow
option_overflow_counter_index[1] = 0;
option_overflow_threshold[0] = 0; // reset at each capture
option_overflow_threshold[1] = 0;
static struct option long_options[] =
{
/* These options set a flag. */
{"m0", required_argument, &longopt_flag, 'm'},
{"m1", required_argument, &longopt_flag, 'm'},
{"m2", required_argument, &longopt_flag, 'm'},
{"m3", required_argument, &longopt_flag, 'm'},
{"m4", required_argument, &longopt_flag, 'm'},
{"m5", required_argument, &longopt_flag, 'm'},
{"m6", required_argument, &longopt_flag, 'm'},
{"m7", required_argument, &longopt_flag, 'm'},
{"tr0", required_argument, &longopt_flag, 'q'},
{"tr1", required_argument, &longopt_flag, 'q'},
{"tr2", required_argument, &longopt_flag, 'q'},
{"tr3", required_argument, &longopt_flag, 'q'},
{"tr4", required_argument, &longopt_flag, 'q'},
{"tr5", required_argument, &longopt_flag, 'q'},
{"tr", required_argument, &longopt_flag, 'q'},
{"p0", required_argument, &longopt_flag, 'p'},
{"p1", required_argument, &longopt_flag, 'p'},
{"p2", required_argument, &longopt_flag, 'p'},
{"p3", required_argument, &longopt_flag, 'p'},
{"p4", required_argument, &longopt_flag, 'p'},
{"p5", required_argument, &longopt_flag, 'p'},
{"p6", required_argument, &longopt_flag, 'p'},
{"p7", required_argument, &longopt_flag, 'p'},
{"allcounters", no_argument, &longopt_flag, '8'},
{"overflow_delay", required_argument, &longopt_flag, '1'},
{0, 0, 0, 0}
};
while ((c = getopt_long (argc, argv, "hnm:d:a:i:o:t:r:p:q:D", long_options, &option_index)) != -1) {
// small trick to merge long options with short options of same doaain (-m and --m0 --m1 ...)
unsigned int long_opt = 0;
if (c == 0)
{
long_opt = 1;
c = long_options[option_index].val;
}
switch (c)
{
case 'h':
{
unsigned int loop = 0;
printf("\n\tomapconf trace bw [-h] [<-m | --m<x>> <0xyy | ma_mpu | alldmm | dss | iva | ...>] [<-p | --p<x> <emif1 | emif2>] [<--tr | --tr<x>> <r|w|r+w>] [-d x] [--overflow_delay x] [-a 1 or 2] [-i x] [-o x -t y] [-r 0xaaaaaaaa-0xbbbbbbbb] [-n]\n");
printf("\n\t-m, -p, -q sets all 8 counters while -m0, --p0, --q0 to --m7, --tr7, --p5 set 1 counter only\n");
printf("\n\t-m <0xyy | ma_mpu | alldmm | dss | iva | ...> (MA_MPU_1_2 deprecated)\n");
printf("\t\tMaster initiator monitored. WARNING: All DMM traffic includes DSS, IVA, GPU, ... but not MA_MPU, which requires parallel monitoring \n");
printf("\t\tma_mpu (MA_MPU_1_2 deprecated) - Non DMM MPU memory traffic, see Examples\n");
while (match_master[loop].name != NULL)
{
printf("\t\t%s 0x%x\n", match_master[loop].name, match_master[loop].value);
loop++;
}
printf("\n\t-d xxx or 0.xx\n");
printf("\t\tDelay in ms between 2 captures, can be float\n");
printf("\n\t--overflow_delay xxx or 0.xx\n");
printf("\t\tDelay in ms after which HW IP is reset to avoid overflow. Disables -o -t options. Can be float.\n");
printf("\n\t-p <emif1 | emif2> or --p<x> <emif1 | emif2>\n");
printf("\t\tProbed channel. 1 counter can monitor only EMIF1 or EMIF2\n");
printf("\n\t--tr <r|w|r+w> or --tr<x> <r|w|r+w>\n");
printf("\t\tTransaction qualifier. Rd or Wr or Rd+Wr monitoring. HW implementation prevents changing this on last 2 counters\n");
printf("\n\t-a 1 or 2\n");
printf("\t\taccumulation type. 2: dump at every capture. 1: dump only at end\n");
printf("\n\t-i x\n");
printf("\t\tnumber of iterations (for -a 1). You can Ctrl-C during test, current captures will be displayed\n");
printf("\n\t-o x -t y \n");
printf("\t\tindex for overflow handling + threshold to reset HW. Disables auto-reset of HW IP based on time (--overflow_delay). You MUST use them for -a 1\n");
printf("\t\tUse this option twice to set 2 different thresholds on 2 different counters\n");
printf("\n\t-r 0xaa-0xbb\n");
printf("\t\taddress filtering, like 0x9b000000-0x9f000000\n");
printf("\n\t-n\n");
printf("\t\tno sleep of 32kHz (work-around for 32kHz reading HW bug). MANDATORY for OMAP5 until fix is found\n");
printf("\n\t-D\n");
printf("\t\tdisable statcol (deprecated)\n");
printf("\n\tExamples:\n");
printf("\tDefault: --p7 emif2 (this forces use of 8 counters and counter 7 is using emif2 as default probed channel)\n");
printf("\t\tCounter: 0 Master: alldmm Transaction: w Probe: emif1\n");
printf("\t\tCounter: 1 Master: alldmm Transaction: w Probe: emif2\n");
printf("\t\tCounter: 2 Master: alldmm Transaction: r Probe: emif1\n");
printf("\t\tCounter: 3 Master: alldmm Transaction: r Probe: emif2\n");
printf("\t\tCounter: 4 Master: alldmm Transaction: w Probe: emif1\n");
printf("\t\tCounter: 5 Master: alldmm Transaction: w Probe: emif2\n");
printf("\t\tCounter: 6 Master: alldmm Transaction: r+w Probe: emif1\n");
printf("\t\tCounter: 7 Master: alldmm Transaction: r+w Probe: emif2\n");
printf("\n\t-m 0x70 -d 1000 -a 2 (often used as -m 0x70 only)\n");
printf("\t\taccumulation 2 is reading of registers and tracing them immediately\n");
printf("\t\tFormat is time: time_start time_end delta_time -> Wr_DMM_EMIF1 Wr_DMM_EMIF2 Rd_DMM_EMIF1 Rd_DMM_EMIF2 (MB/s)\n");
printf("\n\t-m dss -d 0.3 -a 1 -i 40000 -o 2 -t 3000000000\n");
printf("\t\taccumulation 1 is reading of registers and storing in RAM. Result is dumped at the end with CCS format to reuse\n");
printf("\t\texisting post-processing. So you must set iterations. Overflow is taken into account. Suits small delays\n");
printf("\n\t-m MA_MPU -d 1000 -a 2 --overflow_delay 500\n");
printf("\t\tMA_MPU is MPU memory adaptor, a direct path to EMIF. MA_MPU will display:\n");
printf("\t\tWr_MA_MPU_EMIF1 Wr_MA_MPU_EMIF2 Rd_MA_MPU_EMIF Rd_MA_MPU_EMIF2 (MB/s)\n");
printf("\n\t--tr r+w -p emif1 --m0 ma_mpu --m1 ma_mpu --tr1 w --p1 emif2 --m2 gpu_p1 --m3 dss --m4 alldmm --m5 alldmm --p5 emif2\n");
printf("\t\tCounter: 0 Master: ma_mpu Transaction: r+w Probe: emif1\n");
printf("\t\tCounter: 1 Master: ma_mpu Transaction: w Probe: emif2\n");
printf("\t\tCounter: 2 Master: gpu_p1 Transaction: r+w Probe: emif1\n");
printf("\t\tCounter: 3 Master: dss Transaction: r+w Probe: emif1\n");
printf("\t\tCounter: 4 Master: alldmm Transaction: r+w Probe: emif1\n");
printf("\t\tCounter: 5 Master: alldmm Transaction: r+w Probe: emif2\n");
printf("\n\t2 masters + all traffic on EMIF1 and EMIF2: --tr r+w --m0 dss --m1 dss --m2 iva --m3 iva --m6 ma_mpu --m7 ma_mpu\n");
printf("\tNote that you can monitor more masters if you have identified earlier that traffic is well balanced over EMIF1 and EMIF2, i.e. traffic for this master = 2 * EMIF1 = 2 * EMIF2\n");
printf("\n\tDefault settings:\n");
printf("\t\t-m 0xcd -d 1000 -a 2 -i 0 --overflow_delay 1000\n");
printf("\t\tall initiators, 1000ms delay, accumulation 2, infinite iterations, auto-reset IP after 1 s, i.e. always stop/restart HW IP after 1 capture\n");
printf("\n\tPost-processing (for -a 1):\n");
printf("\t\tgit clone git://gitorious.tif.ti.com/omap-video-perf/runperf.git, instrumentation/bandwidth/BWstats_ccsv5.py\n");
printf("\t\tpython-matplotlib is needed\n");
printf("\n\tWiki:\n");
printf("\t\t<http://opbuwiki.dal.design.ti.com/index.php/L3_bus_monitoring_SW_tool>\n\n");
//sci_global_disable(psci_hdl);
//sci_close(&psci_hdl);
return 0;
}
case 'm':
{
unsigned int index;
if (long_opt == 1) {
index = long_options[option_index].name[1] - '0';
// go up to 6 couhters
if ((index + 1) > num_use_cases)
num_use_cases = index + 1;
}
if (!strstr(optarg, "ma_mpu")) {
unsigned int loop = 0;
if (strstr(optarg, "0x")) {
unsigned int a;
sscanf(optarg, "%x", &a);
while (match_master[loop].name != NULL)
{
if (match_master[loop].value == a)
break;
loop++;
}
}
else {
while (match_master[loop].name != NULL)
{
if (!strcmp(match_master[loop].name, optarg))
break;
loop++;
}
}
if (match_master[loop].name != NULL) {
if (long_opt == 1) {
pmy_cfg[index]->filter[0].mstr_addr_match = match_master[loop].value;
if (pmy_cfg[index]->probe_id == SCI_MA_MPU_P1)
pmy_cfg[index]->probe_id = SCI_EMIF1;
if (pmy_cfg[index]->probe_id == SCI_MA_MPU_P2)
pmy_cfg[index]->probe_id = SCI_EMIF2;
}
else {
unsigned int i;
for (i = 0; i < sizeof(pmy_cfg)/sizeof(struct sci_config_sdram *); i++) {
pmy_cfg[i]->filter[0].mstr_addr_match = match_master[loop].value;
if (pmy_cfg[i]->probe_id == SCI_MA_MPU_P1)
pmy_cfg[i]->probe_id = SCI_EMIF1;
if (pmy_cfg[i]->probe_id == SCI_MA_MPU_P2)
pmy_cfg[i]->probe_id = SCI_EMIF2;
}
}
}
// parsing error
else {
printf("ERROR: %s option of -m is not recognized\n", optarg);
goto END;
}
}
else if ( (!strcmp(optarg, "ma_mpu_1_2")) && (long_opt == 0) ) {
my_config_emif1.probe_id = SCI_MA_MPU_P1;
my_config_emif1.filter[0].mstr_addr_match = SCI_MASTID_ALL;
my_config_emif2.probe_id = SCI_MA_MPU_P2;
my_config_emif2.filter[0].mstr_addr_match = SCI_MASTID_ALL;
my_config_emif3.probe_id = SCI_MA_MPU_P1;
my_config_emif3.filter[0].mstr_addr_match = SCI_MASTID_ALL;
my_config_emif4.probe_id = SCI_MA_MPU_P2;
my_config_emif5.filter[0].mstr_addr_match = SCI_MASTID_ALL;
my_config_emif5.probe_id = SCI_MA_MPU_P1;
my_config_emif6.filter[0].mstr_addr_match = SCI_MASTID_ALL;
my_config_emif6.probe_id = SCI_MA_MPU_P2;
my_config_emif6.filter[0].mstr_addr_match = SCI_MASTID_ALL;
my_config_emif7.probe_id = SCI_MA_MPU_P1;
my_config_emif7.filter[0].mstr_addr_match = SCI_MASTID_ALL;
my_config_emif8.probe_id = SCI_MA_MPU_P2;
my_config_emif8.filter[0].mstr_addr_match = SCI_MASTID_ALL;
}
else if (!strcmp(optarg, "ma_mpu")) {
if (long_opt == 1) {
pmy_cfg[index]->filter[0].mstr_addr_match = SCI_MASTID_ALL;
if (pmy_cfg[index]->probe_id == SCI_EMIF1)
pmy_cfg[index]->probe_id = SCI_MA_MPU_P1;
if (pmy_cfg[index]->probe_id == SCI_EMIF2)
pmy_cfg[index]->probe_id = SCI_MA_MPU_P2;
}
else {
unsigned int i;
for (i = 0; i < sizeof(pmy_cfg)/sizeof(struct sci_config_sdram *); i++) {
pmy_cfg[i]->filter[0].mstr_addr_match = SCI_MASTID_ALL;
if (pmy_cfg[i]->probe_id == SCI_EMIF1)
pmy_cfg[i]->probe_id = SCI_MA_MPU_P1;
if (pmy_cfg[i]->probe_id == SCI_EMIF2)
pmy_cfg[i]->probe_id = SCI_MA_MPU_P2;
}
}
}
else {
printf("ERROR: %s option of -m is not recognized\n", optarg);
goto END;
}
}
break;
case 'q':
{
unsigned int loop = 0;
unsigned int index;
if (!strcmp(long_options[option_index].name, "tr"))
long_opt = 0;
if (long_opt == 1) {
index = long_options[option_index].name[2] - '0';
// go up to 6 couhters
if ((index + 1) > num_use_cases)
num_use_cases = index + 1;
}
while (match_qualifier[loop].name != NULL)
{
if (!strcmp(match_qualifier[loop].name, optarg))
break;
loop++;
}
if (match_qualifier[loop].name != NULL) {
if (long_opt == 1) {
pmy_cfg[index]->filter[0].trans_qual = match_qualifier[loop].value;
}
else {
unsigned int i;
for (i = 0; i < sizeof(pmy_cfg)/sizeof(struct sci_config_sdram *); i++) {
pmy_cfg[i]->filter[0].trans_qual = match_qualifier[loop].value;
}
}
}
else {
printf("ERROR: %s option of -q/--qx not recognized\n", optarg);
goto END;
}
}
break;
case 'p':
{
unsigned int loop = 0;
unsigned int index;
if (long_opt == 1) {
index = long_options[option_index].name[1] - '0';
// go up to 6 couhters
if ((index + 1) > num_use_cases)
num_use_cases = index + 1;
}
while (match_probe[loop].name != NULL)
{
if (!strcmp(match_probe[loop].name, optarg))
break;
loop++;
}
if (match_probe[loop].name != NULL) {
if (long_opt == 1) {
if (pmy_cfg[index]->probe_id == SCI_MA_MPU_P1) {
if (match_probe[loop].value == SCI_EMIF2)
pmy_cfg[index]->probe_id = SCI_MA_MPU_P2;
}
else if (pmy_cfg[index]->probe_id == SCI_MA_MPU_P2) {
if (match_probe[loop].value == SCI_EMIF1)
pmy_cfg[index]->probe_id = SCI_MA_MPU_P1;
}
else if (pmy_cfg[index]->probe_id != SCI_MA_MPU_P1 &&
pmy_cfg[index]->probe_id != SCI_MA_MPU_P2) {
pmy_cfg[index]->probe_id = match_probe[loop].value;
}
}
else {
unsigned int i;
for (i = 0; i < sizeof(pmy_cfg)/sizeof(struct sci_config_sdram *); i++) {
if ( (pmy_cfg[i]->probe_id == SCI_MA_MPU_P1) && (match_probe[loop].value == SCI_EMIF2) )
pmy_cfg[i]->probe_id = SCI_MA_MPU_P2;
else if ( (pmy_cfg[i]->probe_id == SCI_MA_MPU_P2) && (match_probe[loop].value == SCI_EMIF1) )
pmy_cfg[i]->probe_id = SCI_MA_MPU_P1;
else if (pmy_cfg[index]->probe_id != SCI_MA_MPU_P1 &&
pmy_cfg[index]->probe_id != SCI_MA_MPU_P2)
pmy_cfg[i]->probe_id = match_probe[loop].value;
}
}
}
else {
printf("ERROR: %s option of -p/--px not recognized\n", optarg);
goto END;
}
}
break;
case 'd':
{
float a;
if ( (sscanf(optarg, "%f", &a) > 0) && (a > 0))
option_delay_us = a * 1000;
else {
printf("ERROR: %s option of -d not recognized or wrong\n", optarg);
goto END;
}
if (option_overflow_iterations > 0)
option_overflow_iterations = option_overflow_delay_us / option_delay_us;
}
break;
case 'a':
sscanf(optarg, "%u", &option_accumulation_type);
if ((option_accumulation_type != 1) && (option_accumulation_type != 2)) {
printf("ERROR: %s option of -a not recognized or wrong\n", optarg);
goto END;
}
break;
case 'i':
if (sscanf(optarg, "%u", &option_iterations) == 0) {
printf("ERROR: %s option of -i not recognized\n", optarg);
goto END;
}
break;
case 'o':
{
static unsigned int o_count = 0;
unsigned int result;
if ((sscanf(optarg, "%u", &result) == 0) || (result > 7)) {
printf("ERROR: %s option of -o not recognized or too high\n", optarg);
goto END;
}
option_overflow_counter_index[1] = result;
if (o_count++ == 0)
option_overflow_counter_index[0] = result;
option_overflow_delay_us = 0;
option_overflow_iterations = 0;
}
break;
case 't':
{
static unsigned int t_count = 0;
unsigned int result;
if (sscanf(optarg, "%u", &result) == 0) {
printf("ERROR: %s option of -t not recognized\n", optarg);
goto END;
}
option_overflow_threshold[1] = result;
if (t_count++ == 0)
option_overflow_threshold[0] = result;
option_overflow_delay_us = 0;
option_overflow_iterations = 0;
}
break;
case 'n':
option_nosleep_32k = 1;
break;
case '8':
num_use_cases = sizeof(pmy_cfg)/sizeof(struct sci_config_sdram *);
break;
case '1':
{
float a;
if ( (sscanf(optarg, "%f", &a) > 0) && (a > 0)) {
option_overflow_delay_us = a * 1000;
option_overflow_iterations = option_overflow_delay_us / option_delay_us;
}
else {
printf("ERROR: %s option of --overflow_delay not recognized or wrong\n", optarg);
goto END;
}
}
break;
case 'r':
sscanf(optarg, "0x%x-0x%x", &option_min_addr, &option_max_addr);
my_config_emif1.addr_filter_min = option_min_addr;
my_config_emif2.addr_filter_min = option_min_addr;
my_config_emif3.addr_filter_min = option_min_addr;
my_config_emif4.addr_filter_min = option_min_addr;
my_config_emif5.addr_filter_min = option_min_addr;
my_config_emif6.addr_filter_min = option_min_addr;
my_config_emif1.addr_filter_max = option_max_addr;
my_config_emif2.addr_filter_max = option_max_addr;
my_config_emif3.addr_filter_max = option_max_addr;
my_config_emif4.addr_filter_max = option_max_addr;
my_config_emif5.addr_filter_max = option_max_addr;
my_config_emif6.addr_filter_max = option_max_addr;
my_config_emif1.addr_filter_enable = true;
my_config_emif2.addr_filter_enable = true;
my_config_emif3.addr_filter_enable = true;
my_config_emif4.addr_filter_enable = true;
my_config_emif5.addr_filter_enable = true;
my_config_emif6.addr_filter_enable = true;
break;
case 'D':
option_disable = 1;
default:
printf("ERROR: Unknown option\n");
goto END;
}
}
// Error checking, are there still elements ?
if (optind < argc)
{
printf ("ERROR: non-option ARGV-elements: ");
while (optind < argc)
printf ("%s ", argv[optind++]);
putchar ('\n');
goto END;
}
// Even if above chhanges config of counter 7 and 8, we restore default as they can't filter
my_config_emif7.filter[0].mstr_addr_match = SCI_MASTID_ALL;
my_config_emif7.filter[0].trans_qual = SCI_RD_OR_WR_DONTCARE;
my_config_emif8.filter[0].mstr_addr_match = SCI_MASTID_ALL;
my_config_emif8.filter[0].trans_qual = SCI_RD_OR_WR_DONTCARE;
// Describe configuration of counters in human readable format
for (describe_loop = 0; describe_loop < num_use_cases; describe_loop++) {
unsigned int a, b, c;
char *a_name, *b_name, *c_name;
unsigned int loop = 0, loop_transaction = 0;
a = pmy_cfg[describe_loop]->filter[0].mstr_addr_match;
b = pmy_cfg[describe_loop]->filter[0].trans_qual;
c = pmy_cfg[describe_loop]->probe_id;
while (match_probe[loop].name != NULL)
{
if (match_probe[loop].value == c)
break;
loop++;
}
if (match_probe[loop].name != NULL) {
c_name = match_probe[loop].name;
strcpy(msg[describe_loop], match_probe[loop].name_ccs);
strcpy(msg_overflow[describe_loop], match_probe[loop].name_ccs);
}
else {
c_name = "ERROR";
strcpy(msg[describe_loop], "ERROR");
strcpy(msg_overflow[describe_loop], "ERROR");
}
loop_transaction = 0;
while (match_qualifier[loop_transaction].name != NULL)
{
if (match_qualifier[loop_transaction].value == b)
break;
loop_transaction++;
}
if (match_qualifier[loop_transaction].name != NULL) {
char temp[20];
b_name = match_qualifier[loop_transaction].name;
sprintf(temp, ":%s:", match_qualifier[loop_transaction].name_ccs);
strcat(msg[describe_loop], temp);
sprintf(temp, ":%s:", match_qualifier[loop_transaction].name);
strcat(msg_overflow[describe_loop], temp);
}
else {
b_name = "ERROR";
strcat(msg[describe_loop], ":ERROR:");
strcat(msg_overflow[describe_loop], ":ERROR:");
}
loop = 0;
while (match_master[loop].name != NULL)
{
if (match_master[loop].value == a)
break;
loop++;
}
if (match_master[loop].name != NULL) {
a_name = match_master[loop].name;
strcat(msg[describe_loop], match_master[loop].name_ccs);
strcat(msg_overflow[describe_loop], match_master[loop].name_ccs);
}
else {
a_name = "ERROR";
strcat(msg[describe_loop], "ERROR");
strcat(msg_overflow[describe_loop], "ERROR");
}
if ( (pmy_cfg[describe_loop]->filter[0].mstr_addr_match == SCI_MASTID_ALL) && (pmy_cfg[describe_loop]->probe_id == SCI_MA_MPU_P1)) {
printf("Counter: %d Master: ma_mpu Transaction: %s Probe: emif1\n", describe_loop, b_name);
sprintf(msg[describe_loop], "EMIF 0:%s:MA_MPU", match_qualifier[loop_transaction].name_ccs);
sprintf(msg_overflow[describe_loop], "EMIF 0:%s:MA_MPU", match_qualifier[loop_transaction].name);
continue;
}
if ( (pmy_cfg[describe_loop]->filter[0].mstr_addr_match == SCI_MASTID_ALL) && (pmy_cfg[describe_loop]->probe_id == SCI_MA_MPU_P2)) {
printf("Counter: %d Master: ma_mpu Transaction: %s Probe: emif2\n", describe_loop, b_name);
sprintf(msg[describe_loop], "EMIF 1:%s:MA_MPU", match_qualifier[loop_transaction].name_ccs);
sprintf(msg_overflow[describe_loop], "EMIF 1:%s:MA_MPU", match_qualifier[loop_transaction].name);
continue;
}
printf("Counter: %d Master: %s Transaction: %s Probe: %s\n", describe_loop, a_name, b_name, c_name);
}
printf("delay in us: %u\n", option_delay_us);
if (option_overflow_iterations > 0)
printf("overflow delay in us: %u (iterations=%u)\n", option_overflow_delay_us, option_overflow_iterations);
else
printf("overflow delay in us: DISABLED (-o -t used)\n");
printf("accumulation type: %u\n", option_accumulation_type);
printf("iterations (0=infinite): %u\n", option_iterations);
if (option_overflow_iterations == 0) {
printf("Overflow counter index: %u %u\n", option_overflow_counter_index[0], option_overflow_counter_index[1]);
printf("Overflow threshold: %u %u\n", option_overflow_threshold[0], option_overflow_threshold[1]);
}
else {
printf("Overflow counter index: DISABLED (overflow delay used)\n");
printf("Overflow threshold: DISABLED (overflow delay used)\n");
}
if (option_iterations > MAX_ITERATIONS) {
option_iterations = MAX_ITERATIONS;
printf("WARNING: MAX_ITERATIONS(%d) exceeded\n", option_iterations);
}
powerdm_emu_enable();
/////////////////////////////////////////////////////
//Make sure DebugSS is powered up and enabled //
/////////////////////////////////////////////////////
my_sci_config.errhandler = sci_errhandler;
my_sci_config.data_options = 0; //Disable options
my_sci_config.trigger_enable = false;
my_sci_config.sdram_msg_rate = 1;
my_sci_config.mstr_msg_rate = 1;
my_sci_config.mode = SCI_MODE_DUMP;
addr_32k = mem_map_32k();
my_sci_err = sci_open(&psci_hdl, &my_sci_config);
if (SCI_SUCCESS != my_sci_err) exit(-1);
{
uint32_t plib_major_ver;
uint32_t plib_minor_ver;
uint32_t plib_func_id;
uint32_t pmod_func_id;
sci_get_version(psci_hdl, &plib_major_ver, &plib_minor_ver,
&plib_func_id, &pmod_func_id );
if ( plib_func_id != pmod_func_id )
{
printf ("Error - func missmatch with device %d %d\n", plib_func_id, pmod_func_id);
sci_close(&psci_hdl);
powerdm_emu_disable();
exit(-1);
}
}
// Test
{
unsigned int i, j;
for (i = 0; i < num_use_cases; i++) {
my_sci_err = sci_reg_usecase_sdram(psci_hdl, pmy_cfg[i], &my_usecase_key[i] );
if ( SCI_SUCCESS != my_sci_err) break;
valid_usecase_cnt++;
}
/* If you kill the process, statcoll is left running. this is an option to disable it. We should intercept and handle signal */
if (option_disable == 1) {
sci_global_disable(psci_hdl);
sci_close(&psci_hdl);
return 0;
}
/* And this is an ugly hack to disable it so that it will reset counters at enable */
sci_global_disable(psci_hdl);
if (option_nosleep_32k)
nosleep_32k_enable();
if (valid_usecase_cnt == num_use_cases)
{
uint32_t *counters_current = counters;
unsigned int tests_overflow = 1;
if (option_accumulation_type == 1) {
for (tests = 0; tests < (option_iterations * 9); tests++)
counters[tests] = 0;
my_sci_err = sci_global_enable(psci_hdl);
for (tests = 0; tests < option_iterations; tests++) {
usleep(option_delay_us);
*(counters_current + TIMESTAMP_INDEX) = GET_32K;
sci_dump_sdram_cntrs(num_use_cases, counters_current + COUNTER_INDEX);
if ( ( (option_overflow_iterations > 0) && (tests_overflow > option_overflow_iterations) )
|| ( (option_overflow_iterations == 0)
&& ( (*(counters_current + COUNTER_INDEX + option_overflow_counter_index[0]) >= option_overflow_threshold[0])
|| (*(counters_current + COUNTER_INDEX + option_overflow_counter_index[1]) >= option_overflow_threshold[1])
)
)
) {
sci_global_disable(psci_hdl);
sci_global_enable(psci_hdl);
counters_current += SAMPLE_SIZE;
*(counters_current + TIMESTAMP_INDEX) = GET_32K;
sci_dump_sdram_cntrs(num_use_cases, counters_current + COUNTER_INDEX);
tests++;
tests_overflow = 1;
//printf("overflow %u\n", *counters_current - counters[0]);
}
counters_current += SAMPLE_SIZE;
tests_overflow++;
}
}
else {
uint32_t *counters_prev;
uint32_t *counters_overflow;
unsigned int overflow_on;
uint32_t delta_time;
unsigned int tests_overflow = 1;
for (i = 0; i < sizeof(counters)/4; i++)
counters[i] = 0;
counters_prev = counters;
counters_current = counters + SAMPLE_SIZE;
counters_overflow = counters + 2 * SAMPLE_SIZE;
sci_global_enable(psci_hdl);
*(counters_prev + TIMESTAMP_INDEX) = GET_32K;
sci_dump_sdram_cntrs(num_use_cases, counters_prev + COUNTER_INDEX);
for (;;) {
tests_overflow++;
usleep(option_delay_us);
*(counters_current + TIMESTAMP_INDEX) = GET_32K;
sci_dump_sdram_cntrs(num_use_cases, counters_current + COUNTER_INDEX);
if ( ( (option_overflow_iterations > 0) && (tests_overflow > option_overflow_iterations) )
|| ( (option_overflow_iterations == 0)
&& ( (*(counters_current + COUNTER_INDEX + option_overflow_counter_index[0]) >= option_overflow_threshold[0])
|| (*(counters_current + COUNTER_INDEX + option_overflow_counter_index[1]) >= option_overflow_threshold[1])
)
)
) {
sci_global_disable(psci_hdl);
sci_global_enable(psci_hdl);
*(counters_overflow + TIMESTAMP_INDEX) = GET_32K;
sci_dump_sdram_cntrs(num_use_cases, counters_overflow + COUNTER_INDEX);
overflow_on = 1;
tests_overflow = 1;
}
/* trace current - prev */
delta_time = *(counters_current + TIMESTAMP_INDEX) - *(counters_prev + TIMESTAMP_INDEX);
printf("time: %u %u %u -> ", *(counters_current + TIMESTAMP_INDEX), *(counters_prev + TIMESTAMP_INDEX), delta_time);
for (j = 0; j < num_use_cases; j++) {
printf("%.2f ", ((float)(*(counters_current + COUNTER_INDEX + j) - *(counters_prev + COUNTER_INDEX + j))/1000000)*32768.0/delta_time);
}
printf("\n");
for (j = 0; j < num_use_cases; j++) {
if (*(counters_current + COUNTER_INDEX + j) == 0xFFFFFFFF) {
fprintf(stderr, "ERROR: counter %d %s overflowed at time %u, don't trust results\n", j, msg[j], *(counters_current + TIMESTAMP_INDEX));
printf("ERROR: counter %d %s overflowed at time %u, don't trust results\n", j, msg[j], *(counters_current + TIMESTAMP_INDEX));
}
}
/* pointers increment */
if (overflow_on == 1) {
overflow_on = 0;
counters_current = counters_overflow;
}
// offset all pointers by 1 sample
counters_prev = counters_current;
if ((unsigned int)(counters_current - counters) == (2 * SAMPLE_SIZE))
counters_current = counters;
else
counters_current += SAMPLE_SIZE;
counters_overflow = counters_current;
if ((unsigned int)(counters_overflow - counters) == (2 * SAMPLE_SIZE))
counters_overflow = counters;
else
counters_overflow += SAMPLE_SIZE;
}
}
}
else {
printf(" SCI Lib Error %d\n", my_sci_err);
}
}
sci_killhandler();
END:
exit(0);
}
int statcoll_main(int argc, char **argv)
{
struct sci_config my_sci_config;
enum sci_err my_sci_err;
int c;
unsigned int delay_us;
unsigned int iterations;
unsigned int overflow_threshold;
unsigned int disable = 0;
unsigned int min_addr;
unsigned int max_addr;
delay_us = 1000000;
accumulation_type = 2;
iterations = 0;
overflow_counter_index = 1;
overflow_threshold = 0;
while ((c = getopt (argc, argv, "hnm:d:a:i:o:t:r:D")) != -1) {
switch (c)
{
case 'h':
printf("\n\tomapconf trace bw [-h] [-m 0xyy or MA_MPU_1_2] [-d x] [-a 1 or 2] [-i x] [-o x -t y] [-r 0xaaaaaaaa-0xbbbbbbbb] [-n]\n");
printf("\n\t-m 0xaa or MA_MPU_1_2\n");
printf("\t\tMaster initiator\n");
printf("\t\tMA_MPU_1_2 - Non DMM MPU memory traffic, see Examples\n");
printf("\t\tSCI_MASTID_ALL 0x%x\n", SCI_MASTID_ALL);
printf("\t\tSCI_MSTID_MPUSS 0x%x\n",SCI_MSTID_MPUSS );
printf("\t\tSCI_MSTID_DAP 0x%x\n", SCI_MSTID_DAP);
printf("\t\tSCI_MSTID_DSP 0x%x\n", SCI_MSTID_DSP);
printf("\t\tSCI_MSTID_IVA 0x%x\n", SCI_MSTID_IVA);
printf("\t\tSCI_MSTID_ISS 0x%x\n", SCI_MSTID_ISS);
printf("\t\tSCI_MSTID_IPU 0x%x\n", SCI_MSTID_IPU);
printf("\t\tSCI_MSTID_FDIF 0x%x\n", SCI_MSTID_FDIF);
printf("\t\tSCI_MSTID_SDMA_RD 0x%x\n", SCI_MSTID_SDMA_RD);
printf("\t\tSCI_MSTID_SDMA_WR 0x%x\n", SCI_MSTID_SDMA_WR);
printf("\t\tSCI_MSTID_GPU_P1 0x%x\n", SCI_MSTID_GPU_P1);
printf("\t\tSCI_MSTID_GPU_P2 0x%x\n", SCI_MSTID_GPU_P2);
printf("\t\tSCI_MSTID_BB2D_P1 0x%x (GC320)\n", SCI_MSTID_BB2D_P1);
printf("\t\tSCI_MSTID_BB2D_P2 0x%x (GC320)\n", SCI_MSTID_BB2D_P2);
printf("\t\tSCI_MSTID_DSS 0x%x\n", SCI_MSTID_DSS);
printf("\t\tSCI_MSTID_C2C 0x%x\n", SCI_MSTID_C2C);
printf("\t\tSCI_MSTID_LLI 0x%x\n", SCI_MSTID_LLI);
printf("\t\tSCI_MSTID_HSI 0x%x\n", SCI_MSTID_HSI);
printf("\t\tSCI_MSTID_UNIPRO1 0x%x\n", SCI_MSTID_UNIPRO1);
printf("\t\tSCI_MSTID_UNIPRO2 0x%x\n", SCI_MSTID_UNIPRO2);
printf("\t\tSCI_MSTID_MMC1 0x%x\n", SCI_MSTID_MMC1);
printf("\t\tSCI_MSTID_MMC2 0x%x\n", SCI_MSTID_MMC2);
printf("\t\tSCI_MSTID_SATA 0x%x\n", SCI_MSTID_SATA);
printf("\t\tSCI_MSTID_USB_HOST_HS 0x%x\n", SCI_MSTID_USB_HOST_HS);
printf("\t\tSCI_MSTID_USB_OTG_HS 0x%x\n", SCI_MSTID_USB_OTG_HS);
printf("\n\t-d xxx or 0.xx\n");
printf("\t\tDelay in ms between 2 captures, can be float\n");
printf("\n\t-a 1 or 2\n");
printf("\t\taccumulation type. 2: dump at every capture. 1: dump only at end\n");
printf("\n\t-i x\n");
printf("\t\tnumber of iterations (for -a 1). You can Ctrl-C during test, current captures will be displayed\n");
printf("\n\t-o x -t y \n");
printf("\t\tindex for overflow handling (0=Wr_EMIF0,1=Wr_EMIF1,2=Rd_EMIF0,3=Rd_EMIF1) + threshold to reset HW. You must use them for -a 1\n");
printf("\n\t-r 0xaa-0xbb\n");
printf("\t\taddress filtering, like 0x9b000000-0x9f000000\n");
printf("\n\t-n\n");
printf("\t\tno sleep of 32kHz (work-around for 32kHz reading HW bug). MANDATORY for OMAP5 until fix is found\n");
printf("\n\t-D\n");
printf("\t\tdisable statcol (deprecated)\n");
printf("\n\tExamples:\n");
printf("\t-m 0x70 -d 0.3 -a 1 -i 40000 -o 2 -t 3000000000\n");
printf("\t\taccumulation 1 is reading of registers and storing in RAM. Result is dumped at the end with CCS format to reuse\n");
printf("\t\texisting post-processing. So you must set iterations. Overflow is taken into account. Suits small delays\n");
printf("\n\t-m 0x70 -d 1000 -a 2 -o 2 -t 3000000000 (often used as -m 0x70 only)\n");
printf("\t\taccumulation 2 is reading of registers and tracing them immediately\n");
printf("\t\tFormat is time: time_start time_end delta_time -> Wr_EMIF0 Wr_EMIF1 Rd_EMIF0 Rd_EMIF1 (MB/s)\n");
printf("\n\t-m MA_MPU_1_2 -d 1000 -a 2 -o 2 -t 3000000000\n");
printf("\t\tMA_MPU is MPU memory adaptor, a direct path to EMIF. There are 2 MA. MA_MPU_1_2 will display:\n");
printf("\t\tWr_MA_MPU_1 Wr_MA_MPU_2 Rd_MA_MPU_1 Rd_MA_MPU_2 (MB/s)\n");
printf("\n\tDefault settings:\n");
printf("\t\t-m 0xcd -d 1000 -a 2 -i 0 -o 0 -t 0\n");
printf("\t\tall initiators, 1000ms delay, accumulation 2, infinite iterations, overflow on counter 0, threshold=0 i.e. always stop/restart HW IP after 1 capture\n");
printf("\n\tPost-processing (for -a 1):\n");
printf("\t\tgit clone git://gitorious.tif.ti.com/omap-video-perf/runperf.git, instrumentation/bandwidth/BWstats_ccsv5.py\n");
printf("\t\tpython-matplotlib is needed\n");
printf("\n\tWiki:\n");
printf("\t\t<http://opbuwiki.dal.design.ti.com/index.php/L3_bus_monitoring_SW_tool>\n\n");
sci_global_disable(psci_hdl);
sci_close(&psci_hdl);
return 0;
case 'm':
if (strstr(optarg, "0x")) {
int a;
sscanf(optarg, "%x", &a);
my_config_emif1.filter[0].mstr_addr_match = a;
my_config_emif2.filter[0].mstr_addr_match = a;
my_config_emif3.filter[0].mstr_addr_match = a;
my_config_emif4.filter[0].mstr_addr_match = a;
printf("Master: %x\n", a);
}
else if (strstr(optarg, "ma_mpu_1_2")) {
my_config_emif1.probe_id = SCI_MA_MPU_P1;
my_config_emif2.probe_id = SCI_MA_MPU_P2;
my_config_emif3.probe_id = SCI_MA_MPU_P1;
my_config_emif4.probe_id = SCI_MA_MPU_P2;
printf("Master: MA_MPU_1 and MA_MPU_2\n");
}
break;
case 'd':
{
float a;
sscanf(optarg, "%f", &a);
delay_us = a * 1000;
}
break;
case 'a':
sscanf(optarg, "%u", &accumulation_type);
break;
case 'i':
sscanf(optarg, "%u", &iterations);
break;
case 'o':
sscanf(optarg, "%u", &overflow_counter_index);
break;
case 't':
sscanf(optarg, "%u", &overflow_threshold);
break;
case 'n':
nosleep_32k = 1;
break;
case 'r':
sscanf(optarg, "0x%x-0x%x", &min_addr, &max_addr);
my_config_emif1.addr_filter_min = min_addr;
my_config_emif2.addr_filter_min = min_addr;
my_config_emif3.addr_filter_min = min_addr;
my_config_emif4.addr_filter_min = min_addr;
my_config_emif1.addr_filter_max = max_addr;
my_config_emif2.addr_filter_max = max_addr;
my_config_emif3.addr_filter_max = max_addr;
my_config_emif4.addr_filter_max = max_addr;
my_config_emif1.addr_filter_enable = true;
my_config_emif2.addr_filter_enable = true;
my_config_emif3.addr_filter_enable = true;
my_config_emif4.addr_filter_enable = true;
break;
case 'D':
disable = 1;
default:
printf("Unknown option\n");
}
}
printf("delay in us: %u\n", delay_us);
printf("accumulation type: %u\n", accumulation_type);
printf("iterations (0=infinite): %u\n", iterations);
printf("Overflow counter index: %u\n", overflow_counter_index);
printf("Overflow threshold: %u\n", overflow_threshold);
if ((accumulation_type == 1) && (overflow_threshold == 0))
printf("WARNING: it is not recommended to set -a 1 with -t 0 if -d is small. HW is reset at every capture !\n");
if (iterations > MAX_ITERATIONS) {
iterations = MAX_ITERATIONS;
printf("WARNING: MAX_ITERATIONS(%d) exceeded\n", iterations);
}
omapconf_emu_enable_domain();
/////////////////////////////////////////////////////
//Make sure DebugSS is powered up and enabled //
/////////////////////////////////////////////////////
my_sci_config.errhandler = sci_errhandler;
my_sci_config.data_options = 0; //Disable options
my_sci_config.trigger_enable = false;
my_sci_config.sdram_msg_rate = 1;
my_sci_config.mstr_msg_rate = 1;
my_sci_config.mode = SCI_MODE_DUMP;
addr_32k = mem_map_32k();
my_sci_err = sci_open(&psci_hdl, &my_sci_config);
if (SCI_SUCCESS != my_sci_err) exit(-1);
{
uint32_t plib_major_ver;
uint32_t plib_minor_ver;
uint32_t plib_func_id;
uint32_t pmod_func_id;
sci_get_version(psci_hdl, &plib_major_ver, &plib_minor_ver,
&plib_func_id, &pmod_func_id );
if ( plib_func_id != pmod_func_id )
{
printf ("Error - func missmatch with device %d %d\n", plib_func_id, pmod_func_id);
sci_close(&psci_hdl);
exit(-1);
}
}
// Test
{
unsigned int i, j;
num_use_cases = sizeof(pmy_cfg)/sizeof(struct sci_config_sdram *);
for (i = 0; i < num_use_cases; i++) {
my_sci_err = sci_reg_usecase_sdram(psci_hdl, pmy_cfg[i], &my_usecase_key[i] );
if ( SCI_SUCCESS != my_sci_err) break;
valid_usecase_cnt++;
}
/* If you kill the process, statcoll is left running. this is an option to disable it. We should intercept and handle signal */
if (disable == 1) {
sci_global_disable(psci_hdl);
sci_close(&psci_hdl);
return 0;
}
/* And this is an ugly hack to disable it so that it will reset counters at enable */
sci_global_disable(psci_hdl);
if (nosleep_32k)
nosleep_32k_enable();
if (valid_usecase_cnt == num_use_cases)
{
uint32_t *counters_current = counters;
if (accumulation_type == 1) {
for (tests = 0; tests < (iterations * 9); tests++)
counters[tests] = 0;
my_sci_err = sci_global_enable(psci_hdl);
for (tests = 0; tests < iterations; tests++) {
usleep(delay_us);
*counters_current = GET_32K;
sci_dump_sdram_cntrs(num_use_cases, counters_current + 1);
if (*(counters_current + 1 + overflow_counter_index) >= overflow_threshold) {
sci_global_disable(psci_hdl);
sci_global_enable(psci_hdl);
counters_current += 1 + num_use_cases;
*counters_current = GET_32K;
sci_dump_sdram_cntrs(num_use_cases, counters_current + 1);
tests++;
//printf("overflow %u\n", *counters_current - counters[0]);
}
counters_current += 1 + num_use_cases;
}
}
else {
uint32_t *counters_prev;
uint32_t *counters_overflow;
unsigned int overflow_on;
uint32_t delta_time;
for (i = 0; i < sizeof(counters)/4; i++)
counters[i] = 0;
counters_prev = counters;
counters_current = counters + 1 + num_use_cases;
counters_overflow = counters + 2 + 2 * num_use_cases;
sci_global_enable(psci_hdl);
*counters_prev = GET_32K;
sci_dump_sdram_cntrs(num_use_cases, counters_prev + 1);
for (;;) {
usleep(delay_us);
*counters_current = GET_32K;
sci_dump_sdram_cntrs(num_use_cases, counters_current + 1);
if (*(counters_current + 1 + overflow_counter_index ) >= overflow_threshold) {
//printf("DEBUG1 %u %u %u %u\n", *counters_prev, *(counters_prev + 1), *(counters_prev + 2), *(counters_prev + 3));
//printf("DEBUG2 %u %u %u %u\n", *counters_current, *(counters_current + 1), *(counters_current + 2), *(counters_current + 3));
sci_global_disable(psci_hdl);
sci_global_enable(psci_hdl);
*counters_overflow = GET_32K;
sci_dump_sdram_cntrs(num_use_cases, counters_overflow + 1);
overflow_on = 1;
}
/* trace current - prev */
delta_time = *counters_current - *counters_prev;
printf("time: %u %u %u -> ", *counters_current, *counters_prev, delta_time);
for (j = 0; j < num_use_cases; j++) {
printf("%.2f ", ((float)(*(counters_current + 1 + j) - *(counters_prev + 1 + j))/1000000)*32768.0/delta_time);
}
printf("\n");
/* pointers increment */
if (overflow_on == 1) {
overflow_on = 0;
printf("Warning: statcoll HW IP reset to avoid overflow (user defined through -o -t)\n");
counters_current = counters_overflow;
}
counters_prev = counters_current;
if ((unsigned int)(counters_current - counters) == (2 + 2 * num_use_cases))
counters_current = counters;
else
counters_current += 1 + num_use_cases;
counters_overflow = counters_current;
if ((unsigned int)(counters_overflow - counters) == (2 + 2 * num_use_cases))
counters_overflow = counters;
else
counters_overflow += 1 + num_use_cases;
}
}
}
else {
printf(" SCI Lib Error %d\n", my_sci_err);
}
}
sci_killhandler();
exit(0);
}
const char * /* Original version by Solomon Peachy */
version_guess_from_hashcode(sci_version_t *result, int *res_version, guint32 *code)
{
int i;
int fd = -1;
int left = VERSION_DETECT_HASH_SIZE;
guint32 hash_code;
guint8 buf[VERSION_DETECT_BUF_SIZE];
if (IS_VALID_FD(fd = sci_open("resource.001", O_RDONLY|O_BINARY))) {
hash_code = HASHCODE_MAGIC_RESOURCE_001;
} else if (IS_VALID_FD(fd = sci_open("resource.000", O_RDONLY|O_BINARY))) {
hash_code = HASHCODE_MAGIC_RESOURCE_000;
} else {
sciprintf("Warning: Could not find RESOURCE.000 or RESOURCE.001, cannot determine hash code\n");
*code = 0;
/* complete and utter failure */
return NULL;
}
while (left > 0) {
int len = read(fd, buf, left < VERSION_DETECT_BUF_SIZE ? left : VERSION_DETECT_BUF_SIZE);
if (len == -1) {
sciprintf("Warning: read error while computing hash code for resource file\n");
*code = 0;
return NULL;
}
if (len == 0)
/* EOF */
break;
for (i = 0; i < len; i++)
hash_code = (hash_code * 19) + *(buf + i);
/* This is the string hashing algorithm used by Objective Caml 3.08; the general idea
** of multiplying the previous hash code with a prime number between 5 and 23 appears
** to be generally considered to be a "good" approach to exhausting the entire 32 bit
** number space in a somewhat equal distribution. For large chunks of data, such as
** SCI resource files, this should both perform well and yield a good distribution,
** or at least that's what standard library designers have been assuming for quite a
** while. */
left -= len;
}
close(fd);
*code = hash_code;
for (i = 0 ; sci_games[i].name ; i++) {
if (sci_games[i].id == hash_code) {
*result = sci_games[i].version;
*res_version = sci_games[i].res_version;
return sci_games[i].name;
}
}
return NULL; /* Failed to find matching game */
}