Commit 553cf5d7 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20200626' into staging 



target-arm queue:
 * hw/arm/aspeed: improve QOM usage
 * hw/misc/pca9552: trace GPIO change events
 * target/arm: Implement ARMv8.5-MemTag for system emulation

# gpg: Signature made Fri 26 Jun 2020 16:13:27 BST
# gpg:                using RSA key E1A5C593CD419DE28E8315CF3C2525ED14360CDE
# gpg:                issuer "peter.maydell@linaro.org"
# gpg: Good signature from "Peter Maydell <peter.maydell@linaro.org>" [ultimate]
# gpg:                 aka "Peter Maydell <pmaydell@gmail.com>" [ultimate]
# gpg:                 aka "Peter Maydell <pmaydell@chiark.greenend.org.uk>" [ultimate]
# Primary key fingerprint: E1A5 C593 CD41 9DE2 8E83  15CF 3C25 25ED 1436 0CDE

* remotes/pmaydell/tags/pull-target-arm-20200626: (57 commits)
  target/arm: Enable MTE
  target/arm: Add allocation tag storage for system mode
  target/arm: Create tagged ram when MTE is enabled
  target/arm: Cache the Tagged bit for a page in MemTxAttrs
  target/arm: Always pass cacheattr to get_phys_addr
  target/arm: Set PSTATE.TCO on exception entry
  target/arm: Implement data cache set allocation tags
  target/arm: Complete TBI clearing for user-only for SVE
  target/arm: Add mte helpers for sve scatter/gather memory ops
  target/arm: Handle TBI for sve scalar + int memory ops
  target/arm: Add mte helpers for sve scalar + int ff/nf loads
  target/arm: Add mte helpers for sve scalar + int stores
  target/arm: Add mte helpers for sve scalar + int loads
  target/arm: Add arm_tlb_bti_gp
  target/arm: Tidy trans_LD1R_zpri
  target/arm: Use mte_check1 for sve LD1R
  target/arm: Use mte_checkN for sve unpredicated stores
  target/arm: Use mte_checkN for sve unpredicated loads
  target/arm: Add helper_mte_check_zva
  target/arm: Implement helper_mte_checkN
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 3591ddd3 c7459633

hw/arm/aspeed.c

+27 −19
Original line number Diff line number Diff line
@@ -32,10 +32,15 @@ static struct arm_boot_info aspeed_board_binfo = { 
    .board_id = -1, /* device-tree-only board */

};



struct AspeedBoardState {

struct AspeedMachineState {

    /* Private */

    MachineState parent_obj;

    /* Public */



    AspeedSoCState soc;

    MemoryRegion ram_container;

    MemoryRegion max_ram;

