qemu

1
/*
2
 * SMSC EMC141X temperature sensor.
3
 *
4
 * Copyright (c) 2020 Bytedance Corporation
5
 * Written by John Wang <wangzhiqiang.bj@bytedance.com>
6
 *
7
 * This program is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU General Public License as
9
 * published by the Free Software Foundation; either version 2 or
10
 * (at your option) version 3 of the License.
11
 *
12
 * This program is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 * GNU General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU General Public License along
18
 * with this program; if not, see <http://www.gnu.org/licenses/>.
19
 */
20

21
#include "qemu/osdep.h"
22
#include "hw/i2c/i2c.h"
23
#include "migration/vmstate.h"
24
#include "qapi/error.h"
25
#include "qapi/visitor.h"
26
#include "qemu/module.h"
27
#include "qom/object.h"
28
#include "hw/sensor/emc141x_regs.h"
29

30
#define SENSORS_COUNT_MAX    4
31

32
struct EMC141XState {
33
    I2CSlave parent_obj;
34
    struct {
35
        uint8_t raw_temp_min;
36
        uint8_t raw_temp_current;
37
        uint8_t raw_temp_max;
38
    } sensor[SENSORS_COUNT_MAX];
39
    uint8_t len;
40
    uint8_t data;
41
    uint8_t pointer;
42
};
43

44
struct EMC141XClass {
45
    I2CSlaveClass parent_class;
46
    uint8_t model;
47
    unsigned sensors_count;
48
};
49

50
#define TYPE_EMC141X "emc141x"
51
OBJECT_DECLARE_TYPE(EMC141XState, EMC141XClass, EMC141X)
52

53
static void emc141x_get_temperature(Object *obj, Visitor *v, const char *name,
54
                                    void *opaque, Error **errp)
55
{
56
    EMC141XState *s = EMC141X(obj);
57
    EMC141XClass *sc = EMC141X_GET_CLASS(s);
58
    int64_t value;
59
    unsigned tempid;
60

61
    if (sscanf(name, "temperature%u", &tempid) != 1) {
62
        error_setg(errp, "error reading %s: %s", name, g_strerror(errno));
63
        return;
64
    }
65

66
    if (tempid >= sc->sensors_count) {
67
        error_setg(errp, "error reading %s", name);
68
        return;
69
    }
70

71
    value = s->sensor[tempid].raw_temp_current * 1000;
72

73
    visit_type_int(v, name, &value, errp);
74
}
75

76
static void emc141x_set_temperature(Object *obj, Visitor *v, const char *name,
77
                                    void *opaque, Error **errp)
78
{
79
    EMC141XState *s = EMC141X(obj);
80
    EMC141XClass *sc = EMC141X_GET_CLASS(s);
81
    int64_t temp;
82
    unsigned tempid;
83

84
    if (!visit_type_int(v, name, &temp, errp)) {
85
        return;
86
    }
87

88
    if (sscanf(name, "temperature%u", &tempid) != 1) {
89
        error_setg(errp, "error reading %s: %s", name, g_strerror(errno));
90
        return;
91
    }
92

93
    if (tempid >= sc->sensors_count) {
94
        error_setg(errp, "error reading %s", name);
95
        return;
96
    }
97

98
    s->sensor[tempid].raw_temp_current = temp / 1000;
99
}
100

