static void stellaris_init(const char *kernel_filename, const char *cpu_model,

                           stellaris_board_info *board)

{

    static const int uart_irq[] = {5, 6, 33, 34};

    static const int timer_irq[] = {19, 21, 23, 35};

    static const uint32_t gpio_addr[7] =

      { 0x40004000, 0x40005000, 0x40006000, 0x40007000,

        0x40024000, 0x40025000, 0x40026000};

    static const int gpio_irq[7] = {0, 1, 2, 3, 4, 30, 31};



    qemu_irq *pic;

    DeviceState *gpio_dev[7];

    qemu_irq gpio_in[7][8];

    qemu_irq gpio_out[7][8];

    qemu_irq adc;

    int sram_size;

    int flash_size;

    I2CBus *i2c;

    DeviceState *dev;

    int i;

    int j;



    MemoryRegion *sram = g_new(MemoryRegion, 1);

    MemoryRegion *flash = g_new(MemoryRegion, 1);

    MemoryRegion *system_memory = get_system_memory();



    flash_size = (((board->dc0 & 0xffff) + 1) << 1) * 1024;

    sram_size = ((board->dc0 >> 18) + 1) * 1024;



    /* Flash programming is done via the SCU, so pretend it is ROM.  */

    memory_region_init_ram(flash, NULL, "stellaris.flash", flash_size,

                           &error_abort);

    vmstate_register_ram_global(flash);

    memory_region_set_readonly(flash, true);

    memory_region_add_subregion(system_memory, 0, flash);



    memory_region_init_ram(sram, NULL, "stellaris.sram", sram_size,

                           &error_abort);

    vmstate_register_ram_global(sram);

    memory_region_add_subregion(system_memory, 0x20000000, sram);



    pic = armv7m_init(system_memory, flash_size, NUM_IRQ_LINES,

                      kernel_filename, cpu_model);



    if (board->dc1 & (1 << 16)) {

        dev = sysbus_create_varargs(TYPE_STELLARIS_ADC, 0x40038000,

                                    pic[14], pic[15], pic[16], pic[17], NULL);

        adc = qdev_get_gpio_in(dev, 0);

    } else {

        adc = NULL;

    }

    for (i = 0; i < 4; i++) {

        if (board->dc2 & (0x10000 << i)) {

            dev = sysbus_create_simple(TYPE_STELLARIS_GPTM,

                                       0x40030000 + i * 0x1000,

                                       pic[timer_irq[i]]);

            /* TODO: This is incorrect, but we get away with it because

               the ADC output is only ever pulsed.  */

            qdev_connect_gpio_out(dev, 0, adc);

        }

    }



    stellaris_sys_init(0x400fe000, pic[28], board, nd_table[0].macaddr.a);



    for (i = 0; i < 7; i++) {

        if (board->dc4 & (1 << i)) {

            gpio_dev[i] = sysbus_create_simple("pl061_luminary", gpio_addr[i],

                                               pic[gpio_irq[i]]);

            for (j = 0; j < 8; j++) {

                gpio_in[i][j] = qdev_get_gpio_in(gpio_dev[i], j);

                gpio_out[i][j] = NULL;

            }

        }

    }



    if (board->dc2 & (1 << 12)) {

        dev = sysbus_create_simple(TYPE_STELLARIS_I2C, 0x40020000, pic[8]);

        i2c = (I2CBus *)qdev_get_child_bus(dev, "i2c");

        if (board->peripherals & BP_OLED_I2C) {

            i2c_create_slave(i2c, "ssd0303", 0x3d);

        }

    }



    for (i = 0; i < 4; i++) {

        if (board->dc2 & (1 << i)) {

            sysbus_create_simple("pl011_luminary", 0x4000c000 + i * 0x1000,

                                 pic[uart_irq[i]]);

        }

    }

    if (board->dc2 & (1 << 4)) {

        dev = sysbus_create_simple("pl022", 0x40008000, pic[7]);

        if (board->peripherals & BP_OLED_SSI) {

            void *bus;

            DeviceState *sddev;

            DeviceState *ssddev;



            /* Some boards have both an OLED controller and SD card connected to

             * the same SSI port, with the SD card chip select connected to a

             * GPIO pin.  Technically the OLED chip select is connected to the

             * SSI Fss pin.  We do not bother emulating that as both devices

             * should never be selected simultaneously, and our OLED controller

             * ignores stray 0xff commands that occur when deselecting the SD

             * card.

             */

            bus = qdev_get_child_bus(dev, "ssi");



            sddev = ssi_create_slave(bus, "ssi-sd");

            ssddev = ssi_create_slave(bus, "ssd0323");

            gpio_out[GPIO_D][0] = qemu_irq_split(

                    qdev_get_gpio_in_named(sddev, SSI_GPIO_CS, 0),

                    qdev_get_gpio_in_named(ssddev, SSI_GPIO_CS, 0));

            gpio_out[GPIO_C][7] = qdev_get_gpio_in(ssddev, 0);



            /* Make sure the select pin is high.  */

            qemu_irq_raise(gpio_out[GPIO_D][0]);

        }

    }

    if (board->dc4 & (1 << 28)) {

        DeviceState *enet;



        qemu_check_nic_model(&nd_table[0], "stellaris");



        enet = qdev_create(NULL, "stellaris_enet");

        qdev_set_nic_properties(enet, &nd_table[0]);

        qdev_init_nofail(enet);

        sysbus_mmio_map(SYS_BUS_DEVICE(enet), 0, 0x40048000);

        sysbus_connect_irq(SYS_BUS_DEVICE(enet), 0, pic[42]);

    }

    if (board->peripherals & BP_GAMEPAD) {

        qemu_irq gpad_irq[5];

        static const int gpad_keycode[5] = { 0xc8, 0xd0, 0xcb, 0xcd, 0x1d };



        gpad_irq[0] = qemu_irq_invert(gpio_in[GPIO_E][0]); /* up */

        gpad_irq[1] = qemu_irq_invert(gpio_in[GPIO_E][1]); /* down */

        gpad_irq[2] = qemu_irq_invert(gpio_in[GPIO_E][2]); /* left */

        gpad_irq[3] = qemu_irq_invert(gpio_in[GPIO_E][3]); /* right */

        gpad_irq[4] = qemu_irq_invert(gpio_in[GPIO_F][1]); /* select */



        stellaris_gamepad_init(5, gpad_irq, gpad_keycode);

    }

    for (i = 0; i < 7; i++) {

        if (board->dc4 & (1 << i)) {

            for (j = 0; j < 8; j++) {

                if (gpio_out[i][j]) {

                    qdev_connect_gpio_out(gpio_dev[i], j, gpio_out[i][j]);

                }

            }

        }

    }

}