    bool mmio_exec;

};



/* Palmetto hardware value: 0x120CE416 */
@@ -253,7 +258,7 @@ static void sdhci_attach_drive(SDHCIState *sdhci, DriveInfo *dinfo) 


static void aspeed_machine_init(MachineState *machine)

{

    AspeedBoardState *bmc;

    AspeedMachineState *bmc = ASPEED_MACHINE(machine);

    AspeedMachineClass *amc = ASPEED_MACHINE_GET_CLASS(machine);

    AspeedSoCClass *sc;

    DriveInfo *drive0 = drive_get(IF_MTD, 0, 0);
@@ -261,8 +266,6 @@ static void aspeed_machine_init(MachineState *machine) 
    int i;

    NICInfo *nd = &nd_table[0];



    bmc = g_new0(AspeedBoardState, 1);



    memory_region_init(&bmc->ram_container, NULL, "aspeed-ram-container",

                       4 * GiB);

    memory_region_add_subregion(&bmc->ram_container, 0, machine->ram);
@@ -329,12 +332,12 @@ static void aspeed_machine_init(MachineState *machine) 
         * needed by the flash modules of the Aspeed machines.

         */

        if (ASPEED_MACHINE(machine)->mmio_exec) {

            memory_region_init_alias(boot_rom, OBJECT(bmc), "aspeed.boot_rom",

            memory_region_init_alias(boot_rom, NULL, "aspeed.boot_rom",

                                     &fl->mmio, 0, fl->size);

            memory_region_add_subregion(get_system_memory(), FIRMWARE_ADDR,

                                        boot_rom);

        } else {

            memory_region_init_rom(boot_rom, OBJECT(bmc), "aspeed.boot_rom",

            memory_region_init_rom(boot_rom, NULL, "aspeed.boot_rom",

                                   fl->size, &error_abort);

            memory_region_add_subregion(get_system_memory(), FIRMWARE_ADDR,

                                        boot_rom);
@@ -345,7 +348,7 @@ static void aspeed_machine_init(MachineState *machine) 
    if (machine->kernel_filename && sc->num_cpus > 1) {

        /* With no u-boot we must set up a boot stub for the secondary CPU */

        MemoryRegion *smpboot = g_new(MemoryRegion, 1);

        memory_region_init_ram(smpboot, OBJECT(bmc), "aspeed.smpboot",

        memory_region_init_ram(smpboot, NULL, "aspeed.smpboot",

                               0x80, &error_abort);

        memory_region_add_subregion(get_system_memory(),

                                    AST_SMP_MAILBOX_BASE, smpboot);
@@ -374,7 +377,7 @@ static void aspeed_machine_init(MachineState *machine) 
    arm_load_kernel(ARM_CPU(first_cpu), machine, &aspeed_board_binfo);

}



static void palmetto_bmc_i2c_init(AspeedBoardState *bmc)

static void palmetto_bmc_i2c_init(AspeedMachineState *bmc)

{

    AspeedSoCState *soc = &bmc->soc;

    DeviceState *dev;
@@ -396,7 +399,7 @@ static void palmetto_bmc_i2c_init(AspeedBoardState *bmc) 
    object_property_set_int(OBJECT(dev), 110000, "temperature3", &error_abort);

}



static void ast2500_evb_i2c_init(AspeedBoardState *bmc)

static void ast2500_evb_i2c_init(AspeedMachineState *bmc)

{

    AspeedSoCState *soc = &bmc->soc;

    uint8_t *eeprom_buf = g_malloc0(8 * 1024);
@@ -413,13 +416,13 @@ static void ast2500_evb_i2c_init(AspeedBoardState *bmc) 
    i2c_create_slave(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 11), "ds1338", 0x32);

}



static void ast2600_evb_i2c_init(AspeedBoardState *bmc)

static void ast2600_evb_i2c_init(AspeedMachineState *bmc)

{

    /* Start with some devices on our I2C busses */

    ast2500_evb_i2c_init(bmc);

}



static void romulus_bmc_i2c_init(AspeedBoardState *bmc)

static void romulus_bmc_i2c_init(AspeedMachineState *bmc)

{

    AspeedSoCState *soc = &bmc->soc;
@@ -428,7 +431,7 @@ static void romulus_bmc_i2c_init(AspeedBoardState *bmc) 
    i2c_create_slave(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 11), "ds1338", 0x32);

}



static void swift_bmc_i2c_init(AspeedBoardState *bmc)

static void swift_bmc_i2c_init(AspeedMachineState *bmc)

{

    AspeedSoCState *soc = &bmc->soc;
@@ -457,7 +460,7 @@ static void swift_bmc_i2c_init(AspeedBoardState *bmc) 
    i2c_create_slave(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 12), "tmp105", 0x4a);

}



static void sonorapass_bmc_i2c_init(AspeedBoardState *bmc)

static void sonorapass_bmc_i2c_init(AspeedMachineState *bmc)

{

    AspeedSoCState *soc = &bmc->soc;
@@ -501,16 +504,19 @@ static void sonorapass_bmc_i2c_init(AspeedBoardState *bmc) 


}



static void witherspoon_bmc_i2c_init(AspeedBoardState *bmc)

static void witherspoon_bmc_i2c_init(AspeedMachineState *bmc)

{

    AspeedSoCState *soc = &bmc->soc;

    uint8_t *eeprom_buf = g_malloc0(8 * 1024);

    DeviceState *dev;



    /* Bus 3: TODO bmp280@77 */

    /* Bus 3: TODO max31785@52 */

    /* Bus 3: TODO dps310@76 */

    i2c_create_slave(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 3), TYPE_PCA9552,

                     0x60);

    dev = i2c_try_create_slave(TYPE_PCA9552, 0x60);

    qdev_prop_set_string(dev, "description", "pca1");

    i2c_realize_and_unref(dev, aspeed_i2c_get_bus(DEVICE(&soc->i2c), 3),

                          &error_fatal);



    i2c_create_slave(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 4), "tmp423", 0x4c);

    i2c_create_slave(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 5), "tmp423", 0x4c);
@@ -525,8 +531,10 @@ static void witherspoon_bmc_i2c_init(AspeedBoardState *bmc) 


