qdev: set properties with device_class_set_props()

[qemu.git] / hw / i2c / core.c

diff --git a/hw/i2c/core.c b/hw/i2c/core.c
index abb3efb1db1f915b06070bc32b0e1fc4b5c34a3c..d413a192eddf97db26c2cfc082286bf6d718afb0 100644 (file)
--- a/hw/i2c/core.c
+++ b/hw/i2c/core.c
@@ -9,37 +9,25 @@
 
 #include "qemu/osdep.h"
 #include "hw/i2c/i2c.h"
 
 #include "qemu/osdep.h"
 #include "hw/i2c/i2c.h"

+#include "hw/qdev-properties.h"
+#include "migration/vmstate.h"
+#include "qemu/module.h"
+#include "trace.h"

 
 

-typedef struct I2CNode I2CNode;
-
-struct I2CNode {
-    I2CSlave *elt;
-    QLIST_ENTRY(I2CNode) next;
-};
-
-struct I2CBus
-{
-    BusState qbus;
-    QLIST_HEAD(, I2CNode) current_devs;
-    uint8_t saved_address;
-    bool broadcast;
-};
+#define I2C_BROADCAST 0x00

 
 static Property i2c_props[] = {
     DEFINE_PROP_UINT8("address", struct I2CSlave, address, 0),
     DEFINE_PROP_END_OF_LIST(),
 };
 
 
 static Property i2c_props[] = {
     DEFINE_PROP_UINT8("address", struct I2CSlave, address, 0),
     DEFINE_PROP_END_OF_LIST(),
 };
 

-#define TYPE_I2C_BUS "i2c-bus"
-#define I2C_BUS(obj) OBJECT_CHECK(I2CBus, (obj), TYPE_I2C_BUS)
-

 static const TypeInfo i2c_bus_info = {
     .name = TYPE_I2C_BUS,
     .parent = TYPE_BUS,
     .instance_size = sizeof(I2CBus),
 };
 
 static const TypeInfo i2c_bus_info = {
     .name = TYPE_I2C_BUS,
     .parent = TYPE_BUS,
     .instance_size = sizeof(I2CBus),
 };
 

-static void i2c_bus_pre_save(void *opaque)
+static int i2c_bus_pre_save(void *opaque)

 {
     I2CBus *bus = opaque;
 
 {
     I2CBus *bus = opaque;
 


@@ -47,8 +35,12 @@ static void i2c_bus_pre_save(void *opaque)
     if (!QLIST_EMPTY(&bus->current_devs)) {
         if (!bus->broadcast) {
             bus->saved_address = QLIST_FIRST(&bus->current_devs)->elt->address;
     if (!QLIST_EMPTY(&bus->current_devs)) {
         if (!bus->broadcast) {
             bus->saved_address = QLIST_FIRST(&bus->current_devs)->elt->address;

+        } else {
+            bus->saved_address = I2C_BROADCAST;

         }
     }
         }
     }

+
+    return 0;

 }
 
 static const VMStateDescription vmstate_i2c_bus = {
 }
 
 static const VMStateDescription vmstate_i2c_bus = {


@@ -58,7 +50,6 @@ static const VMStateDescription vmstate_i2c_bus = {
     .pre_save = i2c_bus_pre_save,
     .fields = (VMStateField[]) {
         VMSTATE_UINT8(saved_address, I2CBus),
     .pre_save = i2c_bus_pre_save,
     .fields = (VMStateField[]) {
         VMSTATE_UINT8(saved_address, I2CBus),

-        VMSTATE_BOOL(broadcast, I2CBus),

         VMSTATE_END_OF_LIST()
     }
 };
         VMSTATE_END_OF_LIST()
     }
 };


@@ -70,7 +61,7 @@ I2CBus *i2c_init_bus(DeviceState *parent, const char *name)
 
     bus = I2C_BUS(qbus_create(TYPE_I2C_BUS, parent, name));
     QLIST_INIT(&bus->current_devs);
 
     bus = I2C_BUS(qbus_create(TYPE_I2C_BUS, parent, name));
     QLIST_INIT(&bus->current_devs);

-    vmstate_register(NULL, -1, &vmstate_i2c_bus, bus);
+    vmstate_register(NULL, VMSTATE_INSTANCE_ID_ANY, &vmstate_i2c_bus, bus);

     return bus;
 }
 
     return bus;
 }
 


