1 /*
2 * sysfs.c sysfs ABI access functions 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 #include <unistd.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <stdint.h>
23 #include <dirent.h>
24 #include <libintl.h>
25 #include <ctype.h>
26 #include <time.h>
27 #include <syslog.h>
28 #include <sys/time.h>
29 #include <errno.h>
30
31 #include "tmon.h"
32
33 struct tmon_platform_data ptdata;
34 const char *trip_type_name[] = {
35 "critical",
36 "hot",
37 "passive",
38 "active",
39 };
40
sysfs_set_ulong(char * path,char * filename,unsigned long val)41 int sysfs_set_ulong(char *path, char *filename, unsigned long val)
42 {
43 FILE *fd;
44 int ret = -1;
45 char filepath[256];
46
47 snprintf(filepath, 256, "%s/%s", path, filename);
48
49 fd = fopen(filepath, "w");
50 if (!fd) {
51 syslog(LOG_ERR, "Err: open %s: %s\n", __func__, filepath);
52 return ret;
53 }
54 ret = fprintf(fd, "%lu", val);
55 fclose(fd);
56
57 return 0;
58 }
59
60 /* history of thermal data, used for control algo */
61 #define NR_THERMAL_RECORDS 3
62 struct thermal_data_record trec[NR_THERMAL_RECORDS];
63 int cur_thermal_record; /* index to the trec array */
64
sysfs_get_ulong(char * path,char * filename,unsigned long * p_ulong)65 static int sysfs_get_ulong(char *path, char *filename, unsigned long *p_ulong)
66 {
67 FILE *fd;
68 int ret = -1;
69 char filepath[256];
70
71 snprintf(filepath, 256, "%s/%s", path, filename);
72
73 fd = fopen(filepath, "r");
74 if (!fd) {
75 syslog(LOG_ERR, "Err: open %s: %s\n", __func__, filepath);
76 return ret;
77 }
78 ret = fscanf(fd, "%lu", p_ulong);
79 fclose(fd);
80
81 return 0;
82 }
83
sysfs_get_string(char * path,char * filename,char * str)84 static int sysfs_get_string(char *path, char *filename, char *str)
85 {
86 FILE *fd;
87 int ret = -1;
88 char filepath[256];
89
90 snprintf(filepath, 256, "%s/%s", path, filename);
91
92 fd = fopen(filepath, "r");
93 if (!fd) {
94 syslog(LOG_ERR, "Err: open %s: %s\n", __func__, filepath);
95 return ret;
96 }
97 ret = fscanf(fd, "%256s", str);
98 fclose(fd);
99
100 return ret;
101 }
102
103 /* get states of the cooling device instance */
probe_cdev(struct cdev_info * cdi,char * path)104 static int probe_cdev(struct cdev_info *cdi, char *path)
105 {
106 sysfs_get_string(path, "type", cdi->type);
107 sysfs_get_ulong(path, "max_state", &cdi->max_state);
108 sysfs_get_ulong(path, "cur_state", &cdi->cur_state);
109
110 syslog(LOG_INFO, "%s: %s: type %s, max %lu, curr %lu inst %d\n",
111 __func__, path,
112 cdi->type, cdi->max_state, cdi->cur_state, cdi->instance);
113
114 return 0;
115 }
116
str_to_trip_type(char * name)117 static int str_to_trip_type(char *name)
118 {
119 int i;
120
121 for (i = 0; i < NR_THERMAL_TRIP_TYPE; i++) {
122 if (!strcmp(name, trip_type_name[i]))
123 return i;
124 }
125
126 return -ENOENT;
127 }
128
129 /* scan and fill in trip point info for a thermal zone and trip point id */
get_trip_point_data(char * tz_path,int tzid,int tpid)130 static int get_trip_point_data(char *tz_path, int tzid, int tpid)
131 {
132 char filename[256];
133 char temp_str[256];
134 int trip_type;
135
136 if (tpid >= MAX_NR_TRIP)
137 return -EINVAL;
138 /* check trip point type */
139 snprintf(filename, sizeof(filename), "trip_point_%d_type", tpid);
140 sysfs_get_string(tz_path, filename, temp_str);
141 trip_type = str_to_trip_type(temp_str);
142 if (trip_type < 0) {
143 syslog(LOG_ERR, "%s:%s no matching type\n", __func__, temp_str);
144 return -ENOENT;
145 }
146 ptdata.tzi[tzid].tp[tpid].type = trip_type;
147 syslog(LOG_INFO, "%s:tz:%d tp:%d:type:%s type id %d\n", __func__, tzid,
148 tpid, temp_str, trip_type);
149
150 /* TODO: check attribute */
151
152 return 0;
153 }
154
155 /* return instance id for file format such as trip_point_4_temp */
get_instance_id(char * name,int pos,int skip)156 static int get_instance_id(char *name, int pos, int skip)
157 {
158 char *ch;
159 int i = 0;
160
161 ch = strtok(name, "_");
162 while (ch != NULL) {
163 ++i;
164 syslog(LOG_INFO, "%s:%s:%s:%d", __func__, name, ch, i);
165 ch = strtok(NULL, "_");
166 if (pos == i)
167 return atol(ch + skip);
168 }
169
170 return -1;
171 }
172
173 /* Find trip point info of a thermal zone */
find_tzone_tp(char * tz_name,char * d_name,struct tz_info * tzi,int tz_id)174 static int find_tzone_tp(char *tz_name, char *d_name, struct tz_info *tzi,
175 int tz_id)
176 {
177 int tp_id;
178 unsigned long temp_ulong;
179
180 if (strstr(d_name, "trip_point") &&
181 strstr(d_name, "temp")) {
182 /* check if trip point temp is non-zero
183 * ignore 0/invalid trip points
184 */
185 sysfs_get_ulong(tz_name, d_name, &temp_ulong);
186 if (temp_ulong < MAX_TEMP_KC) {
187 tzi->nr_trip_pts++;
188 /* found a valid trip point */
189 tp_id = get_instance_id(d_name, 2, 0);
190 syslog(LOG_DEBUG, "tzone %s trip %d temp %lu tpnode %s",
191 tz_name, tp_id, temp_ulong, d_name);
192 if (tp_id < 0 || tp_id >= MAX_NR_TRIP) {
193 syslog(LOG_ERR, "Failed to find TP inst %s\n",
194 d_name);
195 return -1;
196 }
197 get_trip_point_data(tz_name, tz_id, tp_id);
198 tzi->tp[tp_id].temp = temp_ulong;
199 }
200 }
201
202 return 0;
203 }
204
205 /* check cooling devices for binding info. */
find_tzone_cdev(struct dirent * nl,char * tz_name,struct tz_info * tzi,int tz_id,int cid)206 static int find_tzone_cdev(struct dirent *nl, char *tz_name,
207 struct tz_info *tzi, int tz_id, int cid)
208 {
209 unsigned long trip_instance = 0;
210 char cdev_name_linked[256];
211 char cdev_name[256];
212 char cdev_trip_name[256];
213 int cdev_id;
214
215 if (nl->d_type == DT_LNK) {
216 syslog(LOG_DEBUG, "TZ%d: cdev: %s cid %d\n", tz_id, nl->d_name,
217 cid);
218 tzi->nr_cdev++;
219 if (tzi->nr_cdev > ptdata.nr_cooling_dev) {
220 syslog(LOG_ERR, "Err: Too many cdev? %d\n",
221 tzi->nr_cdev);
222 return -EINVAL;
223 }
224 /* find the link to real cooling device record binding */
225 snprintf(cdev_name, 256, "%s/%s", tz_name, nl->d_name);
226 memset(cdev_name_linked, 0, sizeof(cdev_name_linked));
227 if (readlink(cdev_name, cdev_name_linked,
228 sizeof(cdev_name_linked) - 1) != -1) {
229 cdev_id = get_instance_id(cdev_name_linked, 1,
230 sizeof("device") - 1);
231 syslog(LOG_DEBUG, "cdev %s linked to %s : %d\n",
232 cdev_name, cdev_name_linked, cdev_id);
233 tzi->cdev_binding |= (1 << cdev_id);
234
235 /* find the trip point in which the cdev is binded to
236 * in this tzone
237 */
238 snprintf(cdev_trip_name, 256, "%s%s", nl->d_name,
239 "_trip_point");
240 sysfs_get_ulong(tz_name, cdev_trip_name,
241 &trip_instance);
242 /* validate trip point range, e.g. trip could return -1
243 * when passive is enabled
244 */
245 if (trip_instance > MAX_NR_TRIP)
246 trip_instance = 0;
247 tzi->trip_binding[cdev_id] |= 1 << trip_instance;
248 syslog(LOG_DEBUG, "cdev %s -> trip:%lu: 0x%lx %d\n",
249 cdev_name, trip_instance,
250 tzi->trip_binding[cdev_id],
251 cdev_id);
252
253
254 }
255 return 0;
256 }
257
258 return -ENODEV;
259 }
260
261
262
263 /*****************************************************************************
264 * Before calling scan_tzones, thermal sysfs must be probed to determine
265 * the number of thermal zones and cooling devices.
266 * We loop through each thermal zone and fill in tz_info struct, i.e.
267 * ptdata.tzi[]
268 root@jacob-chiefriver:~# tree -d /sys/class/thermal/thermal_zone0
269 /sys/class/thermal/thermal_zone0
270 |-- cdev0 -> ../cooling_device4
271 |-- cdev1 -> ../cooling_device3
272 |-- cdev10 -> ../cooling_device7
273 |-- cdev11 -> ../cooling_device6
274 |-- cdev12 -> ../cooling_device5
275 |-- cdev2 -> ../cooling_device2
276 |-- cdev3 -> ../cooling_device1
277 |-- cdev4 -> ../cooling_device0
278 |-- cdev5 -> ../cooling_device12
279 |-- cdev6 -> ../cooling_device11
280 |-- cdev7 -> ../cooling_device10
281 |-- cdev8 -> ../cooling_device9
282 |-- cdev9 -> ../cooling_device8
283 |-- device -> ../../../LNXSYSTM:00/device:62/LNXTHERM:00
284 |-- power
285 `-- subsystem -> ../../../../class/thermal
286 *****************************************************************************/
scan_tzones(void)287 static int scan_tzones(void)
288 {
289 DIR *dir;
290 struct dirent **namelist;
291 char tz_name[256];
292 int i, j, n, k = 0;
293
294 if (!ptdata.nr_tz_sensor)
295 return -1;
296
297 for (i = 0; i <= ptdata.max_tz_instance; i++) {
298 memset(tz_name, 0, sizeof(tz_name));
299 snprintf(tz_name, 256, "%s/%s%d", THERMAL_SYSFS, TZONE, i);
300
301 dir = opendir(tz_name);
302 if (!dir) {
303 syslog(LOG_INFO, "Thermal zone %s skipped\n", tz_name);
304 continue;
305 }
306 /* keep track of valid tzones */
307 n = scandir(tz_name, &namelist, 0, alphasort);
308 if (n < 0)
309 syslog(LOG_ERR, "scandir failed in %s", tz_name);
310 else {
311 sysfs_get_string(tz_name, "type", ptdata.tzi[k].type);
312 ptdata.tzi[k].instance = i;
313 /* detect trip points and cdev attached to this tzone */
314 j = 0; /* index for cdev */
315 ptdata.tzi[k].nr_cdev = 0;
316 ptdata.tzi[k].nr_trip_pts = 0;
317 while (n--) {
318 char *temp_str;
319
320 if (find_tzone_tp(tz_name, namelist[n]->d_name,
321 &ptdata.tzi[k], k))
322 break;
323 temp_str = strstr(namelist[n]->d_name, "cdev");
324 if (!temp_str) {
325 free(namelist[n]);
326 continue;
327 }
328 if (!find_tzone_cdev(namelist[n], tz_name,
329 &ptdata.tzi[k], i, j))
330 j++; /* increment cdev index */
331 free(namelist[n]);
332 }
333 free(namelist);
334 }
335 /*TODO: reverse trip points */
336 closedir(dir);
337 syslog(LOG_INFO, "TZ %d has %d cdev\n", i,
338 ptdata.tzi[k].nr_cdev);
339 k++;
340 }
341
342 return 0;
343 }
344
scan_cdevs(void)345 static int scan_cdevs(void)
346 {
347 DIR *dir;
348 struct dirent **namelist;
349 char cdev_name[256];
350 int i, n, k = 0;
351
352 if (!ptdata.nr_cooling_dev) {
353 fprintf(stderr, "No cooling devices found\n");
354 return 0;
355 }
356 for (i = 0; i <= ptdata.max_cdev_instance; i++) {
357 memset(cdev_name, 0, sizeof(cdev_name));
358 snprintf(cdev_name, 256, "%s/%s%d", THERMAL_SYSFS, CDEV, i);
359
360 dir = opendir(cdev_name);
361 if (!dir) {
362 syslog(LOG_INFO, "Cooling dev %s skipped\n", cdev_name);
363 /* there is a gap in cooling device id, check again
364 * for the same index.
365 */
366 continue;
367 }
368
369 n = scandir(cdev_name, &namelist, 0, alphasort);
370 if (n < 0)
371 syslog(LOG_ERR, "scandir failed in %s", cdev_name);
372 else {
373 sysfs_get_string(cdev_name, "type", ptdata.cdi[k].type);
374 ptdata.cdi[k].instance = i;
375 if (strstr(ptdata.cdi[k].type, ctrl_cdev)) {
376 ptdata.cdi[k].flag |= CDEV_FLAG_IN_CONTROL;
377 syslog(LOG_DEBUG, "control cdev id %d\n", i);
378 }
379 while (n--)
380 free(namelist[n]);
381 free(namelist);
382 }
383 closedir(dir);
384 k++;
385 }
386 return 0;
387 }
388
389
probe_thermal_sysfs(void)390 int probe_thermal_sysfs(void)
391 {
392 DIR *dir;
393 struct dirent **namelist;
394 int n;
395
396 dir = opendir(THERMAL_SYSFS);
397 if (!dir) {
398 fprintf(stderr, "\nNo thermal sysfs, exit\n");
399 return -1;
400 }
401 n = scandir(THERMAL_SYSFS, &namelist, 0, alphasort);
402 if (n < 0)
403 syslog(LOG_ERR, "scandir failed in thermal sysfs");
404 else {
405 /* detect number of thermal zones and cooling devices */
406 while (n--) {
407 int inst;
408
409 if (strstr(namelist[n]->d_name, CDEV)) {
410 inst = get_instance_id(namelist[n]->d_name, 1,
411 sizeof("device") - 1);
412 /* keep track of the max cooling device since
413 * there may be gaps.
414 */
415 if (inst > ptdata.max_cdev_instance)
416 ptdata.max_cdev_instance = inst;
417
418 syslog(LOG_DEBUG, "found cdev: %s %d %d\n",
419 namelist[n]->d_name,
420 ptdata.nr_cooling_dev,
421 ptdata.max_cdev_instance);
422 ptdata.nr_cooling_dev++;
423 } else if (strstr(namelist[n]->d_name, TZONE)) {
424 inst = get_instance_id(namelist[n]->d_name, 1,
425 sizeof("zone") - 1);
426 if (inst > ptdata.max_tz_instance)
427 ptdata.max_tz_instance = inst;
428
429 syslog(LOG_DEBUG, "found tzone: %s %d %d\n",
430 namelist[n]->d_name,
431 ptdata.nr_tz_sensor,
432 ptdata.max_tz_instance);
433 ptdata.nr_tz_sensor++;
434 }
435 free(namelist[n]);
436 }
437 free(namelist);
438 }
439 syslog(LOG_INFO, "found %d tzone(s), %d cdev(s), target zone %d\n",
440 ptdata.nr_tz_sensor, ptdata.nr_cooling_dev,
441 target_thermal_zone);
442 closedir(dir);
443
444 if (!ptdata.nr_tz_sensor) {
445 fprintf(stderr, "\nNo thermal zones found, exit\n\n");
446 return -1;
447 }
448
449 ptdata.tzi = calloc(ptdata.max_tz_instance+1, sizeof(struct tz_info));
450 if (!ptdata.tzi) {
451 fprintf(stderr, "Err: allocate tz_info\n");
452 return -1;
453 }
454
455 /* we still show thermal zone information if there is no cdev */
456 if (ptdata.nr_cooling_dev) {
457 ptdata.cdi = calloc(ptdata.max_cdev_instance + 1,
458 sizeof(struct cdev_info));
459 if (!ptdata.cdi) {
460 free(ptdata.tzi);
461 fprintf(stderr, "Err: allocate cdev_info\n");
462 return -1;
463 }
464 }
465
466 /* now probe tzones */
467 if (scan_tzones())
468 return -1;
469 if (scan_cdevs())
470 return -1;
471 return 0;
472 }
473
474 /* convert sysfs zone instance to zone array index */
zone_instance_to_index(int zone_inst)475 int zone_instance_to_index(int zone_inst)
476 {
477 int i;
478
479 for (i = 0; i < ptdata.nr_tz_sensor; i++)
480 if (ptdata.tzi[i].instance == zone_inst)
481 return i;
482 return -ENOENT;
483 }
484
485 /* read temperature of all thermal zones */
update_thermal_data()486 int update_thermal_data()
487 {
488 int i;
489 int next_thermal_record = cur_thermal_record + 1;
490 char tz_name[256];
491 static unsigned long samples;
492
493 if (!ptdata.nr_tz_sensor) {
494 syslog(LOG_ERR, "No thermal zones found!\n");
495 return -1;
496 }
497
498 /* circular buffer for keeping historic data */
499 if (next_thermal_record >= NR_THERMAL_RECORDS)
500 next_thermal_record = 0;
501 gettimeofday(&trec[next_thermal_record].tv, NULL);
502 if (tmon_log) {
503 fprintf(tmon_log, "%lu ", ++samples);
504 fprintf(tmon_log, "%3.1f ", p_param.t_target);
505 }
506 for (i = 0; i < ptdata.nr_tz_sensor; i++) {
507 memset(tz_name, 0, sizeof(tz_name));
508 snprintf(tz_name, 256, "%s/%s%d", THERMAL_SYSFS, TZONE,
509 ptdata.tzi[i].instance);
510 sysfs_get_ulong(tz_name, "temp",
511 &trec[next_thermal_record].temp[i]);
512 if (tmon_log)
513 fprintf(tmon_log, "%lu ",
514 trec[next_thermal_record].temp[i] / 1000);
515 }
516 cur_thermal_record = next_thermal_record;
517 for (i = 0; i < ptdata.nr_cooling_dev; i++) {
518 char cdev_name[256];
519 unsigned long val;
520
521 snprintf(cdev_name, 256, "%s/%s%d", THERMAL_SYSFS, CDEV,
522 ptdata.cdi[i].instance);
523 probe_cdev(&ptdata.cdi[i], cdev_name);
524 val = ptdata.cdi[i].cur_state;
525 if (val > 1000000)
526 val = 0;
527 if (tmon_log)
528 fprintf(tmon_log, "%lu ", val);
529 }
530
531 if (tmon_log) {
532 fprintf(tmon_log, "\n");
533 fflush(tmon_log);
534 }
535
536 return 0;
537 }
538
set_ctrl_state(unsigned long state)539 void set_ctrl_state(unsigned long state)
540 {
541 char ctrl_cdev_path[256];
542 int i;
543 unsigned long cdev_state;
544
545 if (no_control)
546 return;
547 /* set all ctrl cdev to the same state */
548 for (i = 0; i < ptdata.nr_cooling_dev; i++) {
549 if (ptdata.cdi[i].flag & CDEV_FLAG_IN_CONTROL) {
550 if (ptdata.cdi[i].max_state < 10) {
551 strcpy(ctrl_cdev, "None.");
552 return;
553 }
554 /* scale to percentage of max_state */
555 cdev_state = state * ptdata.cdi[i].max_state/100;
556 syslog(LOG_DEBUG,
557 "ctrl cdev %d set state %lu scaled to %lu\n",
558 ptdata.cdi[i].instance, state, cdev_state);
559 snprintf(ctrl_cdev_path, 256, "%s/%s%d", THERMAL_SYSFS,
560 CDEV, ptdata.cdi[i].instance);
561 syslog(LOG_DEBUG, "ctrl cdev path %s", ctrl_cdev_path);
562 sysfs_set_ulong(ctrl_cdev_path, "cur_state",
563 cdev_state);
564 }
565 }
566 }
567
get_ctrl_state(unsigned long * state)568 void get_ctrl_state(unsigned long *state)
569 {
570 char ctrl_cdev_path[256];
571 int ctrl_cdev_id = -1;
572 int i;
573
574 /* TODO: take average of all ctrl types. also consider change based on
575 * uevent. Take the first reading for now.
576 */
577 for (i = 0; i < ptdata.nr_cooling_dev; i++) {
578 if (ptdata.cdi[i].flag & CDEV_FLAG_IN_CONTROL) {
579 ctrl_cdev_id = ptdata.cdi[i].instance;
580 syslog(LOG_INFO, "ctrl cdev %d get state\n",
581 ptdata.cdi[i].instance);
582 break;
583 }
584 }
585 if (ctrl_cdev_id == -1) {
586 *state = 0;
587 return;
588 }
589 snprintf(ctrl_cdev_path, 256, "%s/%s%d", THERMAL_SYSFS,
590 CDEV, ctrl_cdev_id);
591 sysfs_get_ulong(ctrl_cdev_path, "cur_state", state);
592 }
593
free_thermal_data(void)594 void free_thermal_data(void)
595 {
596 free(ptdata.tzi);
597 free(ptdata.cdi);
598 }
599