    smbus_eeprom_init_one(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 11), 0x51,

                          eeprom_buf);

    i2c_create_slave(aspeed_i2c_get_bus(DEVICE(&soc->i2c), 11), TYPE_PCA9552,

                     0x60);

    dev = i2c_try_create_slave(TYPE_PCA9552, 0x60);

    qdev_prop_set_string(dev, "description", "pca0");

    i2c_realize_and_unref(dev, aspeed_i2c_get_bus(DEVICE(&soc->i2c), 11),

                          &error_fatal);

    /* Bus 11: TODO ucd90160@64 */

}
@@ -751,7 +759,7 @@ static const TypeInfo aspeed_machine_types[] = { 
    }, {

        .name          = TYPE_ASPEED_MACHINE,

        .parent        = TYPE_MACHINE,

        .instance_size = sizeof(AspeedMachine),

        .instance_size = sizeof(AspeedMachineState),

        .instance_init = aspeed_machine_instance_init,

        .class_size    = sizeof(AspeedMachineClass),

        .class_init    = aspeed_machine_class_init,

hw/arm/virt.c

+53 −2
Original line number Diff line number Diff line
@@ -1390,8 +1390,19 @@ static void create_platform_bus(VirtMachineState *vms) 
                                sysbus_mmio_get_region(s, 0));

}



static void create_tag_ram(MemoryRegion *tag_sysmem,

                           hwaddr base, hwaddr size,

                           const char *name)

{

    MemoryRegion *tagram = g_new(MemoryRegion, 1);



    memory_region_init_ram(tagram, NULL, name, size / 32, &error_fatal);

    memory_region_add_subregion(tag_sysmem, base / 32, tagram);

}



static void create_secure_ram(VirtMachineState *vms,

                              MemoryRegion *secure_sysmem)

                              MemoryRegion *secure_sysmem,

                              MemoryRegion *secure_tag_sysmem)

