?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
HID: hiddev: Fix slab-out-of-bounds write in hiddev_ioctl_usage()
[linux/fpc-iii.git] / tools / thermal / tmon / tui.c
blobb5d1c6b22dd3c8781c7cadd590f2121dfb8328cc
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 }
Linux with added FPC-III support