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 };
  29
  30 static void i2c_bus_pre_save(void *opaque)
  31 {
  32     i2c_bus *bus = opaque;
  33
  34     bus->saved_address = bus->current_dev ? bus->current_dev->address : -1;
  35 }
  36
  37 static int i2c_bus_post_load(void *opaque, int version_id)
  38 {
  39     i2c_bus *bus = opaque;
  40
  41     /* The bus is loaded before attached devices, so load and save the
  42        current device id.  Devices will check themselves as loaded.  */
  43     bus->current_dev = NULL;
  44     return 0;
  45 }
  46
  47 static const VMStateDescription vmstate_i2c_bus = {
  48     .name = "i2c_bus",
  49     .version_id = 1,
  50     .minimum_version_id = 1,
  51     .minimum_version_id_old = 1,
  52     .pre_save = i2c_bus_pre_save,
  53     .post_load = i2c_bus_post_load,
  54     .fields      = (VMStateField []) {
  55         VMSTATE_UINT8(saved_address, i2c_bus),
  56         VMSTATE_END_OF_LIST()
  57     }
  58 };
  59
  60 /* Create a new I2C bus.  */
  61 i2c_bus *i2c_init_bus(DeviceState *parent, const char *name)
  62 {
  63     i2c_bus *bus;
  64
  65     bus = FROM_QBUS(i2c_bus, qbus_create(&i2c_bus_info, parent, name));
  66     vmstate_register(NULL, -1, &vmstate_i2c_bus, bus);
  67     return bus;
  68 }
  69
  70 void i2c_set_slave_address(I2CSlave *dev, uint8_t address)
  71 {
  72     dev->address = address;
  73 }
  74
  75 /* Return nonzero if bus is busy.  */
  76 int i2c_bus_busy(i2c_bus *bus)
  77 {
  78     return bus->current_dev != NULL;
  79 }
  80
  81 /* Returns non-zero if the address is not valid.  */
  82 /* TODO: Make this handle multiple masters.  */
  83 int i2c_start_transfer(i2c_bus *bus, uint8_t address, int recv)
  84 {
  85     DeviceState *qdev;
  86     I2CSlave *slave = NULL;
  87     I2CSlaveClass *sc;
  88
  89     QTAILQ_FOREACH(qdev, &bus->qbus.children, sibling) {
  90         I2CSlave *candidate = I2C_SLAVE_FROM_QDEV(qdev);
  91         if (candidate->address == address) {
  92             slave = candidate;
  93             break;
  94         }
  95     }
  96
  97     if (!slave) {
  98         return 1;
  99     }
 100
 101     sc = I2C_SLAVE_GET_CLASS(slave);
 102     /* If the bus is already busy, assume this is a repeated
 103        start condition.  */
 104     bus->current_dev = slave;
 105     if (sc->event) {
 106         sc->event(slave, recv ? I2C_START_RECV : I2C_START_SEND);
 107     }
 108     return 0;
 109 }
 110
 111 void i2c_end_transfer(i2c_bus *bus)
 112 {
 113     I2CSlave *dev = bus->current_dev;
 114     I2CSlaveClass *sc;
 115
 116     if (!dev) {
 117         return;
 118     }
 119
 120     sc = I2C_SLAVE_GET_CLASS(dev);
 121     if (sc->event) {
 122         sc->event(dev, I2C_FINISH);
 123     }
 124
 125     bus->current_dev = NULL;
 126 }
 127
 128 int i2c_send(i2c_bus *bus, uint8_t data)
 129 {
 130     I2CSlave *dev = bus->current_dev;
 131     I2CSlaveClass *sc;
 132
 133     if (!dev) {
 134         return -1;
 135     }
 136
 137     sc = I2C_SLAVE_GET_CLASS(dev);
 138     if (sc->send) {
 139         return sc->send(dev, data);
 140     }
 141
 142     return -1;
 143 }
 144
 145 int i2c_recv(i2c_bus *bus)
 146 {
 147     I2CSlave *dev = bus->current_dev;
 148     I2CSlaveClass *sc;
 149
 150     if (!dev) {
 151         return -1;
 152     }
 153
 154     sc = I2C_SLAVE_GET_CLASS(dev);
 155     if (sc->recv) {
 156         return sc->recv(dev);
 157     }
 158
 159     return -1;
 160 }
 161
 162 void i2c_nack(i2c_bus *bus)
 163 {
 164     I2CSlave *dev = bus->current_dev;
 165     I2CSlaveClass *sc;
 166
 167     if (!dev) {
 168         return;
 169     }
 170
 171     sc = I2C_SLAVE_GET_CLASS(dev);
 172     if (sc->event) {
 173         sc->event(dev, I2C_NACK);
 174     }
 175 }
 176
 177 static int i2c_slave_post_load(void *opaque, int version_id)
 178 {
 179     I2CSlave *dev = opaque;
 180     i2c_bus *bus;
 181     bus = FROM_QBUS(i2c_bus, qdev_get_parent_bus(&dev->qdev));
 182     if (bus->saved_address == dev->address) {
 183         bus->current_dev = dev;
 184     }
 185     return 0;
 186 }
 187
 188 const VMStateDescription vmstate_i2c_slave = {
 189     .name = "I2CSlave",
 190     .version_id = 1,
 191     .minimum_version_id = 1,
 192     .minimum_version_id_old = 1,
 193     .post_load = i2c_slave_post_load,
 194     .fields      = (VMStateField []) {
 195         VMSTATE_UINT8(address, I2CSlave),
 196         VMSTATE_END_OF_LIST()
 197     }
 198 };
 199
 200 static int i2c_slave_qdev_init(DeviceState *dev)
 201 {
 202     I2CSlave *s = I2C_SLAVE_FROM_QDEV(dev);
 203     I2CSlaveClass *sc = I2C_SLAVE_GET_CLASS(s);
 204
 205     return sc->init(s);
 206 }
 207
 208 DeviceState *i2c_create_slave(i2c_bus *bus, const char *name, uint8_t addr)
 209 {
 210     DeviceState *dev;
 211
 212     dev = qdev_create(&bus->qbus, name);
 213     qdev_prop_set_uint8(dev, "address", addr);
 214     qdev_init_nofail(dev);
 215     return dev;
 216 }
 217
 218 static void i2c_slave_class_init(ObjectClass *klass, void *data)
 219 {
 220     DeviceClass *k = DEVICE_CLASS(klass);
 221     k->init = i2c_slave_qdev_init;
 222     k->bus_info = &i2c_bus_info;
 223     k->props = i2c_props;
 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)