Update VERSION for v7.2.0-rc3
[qemu.git] / hw / i2c / smbus_slave.c
1 /*
2 * QEMU SMBus device emulation.
3 *
4 * This code is a helper for SMBus device emulation. It implements an
5 * I2C device inteface and runs the SMBus protocol from the device
6 * point of view and maps those to simple calls to emulate.
7 *
8 * Copyright (c) 2007 CodeSourcery.
9 * Written by Paul Brook
10 *
11 * This code is licensed under the LGPL.
12 */
13
14 /* TODO: Implement PEC. */
15
16 #include "qemu/osdep.h"
17 #include "hw/i2c/i2c.h"
18 #include "hw/i2c/smbus_slave.h"
19 #include "migration/vmstate.h"
20 #include "qemu/module.h"
21
22 //#define DEBUG_SMBUS 1
23
24 #ifdef DEBUG_SMBUS
25 #define DPRINTF(fmt, ...) \
26 do { printf("smbus(%02x): " fmt , dev->i2c.address, ## __VA_ARGS__); } while (0)
27 #define BADF(fmt, ...) \
28 do { fprintf(stderr, "smbus: error: " fmt , ## __VA_ARGS__); exit(1);} while (0)
29 #else
30 #define DPRINTF(fmt, ...) do {} while(0)
31 #define BADF(fmt, ...) \
32 do { fprintf(stderr, "smbus: error: " fmt , ## __VA_ARGS__);} while (0)
33 #endif
34
35 enum {
36 SMBUS_IDLE,
37 SMBUS_WRITE_DATA,
38 SMBUS_READ_DATA,
39 SMBUS_DONE,
40 SMBUS_CONFUSED = -1
41 };
42
43 static void smbus_do_quick_cmd(SMBusDevice *dev, int recv)
44 {
45 SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev);
46
47 DPRINTF("Quick Command %d\n", recv);
48 if (sc->quick_cmd) {
49 sc->quick_cmd(dev, recv);
50 }
51 }
52
53 static void smbus_do_write(SMBusDevice *dev)
54 {
55 SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev);
56
57 DPRINTF("Command %d len %d\n", dev->data_buf[0], dev->data_len);
58 if (sc->write_data) {
59 sc->write_data(dev, dev->data_buf, dev->data_len);
60 }
61 }
62
63 static int smbus_i2c_event(I2CSlave *s, enum i2c_event event)
64 {
65 SMBusDevice *dev = SMBUS_DEVICE(s);
66
67 switch (event) {
68 case I2C_START_SEND:
69 switch (dev->mode) {
70 case SMBUS_IDLE:
71 DPRINTF("Incoming data\n");
72 dev->mode = SMBUS_WRITE_DATA;
73 break;
74
75 default:
76 BADF("Unexpected send start condition in state %d\n", dev->mode);
77 dev->mode = SMBUS_CONFUSED;
78 break;
79 }
80 break;
81
82 case I2C_START_RECV:
83 switch (dev->mode) {
84 case SMBUS_IDLE:
85 DPRINTF("Read mode\n");
86 dev->mode = SMBUS_READ_DATA;
87 break;
88
89 case SMBUS_WRITE_DATA:
90 if (dev->data_len == 0) {
91 BADF("Read after write with no data\n");
92 dev->mode = SMBUS_CONFUSED;
93 } else {
94 smbus_do_write(dev);
95 DPRINTF("Read mode\n");
96 dev->mode = SMBUS_READ_DATA;
97 }
98 break;
99
100 default:
101 BADF("Unexpected recv start condition in state %d\n", dev->mode);
102 dev->mode = SMBUS_CONFUSED;
103 break;
104 }
105 break;
106
107 case I2C_FINISH:
108 if (dev->data_len == 0) {
109 if (dev->mode == SMBUS_WRITE_DATA || dev->mode == SMBUS_READ_DATA) {
110 smbus_do_quick_cmd(dev, dev->mode == SMBUS_READ_DATA);
111 }
112 } else {
113 switch (dev->mode) {
114 case SMBUS_WRITE_DATA:
115 smbus_do_write(dev);
116 break;
117
118 case SMBUS_READ_DATA:
119 BADF("Unexpected stop during receive\n");
120 break;
121
122 default:
123 /* Nothing to do. */
124 break;
125 }
126 }
127 dev->mode = SMBUS_IDLE;
128 dev->data_len = 0;
129 break;
130
131 case I2C_NACK:
132 switch (dev->mode) {
133 case SMBUS_DONE:
134 /* Nothing to do. */
135 break;
136
137 case SMBUS_READ_DATA:
138 dev->mode = SMBUS_DONE;
139 break;
140
141 default:
142 BADF("Unexpected NACK in state %d\n", dev->mode);
143 dev->mode = SMBUS_CONFUSED;
144 break;
145 }
146 break;
147
148 default:
149 return -1;
150 }
151
152 return 0;
153 }
154
155 static uint8_t smbus_i2c_recv(I2CSlave *s)
156 {
157 SMBusDevice *dev = SMBUS_DEVICE(s);
158 SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev);
159 uint8_t ret = 0xff;
160
161 switch (dev->mode) {
162 case SMBUS_READ_DATA:
163 if (sc->receive_byte) {
164 ret = sc->receive_byte(dev);
165 }
166 DPRINTF("Read data %02x\n", ret);
167 break;
168
169 default:
170 BADF("Unexpected read in state %d\n", dev->mode);
171 dev->mode = SMBUS_CONFUSED;
172 break;
173 }
174
175 return ret;
176 }
177
178 static int smbus_i2c_send(I2CSlave *s, uint8_t data)
179 {
180 SMBusDevice *dev = SMBUS_DEVICE(s);
181
182 switch (dev->mode) {
183 case SMBUS_WRITE_DATA:
184 DPRINTF("Write data %02x\n", data);
185 if (dev->data_len >= sizeof(dev->data_buf)) {
186 BADF("Too many bytes sent\n");
187 } else {
188 dev->data_buf[dev->data_len++] = data;
189 }
190 break;
191
192 default:
193 BADF("Unexpected write in state %d\n", dev->mode);
194 break;
195 }
196
197 return 0;
198 }
199
200 static void smbus_device_class_init(ObjectClass *klass, void *data)
201 {
202 I2CSlaveClass *sc = I2C_SLAVE_CLASS(klass);
203
204 sc->event = smbus_i2c_event;
205 sc->recv = smbus_i2c_recv;
206 sc->send = smbus_i2c_send;
207 }
208
209 bool smbus_vmstate_needed(SMBusDevice *dev)
210 {
211 return dev->mode != SMBUS_IDLE;
212 }
213
214 const VMStateDescription vmstate_smbus_device = {
215 .name = TYPE_SMBUS_DEVICE,
216 .version_id = 1,
217 .minimum_version_id = 1,
218 .fields = (VMStateField[]) {
219 VMSTATE_I2C_SLAVE(i2c, SMBusDevice),
220 VMSTATE_INT32(mode, SMBusDevice),
221 VMSTATE_INT32(data_len, SMBusDevice),
222 VMSTATE_UINT8_ARRAY(data_buf, SMBusDevice, SMBUS_DATA_MAX_LEN),
223 VMSTATE_END_OF_LIST()
224 }
225 };
226
227 static const TypeInfo smbus_device_type_info = {
228 .name = TYPE_SMBUS_DEVICE,
229 .parent = TYPE_I2C_SLAVE,
230 .instance_size = sizeof(SMBusDevice),
231 .abstract = true,
232 .class_size = sizeof(SMBusDeviceClass),
233 .class_init = smbus_device_class_init,
234 };
235
236 static void smbus_device_register_types(void)
237 {
238 type_register_static(&smbus_device_type_info);
239 }
240
241 type_init(smbus_device_register_types)