cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

core.c (9341B)

      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 "qemu/osdep.h"
     11#include "hw/i2c/i2c.h"
     12#include "hw/qdev-properties.h"
     13#include "migration/vmstate.h"
     14#include "qapi/error.h"
     15#include "qemu/module.h"
     16#include "trace.h"
     17
     18#define I2C_BROADCAST 0x00
     19
     20static Property i2c_props[] = {
     21    DEFINE_PROP_UINT8("address", struct I2CSlave, address, 0),
     22    DEFINE_PROP_END_OF_LIST(),
     23};
     24
     25static const TypeInfo i2c_bus_info = {
     26    .name = TYPE_I2C_BUS,
     27    .parent = TYPE_BUS,
     28    .instance_size = sizeof(I2CBus),
     29};
     30
     31static int i2c_bus_pre_save(void *opaque)
     32{
     33    I2CBus *bus = opaque;
     34
     35    bus->saved_address = -1;
     36    if (!QLIST_EMPTY(&bus->current_devs)) {
     37        if (!bus->broadcast) {
     38            bus->saved_address = QLIST_FIRST(&bus->current_devs)->elt->address;
     39        } else {
     40            bus->saved_address = I2C_BROADCAST;
     41        }
     42    }
     43
     44    return 0;
     45}
     46
     47static const VMStateDescription vmstate_i2c_bus = {
     48    .name = "i2c_bus",
     49    .version_id = 1,
     50    .minimum_version_id = 1,
     51    .pre_save = i2c_bus_pre_save,
     52    .fields = (VMStateField[]) {
     53        VMSTATE_UINT8(saved_address, I2CBus),
     54        VMSTATE_END_OF_LIST()
     55    }
     56};
     57
     58/* Create a new I2C bus.  */
     59I2CBus *i2c_init_bus(DeviceState *parent, const char *name)
     60{
     61    I2CBus *bus;
     62
     63    bus = I2C_BUS(qbus_new(TYPE_I2C_BUS, parent, name));
     64    QLIST_INIT(&bus->current_devs);
     65    vmstate_register(NULL, VMSTATE_INSTANCE_ID_ANY, &vmstate_i2c_bus, bus);
     66    return bus;
     67}
     68
     69void i2c_slave_set_address(I2CSlave *dev, uint8_t address)
     70{
     71    dev->address = address;
     72}
     73
     74/* Return nonzero if bus is busy.  */
     75int i2c_bus_busy(I2CBus *bus)
     76{
     77    return !QLIST_EMPTY(&bus->current_devs);
     78}
     79
     80bool i2c_scan_bus(I2CBus *bus, uint8_t address, bool broadcast,
     81                  I2CNodeList *current_devs)
     82{
     83    BusChild *kid;
     84
     85    QTAILQ_FOREACH(kid, &bus->qbus.children, sibling) {
     86        DeviceState *qdev = kid->child;
     87        I2CSlave *candidate = I2C_SLAVE(qdev);
     88        I2CSlaveClass *sc = I2C_SLAVE_GET_CLASS(candidate);
     89
     90        if (sc->match_and_add(candidate, address, broadcast, current_devs)) {
     91            if (!broadcast) {
     92                return true;
     93            }
     94        }
     95    }
     96
     97    /*
     98     * If broadcast was true, and the list was full or empty, return true. If
     99     * broadcast was false, return false.
    100     */
    101    return broadcast;
    102}
    103
    104/* TODO: Make this handle multiple masters.  */
    105/*
    106 * Start or continue an i2c transaction.  When this is called for the
    107 * first time or after an i2c_end_transfer(), if it returns an error
    108 * the bus transaction is terminated (or really never started).  If
    109 * this is called after another i2c_start_transfer() without an
    110 * intervening i2c_end_transfer(), and it returns an error, the
    111 * transaction will not be terminated.  The caller must do it.
    112 *
    113 * This corresponds with the way real hardware works.  The SMBus
    114 * protocol uses a start transfer to switch from write to read mode
    115 * without releasing the bus.  If that fails, the bus is still
    116 * in a transaction.
    117 *
    118 * @event must be I2C_START_RECV or I2C_START_SEND.
    119 */
    120static int i2c_do_start_transfer(I2CBus *bus, uint8_t address,
    121                                 enum i2c_event event)
    122{
    123    I2CSlaveClass *sc;
    124    I2CNode *node;
    125    bool bus_scanned = false;
    126
    127    if (address == I2C_BROADCAST) {
    128        /*
    129         * This is a broadcast, the current_devs will be all the devices of the
    130         * bus.
    131         */
    132        bus->broadcast = true;
    133    }
    134
    135    /*
    136     * If there are already devices in the list, that means we are in
    137     * the middle of a transaction and we shouldn't rescan the bus.
    138     *
    139     * This happens with any SMBus transaction, even on a pure I2C
    140     * device.  The interface does a transaction start without
    141     * terminating the previous transaction.
    142     */
    143    if (QLIST_EMPTY(&bus->current_devs)) {
    144        /* Disregard whether devices were found. */
    145        (void)i2c_scan_bus(bus, address, bus->broadcast, &bus->current_devs);
    146        bus_scanned = true;
    147    }
    148
    149    if (QLIST_EMPTY(&bus->current_devs)) {
    150        return 1;
    151    }
    152
    153    QLIST_FOREACH(node, &bus->current_devs, next) {
    154        I2CSlave *s = node->elt;
    155        int rv;
    156
    157        sc = I2C_SLAVE_GET_CLASS(s);
    158        /* If the bus is already busy, assume this is a repeated
    159           start condition.  */
    160
    161        if (sc->event) {
    162            trace_i2c_event("start", s->address);
    163            rv = sc->event(s, event);
    164            if (rv && !bus->broadcast) {
    165                if (bus_scanned) {
    166                    /* First call, terminate the transfer. */
    167                    i2c_end_transfer(bus);
    168                }
    169                return rv;
    170            }
    171        }
    172    }
    173    return 0;
    174}
    175
    176int i2c_start_transfer(I2CBus *bus, uint8_t address, bool is_recv)
    177{
    178    return i2c_do_start_transfer(bus, address, is_recv
    179                                               ? I2C_START_RECV
    180                                               : I2C_START_SEND);
    181}
    182
    183int i2c_start_recv(I2CBus *bus, uint8_t address)
    184{
    185    return i2c_do_start_transfer(bus, address, I2C_START_RECV);
    186}
    187
    188int i2c_start_send(I2CBus *bus, uint8_t address)
    189{
    190    return i2c_do_start_transfer(bus, address, I2C_START_SEND);
    191}
    192
    193void i2c_end_transfer(I2CBus *bus)
    194{
    195    I2CSlaveClass *sc;
    196    I2CNode *node, *next;
    197
    198    QLIST_FOREACH_SAFE(node, &bus->current_devs, next, next) {
    199        I2CSlave *s = node->elt;
    200        sc = I2C_SLAVE_GET_CLASS(s);
    201        if (sc->event) {
    202            trace_i2c_event("finish", s->address);
    203            sc->event(s, I2C_FINISH);
    204        }
    205        QLIST_REMOVE(node, next);
    206        g_free(node);
    207    }
    208    bus->broadcast = false;
    209}
    210
    211int i2c_send(I2CBus *bus, uint8_t data)
    212{
    213    I2CSlaveClass *sc;
    214    I2CSlave *s;
    215    I2CNode *node;
    216    int ret = 0;
    217
    218    QLIST_FOREACH(node, &bus->current_devs, next) {
    219        s = node->elt;
    220        sc = I2C_SLAVE_GET_CLASS(s);
    221        if (sc->send) {
    222            trace_i2c_send(s->address, data);
    223            ret = ret || sc->send(s, data);
    224        } else {
    225            ret = -1;
    226        }
    227    }
    228
    229    return ret ? -1 : 0;
    230}
    231
    232uint8_t i2c_recv(I2CBus *bus)
    233{
    234    uint8_t data = 0xff;
    235    I2CSlaveClass *sc;
    236    I2CSlave *s;
    237
    238    if (!QLIST_EMPTY(&bus->current_devs) && !bus->broadcast) {
    239        sc = I2C_SLAVE_GET_CLASS(QLIST_FIRST(&bus->current_devs)->elt);
    240        if (sc->recv) {
    241            s = QLIST_FIRST(&bus->current_devs)->elt;
    242            data = sc->recv(s);
    243            trace_i2c_recv(s->address, data);
    244        }
    245    }
    246
    247    return data;
    248}
    249
    250void i2c_nack(I2CBus *bus)
    251{
    252    I2CSlaveClass *sc;
    253    I2CNode *node;
    254
    255    if (QLIST_EMPTY(&bus->current_devs)) {
    256        return;
    257    }
    258
    259    QLIST_FOREACH(node, &bus->current_devs, next) {
    260        sc = I2C_SLAVE_GET_CLASS(node->elt);
    261        if (sc->event) {
    262            trace_i2c_event("nack", node->elt->address);
    263            sc->event(node->elt, I2C_NACK);
    264        }
    265    }
    266}
    267
    268static int i2c_slave_post_load(void *opaque, int version_id)
    269{
    270    I2CSlave *dev = opaque;
    271    I2CBus *bus;
    272    I2CNode *node;
    273
    274    bus = I2C_BUS(qdev_get_parent_bus(DEVICE(dev)));
    275    if ((bus->saved_address == dev->address) ||
    276        (bus->saved_address == I2C_BROADCAST)) {
    277        node = g_malloc(sizeof(struct I2CNode));
    278        node->elt = dev;
    279        QLIST_INSERT_HEAD(&bus->current_devs, node, next);
    280    }
    281    return 0;
    282}
    283
    284const VMStateDescription vmstate_i2c_slave = {
    285    .name = "I2CSlave",
    286    .version_id = 1,
    287    .minimum_version_id = 1,
    288    .post_load = i2c_slave_post_load,
    289    .fields = (VMStateField[]) {
    290        VMSTATE_UINT8(address, I2CSlave),
    291        VMSTATE_END_OF_LIST()
    292    }
    293};
    294
    295I2CSlave *i2c_slave_new(const char *name, uint8_t addr)
    296{
    297    DeviceState *dev;
    298
    299    dev = qdev_new(name);
    300    qdev_prop_set_uint8(dev, "address", addr);
    301    return I2C_SLAVE(dev);
    302}
    303
    304bool i2c_slave_realize_and_unref(I2CSlave *dev, I2CBus *bus, Error **errp)
    305{
    306    return qdev_realize_and_unref(&dev->qdev, &bus->qbus, errp);
    307}
    308
    309I2CSlave *i2c_slave_create_simple(I2CBus *bus, const char *name, uint8_t addr)
    310{
    311    I2CSlave *dev = i2c_slave_new(name, addr);
    312
    313    i2c_slave_realize_and_unref(dev, bus, &error_abort);
    314
    315    return dev;
    316}
    317
    318static bool i2c_slave_match(I2CSlave *candidate, uint8_t address,
    319                            bool broadcast, I2CNodeList *current_devs)
    320{
    321    if ((candidate->address == address) || (broadcast)) {
    322        I2CNode *node = g_malloc(sizeof(struct I2CNode));
    323        node->elt = candidate;
    324        QLIST_INSERT_HEAD(current_devs, node, next);
    325        return true;
    326    }
    327
    328    /* Not found and not broadcast. */
    329    return false;
    330}
    331
    332static void i2c_slave_class_init(ObjectClass *klass, void *data)
    333{
    334    DeviceClass *k = DEVICE_CLASS(klass);
    335    I2CSlaveClass *sc = I2C_SLAVE_CLASS(klass);
    336    set_bit(DEVICE_CATEGORY_MISC, k->categories);
    337    k->bus_type = TYPE_I2C_BUS;
    338    device_class_set_props(k, i2c_props);
    339    sc->match_and_add = i2c_slave_match;
    340}
    341
    342static const TypeInfo i2c_slave_type_info = {
    343    .name = TYPE_I2C_SLAVE,
    344    .parent = TYPE_DEVICE,
    345    .instance_size = sizeof(I2CSlave),
    346    .abstract = true,
    347    .class_size = sizeof(I2CSlaveClass),
    348    .class_init = i2c_slave_class_init,
    349};
    350
    351static void i2c_slave_register_types(void)
    352{
    353    type_register_static(&i2c_bus_info);
    354    type_register_static(&i2c_slave_type_info);
    355}
    356
    357type_init(i2c_slave_register_types)