{

    MemoryRegion *secram = g_new(MemoryRegion, 1);

    char *nodename;
@@ -1409,6 +1420,10 @@ static void create_secure_ram(VirtMachineState *vms, 
    qemu_fdt_setprop_string(vms->fdt, nodename, "status", "disabled");

    qemu_fdt_setprop_string(vms->fdt, nodename, "secure-status", "okay");



    if (secure_tag_sysmem) {

        create_tag_ram(secure_tag_sysmem, base, size, "mach-virt.secure-tag");

    }



    g_free(nodename);

}
@@ -1665,6 +1680,8 @@ static void machvirt_init(MachineState *machine) 
    const CPUArchIdList *possible_cpus;

    MemoryRegion *sysmem = get_system_memory();

    MemoryRegion *secure_sysmem = NULL;

    MemoryRegion *tag_sysmem = NULL;

    MemoryRegion *secure_tag_sysmem = NULL;

    int n, virt_max_cpus;

    bool firmware_loaded;

    bool aarch64 = true;
@@ -1819,6 +1836,35 @@ static void machvirt_init(MachineState *machine) 
                                     "secure-memory", &error_abort);

        }



        /*

         * The cpu adds the property if and only if MemTag is supported.

         * If it is, we must allocate the ram to back that up.

         */

        if (object_property_find(cpuobj, "tag-memory", NULL)) {

            if (!tag_sysmem) {

                tag_sysmem = g_new(MemoryRegion, 1);

                memory_region_init(tag_sysmem, OBJECT(machine),

                                   "tag-memory", UINT64_MAX / 32);



                if (vms->secure) {

                    secure_tag_sysmem = g_new(MemoryRegion, 1);

                    memory_region_init(secure_tag_sysmem, OBJECT(machine),

                                       "secure-tag-memory", UINT64_MAX / 32);



                    /* As with ram, secure-tag takes precedence over tag.  */

                    memory_region_add_subregion_overlap(secure_tag_sysmem, 0,

                                                        tag_sysmem, -1);

                }

            }



            object_property_set_link(cpuobj, OBJECT(tag_sysmem),

                                     "tag-memory", &error_abort);

            if (vms->secure) {

                object_property_set_link(cpuobj, OBJECT(secure_tag_sysmem),

                                         "secure-tag-memory", &error_abort);

            }

        }



        qdev_realize(DEVICE(cpuobj), NULL, &error_fatal);

        object_unref(cpuobj);

    }
@@ -1857,10 +1903,15 @@ static void machvirt_init(MachineState *machine) 
    create_uart(vms, VIRT_UART, sysmem, serial_hd(0));



    if (vms->secure) {

        create_secure_ram(vms, secure_sysmem);

        create_secure_ram(vms, secure_sysmem, secure_tag_sysmem);

        create_uart(vms, VIRT_SECURE_UART, secure_sysmem, serial_hd(1));

    }



    if (tag_sysmem) {

        create_tag_ram(tag_sysmem, vms->memmap[VIRT_MEM].base,

                       machine->ram_size, "mach-virt.tag");

    }



    vms->highmem_ecam &= vms->highmem && (!firmware_loaded || aarch64);



    create_rtc(vms);

hw/i2c/core.c

+16 −2
Original line number Diff line number Diff line
@@ -267,13 +267,27 @@ const VMStateDescription vmstate_i2c_slave = { 
    }

};



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

DeviceState *i2c_try_create_slave(const char *name, uint8_t addr)

{

    DeviceState *dev;



    dev = qdev_new(name);

    qdev_prop_set_uint8(dev, "address", addr);

    qdev_realize_and_unref(dev, &bus->qbus, &error_fatal);

    return dev;

}



bool i2c_realize_and_unref(DeviceState *dev, I2CBus *bus, Error **errp)

{

    return qdev_realize_and_unref(dev, &bus->qbus, errp);

}



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

{

    DeviceState *dev;



    dev = i2c_try_create_slave(name, addr);

    i2c_realize_and_unref(dev, bus, &error_fatal);



    return dev;

}

hw/misc/pca9552.c

+162 −54
Original line number Diff line number Diff line
@@ -4,6 +4,7 @@ 
 *     https://www.nxp.com/docs/en/application-note/AN264.pdf

 *

 * Copyright (c) 2017-2018, IBM Corporation.

 * Copyright (c) 2020 Philippe Mathieu-Daudé

 *

 * This work is licensed under the terms of the GNU GPL, version 2 or

 * later. See the COPYING file in the top-level directory.
@@ -12,11 +13,29 @@ 
#include "qemu/osdep.h"

#include "qemu/log.h"

#include "qemu/module.h"

#include "qemu/bitops.h"

#include "hw/qdev-properties.h"

#include "hw/misc/pca9552.h"

#include "hw/misc/pca9552_regs.h"

#include "hw/irq.h"

#include "migration/vmstate.h"

#include "qapi/error.h"

#include "qapi/visitor.h"

