1
2
3
4
5
6
7
8
9
10
11
12#include "qemu/osdep.h"
13#include "hw/hw.h"
14#include "hw/i2c/i2c.h"
15#include "hw/i2c/smbus.h"
16
17
18
19#ifdef DEBUG_SMBUS
20#define DPRINTF(fmt, ...) \
21do { printf("smbus(%02x): " fmt , dev->i2c.address, ## __VA_ARGS__); } while (0)
22#define BADF(fmt, ...) \
23do { fprintf(stderr, "smbus: error: " fmt , ## __VA_ARGS__); exit(1);} while (0)
24#else
25#define DPRINTF(fmt, ...) do {} while(0)
26#define BADF(fmt, ...) \
27do { fprintf(stderr, "smbus: error: " fmt , ## __VA_ARGS__);} while (0)
28#endif
29
30enum {
31 SMBUS_IDLE,
32 SMBUS_WRITE_DATA,
33 SMBUS_RECV_BYTE,
34 SMBUS_READ_DATA,
35 SMBUS_DONE,
36 SMBUS_CONFUSED = -1
37};
38
39static void smbus_do_quick_cmd(SMBusDevice *dev, int recv)
40{
41 SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev);
42
43 DPRINTF("Quick Command %d\n", recv);
44 if (sc->quick_cmd) {
45 sc->quick_cmd(dev, recv);
46 }
47}
48
49static void smbus_do_write(SMBusDevice *dev)
50{
51 SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev);
52
53 if (dev->data_len == 0) {
54 smbus_do_quick_cmd(dev, 0);
55 } else if (dev->data_len == 1) {
56 DPRINTF("Send Byte\n");
57 if (sc->send_byte) {
58 sc->send_byte(dev, dev->data_buf[0]);
59 }
60 } else {
61 dev->command = dev->data_buf[0];
62 DPRINTF("Command %d len %d\n", dev->command, dev->data_len - 1);
63 if (sc->write_data) {
64 sc->write_data(dev, dev->command, dev->data_buf + 1,
65 dev->data_len - 1);
66 }
67 }
68}
69
70static void smbus_i2c_event(I2CSlave *s, enum i2c_event event)
71{
72 SMBusDevice *dev = SMBUS_DEVICE(s);
73
74 switch (event) {
75 case I2C_START_SEND:
76 switch (dev->mode) {
77 case SMBUS_IDLE:
78 DPRINTF("Incoming data\n");
79 dev->mode = SMBUS_WRITE_DATA;
80 break;
81 default:
82 BADF("Unexpected send start condition in state %d\n", dev->mode);
83 dev->mode = SMBUS_CONFUSED;
84 break;
85 }
86 break;
87
88 case I2C_START_RECV:
89 switch (dev->mode) {
90 case SMBUS_IDLE:
91 DPRINTF("Read mode\n");
92 dev->mode = SMBUS_RECV_BYTE;
93 break;
94 case SMBUS_WRITE_DATA:
95 if (dev->data_len == 0) {
96 BADF("Read after write with no data\n");
97 dev->mode = SMBUS_CONFUSED;
98 } else {
99 if (dev->data_len > 1) {
100 smbus_do_write(dev);
101 } else {
102 dev->command = dev->data_buf[0];
103 DPRINTF("%02x: Command %d\n", dev->i2c.address,
104 dev->command);
105 }
106 DPRINTF("Read mode\n");
107 dev->data_len = 0;
108 dev->mode = SMBUS_READ_DATA;
109 }
110 break;
111 default:
112 BADF("Unexpected recv start condition in state %d\n", dev->mode);
113 dev->mode = SMBUS_CONFUSED;
114 break;
115 }
116 break;
117
118 case I2C_FINISH:
119 switch (dev->mode) {
120 case SMBUS_WRITE_DATA:
121 smbus_do_write(dev);
122 break;
123 case SMBUS_RECV_BYTE:
124 smbus_do_quick_cmd(dev, 1);
125 break;
126 case SMBUS_READ_DATA:
127 BADF("Unexpected stop during receive\n");
128 break;
129 default:
130
131 break;
132 }
133 dev->mode = SMBUS_IDLE;
134 dev->data_len = 0;
135 break;
136
137 case I2C_NACK:
138 switch (dev->mode) {
139 case SMBUS_DONE:
140
141 break;
142 case SMBUS_READ_DATA:
143 dev->mode = SMBUS_DONE;
144 break;
145 default:
146 BADF("Unexpected NACK in state %d\n", dev->mode);
147 dev->mode = SMBUS_CONFUSED;
148 break;
149 }
150 }
151}
152
153static int smbus_i2c_recv(I2CSlave *s)
154{
155 SMBusDevice *dev = SMBUS_DEVICE(s);
156 SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev);
157 int ret;
158
159 switch (dev->mode) {
160 case SMBUS_RECV_BYTE:
161 if (sc->receive_byte) {
162 ret = sc->receive_byte(dev);
163 } else {
164 ret = 0;
165 }
166 DPRINTF("Receive Byte %02x\n", ret);
167 dev->mode = SMBUS_DONE;
168 break;
169 case SMBUS_READ_DATA:
170 if (sc->read_data) {
171 ret = sc->read_data(dev, dev->command, dev->data_len);
172 dev->data_len++;
173 } else {
174 ret = 0;
175 }
176 DPRINTF("Read data %02x\n", ret);
177 break;
178 default:
179 BADF("Unexpected read in state %d\n", dev->mode);
180 dev->mode = SMBUS_CONFUSED;
181 ret = 0;
182 break;
183 }
184 return ret;
185}
186
187static int smbus_i2c_send(I2CSlave *s, uint8_t data)
188{
189 SMBusDevice *dev = SMBUS_DEVICE(s);
190
191 switch (dev->mode) {
192 case SMBUS_WRITE_DATA:
193 DPRINTF("Write data %02x\n", data);
194 dev->data_buf[dev->data_len++] = data;
195 break;
196 default:
197 BADF("Unexpected write in state %d\n", dev->mode);
198 break;
199 }
200 return 0;
201}
202
203static int smbus_device_init(I2CSlave *i2c)
204{
205 SMBusDevice *dev = SMBUS_DEVICE(i2c);
206 SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev);
207
208 return sc->init(dev);
209}
210
211
212int smbus_quick_command(I2CBus *bus, uint8_t addr, int read)
213{
214 if (i2c_start_transfer(bus, addr, read)) {
215 return -1;
216 }
217 i2c_end_transfer(bus);
218 return 0;
219}
220
221int smbus_receive_byte(I2CBus *bus, uint8_t addr)
222{
223 uint8_t data;
224
225 if (i2c_start_transfer(bus, addr, 1)) {
226 return -1;
227 }
228 data = i2c_recv(bus);
229 i2c_nack(bus);
230 i2c_end_transfer(bus);
231 return data;
232}
233
234int smbus_send_byte(I2CBus *bus, uint8_t addr, uint8_t data)
235{
236 if (i2c_start_transfer(bus, addr, 0)) {
237 return -1;
238 }
239 i2c_send(bus, data);
240 i2c_end_transfer(bus);
241 return 0;
242}
243
244int smbus_read_byte(I2CBus *bus, uint8_t addr, uint8_t command)
245{
246 uint8_t data;
247 if (i2c_start_transfer(bus, addr, 0)) {
248 return -1;
249 }
250 i2c_send(bus, command);
251 if (i2c_start_transfer(bus, addr, 1)) {
252 assert(0);
253 }
254 data = i2c_recv(bus);
255 i2c_nack(bus);
256 i2c_end_transfer(bus);
257 return data;
258}
259
260int smbus_write_byte(I2CBus *bus, uint8_t addr, uint8_t command, uint8_t data)
261{
262 if (i2c_start_transfer(bus, addr, 0)) {
263 return -1;
264 }
265 i2c_send(bus, command);
266 i2c_send(bus, data);
267 i2c_end_transfer(bus);
268 return 0;
269}
270
271int smbus_read_word(I2CBus *bus, uint8_t addr, uint8_t command)
272{
273 uint16_t data;
274 if (i2c_start_transfer(bus, addr, 0)) {
275 return -1;
276 }
277 i2c_send(bus, command);
278 if (i2c_start_transfer(bus, addr, 1)) {
279 assert(0);
280 }
281 data = i2c_recv(bus);
282 data |= i2c_recv(bus) << 8;
283 i2c_nack(bus);
284 i2c_end_transfer(bus);
285 return data;
286}
287
288int smbus_write_word(I2CBus *bus, uint8_t addr, uint8_t command, uint16_t data)
289{
290 if (i2c_start_transfer(bus, addr, 0)) {
291 return -1;
292 }
293 i2c_send(bus, command);
294 i2c_send(bus, data & 0xff);
295 i2c_send(bus, data >> 8);
296 i2c_end_transfer(bus);
297 return 0;
298}
299
300int smbus_read_block(I2CBus *bus, uint8_t addr, uint8_t command, uint8_t *data)
301{
302 int len;
303 int i;
304
305 if (i2c_start_transfer(bus, addr, 0)) {
306 return -1;
307 }
308 i2c_send(bus, command);
309 if (i2c_start_transfer(bus, addr, 1)) {
310 assert(0);
311 }
312 len = i2c_recv(bus);
313 if (len > 32) {
314 len = 0;
315 }
316 for (i = 0; i < len; i++) {
317 data[i] = i2c_recv(bus);
318 }
319 i2c_nack(bus);
320 i2c_end_transfer(bus);
321 return len;
322}
323
324int smbus_write_block(I2CBus *bus, uint8_t addr, uint8_t command, uint8_t *data,
325 int len)
326{
327 int i;
328
329 if (len > 32)
330 len = 32;
331
332 if (i2c_start_transfer(bus, addr, 0)) {
333 return -1;
334 }
335 i2c_send(bus, command);
336 i2c_send(bus, len);
337 for (i = 0; i < len; i++) {
338 i2c_send(bus, data[i]);
339 }
340 i2c_end_transfer(bus);
341 return 0;
342}
343
344static void smbus_device_class_init(ObjectClass *klass, void *data)
345{
346 I2CSlaveClass *sc = I2C_SLAVE_CLASS(klass);
347
348 sc->init = smbus_device_init;
349 sc->event = smbus_i2c_event;
350 sc->recv = smbus_i2c_recv;
351 sc->send = smbus_i2c_send;
352}
353
354static const TypeInfo smbus_device_type_info = {
355 .name = TYPE_SMBUS_DEVICE,
356 .parent = TYPE_I2C_SLAVE,
357 .instance_size = sizeof(SMBusDevice),
358 .abstract = true,
359 .class_size = sizeof(SMBusDeviceClass),
360 .class_init = smbus_device_class_init,
361};
362
363static void smbus_device_register_types(void)
364{
365 type_register_static(&smbus_device_type_info);
366}
367
368type_init(smbus_device_register_types)
369
