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/hw.h" 18 #include "hw/i2c/i2c.h" 19 #include "hw/i2c/smbus_slave.h" 20 21 //#define DEBUG_SMBUS 1 22 23 #ifdef DEBUG_SMBUS 24 #define DPRINTF(fmt, ...) \ 25 do { printf("smbus(%02x): " fmt , dev->i2c.address, ## __VA_ARGS__); } while (0) 26 #define BADF(fmt, ...) \ 27 do { fprintf(stderr, "smbus: error: " fmt , ## __VA_ARGS__); exit(1);} while (0) 28 #else 29 #define DPRINTF(fmt, ...) do {} while(0) 30 #define BADF(fmt, ...) \ 31 do { fprintf(stderr, "smbus: error: " fmt , ## __VA_ARGS__);} while (0) 32 #endif 33 34 enum { 35 SMBUS_IDLE, 36 SMBUS_WRITE_DATA, 37 SMBUS_RECV_BYTE, 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 if (dev->data_len == 1) { 58 DPRINTF("Send Byte\n"); 59 if (sc->send_byte) { 60 sc->send_byte(dev, dev->data_buf[0]); 61 } 62 } else { 63 dev->command = dev->data_buf[0]; 64 DPRINTF("Command %d len %d\n", dev->command, dev->data_len - 1); 65 if (sc->write_data) { 66 sc->write_data(dev, dev->command, dev->data_buf + 1, 67 dev->data_len - 1); 68 } 69 } 70 } 71 72 static int smbus_i2c_event(I2CSlave *s, enum i2c_event event) 73 { 74 SMBusDevice *dev = SMBUS_DEVICE(s); 75 76 switch (event) { 77 case I2C_START_SEND: 78 switch (dev->mode) { 79 case SMBUS_IDLE: 80 DPRINTF("Incoming data\n"); 81 dev->mode = SMBUS_WRITE_DATA; 82 break; 83 default: 84 BADF("Unexpected send start condition in state %d\n", dev->mode); 85 dev->mode = SMBUS_CONFUSED; 86 break; 87 } 88 break; 89 90 case I2C_START_RECV: 91 switch (dev->mode) { 92 case SMBUS_IDLE: 93 DPRINTF("Read mode\n"); 94 dev->mode = SMBUS_RECV_BYTE; 95 break; 96 case SMBUS_WRITE_DATA: 97 if (dev->data_len == 0) { 98 BADF("Read after write with no data\n"); 99 dev->mode = SMBUS_CONFUSED; 100 } else { 101 if (dev->data_len > 1) { 102 smbus_do_write(dev); 103 } else { 104 dev->command = dev->data_buf[0]; 105 DPRINTF("%02x: Command %d\n", dev->i2c.address, 106 dev->command); 107 } 108 DPRINTF("Read mode\n"); 109 dev->data_len = 0; 110 dev->mode = SMBUS_READ_DATA; 111 } 112 break; 113 default: 114 BADF("Unexpected recv start condition in state %d\n", dev->mode); 115 dev->mode = SMBUS_CONFUSED; 116 break; 117 } 118 break; 119 120 case I2C_FINISH: 121 if (dev->data_len == 0) { 122 if (dev->mode == SMBUS_WRITE_DATA || dev->mode == SMBUS_READ_DATA) { 123 smbus_do_quick_cmd(dev, dev->mode == SMBUS_READ_DATA); 124 } 125 } else { 126 switch (dev->mode) { 127 case SMBUS_WRITE_DATA: 128 smbus_do_write(dev); 129 break; 130 131 case SMBUS_READ_DATA: 132 BADF("Unexpected stop during receive\n"); 133 break; 134 135 default: 136 /* Nothing to do. */ 137 break; 138 } 139 } 140 dev->mode = SMBUS_IDLE; 141 dev->data_len = 0; 142 break; 143 144 case I2C_NACK: 145 switch (dev->mode) { 146 case SMBUS_DONE: 147 /* Nothing to do. */ 148 break; 149 case SMBUS_READ_DATA: 150 dev->mode = SMBUS_DONE; 151 break; 152 default: 153 BADF("Unexpected NACK in state %d\n", dev->mode); 154 dev->mode = SMBUS_CONFUSED; 155 break; 156 } 157 } 158 159 return 0; 160 } 161 162 static uint8_t smbus_i2c_recv(I2CSlave *s) 163 { 164 SMBusDevice *dev = SMBUS_DEVICE(s); 165 SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev); 166 uint8_t ret; 167 168 switch (dev->mode) { 169 case SMBUS_RECV_BYTE: 170 if (sc->receive_byte) { 171 ret = sc->receive_byte(dev); 172 } else { 173 ret = 0; 174 } 175 DPRINTF("Receive Byte %02x\n", ret); 176 dev->mode = SMBUS_DONE; 177 break; 178 case SMBUS_READ_DATA: 179 if (sc->read_data) { 180 ret = sc->read_data(dev, dev->command, dev->data_len); 181 dev->data_len++; 182 } else { 183 ret = 0; 184 } 185 DPRINTF("Read data %02x\n", ret); 186 break; 187 default: 188 BADF("Unexpected read in state %d\n", dev->mode); 189 dev->mode = SMBUS_CONFUSED; 190 ret = 0; 191 break; 192 } 193 return ret; 194 } 195 196 static int smbus_i2c_send(I2CSlave *s, uint8_t data) 197 { 198 SMBusDevice *dev = SMBUS_DEVICE(s); 199 200 switch (dev->mode) { 201 case SMBUS_WRITE_DATA: 202 DPRINTF("Write data %02x\n", data); 203 if (dev->data_len >= sizeof(dev->data_buf)) { 204 BADF("Too many bytes sent\n"); 205 } else { 206 dev->data_buf[dev->data_len++] = data; 207 } 208 break; 209 default: 210 BADF("Unexpected write in state %d\n", dev->mode); 211 break; 212 } 213 return 0; 214 } 215 216 static void smbus_device_class_init(ObjectClass *klass, void *data) 217 { 218 I2CSlaveClass *sc = I2C_SLAVE_CLASS(klass); 219 220 sc->event = smbus_i2c_event; 221 sc->recv = smbus_i2c_recv; 222 sc->send = smbus_i2c_send; 223 } 224 225 static const TypeInfo smbus_device_type_info = { 226 .name = TYPE_SMBUS_DEVICE, 227 .parent = TYPE_I2C_SLAVE, 228 .instance_size = sizeof(SMBusDevice), 229 .abstract = true, 230 .class_size = sizeof(SMBusDeviceClass), 231 .class_init = smbus_device_class_init, 232 }; 233 234 static void smbus_device_register_types(void) 235 { 236 type_register_static(&smbus_device_type_info); 237 } 238 239 type_init(smbus_device_register_types) 240