← Back to branch summary

~jfi/ubuntu/quantal/psensor/new-upstream

« back to all changes in this revision

Viewing changes to src/lib/lmsensor.c

  • Committer: Bazaar Package Importer
  • Author(s): Jean-Philippe Orsini
  • Date: 2011-02-20 15:15:30 UTC
  • Revision ID: james.westby@ubuntu.com-20110220151530-5xzhb3o39yaegrn0
Tags: upstream-0.6.1.5
Import upstream version 0.6.1.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib/lmsensor.c
 
1
/*
 
2
    Copyright (C) 2010-2011 wpitchoune@gmail.com
 
3
 
 
4
    This program is free software; you can redistribute it and/or modify
 
5
    it under the terms of the GNU General Public License as published by
 
6
    the Free Software Foundation; either version 2 of the License, or
 
7
    (at your option) any later version.
 
8
 
 
9
    This program is distributed in the hope that it will be useful,
 
10
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
    GNU General Public License for more details.
 
13
 
 
14
    You should have received a copy of the GNU General Public License
 
15
    along with this program; if not, write to the Free Software
 
16
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 
17
    02110-1301 USA
 
18
*/
 
19
 
 
20
#include <locale.h>
 
21
#include <libintl.h>
 
22
#define _(str) gettext(str)
 
23
 
 
24
#include <stdio.h>
 
25
#include <stdlib.h>
 
26
#include <string.h>
 
27
 
 
28
#include <sensors/sensors.h>
 
29
#include <sensors/error.h>
 
30
 
 
31
#include "psensor.h"
 
32
 
 
33
double
 
34
lmsensor_get_value(const sensors_chip_name *name,
 
35
                   const sensors_subfeature *sub)
 
36
{
 
37
        double val;
 
38
        int err;
 
39
 
 
40
        err = sensors_get_value(name, sub->number, &val);
 
41
        if (err) {
 
42
                fprintf(stderr,
 
43
                        _("ERROR: Can't get value of subfeature %s: %s\n"),
 
44
                        sub->name, sensors_strerror(err));
 
45
                val = 0.0;
 
46
        }
 
47
        return val;
 
48
}
 
49
 
 
50
double lmsensor_get_temp_input(struct psensor *sensor)
 
51
{
 
52
        const sensors_chip_name *chip = sensor->iname;
 
53
        const sensors_feature *feature = sensor->feature;
 
54
 
 
55
        const sensors_subfeature *sf;
 
56
 
 
57
        sf = sensors_get_subfeature(chip,
 
58
                                    feature, SENSORS_SUBFEATURE_TEMP_INPUT);
 
59
        if (sf) {
 
60
                double val = lmsensor_get_value(chip, sf);
 
61
                if (val < 0.0)
 
62
                        return 0.0;
 
63
                else
 
64
                        return val;
 
65
        } else {
 
66
                return 0.0;
 
67
        }
 
68
}
 
69
 
 
70
double lmsensor_get_fan_input(struct psensor *sensor)
 
71
{
 
72
        const sensors_chip_name *chip = sensor->iname;
 
73
        const sensors_feature *feature = sensor->feature;
 
74
 
 
75
        const sensors_subfeature *sf;
 
76
 
 
77
        sf = sensors_get_subfeature(chip,
 
78
                                    feature, SENSORS_SUBFEATURE_FAN_INPUT);
 
79
        if (sf)
 
80
                return lmsensor_get_value(chip, sf);
 
81
        else
 
82
                return 0;
 
83
}
 
84
 
 
85
void lmsensor_psensor_list_update(struct psensor **sensors)
 
86
{
 
87
        struct psensor **s_ptr = sensors;
 
88
 
 
89
        while (*s_ptr) {
 
90
                struct psensor *sensor = *s_ptr;
 
91
 
 
92
                if (sensor->type == SENSOR_TYPE_LMSENSOR_TEMP)
 
93
                        psensor_set_current_value
 
94
                            (sensor, lmsensor_get_temp_input(sensor));
 
95
                else if (sensor->type == SENSOR_TYPE_LMSENSOR_FAN)
 
96
                        psensor_set_current_value
 
97
                            (sensor, lmsensor_get_fan_input(sensor));
 
98
 
 
99
                s_ptr++;
 
100
        }
 
101
}
 
102
 
 
103
struct psensor *
 
104
lmsensor_psensor_create(const sensors_chip_name *chip,
 
105
                        const sensors_feature *feature,
 
106
                        int values_max_length)
 
107
{
 
108
        char name[200];
 
109
        const sensors_subfeature *sf;
 
110
        char *label;
 
111
        int type;
 
112
        char *id;
 
113
        struct psensor *psensor;
 
114
        sensors_subfeature_type fault_subfeature;
 
115
 
 
116
        if (sensors_snprintf_chip_name(name, 200, chip) < 0)
 
117
                return NULL;
 
118
 
 
119
        if (feature->type == SENSORS_FEATURE_TEMP) {
 
120
                fault_subfeature = SENSORS_SUBFEATURE_TEMP_FAULT;
 
121
 
 
122
        } else if (feature->type == SENSORS_FEATURE_FAN) {
 
123
                fault_subfeature = SENSORS_SUBFEATURE_FAN_FAULT;
 
124
 
 
125
        } else {
 
126
                fprintf(stderr,
 
127
                        _("ERROR: create_sensor, wrong feature type\n"));
 
128
                return NULL;
 
129
        }
 
130
 
 
131
        sf = sensors_get_subfeature(chip, feature, fault_subfeature);
 
132
        if (sf && lmsensor_get_value(chip, sf))
 
133
                return NULL;
 
134
 
 
135
        label = sensors_get_label(chip, feature);
 
136
        if (!label)
 
137
                return NULL;
 
138
 
 
139
        type = 0;
 
140
        if (feature->type == SENSORS_FEATURE_TEMP)
 
141
                type = SENSOR_TYPE_LMSENSOR_TEMP;
 
142
        else if (feature->type == SENSORS_FEATURE_FAN)
 
143
                type = SENSOR_TYPE_LMSENSOR_FAN;
 
144
        else
 
145
                return NULL;
 
146
 
 
147
        id = malloc(strlen("lmsensor ") + 1 + strlen(name) + 1 + strlen(label) +
 
148
                    1);
 
149
        sprintf(id, "lmsensor %s %s", name, label);
 
150
 
 
151
        psensor = psensor_create(id, strdup(label), type, values_max_length);
 
152
 
 
153
        psensor->iname = chip;
 
154
        psensor->feature = feature;
 
155
 
 
156
        if (feature->type == SENSORS_FEATURE_TEMP
 
157
            && (lmsensor_get_temp_input(psensor) <= 0.0)) {
 
158
                free(psensor);
 
159
                return NULL;
 
160
        }
 
161
 
 
162
        return psensor;
 
163
}
 
164
 
 
165
int lmsensor_init()
 
166
{
 
167
        int err = sensors_init(NULL);
 
168
 
 
169
        if (err) {
 
170
                fprintf(stderr,
 
171
                        _("ERROR: lm-sensors initialization failure: %s\n"),
 
172
                        sensors_strerror(err));
 
173
                return 0;
 
174
        } else {
 
175
                return 1;
 
176
        }
 
177
}