Debian Codegraph @

prog/sensord/chips.c

raw
1 /*
2 * sensord
3 *
4 * A daemon that periodically logs sensor information to syslog.
5 *
6 * Copyright (c) 1999-2002 Merlin Hughes <[email protected]>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
21 * MA 02110-1301 USA.
22 */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "sensord.h"
29
30 /* TODO: Temp in C/F */
31
32 /** formatters **/
33
34 static char buff[4096];
35
36 static const char *fmtExtra(int alrm, int beep)
37 {
38 if (alrm)
39 sprintf(buff + strlen(buff), " [ALARM]");
40 if (beep)
41 sprintf(buff + strlen(buff), " (beep)");
42 return buff;
43 }
44
45 static const char *fmtTemps_1(const double values[], int alrm, int beep)
46 {
47 sprintf(buff, "%.1f C (limit = %.1f C, hysteresis = %.1f C)",
48 values[0], values[1], values[2]);
49 return fmtExtra(alrm, beep);
50 }
51
52 static const char *fmtTemps_minmax_1(const double values[], int alrm,
53 int beep) {
54 sprintf(buff, "%.1f C (min = %.1f C, max = %.1f C)", values[0],
55 values[1], values[2]);
56 return fmtExtra(alrm, beep);
57 }
58
59 static const char *fmtTemp_only(const double values[], int alrm, int beep)
60 {
61 sprintf(buff, "%.1f C", values[0]);
62 return fmtExtra(alrm, beep);
63 }
64
65 static const char *fmtVolt_2(const double values[], int alrm, int beep)
66 {
67 sprintf(buff, "%+.2f V", values[0]);
68 return fmtExtra(alrm, beep);
69 }
70
71 static const char *fmtVolt_3(const double values[], int alrm, int beep)
72 {
73 sprintf(buff, "%+.3f V", values[0]);
74 return fmtExtra(alrm, beep);
75 }
76
77 static const char *fmtVolts_2(const double values[], int alrm, int beep)
78 {
79 sprintf(buff, "%+.2f V (min = %+.2f V, max = %+.2f V)", values[0],
80 values[1], values[2]);
81 return fmtExtra(alrm, beep);
82 }
83
84 static const char *fmtFans_0(const double values[], int alrm, int beep)
85 {
86 sprintf(buff, "%.0f RPM (min = %.0f RPM, div = %.0f)", values[0],
87 values[1], values[2]);
88 return fmtExtra(alrm, beep);
89 }
90
91 static const char *fmtFans_nodiv_0(const double values[], int alrm, int beep)
92 {
93 sprintf(buff, "%.0f RPM (min = %.0f RPM)", values[0], values[1]);
94 return fmtExtra(alrm, beep);
95 }
96
97 static const char *fmtFan_only(const double values[], int alrm, int beep)
98 {
99 sprintf(buff, "%.0f RPM", values[0]);
100 return fmtExtra(alrm, beep);
101 }
102
103 static const char *fmtSoundAlarm(const double values[], int alrm, int beep)
104 {
105 sprintf(buff, "Sound alarm %s",
106 (values[0] < 0.5) ? "disabled" : "enabled");
107 return fmtExtra(alrm, beep);
108 }
109
110 static const char *rrdF0(const double values[])
111 {
112 sprintf(buff, "%.0f", values[0]);
113 return buff;
114 }
115
116 static const char *rrdF1(const double values[])
117 {
118 sprintf(buff, "%.1f", values[0]);
119 return buff;
120 }
121
122 static const char *rrdF2(const double values[])
123 {
124 sprintf(buff, "%.2f", values[0]);
125 return buff;
126 }
127
128 static const char *rrdF3(const double values[])
129 {
130 sprintf(buff, "%.3f", values[0]);
131 return buff;
132 }
133
134 static void fillChipVoltage(FeatureDescriptor *voltage,
135 const sensors_chip_name *name,
136 const sensors_feature *feature)
137 {
138 const sensors_subfeature *sf, *sfmin, *sfmax;
139 int pos = 0;
140
141 voltage->rrd = rrdF2;
142 voltage->type = DataType_voltage;
143
144 sf = sensors_get_subfeature(name, feature,
145 SENSORS_SUBFEATURE_IN_INPUT);
146 if (sf)
147 voltage->dataNumbers[pos++] = sf->number;
148
149 sfmin = sensors_get_subfeature(name, feature,
150 SENSORS_SUBFEATURE_IN_MIN);
151 sfmax = sensors_get_subfeature(name, feature,
152 SENSORS_SUBFEATURE_IN_MAX);
153 if (sfmin && sfmax) {
154 voltage->format = fmtVolts_2;
155 voltage->dataNumbers[pos++] = sfmin->number;
156 voltage->dataNumbers[pos++] = sfmax->number;
157 } else {
158 voltage->format = fmtVolt_2;
159 }
160
161 /* terminate the list */
162 voltage->dataNumbers[pos] = -1;
163
164 /* alarm if applicable */
165 if ((sf = sensors_get_subfeature(name, feature,
166 SENSORS_SUBFEATURE_IN_ALARM)) ||
167 (sf = sensors_get_subfeature(name, feature,
168 SENSORS_SUBFEATURE_IN_MIN_ALARM)) ||
169 (sf = sensors_get_subfeature(name, feature,
170 SENSORS_SUBFEATURE_IN_MAX_ALARM))) {
171 voltage->alarmNumber = sf->number;
172 } else {
173 voltage->alarmNumber = -1;
174 }
175 /* beep if applicable */
176 if ((sf = sensors_get_subfeature(name, feature,
177 SENSORS_SUBFEATURE_IN_BEEP))) {
178 voltage->beepNumber = sf->number;
179 } else {
180 voltage->beepNumber = -1;
181 }
182 }
183
184 static void fillChipTemperature(FeatureDescriptor *temperature,
185 const sensors_chip_name *name,
186 const sensors_feature *feature)
187 {
188 const sensors_subfeature *sf, *sfmin, *sfmax, *sfhyst;
189 int pos = 0;
190
191 temperature->rrd = rrdF1;
192 temperature->type = DataType_temperature;
193
194 sf = sensors_get_subfeature(name, feature,
195 SENSORS_SUBFEATURE_TEMP_INPUT);
196 if (sf)
197 temperature->dataNumbers[pos++] = sf->number;
198
199 sfmin = sensors_get_subfeature(name, feature,
200 SENSORS_SUBFEATURE_TEMP_MIN);
201 sfmax = sensors_get_subfeature(name, feature,
202 SENSORS_SUBFEATURE_TEMP_MAX);
203 sfhyst = sensors_get_subfeature(name, feature,
204 SENSORS_SUBFEATURE_TEMP_MAX_HYST);
205 if (sfmin && sfmax) {
206 temperature->format = fmtTemps_minmax_1;
207 temperature->dataNumbers[pos++] = sfmin->number;
208 temperature->dataNumbers[pos++] = sfmax->number;
209 } else if (sfmax && sfhyst) {
210 temperature->format = fmtTemps_1;
211 temperature->dataNumbers[pos++] = sfmax->number;
212 temperature->dataNumbers[pos++] = sfhyst->number;
213 } else {
214 temperature->format = fmtTemp_only;
215 }
216
217 /* terminate the list */
218 temperature->dataNumbers[pos] = -1;
219
220 /* alarm if applicable */
221 if ((sf = sensors_get_subfeature(name, feature,
222 SENSORS_SUBFEATURE_TEMP_ALARM)) ||
223 (sf = sensors_get_subfeature(name, feature,
224 SENSORS_SUBFEATURE_TEMP_MAX_ALARM)) ||
225 (sf = sensors_get_subfeature(name, feature,
226 SENSORS_SUBFEATURE_TEMP_EMERGENCY_ALARM))) {
227 temperature->alarmNumber = sf->number;
228 } else {
229 temperature->alarmNumber = -1;
230 }
231 /* beep if applicable */
232 if ((sf = sensors_get_subfeature(name, feature,
233 SENSORS_SUBFEATURE_TEMP_BEEP))) {
234 temperature->beepNumber = sf->number;
235 } else {
236 temperature->beepNumber = -1;
237 }
238 }
239
240 static void fillChipFan(FeatureDescriptor *fan,
241 const sensors_chip_name *name,
242 const sensors_feature *feature)
243 {
244 const sensors_subfeature *sf, *sfmin, *sfdiv;
245 int pos = 0;
246
247 fan->rrd = rrdF0;
248 fan->type = DataType_rpm;
249
250 sf = sensors_get_subfeature(name, feature,
251 SENSORS_SUBFEATURE_FAN_INPUT);
252 if (sf)
253 fan->dataNumbers[pos++] = sf->number;
254
255 sfmin = sensors_get_subfeature(name, feature,
256 SENSORS_SUBFEATURE_FAN_MIN);
257 if (sfmin) {
258 fan->dataNumbers[pos++] = sfmin->number;
259 sfdiv = sensors_get_subfeature(name, feature,
260 SENSORS_SUBFEATURE_FAN_DIV);
261 if (sfdiv) {
262 fan->format = fmtFans_0;
263 fan->dataNumbers[pos++] = sfdiv->number;
264 } else {
265 fan->format = fmtFans_nodiv_0;
266 }
267 } else {
268 fan->format = fmtFan_only;
269 }
270
271 /* terminate the list */
272 fan->dataNumbers[pos] = -1;
273
274 /* alarm if applicable */
275 sf = sensors_get_subfeature(name, feature,
276 SENSORS_SUBFEATURE_FAN_ALARM);
277 if (sf) {
278 fan->alarmNumber = sf->number;
279 } else {
280 fan->alarmNumber = -1;
281 }
282 /* beep if applicable */
283 sf = sensors_get_subfeature(name, feature,
284 SENSORS_SUBFEATURE_FAN_BEEP);
285 if (sf) {
286 fan->beepNumber = sf->number;
287 } else {
288 fan->beepNumber = -1;
289 }
290 }
291
292 static void fillChipVid(FeatureDescriptor *vid,
293 const sensors_chip_name *name,
294 const sensors_feature *feature)
295 {
296 const sensors_subfeature *sub;
297
298 sub = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_VID);
299 if (!sub)
300 return;
301
302 vid->format = fmtVolt_3;
303 vid->rrd = rrdF3;
304 vid->type = DataType_voltage;
305 vid->alarmNumber = -1;
306 vid->beepNumber = -1;
307 vid->dataNumbers[0] = sub->number;
308 vid->dataNumbers[1] = -1;
309 }
310
311 static void fillChipBeepEnable(FeatureDescriptor *beepen,
312 const sensors_chip_name *name,
313 const sensors_feature *feature)
314 {
315 const sensors_subfeature *sub;
316
317 sub = sensors_get_subfeature(name, feature,
318 SENSORS_SUBFEATURE_BEEP_ENABLE);
319 if (!sub)
320 return;
321
322 beepen->format = fmtSoundAlarm;
323 beepen->rrd = rrdF0;
324 beepen->type = DataType_other;
325 beepen->alarmNumber = -1;
326 beepen->beepNumber = -1;
327 beepen->dataNumbers[0] = sub->number;
328 beepen->dataNumbers[1] = -1;
329 }
330
331 static FeatureDescriptor * generateChipFeatures(const sensors_chip_name *chip)
332 {
333 int nr, count = 1;
334 const sensors_feature *sensor;
335 FeatureDescriptor *features;
336
337 /* How many main features do we have? */
338 nr = 0;
339 while ((sensor = sensors_get_features(chip, &nr)))
340 count++;
341
342 /* Allocate the memory we need */
343 features = calloc(count, sizeof(FeatureDescriptor));
344 if (!features)
345 return NULL;
346
347 /* Fill in the data structures */
348 count = 0;
349 nr = 0;
350 while ((sensor = sensors_get_features(chip, &nr))) {
351 switch (sensor->type) {
352 case SENSORS_FEATURE_TEMP:
353 fillChipTemperature(&features[count], chip, sensor);
354 break;
355 case SENSORS_FEATURE_IN:
356 fillChipVoltage(&features[count], chip, sensor);
357 break;
358 case SENSORS_FEATURE_FAN:
359 fillChipFan(&features[count], chip, sensor);
360 break;
361 case SENSORS_FEATURE_VID:
362 fillChipVid(&features[count], chip, sensor);
363 break;
364 case SENSORS_FEATURE_BEEP_ENABLE:
365 fillChipBeepEnable(&features[count], chip, sensor);
366 break;
367 default:
368 continue;
369 }
370
371 features[count].feature = sensor;
372 count++;
373 }
374
375 return features;
376 }
377
378 ChipDescriptor * knownChips;
379
380 int initKnownChips(void)
381 {
382 int nr, count = 1;
383 const sensors_chip_name *name;
384
385 /* How many chips do we have? */
386 nr = 0;
387 while ((name = sensors_get_detected_chips(NULL, &nr)))
388 count++;
389
390 /* Allocate the memory we need */
391 knownChips = calloc(count, sizeof(ChipDescriptor));
392 if (!knownChips)
393 return 1;
394
395 /* Fill in the data structures */
396 count = 0;
397 nr = 0;
398 while ((name = sensors_get_detected_chips(NULL, &nr))) {
399 knownChips[count].name = name;
400 if ((knownChips[count].features = generateChipFeatures(name)))
401 count++;
402 }
403
404 return 0;
405 }
406
407 void freeKnownChips(void)
408 {
409 int index0;
410
411 for (index0 = 0; knownChips[index0].features; index0++)
412 free(knownChips[index0].features);
413 free(knownChips);
414 }