@@ -85,15 +76,28 @@ int i2c_bus_busy(I2CBus *bus)
     return !QLIST_EMPTY(&bus->current_devs);
 }
 
     return !QLIST_EMPTY(&bus->current_devs);
 }
 

-/* Returns non-zero if the address is not valid.  */

 /* TODO: Make this handle multiple masters.  */
 /* TODO: Make this handle multiple masters.  */

+/*
+ * Start or continue an i2c transaction.  When this is called for the
+ * first time or after an i2c_end_transfer(), if it returns an error
+ * the bus transaction is terminated (or really never started).  If
+ * this is called after another i2c_start_transfer() without an
+ * intervening i2c_end_transfer(), and it returns an error, the
+ * transaction will not be terminated.  The caller must do it.
+ *
+ * This corresponds with the way real hardware works.  The SMBus
+ * protocol uses a start transfer to switch from write to read mode
+ * without releasing the bus.  If that fails, the bus is still
+ * in a transaction.
+ */

 int i2c_start_transfer(I2CBus *bus, uint8_t address, int recv)
 {
     BusChild *kid;
     I2CSlaveClass *sc;
     I2CNode *node;
 int i2c_start_transfer(I2CBus *bus, uint8_t address, int recv)
 {
     BusChild *kid;
     I2CSlaveClass *sc;
     I2CNode *node;

+    bool bus_scanned = false;

 
 

-    if (address == 0x00) {
+    if (address == I2C_BROADCAST) {

         /*
          * This is a broadcast, the current_devs will be all the devices of the
          * bus.
         /*
          * This is a broadcast, the current_devs will be all the devices of the
          * bus.


@@ -101,17 +105,28 @@ int i2c_start_transfer(I2CBus *bus, uint8_t address, int recv)
         bus->broadcast = true;
     }
 
         bus->broadcast = true;
     }
 

-    QTAILQ_FOREACH(kid, &bus->qbus.children, sibling) {
-        DeviceState *qdev = kid->child;
-        I2CSlave *candidate = I2C_SLAVE(qdev);
-        if ((candidate->address == address) || (bus->broadcast)) {
-            node = g_malloc(sizeof(struct I2CNode));
-            node->elt = candidate;
-            QLIST_INSERT_HEAD(&bus->current_devs, node, next);
-            if (!bus->broadcast) {
-                break;
+    /*
+     * If there are already devices in the list, that means we are in
+     * the middle of a transaction and we shouldn't rescan the bus.
+     *
+     * This happens with any SMBus transaction, even on a pure I2C
+     * device.  The interface does a transaction start without
+     * terminating the previous transaction.
+     */
+    if (QLIST_EMPTY(&bus->current_devs)) {
+        QTAILQ_FOREACH(kid, &bus->qbus.children, sibling) {
+            DeviceState *qdev = kid->child;
+            I2CSlave *candidate = I2C_SLAVE(qdev);
+            if ((candidate->address == address) || (bus->broadcast)) {
+                node = g_malloc(sizeof(struct I2CNode));
+                node->elt = candidate;
+                QLIST_INSERT_HEAD(&bus->current_devs, node, next);
+                if (!bus->broadcast) {
+                    break;
+                }

             }
         }
             }
         }

+        bus_scanned = true;

     }
 
     if (QLIST_EMPTY(&bus->current_devs)) {
     }
 
     if (QLIST_EMPTY(&bus->current_devs)) {


@@ -119,11 +134,23 @@ int i2c_start_transfer(I2CBus *bus, uint8_t address, int recv)
     }
 
     QLIST_FOREACH(node, &bus->current_devs, next) {
     }
 
     QLIST_FOREACH(node, &bus->current_devs, next) {

-        sc = I2C_SLAVE_GET_CLASS(node->elt);
+        I2CSlave *s = node->elt;
+        int rv;
+
+        sc = I2C_SLAVE_GET_CLASS(s);

         /* If the bus is already busy, assume this is a repeated
            start condition.  */
         /* If the bus is already busy, assume this is a repeated
            start condition.  */

+

         if (sc->event) {
         if (sc->event) {

-            sc->event(node->elt, recv ? I2C_START_RECV : I2C_START_SEND);
+            trace_i2c_event("start", s->address);
+            rv = sc->event(s, recv ? I2C_START_RECV : I2C_START_SEND);
+            if (rv && !bus->broadcast) {
+                if (bus_scanned) {
+                    /* First call, terminate the transfer. */
+                    i2c_end_transfer(bus);
+                }
+                return rv;
+            }

         }
     }
     return 0;
         }
     }
     return 0;


@@ -134,14 +161,12 @@ void i2c_end_transfer(I2CBus *bus)
     I2CSlaveClass *sc;
     I2CNode *node, *next;
 
     I2CSlaveClass *sc;
     I2CNode *node, *next;
 

-    if (QLIST_EMPTY(&bus->current_devs)) {
-        return;
-    }
-

     QLIST_FOREACH_SAFE(node, &bus->current_devs, next, next) {
     QLIST_FOREACH_SAFE(node, &bus->current_devs, next, next) {

-        sc = I2C_SLAVE_GET_CLASS(node->elt);
+        I2CSlave *s = node->elt;
+        sc = I2C_SLAVE_GET_CLASS(s);

         if (sc->event) {
         if (sc->event) {

-            sc->event(node->elt, I2C_FINISH);
+            trace_i2c_event("finish", s->address);
+            sc->event(s, I2C_FINISH);

         }
         QLIST_REMOVE(node, next);
         g_free(node);
         }
         QLIST_REMOVE(node, next);
         g_free(node);


@@ -152,35 +177,34 @@ void i2c_end_transfer(I2CBus *bus)
 int i2c_send_recv(I2CBus *bus, uint8_t *data, bool send)
 {
     I2CSlaveClass *sc;
 int i2c_send_recv(I2CBus *bus, uint8_t *data, bool send)
 {
     I2CSlaveClass *sc;

+    I2CSlave *s;

     I2CNode *node;
     int ret = 0;
 
     if (send) {
         QLIST_FOREACH(node, &bus->current_devs, next) {
     I2CNode *node;
     int ret = 0;
 
     if (send) {
         QLIST_FOREACH(node, &bus->current_devs, next) {

-            sc = I2C_SLAVE_GET_CLASS(node->elt);
+            s = node->elt;
+            sc = I2C_SLAVE_GET_CLASS(s);

             if (sc->send) {
             if (sc->send) {

-                ret = ret || sc->send(node->elt, *data);
+                trace_i2c_send(s->address, *data);
+                ret = ret || sc->send(s, *data);

             } else {
                 ret = -1;
             }
         }
         return ret ? -1 : 0;
     } else {
             } else {
                 ret = -1;
             }
         }
         return ret ? -1 : 0;
     } else {

-        if ((QLIST_EMPTY(&bus->current_devs)) || (bus->broadcast)) {
-            return -1;
-        }
-
-        sc = I2C_SLAVE_GET_CLASS(QLIST_FIRST(&bus->current_devs)->elt);
-        if (sc->recv) {
-            ret = sc->recv(QLIST_FIRST(&bus->current_devs)->elt);
-            if (ret < 0) {
-                return ret;
-            } else {
-                *data = ret;
-                return 0;
+        ret = 0xff;
+        if (!QLIST_EMPTY(&bus->current_devs) && !bus->broadcast) {
+            sc = I2C_SLAVE_GET_CLASS(QLIST_FIRST(&bus->current_devs)->elt);
+            if (sc->recv) {
+                s = QLIST_FIRST(&bus->current_devs)->elt;
+                ret = sc->recv(s);
+                trace_i2c_recv(s->address, ret);

             }
         }
             }
         }

-        return -1;
+        *data = ret;
+        return 0;

     }
 }
 
     }
 }
 


@@ -189,12 +213,12 @@ int i2c_send(I2CBus *bus, uint8_t data)
     return i2c_send_recv(bus, &data, true);
 }
 
     return i2c_send_recv(bus, &data, true);
 }
 

-int i2c_recv(I2CBus *bus)
+uint8_t i2c_recv(I2CBus *bus)

 {
 {

-    uint8_t data;
-    int ret = i2c_send_recv(bus, &data, false);
+    uint8_t data = 0xff;

 
 

-    return ret < 0 ? ret : data;
+    i2c_send_recv(bus, &data, false);
+    return data;

 }
 
 void i2c_nack(I2CBus *bus)
 }
 
 void i2c_nack(I2CBus *bus)


@@ -209,6 +233,7 @@ void i2c_nack(I2CBus *bus)
     QLIST_FOREACH(node, &bus->current_devs, next) {
         sc = I2C_SLAVE_GET_CLASS(node->elt);
         if (sc->event) {
     QLIST_FOREACH(node, &bus->current_devs, next) {
         sc = I2C_SLAVE_GET_CLASS(node->elt);
         if (sc->event) {

+            trace_i2c_event("nack", node->elt->address);

             sc->event(node->elt, I2C_NACK);
         }
     }
             sc->event(node->elt, I2C_NACK);
         }
     }


@@ -221,7 +246,8 @@ static int i2c_slave_post_load(void *opaque, int version_id)
     I2CNode *node;
 
     bus = I2C_BUS(qdev_get_parent_bus(DEVICE(dev)));
     I2CNode *node;
 
     bus = I2C_BUS(qdev_get_parent_bus(DEVICE(dev)));

-    if ((bus->saved_address == dev->address) || (bus->broadcast)) {
+    if ((bus->saved_address == dev->address) ||
+        (bus->saved_address == I2C_BROADCAST)) {

         node = g_malloc(sizeof(struct I2CNode));
         node->elt = dev;
         QLIST_INSERT_HEAD(&bus->current_devs, node, next);
         node = g_malloc(sizeof(struct I2CNode));
         node->elt = dev;
         QLIST_INSERT_HEAD(&bus->current_devs, node, next);


@@ -240,14 +266,6 @@ const VMStateDescription vmstate_i2c_slave = {
     }
 };
 
     }
 };
 

