1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include "qemu/osdep.h"
22#include "hw/hw.h"
23#include "hw/i2c/i2c.h"
24#include "tmp105.h"
25#include "qapi/error.h"
26#include "qapi/visitor.h"
27#include "qemu/module.h"
28
29static void tmp105_interrupt_update(TMP105State *s)
30{
31 qemu_set_irq(s->pin, s->alarm ^ ((~s->config >> 2) & 1));
32}
33
34static void tmp105_alarm_update(TMP105State *s)
35{
36 if ((s->config >> 0) & 1) {
37 if ((s->config >> 7) & 1)
38 s->config &= ~(1 << 7);
39 else
40 return;
41 }
42
43 if ((s->config >> 1) & 1) {
44 if (s->temperature >= s->limit[1])
45 s->alarm = 1;
46 else if (s->temperature < s->limit[0])
47 s->alarm = 1;
48 } else {
49 if (s->temperature >= s->limit[1])
50 s->alarm = 1;
51 else if (s->temperature < s->limit[0])
52 s->alarm = 0;
53 }
54
55 tmp105_interrupt_update(s);
56}
57
58static void tmp105_get_temperature(Object *obj, Visitor *v, const char *name,
59 void *opaque, Error **errp)
60{
61 TMP105State *s = TMP105(obj);
62 int64_t value = s->temperature * 1000 / 256;
63
64 visit_type_int(v, name, &value, errp);
65}
66
67
68
69
70static void tmp105_set_temperature(Object *obj, Visitor *v, const char *name,
71 void *opaque, Error **errp)
72{
73 TMP105State *s = TMP105(obj);
74 Error *local_err = NULL;
75 int64_t temp;
76
77 visit_type_int(v, name, &temp, &local_err);
78 if (local_err) {
79 error_propagate(errp, local_err);
80 return;
81 }
82 if (temp >= 128000 || temp < -128000) {
83 error_setg(errp, "value %" PRId64 ".%03" PRIu64 " C is out of range",
84 temp / 1000, temp % 1000);
85 return;
86 }
87
88 s->temperature = (int16_t) (temp * 256 / 1000);
89
90 tmp105_alarm_update(s);
91}
92
93static const int tmp105_faultq[4] = { 1, 2, 4, 6 };
94
95static void tmp105_read(TMP105State *s)
96{
97 s->len = 0;
98
99 if ((s->config >> 1) & 1) {
100 s->alarm = 0;
101 tmp105_interrupt_update(s);
102 }
103
104 switch (s->pointer & 3) {
105 case TMP105_REG_TEMPERATURE:
106 s->buf[s->len ++] = (((uint16_t) s->temperature) >> 8);
107 s->buf[s->len ++] = (((uint16_t) s->temperature) >> 0) &
108 (0xf0 << ((~s->config >> 5) & 3));
109 break;
110
111 case TMP105_REG_CONFIG:
112 s->buf[s->len ++] = s->config;
113 break;
114
115 case TMP105_REG_T_LOW:
116 s->buf[s->len ++] = ((uint16_t) s->limit[0]) >> 8;
117 s->buf[s->len ++] = ((uint16_t) s->limit[0]) >> 0;
118 break;
119
120 case TMP105_REG_T_HIGH:
121 s->buf[s->len ++] = ((uint16_t) s->limit[1]) >> 8;
122 s->buf[s->len ++] = ((uint16_t) s->limit[1]) >> 0;
123 break;
124 }
125}
126
127static void tmp105_write(TMP105State *s)
128{
129 switch (s->pointer & 3) {
130 case TMP105_REG_TEMPERATURE:
131 break;
132
133 case TMP105_REG_CONFIG:
134 if (s->buf[0] & ~s->config & (1 << 0))
135 printf("%s: TMP105 shutdown\n", __func__);
136 s->config = s->buf[0];
137 s->faults = tmp105_faultq[(s->config >> 3) & 3];
138 tmp105_alarm_update(s);
139 break;
140
141 case TMP105_REG_T_LOW:
142 case TMP105_REG_T_HIGH:
143 if (s->len >= 3)
144 s->limit[s->pointer & 1] = (int16_t)
145 ((((uint16_t) s->buf[0]) << 8) | s->buf[1]);
146 tmp105_alarm_update(s);
147 break;
148 }
149}
150
151static uint8_t tmp105_rx(I2CSlave *i2c)
152{
153 TMP105State *s = TMP105(i2c);
154
155 if (s->len < 2) {
156 return s->buf[s->len ++];
157 } else {
158 return 0xff;
159 }
160}
161
162static int tmp105_tx(I2CSlave *i2c, uint8_t data)
163{
164 TMP105State *s = TMP105(i2c);
165
166 if (s->len == 0) {
167 s->pointer = data;
168 s->len++;
169 } else {
170 if (s->len <= 2) {
171 s->buf[s->len - 1] = data;
172 }
173 s->len++;
174 tmp105_write(s);
175 }
176
177 return 0;
178}
179
180static int tmp105_event(I2CSlave *i2c, enum i2c_event event)
181{
182 TMP105State *s = TMP105(i2c);
183
184 if (event == I2C_START_RECV) {
185 tmp105_read(s);
186 }
187
188 s->len = 0;
189 return 0;
190}
191
192static int tmp105_post_load(void *opaque, int version_id)
193{
194 TMP105State *s = opaque;
195
196 s->faults = tmp105_faultq[(s->config >> 3) & 3];
197
198 tmp105_interrupt_update(s);
199 return 0;
200}
201
202static const VMStateDescription vmstate_tmp105 = {
203 .name = "TMP105",
204 .version_id = 0,
205 .minimum_version_id = 0,
206 .post_load = tmp105_post_load,
207 .fields = (VMStateField[]) {
208 VMSTATE_UINT8(len, TMP105State),
209 VMSTATE_UINT8_ARRAY(buf, TMP105State, 2),
210 VMSTATE_UINT8(pointer, TMP105State),
211 VMSTATE_UINT8(config, TMP105State),
212 VMSTATE_INT16(temperature, TMP105State),
213 VMSTATE_INT16_ARRAY(limit, TMP105State, 2),
214 VMSTATE_UINT8(alarm, TMP105State),
215 VMSTATE_I2C_SLAVE(i2c, TMP105State),
216 VMSTATE_END_OF_LIST()
217 }
218};
219
220static void tmp105_reset(I2CSlave *i2c)
221{
222 TMP105State *s = TMP105(i2c);
223
224 s->temperature = 0;
225 s->pointer = 0;
226 s->config = 0;
227 s->faults = tmp105_faultq[(s->config >> 3) & 3];
228 s->alarm = 0;
229
230 tmp105_interrupt_update(s);
231}
232
233static void tmp105_realize(DeviceState *dev, Error **errp)
234{
235 I2CSlave *i2c = I2C_SLAVE(dev);
236 TMP105State *s = TMP105(i2c);
237
238 qdev_init_gpio_out(&i2c->qdev, &s->pin, 1);
239
240 tmp105_reset(&s->i2c);
241}
242
243static void tmp105_initfn(Object *obj)
244{
245 object_property_add(obj, "temperature", "int",
246 tmp105_get_temperature,
247 tmp105_set_temperature, NULL, NULL, NULL);
248}
249
250static void tmp105_class_init(ObjectClass *klass, void *data)
251{
252 DeviceClass *dc = DEVICE_CLASS(klass);
253 I2CSlaveClass *k = I2C_SLAVE_CLASS(klass);
254
255 dc->realize = tmp105_realize;
256 k->event = tmp105_event;
257 k->recv = tmp105_rx;
258 k->send = tmp105_tx;
259 dc->vmsd = &vmstate_tmp105;
260}
261
262static const TypeInfo tmp105_info = {
263 .name = TYPE_TMP105,
264 .parent = TYPE_I2C_SLAVE,
265 .instance_size = sizeof(TMP105State),
266 .instance_init = tmp105_initfn,
267 .class_init = tmp105_class_init,
268};
269
270static void tmp105_register_types(void)
271{
272 type_register_static(&tmp105_info);
273}
274
275type_init(tmp105_register_types)
276
