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