static void stellaris_init(const char *kernel_filename, const char *cpu_model,

                           stellaris_board_info *board)

{

    static const int uart_irq[] = {5, 6, 33, 34};

    static const int timer_irq[] = {19, 21, 23, 35};

    static const uint32_t gpio_addr[7] =

      { 0x40004000, 0x40005000, 0x40006000, 0x40007000,

        0x40024000, 0x40025000, 0x40026000};

    static const int gpio_irq[7] = {0, 1, 2, 3, 4, 30, 31};



    qemu_irq *pic;

    DeviceState *gpio_dev[7];

    qemu_irq gpio_in[7][8];

    qemu_irq gpio_out[7][8];

    qemu_irq adc;

    int sram_size;

    int flash_size;

    I2CBus *i2c;

    DeviceState *dev;

    int i;

    int j;



    MemoryRegion *sram = g_new(MemoryRegion, 1);

    MemoryRegion *flash = g_new(MemoryRegion, 1);

    MemoryRegion *system_memory = get_system_memory();



    flash_size = (((board->dc0 & 0xffff) + 1) << 1) * 1024;

    sram_size = ((board->dc0 >> 18) + 1) * 1024;



    

    memory_region_init_ram(flash, NULL, "stellaris.flash", flash_size,

                           &error_abort);

    vmstate_register_ram_global(flash);

    memory_region_set_readonly(flash, true);

    memory_region_add_subregion(system_memory, 0, flash);



    memory_region_init_ram(sram, NULL, "stellaris.sram", sram_size,

                           &error_abort);

    vmstate_register_ram_global(sram);

    memory_region_add_subregion(system_memory, 0x20000000, sram);



    pic = armv7m_init(system_memory, flash_size, NUM_IRQ_LINES,

                      kernel_filename, cpu_model);



    if (board->dc1 & (1 << 16)) {

        dev = sysbus_create_varargs(TYPE_STELLARIS_ADC, 0x40038000,

                                    pic[14], pic[15], pic[16], pic[17], NULL);

        adc = qdev_get_gpio_in(dev, 0);

    } else {

        adc = NULL;

    }

    for (i = 0; i < 4; i++) {

        if (board->dc2 & (0x10000 << i)) {

            dev = sysbus_create_simple(TYPE_STELLARIS_GPTM,

                                       0x40030000 + i * 0x1000,

                                       pic[timer_irq[i]]);

            



            qdev_connect_gpio_out(dev, 0, adc);

        }

    }



    stellaris_sys_init(0x400fe000, pic[28], board, nd_table[0].macaddr.a);



    for (i = 0; i < 7; i++) {

        if (board->dc4 & (1 << i)) {

            gpio_dev[i] = sysbus_create_simple("pl061_luminary", gpio_addr[i],

                                               pic[gpio_irq[i]]);

            for (j = 0; j < 8; j++) {

                gpio_in[i][j] = qdev_get_gpio_in(gpio_dev[i], j);

                gpio_out[i][j] = NULL;

            }

        }

    }



    if (board->dc2 & (1 << 12)) {

        dev = sysbus_create_simple(TYPE_STELLARIS_I2C, 0x40020000, pic[8]);

        i2c = (I2CBus *)qdev_get_child_bus(dev, "i2c");

        if (board->peripherals & BP_OLED_I2C) {

            i2c_create_slave(i2c, "ssd0303", 0x3d);

        }

    }



    for (i = 0; i < 4; i++) {

        if (board->dc2 & (1 << i)) {

            sysbus_create_simple("pl011_luminary", 0x4000c000 + i * 0x1000,

                                 pic[uart_irq[i]]);

        }

    }

    if (board->dc2 & (1 << 4)) {

        dev = sysbus_create_simple("pl022", 0x40008000, pic[7]);

        if (board->peripherals & BP_OLED_SSI) {

            void *bus;

            DeviceState *sddev;

            DeviceState *ssddev;



            















            bus = qdev_get_child_bus(dev, "ssi");



            sddev = ssi_create_slave(bus, "ssi-sd");

            ssddev = ssi_create_slave(bus, "ssd0323");

            gpio_out[GPIO_D][0] = qemu_irq_split(

                    qdev_get_gpio_in_named(sddev, SSI_GPIO_CS, 0),

                    qdev_get_gpio_in_named(ssddev, SSI_GPIO_CS, 0));

            gpio_out[GPIO_C][7] = qdev_get_gpio_in(ssddev, 0);



            

            qemu_irq_raise(gpio_out[GPIO_D][0]);

        }

    }

    if (board->dc4 & (1 << 28)) {

        DeviceState *enet;



        qemu_check_nic_model(&nd_table[0], "stellaris");



        enet = qdev_create(NULL, "stellaris_enet");

        qdev_set_nic_properties(enet, &nd_table[0]);

        qdev_init_nofail(enet);

        sysbus_mmio_map(SYS_BUS_DEVICE(enet), 0, 0x40048000);

        sysbus_connect_irq(SYS_BUS_DEVICE(enet), 0, pic[42]);

    }

    if (board->peripherals & BP_GAMEPAD) {

        qemu_irq gpad_irq[5];

        static const int gpad_keycode[5] = { 0xc8, 0xd0, 0xcb, 0xcd, 0x1d };



        gpad_irq[0] = qemu_irq_invert(gpio_in[GPIO_E][0]); 

        gpad_irq[1] = qemu_irq_invert(gpio_in[GPIO_E][1]); 

        gpad_irq[2] = qemu_irq_invert(gpio_in[GPIO_E][2]); 

        gpad_irq[3] = qemu_irq_invert(gpio_in[GPIO_E][3]); 

        gpad_irq[4] = qemu_irq_invert(gpio_in[GPIO_F][1]); 



        stellaris_gamepad_init(5, gpad_irq, gpad_keycode);

    }

    for (i = 0; i < 7; i++) {

        if (board->dc4 & (1 << i)) {

            for (j = 0; j < 8; j++) {

                if (gpio_out[i][j]) {

                    qdev_connect_gpio_out(gpio_dev[i], j, gpio_out[i][j]);

                }

            }

        }

    }

}

                           &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);                            &error_abort);
