max_en = !level;        break;    }}#define MAX1111_BATT_VOLT	1#define MAX1111_BATT_TEMP	2#define MAX1111_ACIN_VOLT	3#define SPITZ_BATTERY_TEMP	0xe0	/* About 2.9V */#define SPITZ_BATTERY_VOLT	0xd0	/* About 4.0V */#define SPITZ_CHARGEON_ACIN	0x80	/* About 5.0V */static void spitz_adc_temp_on(void *opaque, int line, int level){    if (!max1111)        return;    if (level)        max111x_set_input(max1111, MAX1111_BATT_TEMP, SPITZ_BATTERY_TEMP);    else        max111x_set_input(max1111, MAX1111_BATT_TEMP, 0);}static void spitz_ssp_save(QEMUFile *f, void *opaque){    qemu_put_be32(f, lcd_en);    qemu_put_be32(f, ads_en);    qemu_put_be32(f, max_en);    qemu_put_be32(f, bl_intensity);    qemu_put_be32(f, bl_power);}static int spitz_ssp_load(QEMUFile *f, void *opaque, int version_id){    lcd_en = qemu_get_be32(f);    ads_en = qemu_get_be32(f);    max_en = qemu_get_be32(f);    bl_intensity = qemu_get_be32(f);    bl_power = qemu_get_be32(f);    return 0;}static void spitz_ssp_attach(struct pxa2xx_state_s *cpu){    qemu_irq *chipselects;    lcd_en = ads_en = max_en = 0;    ads7846 = ads7846_init(pxa2xx_gpio_in_get(cpu->gpio)[SPITZ_GPIO_TP_INT]);    max1111 = max1111_init(0);    max111x_set_input(max1111, MAX1111_BATT_VOLT, SPITZ_BATTERY_VOLT);    max111x_set_input(max1111, MAX1111_BATT_TEMP, 0);    max111x_set_input(max1111, MAX1111_ACIN_VOLT, SPITZ_CHARGEON_ACIN);    pxa2xx_ssp_attach(cpu->ssp[CORGI_SSP_PORT - 1], corgi_ssp_read,                    corgi_ssp_write, cpu);    chipselects = qemu_allocate_irqs(corgi_ssp_gpio_cs, cpu, 3);    pxa2xx_gpio_out_set(cpu->gpio, SPITZ_GPIO_LCDCON_CS,  chipselects[0]);    pxa2xx_gpio_out_set(cpu->gpio, SPITZ_GPIO_ADS7846_CS, chipselects[1]);    pxa2xx_gpio_out_set(cpu->gpio, SPITZ_GPIO_MAX1111_CS, chipselects[2]);    bl_intensity = 0x20;    bl_power = 0;    register_savevm("spitz_ssp", 0, 0, spitz_ssp_save, spitz_ssp_load, cpu);}/* CF Microdrive */static void spitz_microdrive_attach(struct pxa2xx_state_s *cpu){    struct pcmcia_card_s *md;    int index;    BlockDriverState *bs;    index = drive_get_index(IF_IDE, 0, 0);    if (index == -1)        return;    bs = drives_table[index].bdrv;    if (bdrv_is_inserted(bs) && !bdrv_is_removable(bs)) {        md = dscm1xxxx_init(bs);        pxa2xx_pcmcia_attach(cpu->pcmcia[1], md);    }}/* Wm8750 and Max7310 on I2C */#define AKITA_MAX_ADDR	0x18#define SPITZ_WM_ADDRL	0x1b#define SPITZ_WM_ADDRH	0x1a#define SPITZ_GPIO_WM	5#ifdef HAS_AUDIOstatic void spitz_wm8750_addr(void *opaque, int line, int level){    i2c_slave *wm = (i2c_slave *) opaque;    if (level)        i2c_set_slave_address(wm, SPITZ_WM_ADDRH);    else        i2c_set_slave_address(wm, SPITZ_WM_ADDRL);}#endifstatic void spitz_i2c_setup(struct pxa2xx_state_s *cpu){    /* Attach the CPU on one end of our I2C bus.  */    i2c_bus *bus = pxa2xx_i2c_bus(cpu->i2c[0]);#ifdef HAS_AUDIO    AudioState *audio;    i2c_slave *wm;    audio = AUD_init();    if (!audio)        return;    /* Attach a WM8750 to the bus */    wm = wm8750_init(bus, audio);    spitz_wm8750_addr(wm, 0, 0);    pxa2xx_gpio_out_set(cpu->gpio, SPITZ_GPIO_WM,                    qemu_allocate_irqs(spitz_wm8750_addr, wm, 1)[0]);    /* .. and to the sound interface.  */    cpu->i2s->opaque = wm;    cpu->i2s->codec_out = wm8750_dac_dat;    cpu->i2s->codec_in = wm8750_adc_dat;    wm8750_data_req_set(wm, cpu->i2s->data_req, cpu->i2s);#endif}static void spitz_akita_i2c_setup(struct pxa2xx_state_s *cpu){    /* Attach a Max7310 to Akita I2C bus.  */    i2c_set_slave_address(max7310_init(pxa2xx_i2c_bus(cpu->i2c[0])),                    AKITA_MAX_ADDR);}/* Other peripherals */static void spitz_out_switch(void *opaque, int line, int level){    switch (line) {    case 0:        spitz_printf("Charging %s.\n", level ? "off" : "on");        break;    case 1:        spitz_printf("Discharging %s.\n", level ? "on" : "off");        break;    case 2:        spitz_printf("Green LED %s.\n", level ? "on" : "off");        break;    case 3:        spitz_printf("Orange LED %s.\n", level ? "on" : "off");        break;    case 4:        spitz_bl_bit5(opaque, line, level);        break;    case 5:        spitz_bl_power(opaque, line, level);        break;    case 6:        spitz_adc_temp_on(opaque, line, level);        break;    }}#define SPITZ_SCP_LED_GREEN		1#define SPITZ_SCP_JK_B			2#define SPITZ_SCP_CHRG_ON		3#define SPITZ_SCP_MUTE_L		4#define SPITZ_SCP_MUTE_R		5#define SPITZ_SCP_CF_POWER		6#define SPITZ_SCP_LED_ORANGE		7#define SPITZ_SCP_JK_A			8#define SPITZ_SCP_ADC_TEMP_ON		9#define SPITZ_SCP2_IR_ON		1#define SPITZ_SCP2_AKIN_PULLUP		2#define SPITZ_SCP2_BACKLIGHT_CONT	7#define SPITZ_SCP2_BACKLIGHT_ON		8#define SPITZ_SCP2_MIC_BIAS		9static void spitz_scoop_gpio_setup(struct pxa2xx_state_s *cpu,                struct scoop_info_s *scp, int num){    qemu_irq *outsignals = qemu_allocate_irqs(spitz_out_switch, cpu, 8);    scoop_gpio_out_set(&scp[0], SPITZ_SCP_CHRG_ON, outsignals[0]);    scoop_gpio_out_set(&scp[0], SPITZ_SCP_JK_B, outsignals[1]);    scoop_gpio_out_set(&scp[0], SPITZ_SCP_LED_GREEN, outsignals[2]);    scoop_gpio_out_set(&scp[0], SPITZ_SCP_LED_ORANGE, outsignals[3]);    if (num >= 2) {        scoop_gpio_out_set(&scp[1], SPITZ_SCP2_BACKLIGHT_CONT, outsignals[4]);        scoop_gpio_out_set(&scp[1], SPITZ_SCP2_BACKLIGHT_ON, outsignals[5]);    }    scoop_gpio_out_set(&scp[0], SPITZ_SCP_ADC_TEMP_ON, outsignals[6]);}#define SPITZ_GPIO_HSYNC		22#define SPITZ_GPIO_SD_DETECT		9#define SPITZ_GPIO_SD_WP		81#define SPITZ_GPIO_ON_RESET		89#define SPITZ_GPIO_BAT_COVER		90#define SPITZ_GPIO_CF1_IRQ		105#define SPITZ_GPIO_CF1_CD		94#define SPITZ_GPIO_CF2_IRQ		106#define SPITZ_GPIO_CF2_CD		93static int spitz_hsync;static void spitz_lcd_hsync_handler(void *opaque, int line, int level){    struct pxa2xx_state_s *cpu = (struct pxa2xx_state_s *) opaque;    qemu_set_irq(pxa2xx_gpio_in_get(cpu->gpio)[SPITZ_GPIO_HSYNC], spitz_hsync);    spitz_hsync ^= 1;}static void spitz_gpio_setup(struct pxa2xx_state_s *cpu, int slots){    qemu_irq lcd_hsync;    /*     * Bad hack: We toggle the LCD hsync GPIO on every GPIO status     * read to satisfy broken guests that poll-wait for hsync.     * Simulating a real hsync event would be less practical and     * wouldn't guarantee that a guest ever exits the loop.     */    spitz_hsync = 0;    lcd_hsync = qemu_allocate_irqs(spitz_lcd_hsync_handler, cpu, 1)[0];    pxa2xx_gpio_read_notifier(cpu->gpio, lcd_hsync);    pxa2xx_lcd_vsync_notifier(cpu->lcd, lcd_hsync);    /* MMC/SD host */    pxa2xx_mmci_handlers(cpu->mmc,                    pxa2xx_gpio_in_get(cpu->gpio)[SPITZ_GPIO_SD_WP],                    pxa2xx_gpio_in_get(cpu->gpio)[SPITZ_GPIO_SD_DETECT]);    /* Battery lock always closed */    qemu_irq_raise(pxa2xx_gpio_in_get(cpu->gpio)[SPITZ_GPIO_BAT_COVER]);    /* Handle reset */    pxa2xx_gpio_out_set(cpu->gpio, SPITZ_GPIO_ON_RESET, cpu->reset);    /* PCMCIA signals: card's IRQ and Card-Detect */    if (slots >= 1)        pxa2xx_pcmcia_set_irq_cb(cpu->pcmcia[0],                        pxa2xx_gpio_in_get(cpu->gpio)[SPITZ_GPIO_CF1_IRQ],                        pxa2xx_gpio_in_get(cpu->gpio)[SPITZ_GPIO_CF1_CD]);    if (slots >= 2)        pxa2xx_pcmcia_set_irq_cb(cpu->pcmcia[1],                        pxa2xx_gpio_in_get(cpu->gpio)[SPITZ_GPIO_CF2_IRQ],                        pxa2xx_gpio_in_get(cpu->gpio)[SPITZ_GPIO_CF2_CD]);    /* Initialise the screen rotation related signals */    spitz_gpio_invert[3] = 0;	/* Always open */    if (graphic_rotate) {	/* Tablet mode */        spitz_gpio_invert[4] = 0;    } else {			/* Portrait mode */        spitz_gpio_invert[4] = 1;    }    qemu_set_irq(pxa2xx_gpio_in_get(cpu->gpio)[SPITZ_GPIO_SWA],                    spitz_gpio_invert[3]);    qemu_set_irq(pxa2xx_gpio_in_get(cpu->gpio)[SPITZ_GPIO_SWB],                    spitz_gpio_invert[4]);}/* Write the bootloader parameters memory area.  */#define MAGIC_CHG(a, b, c, d)	((d << 24) | (c << 16) | (b << 8) | a)struct __attribute__ ((__packed__)) sl_param_info {    uint32_t comadj_keyword;    int32_t comadj;    uint32_t uuid_keyword;    char uuid[16];    uint32_t touch_keyword;    int32_t touch_xp;    int32_t touch_yp;    int32_t touch_xd;    int32_t touch_yd;    uint32_t adadj_keyword;    int32_t adadj;    uint32_t phad_keyword;    int32_t phadadj;} spitz_bootparam = {    .comadj_keyword	= MAGIC_CHG('C', 'M', 'A', 'D'),    .comadj		= 125,    .uuid_keyword	= MAGIC_CHG('U', 'U', 'I', 'D'),    .uuid		= { -1 },    .touch_keyword	= MAGIC_CHG('T', 'U', 'C', 'H'),    .touch_xp		= -1,    .adadj_keyword	= MAGIC_CHG('B', 'V', 'A', 'D'),    .adadj		= -1,    .phad_keyword	= MAGIC_CHG('P', 'H', 'A', 'D'),    .phadadj		= 0x01,};static void sl_bootparam_write(uint32_t ptr){    memcpy(phys_ram_base + ptr, &spitz_bootparam,                    sizeof(struct sl_param_info));}#define SL_PXA_PARAM_BASE	0xa0000a00/* Board init.  */enum spitz_model_e { spitz, akita, borzoi, terrier };static void spitz_common_init(int ram_size, int vga_ram_size,                DisplayState *ds, const char *kernel_filename,                const char *kernel_cmdline, const char *initrd_filename,                const char *cpu_model, enum spitz_model_e model, int arm_id){    uint32_t spitz_ram = 0x04000000;    uint32_t spitz_rom = 0x00800000;    struct pxa2xx_state_s *cpu;    struct scoop_info_s *scp;    if (!cpu_model)        cpu_model = (model == terrier) ? "pxa270-c5" : "pxa270-c0";    /* Setup CPU & memory */    if (ram_size < spitz_ram + spitz_rom + PXA2XX_INTERNAL_SIZE) {        fprintf(stderr, "This platform requires %i bytes of memory\n",                        spitz_ram + spitz_rom + PXA2XX_INTERNAL_SIZE);        exit(1);    }    cpu = pxa270_init(spitz_ram, ds, cpu_model);    sl_flash_register(cpu, (model == spitz) ? FLASH_128M : FLASH_1024M);    cpu_register_physical_memory(0, spitz_rom,                    qemu_ram_alloc(spitz_rom) | IO_MEM_ROM);    /* Setup peripherals */    spitz_keyboard_register(cpu);    spitz_ssp_attach(cpu);    scp = spitz_scoop_init(cpu, (model == akita) ? 1 : 2);    spitz_scoop_gpio_setup(cpu, scp, (model == akita) ? 1 : 2);    spitz_gpio_setup(cpu, (model == akita) ? 1 : 2);    spitz_i2c_setup(cpu);    if (model == akita)        spitz_akita_i2c_setup(cpu);    if (model == terrier)        /* A 6.0 GB microdrive is permanently sitting in CF slot 1.  */        spitz_microdrive_attach(cpu);    else if (model != akita)        /* A 4.0 GB microdrive is permanently sitting in CF slot 1.  */        spitz_microdrive_attach(cpu);    /* Setup initial (reset) machine state */    cpu->env->regs[15] = PXA2XX_SDRAM_BASE;    arm_load_kernel(cpu->env, spitz_ram, kernel_filename, kernel_cmdline,                    initrd_filename, arm_id, PXA2XX_SDRAM_BASE);    sl_bootparam_write(SL_PXA_PARAM_BASE - PXA2XX_SDRAM_BASE);}static void spitz_init(int ram_size, int vga_ram_size,                const char *boot_device, DisplayState *ds,                const char *kernel_filename, const char *kernel_cmdline,                const char *initrd_filename, const char *cpu_model){    spitz_common_init(ram_size, vga_ram_size, ds, kernel_filename,                kernel_cmdline, initrd_filename, cpu_model, spitz, 0x2c9);}static void borzoi_init(int ram_size, int vga_ram_size,                const char *boot_device, DisplayState *ds,                const char *kernel_filename, const char *kernel_cmdline,                const char *initrd_filename, const char *cpu_model){    spitz_common_init(ram_size, vga_ram_size, ds, kernel_filename,                kernel_cmdline, initrd_filename, cpu_model, borzoi, 0x33f);}static void akita_init(int ram_size, int vga_ram_size,                const char *boot_device, DisplayState *ds,                const char *kernel_filename, const char *kernel_cmdline,                const char *initrd_filename, const char *cpu_model){    spitz_common_init(ram_size, vga_ram_size, ds, kernel_filename,                kernel_cmdline, initrd_filename, cpu_model, akita, 0x2e8);}static void terrier_init(int ram_size, int vga_ram_size,                const char *boot_device, DisplayState *ds,                const char *kernel_filename, const char *kernel_cmdline,                const char *initrd_filename, const char *cpu_model){    spitz_common_init(ram_size, vga_ram_size, ds, kernel_filename,                kernel_cmdline, initrd_filename, cpu_model, terrier, 0x33f);}QEMUMachine akitapda_machine = {    "akita",    "Akita PDA (PXA270)",    akita_init,};QEMUMachine spitzpda_machine = {    "spitz",    "Spitz PDA (PXA270)",    spitz_init,};QEMUMachine borzoipda_machine = {    "borzoi",    "Borzoi PDA (PXA270)",    borzoi_init,};QEMUMachine terrierpda_machine = {    "terrier",    "Terrier PDA (PXA270)",    terrier_init,};