#include "trace.h"



typedef struct PCA955xClass {

    /*< private >*/

    I2CSlaveClass parent_class;

    /*< public >*/



    uint8_t pin_count;

    uint8_t max_reg;

} PCA955xClass;



#define PCA955X_CLASS(klass) \

    OBJECT_CLASS_CHECK(PCA955xClass, (klass), TYPE_PCA955X)

#define PCA955X_GET_CLASS(obj) \

    OBJECT_GET_CLASS(PCA955xClass, (obj), TYPE_PCA955X)



#define PCA9552_LED_ON   0x0

#define PCA9552_LED_OFF  0x1
@@ -25,7 +44,7 @@ 


static const char *led_state[] = {"on", "off", "pwm0", "pwm1"};



static uint8_t pca9552_pin_get_config(PCA9552State *s, int pin)

static uint8_t pca955x_pin_get_config(PCA955xState *s, int pin)

{

    uint8_t reg   = PCA9552_LS0 + (pin / 4);

    uint8_t shift = (pin % 4) << 1;
@@ -33,20 +52,71 @@ static uint8_t pca9552_pin_get_config(PCA9552State *s, int pin) 
    return extract32(s->regs[reg], shift, 2);

}



static void pca9552_update_pin_input(PCA9552State *s)

/* Return INPUT status (bit #N belongs to GPIO #N) */

static uint16_t pca955x_pins_get_status(PCA955xState *s)

{

    return (s->regs[PCA9552_INPUT1] << 8) | s->regs[PCA9552_INPUT0];

}



static void pca955x_display_pins_status(PCA955xState *s,

                                        uint16_t previous_pins_status)

{

    PCA955xClass *k = PCA955X_GET_CLASS(s);

    uint16_t pins_status, pins_changed;

    int i;



    pins_status = pca955x_pins_get_status(s);

    pins_changed = previous_pins_status ^ pins_status;

    if (!pins_changed) {

        return;

    }

    if (trace_event_get_state_backends(TRACE_PCA955X_GPIO_STATUS)) {

        char *buf = g_newa(char, k->pin_count + 1);



        for (i = 0; i < k->pin_count; i++) {

            if (extract32(pins_status, i, 1)) {

                buf[i] = '*';

            } else {

                buf[i] = '.';

            }

        }

        buf[i] = '\0';

        trace_pca955x_gpio_status(s->description, buf);

    }

    if (trace_event_get_state_backends(TRACE_PCA955X_GPIO_CHANGE)) {

        for (i = 0; i < k->pin_count; i++) {

            if (extract32(pins_changed, i, 1)) {

                unsigned new_state = extract32(pins_status, i, 1);



                /*

                 * We display the state using the PCA logic ("active-high").

                 * This is not the state of the LED, which signal might be

                 * wired "active-low" on the board.

                 */

                trace_pca955x_gpio_change(s->description, i,

                                          !new_state, new_state);

            }

        }

    }

}



static void pca955x_update_pin_input(PCA955xState *s)

