hw/i2c.c

   1 /*
   2  * QEMU I2C bus interface.
   3  *
   4  * Copyright (c) 2007 CodeSourcery.
   5  * Written by Paul Brook
   6  *
   7  * This code is licensed under the LGPL.
   8  */
   9
  10 #include "i2c.h"
  11
  12 struct i2c_bus
  13 {
  14     BusState qbus;
  15     I2CSlave *current_dev;
  16     I2CSlave *dev;
  17     uint8_t saved_address;
  18 };
  19
  20 static Property i2c_props[] = {
  21     DEFINE_PROP_UINT8("address", struct I2CSlave, address, 0),
  22     DEFINE_PROP_END_OF_LIST(),
  23 };
  24
  25 static struct BusInfo i2c_bus_info = {
  26     .name = "I2C",
  27     .size = sizeof(i2c_bus),
  28     .props = i2c_props,
  29 };
  30
  31 static void i2c_bus_pre_save(void *opaque)
  32 {
  33     i2c_bus *bus = opaque;
  34
  35     bus->saved_address = bus->current_dev ? bus->current_dev->address : -1;
  36 }
  37
  38 static int i2c_bus_post_load(void *opaque, int version_id)
  39 {
  40     i2c_bus *bus = opaque;
  41
  42     /* The bus is loaded before attached devices, so load and save the
  43        current device id.  Devices will check themselves as loaded.  */
  44     bus->current_dev = NULL;
  45     return 0;
  46 }
  47
  48 static const VMStateDescription vmstate_i2c_bus = {
  49     .name = "i2c_bus",
  50     .version_id = 1,
  51     .minimum_version_id = 1,
  52     .minimum_version_id_old = 1,
  53     .pre_save = i2c_bus_pre_save,
  54     .post_load = i2c_bus_post_load,
  55     .fields      = (VMStateField []) {
  56         VMSTATE_UINT8(saved_address, i2c_bus),
  57         VMSTATE_END_OF_LIST()
  58     }
  59 };
  60
  61 /* Create a new I2C bus.  */
  62 i2c_bus *i2c_init_bus(DeviceState *parent, const char *name)
  63 {
  64     i2c_bus *bus;
  65
  66     bus = FROM_QBUS(i2c_bus, qbus_create(&i2c_bus_info, parent, name));
  67     vmstate_register(NULL, -1, &vmstate_i2c_bus, bus);
  68     return bus;
  69 }
  70
  71 void i2c_set_slave_address(I2CSlave *dev, uint8_t address)
  72 {
  73     dev->address = address;
  74 }
  75
  76 /* Return nonzero if bus is busy.  */
  77 int i2c_bus_busy(i2c_bus *bus)
  78 {
  79     return bus->current_dev != NULL;
  80 }
  81
  82 /* Returns non-zero if the address is not valid.  */
  83 /* TODO: Make this handle multiple masters.  */
  84 int i2c_start_transfer(i2c_bus *bus, uint8_t address, int recv)
  85 {
  86     DeviceState *qdev;
  87     I2CSlave *slave = NULL;
  88     I2CSlaveClass *sc;
  89
  90     QTAILQ_FOREACH(qdev, &bus->qbus.children, sibling) {
  91         I2CSlave *candidate = I2C_SLAVE_FROM_QDEV(qdev);
  92         if (candidate->address == address) {
  93             slave = candidate;
  94             break;
  95         }
  96     }
  97
  98     if (!slave) {
  99         return 1;
 100     }
 101
 102     sc = I2C_SLAVE_GET_CLASS(slave);
 103     /* If the bus is already busy, assume this is a repeated
 104        start condition.  */
 105     bus->current_dev = slave;
 106     if (sc->event) {
 107         sc->event(slave, recv ? I2C_START_RECV : I2C_START_SEND);
 108     }
 109     return 0;
 110 }
 111
 112 void i2c_end_transfer(i2c_bus *bus)
 113 {
 114     I2CSlave *dev = bus->current_dev;
 115     I2CSlaveClass *sc;
 116
 117     if (!dev) {
 118         return;
 119     }
 120
 121     sc = I2C_SLAVE_GET_CLASS(dev);
 122     if (sc->event) {
 123         sc->event(dev, I2C_FINISH);
 124     }
 125
 126     bus->current_dev = NULL;
 127 }
 128
 129 int i2c_send(i2c_bus *bus, uint8_t data)
 130 {
 131     I2CSlave *dev = bus->current_dev;
 132     I2CSlaveClass *sc;
 133
 134     if (!dev) {
 135         return -1;
 136     }
 137
 138     sc = I2C_SLAVE_GET_CLASS(dev);
 139     if (sc->send) {
 140         return sc->send(dev, data);
 141     }
 142
 143     return -1;
 144 }
 145
 146 int i2c_recv(i2c_bus *bus)
 147 {
 148     I2CSlave *dev = bus->current_dev;
 149     I2CSlaveClass *sc;
 150
 151     if (!dev) {
 152         return -1;
 153     }
 154
 155     sc = I2C_SLAVE_GET_CLASS(dev);
 156     if (sc->recv) {
 157         return sc->recv(dev);
 158     }
 159
 160     return -1;
 161 }
 162
 163 void i2c_nack(i2c_bus *bus)
 164 {
 165     I2CSlave *dev = bus->current_dev;
 166     I2CSlaveClass *sc;
 167
 168     if (!dev) {
 169         return;
 170     }
 171
 172     sc = I2C_SLAVE_GET_CLASS(dev);
 173     if (sc->event) {
 174         sc->event(dev, I2C_NACK);
 175     }
 176 }
 177
 178 static int i2c_slave_post_load(void *opaque, int version_id)
 179 {
 180     I2CSlave *dev = opaque;
 181     i2c_bus *bus;
 182     bus = FROM_QBUS(i2c_bus, qdev_get_parent_bus(&dev->qdev));
 183     if (bus->saved_address == dev->address) {
 184         bus->current_dev = dev;
 185     }
 186     return 0;
 187 }
 188
 189 const VMStateDescription vmstate_i2c_slave = {
 190     .name = "I2CSlave",
 191     .version_id = 1,
 192     .minimum_version_id = 1,
 193     .minimum_version_id_old = 1,
 194     .post_load = i2c_slave_post_load,
 195     .fields      = (VMStateField []) {
 196         VMSTATE_UINT8(address, I2CSlave),
 197         VMSTATE_END_OF_LIST()
 198     }
 199 };
 200
 201 static int i2c_slave_qdev_init(DeviceState *dev)
 202 {
 203     I2CSlave *s = I2C_SLAVE_FROM_QDEV(dev);
 204     I2CSlaveClass *sc = I2C_SLAVE_GET_CLASS(s);
 205
 206     return sc->init(s);
 207 }
 208
 209 DeviceState *i2c_create_slave(i2c_bus *bus, const char *name, uint8_t addr)
 210 {
 211     DeviceState *dev;
 212
 213     dev = qdev_create(&bus->qbus, name);
 214     qdev_prop_set_uint8(dev, "address", addr);
 215     qdev_init_nofail(dev);
 216     return dev;
 217 }
 218
 219 static void i2c_slave_class_init(ObjectClass *klass, void *data)
 220 {
 221     DeviceClass *k = DEVICE_CLASS(klass);
 222     k->init = i2c_slave_qdev_init;
 223     k->bus_info = &i2c_bus_info;
 224 }
 225
 226 static TypeInfo i2c_slave_type_info = {
 227     .name = TYPE_I2C_SLAVE,
 228     .parent = TYPE_DEVICE,
 229     .instance_size = sizeof(I2CSlave),
 230     .abstract = true,
 231     .class_size = sizeof(I2CSlaveClass),
 232     .class_init = i2c_slave_class_init,
 233 };
 234
 235 static void i2c_slave_register_types(void)
 236 {
 237     type_register_static(&i2c_slave_type_info);
 238 }
 239
 240 type_init(i2c_slave_register_types)