5 * This work is licensed under the terms of 3-clause BSD license.
6 * See COPYING file in the top-level directory.
14 #include <sys/types.h>
17 #include <sys/ioctl.h>
22 #include <sys/socket.h>
27 #include <linux/omapfb.h>
31 #define SCREEN_WIDTH 800
32 #define SCREEN_HEIGHT 480
35 #define MEM_SIZE (((WIDTH * HEIGHT * 2 * 2) + 0xfff) & ~0xfff)
38 static struct fb_var_screeninfo g_vi;
39 static uint16_t *g_screen_base, *g_screen;
40 static unsigned int g_old_mem;
42 static int g_exit, g_hide;
43 static pthread_cond_t g_cond;
45 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
46 #define IS_START(buf, str) \
47 !strncmp(buf, str, sizeof(str) - 1)
49 static void clear_bytes(void *mem, int bytes);
51 static int setup_layer(int fd)
53 struct omapfb_plane_info pi;
54 struct omapfb_mem_info mi;
55 struct omapfb_color_key key;
58 ret = ioctl(fd, OMAPFB_QUERY_PLANE, &pi);
60 perror("ioctl OMAPFB_QUERY_PLANE");
64 ret = ioctl(fd, OMAPFB_QUERY_MEM, &mi);
66 perror("ioctl OMAPFB_QUERY_MEM");
70 /* must disable when changing stuff */
73 ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
75 perror("ioctl OMAPFB_SETUP_PLANE (d)");
81 if (mi.size < MEM_SIZE) {
83 ret = ioctl(fd, OMAPFB_SETUP_MEM, &mi);
85 perror("ioctl SETUP_MEM");
90 pi.pos_x = SCREEN_WIDTH - WIDTH;
93 pi.out_height = HEIGHT;
94 ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
96 perror("ioctl OMAPFB_SETUP_PLANE (e1)");
100 ret = ioctl(fd, FBIOGET_VSCREENINFO, &g_vi);
102 perror("ioctl FBIOGET_VSCREENINFO");
106 g_vi.xres = g_vi.xres_virtual = WIDTH;
108 g_vi.yres_virtual = HEIGHT * 2;
109 g_vi.bits_per_pixel = 16;
111 ret = ioctl(fd, FBIOPUT_VSCREENINFO, &g_vi);
113 perror("ioctl FBIOPUT_VSCREENINFO");
118 ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
120 perror("ioctl OMAPFB_SETUP_PLANE (e2)");
124 memset(&key, 0, sizeof(key));
125 key.key_type = OMAPFB_COLOR_KEY_VID_SRC;
126 key.trans_key = 0x07e0;
128 ret = ioctl(fd, OMAPFB_SET_COLOR_KEY, &key);
130 perror("ioctl OMAPFB_SET_COLOR_KEY");
134 g_screen_base = mmap(NULL, MEM_SIZE, PROT_READ | PROT_WRITE,
136 if (g_screen_base == MAP_FAILED) {
138 g_screen = g_screen_base = NULL;
141 clear_bytes(g_screen_base, MEM_SIZE);
142 g_screen = g_screen_base;
148 static int check_layer(int fd)
150 struct omapfb_plane_info pi;
153 ret = ioctl(fd, OMAPFB_QUERY_PLANE, &pi);
155 perror("ioctl OMAPFB_QUERY_PLANE");
160 printf("something disabled the layer (tv-out?), quitting\n");
167 static void remove_layer(int fd)
169 struct omapfb_plane_info pi;
170 struct omapfb_mem_info mi;
173 if (g_screen_base != NULL) {
174 munmap(g_screen_base, MEM_SIZE);
175 g_screen = g_screen_base = NULL;
178 memset(&pi, 0, sizeof(pi));
180 ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi);
182 perror("ioctl OMAPFB_SETUP_PLANE (c)");
184 ret = ioctl(fd, OMAPFB_QUERY_MEM, &mi);
186 perror("ioctl OMAPFB_QUERY_MEM");
190 if (mi.size != g_old_mem) {
192 ret = ioctl(fd, OMAPFB_SETUP_MEM, &mi);
194 perror("ioctl SETUP_MEM");
202 static void flip_fb(int fd)
204 g_vi.yoffset = g_flip_id * HEIGHT;
205 ioctl(fd, FBIOPAN_DISPLAY, &g_vi);
207 g_screen = g_screen_base + g_flip_id * WIDTH * HEIGHT;
210 static void handle_term(int num)
213 pthread_cond_signal(&g_cond);
216 static void handle_usr1(int num)
219 pthread_cond_signal(&g_cond);
227 static int handle_socket(int sock)
232 ret = recv(sock, buf, sizeof(buf) - 1, 0);
241 p = strchr(buf, ':');
243 for (i = 0; i < ARRAY_SIZE(user_msgs); i++) {
244 if (user_msgs[i].text[0] == 0)
246 if (!strncmp(user_msgs[i].text, buf, p - buf + 1))
249 if (i == ARRAY_SIZE(user_msgs)) {
250 printf("out of user_msg slots\n");
253 memcpy(user_msgs[i].text, buf, sizeof(user_msgs[i].text) - 1);
254 user_msgs[i].text[sizeof(user_msgs[i].text) - 1] = 0;
255 user_msgs[i].idle = 0;
257 else if (!strcmp(buf, "poke")) {
258 // if hidden, show up
267 else if (!strcmp(buf, "hide")) {
271 else if (!strcmp(buf, "show")) {
275 else if (!strcmp(buf, "quit")) {
280 printf("unknown command: '%s'\n", buf);
286 #define s_printf(x, y, fmt, ...) \
287 basic_text_out16(g_screen, WIDTH, x, y, fmt, ##__VA_ARGS__);
289 static int read_int_file(const char *fn, int *val)
298 ret = fscanf(f, "%d", val);
306 static void clear_bytes(void *mem, int bytes)
311 for (; l >= 4; l -= 4, p += 4)
312 p[0] = p[1] = p[2] = p[3] = 0x07e007e0;
313 for (; l > 0; l--, p++)
317 static void clear(int h)
319 clear_bytes(g_screen, WIDTH * h * 2);
323 unsigned long idlesum;
330 struct proc_stat last_st;
340 static void collect_proc_stat(void)
346 unsigned long iowait;
350 hz = sysconf(_SC_CLK_TCK);
351 printf("hz: %ld\n", hz);
354 f = fopen("/proc/stat", "r");
358 if (fscanf(f, "cpu %*s %*s %lu %lu %lu",
359 &st.sys, &wait, &iowait) != 3)
362 if (fgets(buf, sizeof(buf), f) == NULL)
364 } while (fscanf(f, "intr %lu", &st.irqs) != 1);
366 if (fgets(buf, sizeof(buf), f) == NULL)
368 } while (fscanf(f, "ctxt %lu", &st.ctxt) != 1);
370 st.idlesum = wait + iowait;
372 stats.cpu_usage = hz - (st.idlesum - stats.last_st.idlesum);
373 stats.cpu_sys = st.sys - stats.last_st.sys;
375 stats.cpu_usage = stats.cpu_usage * 100 / hz;
376 stats.cpu_sys = stats.cpu_sys * 100 / hz;
378 stats.irqs = st.irqs - stats.last_st.irqs;
379 stats.ctxt = st.ctxt - stats.last_st.ctxt;
386 static void collect_mem_stat(void)
388 static const char fn[] = "/proc/meminfo";
389 uint32_t total = 0, free = 0, buffers = 0, cached = 0;
390 uint32_t anonhuge = 0, hugetot = 0, hugefree = 0, hugepgsz = 0;
391 uint32_t free_swap = 0;
399 while (fgets(buf, sizeof(buf), f)) {
400 if (total == 0 && sscanf(buf, "MemTotal: %u", &total) == 1)
402 if (free == 0 && sscanf(buf, "MemFree: %u", &free) == 1)
404 if (buffers == 0 && sscanf(buf, "Buffers: %u", &buffers) == 1)
406 if (cached == 0 && sscanf(buf, "Cached: %u", &cached) == 1)
408 if (free_swap == 0 && sscanf(buf, "SwapFree: %u", &free_swap) == 1)
410 if (anonhuge == 0 && sscanf(buf, "AnonHugePages: %u", &anonhuge) == 1)
412 if (hugetot == 0 && sscanf(buf, "HugePages_Total: %u", &hugetot) == 1)
414 if (hugefree == 0 && sscanf(buf, "HugePages_Free: %u", &hugefree) == 1)
416 if (hugepgsz == 0 && sscanf(buf, "Hugepagesize: %u", &hugepgsz) == 1)
422 hugetot = (hugetot - hugefree) * hugepgsz;
423 free += buffers + cached;
424 stats.mem_free = free >> 10;
425 stats.mem_huge = hugetot >> 10;
426 stats.mem_free_swap = free_swap >> 10;
435 struct io_stat last_st;
440 static void collect_io_stat(void)
442 unsigned long sec_r, sec_w;
443 struct io_stat st = { 0, };
448 for (i = 0; i < 2; i++) {
449 snprintf(buf, sizeof(buf), "/sys/block/mmcblk%d/stat", i);
454 if (fscanf(f, "%*s %*s %lu %*s %*s %*s %lu",
455 &sec_r, &sec_w) == 2)
463 io_stats.read = st.sec_r - io_stats.last_st.sec_r;
464 io_stats.write = st.sec_w - io_stats.last_st.sec_w;
465 // assuming 512 byte sectors..
467 io_stats.write >>= 1;
469 io_stats.last_st = st;
478 struct net_stat last_st;
486 static void collect_net_stat(void)
488 struct net_stat st = { 0, };
489 unsigned long rx, tx;
494 net_stats.down = net_stats.up =
495 net_stats.have_wlan = net_stats.link = net_stats.level = 0;
497 f = fopen("/proc/net/dev", "r");
502 static const char fmt[] =
503 "%255s %lu %*s %*s %*s %*s %*s %*s %lu";
504 if (fscanf(f, fmt, buf, &rx, &tx) != 3)
506 if (IS_START(buf, "lo"))
515 net_stats.down = st.rx - net_stats.last_st.rx;
516 net_stats.up = st.tx - net_stats.last_st.tx;
518 net_stats.last_st = st;
520 f = fopen("/proc/net/wireless", "r");
526 if (fscanf(f, "%255s %*x %d. %d.", buf, &lnk, &lvl) != 3)
528 if (IS_START(buf, "lo"))
530 // first one should be enough
531 net_stats.have_wlan = 1;
532 net_stats.link = lnk;
533 net_stats.level = lvl;
539 static void collect_stats(void)
547 static char cpu_reg_path[64];
549 static void init_stats(void)
556 // find the CPU regulator
557 for (i = found = 0; ; i++) {
558 snprintf(buf, sizeof(buf),
559 "/sys/class/regulator/regulator.%d/name", i);
563 fgets(buf, sizeof(buf), f);
565 if (IS_START(buf, "vdd_mpu")) {
572 snprintf(cpu_reg_path, sizeof(cpu_reg_path),
573 "/sys/class/regulator/regulator.%d/microvolts", i);
575 // do collect so differential stats get sane values
579 static void get_time(int x, int y)
585 gettimeofday(&tv, NULL);
586 t = localtime(&tv.tv_sec);
587 strftime(buf, sizeof(buf), "%T", t);
588 s_printf(x, y, " %s", buf);
591 static void get_cpu(int x, int y)
593 s_printf(x, y, "CPU:%5d%%", stats.cpu_usage);
596 static void get_sys(int x, int y)
598 s_printf(x, y, "SYS:%5d%%", stats.cpu_sys);
601 static void get_irq(int x, int y)
603 s_printf(x, y, "IRQ:%5u", stats.irqs);
606 static void get_cs(int x, int y)
608 s_printf(x, y, "CS:%6u", stats.ctxt);
611 static void get_cpuf(int x, int y)
613 static const char fn[] =
614 "/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq";
617 if (read_int_file(fn, &f))
619 s_printf(x, y, "f:%7dM", f / 1000);
622 static void get_cpuv(int x, int y)
626 if (!cpu_reg_path[0] || read_int_file(cpu_reg_path, &v))
628 s_printf(x, y, "V:%7.3fV", (float)v / 1000000.0f);
631 static void get_memfree(int x, int y)
633 s_printf(x, y, "M:%7dM", stats.mem_free);
636 static void get_memhuge(int x, int y)
638 s_printf(x, y, "H:%7dM", stats.mem_huge);
641 static void get_memswap(int x, int y)
643 s_printf(x, y, "S:%7dM", stats.mem_free_swap);
646 #define PS_BASE "/sys/class/power_supply/bq27500-0/"
648 static void get_bcap(int x, int y)
650 static const char fnc[] = PS_BASE "capacity";
653 if (read_int_file(fnc, &c))
655 s_printf(x, y, "C:%7d%%", c);
658 static void get_btime(int x, int y)
660 static const char fne[] = PS_BASE "time_to_empty_now";
661 static const char fnf[] = PS_BASE "time_to_full_now";
664 if (read_int_file(fne, &t) || t == 0) {
665 if (read_int_file(fnf, &t))
668 s_printf(x, y, "t:%4d:%02d", t / 3600, t / 60 % 60);
671 static void get_bvolts(int x, int y)
673 static const char fnv[] = PS_BASE "voltage_now";
676 if (read_int_file(fnv, &volt))
679 s_printf(x, y, "V:%7.3fV", (float)volt / 1000000.0f);
682 static void get_bwatts(int x, int y)
684 static const char fnc[] = PS_BASE "current_now";
685 static const char fnv[] = PS_BASE "voltage_now";
686 int w, cur = 0, volt = 0;
688 if (read_int_file(fnc, &cur))
690 if (read_int_file(fnv, &volt))
693 w = (cur / 1000) * (volt / 1000);
694 s_printf(x, y, "P:%7.3fW", (float)w / 1000000.0f);
697 static void get_btemp(int x, int y)
699 static const char fnt[] = PS_BASE "temp";
702 if (read_int_file(fnt, &t))
704 s_printf(x, y, "T:%7.1fC", (float)t / 10.0f);
707 static void get_ioread(int x, int y)
709 s_printf(x, y, "R:%5.1fM/s", (float)io_stats.read / 1000.0f);
712 static void get_iowrite(int x, int y)
714 s_printf(x, y, "W:%5.1fM/s", (float)io_stats.write / 1000.0f);
717 static void get_netdown(int x, int y)
719 s_printf(x, y, "D:%5uK/s", net_stats.down / 1000);
722 static void get_netup(int x, int y)
724 s_printf(x, y, "U:%5uK/s", net_stats.up / 1000);
727 static void get_netsgnl(int x, int y)
729 s_printf(x, y, "S:%5ddBm", net_stats.level);
732 int main(int argc, char *argv[])
734 static const char socket_name[] = "\0liveinfo";
735 static const char fbname[] = "/dev/fb2";
736 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
737 pthread_condattr_t condattr;
738 struct sockaddr_un sun;
743 int y = 0, y_max = 0;
748 // look for other instance
749 sock = socket(PF_UNIX, SOCK_DGRAM, 0);
751 perror("socket PF_UNIX");
755 memset(&sun, 0, sizeof(sun));
756 sun.sun_family = AF_UNIX;
757 memcpy(sun.sun_path, socket_name, sizeof(socket_name));
759 ret = connect(sock, (struct sockaddr *)&sun, sizeof(sun));
761 printf("other instance detected, sending poke command\n");
762 ret = send(sock, "poke", 4, 0);
766 return ret == 4 ? 0 : 1;
769 fd = open(fbname, O_RDWR);
771 fprintf(stderr, "open %s: ", fbname);
778 // no need for privileges any more
779 p = getenv("SUDO_UID");
789 // bind/listen for commands
790 ret = bind(sock, (struct sockaddr *)&sun, sizeof(sun));
798 ret = listen(sock, 1);
807 pfd.events = POLLIN | POLLPRI;
810 ret = pthread_condattr_init(&condattr);
811 ret |= pthread_condattr_setclock(&condattr, CLOCK_MONOTONIC);
812 ret |= pthread_cond_init(&g_cond, &condattr);
813 pthread_condattr_destroy(&condattr);
815 fprintf(stderr, "cond init failed\n");
819 ret = setup_layer(fd);
823 // clean up on kill too
824 signal(SIGTERM, handle_term);
825 signal(SIGUSR1, handle_usr1);
827 pthread_mutex_lock(&mutex);
828 ret = clock_gettime(CLOCK_MONOTONIC, &ts);
830 perror("clock_gettime CLOCK_MONOTONIC");
838 // anything on unix socket?
839 ret = poll(&pfd, 1, 0);
845 ret = handle_socket(sock);
859 else if (is_hidden) {
860 ret = setup_layer(fd);
866 if (check_layer(fd) != 0)
877 get_time (0, y += Y_STEP);
879 get_cpu (0, y += Y_STEP);
880 get_sys (0, y += Y_STEP);
881 get_irq (0, y += Y_STEP);
882 get_cs (0, y += Y_STEP);
883 get_cpuf (0, y += Y_STEP);
884 get_cpuv (0, y += Y_STEP);
886 s_printf(0, y += Y_STEP, "mem");
887 get_memfree(0, y += Y_STEP);
888 get_memswap(0, y += Y_STEP);
890 get_memhuge(0, y += Y_STEP);
892 s_printf(0, y += Y_STEP, "i/o");
893 get_ioread (0, y += Y_STEP);
894 get_iowrite(0, y += Y_STEP);
896 s_printf(0, y += Y_STEP, "net");
897 get_netdown(0, y += Y_STEP);
898 get_netup (0, y += Y_STEP);
899 if (net_stats.have_wlan)
900 get_netsgnl(0, y += Y_STEP);
902 s_printf(0, y += Y_STEP, "batt");
903 get_bcap (0, y += Y_STEP);
904 get_btime (0, y += Y_STEP);
905 get_bvolts (0, y += Y_STEP);
906 get_bwatts (0, y += Y_STEP);
907 get_btemp (0, y += Y_STEP);
909 // print user messages
911 for (i = 0; i < ARRAY_SIZE(user_msgs); i++) {
912 if (user_msgs[i].text[0] == 0)
915 if (user_msgs[i].idle > 6) {
916 // drop old entry, shift others up
917 memmove(&user_msgs[i], &user_msgs[i + 1],
918 (ARRAY_SIZE(user_msgs) - i - 1) * sizeof(user_msgs[0]));
919 user_msgs[ARRAY_SIZE(user_msgs) - 1].text[0] = 0;
925 s_printf(0, y += Y_STEP, user_msgs[i].text);
932 pthread_cond_timedwait(&g_cond, &mutex, &ts);
942 // vim:expandtab:sw=2:ts=2