{

    PCA955xClass *k = PCA955X_GET_CLASS(s);

    int i;



    for (i = 0; i < s->nr_leds; i++) {

    for (i = 0; i < k->pin_count; i++) {

        uint8_t input_reg = PCA9552_INPUT0 + (i / 8);

        uint8_t input_shift = (i % 8);

        uint8_t config = pca9552_pin_get_config(s, i);

        uint8_t config = pca955x_pin_get_config(s, i);



        switch (config) {

        case PCA9552_LED_ON:

            qemu_set_irq(s->gpio[i], 1);

            s->regs[input_reg] |= 1 << input_shift;

            break;

        case PCA9552_LED_OFF:

            qemu_set_irq(s->gpio[i], 0);

            s->regs[input_reg] &= ~(1 << input_shift);

            break;

        case PCA9552_LED_PWM0:
@@ -58,7 +128,7 @@ static void pca9552_update_pin_input(PCA9552State *s) 
    }

}



static uint8_t pca9552_read(PCA9552State *s, uint8_t reg)

static uint8_t pca955x_read(PCA955xState *s, uint8_t reg)

{

    switch (reg) {

    case PCA9552_INPUT0:
@@ -79,8 +149,10 @@ static uint8_t pca9552_read(PCA9552State *s, uint8_t reg) 
    }

}



static void pca9552_write(PCA9552State *s, uint8_t reg, uint8_t data)

static void pca955x_write(PCA955xState *s, uint8_t reg, uint8_t data)

{

    uint16_t pins_status;



    switch (reg) {

    case PCA9552_PSC0:

    case PCA9552_PWM0:
@@ -93,8 +165,10 @@ static void pca9552_write(PCA9552State *s, uint8_t reg, uint8_t data) 
    case PCA9552_LS1:

    case PCA9552_LS2:

    case PCA9552_LS3:

        pins_status = pca955x_pins_get_status(s);

        s->regs[reg] = data;

        pca9552_update_pin_input(s);

        pca955x_update_pin_input(s);

        pca955x_display_pins_status(s, pins_status);

        break;



    case PCA9552_INPUT0:
@@ -110,22 +184,24 @@ static void pca9552_write(PCA9552State *s, uint8_t reg, uint8_t data) 
 * after each byte is sent to or received by the device. The index

 * rollovers to 0 when the maximum register address is reached.

 */

static void pca9552_autoinc(PCA9552State *s)

static void pca955x_autoinc(PCA955xState *s)

{

    PCA955xClass *k = PCA955X_GET_CLASS(s);



    if (s->pointer != 0xFF && s->pointer & PCA9552_AUTOINC) {

        uint8_t reg = s->pointer & 0xf;



        reg = (reg + 1) % (s->max_reg + 1);

        reg = (reg + 1) % (k->max_reg + 1);

        s->pointer = reg | PCA9552_AUTOINC;

    }

}



static uint8_t pca9552_recv(I2CSlave *i2c)

static uint8_t pca955x_recv(I2CSlave *i2c)

{

    PCA9552State *s = PCA9552(i2c);

    PCA955xState *s = PCA955X(i2c);

    uint8_t ret;



    ret = pca9552_read(s, s->pointer & 0xf);

    ret = pca955x_read(s, s->pointer & 0xf);



    /*

     * From the Specs:
@@ -143,40 +219,41 @@ static uint8_t pca9552_recv(I2CSlave *i2c) 
                      __func__);

    }



    pca9552_autoinc(s);

    pca955x_autoinc(s);



    return ret;

}



static int pca9552_send(I2CSlave *i2c, uint8_t data)

static int pca955x_send(I2CSlave *i2c, uint8_t data)

{

    PCA9552State *s = PCA9552(i2c);

    PCA955xState *s = PCA955X(i2c);



    /* First byte sent by is the register address */

    if (s->len == 0) {

        s->pointer = data;

        s->len++;

    } else {

        pca9552_write(s, s->pointer & 0xf, data);

        pca955x_write(s, s->pointer & 0xf, data);



        pca9552_autoinc(s);

        pca955x_autoinc(s);

    }



    return 0;

}



static int pca9552_event(I2CSlave *i2c, enum i2c_event event)

static int pca955x_event(I2CSlave *i2c, enum i2c_event event)

{

    PCA9552State *s = PCA9552(i2c);

    PCA955xState *s = PCA955X(i2c);



    s->len = 0;

    return 0;

}



static void pca9552_get_led(Object *obj, Visitor *v, const char *name,

static void pca955x_get_led(Object *obj, Visitor *v, const char *name,

                            void *opaque, Error **errp)

{

    PCA9552State *s = PCA9552(obj);

    PCA955xClass *k = PCA955X_GET_CLASS(obj);

    PCA955xState *s = PCA955X(obj);

    int led, rc, reg;

    uint8_t state;
@@ -185,7 +262,7 @@ static void pca9552_get_led(Object *obj, Visitor *v, const char *name, 
        error_setg(errp, "%s: error reading %s", __func__, name);

        return;

    }

    if (led < 0 || led > s->nr_leds) {

    if (led < 0 || led > k->pin_count) {

        error_setg(errp, "%s invalid led %s", __func__, name);

        return;

    }
@@ -195,7 +272,7 @@ static void pca9552_get_led(Object *obj, Visitor *v, const char *name, 
     * reading the INPUTx reg

     */

    reg = PCA9552_LS0 + led / 4;

    state = (pca9552_read(s, reg) >> (led % 8)) & 0x3;

    state = (pca955x_read(s, reg) >> (led % 8)) & 0x3;

    visit_type_str(v, name, (char **)&led_state[state], errp);

}
@@ -209,10 +286,11 @@ static inline uint8_t pca955x_ledsel(uint8_t oldval, int led_num, int state) 
                ((state & 0x3) << (led_num << 1));

}



static void pca9552_set_led(Object *obj, Visitor *v, const char *name,

static void pca955x_set_led(Object *obj, Visitor *v, const char *name,

                            void *opaque, Error **errp)

{

    PCA9552State *s = PCA9552(obj);

    PCA955xClass *k = PCA955X_GET_CLASS(obj);

    PCA955xState *s = PCA955X(obj);

    Error *local_err = NULL;

    int led, rc, reg, val;

    uint8_t state;
@@ -228,7 +306,7 @@ static void pca9552_set_led(Object *obj, Visitor *v, const char *name, 
        error_setg(errp, "%s: error reading %s", __func__, name);

        return;

    }

    if (led < 0 || led > s->nr_leds) {

    if (led < 0 || led > k->pin_count) {

        error_setg(errp, "%s invalid led %s", __func__, name);

        return;

    }
@@ -244,9 +322,9 @@ static void pca9552_set_led(Object *obj, Visitor *v, const char *name, 
    }



    reg = PCA9552_LS0 + led / 4;

    val = pca9552_read(s, reg);

    val = pca955x_read(s, reg);

    val = pca955x_ledsel(val, led % 4, state);

    pca9552_write(s, reg, val);

    pca955x_write(s, reg, val);

}



static const VMStateDescription pca9552_vmstate = {
@@ -254,17 +332,17 @@ static const VMStateDescription pca9552_vmstate = { 
    .version_id = 0,

    .minimum_version_id = 0,

    .fields = (VMStateField[]) {

        VMSTATE_UINT8(len, PCA9552State),

        VMSTATE_UINT8(pointer, PCA9552State),

        VMSTATE_UINT8_ARRAY(regs, PCA9552State, PCA9552_NR_REGS),

        VMSTATE_I2C_SLAVE(i2c, PCA9552State),

        VMSTATE_UINT8(len, PCA955xState),

        VMSTATE_UINT8(pointer, PCA955xState),

        VMSTATE_UINT8_ARRAY(regs, PCA955xState, PCA955X_NR_REGS),

        VMSTATE_I2C_SLAVE(i2c, PCA955xState),

        VMSTATE_END_OF_LIST()

    }

};



static void pca9552_reset(DeviceState *dev)

{

    PCA9552State *s = PCA9552(dev);

    PCA955xState *s = PCA955X(dev);



    s->regs[PCA9552_PSC0] = 0xFF;

    s->regs[PCA9552_PWM0] = 0x80;
@@ -275,57 +353,87 @@ static void pca9552_reset(DeviceState *dev) 
    s->regs[PCA9552_LS2] = 0x55;

    s->regs[PCA9552_LS3] = 0x55;



    pca9552_update_pin_input(s);

    pca955x_update_pin_input(s);



    s->pointer = 0xFF;

    s->len = 0;

}



static void pca9552_initfn(Object *obj)

static void pca955x_initfn(Object *obj)

{

    PCA9552State *s = PCA9552(obj);

    PCA955xClass *k = PCA955X_GET_CLASS(obj);

    int led;



    /* If support for the other PCA955X devices are implemented, these

     * constant values might be part of class structure describing the

     * PCA955X device

     */

    s->max_reg = PCA9552_LS3;

    s->nr_leds = 16;



    for (led = 0; led < s->nr_leds; led++) {

    assert(k->pin_count <= PCA955X_PIN_COUNT_MAX);

    for (led = 0; led < k->pin_count; led++) {

        char *name;



        name = g_strdup_printf("led%d", led);

        object_property_add(obj, name, "bool", pca9552_get_led, pca9552_set_led,

        object_property_add(obj, name, "bool", pca955x_get_led, pca955x_set_led,

                            NULL, NULL);

        g_free(name);

    }

}



static void pca9552_class_init(ObjectClass *klass, void *data)

static void pca955x_realize(DeviceState *dev, Error **errp)

{

    PCA955xClass *k = PCA955X_GET_CLASS(dev);

    PCA955xState *s = PCA955X(dev);



    if (!s->description) {

        s->description = g_strdup("pca-unspecified");

    }



    qdev_init_gpio_out(dev, s->gpio, k->pin_count);

}



static Property pca955x_properties[] = {

    DEFINE_PROP_STRING("description", PCA955xState, description),

    DEFINE_PROP_END_OF_LIST(),

};



static void pca955x_class_init(ObjectClass *klass, void *data)

{

    DeviceClass *dc = DEVICE_CLASS(klass);

    I2CSlaveClass *k = I2C_SLAVE_CLASS(klass);



    k->event = pca9552_event;

    k->recv = pca9552_recv;

    k->send = pca9552_send;

    k->event = pca955x_event;

    k->recv = pca955x_recv;

    k->send = pca955x_send;

    dc->realize = pca955x_realize;

    device_class_set_props(dc, pca955x_properties);

}



static const TypeInfo pca955x_info = {

    .name          = TYPE_PCA955X,

    .parent        = TYPE_I2C_SLAVE,

    .instance_init = pca955x_initfn,

    .instance_size = sizeof(PCA955xState),

    .class_init    = pca955x_class_init,

    .abstract      = true,

};



static void pca9552_class_init(ObjectClass *oc, void *data)

{

    DeviceClass *dc = DEVICE_CLASS(oc);

    PCA955xClass *pc = PCA955X_CLASS(oc);



    dc->reset = pca9552_reset;

    dc->vmsd = &pca9552_vmstate;

    pc->max_reg = PCA9552_LS3;

    pc->pin_count = 16;

}



static const TypeInfo pca9552_info = {

    .name          = TYPE_PCA9552,

    .parent        = TYPE_I2C_SLAVE,

    .instance_init = pca9552_initfn,

    .instance_size = sizeof(PCA9552State),

    .parent        = TYPE_PCA955X,

    .class_init    = pca9552_class_init,

};



static void pca9552_register_types(void)

static void pca955x_register_types(void)

{

    type_register_static(&pca955x_info);

    type_register_static(&pca9552_info);

}



type_init(pca9552_register_types)
 
type_init(pca955x_register_types)

hw/misc/trace-events

+4 −0
Original line number Diff line number Diff line
@@ -209,3 +209,7 @@ via1_adb_poll(uint8_t data, const char *vadbint, int status, int index, int size 
# grlib_ahb_apb_pnp.c

grlib_ahb_pnp_read(uint64_t addr, uint32_t value) "AHB PnP read addr:0x%03"PRIx64" data:0x%08x"

grlib_apb_pnp_read(uint64_t addr, uint32_t value) "APB PnP read addr:0x%03"PRIx64" data:0x%08x"



# pca9552.c

pca955x_gpio_status(const char *description, const char *buf) "%s GPIOs 0-15 [%s]"

pca955x_gpio_change(const char *description, unsigned id, unsigned prev_state, unsigned current_state) "%s GPIO id:%u status: %u -> %u"