101
static void emc141x_read(EMC141XState *s)
102
{
103
    EMC141XClass *sc = EMC141X_GET_CLASS(s);
104
    switch (s->pointer) {
105
    case EMC141X_DEVICE_ID:
106
        s->data = sc->model;
107
        break;
108
    case EMC141X_MANUFACTURER_ID:
109
        s->data = MANUFACTURER_ID;
110
        break;
111
    case EMC141X_REVISION:
112
        s->data = REVISION;
113
        break;
114
    case EMC141X_TEMP_HIGH0:
115
        s->data = s->sensor[0].raw_temp_current;
116
        break;
117
    case EMC141X_TEMP_HIGH1:
118
        s->data = s->sensor[1].raw_temp_current;
119
        break;
120
    case EMC141X_TEMP_HIGH2:
121
        s->data = s->sensor[2].raw_temp_current;
122
        break;
123
    case EMC141X_TEMP_HIGH3:
124
        s->data = s->sensor[3].raw_temp_current;
125
        break;
126
    case EMC141X_TEMP_MAX_HIGH0:
127
        s->data = s->sensor[0].raw_temp_max;
128
        break;
129
    case EMC141X_TEMP_MAX_HIGH1:
130
        s->data = s->sensor[1].raw_temp_max;
131
        break;
132
    case EMC141X_TEMP_MAX_HIGH2:
133
        s->data = s->sensor[2].raw_temp_max;
134
        break;
135
    case EMC141X_TEMP_MAX_HIGH3:
136
        s->data = s->sensor[3].raw_temp_max;
137
        break;
138
    case EMC141X_TEMP_MIN_HIGH0:
139
        s->data = s->sensor[0].raw_temp_min;
140
        break;
141
    case EMC141X_TEMP_MIN_HIGH1:
142
        s->data = s->sensor[1].raw_temp_min;
143
        break;
144
    case EMC141X_TEMP_MIN_HIGH2:
145
        s->data = s->sensor[2].raw_temp_min;
146
        break;
147
    case EMC141X_TEMP_MIN_HIGH3:
148
        s->data = s->sensor[3].raw_temp_min;
149
        break;
150
    default:
151
        s->data = 0;
152
    }
153
}
154

155
static void emc141x_write(EMC141XState *s)
156
{
157
    switch (s->pointer) {
158
    case EMC141X_TEMP_MAX_HIGH0:
159
        s->sensor[0].raw_temp_max = s->data;
160
        break;
161
    case EMC141X_TEMP_MAX_HIGH1:
162
        s->sensor[1].raw_temp_max = s->data;
163
        break;
164
    case EMC141X_TEMP_MAX_HIGH2:
165
        s->sensor[2].raw_temp_max = s->data;
166
        break;
167
    case EMC141X_TEMP_MAX_HIGH3:
168
        s->sensor[3].raw_temp_max = s->data;
169
        break;
170
    case EMC141X_TEMP_MIN_HIGH0:
171
        s->sensor[0].raw_temp_min = s->data;
172
        break;
173
    case EMC141X_TEMP_MIN_HIGH1:
174
        s->sensor[1].raw_temp_min = s->data;
175
        break;
176
    case EMC141X_TEMP_MIN_HIGH2:
177
        s->sensor[2].raw_temp_min = s->data;
178
        break;
179
    case EMC141X_TEMP_MIN_HIGH3:
180
        s->sensor[3].raw_temp_min = s->data;
181
        break;
182
    default:
183
        s->data = 0;
184
    }
185
}
186

187
static uint8_t emc141x_rx(I2CSlave *i2c)
188
{
189
    EMC141XState *s = EMC141X(i2c);
190

191
    if (s->len == 0) {
192
        s->len++;
193
        return s->data;
194
    } else {
195
        return 0xff;
196
    }
197
}
198

199
static int emc141x_tx(I2CSlave *i2c, uint8_t data)
200
{
201
    EMC141XState *s = EMC141X(i2c);
202

203
    if (s->len == 0) {
204
        /* first byte is the reg pointer */
205
        s->pointer = data;
206
        s->len++;
207
    } else if (s->len == 1) {
208
        s->data = data;
209
        emc141x_write(s);
210
    }
211

212
    return 0;
213
}
214

215
static int emc141x_event(I2CSlave *i2c, enum i2c_event event)
216
{
217
    EMC141XState *s = EMC141X(i2c);
218

219
    if (event == I2C_START_RECV) {
220
        emc141x_read(s);
221
    }
222

223
    s->len = 0;
224
    return 0;
225
}
226