static void FUNC_0(const char *VAR_0, const char *VAR_1,

                           stellaris_board_info *VAR_2)

{

    static const int VAR_3[] = {5, 6, 33, 34};

    static const int VAR_4[] = {19, 21, 23, 35};

    static const uint32_t VAR_5[7] =

      { 0x40004000, 0x40005000, 0x40006000, 0x40007000,

        0x40024000, 0x40025000, 0x40026000};

    static const int VAR_6[7] = {0, 1, 2, 3, 4, 30, 31};



    qemu_irq *pic;

    DeviceState *gpio_dev[7];

    qemu_irq gpio_in[7][8];

    qemu_irq gpio_out[7][8];

    qemu_irq adc;

    int VAR_7;

    int VAR_8;

    I2CBus *i2c;

    DeviceState *dev;

    int VAR_9;

    int VAR_10;



    MemoryRegion *sram = g_new(MemoryRegion, 1);

    MemoryRegion *flash = g_new(MemoryRegion, 1);

    MemoryRegion *system_memory = get_system_memory();



    VAR_8 = (((VAR_2->dc0 & 0xffff) + 1) << 1) * 1024;

    VAR_7 = ((VAR_2->dc0 >> 18) + 1) * 1024;



    

    memory_region_init_ram(flash, NULL, "stellaris.flash", VAR_8,

                           &error_abort);

    vmstate_register_ram_global(flash);

    memory_region_set_readonly(flash, true);

    memory_region_add_subregion(system_memory, 0, flash);



    memory_region_init_ram(sram, NULL, "stellaris.sram", VAR_7,

                           &error_abort);

    vmstate_register_ram_global(sram);

    memory_region_add_subregion(system_memory, 0x20000000, sram);



    pic = armv7m_init(system_memory, VAR_8, NUM_IRQ_LINES,

                      VAR_0, VAR_1);



    if (VAR_2->dc1 & (1 << 16)) {

        dev = sysbus_create_varargs(TYPE_STELLARIS_ADC, 0x40038000,

                                    pic[14], pic[15], pic[16], pic[17], NULL);

        adc = qdev_get_gpio_in(dev, 0);

    } else {

        adc = NULL;

    }

    for (VAR_9 = 0; VAR_9 < 4; VAR_9++) {

        if (VAR_2->dc2 & (0x10000 << VAR_9)) {

            dev = sysbus_create_simple(TYPE_STELLARIS_GPTM,

                                       0x40030000 + VAR_9 * 0x1000,

                                       pic[VAR_4[VAR_9]]);

            



            qdev_connect_gpio_out(dev, 0, adc);

        }

    }



    stellaris_sys_init(0x400fe000, pic[28], VAR_2, nd_table[0].macaddr.a);



    for (VAR_9 = 0; VAR_9 < 7; VAR_9++) {

        if (VAR_2->dc4 & (1 << VAR_9)) {

            gpio_dev[VAR_9] = sysbus_create_simple("pl061_luminary", VAR_5[VAR_9],

                                               pic[VAR_6[VAR_9]]);

            for (VAR_10 = 0; VAR_10 < 8; VAR_10++) {

                gpio_in[VAR_9][VAR_10] = qdev_get_gpio_in(gpio_dev[VAR_9], VAR_10);

                gpio_out[VAR_9][VAR_10] = NULL;

            }

        }

    }



    if (VAR_2->dc2 & (1 << 12)) {

        dev = sysbus_create_simple(TYPE_STELLARIS_I2C, 0x40020000, pic[8]);

        i2c = (I2CBus *)qdev_get_child_bus(dev, "i2c");

        if (VAR_2->peripherals & BP_OLED_I2C) {

            i2c_create_slave(i2c, "ssd0303", 0x3d);

        }

    }



    for (VAR_9 = 0; VAR_9 < 4; VAR_9++) {

        if (VAR_2->dc2 & (1 << VAR_9)) {

            sysbus_create_simple("pl011_luminary", 0x4000c000 + VAR_9 * 0x1000,

                                 pic[VAR_3[VAR_9]]);

        }

    }

    if (VAR_2->dc2 & (1 << 4)) {

        dev = sysbus_create_simple("pl022", 0x40008000, pic[7]);

        if (VAR_2->peripherals & BP_OLED_SSI) {

            void *VAR_11;

            DeviceState *sddev;

            DeviceState *ssddev;



            















            VAR_11 = qdev_get_child_bus(dev, "ssi");



            sddev = ssi_create_slave(VAR_11, "ssi-sd");

            ssddev = ssi_create_slave(VAR_11, "ssd0323");

            gpio_out[GPIO_D][0] = qemu_irq_split(

                    qdev_get_gpio_in_named(sddev, SSI_GPIO_CS, 0),

                    qdev_get_gpio_in_named(ssddev, SSI_GPIO_CS, 0));

            gpio_out[GPIO_C][7] = qdev_get_gpio_in(ssddev, 0);



            

            qemu_irq_raise(gpio_out[GPIO_D][0]);

        }

    }

    if (VAR_2->dc4 & (1 << 28)) {

        DeviceState *enet;



        qemu_check_nic_model(&nd_table[0], "stellaris");



        enet = qdev_create(NULL, "stellaris_enet");

        qdev_set_nic_properties(enet, &nd_table[0]);

        qdev_init_nofail(enet);

        sysbus_mmio_map(SYS_BUS_DEVICE(enet), 0, 0x40048000);

        sysbus_connect_irq(SYS_BUS_DEVICE(enet), 0, pic[42]);

    }

    if (VAR_2->peripherals & BP_GAMEPAD) {

        qemu_irq gpad_irq[5];

        static const int VAR_12[5] = { 0xc8, 0xd0, 0xcb, 0xcd, 0x1d };



        gpad_irq[0] = qemu_irq_invert(gpio_in[GPIO_E][0]); 

        gpad_irq[1] = qemu_irq_invert(gpio_in[GPIO_E][1]); 

        gpad_irq[2] = qemu_irq_invert(gpio_in[GPIO_E][2]); 

        gpad_irq[3] = qemu_irq_invert(gpio_in[GPIO_E][3]); 

        gpad_irq[4] = qemu_irq_invert(gpio_in[GPIO_F][1]); 



        stellaris_gamepad_init(5, gpad_irq, VAR_12);

    }

    for (VAR_9 = 0; VAR_9 < 7; VAR_9++) {

        if (VAR_2->dc4 & (1 << VAR_9)) {

            for (VAR_10 = 0; VAR_10 < 8; VAR_10++) {

                if (gpio_out[VAR_9][VAR_10]) {

                    qdev_connect_gpio_out(gpio_dev[VAR_9], VAR_10, gpio_out[VAR_9][VAR_10]);

                }

            }

        }

    }

}

