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