227
static const VMStateDescription vmstate_emc141x = {
228
    .name = "EMC141X",
229
    .version_id = 0,
230
    .minimum_version_id = 0,
231
    .fields = (const VMStateField[]) {
232
        VMSTATE_UINT8(len, EMC141XState),
233
        VMSTATE_UINT8(data, EMC141XState),
234
        VMSTATE_UINT8(pointer, EMC141XState),
235
        VMSTATE_I2C_SLAVE(parent_obj, EMC141XState),
236
        VMSTATE_END_OF_LIST()
237
    }
238
};
239

240
static void emc141x_reset(DeviceState *dev)
241
{
242
    EMC141XState *s = EMC141X(dev);
243
    int i;
244

245
    for (i = 0; i < SENSORS_COUNT_MAX; i++) {
246
        s->sensor[i].raw_temp_max = 0x55;
247
    }
248
    s->pointer = 0;
249
    s->len = 0;
250
}
251

252
static void emc141x_initfn(Object *obj)
253
{
254
    object_property_add(obj, "temperature0", "int",
255
                        emc141x_get_temperature,
256
                        emc141x_set_temperature, NULL, NULL);
257
    object_property_add(obj, "temperature1", "int",
258
                        emc141x_get_temperature,
259
                        emc141x_set_temperature, NULL, NULL);
260
    object_property_add(obj, "temperature2", "int",
261
                        emc141x_get_temperature,
262
                        emc141x_set_temperature, NULL, NULL);
263
    object_property_add(obj, "temperature3", "int",
264
                        emc141x_get_temperature,
265
                        emc141x_set_temperature, NULL, NULL);
266
}
267

268
static void emc141x_class_init(ObjectClass *klass, void *data)
269
{
270
    DeviceClass *dc = DEVICE_CLASS(klass);
271
    I2CSlaveClass *k = I2C_SLAVE_CLASS(klass);
272

273
    dc->reset = emc141x_reset;
274
    k->event = emc141x_event;
275
    k->recv = emc141x_rx;
276
    k->send = emc141x_tx;
277
    dc->vmsd = &vmstate_emc141x;
278
}
279

280
static void emc1413_class_init(ObjectClass *klass, void *data)
281
{
282
    EMC141XClass *ec = EMC141X_CLASS(klass);
283

284
    emc141x_class_init(klass, data);
285
    ec->model = EMC1413_DEVICE_ID;
286
    ec->sensors_count = 3;
287
}
288

289
static void emc1414_class_init(ObjectClass *klass, void *data)
290
{
291
    EMC141XClass *ec = EMC141X_CLASS(klass);
292

293
    emc141x_class_init(klass, data);
294
    ec->model = EMC1414_DEVICE_ID;
295
    ec->sensors_count = 4;
296
}
297

298
static const TypeInfo emc141x_info = {
299
    .name          = TYPE_EMC141X,
300
    .parent        = TYPE_I2C_SLAVE,
301
    .instance_size = sizeof(EMC141XState),
302
    .class_size    = sizeof(EMC141XClass),
303
    .instance_init = emc141x_initfn,
304
    .abstract      = true,
305
};
306

307
static const TypeInfo emc1413_info = {
308
    .name          = "emc1413",
309
    .parent        = TYPE_EMC141X,
310
    .class_init    = emc1413_class_init,
311
};
312

313
static const TypeInfo emc1414_info = {
314
    .name          = "emc1414",
315
    .parent        = TYPE_EMC141X,
316
    .class_init    = emc1414_class_init,
317
};
318

319
static void emc141x_register_types(void)
320
{
321
    type_register_static(&emc141x_info);
322
    type_register_static(&emc1413_info);
323
    type_register_static(&emc1414_info);
324
}
325

326
type_init(emc141x_register_types)
327