static void FUNC_0(const char *VAR_0, const char *VAR_1,
stellaris_board_info *VAR_2)
{ static const int VAR_3[] = {5, 6, 33, 34}; static const int VAR_4[] = {19, 21, 23, 35}; static const uint32_t VAR_5[7] =
{ 0x40004000, 0x40005000, 0x40006000, 0x40007000, 0x40024000, 0x40025000, 0x40026000}; static const int VAR_6[7] = {0, 1, 2, 3, 4, 30, 31}; qemu_irq *pic; DeviceState *gpio_dev[7]; qemu_irq gpio_in[7][8]; qemu_irq gpio_out[7][8]; qemu_irq adc; int VAR_7; int VAR_8; I2CBus *i2c; DeviceState *dev; int VAR_9; int VAR_10; MemoryRegion *sram = g_new(MemoryRegion, 1); MemoryRegion *flash = g_new(MemoryRegion, 1); MemoryRegion *system_memory = get_system_memory(); VAR_8 = (((VAR_2->dc0 & 0xffff) + 1) << 1) * 1024; VAR_7 = ((VAR_2->dc0 >> 18) + 1) * 1024; memory_region_init_ram(flash, NULL, "stellaris.flash", VAR_8,
&error_abort); vmstate_register_ram_global(flash); memory_region_set_readonly(flash, true); memory_region_add_subregion(system_memory, 0, flash); memory_region_init_ram(sram, NULL, "stellaris.sram", VAR_7,
&error_abort); vmstate_register_ram_global(sram); memory_region_add_subregion(system_memory, 0x20000000, sram); pic = armv7m_init(system_memory, VAR_8, NUM_IRQ_LINES,
VAR_0, VAR_1); if (VAR_2->dc1 & (1 << 16)) { dev = sysbus_create_varargs(TYPE_STELLARIS_ADC, 0x40038000,
pic[14], pic[15], pic[16], pic[17], NULL); adc = qdev_get_gpio_in(dev, 0); } else { adc = NULL; } for (VAR_9 = 0; VAR_9 < 4; VAR_9++) { if (VAR_2->dc2 & (0x10000 << VAR_9)) { dev = sysbus_create_simple(TYPE_STELLARIS_GPTM,
0x40030000 + VAR_9 * 0x1000,
pic[VAR_4[VAR_9]]); qdev_connect_gpio_out(dev, 0, adc); } } stellaris_sys_init(0x400fe000, pic[28], VAR_2, nd_table[0].macaddr.a); for (VAR_9 = 0; VAR_9 < 7; VAR_9++) { if (VAR_2->dc4 & (1 << VAR_9)) { gpio_dev[VAR_9] = sysbus_create_simple("pl061_luminary", VAR_5[VAR_9],
pic[VAR_6[VAR_9]]); for (VAR_10 = 0; VAR_10 < 8; VAR_10++) { gpio_in[VAR_9][VAR_10] = qdev_get_gpio_in(gpio_dev[VAR_9], VAR_10); gpio_out[VAR_9][VAR_10] = NULL; } } } if (VAR_2->dc2 & (1 << 12)) { dev = sysbus_create_simple(TYPE_STELLARIS_I2C, 0x40020000, pic[8]); i2c = (I2CBus *)qdev_get_child_bus(dev, "i2c"); if (VAR_2->peripherals & BP_OLED_I2C) { i2c_create_slave(i2c, "ssd0303", 0x3d); } } for (VAR_9 = 0; VAR_9 < 4; VAR_9++) { if (VAR_2->dc2 & (1 << VAR_9)) { sysbus_create_simple("pl011_luminary", 0x4000c000 + VAR_9 * 0x1000,
pic[VAR_3[VAR_9]]); } } if (VAR_2->dc2 & (1 << 4)) { dev = sysbus_create_simple("pl022", 0x40008000, pic[7]); if (VAR_2->peripherals & BP_OLED_SSI) { void *VAR_11; DeviceState *sddev; DeviceState *ssddev; VAR_11 = qdev_get_child_bus(dev, "ssi"); sddev = ssi_create_slave(VAR_11, "ssi-sd"); ssddev = ssi_create_slave(VAR_11, "ssd0323"); gpio_out[GPIO_D][0] = qemu_irq_split(
qdev_get_gpio_in_named(sddev, SSI_GPIO_CS, 0),
qdev_get_gpio_in_named(ssddev, SSI_GPIO_CS, 0)); gpio_out[GPIO_C][7] = qdev_get_gpio_in(ssddev, 0); qemu_irq_raise(gpio_out[GPIO_D][0]); } } if (VAR_2->dc4 & (1 << 28)) { DeviceState *enet; qemu_check_nic_model(&nd_table[0], "stellaris"); enet = qdev_create(NULL, "stellaris_enet"); qdev_set_nic_properties(enet, &nd_table[0]); qdev_init_nofail(enet); sysbus_mmio_map(SYS_BUS_DEVICE(enet), 0, 0x40048000); sysbus_connect_irq(SYS_BUS_DEVICE(enet), 0, pic[42]); } if (VAR_2->peripherals & BP_GAMEPAD) { qemu_irq gpad_irq[5]; static const int VAR_12[5] = { 0xc8, 0xd0, 0xcb, 0xcd, 0x1d }; gpad_irq[0] = qemu_irq_invert(gpio_in[GPIO_E][0]); gpad_irq[1] = qemu_irq_invert(gpio_in[GPIO_E][1]); gpad_irq[2] = qemu_irq_invert(gpio_in[GPIO_E][2]); gpad_irq[3] = qemu_irq_invert(gpio_in[GPIO_E][3]); gpad_irq[4] = qemu_irq_invert(gpio_in[GPIO_F][1]); stellaris_gamepad_init(5, gpad_irq, VAR_12); } for (VAR_9 = 0; VAR_9 < 7; VAR_9++) { if (VAR_2->dc4 & (1 << VAR_9)) { for (VAR_10 = 0; VAR_10 < 8; VAR_10++) { if (gpio_out[VAR_9][VAR_10]) { qdev_connect_gpio_out(gpio_dev[VAR_9], VAR_10, gpio_out[VAR_9][VAR_10]); } } } } }