diff options
Diffstat (limited to 'meta-agl-bsp/meta-ti/recipes-arago/weston')
20 files changed, 5697 insertions, 0 deletions
diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-Add-soc-performance-monitor-utilites.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-Add-soc-performance-monitor-utilites.patch new file mode 100644 index 000000000..751a7cee9 --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-Add-soc-performance-monitor-utilites.patch @@ -0,0 +1,3565 @@ +From 7830118ecb980766f4a6e3997769d7ae326bee77 Mon Sep 17 00:00:00 2001 +From: Karthik Ramanan <a0393906@ti.com> +Date: Fri, 3 Jun 2016 18:32:50 +0530 +Subject: [PATCH] Add soc performance monitor utilites + +Signed-off-by: Karthik Ramanan <a0393906@ti.com> +--- + Makefile.am | 17 +- + clients/Dra7xx_ddrstat_speed.c | 494 +++++++++++++ + clients/soc_performance_monitor.c | 625 ++++++++++++++++ + clients/soc_performance_monitor.h | 40 ++ + clients/statcoll.c | 1433 +++++++++++++++++++++++++++++++++++++ + clients/statcoll.h | 152 ++++ + clients/statcoll_gui.h | 101 +++ + clients/time_bar_graph.c | 515 +++++++++++++ + clients/time_bar_graph.h | 93 +++ + 10 files changed, 4873 insertions(+), 1 deletion(-) + create mode 100644 clients/Dra7xx_ddrstat_speed.c + create mode 100644 clients/soc_performance_monitor.c + create mode 100644 clients/soc_performance_monitor.h + create mode 100644 clients/statcoll.c + create mode 100644 clients/statcoll.h + create mode 100644 clients/statcoll_gui.h + create mode 100644 clients/time_bar_graph.c + create mode 100644 clients/time_bar_graph.h + +diff --git a/Makefile.am b/Makefile.am +index 62719c9..55aed6d 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -432,7 +432,9 @@ demo_clients = \ + weston-fullscreen \ + weston-stacking \ + weston-calibrator \ +- weston-scaler ++ weston-scaler \ ++ soc-performance-monitor \ ++ soc-ddr-bw-visualizer + + if INSTALL_DEMO_CLIENTS + bin_PROGRAMS += $(demo_clients) +@@ -570,6 +572,19 @@ weston_image_SOURCES = clients/image.c + weston_image_LDADD = libtoytoolkit.la + weston_image_CFLAGS = $(AM_CFLAGS) $(CLIENT_CFLAGS) + ++noinst_LTLIBRARIES += libtimebargraph.la ++libtimebargraph_la_SOURCES = clients/time_bar_graph.c clients/time_bar_graph.h ++libtimebargraph_la_LIBADD = libtoytoolkit.la ++libtimebargraph_la_CFLAGS = $(AM_CFLAGS) $(CLIENT_CFLAGS) $(CAIRO_CFLAGS) $(CAIRO_EGL_CFLAGS) ++ ++soc_performance_monitor_SOURCES = clients/soc_performance_monitor.c clients/soc_performance_monitor.h ++soc_performance_monitor_LDADD = libtoytoolkit.la libtimebargraph.la ++soc_performance__CFLAGS = $(AM_CFLAGS) $(CLIENT_CFLAGS) ++ ++soc_ddr_bw_visualizer_SOURCES = clients/statcoll.c clients/Dra7xx_ddrstat_speed.c clients/statcoll.h clients/statcoll_gui.h ++soc_ddr_bw_visualizer_LDADD = libtoytoolkit.la libtimebargraph.la ++soc_ddr_bw_visualizer__CFLAGS = $(AM_CFLAGS) $(CLIENT_CFLAGS) ++ + weston_cliptest_SOURCES = \ + clients/cliptest.c \ + src/vertex-clipping.c \ +diff --git a/clients/Dra7xx_ddrstat_speed.c b/clients/Dra7xx_ddrstat_speed.c +new file mode 100644 +index 0000000..af06733 +--- /dev/null ++++ b/clients/Dra7xx_ddrstat_speed.c +@@ -0,0 +1,494 @@ ++/* ++ * Copyright (C) 2015 Texas Instruments ++ * Author: Karthik Ramanan <karthik.ramanan@ti.com> ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 as published by ++ * the Free Software Foundation. ++ * ++ * This program is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for ++ * more details. ++ * ++ * You should have received a copy of the GNU General Public License along with ++ * this program. If not, see <http://www.gnu.org/licenses/>. ++ */ ++ ++#include <stdio.h> ++#include <stdlib.h> ++#include <stdint.h> ++#include <string.h> ++#include <sys/mman.h> ++#include <sys/time.h> ++#include <unistd.h> ++#include <fcntl.h> ++#include "statcoll.h" ++ ++#define PAGE_SIZE 4096 ++ ++#define EMIF1_BASE 0x4c000000 ++#define EMIF2_BASE 0x4d000000 ++ ++#define EMIF_PERF_CNT_1 0x80 ++#define EMIF_PERF_CNT_2 0x84 ++#define EMIF_PERF_CNT_CFG 0x88 ++#define EMIF_PERF_CNT_TIM 0x90 ++ ++static unsigned ++tv_diff(struct timeval *tv1, struct timeval *tv2) ++{ ++ return (tv2->tv_sec - tv1->tv_sec) * 1000000 + ++ (tv2->tv_usec - tv1->tv_usec); ++} ++ ++ ++struct emif_perf { ++ int code; ++ const char *name; ++}; ++ ++static const struct emif_perf emif_perf_tab[] = { ++ { 0, "access" }, ++ { 1, "activate" }, ++ { 2, "read" }, ++ { 3, "write" }, ++ { 4, "fifo_cmd" }, ++ { 5, "fifo_write" }, ++ { 6, "fifo_read" }, ++ { 7, "fifo_ret" }, ++ { 8, "prio" }, ++ { 9, "cmd_pend" }, ++ { 10, "data" }, ++}; ++ ++static void *emif1, *emif2; ++static int BANDWIDTH=0; ++static int DELAY = 1; ++static int EMIF_PERF_CFG1 = 9; ++static int EMIF_PERF_CFG2 = 10; ++ ++ ++static int STATCOLL=0; ++static int TOTAL_TIME; ++static int INTERVAL_US; ++ ++struct timeval t1, t2; ++ ++FILE* outfile; ++struct emif_stats { ++ uint32_t cycles; ++ uint32_t cnt1; ++ uint32_t cnt2; ++}; ++ ++static struct emif_stats emif1_start, emif1_end; ++static struct emif_stats emif2_start, emif2_end; ++ ++static void *emif_init(int fd, unsigned base) ++{ ++ void *mem = ++ mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, base); ++ volatile uint32_t *emif = mem,temp; ++ ++ if (mem == MAP_FAILED){ ++ return NULL; ++ } ++ ++ emif[EMIF_PERF_CNT_CFG>>2] = EMIF_PERF_CFG2 << 16 | EMIF_PERF_CFG1; ++ ++ return mem; ++} ++ ++static void emif_read(volatile uint32_t *emif, struct emif_stats *st) ++{ ++ st->cycles = emif[EMIF_PERF_CNT_TIM>>2]; ++ st->cnt1 = emif[EMIF_PERF_CNT_1>>2]; ++ st->cnt2 = emif[EMIF_PERF_CNT_2>>2]; ++} ++ ++static void emif_print(const char *tag, struct emif_stats *st1, ++ struct emif_stats *st2) ++{ ++ uint32_t cycles = st2->cycles - st1->cycles; ++ uint32_t cnt1 = st2->cnt1 - st1->cnt1; ++ uint32_t cnt2 = st2->cnt2 - st1->cnt2; ++ printf("%s %s %2llu%% %s %2llu%%", tag, ++ emif_perf_tab[EMIF_PERF_CFG1].name, 100ull*cnt1/cycles, ++ emif_perf_tab[EMIF_PERF_CFG2].name, 100ull*cnt2/cycles); ++ fprintf(outfile,"%s%s= %2llu,%s%s= %2llu,", ++ tag, emif_perf_tab[EMIF_PERF_CFG1].name, 100ull*cnt1/cycles, ++ tag, emif_perf_tab[EMIF_PERF_CFG2].name, 100ull*cnt2/cycles); ++} ++ ++static int perf_init(void) ++{ ++ int fd = open("/dev/mem", O_RDWR); ++ int err = 0; ++ ++ if (fd == -1){ ++ printf("error fd=open() \n"); ++ return -1; ++ } ++ emif1 = emif_init(fd, EMIF1_BASE); ++ emif2 = emif_init(fd, EMIF2_BASE); ++ ++ if (!emif1 || !emif2){ ++ printf("error if (!emif1 || !emif2) \n"); ++ err = -1; ++ } ++ ++ close(fd); ++ return err; ++} ++ ++static void perf_start(void) ++{ ++ if (emif1) { ++ emif_read(emif1, &emif1_start); ++ emif_read(emif2, &emif2_start); ++ } ++} ++ ++static void perf_stop(void) ++{ ++ if (emif1) { ++ emif_read(emif1, &emif1_end); ++ emif_read(emif2, &emif2_end); ++ } ++} ++ ++static void perf_print(void) ++{ ++ if (emif1) { ++ emif_print("EMIF1", &emif1_start, &emif1_end); ++ printf("\t"); ++ emif_print("EMIF2", &emif2_start, &emif2_end); ++ printf("\r"); ++ fprintf(outfile, "\n"); ++ fflush(outfile); ++ fflush(stdout); ++ } ++} ++ ++static void perf_close(void) ++{ ++ if (emif1) munmap(emif1, PAGE_SIZE); ++ if (emif2) munmap(emif2, PAGE_SIZE); ++} ++ ++static int get_cfg(const char *name, int def) ++{ ++ char *end; ++ int n = strtol(name, &end, 0); ++ int i; ++ ++ if (!*end) ++ return n; ++ ++ for (i = 0; i < sizeof(emif_perf_tab)/sizeof(emif_perf_tab[0]); i++) ++ if (!strcmp(name, emif_perf_tab[i].name)) ++ return emif_perf_tab[i].code; ++ ++ return def; ++} ++ ++ ++unsigned int emif_freq() ++{ ++ volatile unsigned *tim1; ++ unsigned v1, v2; ++ int fd; ++ ++ /*calculation EMIF frequency ++ EMIF_PERF_CNT_TIM = \n32-bit counter that ++ continuously counts number for ++ EMIF_FCLK clock cycles elapsed ++ after EMIFis brought out of reset*/ ++ ++ fd = open("/dev/mem", O_RDONLY); ++ if (fd == -1) { ++ perror("/dev/mem"); ++ return 1; ++ } ++ ++ void *mem = ++ mem = mmap(NULL, PAGE_SIZE, PROT_READ, MAP_SHARED, fd, EMIF1_BASE); ++ if (mem == MAP_FAILED) { ++ perror("mmap"); ++ exit(1); ++ } ++ ++ tim1 = (unsigned *)((char*)mem + EMIF_PERF_CNT_TIM); ++ ++ v1 = *tim1; ++ gettimeofday(&t1, NULL); ++ sleep(2); ++ v2 = *tim1; ++ gettimeofday(&t2, NULL); ++ ++ munmap(mem, PAGE_SIZE); ++ close(fd); ++ ++ return (v2 - v1) / tv_diff(&t1, &t2); ++ ++} ++ ++ ++char config_file_path[100]; ++char keylist[][50] = { ++ "DELAY", ++ "EMIF_PERF_CFG1", ++ "EMIF_PERF_CFG2", ++ "BANDWIDTH", ++ "STATCOLL", ++ "TOTAL_TIME", ++ "INTERVAL_US", ++ "INITIATORS", ++}; ++ ++char line[512], *p; ++char tokens[6][512]; ++int temp, flag = 0; ++char *keyvalue, *pair; ++char key[100]; ++int linecount=0; ++ ++ ++int debug=0; ++ ++void print_valid_options(void) ++{ ++ int i; ++ printf("Invalid key found\n"); ++ printf("Supported keys are :\n"); ++ for(i=0; i<sizeof(keylist)/sizeof(keylist[0]); i++) ++ printf("\t\t %s\n", keylist[i]); ++ ++} ++int validatekey(char *ptr) ++{ ++ int i; ++ for(i=0; i<sizeof(keylist)/sizeof(keylist[0]); i++) ++ if(strcmp(ptr, keylist[i]) == 0) ++ return 0; ++ ++ return 1; ++} ++ ++void add_key_value(char *key, int value) ++{ ++ printd("%s", "Inside add_key_value\n"); ++ ++ if(strcmp(key, "BANDWIDTH") == 0) { ++ BANDWIDTH = value; ++ return; ++ } ++ if(strcmp(key, "STATCOLL") == 0) { ++ STATCOLL = value; ++ return; ++ } ++ else ++ printd("%s", "********** UNKNOWN**********"); ++ ++ if(BANDWIDTH == 1) { ++ if(strcmp(key, "DELAY") == 0) ++ DELAY = value; ++ else if(strcmp(key, "EMIF_PERF_CFG1") == 0) ++ EMIF_PERF_CFG1 = value; ++ else if(strcmp(key, "EMIF_PERF_CFG2") == 0) ++ EMIF_PERF_CFG2 = value; ++ } ++ else ++ printf("NOTE: BANDWIDTH is not enabled, ignoring %s\n", key); ++ ++ ++ if(STATCOLL == 1) { ++ if(strcmp(key, "INTERVAL_US") == 0) ++ INTERVAL_US = value; ++ else if(strcmp(key, "TOTAL_TIME") == 0) ++ TOTAL_TIME = value; ++ } ++ else ++ printf("NOTE: STATCOLL is not enabled, ignoring %s\n", key); ++} ++ ++void bandwidth_usage() { ++ ++ printf("#########################################################\n##\n" ++ ++ "## usage : ./Dra7xx_ddrstat <DELAY> <EMIF_PERF_CFG1> <EMIF_PERF_CFG2> \n" ++ "## default : DELAY=1 EMIF_PERF_CFG1=9 EMIF_PERF_CFG2=10\n" ++ "## option : for EMIF_PERF_CFG1 and EMIF_PERF_CFG2\n" ++ "## 0 -> access,\n" ++ "## 1 -> activate,\n" ++ "## 2 -> read,\n" ++ "## 3 -> write,\n" ++ "## 4 -> fifo_cmd,\n" ++ "## 5 -> fifo_write,\n" ++ "## 6 -> fifo_read,\n" ++ "## 7 -> fifo_ret,\n" ++ "## 8 -> prio,\n" ++ "## 9 -> cmd_pend,\n" ++ "## 10 -> data \n##\n" ++ ++ "## EMIF frq : %d MHz\n\n", emif_freq() ); ++} ++ ++ ++int main(int argc, char **argv) ++{ ++ int option; ++ FILE *fp; ++ int i; ++ int xpos = 600, ypos = 40; ++ ++ ++ /* Read config file */ ++ /* Initialize this to turn off verbosity of getopt */ ++ opterr = 0; ++ ++// while ((option = getopt (argc, argv, "df:")) != -1) ++ while ((option = getopt (argc, argv, "dx:y:")) != -1) ++ { ++ switch(option) ++ { ++#if 0 ++ case 'f': ++ strcpy(config_file_path, optarg); ++ break; ++#endif ++ case 'd': ++ debug=1; ++ break; ++ case 'x': ++ xpos=atoi(optarg); ++ break; ++ case 'y': ++ ypos=atoi(optarg); ++ break; ++ ++ default: ++ printf("Invalid option.. Exiting\n"); ++ exit(0); ++ } ++ } ++ ++ printf("xpos = %d, ypos = %d\n", xpos, ypos); ++ ++ strcpy(config_file_path,"config.ini"); ++ fp = fopen(config_file_path, "r"); ++ if (fp == NULL) { ++ fprintf(stderr, "couldn't open the specified file\n"); ++ return -1; ++ } ++ ++ while (fgets(line, sizeof line, fp)) { ++ printd("Line is = %s", line); ++ ++ if (line[0] == '#' || line[0] == '\n') { ++ continue; ++ } ++ ++ memset(tokens, 0, sizeof(tokens)); ++ i = 0; ++ ++ pair = strtok (line," ,"); ++ while (pair != NULL) ++ { ++ printd ("\tPair is = %s\n",pair); ++ strcpy(tokens[i++], pair); ++ pair = strtok (NULL, " ,.-"); ++ } ++ ++ for(temp=0; temp< i; temp++) ++ { ++ printd("Line %d: %s\n", temp, tokens[temp]); ++ ++ keyvalue = strtok (tokens[temp]," ="); ++ while (keyvalue != NULL) ++ { ++ if(flag == 0) ++ { ++ if(validatekey(keyvalue)) ++ { ++ print_valid_options(); ++ exit(0); ++ } ++ strcpy(key, keyvalue); ++ printd ("\tKey is = %s\n",key); ++ flag++; ++ } ++ else ++ { ++ printd ("\tValue is = %s",keyvalue); ++ printd (" (%d)\n", atoi(keyvalue)); ++ add_key_value(key, atoi(keyvalue)); ++ flag = 0; ++ } ++ keyvalue = strtok (NULL, " ="); ++ } ++ } ++ ++ ++ ++ linecount++; ++ printd("%s", "------------------- \n"); ++ ++ } ++ ++ fclose(fp); ++ ++ printf("\n\nCOMPLETED: Parsing of the user specified parameters.. \n \ ++ \nConfiguring device now.. \n\n"); ++ if(BANDWIDTH == 1) { ++ bandwidth_usage(); ++ if (DELAY <= 0) ++ DELAY = 1; ++ ++ if (perf_init()){ ++ printf("perf_init return non zero \n"); ++ return 1; ++ } ++ ++ outfile = fopen("emif-performance.csv", "w+"); ++ if (!outfile) { ++ printf("\n Error opening file"); ++ } ++ for (;;) { ++ perf_start(); ++ sleep(DELAY); ++ perf_stop(); ++ perf_print(); ++ } ++ ++ fclose(outfile); ++ perf_close(); ++ return 0; ++ } ++ ++ if(STATCOLL == 1) { ++ printf("STATISTICS COLLECTOR option chosen\n"); ++ printf("------------------------------------------------\n\n"); ++ fp = fopen("initiators.cfg", "r"); ++ if (fp == NULL) { ++ fprintf(stderr, "couldn't open the specified file initiators.cfg'\n"); ++ return -1; ++ } ++ ++ int i=0; ++ char list[100][50]; ++ memset(list, sizeof(list), 0); ++ while (fgets(line, sizeof line, fp)) { ++ printf("Line is = %s", line); ++ /* Slightly strange way to chop off the \n character */ ++ strtok(line, "\n"); ++ strcpy(list[i++], line); ++ } ++ fclose(fp); ++ ++ statcoll_start(TOTAL_TIME, INTERVAL_US, list, xpos, ypos); ++ } ++ ++} ++ +diff --git a/clients/soc_performance_monitor.c b/clients/soc_performance_monitor.c +new file mode 100644 +index 0000000..5d1db32 +--- /dev/null ++++ b/clients/soc_performance_monitor.c +@@ -0,0 +1,625 @@ ++/* ++ * Copyright (C) 2016 Texas Instruments ++ * Author: Karthik Ramanan <karthik.ramanan@ti.com> ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 as published by ++ * the Free Software Foundation. ++ * ++ * This program is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for ++ * more details. ++ * ++ * You should have received a copy of the GNU General Public License along with ++ * this program. If not, see <http://www.gnu.org/licenses/>. ++ */ ++ ++#include <stdint.h> ++#include <stdio.h> ++#include <stdlib.h> ++#include <string.h> ++#include <stdint.h> ++#include <signal.h> ++#include <time.h> ++#include <math.h> ++#include <unistd.h> ++#include <sys/time.h> ++#include <pthread.h> ++#include <errno.h> ++#include <unistd.h> ++#include <fcntl.h> ++#include <sys/stat.h> ++ ++#include "time_bar_graph.h" ++ ++#include "soc_performance_monitor.h" ++ ++static int debug=0; ++ ++static char readfifo[100]; ++static int MAX_WIDTH=1920; ++static int MAX_HEIGHT=1080; ++static int x_pos=0; ++static int y_pos=40; ++ ++void *ctx; ++struct time_graph_create_params tg_p; ++struct bar_graph_create_params bg_p; ++ ++static int cpu_load_offset = 0; ++static int total_cpu_load_items = 0; ++static int total_elements = 0; ++ ++struct _bar_graph_y_config *y_cfg; ++struct _text_config *t_cfg; ++char *tg_text[100]; ++char *bg_text[100]; ++ ++ ++int command_handler(int command, double *y, char **text) ++{ ++ static int fd; ++ char buf[MAX_BUF]; ++ int i, bytes, offset; ++ ++ switch(command) ++ { ++ case OPEN: ++ fd = open(readfifo, O_RDONLY|O_NONBLOCK); ++ break; ++ ++ case READ: ++ ++ /* open, read, and display the message from the FIFO */ ++ bytes=read(fd, buf, MAX_BUF); ++ buf[bytes]='\0'; ++ if(bytes > 0) ++ { ++ char command[100]; ++ char string[100]; ++ sscanf(buf, "%s %s", command, string); ++ printd("Received %s\n", buf); ++ if(strcmp(command, "TABLE:") == 0) ++ { ++ char field[100], value[100], unit[100]; ++ sscanf(buf, "%s %s %s %s", command, field, value, unit); ++ for(i=0; i<cpu_load_offset; i++) { ++ if(strcmp(text[i*2], field) == 0) { ++ printd("Updating value(%s), unit(%s)\n", value, unit); ++ sprintf(text[i*2+1], "%s %s", value, unit); ++ } ++ } ++ } ++ else if(strcmp(command, "CPULOAD:") == 0) ++ { ++ char field[100], value[100]; ++ ++ sscanf(buf, "%s %s %s", command, field, value); ++ ++ for(i=cpu_load_offset; i<cpu_load_offset+total_cpu_load_items; i++) { ++ if(strcmp(text[i*2], field) == 0) { ++ y[i*2+1] = atoi(value)/100.0; ++ sprintf(text[i*2+1], " %02s%s", value,"%"); ++ printd("CPULOAD: Updating %s with %s\n", field, value); ++ } ++ } ++ } ++ else if(strcmp(command, "MOVE:") == 0) ++ { ++ char value[100]; ++ printd("Received MOVE command : %s\n", buf); ++ sscanf(string, "%s", value); ++ sprintf(tg_p.title, "CPU Usage[@position-req=%sx%d]", value, y_pos); ++ move_graph(ctx, &tg_p); ++ } ++ else ++ { ++ printf("ERROR: Received unexpected data from FIFO - \" %s \" \n", buf); ++ } ++ memset(buf, 0x0, sizeof(buf)); ++ } ++ ++ break; ++ ++ case CLOSE: ++ close(fd); ++ break; ++ } ++ return bytes; ++} ++ ++volatile sig_atomic_t sigtermed = 0; ++ ++void my_signal_handler(int signum) ++{ ++ if (signum == SIGTERM || signum == SIGINT) { ++ sigtermed = 1; ++ } ++} ++ ++int get_strings_in_section(char *string, char **output) ++{ ++ FILE *fd; ++ char line[512]; ++ int total_strings = 0; ++ ++ fd = fopen("soc_performance_monitor.cfg", "r"); ++ if(fd == NULL) { ++ fprintf(stderr, "ERROR: Unable to open file soc_performance_monitor.cfg\n"); ++ fprintf(stderr, " Please copy the file from /etc/visualization_scripts into current directory\n"); ++ exit(0); ++ } ++ ++ while(fgets(line, sizeof line, fd)) { ++ if(strstr(line, string)) { ++ printf("\n-------------------------------------------------\n"); ++ printf("CONFIG FILE PARSE: Found section %s in line : %s\n", string, line); ++ break; ++ } ++ } ++ ++ while(fgets(line, sizeof line, fd)) { ++ printd("Line is = %s", line); ++ ++ if (line[0] == '#' || line[0] == '\n' || line[0] == '[') { ++ break; ++ } ++ ++ line[strlen(line) - 1] = '\0'; ++ strcpy(output[total_strings++], line); ++ ++ } ++ fclose(fd); ++ ++ return total_strings; ++} ++ ++ ++void fill_cpu_load_details(int start_offset, int end_offset, char **output, struct table_configuration *table_config) ++{ ++ int i; ++ ++ const int BL_START_X = table_config->BL_START_X; ++ const int BL_START_Y = table_config->BL_START_Y; ++ const int BAR_GAP = table_config->BAR_GAP; ++ const int BAR_HEIGHT = table_config->BAR_HEIGHT; ++ const int BAR_WIDTH = table_config->BAR_WIDTH; ++ const int TR_START_X = table_config->TR_START_X; ++ const int TR_START_Y = table_config->TR_START_Y; ++ const int FONT_SIZE = table_config->FONT_SIZE; ++ printf("Filling from %d to %d\n", start_offset, end_offset); ++ cpu_load_offset = start_offset; ++ ++ for(i=start_offset; i< end_offset-1; i++) { ++ y_cfg[i*2].region.bottom_left.x = BL_START_X + (i-start_offset) * (BAR_GAP + BAR_WIDTH); ++ y_cfg[i*2].region.bottom_left.y = BL_START_Y; ++ y_cfg[i*2].region.top_right.x = TR_START_X + (i-start_offset) * (BAR_GAP + BAR_WIDTH); ++ y_cfg[i*2].region.top_right.y = TR_START_Y; ++ y_cfg[i*2].line_color.r = 1.0; ++ y_cfg[i*2].line_color.g = 1.0; ++ y_cfg[i*2].line_color.b = 1.0; ++ y_cfg[i*2].line_color.a = 1.0; ++ y_cfg[i*2].fill_color.r = 0.0; ++ y_cfg[i*2].fill_color.g = 0.0; ++ y_cfg[i*2].fill_color.b = 1.0; ++ y_cfg[i*2].fill_color.a = 0.7; ++ ++ y_cfg[i*2+1].region.bottom_left.x = BL_START_X +(i-start_offset) * (BAR_GAP + BAR_WIDTH); ++ y_cfg[i*2+1].region.bottom_left.y = BL_START_Y; ++ y_cfg[i*2+1].region.top_right.x = TR_START_X + (i-start_offset) * (BAR_GAP + BAR_WIDTH); ++ y_cfg[i*2+1].region.top_right.y = TR_START_Y; ++ y_cfg[i*2+1].line_color.r = 1.0; ++ y_cfg[i*2+1].line_color.g = 1.0; ++ y_cfg[i*2+1].line_color.b = 1.0; ++ y_cfg[i*2+1].line_color.a = 1.0; ++ y_cfg[i*2+1].fill_color.r = 1.0; ++ y_cfg[i*2+1].fill_color.g = 0.0; ++ y_cfg[i*2+1].fill_color.b = 0.0; ++ y_cfg[i*2+1].fill_color.a = 1.0; ++ ++ ++ t_cfg[i*2].color.r = 1.0; ++ t_cfg[i*2].color.g = 1.0; ++ t_cfg[i*2].color.b = 1.0; ++ t_cfg[i*2].color.a = 1.0; ++ t_cfg[i*2].at.x = BL_START_X + (i-start_offset) * (BAR_GAP + BAR_WIDTH); ++ t_cfg[i*2].at.y = BL_START_Y + FONT_SIZE; ++ t_cfg[i*2].fontsize = FONT_SIZE; ++ ++ t_cfg[i*2+1].color.r = 1.0; ++ t_cfg[i*2+1].color.g = 1.0; ++ t_cfg[i*2+1].color.b = 1.0; ++ t_cfg[i*2+1].color.a = 1.0; ++ t_cfg[i*2+1].at.x = BL_START_X + (i-start_offset) * (BAR_GAP + BAR_WIDTH); ++ t_cfg[i*2+1].at.y = BL_START_Y - BAR_HEIGHT - FONT_SIZE; ++ t_cfg[i*2+1].fontsize = FONT_SIZE; ++ ++ strcpy(bg_text[i*2], output[i - start_offset]); ++ strcpy(bg_text[i*2+1], "0%"); ++ } ++ ++ t_cfg[(end_offset-1)*2].color.r = 0.0; ++ t_cfg[(end_offset-1)*2].color.g = 1.0; ++ t_cfg[(end_offset-1)*2].color.b = 1.0; ++ t_cfg[(end_offset-1)*2].color.a = 1.0; ++ t_cfg[(end_offset-1)*2].at.x = BL_START_X + 80; ++ t_cfg[(end_offset-1)*2].at.y = TR_START_Y - 40; ++ t_cfg[(end_offset-1)*2].fontsize = FONT_SIZE + 3; ++ ++ printd("Copying title string %s\n", output[end_offset - start_offset -1]); ++ strcpy(bg_text[(end_offset-1)*2], output[end_offset - start_offset-1]); ++} ++ ++void fill_table_details(int start_offset, int end_offset, char **output, struct table_configuration *table_config) ++{ ++ int i; ++ ++ const int BL_START_X = table_config->BL_START_X; ++ const int BL_START_Y = table_config->BL_START_Y; ++ const int BAR_GAP = table_config->BAR_GAP; ++ const int BAR_HEIGHT = table_config->BAR_HEIGHT; ++ const int BAR_WIDTH = table_config->BAR_WIDTH; ++ const int TR_START_X = table_config->TR_START_X; ++ const int TR_START_Y = table_config->TR_START_Y; ++ const int FONT_SIZE = table_config->FONT_SIZE; ++ printf("Filling from %d to %d\n", start_offset, end_offset); ++ ++ ++ char tokenize[200]; ++ char tokens[10][100]; ++ char *pair, *key, *value; ++ int k=0; ++ char title[100], unit[100]; ++ ++ strcpy(tokenize, output[end_offset - start_offset - 1]); ++ memset(tokens, 0, sizeof(tokens)); ++ ++ k=0; ++ pair = strtok (tokenize,","); ++ while (pair != NULL) { ++ strcpy(tokens[k++], pair); ++ pair = strtok (NULL, ","); ++ } ++ ++ i=0; ++ memset(title, 0, sizeof(title)); ++ memset(unit, 0, sizeof(unit)); ++ while(i < k) { ++ key=strtok(tokens[i], "="); ++ if(key != NULL) { ++ if(strcmp(key,"TITLE") == 0) { ++ value = strtok(NULL, "="); ++ if(value != NULL) { ++ strcpy(title, value); ++ } ++ } ++ if(strcmp(key,"UNIT") == 0) { ++ value = strtok(NULL, "="); ++ if(value != NULL) { ++ strcpy(unit, value); ++ } ++ } ++ } ++ i++; ++ } ++ ++ for(i=start_offset; i< end_offset-1; i++) { ++ y_cfg[i*2].region.bottom_left.x = BL_START_X; ++ y_cfg[i*2].region.bottom_left.y = BL_START_Y + (i - start_offset) * (BAR_GAP + BAR_HEIGHT); ++ y_cfg[i*2].region.top_right.x = TR_START_X; ++ y_cfg[i*2].region.top_right.y = TR_START_Y + (i - start_offset) * (BAR_GAP + BAR_HEIGHT); ++ y_cfg[i*2].line_color.r = 1.0; ++ y_cfg[i*2].line_color.g = 1.0; ++ y_cfg[i*2].line_color.b = 1.0; ++ y_cfg[i*2].line_color.a = 1.0; ++ y_cfg[i*2].fill_color.r = 0.0; ++ y_cfg[i*2].fill_color.g = 0.3; ++ y_cfg[i*2].fill_color.b = 0.0; ++ y_cfg[i*2].fill_color.a = 0.7; ++ ++ y_cfg[i*2+1].region.bottom_left.x = TR_START_X; ++ y_cfg[i*2+1].region.bottom_left.y = BL_START_Y + (i - start_offset) * (BAR_GAP + BAR_HEIGHT); ++ y_cfg[i*2+1].region.top_right.x = TR_START_X + (BAR_WIDTH); //+ 1 * BL_START_X; ++ y_cfg[i*2+1].region.top_right.y = TR_START_Y + (i - start_offset) * (BAR_GAP + BAR_HEIGHT);; ++ y_cfg[i*2+1].line_color.r = 1.0; ++ y_cfg[i*2+1].line_color.g = 1.0; ++ y_cfg[i*2+1].line_color.b = 1.0; ++ y_cfg[i*2+1].line_color.a = 1.0; ++ y_cfg[i*2+1].fill_color.r = 0.3; ++ y_cfg[i*2+1].fill_color.g = 0.0; ++ y_cfg[i*2+1].fill_color.b = 0.0; ++ y_cfg[i*2+1].fill_color.a = 0.7; ++ ++ ++ t_cfg[i*2].color.r = 1.0; ++ t_cfg[i*2].color.g = 1.0; ++ t_cfg[i*2].color.b = 1.0; ++ t_cfg[i*2].color.a = 1.0; ++ t_cfg[i*2].at.x = BL_START_X + 5; ++ t_cfg[i*2].at.y = BL_START_Y + (i - start_offset) * (BAR_GAP+BAR_HEIGHT) -5; ++ t_cfg[i*2].fontsize = FONT_SIZE; ++ ++ t_cfg[i*2+1].color.r = 1.0; ++ t_cfg[i*2+1].color.g = 1.0; ++ t_cfg[i*2+1].color.b = 1.0; ++ t_cfg[i*2+1].color.a = 1.0; ++ t_cfg[i*2+1].at.x = TR_START_X + 50;//BAR_WIDTH + TR_START_X; ++ t_cfg[i*2+1].at.y = BL_START_Y + (i - start_offset) * (BAR_GAP + BAR_HEIGHT) -5; ++ t_cfg[i*2+1].fontsize = FONT_SIZE; ++ ++ printd("Copying string %s at %d\n", output[i-start_offset], i); ++ strcpy(bg_text[i*2], output[i-start_offset]); ++ printd("Setting text 0 %s at %d\n", unit, i*2+1); ++ sprintf(bg_text[i*2+1], "0 %s", unit); ++ } ++ for(i=start_offset; i< end_offset*2; i++) { ++ printd("%d - (%d, %d) to (%d, %d)\n", i, y_cfg[i].region.bottom_left.x, y_cfg[i].region.bottom_left.y, y_cfg[i].region.top_right.x, y_cfg[i].region.top_right.y); ++ } ++ ++ t_cfg[(end_offset-1)*2].color.r = 0.0; ++ t_cfg[(end_offset-1)*2].color.g = 1.0; ++ t_cfg[(end_offset-1)*2].color.b = 1.0; ++ t_cfg[(end_offset-1)*2].color.a = 1.0; ++ t_cfg[(end_offset-1)*2].at.x = BL_START_X + 80; ++ t_cfg[(end_offset-1)*2].at.y = BL_START_Y - 40; ++ t_cfg[(end_offset-1)*2].fontsize = FONT_SIZE + 3; ++ ++ printd("Copying title string %s\n", title); ++ strcpy(bg_text[(end_offset-1)*2], title); ++ ++} ++ ++ ++int get_key_value_from_string(char *string, char *limiter, char *key, char *value) ++{ ++ char *mykey, *myvalue; ++ ++ mykey=strtok(string, limiter); ++ if(mykey != NULL) { ++ myvalue = strtok(NULL, "="); ++ strtok(myvalue, "\n"); ++ if(myvalue == NULL) { ++ return -1; ++ } ++ } ++ else { ++ return -1; ++ } ++ printd("Key is %s\n", mykey); ++ printd("Value is %s\n", myvalue); ++ strcpy(key, mykey); ++ strcpy(value, myvalue); ++ return 0; ++ ++} ++ ++void populate_table_configuration(struct table_configuration *tbl_cfg, int cur_items, char **item_list) ++{ ++ static int total_items = 0; ++ static int total_tables = 0; ++ ++ tbl_cfg->BAR_HEIGHT = 25; ++ tbl_cfg->BAR_WIDTH = 150; ++ tbl_cfg->BL_START_X = 40; ++ tbl_cfg->BL_START_Y = 80 + (total_items + total_tables) * tbl_cfg->BAR_HEIGHT; ++ tbl_cfg->BAR_GAP = 0; ++ tbl_cfg->TR_START_X = tbl_cfg->BL_START_X + tbl_cfg->BAR_WIDTH; ++ tbl_cfg->TR_START_Y = tbl_cfg->BL_START_Y - tbl_cfg->BAR_HEIGHT; ++ tbl_cfg->FONT_SIZE = 15; ++ ++ printf("Proceeding with filling out details...\n"); ++ if(cur_items > 0) ++ fill_table_details(total_items, total_items+cur_items, item_list, tbl_cfg); ++ ++ total_items += cur_items; ++ if(cur_items > 0) ++ total_tables++; ++ ++ printf("total_items = %d, total_tables = %d\n", total_items, total_tables); ++ return; ++} ++ ++int fill_list_from_section(char **section_list, char *section_name) ++{ ++ int total_items, j; ++ ++ for(j=0; j<20; j++) { ++ section_list[j] = malloc(100); ++ } ++ ++ total_items = get_strings_in_section(section_name, section_list); ++ printf("\tThe total values in the section %s are %d\n", section_name, total_items); ++ for(j=0; j<total_items; j++) { ++ printf("\t\tThe returned strings for BOOT_TIME are %s\n", section_list[j]); ++ } ++ ++ total_elements += total_items; ++ ++ return total_items; ++} ++ ++int main(int argc, char *argv[]) ++{ ++ double *bg_y; ++ double *tg_y; ++ int i,j; ++ int refresh_rate; ++ ++ if (SIG_ERR == signal(SIGPIPE,SIG_IGN)) ++ exit(1); ++ ++ if (SIG_ERR == signal(SIGINT,my_signal_handler)) ++ exit(1); ++ ++ if (SIG_ERR == signal(SIGTERM,my_signal_handler)) ++ exit(1); ++ ++ if(argc == 2) { ++ printf("Enabling debug\n"); ++ debug = atoi(argv[1]); ++ } ++ else { ++ printf("Debug is disabled\n"); ++ debug = 0; ++ } ++ ++ char *output[20]; ++ int total = fill_list_from_section(output, "GLOBAL"); ++ for(j=0; j<total; j++) { ++ char key[100], value[100]; ++ int ret = get_key_value_from_string(output[j], "=", key, value); ++ if(ret == 0) { ++ if(strcmp(key, "FIFO") == 0) { ++ strcpy(readfifo, value); ++ } ++ if(strcmp(key, "REFRESH_RATE_USEC") == 0) { ++ refresh_rate = atoi(value); ++ } ++ if(strcmp(key, "MAX_WIDTH") == 0) { ++ MAX_WIDTH = atoi(value); ++ } ++ if(strcmp(key, "MAX_HEIGHT") == 0) { ++ MAX_HEIGHT = atoi(value); ++ } ++ if(strcmp(key, "X_POS") == 0) { ++ x_pos = atoi(value); ++ } ++ if(strcmp(key, "Y_POS") == 0) { ++ y_pos = atoi(value); ++ } ++ } ++ ++ } ++ ++ printf("\n-------------------------------------------------\n"); ++ printf("Configured REFRESH_RATE is %d\n", refresh_rate); ++ printf("Configured FIFO is %s\n", readfifo); ++ printf("Configured MAX_WIDTH is %d\n", MAX_WIDTH); ++ printf("Configured MAX_HEIGHT is %d\n", MAX_HEIGHT); ++ printf("Configured starting location is (%d, %d)\n", x_pos, y_pos); ++ printf("\n-------------------------------------------------\n"); ++ ++ int fd = open(readfifo, O_RDONLY|O_NONBLOCK); ++ if (fd != -1) { ++ printf("SUCCESS: Configured FIFO exists\n"); ++ close(fd); ++ } ++ else { ++ printf("ERROR: %s not found\nPlease create the fifo by executing mkfifo %s before running the application\n", readfifo, readfifo); ++ exit(0); ++ } ++ ++ ++ bg_p.title = malloc(100); ++ sprintf(bg_p.title, "CPU Usage[@position-req=%dx%d]", x_pos, y_pos); ++ ++ /* ------------------------------------------------------------------------*/ ++ /* Section for populating all lists from cfg sections*/ ++ /* ------------------------------------------------------------------------*/ ++ char *boot_list[20]; ++ int total_boot_items = fill_list_from_section(boot_list, "BOOT_TIME"); ++ ++ char *temperature_list[20]; ++ int total_temperature_items = fill_list_from_section(temperature_list, "TEMPERATURE"); ++ ++ char *cpu_load_list[20]; ++ total_cpu_load_items = fill_list_from_section(cpu_load_list, "CPU_LOAD"); ++ ++ char *voltage_list[20]; ++ int total_voltage_items = fill_list_from_section(voltage_list, "VOLTAGE"); ++ ++ char *frequency_list[20]; ++ int total_frequency_items = fill_list_from_section(frequency_list, "FREQUENCY"); ++ /* ------------------------------------------------------------------------*/ ++ /* total_elements will be updated inside the fill_list_from_section function */ ++ ++ t_cfg = malloc(sizeof(struct _text_config) * (total_elements*2 + 1)); ++ y_cfg = malloc(sizeof(struct _bar_graph_y_config) * total_elements*2); ++ bg_p.num_of_y_items = total_elements*2; ++ bg_p.y_config_array = y_cfg; ++ bg_p.num_of_text_items = total_elements*2 + 1; ++ bg_p.text_config_array = t_cfg; ++ ++ bg_y = malloc(sizeof(double) * total_elements * 2); ++ for(i=0; i< (total_elements*2+1); i++) { ++ bg_text[i] = malloc(150); ++ bg_y[i] = 1.0; ++ } ++ ++ tg_y = malloc(sizeof(double) * total_elements * 2); ++ for(i=0; i< (total_elements*2+1); i++) { ++ tg_text[i] = malloc(150); ++ tg_y[i] = 0.1 * i; ++ } ++ ++ struct table_configuration boot_table_config; ++ populate_table_configuration(&boot_table_config, total_boot_items, boot_list); ++ ++ struct table_configuration temp_table_config; ++ populate_table_configuration(&temp_table_config, total_temperature_items, temperature_list); ++ ++ struct table_configuration voltage_table_config; ++ populate_table_configuration(&voltage_table_config, total_voltage_items, voltage_list); ++ ++ struct table_configuration frequency_table_config; ++ populate_table_configuration(&frequency_table_config, total_frequency_items, frequency_list); ++ ++ struct table_configuration cpu_load_config; ++ cpu_load_config.BL_START_X = 40; ++ cpu_load_config.BL_START_Y = 80 + (total_boot_items + total_temperature_items + total_voltage_items + total_frequency_items+ 4) * boot_table_config.BAR_HEIGHT + 80 /*cpu_load_config.BAR_HEIGHT */; ++ cpu_load_config.BAR_GAP = 20; ++ cpu_load_config.BAR_HEIGHT = 80; ++ cpu_load_config.BAR_WIDTH = 40; ++ cpu_load_config.TR_START_X = cpu_load_config.BL_START_X + cpu_load_config.BAR_WIDTH; ++ cpu_load_config.TR_START_Y = cpu_load_config.BL_START_Y - cpu_load_config.BAR_HEIGHT; ++ cpu_load_config.FONT_SIZE = 15; ++ if(total_cpu_load_items > 0) { ++ fill_cpu_load_details(total_boot_items+total_temperature_items+total_voltage_items+total_frequency_items, total_boot_items+total_temperature_items+total_voltage_items+total_frequency_items+total_cpu_load_items, cpu_load_list, &cpu_load_config); ++ } ++ else { ++ cpu_load_offset = total_boot_items + total_temperature_items + total_voltage_items + total_frequency_items; ++ } ++ ++ tg_p.title=(char *)malloc(100); ++ sprintf(tg_p.title, "CPU Usage[@position-req=%dx%d]", x_pos, y_pos); ++ tg_p.height = MAX_HEIGHT; ++ tg_p.width = MAX_WIDTH; ++ ++ struct _y_config *tg_y_cfg = malloc(tg_p.num_of_y_items * sizeof(struct _y_config)); ++ tg_p.y_config_array = tg_y_cfg; ++ tg_p.text_config_array = t_cfg; ++ ++ printf("Proceeding to create starting visualization...\n"); ++ ctx = time_graph_create(argc, argv, &tg_p); ++ if (!ctx) { ++ printf("Unable to create time_graph... \n"); ++ exit(0); ++ } ++ ++ ctx = bar_graph_create(argc, argv, &bg_p); ++ if (!ctx) { ++ printf("Error creating context\n"); ++ exit(0); ++ } ++ ++ command_handler(OPEN, NULL, NULL); ++ ++ /* Plot the graph first time */ ++ time_graph_plot(ctx, tg_y, (const char **)tg_text); ++ bar_graph_plot(ctx, bg_y, (const char **)bg_text); ++ ++ while (!sigtermed) ++ { ++ usleep(refresh_rate); ++ int bytes_read = command_handler(READ, bg_y, bg_text); ++ if(bytes_read > 0) { ++ time_graph_plot(ctx, tg_y, (const char **)tg_text); ++ bar_graph_plot(ctx, bg_y, (const char **)bg_text); ++ } ++ } ++ ++ bar_graph_destroy(ctx); ++ command_handler(CLOSE, NULL, NULL); ++ return 0; ++} +diff --git a/clients/soc_performance_monitor.h b/clients/soc_performance_monitor.h +new file mode 100644 +index 0000000..861c8c7 +--- /dev/null ++++ b/clients/soc_performance_monitor.h +@@ -0,0 +1,40 @@ ++#define __SLEEP usleep(1000000) ++ ++#define MAX_BUF 1024 ++#define OPEN 1 ++#define READ 2 ++#define CLOSE 3 ++ ++#define MAX_COLORS 12 ++ ++#define printd(fmt, ...) \ ++ do { if (debug) fprintf(stderr, fmt, __VA_ARGS__); } while (0) ++ ++ ++struct _rgba pallette[MAX_COLORS] = ++{ ++ { 1.0, 0.0, 0.0, 1.0 }, ++ { 0.0, 0.5, 0.0, 1.0 }, ++ { 0.0, 0.0, 1.0, 1.0 }, ++ { 0.0, 0.0, 0.0, 1.0 }, ++ { 0.0, 0.5, 1.0, 1.0 }, ++ { 1.0, 0.0, 1.0, 1.0 }, ++ { 0.5, 0.5, 1.0, 1.0 }, ++ { 1.0, 0.5, 0.0, 1.0 }, ++ { 0.5, 0.5, 0.25, 1.0 }, ++ { 0.5, 0.0, 0.0, 1.0 }, ++ { 1.0, 0.5, 0.5, 1.0 }, ++ { 0.0, 0.0, 0.20, 1.0 } ++}; ++ ++struct table_configuration { ++ int BL_START_X; ++ int BL_START_Y; ++ int BAR_GAP; ++ int BAR_HEIGHT; ++ int BAR_WIDTH; ++ int TR_START_X; ++ int TR_START_Y; ++ int FONT_SIZE; ++}; ++ +diff --git a/clients/statcoll.c b/clients/statcoll.c +new file mode 100644 +index 0000000..5d5cae7 +--- /dev/null ++++ b/clients/statcoll.c +@@ -0,0 +1,1433 @@ ++/* ++ * Copyright (C) 2015 Texas Instruments ++ * created by prash@ti.com on 16 Jan 2013 ++ * Adapted to Linux with changes in framework: Karthik R <karthik.ramanan@ti.com> ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 as published by ++ * the Free Software Foundation. ++ * ++ * This program is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for ++ * more details. ++ * ++ * You should have received a copy of the GNU General Public License along with ++ * this program. If not, see <http://www.gnu.org/licenses/>. ++ */ ++ ++#include <stdio.h> ++#include <stdlib.h> ++#include <string.h> ++#include <sys/mman.h> ++#include <fcntl.h> ++#include <signal.h> ++#include <unistd.h> ++#include <sys/time.h> ++ ++#include "statcoll.h" ++#include "statcoll_gui.h" ++#include "time_bar_graph.h" ++ ++#define ENABLE_MODE 0x0 ++#define READ_STATUS_MODE 0x1 ++ ++ ++ ++#define OPEN 1 ++#define READ 2 ++#define CLOSE 3 ++ ++ ++#if 1 ++#define __SLEEP sleep(1) ++#else ++#define __SLEEP usleep(100000) ++#endif ++//#define DUMMY_MODE ++ ++#define MAX_COLORS 12 ++ ++struct _rgba pallette[MAX_COLORS] = ++{ ++ { 1.0, 0.0, 0.0, 1.0 }, ++ { 0.0, 0.5, 0.0, 1.0 }, ++ { 0.0, 0.0, 1.0, 1.0 }, ++ { 0.0, 0.0, 0.0, 1.0 }, ++ { 0.0, 0.5, 1.0, 1.0 }, ++ { 1.0, 0.0, 1.0, 1.0 }, ++ { 0.5, 0.5, 1.0, 1.0 }, ++ { 1.0, 0.5, 0.0, 1.0 }, ++ { 0.5, 0.5, 0.25, 1.0 }, ++ { 0.5, 0.0, 0.0, 1.0 }, ++ { 1.0, 0.5, 0.5, 1.0 }, ++ { 0.0, 0.0, 0.20, 1.0 } ++}; ++ ++const struct list_of_initiators initiators[STATCOL_MAX] = ++{ ++ { STATCOL_EMIF1_SYS, "STATCOL_EMIF1_SYS" }, ++ { STATCOL_EMIF2_SYS,"STATCOL_EMIF2_SYS" }, ++ { STATCOL_MA_MPU_P1,"STATCOL_MPU_P1" }, ++ { STATCOL_MA_MPU_P2,"STATCOL_MPU_P2" }, ++ { STATCOL_MPU1,"STATCOL_MPU1" }, ++ { STATCOL_MMU1,"STATCOL_MMU1" }, ++ { STATCOL_TPTC_RD1,"STATCOL_TPTC_RD1" }, ++ { STATCOL_TPTC_WR1,"STATCOL_TPTC_WR1" }, ++ { STATCOL_TPTC_RD2,"STATCOL_TPTC_RD2" }, ++ { STATCOL_TPTC_WR2,"STATCOL_TPTC_WR2" }, ++ { STATCOL_VIP1_P1,"STATCOL_VIP1_P1" }, ++ { STATCOL_VIP1_P2,"STATCOL_VIP1_P2" }, ++ { STATCOL_VIP2_P1,"STATCOL_VIP2_P1" }, ++ { STATCOL_VIP2_P2,"STATCOL_VIP2_P2" }, ++ { STATCOL_VIP3_P1,"STATCOL_VIP3_P1" }, ++ { STATCOL_VIP3_P2,"STATCOL_VIP3_P2" }, ++ { STATCOL_VPE_P1,"STATCOL_VPE_P1" }, ++ { STATCOL_VPE_P2,"STATCOL_VPE_P2" }, ++ { STATCOL_EVE1_TC0,"STATCOL_EVE1_TC0" }, ++ { STATCOL_EVE1_TC1,"STATCOL_EVE1_TC1" }, ++ { STATCOL_EVE2_TC0,"STATCOL_EVE2_TC0" }, ++ { STATCOL_EVE2_TC1,"STATCOL_EVE2_TC1" }, ++ { STATCOL_EVE3_TC0,"STATCOL_EVE3_TC0" }, ++ { STATCOL_EVE3_TC1,"STATCOL_EVE3_TC1" }, ++ { STATCOL_EVE4_TC0,"STATCOL_EVE4_TC0" }, ++ { STATCOL_EVE4_TC1,"STATCOL_EVE4_TC1" }, ++ { STATCOL_DSP1_MDMA,"STATCOL_DSP1_MDMA" }, ++ { STATCOL_DSP1_EDMA,"STATCOL_DSP1_EDMA" }, ++ { STATCOL_DSP2_MDMA,"STATCOL_DSP2_MDMA" }, ++ { STATCOL_DSP2_EDMA,"STATCOL_DSP2_EDMA" }, ++ { STATCOL_IVA,"STATCOL_IVA" }, ++ { STATCOL_GPU_P1,"STATCOL_GPU_P1" }, ++ { STATCOL_GPU_P2,"STATCOL_GPU_P2" }, ++ { STATCOL_BB2D_P1,"STATCOL_BB2D_P1" }, ++ { STATCOL_DSS,"STATCOL_DSS" }, ++ { STATCOL_CSI2_2,"STATCOL_CSI2_2" }, ++ { STATCOL_MMU2,"STATCOL_MMU2" }, ++ { STATCOL_IPU1,"STATCOL_IPU1" }, ++ { STATCOL_IPU2,"STATCOL_IPU2" }, ++ { STATCOL_DMA_SYSTEM_RD,"STATCOL_DMA_SYSTEM_RD" }, ++ { STATCOL_DMA_SYSTEM_WR,"STATCOL_DMA_SYSTEM_WR" }, ++ { STATCOL_CSI2_1,"STATCOL_CSI2_1" }, ++ { STATCOL_USB3_SS,"STATCOL_USB3_SS" }, ++ { STATCOL_USB2_SS,"STATCOL_USB2_SS" }, ++ { STATCOL_USB2_ULPI_SS1,"STATCOL_USB2_ULPI_SS1" }, ++ { STATCOL_USB2_ULPI_SS2,"STATCOL_USB2_ULPI_SS2" }, ++ { STATCOL_PCIE_SS1,"STATCOL_PCIE_SS1" }, ++ { STATCOL_PCIE_SS2,"STATCOL_PCIE_SS2" }, ++ { STATCOL_DSP1_CFG,"STATCOL_DSP1_CFG" }, ++ { STATCOL_DSP2_CFG,"STATCOL_DSP2_CFG" }, ++ { STATCOL_GMAC_SW,"STATCOL_GMAC_SW" }, ++ { STATCOL_PRUSS1_P1,"STATCOL_PRUSS1_P1" }, ++ { STATCOL_PRUSS1_P2,"STATCOL_PRUSS1_P2" }, ++ { STATCOL_PRUSS2_P1,"STATCOL_PRUSS2_P1" }, ++ { STATCOL_PRUSS2_P2,"STATCOL_PRUSS2_P2" }, ++ { STATCOL_DMA_CRYPTO_RD,"STATCOL_DMA_CRYPTO_RD" }, ++ { STATCOL_DMA_CRYPTO_WR,"STATCOL_DMA_CRYPTO_WR" }, ++ { STATCOL_MPU2,"STATCOL_MPU2" }, ++ { STATCOL_MMC1,"STATCOL_MMC1" }, ++ { STATCOL_MMC2,"STATCOL_MMC2" }, ++ { STATCOL_SATA,"STATCOL_SATA" }, ++ { STATCOL_MLBSS,"STATCOL_MLBSS" }, ++ { STATCOL_BB2D_P2,"STATCOL_BB2D_P2" }, ++ { STATCOL_IEEE1500,"STATCOL_IEEE1500" }, ++ { STATCOL_DBG,"STATCOL_DBG" }, ++ { STATCOL_VCP1,"STATCOL_VCP1" }, ++ { STATCOL_OCMC_RAM1,"STATCOL_OCMC_RAM1" }, ++ { STATCOL_OCMC_RAM2,"STATCOL_OCMC_RAM2" }, ++ { STATCOL_OCMC_RAM3,"STATCOL_OCMC_RAM3" }, ++ { STATCOL_GPMC,"STATCOL_GPMC" }, ++ { STATCOL_MCASP1,"STATCOL_MCASP1" }, ++ { STATCOL_MCASP2,"STATCOL_MCASP2" }, ++ { STATCOL_MCASP3,"STATCOL_MCASP3" }, ++ { STATCOL_VCP2, "STATCOL_VCP2" } ++}; ++ ++StatCollectorObj gStatColState; ++ ++static void *statcoll_base_mem; ++static int *l3_3_clkctrl; ++ ++static UInt32 *statCountDSS = NULL; ++static UInt32 *statCountIVA = NULL; ++static UInt32 *statCountBB2DP1 = NULL; ++static UInt32 *statCountBB2DP2 = NULL; ++static UInt32 *statCountUSB4 = NULL; ++static UInt32 *statCountSata = NULL; ++static UInt32 *statCountEmif1 = NULL; ++static UInt32 *statCountEmif2 = NULL; ++ ++ ++static statcoll_initiators_object global_object[STATCOL_MAX]; ++UInt32 statCountIdx = 0; ++UInt32 TRACE_SZ = 0; ++ ++void create_overall_box(struct _bar_graph_y_config *y_cfg, struct _text_config *t_cfg, char *text[]) ++{ ++ int i=0; ++ ++ memset(y_cfg, 0x0, sizeof(struct _y_config)*25); ++ memset(t_cfg, 0x0, sizeof(struct _text_config)*25); ++ ++ ++ for(i=0; i<TOTAL_Y_PARAMETERS; i++) { ++ (y_cfg+i)->line_color.r = 1.0; ++ (y_cfg+i)->line_color.g = 1.0; ++ (y_cfg+i)->line_color.b = 1.0; ++ (y_cfg+i)->line_color.a = 0.7; ++ (y_cfg+i)->fill_color.r = 0.0; ++ (y_cfg+i)->fill_color.g = 0.0; ++ (y_cfg+i)->fill_color.b = 0.0; ++ (y_cfg+i)->fill_color.a = 0.1; ++ } ++ ++ (y_cfg+0)->region.bottom_left.x = 0; ++ (y_cfg+0)->region.bottom_left.y = MAX_HEIGHT - HEIGHT_EMIF_AREA; ++ (y_cfg+0)->region.top_right.x = MAX_WIDTH; ++ (y_cfg+0)->region.top_right.y = 0; ++ ++ (t_cfg+0)->at.x = MAX_WIDTH/2 - 8*FONT_SIZE - 50; ++ (t_cfg+0)->at.y = BORDER - FONT_SIZE + 6; ++ strcpy(text[0], string_list[0]); ++ ++ (y_cfg+1)->region.bottom_left.x = TIME_GRAPH_AREA_BL_X; ++ (y_cfg+1)->region.bottom_left.y = TIME_GRAPH_AREA_BL_Y; ++ (y_cfg+1)->region.top_right.x = TIME_GRAPH_AREA_TR_X; ++ (y_cfg+1)->region.top_right.y = TIME_GRAPH_AREA_TR_Y; ++ ++ (t_cfg+1)->at.x = TIME_GRAPH_AREA_BL_X - 2*FONT_SIZE; ++ (t_cfg+1)->at.y = TIME_GRAPH_AREA_TR_Y; ++ strcpy(text[1],string_list[1]); ++ ++ for(i=2; i<7; i++) ++ { ++ (y_cfg+i)->region.bottom_left.x = TIME_GRAPH_AREA_BL_X; ++ (y_cfg+i)->region.bottom_left.y = TIME_GRAPH_AREA_BL_Y;// - (i-2) * (30); ++ (y_cfg+i)->region.top_right.x = TIME_GRAPH_AREA_TR_X; ++ (y_cfg+i)->region.top_right.y = TIME_GRAPH_AREA_TR_Y + (i-1) * ((TIME_GRAPH_AREA_BL_Y - TIME_GRAPH_AREA_TR_Y)/5); ++ (t_cfg+i)->at.x = TIME_GRAPH_AREA_BL_X - 2*FONT_SIZE; ++ (t_cfg+i)->at.y = TIME_GRAPH_AREA_TR_Y + (i-1) * ((TIME_GRAPH_AREA_BL_Y - TIME_GRAPH_AREA_TR_Y)/5);//TIME_GRAPH_AREA_TR_Y; ++ strcpy(text[i],string_list[i]); ++ } ++ ++#if 1 ++ (y_cfg+7)->region.bottom_left.x = EMIF_AREA_BL_X; ++ (y_cfg+7)->region.bottom_left.y = EMIF_AREA_BL_Y; ++ (y_cfg+7)->region.top_right.x = EMIF_AREA_TR_X; ++ (y_cfg+7)->region.top_right.y = EMIF_AREA_TR_Y; ++ ++ (t_cfg+7)->at.x = WIDTH_EMIF_AREA/2 - 2*FONT_SIZE; ++ (t_cfg+7)->at.y = EMIF_AREA_TR_Y + FONT_SIZE; ++ strcpy(text[7],string_list[7]); ++ ++ for(i=8; i<12; i=i+2) ++ { ++ (y_cfg+i)->region.bottom_left.x = EMIF_AREA_BL_X + BORDER + (i-8)*(BAR_WIDTH+BAR_GAP)/2; ++ (y_cfg+i)->region.bottom_left.y = EMIF_AREA_BL_Y - BORDER/2;// - (i-2) * (30); ++ (y_cfg+i)->region.top_right.x = EMIF_AREA_BL_X + BORDER + BAR_WIDTH + (i-8) * (BAR_WIDTH + BAR_GAP)/2; ++ (y_cfg+i)->region.top_right.y = EMIF_AREA_TR_Y + BORDER * 1.2; ++ ++ (y_cfg+i)->fill_color.r = 1.0; ++ (y_cfg+i)->fill_color.g = 0.0; ++ (y_cfg+i)->fill_color.b = 0.0; ++ (y_cfg+i)->fill_color.a = 0.1; ++ ++ (y_cfg+i+1)->region.bottom_left.x = EMIF_AREA_BL_X + BORDER + (i-8) * (BAR_WIDTH + BAR_GAP)/2; ++ (y_cfg+i+1)->region.bottom_left.y = EMIF_AREA_BL_Y - BORDER/2; ++ (y_cfg+i+1)->region.top_right.x = EMIF_AREA_BL_X + BORDER + BAR_WIDTH + (i-8) * (BAR_WIDTH + BAR_GAP)/2; ++ (y_cfg+i+1)->region.top_right.y = EMIF_AREA_TR_Y + BORDER*1.2; ++ ++ (y_cfg+i+1)->fill_color.r = 0.0; ++ (y_cfg+i+1)->fill_color.g = 1.0; ++ (y_cfg+i+1)->fill_color.b = 0.0; ++ (y_cfg+i+1)->fill_color.a = 1.0; ++ ++ (t_cfg+i)->at.x = EMIF_AREA_BL_X + BAR_WIDTH + BORDER + (i-8) * (BAR_WIDTH + BAR_GAP)/2- 2.2*FONT_SIZE; ++ (t_cfg+i)->at.y = EMIF_AREA_TR_Y + BORDER*1.2 -5; ++ ++ /* Fixed strings */ ++ (t_cfg+i+1)->at.x = EMIF_AREA_BL_X + BORDER + (i-8) * (BAR_WIDTH + BAR_GAP)/2; ++ (t_cfg+i+1)->at.y = EMIF_AREA_BL_Y;// - BORDER + FONT_SIZE; ++ ++ strcpy(text[i],string_list[i]); ++ strcpy(text[i+1],string_list[i+1]); ++ } ++ ++ (y_cfg+12)->region.bottom_left.x = INITIATORS_AREA_BL_X; ++ (y_cfg+12)->region.bottom_left.y = INITIATORS_AREA_BL_Y; ++ (y_cfg+12)->region.top_right.x = INITIATORS_AREA_TR_X; ++ (y_cfg+12)->region.top_right.y = INITIATORS_AREA_TR_Y; ++ ++ (t_cfg+12)->at.x = EMIF_AREA_TR_X + (INITIATORS_AREA_TR_X - INITIATORS_AREA_BL_X)/2 - 4 * FONT_SIZE; ++ (t_cfg+12)->at.y = INITIATORS_AREA_TR_Y + FONT_SIZE; ++ strcpy(text[12],string_list[12]); ++ ++ for(i=13; i<25; i=i+2) ++ { ++ (y_cfg+i)->region.bottom_left.x = INITIATORS_AREA_BL_X + BORDER + (i-13)*(BAR_WIDTH+BAR_GAP)/2; ++ (y_cfg+i)->region.bottom_left.y = INITIATORS_AREA_BL_Y - BORDER/2;// - (i-2) * (30); ++ (y_cfg+i)->region.top_right.x = INITIATORS_AREA_BL_X + BORDER + BAR_WIDTH + (i-13) * (BAR_WIDTH + BAR_GAP)/2; ++ (y_cfg+i)->region.top_right.y = INITIATORS_AREA_TR_Y + BORDER*1.2; ++ ++ (y_cfg+i)->fill_color.r = 1.0; ++ (y_cfg+i)->fill_color.g = 0.0; ++ (y_cfg+i)->fill_color.b = 0.0; ++ (y_cfg+i)->fill_color.a = 0.1; ++ ++ (y_cfg+i+1)->region.bottom_left.x = INITIATORS_AREA_BL_X + BORDER + (i-13) * (BAR_WIDTH + BAR_GAP)/2; ++ (y_cfg+i+1)->region.bottom_left.y = INITIATORS_AREA_BL_Y - BORDER/2;// - (i-2) * (30); ++ (y_cfg+i+1)->region.top_right.x = INITIATORS_AREA_BL_X + BORDER + BAR_WIDTH + (i-13) * (BAR_WIDTH + BAR_GAP)/2; ++ (y_cfg+i+1)->region.top_right.y = INITIATORS_AREA_TR_Y + BORDER* 1.2; ++ ++ (y_cfg+i+1)->fill_color.r = 0.0; ++ (y_cfg+i+1)->fill_color.g = 1.0; ++ (y_cfg+i+1)->fill_color.b = 0.0; ++ (y_cfg+i+1)->fill_color.a = 1.0; ++ ++ (t_cfg+i)->at.x = INITIATORS_AREA_BL_X + BORDER + BAR_WIDTH + (i-13) * (BAR_WIDTH + BAR_GAP)/2 - 2.2* FONT_SIZE; ++ (t_cfg+i)->at.y = INITIATORS_AREA_TR_Y + BORDER*1.2 -5; ++ ++ (t_cfg+i+1)->at.x = INITIATORS_AREA_BL_X + BORDER + (i-13)*(BAR_WIDTH+BAR_GAP)/2; ++ (t_cfg+i+1)->at.y = INITIATORS_AREA_BL_Y; ++ ++ strcpy(text[i],string_list[i]); ++ strcpy(text[i+1],string_list[i+1]); ++ } ++#endif ++ ++#if 0 ++ for(i=0; i<25; i++) ++ printf("(%d, %d) to (%d, %d)\n", (y_cfg +i)->region.bottom_left.x,(y_cfg +i)->region.bottom_left.y,(y_cfg +i)->region.top_right.x, (y_cfg +i)->region.top_right.y); ++#endif ++ ++ ++ ++ for(i=0; i<25; i++) { ++ (t_cfg+i)->color.r = 0.0; ++ (t_cfg+i)->color.g = 1.0; ++ (t_cfg+i)->color.b = 1.0; ++ (t_cfg+i)->color.a = 1.0; ++ (t_cfg+i)->fontsize = FONT_SIZE; ++ } ++ (t_cfg+0)->fontsize = 20; ++ ++ ++} ++ ++ ++void statCollectorInit() ++{ ++ int index; ++ ++ gStatColState.stat0_filter_cnt = 0; ++ gStatColState.stat1_filter_cnt = 0; ++ gStatColState.stat2_filter_cnt = 0; ++ gStatColState.stat3_filter_cnt = 0; ++ gStatColState.stat4_filter_cnt = 0; ++ gStatColState.stat5_filter_cnt = 0; ++ gStatColState.stat6_filter_cnt = 0; ++ gStatColState.stat7_filter_cnt = 0; ++ gStatColState.stat8_filter_cnt = 0; ++ gStatColState.stat9_filter_cnt = 0; ++ ++ for(index=STATCOL_EMIF1_SYS; index < STATCOL_MAX; index++) ++ { ++ global_object[index].b_enabled = 0; ++ ++ strcpy(global_object[index].name, initiators[index].name); ++ ++ global_object[index].readings = malloc(TRACE_SZ * sizeof(UInt32)); ++ memset(global_object[index].readings, 0, TRACE_SZ * sizeof(UInt32)); ++ ++ global_object[index].timestamp = NULL; ++ ++ global_object[index].group_id = 0xFF; ++ global_object[index].counter_id = 0; ++ global_object[index].base_address = 0; ++ global_object[index].mux_req = 0; ++ } ++ ++} ++ ++void wr_stat_reg(UInt32 address, UInt32 data) ++{ ++ UInt32 *mymem = statcoll_base_mem; ++ UInt32 delta = (address - STATCOLL_BASE) / 4; ++#ifndef DUMMY_MODE ++ mymem[delta] = data; ++#else ++ printf("WRITE: Address = 0x%x, Data = 0x%x\n", address, data); ++#endif ++} ++ ++UInt32 rd_stat_reg(UInt32 address) ++{ ++#ifndef DUMMY_MODE ++ UInt32 *mymem = statcoll_base_mem; ++ UInt32 data; ++ UInt32 delta = (address - STATCOLL_BASE) / 4; ++ data = mymem[delta]; ++ return data; ++#else ++ printf("READ: Address = 0x%x\n", address); ++#endif ++} ++ ++UInt32 statCollectorControlInitialize(UInt32 instance_id) ++{ ++ UInt32 cur_base_address = 0; ++ UInt32 cur_event_mux_req; ++ UInt32 cur_event_mux_resp; ++ UInt32 cur_stat_filter_cnt; ++ ++ switch (instance_id) ++ { ++ case STATCOL_EMIF1_SYS: ++ cur_base_address = stat_coll0_base_address; ++ cur_event_mux_req = 0; ++ cur_event_mux_resp = 1; ++ gStatColState.stat0_filter_cnt = gStatColState.stat0_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat0_filter_cnt; ++ global_object[instance_id].group_id = 0; ++ break; ++ case STATCOL_EMIF2_SYS: ++ cur_base_address = stat_coll0_base_address; ++ cur_event_mux_req = 2; ++ cur_event_mux_resp = 3; ++ gStatColState.stat0_filter_cnt = gStatColState.stat0_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat0_filter_cnt; ++ global_object[instance_id].group_id = 0; ++ break; ++ case STATCOL_MA_MPU_P1: ++ cur_base_address = stat_coll0_base_address; ++ cur_event_mux_req = 4; ++ cur_event_mux_resp = 5; ++ gStatColState.stat0_filter_cnt = gStatColState.stat0_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat0_filter_cnt; ++ global_object[instance_id].group_id = 0; ++ break; ++ case STATCOL_MA_MPU_P2: ++ cur_base_address = stat_coll0_base_address; ++ cur_event_mux_req = 6; ++ cur_event_mux_resp = 7; ++ gStatColState.stat0_filter_cnt = gStatColState.stat0_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat0_filter_cnt; ++ global_object[instance_id].group_id = 0; ++ break; ++ case STATCOL_MPU1: ++ cur_base_address = stat_coll1_base_address; ++ cur_event_mux_req = 0; ++ cur_event_mux_resp = 1; ++ gStatColState.stat1_filter_cnt = gStatColState.stat1_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat1_filter_cnt; ++ global_object[instance_id].group_id = 1; ++ break; ++ case STATCOL_MMU1: ++ cur_base_address = stat_coll1_base_address; ++ cur_event_mux_req = 2; ++ cur_event_mux_resp = 3; ++ gStatColState.stat1_filter_cnt = gStatColState.stat1_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat1_filter_cnt; ++ global_object[instance_id].group_id = 1; ++ break; ++ case STATCOL_TPTC_RD1: ++ cur_base_address = stat_coll1_base_address; ++ cur_event_mux_req = 4; ++ cur_event_mux_resp = 5; ++ gStatColState.stat1_filter_cnt = gStatColState.stat1_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat1_filter_cnt; ++ global_object[instance_id].group_id = 1; ++ break; ++ case STATCOL_TPTC_WR1: ++ cur_base_address = stat_coll1_base_address; ++ cur_event_mux_req = 6; ++ cur_event_mux_resp = 7; ++ gStatColState.stat1_filter_cnt = gStatColState.stat1_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat1_filter_cnt; ++ global_object[instance_id].group_id = 1; ++ break; ++ case STATCOL_TPTC_RD2: ++ cur_base_address = stat_coll1_base_address; ++ cur_event_mux_req = 8; ++ cur_event_mux_resp = 9; ++ gStatColState.stat1_filter_cnt = gStatColState.stat1_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat1_filter_cnt; ++ global_object[instance_id].group_id = 1; ++ break; ++ case STATCOL_TPTC_WR2: ++ cur_base_address = stat_coll1_base_address; ++ cur_event_mux_req = 10; ++ cur_event_mux_resp = 11; ++ gStatColState.stat1_filter_cnt = gStatColState.stat1_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat1_filter_cnt; ++ global_object[instance_id].group_id = 1; ++ break; ++ case STATCOL_VIP1_P1: ++ cur_base_address = stat_coll2_base_address; ++ cur_event_mux_req = 0; ++ cur_event_mux_resp = 1; ++ gStatColState.stat2_filter_cnt = gStatColState.stat2_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat2_filter_cnt; ++ global_object[instance_id].group_id = 2; ++ break; ++ case STATCOL_VIP1_P2: ++ cur_base_address = stat_coll2_base_address; ++ cur_event_mux_req = 2; ++ cur_event_mux_resp = 3; ++ gStatColState.stat2_filter_cnt = gStatColState.stat2_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat2_filter_cnt; ++ global_object[instance_id].group_id = 2; ++ break; ++ case STATCOL_VIP2_P1: ++ cur_base_address = stat_coll2_base_address; ++ cur_event_mux_req = 4; ++ cur_event_mux_resp = 5; ++ gStatColState.stat2_filter_cnt = gStatColState.stat2_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat2_filter_cnt; ++ global_object[instance_id].group_id = 2; ++ break; ++ case STATCOL_VIP2_P2: ++ cur_base_address = stat_coll2_base_address; ++ cur_event_mux_req = 6; ++ cur_event_mux_resp = 7; ++ gStatColState.stat2_filter_cnt = gStatColState.stat2_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat2_filter_cnt; ++ global_object[instance_id].group_id = 2; ++ break; ++ case STATCOL_VIP3_P1: ++ cur_base_address = stat_coll2_base_address; ++ cur_event_mux_req = 8; ++ cur_event_mux_resp = 9; ++ gStatColState.stat2_filter_cnt = gStatColState.stat2_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat2_filter_cnt; ++ global_object[instance_id].group_id = 2; ++ break; ++ case STATCOL_VIP3_P2: ++ cur_base_address = stat_coll2_base_address; ++ cur_event_mux_req = 10; ++ cur_event_mux_resp = 11; ++ gStatColState.stat2_filter_cnt = gStatColState.stat2_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat2_filter_cnt; ++ global_object[instance_id].group_id = 2; ++ break; ++ case STATCOL_VPE_P1: ++ cur_base_address = stat_coll2_base_address; ++ cur_event_mux_req = 12; ++ cur_event_mux_resp = 13; ++ gStatColState.stat2_filter_cnt = gStatColState.stat2_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat2_filter_cnt; ++ global_object[instance_id].group_id = 2; ++ break; ++ case STATCOL_VPE_P2: ++ cur_base_address = stat_coll2_base_address; ++ cur_event_mux_req = 14; ++ cur_event_mux_resp = 15; ++ gStatColState.stat2_filter_cnt = gStatColState.stat2_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat2_filter_cnt; ++ global_object[instance_id].group_id = 2; ++ break; ++ case STATCOL_EVE1_TC0: ++ cur_base_address = stat_coll3_base_address; ++ cur_event_mux_req = 0; ++ cur_event_mux_resp = 1; ++ gStatColState.stat3_filter_cnt = gStatColState.stat3_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat3_filter_cnt; ++ global_object[instance_id].group_id = 3; ++ break; ++ case STATCOL_EVE1_TC1: ++ cur_base_address = stat_coll3_base_address; ++ cur_event_mux_req = 2; ++ cur_event_mux_resp = 3; ++ gStatColState.stat3_filter_cnt = gStatColState.stat3_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat3_filter_cnt; ++ global_object[instance_id].group_id = 3; ++ break; ++ case STATCOL_EVE2_TC0: ++ cur_base_address = stat_coll3_base_address; ++ cur_event_mux_req = 4; ++ cur_event_mux_resp = 5; ++ gStatColState.stat3_filter_cnt = gStatColState.stat3_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat3_filter_cnt; ++ global_object[instance_id].group_id = 3; ++ break; ++ case STATCOL_EVE2_TC1: ++ cur_base_address = stat_coll3_base_address; ++ cur_event_mux_req = 6; ++ cur_event_mux_resp = 7; ++ gStatColState.stat3_filter_cnt = gStatColState.stat3_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat3_filter_cnt; ++ global_object[instance_id].group_id = 3; ++ break; ++ case STATCOL_EVE3_TC0: ++ cur_base_address = stat_coll3_base_address; ++ cur_event_mux_req = 8; ++ cur_event_mux_resp = 9; ++ gStatColState.stat3_filter_cnt = gStatColState.stat3_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat3_filter_cnt; ++ global_object[instance_id].group_id = 3; ++ break; ++ case STATCOL_EVE3_TC1: ++ cur_base_address = stat_coll3_base_address; ++ cur_event_mux_req = 10; ++ cur_event_mux_resp = 11; ++ gStatColState.stat3_filter_cnt = gStatColState.stat3_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat3_filter_cnt; ++ global_object[instance_id].group_id = 3; ++ break; ++ case STATCOL_EVE4_TC0: ++ cur_base_address = stat_coll3_base_address; ++ cur_event_mux_req = 12; ++ cur_event_mux_resp = 13; ++ gStatColState.stat3_filter_cnt = gStatColState.stat3_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat3_filter_cnt; ++ global_object[instance_id].group_id = 3; ++ break; ++ case STATCOL_EVE4_TC1: ++ cur_base_address = stat_coll3_base_address; ++ cur_event_mux_req = 14; ++ cur_event_mux_resp = 15; ++ gStatColState.stat3_filter_cnt = gStatColState.stat3_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat3_filter_cnt; ++ global_object[instance_id].group_id = 3; ++ break; ++ case STATCOL_DSP1_MDMA: ++ cur_base_address = stat_coll4_base_address; ++ cur_event_mux_req = 0; ++ cur_event_mux_resp = 1; ++ gStatColState.stat4_filter_cnt = gStatColState.stat4_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat4_filter_cnt; ++ global_object[instance_id].group_id = 4; ++ break; ++ case STATCOL_DSP1_EDMA: ++ cur_base_address = stat_coll4_base_address; ++ cur_event_mux_req = 2; ++ cur_event_mux_resp = 3; ++ gStatColState.stat4_filter_cnt = gStatColState.stat4_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat4_filter_cnt; ++ global_object[instance_id].group_id = 4; ++ break; ++ case STATCOL_DSP2_MDMA: ++ cur_base_address = stat_coll4_base_address; ++ cur_event_mux_req = 4; ++ cur_event_mux_resp = 5; ++ gStatColState.stat4_filter_cnt = gStatColState.stat4_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat4_filter_cnt; ++ global_object[instance_id].group_id = 4; ++ break; ++ case STATCOL_DSP2_EDMA: ++ cur_base_address = stat_coll4_base_address; ++ cur_event_mux_req = 6; ++ cur_event_mux_resp = 7; ++ gStatColState.stat4_filter_cnt = gStatColState.stat4_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat4_filter_cnt; ++ global_object[instance_id].group_id = 4; ++ break; ++ case STATCOL_IVA: ++ cur_base_address = stat_coll4_base_address; ++ cur_event_mux_req = 8; ++ cur_event_mux_resp = 9; ++ gStatColState.stat4_filter_cnt = gStatColState.stat4_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat4_filter_cnt; ++ global_object[instance_id].group_id = 4; ++ break; ++ case STATCOL_GPU_P1: ++ cur_base_address = stat_coll4_base_address; ++ cur_event_mux_req = 10; ++ cur_event_mux_resp = 11; ++ gStatColState.stat4_filter_cnt = gStatColState.stat4_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat4_filter_cnt; ++ global_object[instance_id].group_id = 4; ++ break; ++ case STATCOL_GPU_P2: ++ cur_base_address = stat_coll4_base_address; ++ cur_event_mux_req = 12; ++ cur_event_mux_resp = 13; ++ gStatColState.stat4_filter_cnt = gStatColState.stat4_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat4_filter_cnt; ++ global_object[instance_id].group_id = 4; ++ break; ++ case STATCOL_BB2D_P1: ++ cur_base_address = stat_coll4_base_address; ++ cur_event_mux_req = 14; ++ cur_event_mux_resp = 15; ++ gStatColState.stat4_filter_cnt = gStatColState.stat4_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat4_filter_cnt; ++ global_object[instance_id].group_id = 4; ++ break; ++ case STATCOL_DSS: ++ cur_base_address = stat_coll5_base_address; ++ cur_event_mux_req = 0; ++ cur_event_mux_resp = 1; ++ gStatColState.stat5_filter_cnt = gStatColState.stat5_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat5_filter_cnt; ++ global_object[instance_id].group_id = 5; ++ break; ++ case STATCOL_CSI2_2: ++ cur_base_address = stat_coll5_base_address; ++ cur_event_mux_req = 2; ++ cur_event_mux_resp = 3; ++ gStatColState.stat5_filter_cnt = gStatColState.stat5_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat5_filter_cnt; ++ global_object[instance_id].group_id = 5; ++ break; ++ case STATCOL_MMU2: ++ cur_base_address = stat_coll5_base_address; ++ cur_event_mux_req = 4; ++ cur_event_mux_resp = 5; ++ gStatColState.stat5_filter_cnt = gStatColState.stat5_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat5_filter_cnt; ++ global_object[instance_id].group_id = 5; ++ break; ++ case STATCOL_IPU1: ++ cur_base_address = stat_coll5_base_address; ++ cur_event_mux_req = 6; ++ cur_event_mux_resp = 7; ++ gStatColState.stat5_filter_cnt = gStatColState.stat5_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat5_filter_cnt; ++ global_object[instance_id].group_id = 5; ++ break; ++ case STATCOL_IPU2: ++ cur_base_address = stat_coll5_base_address; ++ cur_event_mux_req = 8; ++ cur_event_mux_resp = 9; ++ gStatColState.stat5_filter_cnt = gStatColState.stat5_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat5_filter_cnt; ++ global_object[instance_id].group_id = 5; ++ break; ++ case STATCOL_DMA_SYSTEM_RD: ++ cur_base_address = stat_coll5_base_address; ++ cur_event_mux_req = 10; ++ cur_event_mux_resp = 11; ++ gStatColState.stat5_filter_cnt = gStatColState.stat5_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat5_filter_cnt; ++ global_object[instance_id].group_id = 5; ++ break; ++ case STATCOL_DMA_SYSTEM_WR: ++ cur_base_address = stat_coll5_base_address; ++ cur_event_mux_req = 12; ++ cur_event_mux_resp = 13; ++ gStatColState.stat5_filter_cnt = gStatColState.stat5_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat5_filter_cnt; ++ global_object[instance_id].group_id = 5; ++ break; ++ case STATCOL_CSI2_1: ++ cur_base_address = stat_coll5_base_address; ++ cur_event_mux_req = 14; ++ cur_event_mux_resp = 15; ++ gStatColState.stat5_filter_cnt = gStatColState.stat5_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat5_filter_cnt; ++ global_object[instance_id].group_id = 5; ++ break; ++ case STATCOL_USB3_SS: ++ cur_base_address = stat_coll6_base_address; ++ cur_event_mux_req = 0; ++ cur_event_mux_resp = 1; ++ gStatColState.stat6_filter_cnt = gStatColState.stat6_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat6_filter_cnt; ++ global_object[instance_id].group_id = 6; ++ break; ++ case STATCOL_USB2_SS: ++ cur_base_address = stat_coll6_base_address; ++ cur_event_mux_req = 2; ++ cur_event_mux_resp = 3; ++ gStatColState.stat6_filter_cnt = gStatColState.stat6_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat6_filter_cnt; ++ global_object[instance_id].group_id = 6; ++ break; ++ case STATCOL_USB2_ULPI_SS1: ++ cur_base_address = stat_coll6_base_address; ++ cur_event_mux_req = 4; ++ cur_event_mux_resp = 5; ++ gStatColState.stat6_filter_cnt = gStatColState.stat6_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat6_filter_cnt; ++ global_object[instance_id].group_id = 6; ++ break; ++ case STATCOL_USB2_ULPI_SS2: ++ cur_base_address = stat_coll6_base_address; ++ cur_event_mux_req = 6; ++ cur_event_mux_resp = 7; ++ gStatColState.stat6_filter_cnt = gStatColState.stat6_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat6_filter_cnt; ++ global_object[instance_id].group_id = 6; ++ break; ++ case STATCOL_PCIE_SS1: ++ cur_base_address = stat_coll6_base_address; ++ cur_event_mux_req = 8; ++ cur_event_mux_resp = 9; ++ gStatColState.stat6_filter_cnt = gStatColState.stat6_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat6_filter_cnt; ++ global_object[instance_id].group_id = 6; ++ break; ++ case STATCOL_PCIE_SS2: ++ cur_base_address = stat_coll6_base_address; ++ cur_event_mux_req = 10; ++ cur_event_mux_resp = 11; ++ gStatColState.stat6_filter_cnt = gStatColState.stat6_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat6_filter_cnt; ++ global_object[instance_id].group_id = 6; ++ break; ++ case STATCOL_DSP1_CFG: ++ cur_base_address = stat_coll6_base_address; ++ cur_event_mux_req = 12; ++ cur_event_mux_resp = 13; ++ gStatColState.stat6_filter_cnt = gStatColState.stat6_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat6_filter_cnt; ++ global_object[instance_id].group_id = 6; ++ break; ++ case STATCOL_DSP2_CFG: ++ cur_base_address = stat_coll6_base_address; ++ cur_event_mux_req = 14; ++ cur_event_mux_resp = 15; ++ gStatColState.stat6_filter_cnt = gStatColState.stat6_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat6_filter_cnt; ++ global_object[instance_id].group_id = 6; ++ break; ++ case STATCOL_GMAC_SW: ++ cur_base_address = stat_coll7_base_address; ++ cur_event_mux_req = 0; ++ cur_event_mux_resp = 1; ++ gStatColState.stat7_filter_cnt = gStatColState.stat7_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat7_filter_cnt; ++ global_object[instance_id].group_id = 7; ++ break; ++ case STATCOL_PRUSS1_P1: ++ cur_base_address = stat_coll7_base_address; ++ cur_event_mux_req = 2; ++ cur_event_mux_resp = 3; ++ gStatColState.stat7_filter_cnt = gStatColState.stat7_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat7_filter_cnt; ++ global_object[instance_id].group_id = 7; ++ break; ++ case STATCOL_PRUSS1_P2: ++ cur_base_address = stat_coll7_base_address; ++ cur_event_mux_req = 4; ++ cur_event_mux_resp = 5; ++ gStatColState.stat7_filter_cnt = gStatColState.stat7_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat7_filter_cnt; ++ global_object[instance_id].group_id = 7; ++ break; ++ case STATCOL_PRUSS2_P1: ++ cur_base_address = stat_coll7_base_address; ++ cur_event_mux_req = 6; ++ cur_event_mux_resp = 7; ++ gStatColState.stat7_filter_cnt = gStatColState.stat7_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat7_filter_cnt; ++ global_object[instance_id].group_id = 7; ++ break; ++ case STATCOL_PRUSS2_P2: ++ cur_base_address = stat_coll7_base_address; ++ cur_event_mux_req = 8; ++ cur_event_mux_resp = 9; ++ gStatColState.stat7_filter_cnt = gStatColState.stat7_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat7_filter_cnt; ++ global_object[instance_id].group_id = 7; ++ break; ++ case STATCOL_DMA_CRYPTO_RD: ++ cur_base_address = stat_coll7_base_address; ++ cur_event_mux_req = 10; ++ cur_event_mux_resp = 11; ++ gStatColState.stat7_filter_cnt = gStatColState.stat7_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat7_filter_cnt; ++ global_object[instance_id].group_id = 7; ++ break; ++ case STATCOL_DMA_CRYPTO_WR: ++ cur_base_address = stat_coll7_base_address; ++ cur_event_mux_req = 12; ++ cur_event_mux_resp = 13; ++ gStatColState.stat7_filter_cnt = gStatColState.stat7_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat7_filter_cnt; ++ global_object[instance_id].group_id = 7; ++ break; ++ case STATCOL_MPU2: ++ cur_base_address = stat_coll7_base_address; ++ cur_event_mux_req = 14; ++ cur_event_mux_resp = 15; ++ gStatColState.stat7_filter_cnt = gStatColState.stat7_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat7_filter_cnt; ++ global_object[instance_id].group_id = 7; ++ break; ++ case STATCOL_MMC1: ++ cur_base_address = stat_coll8_base_address; ++ cur_event_mux_req = 0; ++ cur_event_mux_resp = 1; ++ gStatColState.stat8_filter_cnt = gStatColState.stat8_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat8_filter_cnt; ++ global_object[instance_id].group_id = 8; ++ break; ++ case STATCOL_MMC2: ++ cur_base_address = stat_coll8_base_address; ++ cur_event_mux_req = 2; ++ cur_event_mux_resp = 3; ++ gStatColState.stat8_filter_cnt = gStatColState.stat8_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat8_filter_cnt; ++ global_object[instance_id].group_id = 8; ++ break; ++ case STATCOL_SATA: ++ cur_base_address = stat_coll8_base_address; ++ cur_event_mux_req = 4; ++ cur_event_mux_resp = 5; ++ gStatColState.stat8_filter_cnt = gStatColState.stat8_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat8_filter_cnt; ++ global_object[instance_id].group_id = 8; ++ break; ++ case STATCOL_MLBSS: ++ cur_base_address = stat_coll8_base_address; ++ cur_event_mux_req = 6; ++ cur_event_mux_resp = 7; ++ gStatColState.stat8_filter_cnt = gStatColState.stat8_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat8_filter_cnt; ++ global_object[instance_id].group_id = 8; ++ break; ++ case STATCOL_BB2D_P2: ++ cur_base_address = stat_coll8_base_address; ++ cur_event_mux_req = 8; ++ cur_event_mux_resp = 9; ++ gStatColState.stat8_filter_cnt = gStatColState.stat8_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat8_filter_cnt; ++ global_object[instance_id].group_id = 8; ++ break; ++ case STATCOL_IEEE1500: ++ cur_base_address = stat_coll8_base_address; ++ cur_event_mux_req = 10; ++ cur_event_mux_resp = 11; ++ gStatColState.stat8_filter_cnt = gStatColState.stat8_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat8_filter_cnt; ++ global_object[instance_id].group_id = 8; ++ break; ++ case STATCOL_DBG: ++ cur_base_address = stat_coll8_base_address; ++ cur_event_mux_req = 12; ++ cur_event_mux_resp = 13; ++ gStatColState.stat8_filter_cnt = gStatColState.stat8_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat8_filter_cnt; ++ global_object[instance_id].group_id = 8; ++ break; ++ case STATCOL_VCP1: ++ cur_base_address = stat_coll8_base_address; ++ cur_event_mux_req = 14; ++ cur_event_mux_resp = 15; ++ gStatColState.stat8_filter_cnt = gStatColState.stat8_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat8_filter_cnt; ++ global_object[instance_id].group_id = 8; ++ break; ++ case STATCOL_OCMC_RAM1: ++ cur_base_address = stat_coll9_base_address; ++ cur_event_mux_req = 0; ++ cur_event_mux_resp = 1; ++ gStatColState.stat9_filter_cnt = gStatColState.stat9_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat9_filter_cnt; ++ global_object[instance_id].group_id = 9; ++ break; ++ case STATCOL_OCMC_RAM2: ++ cur_base_address = stat_coll9_base_address; ++ cur_event_mux_req = 2; ++ cur_event_mux_resp = 3; ++ gStatColState.stat9_filter_cnt = gStatColState.stat9_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat9_filter_cnt; ++ global_object[instance_id].group_id = 9; ++ break; ++ case STATCOL_OCMC_RAM3: ++ cur_base_address = stat_coll9_base_address; ++ cur_event_mux_req = 4; ++ cur_event_mux_resp = 5; ++ gStatColState.stat9_filter_cnt = gStatColState.stat9_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat9_filter_cnt; ++ global_object[instance_id].group_id = 9; ++ break; ++ case STATCOL_GPMC: ++ cur_base_address = stat_coll9_base_address; ++ cur_event_mux_req = 6; ++ cur_event_mux_resp = 7; ++ gStatColState.stat9_filter_cnt = gStatColState.stat9_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat9_filter_cnt; ++ global_object[instance_id].group_id = 9; ++ break; ++ case STATCOL_MCASP1: ++ cur_base_address = stat_coll9_base_address; ++ cur_event_mux_req = 8; ++ cur_event_mux_resp = 9; ++ gStatColState.stat9_filter_cnt = gStatColState.stat9_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat9_filter_cnt; ++ global_object[instance_id].group_id = 9; ++ break; ++ case STATCOL_MCASP2: ++ cur_base_address = stat_coll9_base_address; ++ cur_event_mux_req = 10; ++ cur_event_mux_resp = 11; ++ gStatColState.stat9_filter_cnt = gStatColState.stat9_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat9_filter_cnt; ++ global_object[instance_id].group_id = 9; ++ break; ++ case STATCOL_MCASP3: ++ cur_base_address = stat_coll9_base_address; ++ cur_event_mux_req = 12; ++ cur_event_mux_resp = 13; ++ gStatColState.stat9_filter_cnt = gStatColState.stat9_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat9_filter_cnt; ++ global_object[instance_id].group_id = 9; ++ break; ++ case STATCOL_VCP2: ++ cur_base_address = stat_coll9_base_address; ++ cur_event_mux_req = 14; ++ cur_event_mux_resp = 15; ++ gStatColState.stat9_filter_cnt = gStatColState.stat9_filter_cnt + 1; ++ cur_stat_filter_cnt = gStatColState.stat9_filter_cnt; ++ global_object[instance_id].group_id = 9; ++ break; ++ default: ++ printf("ERROR: Unknown initiator %d\n", instance_id); ++ exit(0); ++ }; ++ ++ { ++ if ( cur_stat_filter_cnt > 4 ) ++ { ++ printf("WARNING: We have exhausted filters/counters.....\n"); ++ return 0; ++ } ++ // Global Enable Stat Collector ++ wr_stat_reg(cur_base_address+0x8,0x1); ++ ++ // Soft Enable Stat Collector ++ wr_stat_reg(cur_base_address+0xC,0x1); ++ ++ wr_stat_reg(cur_base_address+0x18,0x5); ++ // Operation of Stat Collector / RespEvt => Packet ++ wr_stat_reg(cur_base_address+0x1C,0x5); ++ ++ ++ // Event Sel ++ wr_stat_reg(cur_base_address+0x20+4*(cur_stat_filter_cnt-1),cur_event_mux_req); ++ ++ // Op is EventInfo ++ wr_stat_reg(cur_base_address+0x1FC+(0x158*(cur_stat_filter_cnt-1)),2); ++ ++ // Event Info Sel Op -> packet length ++ wr_stat_reg(cur_base_address+0x1F8+(0x158*(cur_stat_filter_cnt-1)),0); ++ ++ // Filter Global Enable ++ wr_stat_reg(cur_base_address+0xAC+(0x158*(cur_stat_filter_cnt-1)),0x1); ++ ++ // Filter Enable ++ wr_stat_reg(cur_base_address+0xBC+(0x158*(cur_stat_filter_cnt-1)),0x1); ++ ++ // Manual dump ++ wr_stat_reg(cur_base_address+0x54,0x1); ++ // use send register to reset counters ++ ++ } ++ ++ global_object[instance_id].mux_req = cur_event_mux_req; ++ global_object[instance_id].base_address = cur_base_address; ++ global_object[instance_id].counter_id = cur_stat_filter_cnt; ++ global_object[instance_id].b_enabled = 1; ++ ++ return cur_stat_filter_cnt; ++} ++ ++ ++ ++void statCollectorReadGroup(UInt32 group_id) ++{ ++ int i=0; ++ UInt32 cur_base_address = 0x45001000 + ((group_id - 1) * 0x1000); ++ ++ wr_stat_reg(cur_base_address+0xC,0x0); ++ ++ for(i=0; i < STATCOL_MAX; i++) ++ { ++ if(global_object[i].group_id == (group_id - 1) && ++ global_object[i].b_enabled == 1) ++ { ++ UInt32 cur_stat_filter_cnt = global_object[i].counter_id; ++ ++ global_object[i].readings[statCountIdx] = rd_stat_reg(cur_base_address+0x8C+((cur_stat_filter_cnt-1)*4)); ++ } ++ } ++ ++ wr_stat_reg(cur_base_address+0xC,0x1); ++} ++ ++ ++volatile sig_atomic_t sigtermed = 0; ++ ++void my_signal_handler(int signum) ++{ ++ if (signum == SIGTERM || signum == SIGINT) { ++ sigtermed = 1; ++ } ++} ++ ++struct sort ++{ ++ int pos; ++ double value; ++}; ++ ++ ++void *ctx; ++struct time_graph_create_params p; ++char xpos_string[100], ypos_string[100]; ++ ++void mpu_handler(int command) ++{ ++#if 1 ++ static int fd; ++ char buf[1000]; ++ char * tabledata= "/tmp/statcollfifo"; ++ int i; ++ int bytes; ++ static int offset = 13; ++ ++ switch(command) ++ { ++ case OPEN: ++ fd = open(tabledata, O_RDONLY|O_NONBLOCK); ++ break; ++ ++ case READ: ++ ++ /* open, read, and display the message from the FIFO */ ++ bytes=read(fd, buf, 1000); ++ if(bytes > 0) ++ { ++ char str[100]; ++ char value[100]; ++ sscanf(buf, "%s %s", str, value); ++ if(strcmp(str, "MOVE:") == 0) ++ { ++ printf("Received MOVE command : %s\n", buf); ++ sprintf(p.title, "CPU Usage[@position-req=%sx%s]", value, ypos_string); ++ move_graph(ctx, &p); ++ } ++ else ++ { ++ printf("ERROR: Received unexpected data from FIFO - \" %s \" \n", buf); ++ } ++ memset(buf, 0x0, sizeof(buf)); ++ } ++ ++ break; ++ ++ case CLOSE: ++ close(fd); ++ break; ++ } ++#endif ++ return; ++} ++ ++ ++UInt32 statcoll_start(UInt32 TOTAL_TIME, UInt32 INTERVAL_US, char list[][50], UInt32 xpos, UInt32 ypos) ++{ ++ int i, fd, index; ++ UInt32 counterIdDss, counterIdIva, counterIdBB2dP1, counterIdBB2dP2, counterIdUsb4, counterIdSata, counterIdEmif1, counterIdEmif2; ++ ++ if (SIG_ERR == signal(SIGPIPE,SIG_IGN)) ++ exit(1); ++ ++ if (SIG_ERR == signal(SIGINT,my_signal_handler)) ++ exit(1); ++ ++ if (SIG_ERR == signal(SIGTERM,my_signal_handler)) ++ exit(1); ++ ++ ++ struct timeval tv1, tv2; ++ gettimeofday(&tv1, NULL); ++ printf("------------------------------------------------\n"); ++ printf("Compile time = %s %s\n",__DATE__, __TIME__); ++ printf("------------------------------------------------\n\n"); ++ //printd("Start time = %d\n", time(NULL)); ++ //printd("Time seconds = %d, usecs = %d\n", tv.tv_sec, tv.tv_usec); ++ ++ statcoll_params params; ++ memset(¶ms, sizeof(params), 0); ++ params.INTERVAL_US = INTERVAL_US; ++ params.TOTAL_TIME = TOTAL_TIME; ++ ++ i=0; ++ index=0; ++ ++ while(list[i][0] != 0) ++ { ++ for(index=0; index< STATCOL_MAX; index++) { ++ if(strcmp(list[i], initiators[index].name) == 0) ++ { ++ strcpy(params.user_config_list[params.no_of_initiators].name, list[i]); ++ params.user_config_list[params.no_of_initiators++].id = initiators[index].id; ++ break; ++ } ++ } ++ ++ if(index == STATCOL_MAX) { ++ printf("ERROR: Unknown initiator.%d.. .%s. \n", i, list[i]); ++ //exit(0); ++ } ++ i++; ++ } ++ ++ struct bar_graph_create_params bg_p; ++ struct _y_config *y_cfg; ++ struct _text_config *t_cfg; ++ double *y; ++ double *bg_y; ++ char *text_list[STATCOL_MAX]; ++ ++ struct _bar_graph_y_config *bg_y_cfg; ++ struct _text_config *bg_t_cfg; ++ char *bg_text_list[STATCOL_MAX]; ++ ++ sprintf(xpos_string, "%d", xpos); ++ sprintf(ypos_string, "%d", ypos); ++ p.title=(char *)malloc(100); ++ sprintf(p.title, "CPU Usage[@position-req=%sx%s]", xpos_string, ypos_string); ++ //p.height = MAX_HEIGHT - HEIGHT_EMIF_AREA; ++ p.height = MAX_HEIGHT;// - HEIGHT_EMIF_AREA; ++ p.width = MAX_WIDTH; ++ p.draw_area.bottom_left.x = TIME_GRAPH_AREA_BL_X; ++ p.draw_area.bottom_left.y = TIME_GRAPH_AREA_BL_Y; ++ p.draw_area.top_right.x = TIME_GRAPH_AREA_TR_X; ++ p.draw_area.top_right.y = TIME_GRAPH_AREA_TR_Y; ++ p.time_span = 120000; // 120 seconds ++ p.num_of_y_items = params.no_of_initiators+1; ++ p.num_of_text_items = 0;//params.no_of_initiators; ++ ++ ++ y_cfg = malloc((params.no_of_initiators+1) * sizeof(struct _y_config)); ++ t_cfg = malloc(params.no_of_initiators * sizeof(struct _text_config)); ++ y = malloc((params.no_of_initiators+1) * sizeof(double)); ++ p.y_config_array = y_cfg; ++ p.text_config_array = t_cfg; ++ ++ bg_y_cfg = malloc(TOTAL_Y_PARAMETERS * sizeof(struct _bar_graph_y_config)); ++ bg_t_cfg = malloc(TOTAL_Y_PARAMETERS * sizeof(struct _text_config)); ++ bg_y = malloc(TOTAL_Y_PARAMETERS * sizeof(double)); ++ ++ for(i=0; i<TOTAL_Y_PARAMETERS; i++) ++ { ++ bg_text_list[i] = malloc(100); ++ strcpy(bg_text_list[i],"test"); ++ } ++ ++ create_overall_box(bg_y_cfg, bg_t_cfg, bg_text_list); ++ ++ ++ i=0; ++ while(i < params.no_of_initiators) ++ { ++ text_list[i] = malloc(100 * sizeof(char)); ++ memset(text_list[i], 0x0, 100); ++ ++ ((struct _y_config *)y_cfg+i)->line_color.r = pallette[i%MAX_COLORS].r; ++ ((struct _y_config *)y_cfg+i)->line_color.g = pallette[i%MAX_COLORS].g; ++ ((struct _y_config *)y_cfg+i)->line_color.b = pallette[i%MAX_COLORS].b; ++ ((struct _y_config *)y_cfg+i)->line_color.a = 0.0;//pallette[i%MAX_COLORS].a; ++ ++ ((struct _y_config *)y_cfg+i)->fill_color.r = 0.0; ++ ((struct _y_config *)y_cfg+i)->fill_color.g = 1.0; ++ ((struct _y_config *)y_cfg+i)->fill_color.b = 0.0; ++ ((struct _y_config *)y_cfg+i)->fill_color.a = 0.5; ++ ++ i++; ++ } ++ ++ ((struct _y_config *)y_cfg+i)->line_color.r = 0.0; ++ ((struct _y_config *)y_cfg+i)->line_color.g = 0.0; ++ ((struct _y_config *)y_cfg+i)->line_color.b = 0.0; ++ ((struct _y_config *)y_cfg+i)->line_color.a = 0.5; ++ ((struct _y_config *)y_cfg+i)->fill_color.r = 0.1; ++ ((struct _y_config *)y_cfg+i)->fill_color.g = 0.9; ++ ((struct _y_config *)y_cfg+i)->fill_color.b = 0.5; ++ ((struct _y_config *)y_cfg+i)->fill_color.a = 1.0; ++ ++ bg_p.title = "CPU Usage"; ++ ++ bg_p.num_of_y_items = TOTAL_Y_PARAMETERS; ++ bg_p.y_config_array = bg_y_cfg; ++ bg_p.num_of_text_items = TOTAL_Y_PARAMETERS; ++ bg_p.text_config_array = bg_t_cfg; ++ ++ ++ int argc; ++ char *argv[10]; ++ ctx = time_graph_create(argc, argv, &p); ++ if (!ctx) { ++ printf("Error creating context\n"); ++ exit(0); ++ } ++ ++ printf("\n Context after time_graph_create = 0x%x\n", ctx); ++ ctx = bar_graph_create(argc, argv, &bg_p); ++ if (!ctx) { ++ printf("Error creating context\n"); ++ exit(0); ++ } ++ ++ printf("\n Context after bar_graph_create= 0x%x\n", ctx); ++ ++ printf("Total configured initiators = %d\n", params.no_of_initiators); ++ ++ ++ fd = open("/dev/mem", O_RDWR); ++ if (fd == -1){ ++ printf("error fd=open() \n"); ++ return -1; ++ } ++ statcoll_base_mem = mmap(NULL, STATCOLL_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, STATCOLL_BASE); ++ ++ if (statcoll_base_mem == MAP_FAILED){ ++ printf("ERROR: mmap failed \n"); ++ return; ++ } ++ close(fd); ++ ++ fd = open("/dev/mem", O_RDWR); ++ if (fd == -1){ ++ printf("error fd=open() \n"); ++ return -1; ++ } ++ l3_3_clkctrl = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, CM_L3INSTR_REGISTER_BASE); ++ if (l3_3_clkctrl == MAP_FAILED){ ++ printf("ERROR: mmap failed for CM_L3INSTR_REGISTER_BASE\n"); ++ return; ++ } ++ close(fd); ++ ++ printf("SUCCESS: Mapped 0x%x to user space address 0x%x\n", STATCOLL_BASE, statcoll_base_mem); ++ printf("INTERVAL = %d usecs\n", INTERVAL_US); ++ printf("TOTAL TIME = %d seconds\n", TOTAL_TIME); ++ TRACE_SZ = (TOTAL_TIME * 1000000)/INTERVAL_US; ++ printf("TRACE SIZE = %d samples\n", TRACE_SZ); ++ ++ printf("**************************************\n"); ++ printf("Going to initialize the L3 clocks \n"); ++ l3_3_clkctrl[CM_L3INSTR_L3INSTR_CLKSTCTRL_OFFSET >> 2] = 0x2; ++ l3_3_clkctrl[CM_L3INSTR_L3_MAIN_2_CLKCTRL_OFFSET >> 2] = 0x1; ++ printf("**************************************\n"); ++ ++ while( (l3_3_clkctrl[CM_L3INSTR_L3_MAIN_2_CLKCTRL_OFFSET >> 2] & 0x30000) != 0x0) ++ { ++ printf("Waiting on module to be functional\n"); ++ } ++ ++ statCollectorInit(); ++ ++ printf("SUCCESS: Initialized STAT COLLECTOR\n"); ++ /* Initialize all enabled initiators */ ++ for(index =0; index < params.no_of_initiators; index++) { ++ printf("\t\t Initialized %s\n", params.user_config_list[index].name); ++ statCollectorControlInitialize(params.user_config_list[index].id); ++ } ++ ++ const char *bg_text = "CPU Utilization"; ++ ++ int second_counter=0; ++ memset(y, 0x0, sizeof(double)* (params.no_of_initiators+1)); ++ ++ ++ ++ ++ mpu_handler(OPEN); ++ ++ ++ while(statCountIdx != (TRACE_SZ - 1)) ++ { ++ usleep(INTERVAL_US); ++ int group; ++ for(group = 1; group<11; group++) ++ statCollectorReadGroup(group); ++ ++ mpu_handler(READ); ++ ++ if(statCountIdx != 0 ) ++ for(i=0; i<params.no_of_initiators; i++) { ++ y[i] += (double)(global_object[params.user_config_list[i].id].readings[statCountIdx])/ (8000000000); ++ } ++ second_counter++; ++ ++ if(second_counter % 30 == 0) ++ { ++ ++ for(i=0; i<TOTAL_Y_PARAMETERS; i++) { ++ bg_y[i] = 1.0; ++ } ++ ++ //HACK ++ bg_y[9]=y[0]*2; ++ bg_y[11]=y[1]*2; ++ sprintf(bg_text_list[8], "%02.1f%s", y[0]*100, "%"); ++ sprintf(bg_text_list[10], "%02.1f%s", y[1]*100, "%"); ++ ++ struct sort sort_array[STATCOL_MAX]; ++ memset(sort_array, 0x0, sizeof(struct sort) * STATCOL_MAX); ++ /* Sort here */ ++ for(i=2; i<params.no_of_initiators; i++) { ++ sort_array[i-2].value = y[i]; ++ sort_array[i-2].pos = i; ++ } ++ ++ int j; ++ double tempdouble; ++ int tempint; ++ for(i=0; i<params.no_of_initiators-2; i++) { ++ for(j=i+1; j<params.no_of_initiators-2; j++) { ++ if(sort_array[i].value < sort_array[j].value) { ++ tempdouble = sort_array[j].value; ++ tempint = sort_array[j].pos; ++ ++ sort_array[j].value = sort_array[i].value; ++ sort_array[j].pos = sort_array[i].pos; ++ ++ sort_array[i].value = tempdouble; ++ sort_array[i].pos = tempint; ++ } ++ } ++ } ++ ++ for(i=0; i<6; i++) ++ { ++ //HACK ++ bg_y[14+i*2] = sort_array[i].value*2; ++ sprintf(bg_text_list[13+i*2], "%02.1f%s", sort_array[i].value*100, "%"); ++ sprintf(bg_text_list[14+i*2], "%s", (params.user_config_list[sort_array[i].pos].name)+8); ++ } ++ ++ bar_graph_plot(ctx, bg_y, (const char **)bg_text_list); ++ ++ y[params.no_of_initiators]=y[0]+y[1]; ++ time_graph_plot(ctx, y, (const char **)text_list); ++ //printf("Plotting the time_graph\n"); ++ memset(y, 0x0, sizeof(double)* (params.no_of_initiators+1)); ++ } ++ statCountIdx++; ++ ++ } ++ ++ mpu_handler(CLOSE); ++ ++ printf("------------------------------------------------\n\n"); ++ printf("SUCCESS: Stat collection completed... Writing into file now\n"); ++ FILE *outfile = fopen("statcollector.csv", "w+"); ++ if (!outfile) { ++ printf("\n ERROR: Error opening file"); ++ } ++ ++ /* Ignore the first index at 0 */ ++ for(index=1; index<statCountIdx; index++) { ++ for(i=0; i<params.no_of_initiators; i++) { ++ fprintf(outfile,"%s = %d,", params.user_config_list[i].name, global_object[params.user_config_list[i].id].readings[index]); ++ } ++ fprintf(outfile,"\n"); ++ } ++ fclose(outfile); ++ ++ time_graph_destroy(ctx); ++ gettimeofday(&tv2, NULL); ++ //printf("End time = %d\n", time(NULL)); ++ //printf("Time seconds = %d, usecs = %d\n", tv.tv_sec, tv.tv_usec); ++ printf("Total execution time = %d secs, %d usecs\n\n", (tv2.tv_sec - tv1.tv_sec), (tv2.tv_usec - tv2.tv_usec)); ++ ++ return 0; ++} ++ ++ +diff --git a/clients/statcoll.h b/clients/statcoll.h +new file mode 100644 +index 0000000..fa92753 +--- /dev/null ++++ b/clients/statcoll.h +@@ -0,0 +1,152 @@ ++#ifndef __STATCOLL_H ++#define __STATCOLL_H ++ ++ ++#define CM_L3INSTR_REGISTER_BASE (0x4A008000) ++ ++#define CM_L3INSTR_L3INSTR_CLKSTCTRL_OFFSET (0xE00) ++#define CM_L3INSTR_L3_MAIN_2_CLKCTRL_OFFSET (0xE20) ++ ++#define STATCOLL_SIZE 40960 ++#define STATCOLL_BASE (0x45001000) ++ ++#define stat_coll0_base_address (0x45001000) ++#define stat_coll1_base_address (0x45002000) ++#define stat_coll2_base_address (0x45003000) ++#define stat_coll3_base_address (0x45004000) ++#define stat_coll4_base_address (0x45005000) ++#define stat_coll5_base_address (0x45006000) ++#define stat_coll6_base_address (0x45007000) ++#define stat_coll7_base_address (0x45008000) ++#define stat_coll8_base_address (0x45009000) ++#define stat_coll9_base_address (0x4500a000) ++ ++#define printd(fmt, ...) \ ++ do { if (debug) fprintf(stderr, fmt, __VA_ARGS__); } while (0) ++ ++typedef unsigned int UInt32; ++ ++ ++typedef enum ++{ ++ STATCOL_EMIF1_SYS, ++ STATCOL_EMIF2_SYS, ++ STATCOL_MA_MPU_P1, ++ STATCOL_MA_MPU_P2, ++ STATCOL_MPU1, ++ STATCOL_MMU1, ++ STATCOL_TPTC_RD1, ++ STATCOL_TPTC_WR1, ++ STATCOL_TPTC_RD2, ++ STATCOL_TPTC_WR2, ++ STATCOL_VIP1_P1, ++ STATCOL_VIP1_P2, ++ STATCOL_VIP2_P1, ++ STATCOL_VIP2_P2, ++ STATCOL_VIP3_P1, ++ STATCOL_VIP3_P2, ++ STATCOL_VPE_P1, ++ STATCOL_VPE_P2, ++ STATCOL_EVE1_TC0, ++ STATCOL_EVE1_TC1, ++ STATCOL_EVE2_TC0, ++ STATCOL_EVE2_TC1, ++ STATCOL_EVE3_TC0, ++ STATCOL_EVE3_TC1, ++ STATCOL_EVE4_TC0, ++ STATCOL_EVE4_TC1, ++ STATCOL_DSP1_MDMA, ++ STATCOL_DSP1_EDMA, ++ STATCOL_DSP2_MDMA, ++ STATCOL_DSP2_EDMA, ++ STATCOL_IVA, ++ STATCOL_GPU_P1, ++ STATCOL_GPU_P2, ++ STATCOL_BB2D_P1, ++ STATCOL_DSS, ++ STATCOL_CSI2_2, ++ STATCOL_MMU2, ++ STATCOL_IPU1, ++ STATCOL_IPU2, ++ STATCOL_DMA_SYSTEM_RD, ++ STATCOL_DMA_SYSTEM_WR, ++ STATCOL_CSI2_1, ++ STATCOL_USB3_SS, ++ STATCOL_USB2_SS, ++ STATCOL_USB2_ULPI_SS1, ++ STATCOL_USB2_ULPI_SS2, ++ STATCOL_PCIE_SS1, ++ STATCOL_PCIE_SS2, ++ STATCOL_DSP1_CFG, ++ STATCOL_DSP2_CFG, ++ STATCOL_GMAC_SW, ++ STATCOL_PRUSS1_P1, ++ STATCOL_PRUSS1_P2, ++ STATCOL_PRUSS2_P1, ++ STATCOL_PRUSS2_P2, ++ STATCOL_DMA_CRYPTO_RD, ++ STATCOL_DMA_CRYPTO_WR, ++ STATCOL_MPU2, ++ STATCOL_MMC1, ++ STATCOL_MMC2, ++ STATCOL_SATA, ++ STATCOL_MLBSS, ++ STATCOL_BB2D_P2, ++ STATCOL_IEEE1500, ++ STATCOL_DBG, ++ STATCOL_VCP1, ++ STATCOL_OCMC_RAM1, ++ STATCOL_OCMC_RAM2, ++ STATCOL_OCMC_RAM3, ++ STATCOL_GPMC, ++ STATCOL_MCASP1, ++ STATCOL_MCASP2, ++ STATCOL_MCASP3, ++ STATCOL_VCP2, ++ STATCOL_MAX ++} STATCOL_ID; ++ ++ ++ ++typedef struct ++{ ++ UInt32 stat0_filter_cnt; ++ UInt32 stat1_filter_cnt; ++ UInt32 stat2_filter_cnt; ++ UInt32 stat3_filter_cnt; ++ UInt32 stat4_filter_cnt; ++ UInt32 stat5_filter_cnt; ++ UInt32 stat6_filter_cnt; ++ UInt32 stat7_filter_cnt; ++ UInt32 stat8_filter_cnt; ++ UInt32 stat9_filter_cnt; ++} StatCollectorObj; ++ ++struct list_of_initiators ++{ ++ STATCOL_ID id; ++ char name[50]; ++}; ++ ++typedef struct ++{ ++ UInt32 INTERVAL_US; ++ UInt32 TOTAL_TIME; ++ UInt32 no_of_initiators; ++ struct list_of_initiators user_config_list[STATCOL_MAX]; ++} statcoll_params; ++ ++typedef struct ++{ ++ UInt32 b_enabled; ++ char name[100]; ++ UInt32 *readings; ++ UInt32 *timestamp; ++ UInt32 group_id; ++ UInt32 counter_id; ++ UInt32 base_address; ++ UInt32 mux_req; ++}statcoll_initiators_object; ++ ++ ++#endif +diff --git a/clients/statcoll_gui.h b/clients/statcoll_gui.h +new file mode 100644 +index 0000000..7362bde +--- /dev/null ++++ b/clients/statcoll_gui.h +@@ -0,0 +1,101 @@ ++ ++/* ++ ++ --------------------------------------------- ++ | | ++ | --------------------------------------- | ++ | | ++ | | ++ | | ++ | | ++ | | ++ | | ++ | | ++ | | ++ | | ++ | | ++ | | ++ | | ++ | | ++ | | ++ | | ++ --------------------------------------------- ++ | | | ++ | | | ++ | | | ++ | | | ++ | | | ++ | | | ++ --------------------------------------------- ++ ++ ++ ++ ++*/ ++#define POSITION_X 2800 ++#define POSITION_Y 40 ++ ++#define MAX_WIDTH 900 ++//#define MAX_WIDTH 528 ++#define MAX_HEIGHT 900 ++ ++/* Derived parameters */ ++#define BAR_GAP (MAX_WIDTH/25) ++#define BAR_WIDTH (MAX_WIDTH/16) ++ ++#define BAR_HEIGHT ((MX_HEIGHT/40) * 6) ++ ++#define BORDER (MAX_WIDTH/15) ++ ++#define HEIGHT_EMIF_AREA (MAX_HEIGHT/4) ++ ++#define FONT_SIZE (MAX_WIDTH/40) ++ ++#define WIDTH_EMIF_AREA (MAX_WIDTH / 4) ++ ++#define TOTAL_Y_PARAMETERS (25) ++ ++#define TIME_GRAPH_AREA_BL_X (BORDER) ++#define TIME_GRAPH_AREA_BL_Y (MAX_HEIGHT - HEIGHT_EMIF_AREA - BORDER) ++#define TIME_GRAPH_AREA_TR_X (MAX_WIDTH - BORDER) ++#define TIME_GRAPH_AREA_TR_Y (BORDER) ++ ++#define EMIF_AREA_BL_X (0) ++#define EMIF_AREA_BL_Y (MAX_HEIGHT) ++#define EMIF_AREA_TR_X (WIDTH_EMIF_AREA) ++#define EMIF_AREA_TR_Y (MAX_HEIGHT - HEIGHT_EMIF_AREA) ++ ++#define INITIATORS_AREA_BL_X (WIDTH_EMIF_AREA) ++#define INITIATORS_AREA_BL_Y (MAX_HEIGHT) ++#define INITIATORS_AREA_TR_X (MAX_WIDTH) ++#define INITIATORS_AREA_TR_Y (MAX_HEIGHT - HEIGHT_EMIF_AREA) ++ ++ ++const char *string_list[TOTAL_Y_PARAMETERS] = { ++ "----DDR BANDWIDTH PLOT----", ++ "8 GBPS", ++ "6.4 ", ++ "4.8", ++ "3.2", ++ "1.6", ++ "0", ++ "EMIF Plot", ++ "test", ++ "EMIF1", ++ "test", ++ "EMIF2", ++ "TOP 6 INITIATORS", ++ "test", ++ "MPU", ++ "test", ++ "DSS", ++ "test", ++ "DSP", ++ "test", ++ "IVA", ++ "test", ++ "GPU", ++ "test", ++ "BB2D", ++}; ++ +diff --git a/clients/time_bar_graph.c b/clients/time_bar_graph.c +new file mode 100644 +index 0000000..9fa9c12 +--- /dev/null ++++ b/clients/time_bar_graph.c +@@ -0,0 +1,515 @@ ++/* ++ * Copyright © 2008 Kristian Høgsberg ++ * ++ * Permission to use, copy, modify, distribute, and sell this software and its ++ * documentation for any purpose is hereby granted without fee, provided that ++ * the above copyright notice appear in all copies and that both that copyright ++ * notice and this permission notice appear in supporting documentation, and ++ * that the name of the copyright holders not be used in advertising or ++ * publicity pertaining to distribution of the software without specific, ++ * written prior permission. The copyright holders make no representations ++ * about the suitability of this software for any purpose. It is provided "as ++ * is" without express or implied warranty. ++ * ++ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, ++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO ++ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR ++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, ++ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER ++ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE ++ * OF THIS SOFTWARE. ++ */ ++ ++#include <stdint.h> ++#include <stdio.h> ++#include <stdlib.h> ++#include <string.h> ++#include <stdint.h> ++#include <signal.h> ++#include <time.h> ++#include <math.h> ++#include <cairo.h> ++#include <sys/time.h> ++#include <pthread.h> ++#include <errno.h> ++#include <unistd.h> ++#include <sys/eventfd.h> ++#include <sys/epoll.h> ++ ++#include <linux/input.h> ++#include <wayland-client.h> ++#include "window.h" ++#include "../shared/cairo-util.h" ++#include "time_bar_graph.h" ++ ++//#define DEBUG 1 ++#ifdef DEBUG ++#define DBG(x...) printf(x) ++#else ++#define DBG(x...) // printf(x) ++#endif ++ ++#define MAX_ITEMS 180 ++#define MAX_TEXT_SIZE 128 ++ ++struct graph_dataset_point { ++ int next_index; ++ double y_values[MAX_ITEMS]; ++}; ++ ++struct graph_data { ++ int dataset_size; ++ int first_index, last_index, num_elems; ++ uint64_t last_time; ++ struct graph_dataset_point dataset[1]; ++}; ++ ++struct graph { ++ struct display *display; ++ struct window *window; ++ struct widget *widget; ++ int width, height; ++ struct time_graph_create_params params; ++ struct bar_graph_create_params bar_graph_params; ++ struct _y_config y_config_array[MAX_ITEMS]; ++ struct _text_config text_config_array[MAX_ITEMS]; ++ ++ /* Bar graph parameters */ ++ struct _bar_graph_y_config bar_graph_y_config_array[MAX_ITEMS]; ++ struct _text_config bar_graph_text_config_array[MAX_ITEMS]; ++ ++ pthread_t thr; ++ int eventfd; ++ struct task task; ++ double x_scaling_factor; ++ pthread_mutex_t mtx; ++ double time_graph_y_values[MAX_ITEMS]; ++ char text_values[MAX_ITEMS][MAX_TEXT_SIZE]; ++ ++ double bar_graph_y_values[MAX_ITEMS]; ++ char bar_graph_text_values[MAX_ITEMS][MAX_TEXT_SIZE]; ++ ++ uint64_t time_now; ++ time_t start_time_tv_sec; ++ struct graph_data *data; ++}; ++ ++struct graph *global_graph=NULL; ++static void ++draw_stuff(struct graph *g, cairo_surface_t *surface) ++{ ++ cairo_t *cr; ++ int i, j, n_elems; ++ double c_x, c_y, d_x, d_y; ++ ++ cr = cairo_create(surface); ++ cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE); ++ cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.5); ++ cairo_paint(cr); ++ cairo_select_font_face(cr, "mono", ++ CAIRO_FONT_SLANT_NORMAL, ++ CAIRO_FONT_WEIGHT_BOLD); ++ cairo_set_line_width (cr, 1.0); ++ cairo_set_operator(cr, CAIRO_OPERATOR_OVER); ++ pthread_mutex_lock(&g->mtx); ++ for (j=0; g->data->num_elems > 0 && j<g->params.num_of_y_items; j++) { ++ n_elems = g->data->num_elems; ++ DBG("first_index: %d, last_index: %d\n", g->data->first_index, g->data->last_index); ++ if (g->y_config_array[j].fill_color.a != 0.0) ++ cairo_move_to(cr, (double)g->params.draw_area.bottom_left.x, (double)g->params.draw_area.bottom_left.y); ++ c_x = (double)g->params.draw_area.bottom_left.x; ++ c_y = (double)g->params.draw_area.bottom_left.y; ++ d_x = 0; ++ i = g->data->first_index; ++ while (n_elems) { ++ DBG("index: %d, x: %f, y: %f, next_index: %d\n", i, c_x, ++ g->data->dataset[i].y_values[j], g->data->dataset[i].next_index); ++ d_y = g->data->dataset[i].y_values[j] - c_y; ++ c_y = g->data->dataset[i].y_values[j]; ++ c_x = c_x + d_x; ++ if (g->y_config_array[j].fill_color.a == 0.0 && n_elems == g->data->num_elems) { ++ cairo_move_to(cr, c_x, c_y); ++ } else { ++ cairo_curve_to(cr, c_x - (d_x * 0.75), c_y - (d_y * 0.92), c_x - (d_x * 0.25), c_y - (d_y * 0.08), c_x, c_y); ++ } ++ if (g->data->dataset[i].next_index > i) { ++ d_x = (g->data->dataset[i].next_index - i); ++ } else { ++ d_x = (g->data->dataset_size + g->data->dataset[i].next_index - i); ++ } ++ i = g->data->dataset[i].next_index; ++ n_elems--; ++ } ++ if (g->y_config_array[j].fill_color.a != 0.0) { ++ cairo_line_to(cr, c_x, (double)g->params.draw_area.bottom_left.y); ++ cairo_line_to(cr, (double)g->params.draw_area.bottom_left.x, (double)g->params.draw_area.bottom_left.y); ++ cairo_close_path(cr); ++ cairo_set_source_rgba(cr, g->y_config_array[j].fill_color.r, g->y_config_array[j].fill_color.g, ++ g->y_config_array[j].fill_color.b, g->y_config_array[j].fill_color.a); ++ cairo_fill_preserve(cr); ++ } ++ cairo_set_source_rgba(cr, g->y_config_array[j].line_color.r, g->y_config_array[j].line_color.g, ++ g->y_config_array[j].line_color.b, g->y_config_array[j].line_color.a); ++ cairo_stroke(cr); ++ } ++ ++ for (j=0; j<g->params.num_of_text_items; j++) { ++ cairo_move_to(cr, (double)g->text_config_array[j].at.x, (double)g->text_config_array[j].at.y); ++ cairo_set_font_size(cr, g->text_config_array[j].fontsize); ++ cairo_set_source_rgba(cr, g->text_config_array[j].color.r, g->text_config_array[j].color.g, ++ g->text_config_array[j].color.b, g->text_config_array[j].color.a); ++ cairo_show_text(cr, g->text_values[j]); ++ } ++ ++ ++ for (j=0; j<g->bar_graph_params.num_of_y_items; j++) { ++ cairo_move_to(cr, (double)g->bar_graph_params.y_config_array[j].region.bottom_left.x, ++ (double)g->bar_graph_params.y_config_array[j].region.bottom_left.y); ++ c_y = (double)g->bar_graph_params.y_config_array[j].region.bottom_left.y - ++ (g->bar_graph_y_values[j] * (double)(g->bar_graph_params.y_config_array[j].region.bottom_left.y - ++ g->bar_graph_params.y_config_array[j].region.top_right.y)); ++ cairo_line_to(cr, (double)g->bar_graph_params.y_config_array[j].region.bottom_left.x, c_y); ++ cairo_line_to(cr, (double)g->bar_graph_params.y_config_array[j].region.top_right.x, c_y); ++ cairo_line_to(cr, (double)g->bar_graph_params.y_config_array[j].region.top_right.x, ++ (double)g->bar_graph_params.y_config_array[j].region.bottom_left.y); ++ cairo_line_to(cr, (double)g->bar_graph_params.y_config_array[j].region.bottom_left.x, ++ (double)g->bar_graph_params.y_config_array[j].region.bottom_left.y); ++ cairo_close_path(cr); ++ cairo_set_source_rgba(cr, g->bar_graph_y_config_array[j].fill_color.r, g->bar_graph_y_config_array[j].fill_color.g, ++ g->bar_graph_y_config_array[j].fill_color.b, g->bar_graph_y_config_array[j].fill_color.a); ++ cairo_fill_preserve(cr); ++ cairo_set_source_rgba(cr, g->bar_graph_y_config_array[j].line_color.r, g->bar_graph_y_config_array[j].line_color.g, ++ g->bar_graph_y_config_array[j].line_color.b, g->bar_graph_y_config_array[j].line_color.a); ++ cairo_stroke(cr); ++ } ++ for (j=0; j<g->bar_graph_params.num_of_text_items; j++) { ++ cairo_move_to(cr, (double)g->bar_graph_text_config_array[j].at.x, (double)g->bar_graph_text_config_array[j].at.y); ++ cairo_set_font_size(cr, g->bar_graph_text_config_array[j].fontsize); ++ cairo_set_source_rgba(cr, g->bar_graph_text_config_array[j].color.r, g->bar_graph_text_config_array[j].color.g, ++ g->bar_graph_text_config_array[j].color.b, g->bar_graph_text_config_array[j].color.a); ++ cairo_save (cr); ++ //cairo_rotate(cr, 2*3.14*21/24); ++ cairo_show_text(cr, g->bar_graph_text_values[j]); ++ cairo_restore(cr); ++ } ++ pthread_mutex_unlock(&g->mtx); ++ cairo_destroy(cr); ++} ++ ++static void ++resize_handler(struct widget *widget, ++ int32_t width, int32_t height, void *data) ++{ ++ struct graph *g = data; ++ ++ /* Dont resize me */ ++ widget_set_size(g->widget, g->width, g->height); ++} ++ ++static void ++redraw_handler(struct widget *widget, void *data) ++{ ++ struct graph *g = data; ++ cairo_surface_t *surface; ++ ++ surface = window_get_surface(g->window); ++ if (surface == NULL || ++ cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) { ++ fprintf(stderr, "failed to create cairo egl surface\n"); ++ return; ++ } ++ ++ draw_stuff(g, surface); ++ cairo_surface_destroy(surface); ++} ++ ++static void ++button_handler(struct widget *widget, ++ struct input *input, uint32_t time, ++ uint32_t button, enum wl_pointer_button_state state, void *data) ++{ ++ struct graph *g = data; ++ ++ switch (button) { ++ case BTN_LEFT: ++ if (state == WL_POINTER_BUTTON_STATE_PRESSED) ++ window_move(g->window, input, ++ display_get_serial(g->display)); ++ break; ++ case BTN_MIDDLE: ++ if (state == WL_POINTER_BUTTON_STATE_PRESSED) ++ widget_schedule_redraw(widget); ++ break; ++ case BTN_RIGHT: ++ if (state == WL_POINTER_BUTTON_STATE_PRESSED) ++ window_show_frame_menu(g->window, input, time); ++ break; ++ } ++} ++ ++static void ++touch_down_handler(struct widget *widget, struct input *input, ++ uint32_t serial, uint32_t time, int32_t id, ++ float x, float y, void *data) ++{ ++ struct graph *g = data; ++ window_move(g->window, input, display_get_serial(g->display)); ++} ++ ++static void task_run(struct task *task, uint32_t events) ++{ ++ eventfd_t e; ++ struct graph *g = (struct graph *)(task->link.prev); ++ uint64_t time_diff; ++ int elems, tmp, incr, i; ++ double y; ++ ++ eventfd_read(g->eventfd, &e); ++ if(e == 1) { ++ pthread_mutex_lock(&g->mtx); ++ /* Process new data */ ++ DBG("time_now: %llu, last_time: %llu\n", g->time_now, g->data->last_time); ++ if (g->time_now > g->data->last_time) { ++ time_diff = g->time_now - g->data->last_time; ++ y = (double)time_diff * g->x_scaling_factor; ++ incr = (int)y; ++ DBG("incr: %d\n", incr); ++ ++ if (g->data->last_index >= g->data->first_index) elems = g->data->last_index - g->data->first_index + 1; ++ else elems = g->data->dataset_size - g->data->first_index + g->data->last_index + 1; ++ /* Move first index to make room for new element */ ++ while (g->data->dataset_size > 0 && (elems + incr) > g->data->dataset_size) { ++ tmp = g->data->dataset[g->data->first_index].next_index - g->data->first_index; ++ if (tmp < 0) tmp = g->data->dataset_size + tmp; ++ g->data->first_index = g->data->dataset[g->data->first_index].next_index; ++ elems -= tmp; ++ g->data->num_elems--; ++ } ++ for (i=0; i<g->params.num_of_y_items; i++) { ++ /* Scale Y */ ++ y = g->time_graph_y_values[i] * (double)(g->params.draw_area.bottom_left.y-g->params.draw_area.top_right.y); ++ y = (double)g->params.draw_area.bottom_left.y - y; ++ g->data->dataset[g->data->last_index].y_values[i] = y; ++ } ++ g->data->dataset[g->data->last_index].next_index = g->data->last_index + incr; ++ if (g->data->dataset[g->data->last_index].next_index >= g->data->dataset_size) ++ g->data->dataset[g->data->last_index].next_index -= g->data->dataset_size; ++ g->data->num_elems++; ++ g->data->last_index = g->data->dataset[g->data->last_index].next_index; ++ g->data->last_time = g->time_now; ++ } ++ pthread_mutex_unlock(&g->mtx); ++ } ++ widget_schedule_redraw(g->widget); ++ DBG("event task ran...\n"); ++} ++ ++void *time_graph_create(int argc, char *argv[], struct time_graph_create_params *cp) ++{ ++ struct graph *g; ++ struct display *d; ++ int dataset_size; ++ struct timeval tv; ++ ++ if (cp->num_of_y_items > MAX_ITEMS) return NULL; ++ if (cp->num_of_text_items > MAX_ITEMS) return NULL; ++ ++ g = (struct graph*)malloc(sizeof(struct graph)); ++ if (g == NULL) { ++ fprintf(stderr, "failed to allocate memory\n"); ++ return NULL; ++ } ++ global_graph = g; ++ g->params = *cp; ++ if (cp->num_of_y_items) ++ memcpy(&g->y_config_array[0], cp->y_config_array, ++ sizeof(struct _y_config) * cp->num_of_y_items); ++ if (cp->num_of_text_items) ++ memcpy(&g->text_config_array[0], cp->text_config_array, ++ sizeof(struct _text_config) * cp->num_of_text_items); ++ d = display_create(&argc, argv); ++ if (d == NULL) { ++ fprintf(stderr, "failed to create display: %m\n"); ++ return NULL; ++ } ++ g->display = d; ++ //g->bg_image = load_cairo_surface(cp->bg_image); ++ g->width = cp->width; //cairo_image_surface_get_width(g->bg_image); ++ g->height = cp->height; //cairo_image_surface_get_height(g->bg_image); ++ dataset_size = cp->draw_area.top_right.x - cp->draw_area.bottom_left.x; ++ g->data = (struct graph_data *)malloc(sizeof(struct graph_data) + ++ (dataset_size * sizeof(struct graph_dataset_point))); ++ if (!g->data) { ++ fprintf(stderr, "failed to allocate memory\n"); ++ display_destroy(g->display); ++ //cairo_surface_destroy(g->bg_image); ++ free(g); ++ return NULL; ++ } ++ g->data->first_index = 0; ++ g->data->last_index = 0; ++ g->data->num_elems = 0; ++ g->data->dataset_size = dataset_size; ++ g->x_scaling_factor = (double)dataset_size / (double)cp->time_span; ++ g->window = window_create(d); ++ g->widget = window_add_widget(g->window, g); ++ window_set_title(g->window, cp->title); ++ widget_set_resize_handler(g->widget, resize_handler); ++ widget_set_redraw_handler(g->widget, redraw_handler); ++ widget_set_button_handler(g->widget, button_handler); ++ widget_set_default_cursor(g->widget, CURSOR_HAND1); ++ widget_set_touch_down_handler(g->widget, touch_down_handler); ++ window_schedule_resize(g->window, g->width, g->height); ++ g->eventfd = eventfd(0, 0); ++ g->task.run = task_run; ++ g->task.link.prev = (struct wl_list*)g; ++ g->task.link.next = NULL; ++ display_watch_fd(d, g->eventfd, EPOLLIN, &g->task); ++ pthread_mutex_init(&g->mtx, NULL); ++ ++ if (0 != pthread_create(&g->thr, NULL, (void *(*)(void *))display_run, (void *)d)) { ++ fprintf(stderr, "pthread_create failed: %m\n"); ++ widget_destroy(g->widget); ++ window_destroy(g->window); ++ display_destroy(g->display); ++ //cairo_surface_destroy(g->bg_image); ++ free(g->data); ++ close(g->eventfd); ++ free(g); ++ return NULL; ++ } ++ gettimeofday(&tv, NULL); ++ g->start_time_tv_sec = tv.tv_sec; ++ g->data->last_time = 0; ++ return (void*)g; ++} ++ ++void move_graph(void *ctx, struct time_graph_create_params *cp) ++{ ++ struct graph *g = ctx; ++ window_set_title(g->window, cp->title); ++} ++ ++void time_graph_plot(void *ctx, double *y_values, const char *text_values[]) ++{ ++ struct timeval tv; ++ struct graph *g = ctx; ++ int i; ++ pthread_mutex_lock(&g->mtx); ++ gettimeofday(&tv, NULL); ++ g->time_now = ((tv.tv_sec - g->start_time_tv_sec) * 1000) + (tv.tv_usec / 1000); ++ memcpy(g->time_graph_y_values, y_values, g->params.num_of_y_items * sizeof(double)); ++ for (i=0;i<g->params.num_of_text_items; i++) { ++ strncpy(g->text_values[i], text_values[i], MAX_TEXT_SIZE); ++ g->text_values[i][MAX_TEXT_SIZE-1] = '\0'; ++ } ++ pthread_mutex_unlock(&g->mtx); ++ eventfd_write(g->eventfd, (eventfd_t)1); ++} ++ ++void time_graph_destroy(void *ctx) ++{ ++ struct graph *g = (struct graph *)ctx; ++ display_exit(g->display); ++ eventfd_write(g->eventfd, (eventfd_t)1); ++ pthread_join(g->thr, NULL); ++ widget_destroy(g->widget); ++ window_destroy(g->window); ++ display_destroy(g->display); ++ free(g->data); ++ close(g->eventfd); ++ free(g); ++ global_graph=NULL; ++} ++ ++void util_get_cpu_usage(double *cpu_usage) ++{ ++ static FILE *fp = NULL; ++ char buf[256]; ++ uint64_t tot; ++ uint64_t u, n, s, i, w, x, y, z; ++ static uint64_t last_i = 0, last_total = 0; ++ ++ ++ if (!fp) { ++ if (!(fp = fopen("/proc/stat", "r"))) ++ fprintf(stderr, "Failed /proc/stat open: %s", strerror(errno)); ++ } ++ if (fp) { ++ while (1) { ++ rewind(fp); ++ fflush(fp); ++ if (!fgets(buf, sizeof(buf), fp)) { ++ fprintf(stderr, "failed /proc/stat read\n"); ++ } else { ++ sscanf(buf, "cpu %Lu %Lu %Lu %Lu %Lu %Lu %Lu %Lu", ++ &u, ++ &n, ++ &s, ++ &i, ++ &w, ++ &x, ++ &y, ++ &z ++ ); ++ if (last_total == 0) { ++ last_total = u+n+s+i+w+x+y+z; ++ last_i = i; ++ usleep(100000); ++ } else { ++ tot = u+n+s+i+w+x+y+z; ++ *cpu_usage = (1.0 - ((double)(i-last_i)/(double)(tot-last_total))); ++ last_i = i; ++ last_total = tot; ++ break; ++ } ++ } ++ } ++ } ++} ++ ++void *bar_graph_create(int argc, char *argv[], struct bar_graph_create_params *cp) ++{ ++ struct graph *g; ++ struct display *d; ++ struct timeval tv; ++ ++ if (cp->num_of_y_items > MAX_ITEMS) return NULL; ++ if (cp->num_of_text_items > MAX_ITEMS) return NULL; ++ ++ if (global_graph == NULL) { ++ fprintf(stderr, "graph not initialized invoke time_graph_create first\n"); ++ return NULL; ++ } ++ g=global_graph; ++ g->bar_graph_params = *cp; ++ if (cp->num_of_y_items) ++ memcpy(&g->bar_graph_y_config_array[0], cp->y_config_array, ++ sizeof(struct _bar_graph_y_config) * cp->num_of_y_items); ++ if (cp->num_of_text_items) ++ memcpy(&g->bar_graph_text_config_array[0], cp->text_config_array, ++ sizeof(struct _text_config) * cp->num_of_text_items); ++ ++ return g; ++} ++ ++void bar_graph_plot(void *ctx, double *y_values, const char *text_values[]) ++{ ++ struct graph *g = ctx; ++ int i; ++ pthread_mutex_lock(&g->mtx); ++ memcpy(g->bar_graph_y_values, y_values, g->bar_graph_params.num_of_y_items * sizeof(double)); ++ for (i=0;i<g->bar_graph_params.num_of_text_items; i++) { ++ strncpy(g->bar_graph_text_values[i], text_values[i], MAX_TEXT_SIZE); ++ g->bar_graph_text_values[i][MAX_TEXT_SIZE-1] = '\0'; ++ } ++ pthread_mutex_unlock(&g->mtx); ++ //eventfd_write(g->eventfd, (eventfd_t)2); ++} ++ ++void bar_graph_destroy(void *ctx) ++{ ++ printf("Nothing to be done for this call\n"); ++ return; ++} ++ +diff --git a/clients/time_bar_graph.h b/clients/time_bar_graph.h +new file mode 100644 +index 0000000..97ac05a +--- /dev/null ++++ b/clients/time_bar_graph.h +@@ -0,0 +1,93 @@ ++ ++#ifndef _BAR_GRAPH_H_ ++#define _BAR_GRAPH_H_ ++ ++#include <stdint.h> ++ ++struct _rgba { ++ double r, g, b, a; // Values between 0 and 1 ++}; ++ ++struct _coordinate { ++ uint32_t x, y; // Co-ordinates relative to top-left of the window ++}; ++ ++struct _rect { ++ struct _coordinate bottom_left, top_right; ++}; ++ ++struct _y_config { ++ struct _rgba line_color; // Line color ++ struct _rgba fill_color; // Fill color, 0 alpha => no fill ++}; ++ ++struct _text_config { ++ struct _rgba color; // Color for drawing the text, RGBA ++ struct _coordinate at; // where to draw the text ++ int fontsize; // Font size ++}; ++ ++struct time_graph_create_params { ++ char *title; ++ //const char *bg_image; ++ uint32_t width; ++ uint32_t height; ++ struct _rect draw_area; ++ uint32_t time_span; // Amount of time the graph has to span in milliseconds ++ uint32_t num_of_y_items; ++ struct _y_config *y_config_array; ++ uint32_t num_of_text_items; ++ struct _text_config *text_config_array; ++}; ++ ++ ++struct _bar_graph_y_config { ++ struct _rect region; // Region for the bar graph ++ struct _rgba line_color; // Color for drawing the line, RGBA ++ struct _rgba fill_color; // Fill under the line with color RGBA, 0 => no fill ++}; ++ ++struct bar_graph_create_params { ++ char *title; ++ //const char *bg_image; ++ uint32_t num_of_y_items; ++ struct _bar_graph_y_config *y_config_array; ++ uint32_t num_of_text_items; ++ struct _text_config *text_config_array; ++}; ++ ++/* Creates a time graph using create parameters */ ++void *bar_graph_create(int argc, char *argv[], struct bar_graph_create_params *cp); ++ ++void move_graph(void *ctx, struct time_graph_create_params *cp); ++ ++/* Plots a new set of y-values from the values in the array y_values. ++ The number of values must be equal to "num_of_y_items" from create params ++ y_values must be normalized between 0.0 to 1.0 ++*/ ++void bar_graph_plot(void *ctx, double *y_values, const char *text_values[]); ++ ++/* Destroy the graph */ ++void bar_graph_destroy(void *ctx); ++ ++ ++/* Creates a time graph using create parameters */ ++void *time_graph_create(int argc, char *argv[], struct time_graph_create_params *cp); ++ ++/* ++ * Plots a new set of points from the values in the array y_values. ++ * The number of values in the array y_values must be equal to "num_of_y_items" ++ * from create params ++ * y_values must be normalized between 0.0 to 1.0 ++ ++ * The number of values in the array text_values must be equal to "num_of_text_items" ++ * from create params ++*/ ++void time_graph_plot(void *ctx, double *y_values, const char *text_values[]); ++ ++/* Destroy the graph */ ++void time_graph_destroy(void *ctx); ++ ++void util_get_cpu_usage(double *cpu_usage); ++ ++#endif /* _BAR_GRAPH_H_ */ +-- +1.9.1 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-ivi-shell-Add-autolaunch-and-launch-rules-functional.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-ivi-shell-Add-autolaunch-and-launch-rules-functional.patch new file mode 100644 index 000000000..b6b32aef7 --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-ivi-shell-Add-autolaunch-and-launch-rules-functional.patch @@ -0,0 +1,467 @@ +From 2e731255404e0efb0df1ede8d0b0a32ac011b420 Mon Sep 17 00:00:00 2001 +From: Volodymyr Riazantsev <volodymyr.riazantsev@globallogic.com> +Date: Sat, 16 Jul 2016 02:53:25 -0400 +Subject: [PATCH] ivi-shell: Add autolaunch and launch rules functionality + +Add ability to select application for autolaunch. +Also launch rules settings are added. + +Signed-off-by: Volodymyr Riazantsev <volodymyr.riazantsev@globallogic.com> +Signed-off-by: Karthik Ramanan <a0393906@ti.com> +--- + ivi-shell/ivi-layout-controller-ti.c | 293 +++++++++++++++++++++++++++++++---- + 1 file changed, 259 insertions(+), 34 deletions(-) + +diff --git a/ivi-shell/ivi-layout-controller-ti.c b/ivi-shell/ivi-layout-controller-ti.c +index b7cf436..4a2d648 100644 +--- a/ivi-shell/ivi-layout-controller-ti.c ++++ b/ivi-shell/ivi-layout-controller-ti.c +@@ -27,6 +27,9 @@ + #include <string.h> + #include <assert.h> + ++#include <fcntl.h> ++#include <unistd.h> ++ + #include "ivi-layout-export.h" + + #ifndef container_of +@@ -56,13 +59,24 @@ if (__dl__ & debug_level) \ + #define pr_wrn(...) __print_log(DL_WRN, "W: " __VA_ARGS__) + #define TRACE() __print_log(DL_DBG, "TR: %s - %d\n", __func__, __LINE__) + +- +-#define WINDOWS_TITLE_HEIGHT 30 + #define DEFAULT_SURFACE_ID_FOR_WL_SHELL_APP 0x80000000 + + /***************************************************************************** + * structure, globals + ****************************************************************************/ ++ ++struct hmi_launch_rule { ++#define MAX_APP_NAME_LEN 64 ++ char app_name[MAX_APP_NAME_LEN]; ++ int screen_id; ++ int order; ++ int autofocus; ++ int mode; ++ int32_t src_rect[4]; ++ int32_t dest_rect[4]; ++ int32_t crop_rect[4]; ++}; ++ + struct hmi_controller_layer { + struct ivi_layout_layer *ivilayer; + uint32_t id_layer; +@@ -75,6 +89,7 @@ struct hmi_controller_layer { + struct wl_list link; + struct wl_list screen_link; + struct wl_list surfaces_list; ++ struct hmi_launch_rule *rule; + }; + + struct hmi_controller_surface { +@@ -82,6 +97,7 @@ struct hmi_controller_surface { + void *ivisurf; + struct wl_list link; + struct wl_listener destroy_listener; ++ int conf_num; + }; + + struct hmi_controller_screen { +@@ -93,6 +109,8 @@ struct hmi_server_setting { + uint32_t base_layer_id; + int32_t panel_height; + char *ivi_homescreen; ++ char *homescreen_app; ++ struct wl_array rules; + }; + + struct hmi_controller { +@@ -108,6 +126,7 @@ struct hmi_controller { + struct wl_listener destroy_listener; + struct wl_client *user_interface; + struct wl_list layers_list; ++ + }; + + const struct ivi_controller_interface *ivi_controller_interface; +@@ -143,6 +162,42 @@ mem_alloc(size_t size, char *file, int32_t line) + + #define MEM_ALLOC(s) mem_alloc((s),__FILE__,__LINE__) + ++static int ++get_process_name_by_pid(pid_t pid, char *name, int size) ++{ ++ char proc_name[256] = "/proc/"; ++ char n[512] = {0}; ++ char *_n; ++ ++ sprintf(&proc_name[strlen(proc_name)], "%d/exe", (int)pid); ++ ++ if (!name ++ || access(proc_name, R_OK) ++ || (readlink(proc_name, n, sizeof(n)) <= 0)) { ++ ++ return -1; ++ } ++ ++ _n = strrchr(n, '/'); ++ strncpy(name, _n ? (_n + 1) : n, size); ++ ++ return 0; ++} ++ ++static struct hmi_launch_rule ++*get_rule(struct wl_array *arr, const char *app_name) ++{ ++ struct hmi_launch_rule *rule = NULL; ++ ++ wl_array_for_each(rule, arr) { ++ if (!strcmp(app_name, rule->app_name)) ++ return rule; ++ } ++ ++ return NULL; ++} ++ ++ + /** + * Internal method to create ivi_layer with hmi_controller_layer and + * add to a ivi_screen +@@ -177,6 +232,42 @@ create_layer(struct ivi_layout_screen *iviscrn, + + } + ++static void ++register_layer_on_screen(struct hmi_controller *hmi_ctrl, ++ int i, ++ struct hmi_controller_layer *nlayer) ++{ ++ unsigned cnt, j = 0; ++ struct hmi_controller_layer *layer = NULL; ++ struct ivi_layout_layer **layers; ++ ++ if (nlayer->rule && nlayer->rule->order == 0) { ++ wl_list_insert(&hmi_ctrl->screens[i].layers_list, &nlayer->screen_link); ++ } else { ++ wl_list_for_each(layer, &hmi_ctrl->screens[i].layers_list, screen_link) { ++ if (layer->rule && (layer->rule->order == 0)) ++ continue; ++ else ++ break; ++ } ++ wl_list_insert(layer->screen_link.prev, &nlayer->screen_link); ++ } ++ ++ cnt = wl_list_length(&hmi_ctrl->screens[i].layers_list); ++ ++ layers = calloc(cnt, sizeof(*layers)); ++ ++ wl_list_for_each_reverse(layer, &hmi_ctrl->screens[i].layers_list, screen_link) { ++ layers[j++] = layer->ivilayer; ++ } ++ ++ ivi_controller_interface->screen_set_render_order(hmi_ctrl->screens[i].iviscrn, layers, cnt); ++ ++ free(layers); ++ ++ ivi_controller_interface->commit_changes(); ++} ++ + static struct hmi_controller_layer + *get_layer_for_surface(struct hmi_controller *hmi_ctrl + , struct ivi_layout_surface *ivisurf +@@ -188,6 +279,9 @@ static struct hmi_controller_layer + struct wl_client *client; + struct ivi_layout_screen *iviscrn = NULL; + struct weston_output *output = NULL; ++ char proc_name[256]; ++ struct hmi_launch_rule *rule; ++ + pid_t pid; + uid_t uid; + gid_t gid; +@@ -213,13 +307,21 @@ static struct hmi_controller_layer + + pr_dbg("Existed layer for PID=%d was not found. Creating new\n", pid); + +- for(;; i++) { +- if (wl_list_empty(&hmi_ctrl->screens[i].layers_list) || +- (i == (hmi_ctrl->screens_count - 1))) +- break; +- }; ++ get_process_name_by_pid(pid, proc_name, sizeof(proc_name)); + +- iviscrn = hmi_ctrl->screens[i].iviscrn; ++ rule = get_rule(&hmi_ctrl->hmi_setting->rules, proc_name); ++ ++ if (rule && (rule->screen_id >= 0) && (rule->screen_id < hmi_ctrl->screens_count)) { ++ iviscrn = hmi_ctrl->screens[rule->screen_id].iviscrn; ++ i = rule->screen_id; ++ } else { ++ for(;; i++) { ++ if (wl_list_empty(&hmi_ctrl->screens[i].layers_list) || ++ (i == (hmi_ctrl->screens_count - 1))) ++ break; ++ }; ++ iviscrn = hmi_ctrl->screens[i].iviscrn; ++ } + + layer = calloc(1, sizeof *layer); + +@@ -230,14 +332,16 @@ static struct hmi_controller_layer + wl_list_init(&layer->surfaces_list); + + layer->width = output->width; +- layer->height = output->height + WINDOWS_TITLE_HEIGHT; ++ layer->height = output->height; + layer->id_layer = hmi_ctrl->hmi_setting->base_layer_id++; + layer->pid = pid; ++ layer->rule = rule; + + create_layer(iviscrn, layer); + + wl_list_insert(&hmi_ctrl->layers_list, &layer->link); +- wl_list_insert(&hmi_ctrl->screens[i].layers_list, &layer->screen_link); ++ ++ register_layer_on_screen(hmi_ctrl, i, layer); + + return layer; + +@@ -350,41 +454,77 @@ set_notification_configure_surface(struct ivi_layout_surface *ivisurf, + struct hmi_controller_layer *hmi_ctrl_layer = NULL; + struct weston_surface *surface; + struct hmi_controller_surface *hmi_ctrl_surf = NULL; ++ int src_rect[4] = {0}; ++ int dest_rect[4] = {0}; + + wl_list_for_each(hmi_ctrl_layer, &hmi_ctrl->layers_list, link) { + wl_list_for_each(hmi_ctrl_surf, &hmi_ctrl_layer->surfaces_list, link) { + if (hmi_ctrl_surf->ivisurf == ivisurf) { +- pr_dbg("Surface was already configured. Skip add to list\n"); + goto found; + } + } + } + +- hmi_ctrl_layer = NULL; ++ return; + found: + surface = ivi_controller_interface->surface_get_weston_surface(ivisurf); + +- if (surface) { +- +- ivi_controller_interface->surface_set_source_rectangle( +- ivisurf, 0, WINDOWS_TITLE_HEIGHT, surface->width, +- surface->height); +- +-#if 0 +- ivi_controller_interface->surface_set_destination_rectangle( +- ivisurf, 0, 0, surface->width, surface->height); +-#else +- if (hmi_ctrl_layer) { +- ivi_controller_interface->surface_set_destination_rectangle( +- ivisurf, 0, 0, hmi_ctrl_layer->width, hmi_ctrl_layer->height); +- } else { +- ivi_controller_interface->surface_set_destination_rectangle( +- ivisurf, 0, 0, surface->width, surface->height); ++ if (!surface) ++ return; ++ ++ src_rect[2] = dest_rect[2] = surface->width; ++ src_rect[3] = dest_rect[3] = surface->height; ++ ++ if (hmi_ctrl_layer && hmi_ctrl_layer->rule) { ++ ++ if (hmi_ctrl_layer->rule->mode >= 0) { ++ switch (hmi_ctrl_layer->rule->mode) { ++ case 1: ++ dest_rect[2] = hmi_ctrl_layer->width; ++ dest_rect[3] = hmi_ctrl_layer->height; ++ break; ++ ++ default: ++ /* No changes, using requested size */ ++ break; ++ } ++ } ++ ++ if (hmi_ctrl_layer->rule->crop_rect[0] >= 0) { ++ src_rect[0] += hmi_ctrl_layer->rule->crop_rect[0]; ++ src_rect[1] += hmi_ctrl_layer->rule->crop_rect[1]; ++ src_rect[2] -= (hmi_ctrl_layer->rule->crop_rect[0] ++ + hmi_ctrl_layer->rule->crop_rect[2]); ++ src_rect[3] -= (hmi_ctrl_layer->rule->crop_rect[1] ++ + hmi_ctrl_layer->rule->crop_rect[3]); ++ } ++ ++ if (hmi_ctrl_layer->rule->dest_rect[0] >= 0 || ++ hmi_ctrl_layer->rule->dest_rect[1] >= 0 || ++ hmi_ctrl_layer->rule->dest_rect[2] >= 0 || ++ hmi_ctrl_layer->rule->dest_rect[3] >= 0) { ++ ++ dest_rect[0] = hmi_ctrl_layer->rule->dest_rect[0]; ++ dest_rect[1] = hmi_ctrl_layer->rule->dest_rect[1]; ++ dest_rect[2] = hmi_ctrl_layer->rule->dest_rect[2] > 0 ? ++ hmi_ctrl_layer->rule->dest_rect[2] : dest_rect[2] ; ++ dest_rect[3] = hmi_ctrl_layer->rule->dest_rect[3] > 0 ? ++ hmi_ctrl_layer->rule->dest_rect[3] : dest_rect[3] ; + } +-#endif +- ivi_controller_interface->surface_set_visibility(ivisurf, true); +- ivi_controller_interface->commit_changes(); + } ++ ++ ivi_controller_interface->surface_set_source_rectangle(ivisurf ++ , src_rect[0], src_rect[1] ++ , src_rect[2], src_rect[3]); ++ ++ ivi_controller_interface->surface_set_destination_rectangle(ivisurf ++ , dest_rect[0], dest_rect[1] ++ , dest_rect[2], dest_rect[3]); ++ ++ ivi_controller_interface->surface_set_visibility(ivisurf, true); ++ ivi_controller_interface->commit_changes(); ++ ++ hmi_ctrl_surf->conf_num++; + } + + static struct hmi_server_setting * +@@ -393,6 +533,9 @@ hmi_server_setting_create(struct weston_compositor *ec) + struct hmi_server_setting *setting = MEM_ALLOC(sizeof(*setting)); + struct weston_config *config = ec->config; + struct weston_config_section *shell_section = NULL; ++ const char *name = NULL; ++ ++ setting->panel_height = 30; + + shell_section = weston_config_get_section(config, "ivi-shell", + NULL, NULL); +@@ -400,7 +543,78 @@ hmi_server_setting_create(struct weston_compositor *ec) + weston_config_section_get_uint(shell_section, "base-layer-id", + &setting->base_layer_id, 1000); + +- setting->panel_height = 30; ++ if ((shell_section = weston_config_get_section(config, "ivi-autolaunch", ++ NULL, NULL))) { ++ weston_config_section_get_string(shell_section, "path", ++ &setting->homescreen_app, NULL); ++ } ++ ++ ++ wl_array_init(&setting->rules); ++ ++ while (weston_config_next_section(config, &shell_section, &name)) { ++ int screen_id; ++ int order; ++ int mode; ++ int focus_on; ++ int crop_rect[4] = {-1, -1, -1, -1}; ++ int src_rect[4] = {-1, -1, -1, -1}; ++ int dest_rect[4] = {-1, -1, -1, -1}; ++ char *app_name; ++ char *buff; ++ struct hmi_launch_rule *rule = NULL; ++ ++ if (0 != strcmp(name, "ivi-layout-rule")) ++ continue; ++ ++ if (0 != weston_config_section_get_string(shell_section, "application", ++ &app_name, NULL)) ++ continue; ++ ++ weston_config_section_get_int(shell_section, "order", &order, -1); ++ weston_config_section_get_int(shell_section, "mode", &mode, -1); ++ weston_config_section_get_int(shell_section, "focus_on", &focus_on, -1); ++ weston_config_section_get_int(shell_section, "screen", &screen_id, -1); ++ ++ if (0 == weston_config_section_get_string(shell_section, "crop_rect", ++ &buff, NULL)) { ++ sscanf(buff, "%d,%d,%d,%d", crop_rect + 0, ++ crop_rect + 1, ++ crop_rect + 2, ++ crop_rect + 3); ++ } ++ ++ if (0 == weston_config_section_get_string(shell_section, "src_rect", ++ &buff, NULL)) { ++ sscanf(buff, "%d,%d,%d,%d", src_rect + 0, ++ src_rect + 1, ++ src_rect + 2, ++ src_rect + 3); ++ } ++ ++ if (0 == weston_config_section_get_string(shell_section, "dest_rect", ++ &buff, NULL)) { ++ sscanf(buff, "%d,%d,%d,%d", dest_rect + 0, ++ dest_rect + 1, ++ dest_rect + 2, ++ dest_rect + 3); ++ } ++ ++ rule = wl_array_add(&setting->rules, sizeof(*rule)); ++ ++ if (rule) { ++ rule->screen_id = screen_id; ++ rule->order = order; ++ rule->mode = mode; ++ rule->autofocus = focus_on; ++ ++ strncpy(rule->app_name, app_name, sizeof(rule->app_name)); ++ ++ memcpy(rule->src_rect, src_rect, sizeof(rule->src_rect)); ++ memcpy(rule->dest_rect, dest_rect, sizeof(rule->dest_rect)); ++ memcpy(rule->crop_rect, crop_rect, sizeof(rule->crop_rect)); ++ } ++ } + + return setting; + } +@@ -415,6 +629,15 @@ hmi_controller_destroy(struct wl_listener *listener, void *data) + free(hmi_ctrl); + } + ++static void hmi_controller_launch_homescreen(struct hmi_controller *hmi_ctrl) ++{ ++ if (hmi_ctrl->hmi_setting->homescreen_app) { ++ if(system(hmi_ctrl->hmi_setting->homescreen_app)) { ++ ; ++ } ++ } ++} ++ + static struct hmi_controller * + hmi_controller_create(struct weston_compositor *ec) + { +@@ -429,9 +652,10 @@ hmi_controller_create(struct weston_compositor *ec) + + ivi_controller_interface->get_screens(&screen_length, &pp_screen); + +- for (i = screen_length; i-- ; j++) { ++ for (i = screen_length; i--;) { + + iviscrn = pp_screen[i]; ++ j = ivi_controller_interface->get_id_of_screen(iviscrn); + hmi_ctrl->screens[j].iviscrn = iviscrn; + wl_list_init(&hmi_ctrl->screens[i].layers_list); + +@@ -506,7 +730,6 @@ controller_module_init(struct weston_compositor *ec, + { + struct hmi_controller *hmi_ctrl = NULL; + +- + if (interface_version < sizeof(struct ivi_controller_interface)) { + weston_log("ivi-layout-controller-ti: version mismatch of controller interface"); + return -1; +@@ -528,5 +751,7 @@ controller_module_init(struct weston_compositor *ec, + + weston_log("ivi-layout-controller-ti: Successfully started."); + ++ hmi_controller_launch_homescreen(hmi_ctrl); ++ + return 0; + } +-- +2.4.5 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-ivi-shell-Add-screenshooter-option.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-ivi-shell-Add-screenshooter-option.patch new file mode 100644 index 000000000..aa45011b9 --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-ivi-shell-Add-screenshooter-option.patch @@ -0,0 +1,29 @@ +From 6189fb7936f469eab53db712f31dc8276075ff5e Mon Sep 17 00:00:00 2001 +From: Volodymyr Riazantsev <volodymyr.riazantsev@globallogic.com> +Date: Tue, 16 Aug 2016 23:47:23 -0400 +Subject: [PATCH] ivi-shell: Add screenshooter option + +Add ability to capture the screen. + +Signed-off-by: Volodymyr Riazantsev <volodymyr.riazantsev@globallogic.com> +Signed-off-by: Karthik Ramanan <a0393906@ti.com> +--- + ivi-shell/ivi-shell.c | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/ivi-shell/ivi-shell.c b/ivi-shell/ivi-shell.c +index 1720705..5637d8e 100644 +--- a/ivi-shell/ivi-shell.c ++++ b/ivi-shell/ivi-shell.c +@@ -456,6 +456,8 @@ module_init(struct weston_compositor *compositor, + argc, argv) < 0) + goto out_settings; + ++ screenshooter_create(compositor); ++ + retval = 0; + + out_settings: +-- +2.4.5 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-ivi-shell-fix-TODO-which-expects-only-one-screen-in-.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-ivi-shell-fix-TODO-which-expects-only-one-screen-in-.patch new file mode 100644 index 000000000..d2af15eca --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-ivi-shell-fix-TODO-which-expects-only-one-screen-in-.patch @@ -0,0 +1,33 @@ +From 93ceff13467e7fb1bee38c0ab6f587f5f99cc594 Mon Sep 17 00:00:00 2001 +From: Nobuhiko Tanibata <NOBUHIKO_TANIBATA@xddp.denso.co.jp> +Date: Wed, 25 Nov 2015 23:36:09 +0900 +Subject: [PATCH 1/7] ivi-shell: fix TODO which expects only one screen in the + system. + +It just return the first screen found in screen list. + +Signed-off-by: Nobuhiko Tanibata <NOBUHIKO_TANIBATA@xddp.denso.co.jp> +Reviewed-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk> +--- + ivi-shell/ivi-layout.c | 5 ++--- + 1 file changed, 2 insertions(+), 3 deletions(-) + +diff --git a/ivi-shell/ivi-layout.c b/ivi-shell/ivi-layout.c +index a04076e..efc0da5 100644 +--- a/ivi-shell/ivi-layout.c ++++ b/ivi-shell/ivi-layout.c +@@ -1484,9 +1484,8 @@ ivi_layout_get_screen_from_id(uint32_t id_screen) + struct ivi_layout_screen *iviscrn = NULL; + + wl_list_for_each(iviscrn, &layout->screen_list, link) { +-/* FIXME : select iviscrn from screen_list by id_screen */ +- return iviscrn; +- break; ++ if (iviscrn->id_screen == id_screen) ++ return iviscrn; + } + + return NULL; +-- +2.4.5 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-ivi-shell-layer-controller-ti-Improve-functionality.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-ivi-shell-layer-controller-ti-Improve-functionality.patch new file mode 100644 index 000000000..7db49341e --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-ivi-shell-layer-controller-ti-Improve-functionality.patch @@ -0,0 +1,326 @@ +From 70f5b755b00d5eab576ed897a8301367b0e367a6 Mon Sep 17 00:00:00 2001 +From: Volodymyr Riazantsev <volodymyr.riazantsev@globallogic.com> +Date: Sat, 16 Jul 2016 02:53:25 -0400 +Subject: [PATCH] ivi-shell: layer-controller-ti: Improve functionality + +Functionality improved: + + * can launch multiple application on start + * handle keyboard focus: + - TAB-LEFTALT can be used for switch focus + - focus history; + - focus on new application. + +Signed-off-by: Volodymyr Riazantsev <volodymyr.riazantsev@globallogic.com> +Signed-off-by: Karthik Ramanan <a0393906@ti.com> +--- + ivi-shell/ivi-layout-controller-ti.c | 167 +++++++++++++++++++++++++++++++---- + 1 file changed, 148 insertions(+), 19 deletions(-) + +diff --git a/ivi-shell/ivi-layout-controller-ti.c b/ivi-shell/ivi-layout-controller-ti.c +index 4a2d648..9be51d1 100644 +--- a/ivi-shell/ivi-layout-controller-ti.c ++++ b/ivi-shell/ivi-layout-controller-ti.c +@@ -30,6 +30,8 @@ + #include <fcntl.h> + #include <unistd.h> + ++#include <linux/input.h> ++ + #include "ivi-layout-export.h" + + #ifndef container_of +@@ -85,6 +87,7 @@ struct hmi_controller_layer { + int32_t width; + int32_t height; + int32_t num_surfaces; ++ int32_t focus; + pid_t pid; + struct wl_list link; + struct wl_list screen_link; +@@ -96,8 +99,10 @@ struct hmi_controller_surface { + void *controller; + void *ivisurf; + struct wl_list link; ++ struct wl_list focus_link; + struct wl_listener destroy_listener; + int conf_num; ++ int focus; + }; + + struct hmi_controller_screen { +@@ -106,11 +111,12 @@ struct hmi_controller_screen { + }; + + struct hmi_server_setting { +- uint32_t base_layer_id; +- int32_t panel_height; +- char *ivi_homescreen; +- char *homescreen_app; +- struct wl_array rules; ++ uint32_t base_layer_id; ++ int32_t panel_height; ++ char *ivi_homescreen; ++ char *homescreen_app; ++ struct wl_array autolaunch_apps; ++ struct wl_array rules; + }; + + struct hmi_controller { +@@ -126,6 +132,7 @@ struct hmi_controller { + struct wl_listener destroy_listener; + struct wl_client *user_interface; + struct wl_list layers_list; ++ struct wl_list focus_history_list; + + }; + +@@ -350,12 +357,59 @@ exit: + } + + static void ++move_kbd_focus(struct hmi_controller_surface *ivisurf, struct hmi_controller *hmi_ctrl, bool history) ++{ ++ struct hmi_controller_layer *layer; ++ struct hmi_controller_surface *surf; ++ struct weston_seat *seat; ++ struct weston_keyboard *keyboard; ++ struct weston_surface *surface; ++ ++ wl_list_for_each(layer, &hmi_ctrl->layers_list, link) { ++ wl_list_for_each(surf, &layer->surfaces_list, link) { ++ if (surf->focus) { ++ surf->focus = 0; ++ wl_list_insert(&hmi_ctrl->focus_history_list, &surf->focus_link); ++ break; ++ } ++ } ++ } ++ ++ wl_list_for_each(seat, &hmi_ctrl->compositor->seat_list, link) { ++ if(!strcmp("default", seat->seat_name)) ++ break; ++ } ++ ++ keyboard = weston_seat_get_keyboard(seat); ++ ++ if (!keyboard) ++ return; ++ ++ if (ivisurf) { ++ surface = ivi_controller_interface->surface_get_weston_surface(ivisurf->ivisurf); ++ weston_keyboard_set_focus(keyboard, surface); ++ ivisurf->focus = 1; ++ ++ if (NULL != ivisurf->focus_link.next) ++ wl_list_remove(&ivisurf->focus_link); ++ ++ } else if (history && !wl_list_empty(&hmi_ctrl->focus_history_list)) { ++ struct hmi_controller_surface *s = ++ wl_container_of(hmi_ctrl->focus_history_list.next, s, focus_link); ++ wl_list_remove(&s->focus_link); ++ surface = ivi_controller_interface->surface_get_weston_surface(s->ivisurf); ++ weston_keyboard_set_focus(keyboard, surface); ++ s->focus = 1; ++ } ++} ++ ++static void + set_notification_create_surface(struct ivi_layout_surface *ivisurf, + void *userdata) + { + struct hmi_controller *hmi_ctrl = userdata; +- struct hmi_controller_layer *hmi_ctrl_layer = NULL; +- struct hmi_controller_surface *hmi_ctrl_surf = NULL; ++ struct hmi_controller_layer *hmi_ctrl_layer; ++ struct hmi_controller_surface *hmi_ctrl_surf; + struct ivi_layout_layer *dest_layer; + struct weston_surface *surface; + +@@ -378,6 +432,7 @@ set_notification_create_surface(struct ivi_layout_surface *ivisurf, + hmi_ctrl_surf = calloc(1, sizeof(*hmi_ctrl_surf)); + hmi_ctrl_surf->ivisurf = ivisurf; + wl_list_init(&hmi_ctrl_surf->link); ++ wl_list_init(&hmi_ctrl_surf->focus_link); + wl_list_insert(&hmi_ctrl_layer->surfaces_list, &hmi_ctrl_surf->link); + + +@@ -419,6 +474,9 @@ remove: + + wl_list_remove(&surf->link); + ++ if (surf->focus) ++ move_kbd_focus(NULL, hmi_ctrl, true); ++ + ivi_controller_interface->layer_remove_surface(dest_layer, ivisurf); + + if (wl_list_empty(&hmi_ctrl_layer->surfaces_list)) { +@@ -451,9 +509,10 @@ set_notification_configure_surface(struct ivi_layout_surface *ivisurf, + void *userdata) + { + struct hmi_controller *hmi_ctrl = userdata; +- struct hmi_controller_layer *hmi_ctrl_layer = NULL; ++ struct hmi_controller_layer *hmi_ctrl_layer; + struct weston_surface *surface; +- struct hmi_controller_surface *hmi_ctrl_surf = NULL; ++ struct weston_seat *seat = NULL; ++ struct hmi_controller_surface *hmi_ctrl_surf; + int src_rect[4] = {0}; + int dest_rect[4] = {0}; + +@@ -511,6 +570,16 @@ found: + dest_rect[3] = hmi_ctrl_layer->rule->dest_rect[3] > 0 ? + hmi_ctrl_layer->rule->dest_rect[3] : dest_rect[3] ; + } ++ ++ if (hmi_ctrl_layer->rule->autofocus) { ++ ++ wl_list_for_each(seat, &hmi_ctrl->compositor->seat_list, link) { ++ if(!strcmp("default", seat->seat_name)) ++ break; ++ } ++ ++ move_kbd_focus(hmi_ctrl_surf, hmi_ctrl, false); ++ } + } + + ivi_controller_interface->surface_set_source_rectangle(ivisurf +@@ -522,6 +591,7 @@ found: + , dest_rect[2], dest_rect[3]); + + ivi_controller_interface->surface_set_visibility(ivisurf, true); ++ + ivi_controller_interface->commit_changes(); + + hmi_ctrl_surf->conf_num++; +@@ -543,14 +613,9 @@ hmi_server_setting_create(struct weston_compositor *ec) + weston_config_section_get_uint(shell_section, "base-layer-id", + &setting->base_layer_id, 1000); + +- if ((shell_section = weston_config_get_section(config, "ivi-autolaunch", +- NULL, NULL))) { +- weston_config_section_get_string(shell_section, "path", +- &setting->homescreen_app, NULL); +- } +- +- + wl_array_init(&setting->rules); ++ wl_array_init(&setting->autolaunch_apps); ++ wl_array_init(&setting->autolaunch_apps); + + while (weston_config_next_section(config, &shell_section, &name)) { + int screen_id; +@@ -564,6 +629,12 @@ hmi_server_setting_create(struct weston_compositor *ec) + char *buff; + struct hmi_launch_rule *rule = NULL; + ++ if (!strcmp(name, "ivi-autolaunch")) { ++ char **s = wl_array_add(&setting->autolaunch_apps, sizeof(*s)); ++ weston_config_section_get_string(shell_section, "path", s, NULL); ++ continue; ++ } ++ + if (0 != strcmp(name, "ivi-layout-rule")) + continue; + +@@ -573,7 +644,7 @@ hmi_server_setting_create(struct weston_compositor *ec) + + weston_config_section_get_int(shell_section, "order", &order, -1); + weston_config_section_get_int(shell_section, "mode", &mode, -1); +- weston_config_section_get_int(shell_section, "focus_on", &focus_on, -1); ++ weston_config_section_get_int(shell_section, "focus_on", &focus_on, 0); + weston_config_section_get_int(shell_section, "screen", &screen_id, -1); + + if (0 == weston_config_section_get_string(shell_section, "crop_rect", +@@ -631,8 +702,10 @@ hmi_controller_destroy(struct wl_listener *listener, void *data) + + static void hmi_controller_launch_homescreen(struct hmi_controller *hmi_ctrl) + { +- if (hmi_ctrl->hmi_setting->homescreen_app) { +- if(system(hmi_ctrl->hmi_setting->homescreen_app)) { ++ char **app; ++ ++ wl_array_for_each(app, &hmi_ctrl->hmi_setting->autolaunch_apps) { ++ if(system(*app)) { + ; + } + } +@@ -674,6 +747,7 @@ hmi_controller_create(struct weston_compositor *ec) + &hmi_ctrl->destroy_listener); + + wl_list_init(&hmi_ctrl->layers_list); ++ wl_list_init(&hmi_ctrl->focus_history_list); + + free(pp_screen); + pp_screen = NULL; +@@ -719,6 +793,57 @@ initialize(struct hmi_controller *hmi_ctrl) + return 1; + } + ++static void ++switch_focus_bindings(struct weston_keyboard *keyboard, uint32_t time, ++ uint32_t key, void *data) ++{ ++ struct hmi_controller *hmi_ctrl = data; ++ struct hmi_controller_layer *hmi_ctrl_layer, *next_l, *cycle_l = NULL; ++ struct hmi_controller_surface *hmi_ctrl_surf; ++ bool pp = false; ++ ++ wl_list_for_each(hmi_ctrl_layer, &hmi_ctrl->layers_list, link) { ++ wl_list_for_each(hmi_ctrl_surf, &hmi_ctrl_layer->surfaces_list, link) { ++ if (hmi_ctrl_surf->focus) { ++ goto ff; ++ } ++ } ++ } ++ ++ hmi_ctrl_surf = NULL; ++ pp = true; ++ ++ff: ++ wl_list_for_each(next_l, &hmi_ctrl->layers_list, link) { ++ ++ if (pp) { ++ if (next_l->rule && next_l->rule->autofocus) { ++ cycle_l = next_l; ++ break; ++ } ++ } else { ++ if (next_l == hmi_ctrl_layer) { ++ pp = true; ++ continue; ++ } else { ++ if (next_l->rule && next_l->rule->autofocus) { ++ cycle_l = next_l; ++ break; ++ } ++ } ++ } ++ } ++ ++ if (!cycle_l) ++ return; ++ ++ move_kbd_focus(container_of(cycle_l->surfaces_list.next ++ , struct hmi_controller_surface ++ , link) ++ , hmi_ctrl, false); ++} ++ ++ + /***************************************************************************** + * exported functions + ****************************************************************************/ +@@ -753,5 +878,9 @@ controller_module_init(struct weston_compositor *ec, + + hmi_controller_launch_homescreen(hmi_ctrl); + ++ weston_compositor_add_key_binding(ec, KEY_TAB , MODIFIER_ALT, ++ switch_focus_bindings, hmi_ctrl); ++ weston_install_debug_key_binding(ec, 0); ++ + return 0; + } +-- +2.4.5 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-udev-seat-restrict-udev-enumeration-to-card0.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-udev-seat-restrict-udev-enumeration-to-card0.patch new file mode 100644 index 000000000..515f06c47 --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-udev-seat-restrict-udev-enumeration-to-card0.patch @@ -0,0 +1,37 @@ +From e8e7a9f7dfa164a75fdbdca87622a2e13334478a Mon Sep 17 00:00:00 2001 +From: Anand Balagopalakrishnan <anandb@ti.com> +Date: Sat, 23 Jan 2016 22:48:07 +0530 +Subject: [PATCH 1/1] udev-seat: restrict udev enumeration to card0 + +In case of separate GPU and Display devices as found in embedded systems, we +could have modeset node and render node controlled by different drivers. +There is a distinct possibility that udev enumeration returns the DRM device +corresponding to render node as the primary DRM device. + +Obviously, modeset operations cannot be done on the GPU DRM device. + +Restrict the udev enumeration to card0 and ensure that DRM device corresponding +to display is returned as the primary DRM device. + +Upstream-Status: Pending + +Signed-off-by: Anand Balagopalakrishnan <anandb@ti.com> +--- + src/compositor-drm.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/compositor-drm.c b/src/compositor-drm.c +index 6777bf8..59c2cc5 100644 +--- a/src/compositor-drm.c ++++ b/src/compositor-drm.c +@@ -2827,7 +2827,7 @@ find_primary_gpu(struct drm_backend *b, const char *seat) + + e = udev_enumerate_new(b->udev); + udev_enumerate_add_match_subsystem(e, "drm"); +- udev_enumerate_add_match_sysname(e, "card[0-9]*"); ++ udev_enumerate_add_match_sysname(e, "card0"); + + udev_enumerate_scan_devices(e); + drm_device = NULL; +-- +1.7.9.5 diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-weston1.9.0-Enabling-DRM-backend-with-multiple-displ.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-weston1.9.0-Enabling-DRM-backend-with-multiple-displ.patch new file mode 100644 index 000000000..3efceb5db --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0001-weston1.9.0-Enabling-DRM-backend-with-multiple-displ.patch @@ -0,0 +1,60 @@ +From 15d9f155fdb3abffc348e81b1560702801994715 Mon Sep 17 00:00:00 2001 +From: Karthik Ramanan <a0393906@ti.com> +Date: Mon, 11 Jan 2016 11:51:30 -0500 +Subject: [PATCH 1/2] weston1.9.0: Enabling DRM backend with multiple displays + +There are three main issues that this patch tries to address + + 1. Black screen when running weston + 2. Support for multiple displays + 3. Handling missing VBlanks + +There is an issue with missing VBlanks for LCD and +HDMI connectors which leads to display not getting refreshed. +This patch can be considered as a workaround. + +Signed-off-by: Karthik Ramanan <a0393906@ti.com> +--- + src/compositor-drm.c | 10 ++++++++-- + 1 file changed, 8 insertions(+), 2 deletions(-) + +diff --git a/src/compositor-drm.c b/src/compositor-drm.c +index 6777bf8..15ddba8 100644 +--- a/src/compositor-drm.c ++++ b/src/compositor-drm.c +@@ -686,7 +686,7 @@ drm_output_repaint(struct weston_output *output_base, + .request.sequence = 1, + }; + +- if ((!s->current && !s->next) || ++ if ((!s->current && !s->next) && + !drm_sprite_crtc_supported(output, s->possible_crtcs)) + continue; + +@@ -847,6 +847,7 @@ page_flip_handler(int fd, unsigned int frame, + { + struct drm_output *output = (struct drm_output *) data; + struct timespec ts; ++ uint32_t bail; + uint32_t flags = PRESENTATION_FEEDBACK_KIND_VSYNC | + PRESENTATION_FEEDBACK_KIND_HW_COMPLETION | + PRESENTATION_FEEDBACK_KIND_HW_CLOCK; +@@ -864,9 +865,14 @@ page_flip_handler(int fd, unsigned int frame, + + output->page_flip_pending = 0; + ++ if(output->vblank_pending) { ++ weston_log("VBlank is pending for connector = %d, frame = %d\n", output->connector_id, frame); ++ bail = 1; ++ } ++ + if (output->destroy_pending) + drm_output_destroy(&output->base); +- else if (!output->vblank_pending) { ++ else if (!output->vblank_pending || bail ) { + ts.tv_sec = sec; + ts.tv_nsec = usec * 1000; + weston_output_finish_frame(&output->base, &ts, flags); +-- +1.9.1 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0002-Weston1.9.0-Allow-visual_id-to-be-0.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0002-Weston1.9.0-Allow-visual_id-to-be-0.patch new file mode 100644 index 000000000..72d067fd9 --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0002-Weston1.9.0-Allow-visual_id-to-be-0.patch @@ -0,0 +1,31 @@ +From 27cf7d0c260fa4754a021e9f6f92f83e2c99f5f4 Mon Sep 17 00:00:00 2001 +From: Eric Ruei <e-ruei1@ti.com> +Date: Mon, 11 Jan 2016 11:59:19 -0500 +Subject: [PATCH 2/2] Weston1.9.0: Allow visual_id to be 0 + +The inquiry of visual id from egl API eglGetConfigAttrib(EGL_NATIVE_VISUAL_ID) +is an optional feature. The visual id will be set to 0 if this feature is +not supported. Therefore, the return condition @function match_config_to_visual() +should be (id == visual_id || id == 0) instead of (id == visual_id) + +Signed-off-by: Eric Ruei <e-ruei1@ti.com> +--- + src/gl-renderer.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/gl-renderer.c b/src/gl-renderer.c +index d7231f4..e1b925e 100644 +--- a/src/gl-renderer.c ++++ b/src/gl-renderer.c +@@ -2194,7 +2194,7 @@ match_config_to_visual(EGLDisplay egl_display, + &id)) + continue; + +- if (id == visual_id) ++ if (id == visual_id || id == 0) + return i; + } + +-- +1.9.1 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0002-ivi-shell-multi-screen-support-to-calcuration-of-a-m.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0002-ivi-shell-multi-screen-support-to-calcuration-of-a-m.patch new file mode 100644 index 000000000..35835f08c --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0002-ivi-shell-multi-screen-support-to-calcuration-of-a-m.patch @@ -0,0 +1,95 @@ +From 5c3c97aecadd59231e3b99a021080b019e1bbea4 Mon Sep 17 00:00:00 2001 +From: Nobuhiko Tanibata <nobuhiko_tanibata@xddp.denso.co.jp> +Date: Wed, 9 Dec 2015 15:39:26 +0900 +Subject: [PATCH 2/7] ivi-shell: multi screen support to calcuration of a mask + of weston_surface. + +A weston_surface is transformed to multi screen coordinate, global +coordinate by matrix:m now. + +Additionally, a mask needs to be calucated, taking account into, +- multi screen coordination: a destination rectangle of layer in the + coordination is easily calcurated by adding weston_output.{x,y} in + simple. This is because there is no scaled and rotated transformation. +- intersect inside of a screen the layer is assigned to. This is because + overlapped region of weston surface in another screen shall not be + displayed according to ivi use case. + +Signed-off-by: Nobuhiko Tanibata <nobuhiko_tanibata@xddp.denso.co.jp> +Reviewed-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk> +--- + ivi-shell/ivi-layout.c | 36 +++++++++++++++++++++++++++++++----- + 1 file changed, 31 insertions(+), 5 deletions(-) + +diff --git a/ivi-shell/ivi-layout.c b/ivi-shell/ivi-layout.c +index efc0da5..c8ea270 100644 +--- a/ivi-shell/ivi-layout.c ++++ b/ivi-shell/ivi-layout.c +@@ -665,15 +665,24 @@ calc_inverse_matrix_transform(const struct weston_matrix *matrix, + + /** + * This computes the whole transformation matrix:m from surface-local +- * coordinates to global coordinates. It is assumed that +- * weston_view::geometry.{x,y} are zero. ++ * coordinates to multi screens coordinate, which is global coordinates. ++ * It is assumed that weston_view::geometry.{x,y} are zero. + * + * Additionally, this computes the mask on surface-local coordinates as a + * ivi_rectangle. This can be set to weston_view_set_mask. + * + * The mask is computed by following steps +- * - destination rectangle of layer is inversed to surface-local cooodinates +- * by inversed matrix:m. ++ * - destination rectangle of layer is tansformed to multi screen coordinate, ++ * global coordinates. This is done by adding weston_output.{x,y} in simple ++ * because there is no scaled and rotated transformation. ++ * - destination rectangle of layer in multi screens coordinate needs to be ++ * intersected inside of a screen the layer is assigned to. This is because ++ * overlapped region of weston surface in another screen shall not be ++ * displayed according to ivi use case. ++ * - destination rectangle of layer ++ * - in multi screen coordinates, ++ * - and intersected inside of an assigned screen, ++ * is inversed to surface-local cooodinates by inversed matrix:m. + * - the area is intersected by intersected area between weston_surface and + * source rectangle of ivi_surface. + */ +@@ -706,7 +715,17 @@ calc_surface_to_global_matrix_and_mask_to_weston_surface( + lp->dest_y, + lp->dest_width, + lp->dest_height }; ++ struct ivi_rectangle screen_dest_rect = { output->x, ++ output->y, ++ output->width, ++ output->height }; ++ struct ivi_rectangle layer_dest_rect_in_global = ++ { lp->dest_x + output->x, ++ lp->dest_y + output->y, ++ lp->dest_width, ++ lp->dest_height }; + struct ivi_rectangle surface_result; ++ struct ivi_rectangle layer_dest_rect_in_global_intersected; + + /* + * the whole transformation matrix:m from surface-local +@@ -729,9 +748,16 @@ calc_surface_to_global_matrix_and_mask_to_weston_surface( + ivi_rectangle_intersect(&surface_source_rect, &weston_surface_rect, + &surface_result); + ++ /* ++ * destination rectangle of layer in multi screens coordinate ++ * is intersected to avoid displaying outside of an assigned screen. ++ */ ++ ivi_rectangle_intersect(&layer_dest_rect_in_global, &screen_dest_rect, ++ &layer_dest_rect_in_global_intersected); ++ + /* calc masking area of weston_surface from m */ + calc_inverse_matrix_transform(m, +- &layer_dest_rect, ++ &layer_dest_rect_in_global_intersected, + &surface_result, + result); + } +-- +2.4.5 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0003-Weston1.9.0-Fix-virtual-keyboard-display-issue-for-Q.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0003-Weston1.9.0-Fix-virtual-keyboard-display-issue-for-Q.patch new file mode 100644 index 000000000..576b37e15 --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0003-Weston1.9.0-Fix-virtual-keyboard-display-issue-for-Q.patch @@ -0,0 +1,40 @@ +From 7d2f4a97306707fb29e743bf66a827e661aa5615 Mon Sep 17 00:00:00 2001 +From: Eric Ruei <e-ruei1@ti.com> +Date: Tue, 23 Feb 2016 18:26:57 -0500 +Subject: [PATCH 3/3] Weston1.9.0: Fix virtual keyboard display issue for QT5 + application + +The virtual keyboard does pop up as expected, however, it will never hide +even when the application is terminated. This problem is due to the order +of the text APIs( text_input_activate and test_input_show_input_panel) are +invoked in QT5 and a potential bug of the API implementation. The virtual +keyboard works as expected if the test_input_show_input_panel() is invoked +prior to the test_input_activate() as most of the weston sample applications +do. However, the problem will show up if that order is reversed and the reason +why is that the current_panel is not set in this case and hence this panel +cannot be hidden. + +It is required to set the current_panel to the text_input when the input_panel +becomes visible at the first time. + + +Signed-off-by: Eric Ruei <e-ruei1@ti.com> +--- + src/text-backend.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/src/text-backend.c b/src/text-backend.c +index cd6c4d99..ba60949 100644 +--- a/src/text-backend.c ++++ b/src/text-backend.c +@@ -338,6 +338,7 @@ text_input_show_input_panel(struct wl_client *client, + text_input->surface); + wl_signal_emit(&ec->update_input_panel_signal, + &text_input->cursor_rectangle); ++ text_input->manager->current_panel = text_input; + } + } + +-- +1.9.1 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0003-ivi-shell-avoid-update_prop-on-invisible-surfaces.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0003-ivi-shell-avoid-update_prop-on-invisible-surfaces.patch new file mode 100644 index 000000000..2509713ba --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0003-ivi-shell-avoid-update_prop-on-invisible-surfaces.patch @@ -0,0 +1,77 @@ +From 679cc873528ffb3fd94306a01dcf9d6ffa8eb120 Mon Sep 17 00:00:00 2001 +From: Nobuhiko Tanibata <nobuhiko_tanibata@xddp.denso.co.jp> +Date: Wed, 9 Dec 2015 15:36:58 +0900 +Subject: [PATCH 3/7] ivi-shell: avoid update_prop() on invisible surfaces + +For multi screen support, ivi_layout_screen to be taken account into +property change in commitChanges. + +Property change is now done in update_prop so to consider ivi_screen +property for caluculating transform of weston surface, ivi_layout_screen + is added as a parameter of update_prop. + +However, update_prop of weston_view of a ivi_surface can not be done +even if it is set on a screen. The propoerty change shall be done only +when a visibility of ivi_surface or ivi_layer which contains the +ivi_surface is ON. Such a condition shall be checked at commit_changes +as well to avoid calling update_prop, which actually updates +weston_views. + +Signed-off-by: Nobuhiko Tanibata <nobuhiko_tanibata@xddp.denso.co.jp> +Reviewed-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk> +--- + ivi-shell/ivi-layout.c | 23 +++++++++++++++++++---- + 1 file changed, 19 insertions(+), 4 deletions(-) + +diff --git a/ivi-shell/ivi-layout.c b/ivi-shell/ivi-layout.c +index c8ea270..9dbebb3 100644 +--- a/ivi-shell/ivi-layout.c ++++ b/ivi-shell/ivi-layout.c +@@ -763,16 +763,17 @@ calc_surface_to_global_matrix_and_mask_to_weston_surface( + } + + static void +-update_prop(struct ivi_layout_layer *ivilayer, ++update_prop(struct ivi_layout_screen *iviscrn, ++ struct ivi_layout_layer *ivilayer, + struct ivi_layout_surface *ivisurf) + { + struct weston_view *tmpview; + struct ivi_rectangle r; + bool can_calc = true; + +- if (!ivilayer->event_mask && !ivisurf->event_mask) { ++ /*In case of no prop change, this just returns*/ ++ if (!ivilayer->event_mask && !ivisurf->event_mask) + return; +- } + + update_opacity(ivilayer, ivisurf); + +@@ -828,8 +829,22 @@ commit_changes(struct ivi_layout *layout) + + wl_list_for_each(iviscrn, &layout->screen_list, link) { + wl_list_for_each(ivilayer, &iviscrn->order.layer_list, order.link) { ++ /* ++ * If ivilayer is invisible, weston_view of ivisurf doesn't ++ * need to be modified. ++ */ ++ if (ivilayer->prop.visibility == false) ++ continue; ++ + wl_list_for_each(ivisurf, &ivilayer->order.surface_list, order.link) { +- update_prop(ivilayer, ivisurf); ++ /* ++ * If ivilayer is invisible, weston_view of ivisurf doesn't ++ * need to be modified. ++ */ ++ if (ivisurf->prop.visibility == false) ++ continue; ++ ++ update_prop(iviscrn, ivilayer, ivisurf); + } + } + } +-- +2.4.5 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0004-Weston1.9.0-Fix-touch-screen-crash-issue.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0004-Weston1.9.0-Fix-touch-screen-crash-issue.patch new file mode 100644 index 000000000..c221d1c5e --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0004-Weston1.9.0-Fix-touch-screen-crash-issue.patch @@ -0,0 +1,37 @@ +From 9a7c0e7b6ae9700069756b33d2ea726e58b552ed Mon Sep 17 00:00:00 2001 +From: Eric Ruei <e-ruei1@ti.com> +Date: Wed, 16 Mar 2016 16:50:31 -0400 +Subject: [PATCH 4/4] Weston1.9.0: Fix touch screen crash issue + +Touch screen operation causes the weston to crash with segment fault sometimes. +The crash occurs when the coordinate (x,y) passed to the weston input module +is outside the view window, hence the weston compositor is not able to pick +up a display view and there is no code to detect this condition at function +notify_touch(). + + +Signed-off-by: Eric Ruei <e-ruei1@ti.com> +--- + src/input.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +diff --git a/src/input.c b/src/input.c +index e230c83..fd8e53f 100644 +--- a/src/input.c ++++ b/src/input.c +@@ -1566,6 +1566,12 @@ notify_touch(struct weston_seat *seat, uint32_t time, int touch_id, + * until all touch points are up again. */ + if (touch->num_tp == 1) { + ev = weston_compositor_pick_view(ec, x, y, &sx, &sy); ++ if (!ev) ++ { ++ weston_log("notify_touch: weston_compositor_pick_view(%d, %d) failed to find a view!\n", ++ wl_fixed_to_int(x), wl_fixed_to_int(y)); ++ return; ++ } + weston_touch_set_focus(touch, ev); + } else if (!touch->focus) { + /* Unexpected condition: We have non-initial touch but +-- +1.9.1 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0004-ivi-shell-fix-layout_layer.view_list-is-not-initiliz.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0004-ivi-shell-fix-layout_layer.view_list-is-not-initiliz.patch new file mode 100644 index 000000000..ea5ef0024 --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0004-ivi-shell-fix-layout_layer.view_list-is-not-initiliz.patch @@ -0,0 +1,44 @@ +From 2a07b287851c974d684aa152486a63062aadd219 Mon Sep 17 00:00:00 2001 +From: Nobuhiko Tanibata <NOBUHIKO_TANIBATA@xddp.denso.co.jp> +Date: Wed, 25 Nov 2015 23:36:57 +0900 +Subject: [PATCH 4/7] ivi-shell: fix layout_layer.view_list is not initilized + per a screen. + +This is potential bug when it supports several screens. If view_list is +initilized here, the views, which are set by the previous screen, are +cleared. So View list shall be initilized in front of wl_list_for_each +of all screens. + +Signed-off-by: Nobuhiko Tanibata <NOBUHIKO_TANIBATA@xddp.denso.co.jp> +Reviewed-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk> +--- + ivi-shell/ivi-layout.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +diff --git a/ivi-shell/ivi-layout.c b/ivi-shell/ivi-layout.c +index 9dbebb3..a7c5e22 100644 +--- a/ivi-shell/ivi-layout.c ++++ b/ivi-shell/ivi-layout.c +@@ -1000,6 +1000,9 @@ commit_screen_list(struct ivi_layout *layout) + struct ivi_layout_layer *ivilayer = NULL; + struct ivi_layout_layer *next = NULL; + struct ivi_layout_surface *ivisurf = NULL; ++ ++ /* Clear view list of layout ivi_layer */ ++ wl_list_init(&layout->layout_layer.view_list.link); + + wl_list_for_each(iviscrn, &layout->screen_list, link) { + if (iviscrn->order.dirty) { +@@ -1024,9 +1027,6 @@ commit_screen_list(struct ivi_layout *layout) + iviscrn->order.dirty = 0; + } + +- /* Clear view list of layout ivi_layer */ +- wl_list_init(&layout->layout_layer.view_list.link); +- + wl_list_for_each(ivilayer, &iviscrn->order.layer_list, order.link) { + if (ivilayer->prop.visibility == false) + continue; +-- +2.4.5 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0005-ivi-shell-convert-from-screen-to-global-coordinates.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0005-ivi-shell-convert-from-screen-to-global-coordinates.patch new file mode 100644 index 000000000..f22af13e6 --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0005-ivi-shell-convert-from-screen-to-global-coordinates.patch @@ -0,0 +1,70 @@ +From 26c4fc86516626e2e463171e4016ccd851125342 Mon Sep 17 00:00:00 2001 +From: Nobuhiko Tanibata <nobuhiko_tanibata@xddp.denso.co.jp> +Date: Wed, 9 Dec 2015 15:38:41 +0900 +Subject: [PATCH 5/7] ivi-shell: convert from screen to global coordinates + +In single screen, the coordinates of layer local coordinates are the +same as global coordinates. However, to support multi screens, the +layer-local coordinates shall be transformed to multi screen coordinates, +which is global coordinates. The abosolute coordinates of a screen in global +stored in (x,y) of output of its weston output so it shall be used to +transform layer-local to global coordinates. + +Signed-off-by: Nobuhiko Tanibata <nobuhiko_tanibata@xddp.denso.co.jp> +Reviewed-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk> +--- + ivi-shell/ivi-layout.c | 10 ++++++++-- + 1 file changed, 8 insertions(+), 2 deletions(-) + +diff --git a/ivi-shell/ivi-layout.c b/ivi-shell/ivi-layout.c +index a7c5e22..c7506de 100644 +--- a/ivi-shell/ivi-layout.c ++++ b/ivi-shell/ivi-layout.c +@@ -688,6 +688,7 @@ calc_inverse_matrix_transform(const struct weston_matrix *matrix, + */ + static void + calc_surface_to_global_matrix_and_mask_to_weston_surface( ++ struct ivi_layout_screen *iviscrn, + struct ivi_layout_layer *ivilayer, + struct ivi_layout_surface *ivisurf, + struct weston_matrix *m, +@@ -695,6 +696,7 @@ calc_surface_to_global_matrix_and_mask_to_weston_surface( + { + const struct ivi_layout_surface_properties *sp = &ivisurf->prop; + const struct ivi_layout_layer_properties *lp = &ivilayer->prop; ++ struct weston_output *output = iviscrn->output; + struct ivi_rectangle weston_surface_rect = { 0, + 0, + ivisurf->surface->width, +@@ -732,7 +734,9 @@ calc_surface_to_global_matrix_and_mask_to_weston_surface( + * coordinates to global coordinates, which is computed by + * two steps, + * - surface-local coordinates to layer-local coordinates +- * - layer-local coordinates to global coordinates ++ * - layer-local coordinates to a single screen-local coordinates ++ * - a single screen-local coordinates to multi screen coordinates, ++ * which is global coordinates. + */ + calc_transformation_matrix(&surface_source_rect, + &surface_dest_rect, +@@ -742,6 +746,8 @@ calc_surface_to_global_matrix_and_mask_to_weston_surface( + &layer_dest_rect, + lp->orientation, m); + ++ weston_matrix_translate(m, output->x, output->y, 0.0f); ++ + /* this intersected ivi_rectangle would be used for masking + * weston_surface + */ +@@ -798,7 +804,7 @@ update_prop(struct ivi_layout_screen *iviscrn, + weston_matrix_init(&ivisurf->transform.matrix); + + calc_surface_to_global_matrix_and_mask_to_weston_surface( +- ivilayer, ivisurf, &ivisurf->transform.matrix, &r); ++ iviscrn, ivilayer, ivisurf, &ivisurf->transform.matrix, &r); + + if (tmpview != NULL) { + weston_view_set_mask(tmpview, r.x, r.y, r.width, r.height); +-- +2.4.5 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0006-ivi-shell-remove-a-code-which-expects-only-a-screen-.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0006-ivi-shell-remove-a-code-which-expects-only-a-screen-.patch new file mode 100644 index 000000000..e0f5de37d --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0006-ivi-shell-remove-a-code-which-expects-only-a-screen-.patch @@ -0,0 +1,30 @@ +From ba9399549000bf581c5b309dd7a26ee818159d70 Mon Sep 17 00:00:00 2001 +From: Nobuhiko Tanibata <NOBUHIKO_TANIBATA@xddp.denso.co.jp> +Date: Wed, 25 Nov 2015 23:37:09 +0900 +Subject: [PATCH 6/7] ivi-shell: remove a code which expects only a screen in + the system. + +It breaks from wl_list_for_each of screens when the frist screen found. + +Signed-off-by: Nobuhiko Tanibata <NOBUHIKO_TANIBATA@xddp.denso.co.jp> +Reviewed-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk> +--- + ivi-shell/ivi-layout.c | 2 -- + 1 file changed, 2 deletions(-) + +diff --git a/ivi-shell/ivi-layout.c b/ivi-shell/ivi-layout.c +index c7506de..85cb457 100644 +--- a/ivi-shell/ivi-layout.c ++++ b/ivi-shell/ivi-layout.c +@@ -1056,8 +1056,6 @@ commit_screen_list(struct ivi_layout *layout) + ivisurf->surface->output = iviscrn->output; + } + } +- +- break; + } + } + +-- +2.4.5 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0007-ivi-shell-layout-Export-surface-destroy-callback.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0007-ivi-shell-layout-Export-surface-destroy-callback.patch new file mode 100644 index 000000000..1fe7cf5aa --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0007-ivi-shell-layout-Export-surface-destroy-callback.patch @@ -0,0 +1,60 @@ +From 9f47b84c94c71ef8bb1459c4c2b2759343432558 Mon Sep 17 00:00:00 2001 +From: Volodymyr Riazantsev <volodymyr.riazantsev@globallogic.com> +Date: Fri, 1 Jul 2016 22:38:43 -0400 +Subject: [PATCH 7/8] ivi-shell: layout: Export surface destroy callback + +[HACK] +Some applications still using regular shell interface and +thereby must be handled through weston native notifications. + +Only one and single notification callback accepted and it can be +in external module. + +So we need to export call back for remove surface inside layout +controlled. + +This is a obvious hack. + +Signed-off-by: Volodymyr Riazantsev <volodymyr.riazantsev@globallogic.com> +Signed-off-by: Karthik Ramanan <a0393906@ti.com> +--- + ivi-shell/ivi-layout-export.h | 7 +++++++ + ivi-shell/ivi-layout.c | 4 +++- + 2 files changed, 10 insertions(+), 1 deletion(-) + +diff --git a/ivi-shell/ivi-layout-export.h b/ivi-shell/ivi-layout-export.h +index 7f93c82..f5ea54e 100644 +--- a/ivi-shell/ivi-layout-export.h ++++ b/ivi-shell/ivi-layout-export.h +@@ -823,6 +823,13 @@ struct ivi_controller_interface { + * \return id of ivi_screen + */ + uint32_t (*get_id_of_screen)(struct ivi_layout_screen *iviscrn); ++ ++ /** ++ * \brief HACK. Destroy surface. ++ * ++ */ ++ void (*surface_destroy)(struct ivi_layout_surface *ivisurf); ++ + }; + + #ifdef __cplusplus +diff --git a/ivi-shell/ivi-layout.c b/ivi-shell/ivi-layout.c +index 85cb457..7d2daa1 100644 +--- a/ivi-shell/ivi-layout.c ++++ b/ivi-shell/ivi-layout.c +@@ -3016,7 +3016,9 @@ static struct ivi_controller_interface ivi_controller_interface = { + /** + * screen controller interfaces part2 + */ +- .get_id_of_screen = ivi_layout_get_id_of_screen ++ .get_id_of_screen = ivi_layout_get_id_of_screen, ++ ++ .surface_destroy = ivi_layout_surface_destroy + }; + + int +-- +2.4.5 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0008-ivi-shell-Add-simple-IVI-shell-layout-controller.patch b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0008-ivi-shell-Add-simple-IVI-shell-layout-controller.patch new file mode 100644 index 000000000..4e63c7a0b --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/0008-ivi-shell-Add-simple-IVI-shell-layout-controller.patch @@ -0,0 +1,589 @@ +From c89c2d63db3cbe83fb1ddd983e4b0ffe87fab296 Mon Sep 17 00:00:00 2001 +From: Volodymyr Riazantsev <volodymyr.riazantsev@globallogic.com> +Date: Fri, 1 Jul 2016 00:28:50 -0400 +Subject: [PATCH 8/8] ivi-shell: Add simple IVI shell layout controller + +Simple IVI shell layout controller. +Assign only one application to primary display. +Second and rest application will go to secondary display if it's +present. + +Signed-off-by: Volodymyr Riazantsev <volodymyr.riazantsev@globallogic.com> +Signed-off-by: Karthik Ramanan <a0393906@ti.com> +--- + Makefile.am | 12 +- + ivi-shell/ivi-layout-controller-ti.c | 532 +++++++++++++++++++++++++++++++++++ + 2 files changed, 543 insertions(+), 1 deletion(-) + create mode 100644 ivi-shell/ivi-layout-controller-ti.c + +diff --git a/Makefile.am b/Makefile.am +index 55aed6d..a9fe3c8 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -868,7 +868,8 @@ if ENABLE_IVI_SHELL + + module_LTLIBRARIES += \ + $(ivi_shell) \ +- $(hmi_controller) ++ $(hmi_controller) \ ++ $(layout_controller) + + ivi_shell = ivi-shell.la + ivi_shell_la_LDFLAGS = -module -avoid-version +@@ -903,6 +904,15 @@ nodist_hmi_controller_la_SOURCES = \ + + BUILT_SOURCES += $(nodist_hmi_controller_la_SOURCES) + ++layout_controller = layout-controller.la ++layout_controller_la_LDFLAGS = -module -avoid-version ++layout_controller_la_LIBADD = $(COMPOSITOR_LIBS) libshared.la ++layout_controller_la_CFLAGS = $(AM_CFLAGS) $(COMPOSITOR_CFLAGS) ++layout_controller_la_SOURCES = \ ++ ivi-shell/ivi-layout-export.h \ ++ ivi-shell/ivi-layout-controller-ti.c \ ++ shared/helpers.h ++ + endif + + +diff --git a/ivi-shell/ivi-layout-controller-ti.c b/ivi-shell/ivi-layout-controller-ti.c +new file mode 100644 +index 0000000..b7cf436 +--- /dev/null ++++ b/ivi-shell/ivi-layout-controller-ti.c +@@ -0,0 +1,532 @@ ++/* ++ * Copyright (C) 2016 GlobalLogic Inc ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining ++ * a copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sublicense, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial ++ * portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS ++ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ++ * SOFTWARE. ++ */ ++ ++#include <stdlib.h> ++#include <string.h> ++#include <assert.h> ++ ++#include "ivi-layout-export.h" ++ ++#ifndef container_of ++#define container_of(ptr, type, member) ({ \ ++ const __typeof__( ((type *)0)->member ) *__mptr = (ptr); \ ++ (type *)( (char *)__mptr - offsetof(type,member) );}) ++#endif ++ ++#ifndef BIT ++#define BIT(bit) (1 << (bit)) ++#endif ++ ++#define __MODULE__ "layout-controller" ++#define DL_ERR BIT(0) ++#define DL_WRN BIT(1) ++#define DL_DBG BIT(2) ++#define DL_ALL (~0) ++ ++static unsigned debug_level = DL_ALL; ++ ++#define __print_log(__dl__, ... ) \ ++if (__dl__ & debug_level) \ ++ fprintf(__dl__ == DL_ERR ? stderr : stdout," ["__MODULE__"]:" __VA_ARGS__); ++ ++#define pr_err(...) __print_log(DL_ERR, "E: " __VA_ARGS__) ++#define pr_dbg(...) __print_log(DL_DBG, "D: " __VA_ARGS__) ++#define pr_wrn(...) __print_log(DL_WRN, "W: " __VA_ARGS__) ++#define TRACE() __print_log(DL_DBG, "TR: %s - %d\n", __func__, __LINE__) ++ ++ ++#define WINDOWS_TITLE_HEIGHT 30 ++#define DEFAULT_SURFACE_ID_FOR_WL_SHELL_APP 0x80000000 ++ ++/***************************************************************************** ++ * structure, globals ++ ****************************************************************************/ ++struct hmi_controller_layer { ++ struct ivi_layout_layer *ivilayer; ++ uint32_t id_layer; ++ int32_t x; ++ int32_t y; ++ int32_t width; ++ int32_t height; ++ int32_t num_surfaces; ++ pid_t pid; ++ struct wl_list link; ++ struct wl_list screen_link; ++ struct wl_list surfaces_list; ++}; ++ ++struct hmi_controller_surface { ++ void *controller; ++ void *ivisurf; ++ struct wl_list link; ++ struct wl_listener destroy_listener; ++}; ++ ++struct hmi_controller_screen { ++ struct ivi_layout_screen *iviscrn; ++ struct wl_list layers_list; ++}; ++ ++struct hmi_server_setting { ++ uint32_t base_layer_id; ++ int32_t panel_height; ++ char *ivi_homescreen; ++}; ++ ++struct hmi_controller { ++ int32_t current_layer; ++ int32_t current_screen; ++ int32_t screens_count; ++ int32_t workspace_count; ++ ++ struct hmi_server_setting *hmi_setting; ++ struct hmi_controller_screen screens[4]; ++ struct hmi_controller_layer application_layer; ++ struct weston_compositor *compositor; ++ struct wl_listener destroy_listener; ++ struct wl_client *user_interface; ++ struct wl_list layers_list; ++}; ++ ++const struct ivi_controller_interface *ivi_controller_interface; ++ ++static void ++hmi_ctrl_surface_destroy(struct wl_listener *listener, void *data); ++ ++int ++controller_module_init(struct weston_compositor *ec, ++ int *argc, char *argv[], ++ const struct ivi_controller_interface *interface, ++ size_t interface_version); ++ ++/***************************************************************************** ++ * local functions ++ ****************************************************************************/ ++static void * ++fail_on_null(void *p, size_t size, char *file, int32_t line) ++{ ++ if (size && !p) { ++ weston_log("%s(%d) %zd: out of memory\n", file, line, size); ++ exit(EXIT_FAILURE); ++ } ++ ++ return p; ++} ++ ++static void * ++mem_alloc(size_t size, char *file, int32_t line) ++{ ++ return fail_on_null(calloc(1, size), size, file, line); ++} ++ ++#define MEM_ALLOC(s) mem_alloc((s),__FILE__,__LINE__) ++ ++/** ++ * Internal method to create ivi_layer with hmi_controller_layer and ++ * add to a ivi_screen ++ */ ++static void ++create_layer(struct ivi_layout_screen *iviscrn, ++ struct hmi_controller_layer *layer) ++{ ++ int32_t ret = 0; ++ ++ layer->ivilayer = ++ ivi_controller_interface->layer_create_with_dimension(layer->id_layer, ++ layer->width, ++ layer->height); ++ assert(layer->ivilayer != NULL); ++ ++ ret = ivi_controller_interface->screen_add_layer(iviscrn, layer->ivilayer); ++ ++ assert(!ret); ++ ++ ret = ivi_controller_interface->layer_set_destination_rectangle(layer->ivilayer, ++ layer->x, layer->y, ++ layer->width, ++ layer->height); ++ assert(!ret); ++ ++ ret = ivi_controller_interface->layer_set_visibility(layer->ivilayer, true); ++ ++ assert(!ret); ++ ++ ivi_controller_interface->commit_changes(); ++ ++} ++ ++static struct hmi_controller_layer ++*get_layer_for_surface(struct hmi_controller *hmi_ctrl ++ , struct ivi_layout_surface *ivisurf ++ , bool create) ++{ ++ struct hmi_controller_layer *layer; ++ struct weston_surface *surface; ++ int32_t i = 0; ++ struct wl_client *client; ++ struct ivi_layout_screen *iviscrn = NULL; ++ struct weston_output *output = NULL; ++ pid_t pid; ++ uid_t uid; ++ gid_t gid; ++ ++ surface = ivi_controller_interface->surface_get_weston_surface(ivisurf); ++ ++ if (!surface) ++ goto exit; ++ ++ client = wl_resource_get_client(surface->resource); ++ ++ wl_client_get_credentials(client, &pid, &uid, &gid); ++ ++ wl_list_for_each(layer, &hmi_ctrl->layers_list, link) { ++ if (layer->pid == pid) { ++ pr_dbg("Existed layer for PID=%d was found\n", pid); ++ return layer; ++ } ++ } ++ ++ if (!(create && hmi_ctrl->screens_count)) ++ goto exit; ++ ++ pr_dbg("Existed layer for PID=%d was not found. Creating new\n", pid); ++ ++ for(;; i++) { ++ if (wl_list_empty(&hmi_ctrl->screens[i].layers_list) || ++ (i == (hmi_ctrl->screens_count - 1))) ++ break; ++ }; ++ ++ iviscrn = hmi_ctrl->screens[i].iviscrn; ++ ++ layer = calloc(1, sizeof *layer); ++ ++ output = ivi_controller_interface->screen_get_output(iviscrn); ++ ++ wl_list_init(&layer->link); ++ wl_list_init(&layer->screen_link); ++ wl_list_init(&layer->surfaces_list); ++ ++ layer->width = output->width; ++ layer->height = output->height + WINDOWS_TITLE_HEIGHT; ++ layer->id_layer = hmi_ctrl->hmi_setting->base_layer_id++; ++ layer->pid = pid; ++ ++ create_layer(iviscrn, layer); ++ ++ wl_list_insert(&hmi_ctrl->layers_list, &layer->link); ++ wl_list_insert(&hmi_ctrl->screens[i].layers_list, &layer->screen_link); ++ ++ return layer; ++ ++exit: ++ return NULL; ++} ++ ++static void ++set_notification_create_surface(struct ivi_layout_surface *ivisurf, ++ void *userdata) ++{ ++ struct hmi_controller *hmi_ctrl = userdata; ++ struct hmi_controller_layer *hmi_ctrl_layer = NULL; ++ struct hmi_controller_surface *hmi_ctrl_surf = NULL; ++ struct ivi_layout_layer *dest_layer; ++ struct weston_surface *surface; ++ ++ wl_list_for_each(hmi_ctrl_layer, &hmi_ctrl->layers_list, link) { ++ wl_list_for_each(hmi_ctrl_surf, &hmi_ctrl_layer->surfaces_list, link) { ++ if (hmi_ctrl_surf->ivisurf == ivisurf) { ++ pr_dbg("Surface was already configured. Skip add to list\n"); ++ return; ++ } ++ } ++ } ++ ++ pr_dbg("Surface create: add to list and get the layer\n"); ++ ++ hmi_ctrl_layer = get_layer_for_surface(hmi_ctrl, ivisurf, true); ++ dest_layer = hmi_ctrl_layer->ivilayer; ++ ++ ivi_controller_interface->layer_add_surface(dest_layer, ivisurf); ++ ++ hmi_ctrl_surf = calloc(1, sizeof(*hmi_ctrl_surf)); ++ hmi_ctrl_surf->ivisurf = ivisurf; ++ wl_list_init(&hmi_ctrl_surf->link); ++ wl_list_insert(&hmi_ctrl_layer->surfaces_list, &hmi_ctrl_surf->link); ++ ++ ++ /* ++ * Set destroy signal for surface ++ * HACK: We trying to track surfaces were created by wl_shell_emulator ++ */ ++ if (ivi_controller_interface->get_id_of_surface(ivisurf) >= ++ DEFAULT_SURFACE_ID_FOR_WL_SHELL_APP) { ++ surface = ivi_controller_interface->surface_get_weston_surface(ivisurf); ++ hmi_ctrl_surf->destroy_listener.notify = hmi_ctrl_surface_destroy; ++ wl_signal_add(&surface->destroy_signal, &hmi_ctrl_surf->destroy_listener); ++ hmi_ctrl_surf->controller = userdata; ++ } ++} ++ ++static void ++set_notification_remove_surface(struct ivi_layout_surface *ivisurf, ++ void *userdata) ++{ ++ struct hmi_controller *hmi_ctrl = userdata; ++ struct hmi_controller_layer *hmi_ctrl_layer = NULL; ++ struct hmi_controller_surface *surf = NULL; ++ struct ivi_layout_layer *dest_layer; ++ ++ wl_list_for_each(hmi_ctrl_layer, &hmi_ctrl->layers_list, link) { ++ wl_list_for_each(surf, &hmi_ctrl_layer->surfaces_list, link) { ++ if (surf->ivisurf == ivisurf) { ++ pr_dbg("Surface remove: surface was found\n"); ++ goto remove; ++ } ++ } ++ } ++ ++ goto exit; ++ ++remove: ++ dest_layer = hmi_ctrl_layer->ivilayer; ++ ++ wl_list_remove(&surf->link); ++ ++ ivi_controller_interface->layer_remove_surface(dest_layer, ivisurf); ++ ++ if (wl_list_empty(&hmi_ctrl_layer->surfaces_list)) { ++ wl_list_remove(&hmi_ctrl_layer->link); ++ wl_list_remove(&hmi_ctrl_layer->screen_link); ++ ivi_controller_interface->layer_destroy(dest_layer); ++ free(hmi_ctrl_layer); ++ } ++ ++ free(surf); ++ ++exit: ++ ivi_controller_interface->commit_changes(); ++} ++ ++static void ++hmi_ctrl_surface_destroy(struct wl_listener *listener, void *data) ++{ ++ struct hmi_controller_surface *hmi_ctrl_surface = ++ container_of(listener, struct hmi_controller_surface, ++ destroy_listener); ++ ++ pr_dbg("Try to remove surface by direct notification\n"); ++ ++ ivi_controller_interface->surface_destroy(hmi_ctrl_surface->ivisurf); ++} ++ ++static void ++set_notification_configure_surface(struct ivi_layout_surface *ivisurf, ++ void *userdata) ++{ ++ struct hmi_controller *hmi_ctrl = userdata; ++ struct hmi_controller_layer *hmi_ctrl_layer = NULL; ++ struct weston_surface *surface; ++ struct hmi_controller_surface *hmi_ctrl_surf = NULL; ++ ++ wl_list_for_each(hmi_ctrl_layer, &hmi_ctrl->layers_list, link) { ++ wl_list_for_each(hmi_ctrl_surf, &hmi_ctrl_layer->surfaces_list, link) { ++ if (hmi_ctrl_surf->ivisurf == ivisurf) { ++ pr_dbg("Surface was already configured. Skip add to list\n"); ++ goto found; ++ } ++ } ++ } ++ ++ hmi_ctrl_layer = NULL; ++found: ++ surface = ivi_controller_interface->surface_get_weston_surface(ivisurf); ++ ++ if (surface) { ++ ++ ivi_controller_interface->surface_set_source_rectangle( ++ ivisurf, 0, WINDOWS_TITLE_HEIGHT, surface->width, ++ surface->height); ++ ++#if 0 ++ ivi_controller_interface->surface_set_destination_rectangle( ++ ivisurf, 0, 0, surface->width, surface->height); ++#else ++ if (hmi_ctrl_layer) { ++ ivi_controller_interface->surface_set_destination_rectangle( ++ ivisurf, 0, 0, hmi_ctrl_layer->width, hmi_ctrl_layer->height); ++ } else { ++ ivi_controller_interface->surface_set_destination_rectangle( ++ ivisurf, 0, 0, surface->width, surface->height); ++ } ++#endif ++ ivi_controller_interface->surface_set_visibility(ivisurf, true); ++ ivi_controller_interface->commit_changes(); ++ } ++} ++ ++static struct hmi_server_setting * ++hmi_server_setting_create(struct weston_compositor *ec) ++{ ++ struct hmi_server_setting *setting = MEM_ALLOC(sizeof(*setting)); ++ struct weston_config *config = ec->config; ++ struct weston_config_section *shell_section = NULL; ++ ++ shell_section = weston_config_get_section(config, "ivi-shell", ++ NULL, NULL); ++ ++ weston_config_section_get_uint(shell_section, "base-layer-id", ++ &setting->base_layer_id, 1000); ++ ++ setting->panel_height = 30; ++ ++ return setting; ++} ++ ++static void ++hmi_controller_destroy(struct wl_listener *listener, void *data) ++{ ++ struct hmi_controller *hmi_ctrl = ++ container_of(listener, struct hmi_controller, destroy_listener); ++ ++ free(hmi_ctrl->hmi_setting); ++ free(hmi_ctrl); ++} ++ ++static struct hmi_controller * ++hmi_controller_create(struct weston_compositor *ec) ++{ ++ struct ivi_layout_screen **pp_screen = NULL; ++ struct ivi_layout_screen *iviscrn = NULL; ++ int32_t screen_length = 0; ++ struct hmi_controller *hmi_ctrl = MEM_ALLOC(sizeof(*hmi_ctrl)); ++ int i, j = 0; ++ ++ hmi_ctrl->hmi_setting = hmi_server_setting_create(ec); ++ hmi_ctrl->compositor = ec; ++ ++ ivi_controller_interface->get_screens(&screen_length, &pp_screen); ++ ++ for (i = screen_length; i-- ; j++) { ++ ++ iviscrn = pp_screen[i]; ++ hmi_ctrl->screens[j].iviscrn = iviscrn; ++ wl_list_init(&hmi_ctrl->screens[i].layers_list); ++ ++ hmi_ctrl->screens_count++; ++ } ++ ++ ivi_controller_interface->add_notification_create_surface( ++ set_notification_create_surface, hmi_ctrl); ++ ivi_controller_interface->add_notification_remove_surface( ++ set_notification_remove_surface, hmi_ctrl); ++ ivi_controller_interface->add_notification_configure_surface( ++ set_notification_configure_surface, hmi_ctrl); ++ ++ hmi_ctrl->destroy_listener.notify = hmi_controller_destroy; ++ wl_signal_add(&hmi_ctrl->compositor->destroy_signal, ++ &hmi_ctrl->destroy_listener); ++ ++ wl_list_init(&hmi_ctrl->layers_list); ++ ++ free(pp_screen); ++ pp_screen = NULL; ++ ++ return hmi_ctrl; ++} ++ ++WL_EXPORT const struct wl_interface ivi_hmi_controller_interface = { ++ "ivi_layout_controller", 1, ++ 0, NULL, ++ 0, NULL, ++}; ++ ++static void ++bind_hmi_controller(struct wl_client *client, ++ void *data, uint32_t version, uint32_t id) ++{ ++ struct hmi_controller *hmi_ctrl = data; ++ ++ if (hmi_ctrl->user_interface != client) { ++ struct wl_resource *res = wl_client_get_object(client, 1); ++ wl_resource_post_error(res, ++ WL_DISPLAY_ERROR_INVALID_OBJECT, ++ "hmi-controller failed: permission denied"); ++ return; ++ } ++ ++ wl_resource_create(client, &ivi_hmi_controller_interface, 1, id); ++} ++ ++static int32_t ++initialize(struct hmi_controller *hmi_ctrl) ++{ ++ struct config_command { ++ char *key; ++ uint32_t *dest; ++ }; ++ ++ struct weston_config *config = hmi_ctrl->compositor->config; ++ ++ weston_config_get_section(config, "ivi-shell", NULL, NULL); ++ ++ return 1; ++} ++ ++/***************************************************************************** ++ * exported functions ++ ****************************************************************************/ ++WL_EXPORT int ++controller_module_init(struct weston_compositor *ec, ++ int *argc, char *argv[], ++ const struct ivi_controller_interface *interface, ++ size_t interface_version) ++{ ++ struct hmi_controller *hmi_ctrl = NULL; ++ ++ ++ if (interface_version < sizeof(struct ivi_controller_interface)) { ++ weston_log("ivi-layout-controller-ti: version mismatch of controller interface"); ++ return -1; ++ } ++ ++ ivi_controller_interface = interface; ++ ++ hmi_ctrl = hmi_controller_create(ec); ++ ++ if (!initialize(hmi_ctrl)) { ++ return -1; ++ } ++ ++ if (wl_global_create(ec->wl_display, ++ &ivi_hmi_controller_interface, 1, ++ hmi_ctrl, bind_hmi_controller) == NULL) { ++ return -1; ++ } ++ ++ weston_log("ivi-layout-controller-ti: Successfully started."); ++ ++ return 0; ++} +-- +2.4.5 + diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/dra7xx-evm/weston.ini b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/dra7xx-evm/weston.ini new file mode 100644 index 000000000..b5aa624d1 --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/dra7xx-evm/weston.ini @@ -0,0 +1,59 @@ +[core] +shell=ivi-shell.so + +[ivi-shell] +ivi-module=layout-controller.so,wl-shell-emulator.so + +[ivi-autolaunch] +path=/usr/AGL/CES2017/start_demo.sh + +#[ivi-layout-rule] +## Application name +#application=some_app +## mode:0 - native size, 1 - full screen +#mode=1 +## order:0 - always on top +#order=0 +## screen id +#screen=2 +## src_rect ignored +#src_rect=1,2,3,4 +## destination +#dest_rect=5,6,7,8 +## borders to crop (left,top,righ,bot) +#crop_rect=9,10,11,12 +## ignored +#focus_on=1 + +[ivi-layout-rule] +application=qmlscene +screen=0 +mode=1 +crop_rect=5,30,10,10 + +[ivi-layout-rule] +application=soc-performance-monitor +screen=1 +mode=0 +dest_rect=0,0,-1,-1 + +[ivi-layout-rule] +application=navi +screen=0 +mode=0 +dest_rect=20,90,760,1100 + +[ivi-layout-rule] +application=soc-ddr-bw-visualizer +screen=1 +mode=0 +dest_rect=400,0,-1,-1 + +[ivi-layout-rule] +application=gst-launch-1.0 +screen=1 +mode=1 + +[output] +name=Unknown-1 +transform=90 diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/weston.service b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/weston.service new file mode 100644 index 000000000..cec707d56 --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston/weston.service @@ -0,0 +1,13 @@ +[Unit] +Description=Weston reference Wayland compositor +Conflicts=getty@tty1.service +After=dbus.service rc.pvr.service + +[Service] +ExecStart=/usr/bin/weston-launch -u root -- --backend=drm-backend.so --idle-time=4294967 --config=/etc/xdg/weston/weston.ini +ExecStop=/usr/bin/killall -s KILL weston +Restart=always +Type=simple + +[Install] +WantedBy=multi-user.target diff --git a/meta-agl-bsp/meta-ti/recipes-arago/weston/weston_1.9.0.bbappend b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston_1.9.0.bbappend new file mode 100644 index 000000000..3c35ad821 --- /dev/null +++ b/meta-agl-bsp/meta-ti/recipes-arago/weston/weston_1.9.0.bbappend @@ -0,0 +1,35 @@ +#inherit append-code-change +# When configured for fbdev compositor, make it the default +PACKAGECONFIG[fbdev] = "--enable-fbdev-compositor WESTON_NATIVE_BACKEND="fbdev-backend.so",--disable-fbdev-compositor,udev mtdev" +PACKAGECONFIG[kms] = "--enable-drm-compositor,--disable-drm-compositor,drm udev libgbm mtdev" + +PR_append = ".agl_arago_16" + +FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:" + +RDEPENDS_${PN} += "weston-conf" + +SRC_URI += " \ + file://0001-weston1.9.0-Enabling-DRM-backend-with-multiple-displ.patch \ + file://0002-Weston1.9.0-Allow-visual_id-to-be-0.patch \ + file://0003-Weston1.9.0-Fix-virtual-keyboard-display-issue-for-Q.patch \ + file://0004-Weston1.9.0-Fix-touch-screen-crash-issue.patch \ + file://0001-udev-seat-restrict-udev-enumeration-to-card0.patch \ + file://0001-Add-soc-performance-monitor-utilites.patch \ +" + +RDEPENDS_${PN}_remove = "weston-conf" + +SRC_URI += " \ + file://0001-ivi-shell-fix-TODO-which-expects-only-one-screen-in-.patch \ + file://0002-ivi-shell-multi-screen-support-to-calcuration-of-a-m.patch \ + file://0003-ivi-shell-avoid-update_prop-on-invisible-surfaces.patch \ + file://0004-ivi-shell-fix-layout_layer.view_list-is-not-initiliz.patch \ + file://0005-ivi-shell-convert-from-screen-to-global-coordinates.patch \ + file://0006-ivi-shell-remove-a-code-which-expects-only-a-screen-.patch \ + file://0007-ivi-shell-layout-Export-surface-destroy-callback.patch \ + file://0008-ivi-shell-Add-simple-IVI-shell-layout-controller.patch \ + file://0001-ivi-shell-Add-autolaunch-and-launch-rules-functional.patch \ + file://0001-ivi-shell-layer-controller-ti-Improve-functionality.patch \ + file://0001-ivi-shell-Add-screenshooter-option.patch \ + " |