-static int i2c_slave_qdev_init(DeviceState *dev)
-{
-    I2CSlave *s = I2C_SLAVE(dev);
-    I2CSlaveClass *sc = I2C_SLAVE_GET_CLASS(s);
-
-    return sc->init(s);
-}
-

 DeviceState *i2c_create_slave(I2CBus *bus, const char *name, uint8_t addr)
 {
     DeviceState *dev;
 DeviceState *i2c_create_slave(I2CBus *bus, const char *name, uint8_t addr)
 {
     DeviceState *dev;


@@ -261,10 +279,9 @@ DeviceState *i2c_create_slave(I2CBus *bus, const char *name, uint8_t addr)
 static void i2c_slave_class_init(ObjectClass *klass, void *data)
 {
     DeviceClass *k = DEVICE_CLASS(klass);
 static void i2c_slave_class_init(ObjectClass *klass, void *data)
 {
     DeviceClass *k = DEVICE_CLASS(klass);

-    k->init = i2c_slave_qdev_init;

     set_bit(DEVICE_CATEGORY_MISC, k->categories);
     k->bus_type = TYPE_I2C_BUS;
     set_bit(DEVICE_CATEGORY_MISC, k->categories);
     k->bus_type = TYPE_I2C_BUS;

-    k->props = i2c_props;
+    device_class_set_props(k, i2c_props);

 }
 
 static const TypeInfo i2c_slave_type_info = {
 }
 
 static const TypeInfo i2c_slave_type_info = {