1 /* 2 * tui.c ncurses text user interface for TMON program 3 * 4 * Copyright (C) 2013 Intel Corporation. All rights reserved. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License version 8 * 2 or later as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * Author: Jacob Pan <jacob.jun.pan@linux.intel.com> 16 * 17 */ 18 19 #include <unistd.h> 20 #include <stdio.h> 21 #include <stdlib.h> 22 #include <string.h> 23 #include <stdint.h> 24 #include <ncurses.h> 25 #include <time.h> 26 #include <syslog.h> 27 #include <panel.h> 28 #include <pthread.h> 29 #include <signal.h> 30 31 #include "tmon.h" 32 33 #define min(x, y) ({ \ 34 typeof(x) _min1 = (x); \ 35 typeof(y) _min2 = (y); \ 36 (void) (&_min1 == &_min2); \ 37 _min1 < _min2 ? _min1 : _min2; }) 38 39 #define max(x, y) ({ \ 40 typeof(x) _max1 = (x); \ 41 typeof(y) _max2 = (y); \ 42 (void) (&_max1 == &_max2); \ 43 _max1 > _max2 ? _max1 : _max2; }) 44 45 static PANEL *data_panel; 46 static PANEL *dialogue_panel; 47 static PANEL *top; 48 49 static WINDOW *title_bar_window; 50 static WINDOW *tz_sensor_window; 51 static WINDOW *cooling_device_window; 52 static WINDOW *control_window; 53 static WINDOW *status_bar_window; 54 static WINDOW *thermal_data_window; 55 static WINDOW *dialogue_window; 56 57 char status_bar_slots[10][40]; 58 static void draw_hbar(WINDOW *win, int y, int start, int len, 59 unsigned long pattern, bool end); 60 61 static int maxx, maxy; 62 static int maxwidth = 200; 63 64 #define TITLE_BAR_HIGHT 1 65 #define SENSOR_WIN_HIGHT 4 /* one row for tz name, one for trip points */ 66 67 68 /* daemon mode flag (set by startup parameter -d) */ 69 static int tui_disabled; 70 71 static void close_panel(PANEL *p) 72 { 73 if (p) { 74 del_panel(p); 75 p = NULL; 76 } 77 } 78 79 static void close_window(WINDOW *win) 80 { 81 if (win) { 82 delwin(win); 83 win = NULL; 84 } 85 } 86 87 void close_windows(void) 88 { 89 if (tui_disabled) 90 return; 91 /* must delete panels before their attached windows */ 92 if (dialogue_window) 93 close_panel(dialogue_panel); 94 if (cooling_device_window) 95 close_panel(data_panel); 96 97 close_window(title_bar_window); 98 close_window(tz_sensor_window); 99 close_window(status_bar_window); 100 close_window(cooling_device_window); 101 close_window(control_window); 102 close_window(thermal_data_window); 103 close_window(dialogue_window); 104 105 } 106 107 void write_status_bar(int x, char *line) 108 { 109 mvwprintw(status_bar_window, 0, x, "%s", line); 110 wrefresh(status_bar_window); 111 } 112 113 /* wrap at 5 */ 114 #define DIAG_DEV_ROWS 5 115 /* 116 * list cooling devices + "set temp" entry; wraps after 5 rows, if they fit 117 */ 118 static int diag_dev_rows(void) 119 { 120 int entries = ptdata.nr_cooling_dev + 1; 121 int rows = max(DIAG_DEV_ROWS, (entries + 1) / 2); 122 return min(rows, entries); 123 } 124 125 void setup_windows(void) 126 { 127 int y_begin = 1; 128 129 if (tui_disabled) 130 return; 131 132 getmaxyx(stdscr, maxy, maxx); 133 resizeterm(maxy, maxx); 134 135 title_bar_window = subwin(stdscr, TITLE_BAR_HIGHT, maxx, 0, 0); 136 y_begin += TITLE_BAR_HIGHT; 137 138 tz_sensor_window = subwin(stdscr, SENSOR_WIN_HIGHT, maxx, y_begin, 0); 139 y_begin += SENSOR_WIN_HIGHT; 140 141 cooling_device_window = subwin(stdscr, ptdata.nr_cooling_dev + 3, maxx, 142 y_begin, 0); 143 y_begin += ptdata.nr_cooling_dev + 3; /* 2 lines for border */ 144 /* two lines to show borders, one line per tz show trip point position 145 * and value. 146 * dialogue window is a pop-up, when needed it lays on top of cdev win 147 */ 148 149 dialogue_window = subwin(stdscr, diag_dev_rows() + 5, maxx-50, 150 DIAG_Y, DIAG_X); 151 152 thermal_data_window = subwin(stdscr, ptdata.nr_tz_sensor * 153 NR_LINES_TZDATA + 3, maxx, y_begin, 0); 154 y_begin += ptdata.nr_tz_sensor * NR_LINES_TZDATA + 3; 155 control_window = subwin(stdscr, 4, maxx, y_begin, 0); 156 157 scrollok(cooling_device_window, TRUE); 158 maxwidth = maxx - 18; 159 status_bar_window = subwin(stdscr, 1, maxx, maxy-1, 0); 160 161 strcpy(status_bar_slots[0], " Ctrl-c - Quit "); 162 strcpy(status_bar_slots[1], " TAB - Tuning "); 163 wmove(status_bar_window, 1, 30); 164 165 /* prepare panels for dialogue, if panel already created then we must 166 * be doing resizing, so just replace windows with new ones, old ones 167 * should have been deleted by close_window 168 */ 169 data_panel = new_panel(cooling_device_window); 170 if (!data_panel) 171 syslog(LOG_DEBUG, "No data panel\n"); 172 else { 173 if (dialogue_window) { 174 dialogue_panel = new_panel(dialogue_window); 175 if (!dialogue_panel) 176 syslog(LOG_DEBUG, "No dialogue panel\n"); 177 else { 178 /* Set up the user pointer to the next panel*/ 179 set_panel_userptr(data_panel, dialogue_panel); 180 set_panel_userptr(dialogue_panel, data_panel); 181 top = data_panel; 182 } 183 } else 184 syslog(LOG_INFO, "no dialogue win, term too small\n"); 185 } 186 doupdate(); 187 werase(stdscr); 188 refresh(); 189 } 190 191 void resize_handler(int sig) 192 { 193 /* start over when term gets resized, but first we clean up */ 194 close_windows(); 195 endwin(); 196 refresh(); 197 clear(); 198 getmaxyx(stdscr, maxy, maxx); /* get the new screen size */ 199 setup_windows(); 200 /* rate limit */ 201 sleep(1); 202 syslog(LOG_DEBUG, "SIG %d, term resized to %d x %d\n", 203 sig, maxy, maxx); 204 signal(SIGWINCH, resize_handler); 205 } 206 207 const char cdev_title[] = " COOLING DEVICES "; 208 void show_cooling_device(void) 209 { 210 int i, j, x, y = 0; 211 212 if (tui_disabled || !cooling_device_window) 213 return; 214 215 werase(cooling_device_window); 216 wattron(cooling_device_window, A_BOLD); 217 mvwprintw(cooling_device_window, 1, 1, 218 "ID Cooling Dev Cur Max Thermal Zone Binding"); 219 wattroff(cooling_device_window, A_BOLD); 220 for (j = 0; j < ptdata.nr_cooling_dev; j++) { 221 /* draw cooling device list on the left in the order of 222 * cooling device instances. skip unused idr. 223 */ 224 mvwprintw(cooling_device_window, j + 2, 1, 225 "%02d %12.12s%6d %6d", 226 ptdata.cdi[j].instance, 227 ptdata.cdi[j].type, 228 ptdata.cdi[j].cur_state, 229 ptdata.cdi[j].max_state); 230 } 231 232 /* show cdev binding, y is the global cooling device instance */ 233 for (i = 0; i < ptdata.nr_tz_sensor; i++) { 234 int tz_inst = ptdata.tzi[i].instance; 235 for (j = 0; j < ptdata.nr_cooling_dev; j++) { 236 int cdev_inst; 237 y = j; 238 x = tz_inst * TZONE_RECORD_SIZE + TZ_LEFT_ALIGN; 239 240 draw_hbar(cooling_device_window, y+2, x, 241 TZONE_RECORD_SIZE-1, ACS_VLINE, false); 242 243 /* draw a column of spaces to separate thermal zones */ 244 mvwprintw(cooling_device_window, y+2, x-1, " "); 245 if (ptdata.tzi[i].cdev_binding) { 246 cdev_inst = ptdata.cdi[j].instance; 247 unsigned long trip_binding = 248 ptdata.tzi[i].trip_binding[cdev_inst]; 249 int k = 0; /* per zone trip point id that 250 * binded to this cdev, one to 251 * many possible based on the 252 * binding bitmask. 253 */ 254 syslog(LOG_DEBUG, 255 "bind tz%d cdev%d tp%lx %d cdev%lx\n", 256 i, j, trip_binding, y, 257 ptdata.tzi[i].cdev_binding); 258 /* draw each trip binding for the cdev */ 259 while (trip_binding >>= 1) { 260 k++; 261 if (!(trip_binding & 1)) 262 continue; 263 /* draw '*' to show binding */ 264 mvwprintw(cooling_device_window, 265 y + 2, 266 x + ptdata.tzi[i].nr_trip_pts - 267 k - 1, "*"); 268 } 269 } 270 } 271 } 272 /* draw border after data so that border will not be messed up 273 * even there is not enough space for all the data to be shown 274 */ 275 wborder(cooling_device_window, 0, 0, 0, 0, 0, 0, 0, 0); 276 wattron(cooling_device_window, A_BOLD); 277 mvwprintw(cooling_device_window, 0, maxx/2 - sizeof(cdev_title), 278 cdev_title); 279 wattroff(cooling_device_window, A_BOLD); 280 281 wrefresh(cooling_device_window); 282 } 283 284 const char DIAG_TITLE[] = "[ TUNABLES ]"; 285 void show_dialogue(void) 286 { 287 int j, x = 0, y = 0; 288 int rows, cols; 289 WINDOW *w = dialogue_window; 290 291 if (tui_disabled || !w) 292 return; 293 294 getmaxyx(w, rows, cols); 295 296 /* Silence compiler 'unused' warnings */ 297 (void)cols; 298 299 werase(w); 300 box(w, 0, 0); 301 mvwprintw(w, 0, maxx/4, DIAG_TITLE); 302 /* list all the available tunables */ 303 for (j = 0; j <= ptdata.nr_cooling_dev; j++) { 304 y = j % diag_dev_rows(); 305 if (y == 0 && j != 0) 306 x += 20; 307 if (j == ptdata.nr_cooling_dev) 308 /* save last choice for target temp */ 309 mvwprintw(w, y+1, x+1, "%C-%.12s", 'A'+j, "Set Temp"); 310 else 311 mvwprintw(w, y+1, x+1, "%C-%.10s-%2d", 'A'+j, 312 ptdata.cdi[j].type, ptdata.cdi[j].instance); 313 } 314 wattron(w, A_BOLD); 315 mvwprintw(w, diag_dev_rows()+1, 1, "Enter Choice [A-Z]?"); 316 wattroff(w, A_BOLD); 317 /* print legend at the bottom line */ 318 mvwprintw(w, rows - 2, 1, 319 "Legend: A=Active, P=Passive, C=Critical"); 320 321 wrefresh(dialogue_window); 322 } 323 324 void write_dialogue_win(char *buf, int y, int x) 325 { 326 WINDOW *w = dialogue_window; 327 328 mvwprintw(w, y, x, "%s", buf); 329 } 330 331 const char control_title[] = " CONTROLS "; 332 void show_control_w(void) 333 { 334 unsigned long state; 335 336 get_ctrl_state(&state); 337 338 if (tui_disabled || !control_window) 339 return; 340 341 werase(control_window); 342 mvwprintw(control_window, 1, 1, 343 "PID gain: kp=%2.2f ki=%2.2f kd=%2.2f Output %2.2f", 344 p_param.kp, p_param.ki, p_param.kd, p_param.y_k); 345 346 mvwprintw(control_window, 2, 1, 347 "Target Temp: %2.1fC, Zone: %d, Control Device: %.12s", 348 p_param.t_target, target_thermal_zone, ctrl_cdev); 349 350 /* draw border last such that everything is within boundary */ 351 wborder(control_window, 0, 0, 0, 0, 0, 0, 0, 0); 352 wattron(control_window, A_BOLD); 353 mvwprintw(control_window, 0, maxx/2 - sizeof(control_title), 354 control_title); 355 wattroff(control_window, A_BOLD); 356 357 wrefresh(control_window); 358 } 359 360 void initialize_curses(void) 361 { 362 if (tui_disabled) 363 return; 364 365 initscr(); 366 start_color(); 367 keypad(stdscr, TRUE); /* enable keyboard mapping */ 368 nonl(); /* tell curses not to do NL->CR/NL on output */ 369 cbreak(); /* take input chars one at a time */ 370 noecho(); /* dont echo input */ 371 curs_set(0); /* turn off cursor */ 372 use_default_colors(); 373 374 init_pair(PT_COLOR_DEFAULT, COLOR_WHITE, COLOR_BLACK); 375 init_pair(PT_COLOR_HEADER_BAR, COLOR_BLACK, COLOR_WHITE); 376 init_pair(PT_COLOR_ERROR, COLOR_BLACK, COLOR_RED); 377 init_pair(PT_COLOR_RED, COLOR_WHITE, COLOR_RED); 378 init_pair(PT_COLOR_YELLOW, COLOR_WHITE, COLOR_YELLOW); 379 init_pair(PT_COLOR_GREEN, COLOR_WHITE, COLOR_GREEN); 380 init_pair(PT_COLOR_BLUE, COLOR_WHITE, COLOR_BLUE); 381 init_pair(PT_COLOR_BRIGHT, COLOR_WHITE, COLOR_BLACK); 382 383 } 384 385 void show_title_bar(void) 386 { 387 int i; 388 int x = 0; 389 390 if (tui_disabled || !title_bar_window) 391 return; 392 393 wattrset(title_bar_window, COLOR_PAIR(PT_COLOR_HEADER_BAR)); 394 wbkgd(title_bar_window, COLOR_PAIR(PT_COLOR_HEADER_BAR)); 395 werase(title_bar_window); 396 397 mvwprintw(title_bar_window, 0, 0, 398 " TMON v%s", VERSION); 399 400 wrefresh(title_bar_window); 401 402 werase(status_bar_window); 403 404 for (i = 0; i < 10; i++) { 405 if (strlen(status_bar_slots[i]) == 0) 406 continue; 407 wattron(status_bar_window, A_REVERSE); 408 mvwprintw(status_bar_window, 0, x, "%s", status_bar_slots[i]); 409 wattroff(status_bar_window, A_REVERSE); 410 x += strlen(status_bar_slots[i]) + 1; 411 } 412 wrefresh(status_bar_window); 413 } 414 415 static void handle_input_val(int ch) 416 { 417 char buf[32]; 418 int val; 419 char path[256]; 420 WINDOW *w = dialogue_window; 421 422 echo(); 423 keypad(w, TRUE); 424 wgetnstr(w, buf, 31); 425 val = atoi(buf); 426 427 if (ch == ptdata.nr_cooling_dev) { 428 snprintf(buf, 31, "Invalid Temp %d! %d-%d", val, 429 MIN_CTRL_TEMP, MAX_CTRL_TEMP); 430 if (val < MIN_CTRL_TEMP || val > MAX_CTRL_TEMP) 431 write_status_bar(40, buf); 432 else { 433 p_param.t_target = val; 434 snprintf(buf, 31, "Set New Target Temp %d", val); 435 write_status_bar(40, buf); 436 } 437 } else { 438 snprintf(path, 256, "%s/%s%d", THERMAL_SYSFS, 439 CDEV, ptdata.cdi[ch].instance); 440 sysfs_set_ulong(path, "cur_state", val); 441 } 442 noecho(); 443 dialogue_on = 0; 444 show_data_w(); 445 show_control_w(); 446 447 top = (PANEL *)panel_userptr(top); 448 top_panel(top); 449 } 450 451 static void handle_input_choice(int ch) 452 { 453 char buf[48]; 454 int base = 0; 455 int cdev_id = 0; 456 457 if ((ch >= 'A' && ch <= 'A' + ptdata.nr_cooling_dev) || 458 (ch >= 'a' && ch <= 'a' + ptdata.nr_cooling_dev)) { 459 base = (ch < 'a') ? 'A' : 'a'; 460 cdev_id = ch - base; 461 if (ptdata.nr_cooling_dev == cdev_id) 462 snprintf(buf, sizeof(buf), "New Target Temp:"); 463 else 464 snprintf(buf, sizeof(buf), "New Value for %.10s-%2d: ", 465 ptdata.cdi[cdev_id].type, 466 ptdata.cdi[cdev_id].instance); 467 write_dialogue_win(buf, diag_dev_rows() + 2, 2); 468 handle_input_val(cdev_id); 469 } else { 470 snprintf(buf, sizeof(buf), "Invalid selection %d", ch); 471 write_dialogue_win(buf, 8, 2); 472 } 473 } 474 475 void *handle_tui_events(void *arg) 476 { 477 int ch; 478 479 keypad(cooling_device_window, TRUE); 480 while ((ch = wgetch(cooling_device_window)) != EOF) { 481 if (tmon_exit) 482 break; 483 /* when term size is too small, no dialogue panels are set. 484 * we need to filter out such cases. 485 */ 486 if (!data_panel || !dialogue_panel || 487 !cooling_device_window || 488 !dialogue_window) { 489 490 continue; 491 } 492 pthread_mutex_lock(&input_lock); 493 if (dialogue_on) { 494 handle_input_choice(ch); 495 /* top panel filter */ 496 if (ch == 'q' || ch == 'Q') 497 ch = 0; 498 } 499 switch (ch) { 500 case KEY_LEFT: 501 box(cooling_device_window, 10, 0); 502 break; 503 case 9: /* TAB */ 504 top = (PANEL *)panel_userptr(top); 505 top_panel(top); 506 if (top == dialogue_panel) { 507 dialogue_on = 1; 508 show_dialogue(); 509 } else { 510 dialogue_on = 0; 511 /* force refresh */ 512 show_data_w(); 513 show_control_w(); 514 } 515 break; 516 case 'q': 517 case 'Q': 518 tmon_exit = 1; 519 break; 520 } 521 update_panels(); 522 doupdate(); 523 pthread_mutex_unlock(&input_lock); 524 } 525 526 if (arg) 527 *(int *)arg = 0; /* make gcc happy */ 528 529 return NULL; 530 } 531 532 /* draw a horizontal bar in given pattern */ 533 static void draw_hbar(WINDOW *win, int y, int start, int len, unsigned long ptn, 534 bool end) 535 { 536 mvwaddch(win, y, start, ptn); 537 whline(win, ptn, len); 538 if (end) 539 mvwaddch(win, y, MAX_DISP_TEMP+TDATA_LEFT, ']'); 540 } 541 542 static char trip_type_to_char(int type) 543 { 544 switch (type) { 545 case THERMAL_TRIP_CRITICAL: return 'C'; 546 case THERMAL_TRIP_HOT: return 'H'; 547 case THERMAL_TRIP_PASSIVE: return 'P'; 548 case THERMAL_TRIP_ACTIVE: return 'A'; 549 default: 550 return '?'; 551 } 552 } 553 554 /* fill a string with trip point type and value in one line 555 * e.g. P(56) C(106) 556 * maintain the distance one degree per char 557 */ 558 static void draw_tp_line(int tz, int y) 559 { 560 int j; 561 int x; 562 563 for (j = 0; j < ptdata.tzi[tz].nr_trip_pts; j++) { 564 x = ptdata.tzi[tz].tp[j].temp / 1000; 565 mvwprintw(thermal_data_window, y + 0, x + TDATA_LEFT, 566 "%c%d", trip_type_to_char(ptdata.tzi[tz].tp[j].type), 567 x); 568 syslog(LOG_INFO, "%s:tz %d tp %d temp = %lu\n", __func__, 569 tz, j, ptdata.tzi[tz].tp[j].temp); 570 } 571 } 572 573 const char data_win_title[] = " THERMAL DATA "; 574 void show_data_w(void) 575 { 576 int i; 577 578 579 if (tui_disabled || !thermal_data_window) 580 return; 581 582 werase(thermal_data_window); 583 wattron(thermal_data_window, A_BOLD); 584 mvwprintw(thermal_data_window, 0, maxx/2 - sizeof(data_win_title), 585 data_win_title); 586 wattroff(thermal_data_window, A_BOLD); 587 /* draw a line as ruler */ 588 for (i = 10; i < MAX_DISP_TEMP; i += 10) 589 mvwprintw(thermal_data_window, 1, i+TDATA_LEFT, "%2d", i); 590 591 for (i = 0; i < ptdata.nr_tz_sensor; i++) { 592 int temp = trec[cur_thermal_record].temp[i] / 1000; 593 int y = 0; 594 595 y = i * NR_LINES_TZDATA + 2; 596 /* y at tz temp data line */ 597 mvwprintw(thermal_data_window, y, 1, "%6.6s%2d:[%3d][", 598 ptdata.tzi[i].type, 599 ptdata.tzi[i].instance, temp); 600 draw_hbar(thermal_data_window, y, TDATA_LEFT, temp, ACS_RARROW, 601 true); 602 draw_tp_line(i, y); 603 } 604 wborder(thermal_data_window, 0, 0, 0, 0, 0, 0, 0, 0); 605 wrefresh(thermal_data_window); 606 } 607 608 const char tz_title[] = "THERMAL ZONES(SENSORS)"; 609 610 void show_sensors_w(void) 611 { 612 int i, j; 613 char buffer[512]; 614 615 if (tui_disabled || !tz_sensor_window) 616 return; 617 618 werase(tz_sensor_window); 619 620 memset(buffer, 0, sizeof(buffer)); 621 wattron(tz_sensor_window, A_BOLD); 622 mvwprintw(tz_sensor_window, 1, 1, "Thermal Zones:"); 623 wattroff(tz_sensor_window, A_BOLD); 624 625 mvwprintw(tz_sensor_window, 1, TZ_LEFT_ALIGN, "%s", buffer); 626 /* fill trip points for each tzone */ 627 wattron(tz_sensor_window, A_BOLD); 628 mvwprintw(tz_sensor_window, 2, 1, "Trip Points:"); 629 wattroff(tz_sensor_window, A_BOLD); 630 631 /* draw trip point from low to high for each tz */ 632 for (i = 0; i < ptdata.nr_tz_sensor; i++) { 633 int inst = ptdata.tzi[i].instance; 634 635 mvwprintw(tz_sensor_window, 1, 636 TZ_LEFT_ALIGN+TZONE_RECORD_SIZE * inst, "%.9s%02d", 637 ptdata.tzi[i].type, ptdata.tzi[i].instance); 638 for (j = ptdata.tzi[i].nr_trip_pts - 1; j >= 0; j--) { 639 /* loop through all trip points */ 640 char type; 641 int tp_pos; 642 /* reverse the order here since trips are sorted 643 * in ascending order in terms of temperature. 644 */ 645 tp_pos = ptdata.tzi[i].nr_trip_pts - j - 1; 646 647 type = trip_type_to_char(ptdata.tzi[i].tp[j].type); 648 mvwaddch(tz_sensor_window, 2, 649 inst * TZONE_RECORD_SIZE + TZ_LEFT_ALIGN + 650 tp_pos, type); 651 syslog(LOG_DEBUG, "draw tz %d tp %d ch:%c\n", 652 inst, j, type); 653 } 654 } 655 wborder(tz_sensor_window, 0, 0, 0, 0, 0, 0, 0, 0); 656 wattron(tz_sensor_window, A_BOLD); 657 mvwprintw(tz_sensor_window, 0, maxx/2 - sizeof(tz_title), tz_title); 658 wattroff(tz_sensor_window, A_BOLD); 659 wrefresh(tz_sensor_window); 660 } 661 662 void disable_tui(void) 663 { 664 tui_disabled = 1; 665 } 666