← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to hw/spitz.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-22 10:13:17 UTC
  • mfrom: (1.2.1 upstream) (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20090322101317-iigjtnu5qil35dtb
Tags: 0.10.1-1
http://bugs.debian.org/501400
[ Aurelien Jarno ]
* New upstream stable release:
  - patches/80_stable-branch.patch: remove.
* debian/control: 
  - Remove depends on proll.
  - Move depends on device-tree-compiler to build-depends.
  - Bump Standards-Version to 3.8.1 (no changes).
* patches/82_qemu-img_decimal.patch: new patch from upstream to make
  qemu-img accept sizes with decimal values (closes: bug#501400).

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/spitz.c
16
16
#include "flash.h"
17
17
#include "qemu-timer.h"
18
18
#include "devices.h"
 
19
#include "sharpsl.h"
19
20
#include "console.h"
20
21
#include "block.h"
21
22
#include "audio/audio.h"
22
23
#include "boards.h"
23
24
 
24
 
#define spitz_printf(format, ...)       \
25
 
    fprintf(stderr, "%s: " format, __FUNCTION__, ##__VA_ARGS__)
26
25
#undef REG_FMT
27
26
#if TARGET_PHYS_ADDR_BITS == 32
28
27
#define REG_FMT                 "0x%02x"
49
48
#define FLASHCTL_NCE            (FLASHCTL_CE0 | FLASHCTL_CE1)
50
49
 
51
50
struct sl_nand_s {
52
 
    target_phys_addr_t target_base;
53
51
    struct nand_flash_s *nand;
54
52
    uint8_t ctl;
55
53
    struct ecc_state_s ecc;
59
57
{
60
58
    struct sl_nand_s *s = (struct sl_nand_s *) opaque;
61
59
    int ryby;
62
 
    addr -= s->target_base;
63
60
 
64
61
    switch (addr) {
65
62
#define BSHR(byte, from, to)    ((s->ecc.lp[byte] >> (from - to)) & (1 << to))
89
86
        return ecc_digest(&s->ecc, nand_getio(s->nand));
90
87
 
91
88
    default:
92
 
        spitz_printf("Bad register offset " REG_FMT "\n", addr);
 
89
        zaurus_printf("Bad register offset " REG_FMT "\n", addr);
93
90
    }
94
91
    return 0;
95
92
}
97
94
static uint32_t sl_readl(void *opaque, target_phys_addr_t addr)
98
95
{
99
96
    struct sl_nand_s *s = (struct sl_nand_s *) opaque;
100
 
    addr -= s->target_base;
101
97
 
102
98
    if (addr == FLASH_FLASHIO)
103
99
        return ecc_digest(&s->ecc, nand_getio(s->nand)) |
110
106
                uint32_t value)
111
107
{
112
108
    struct sl_nand_s *s = (struct sl_nand_s *) opaque;
113
 
    addr -= s->target_base;
114
109
 
115
110
    switch (addr) {
116
111
    case FLASH_ECCCLRR:
133
128
        break;
134
129
 
135
130
    default:
136
 
        spitz_printf("Bad register offset " REG_FMT "\n", addr);
 
131
        zaurus_printf("Bad register offset " REG_FMT "\n", addr);
137
132
    }
138
133
}
139
134
 
176
171
    };
177
172
 
178
173
    s = (struct sl_nand_s *) qemu_mallocz(sizeof(struct sl_nand_s));
179
 
    s->target_base = FLASH_BASE;
180
174
    s->ctl = 0;
181
175
    if (size == FLASH_128M)
182
176
        s->nand = nand_init(NAND_MFR_SAMSUNG, 0x73);
185
179
 
186
180
    iomemtype = cpu_register_io_memory(0, sl_readfn,
187
181
                    sl_writefn, s);
188
 
    cpu_register_physical_memory(s->target_base, 0x40, iomemtype);
 
182
    cpu_register_physical_memory(FLASH_BASE, 0x40, iomemtype);
189
183
 
190
184
    register_savevm("sl_flash", 0, 0, sl_save, sl_load, s);
191
185
}
520
514
                    spitz_keyboard_save, spitz_keyboard_load, s);
521
515
}
522
516
 
523
 
/* SCOOP devices */
524
 
 
525
 
struct scoop_info_s {
526
 
    target_phys_addr_t target_base;
527
 
    qemu_irq handler[16];
528
 
    qemu_irq *in;
529
 
    uint16_t status;
530
 
    uint16_t power;
531
 
    uint32_t gpio_level;
532
 
    uint32_t gpio_dir;
533
 
    uint32_t prev_level;
534
 
 
535
 
    uint16_t mcr;
536
 
    uint16_t cdr;
537
 
    uint16_t ccr;
538
 
    uint16_t irr;
539
 
    uint16_t imr;
540
 
    uint16_t isr;
541
 
    uint16_t gprr;
542
 
};
543
 
 
544
 
#define SCOOP_MCR       0x00
545
 
#define SCOOP_CDR       0x04
546
 
#define SCOOP_CSR       0x08
547
 
#define SCOOP_CPR       0x0c
548
 
#define SCOOP_CCR       0x10
549
 
#define SCOOP_IRR_IRM   0x14
550
 
#define SCOOP_IMR       0x18
551
 
#define SCOOP_ISR       0x1c
552
 
#define SCOOP_GPCR      0x20
553
 
#define SCOOP_GPWR      0x24
554
 
#define SCOOP_GPRR      0x28
555
 
 
556
 
static inline void scoop_gpio_handler_update(struct scoop_info_s *s) {
557
 
    uint32_t level, diff;
558
 
    int bit;
559
 
    level = s->gpio_level & s->gpio_dir;
560
 
 
561
 
    for (diff = s->prev_level ^ level; diff; diff ^= 1 << bit) {
562
 
        bit = ffs(diff) - 1;
563
 
        qemu_set_irq(s->handler[bit], (level >> bit) & 1);
564
 
    }
565
 
 
566
 
    s->prev_level = level;
567
 
}
568
 
 
569
 
static uint32_t scoop_readb(void *opaque, target_phys_addr_t addr)
570
 
{
571
 
    struct scoop_info_s *s = (struct scoop_info_s *) opaque;
572
 
    addr -= s->target_base;
573
 
 
574
 
    switch (addr) {
575
 
    case SCOOP_MCR:
576
 
        return s->mcr;
577
 
    case SCOOP_CDR:
578
 
        return s->cdr;
579
 
    case SCOOP_CSR:
580
 
        return s->status;
581
 
    case SCOOP_CPR:
582
 
        return s->power;
583
 
    case SCOOP_CCR:
584
 
        return s->ccr;
585
 
    case SCOOP_IRR_IRM:
586
 
        return s->irr;
587
 
    case SCOOP_IMR:
588
 
        return s->imr;
589
 
    case SCOOP_ISR:
590
 
        return s->isr;
591
 
    case SCOOP_GPCR:
592
 
        return s->gpio_dir;
593
 
    case SCOOP_GPWR:
594
 
        return s->gpio_level;
595
 
    case SCOOP_GPRR:
596
 
        return s->gprr;
597
 
    default:
598
 
        spitz_printf("Bad register offset " REG_FMT "\n", addr);
599
 
    }
600
 
 
601
 
    return 0;
602
 
}
603
 
 
604
 
static void scoop_writeb(void *opaque, target_phys_addr_t addr, uint32_t value)
605
 
{
606
 
    struct scoop_info_s *s = (struct scoop_info_s *) opaque;
607
 
    addr -= s->target_base;
608
 
    value &= 0xffff;
609
 
 
610
 
    switch (addr) {
611
 
    case SCOOP_MCR:
612
 
        s->mcr = value;
613
 
        break;
614
 
    case SCOOP_CDR:
615
 
        s->cdr = value;
616
 
        break;
617
 
    case SCOOP_CPR:
618
 
        s->power = value;
619
 
        if (value & 0x80)
620
 
            s->power |= 0x8040;
621
 
        break;
622
 
    case SCOOP_CCR:
623
 
        s->ccr = value;
624
 
        break;
625
 
    case SCOOP_IRR_IRM:
626
 
        s->irr = value;
627
 
        break;
628
 
    case SCOOP_IMR:
629
 
        s->imr = value;
630
 
        break;
631
 
    case SCOOP_ISR:
632
 
        s->isr = value;
633
 
        break;
634
 
    case SCOOP_GPCR:
635
 
        s->gpio_dir = value;
636
 
        scoop_gpio_handler_update(s);
637
 
        break;
638
 
    case SCOOP_GPWR:
639
 
        s->gpio_level = value & s->gpio_dir;
640
 
        scoop_gpio_handler_update(s);
641
 
        break;
642
 
    case SCOOP_GPRR:
643
 
        s->gprr = value;
644
 
        break;
645
 
    default:
646
 
        spitz_printf("Bad register offset " REG_FMT "\n", addr);
647
 
    }
648
 
}
649
 
 
650
 
CPUReadMemoryFunc *scoop_readfn[] = {
651
 
    scoop_readb,
652
 
    scoop_readb,
653
 
    scoop_readb,
654
 
};
655
 
CPUWriteMemoryFunc *scoop_writefn[] = {
656
 
    scoop_writeb,
657
 
    scoop_writeb,
658
 
    scoop_writeb,
659
 
};
660
 
 
661
 
static void scoop_gpio_set(void *opaque, int line, int level)
662
 
{
663
 
    struct scoop_info_s *s = (struct scoop_info_s *) s;
664
 
 
665
 
    if (level)
666
 
        s->gpio_level |= (1 << line);
667
 
    else
668
 
        s->gpio_level &= ~(1 << line);
669
 
}
670
 
 
671
 
static inline qemu_irq *scoop_gpio_in_get(struct scoop_info_s *s)
672
 
{
673
 
    return s->in;
674
 
}
675
 
 
676
 
static inline void scoop_gpio_out_set(struct scoop_info_s *s, int line,
677
 
                qemu_irq handler) {
678
 
    if (line >= 16) {
679
 
        spitz_printf("No GPIO pin %i\n", line);
680
 
        return;
681
 
    }
682
 
 
683
 
    s->handler[line] = handler;
684
 
}
685
 
 
686
 
static void scoop_save(QEMUFile *f, void *opaque)
687
 
{
688
 
    struct scoop_info_s *s = (struct scoop_info_s *) opaque;
689
 
    qemu_put_be16s(f, &s->status);
690
 
    qemu_put_be16s(f, &s->power);
691
 
    qemu_put_be32s(f, &s->gpio_level);
692
 
    qemu_put_be32s(f, &s->gpio_dir);
693
 
    qemu_put_be32s(f, &s->prev_level);
694
 
    qemu_put_be16s(f, &s->mcr);
695
 
    qemu_put_be16s(f, &s->cdr);
696
 
    qemu_put_be16s(f, &s->ccr);
697
 
    qemu_put_be16s(f, &s->irr);
698
 
    qemu_put_be16s(f, &s->imr);
699
 
    qemu_put_be16s(f, &s->isr);
700
 
    qemu_put_be16s(f, &s->gprr);
701
 
}
702
 
 
703
 
static int scoop_load(QEMUFile *f, void *opaque, int version_id)
704
 
{
705
 
    struct scoop_info_s *s = (struct scoop_info_s *) opaque;
706
 
    qemu_get_be16s(f, &s->status);
707
 
    qemu_get_be16s(f, &s->power);
708
 
    qemu_get_be32s(f, &s->gpio_level);
709
 
    qemu_get_be32s(f, &s->gpio_dir);
710
 
    qemu_get_be32s(f, &s->prev_level);
711
 
    qemu_get_be16s(f, &s->mcr);
712
 
    qemu_get_be16s(f, &s->cdr);
713
 
    qemu_get_be16s(f, &s->ccr);
714
 
    qemu_get_be16s(f, &s->irr);
715
 
    qemu_get_be16s(f, &s->imr);
716
 
    qemu_get_be16s(f, &s->isr);
717
 
    qemu_get_be16s(f, &s->gprr);
718
 
 
719
 
    return 0;
720
 
}
721
 
 
722
 
static struct scoop_info_s *spitz_scoop_init(struct pxa2xx_state_s *cpu,
723
 
                int count) {
724
 
    int iomemtype;
725
 
    struct scoop_info_s *s;
726
 
 
727
 
    s = (struct scoop_info_s *)
728
 
            qemu_mallocz(sizeof(struct scoop_info_s) * 2);
729
 
    memset(s, 0, sizeof(struct scoop_info_s) * count);
730
 
    s[0].target_base = 0x10800000;
731
 
    s[1].target_base = 0x08800040;
732
 
 
733
 
    /* Ready */
734
 
    s[0].status = 0x02;
735
 
    s[1].status = 0x02;
736
 
 
737
 
    s[0].in = qemu_allocate_irqs(scoop_gpio_set, &s[0], 16);
738
 
    iomemtype = cpu_register_io_memory(0, scoop_readfn,
739
 
                    scoop_writefn, &s[0]);
740
 
    cpu_register_physical_memory(s[0].target_base, 0x1000, iomemtype);
741
 
    register_savevm("scoop", 0, 0, scoop_save, scoop_load, &s[0]);
742
 
 
743
 
    if (count < 2)
744
 
        return s;
745
 
 
746
 
    s[1].in = qemu_allocate_irqs(scoop_gpio_set, &s[1], 16);
747
 
    iomemtype = cpu_register_io_memory(0, scoop_readfn,
748
 
                    scoop_writefn, &s[1]);
749
 
    cpu_register_physical_memory(s[1].target_base, 0x1000, iomemtype);
750
 
    register_savevm("scoop", 1, 0, scoop_save, scoop_load, &s[1]);
751
 
 
752
 
    return s;
753
 
}
754
 
 
755
517
/* LCD backlight controller */
756
518
 
757
519
#define LCDTG_RESCTL    0x00
768
530
static void spitz_bl_update(struct pxa2xx_state_s *s)
769
531
{
770
532
    if (bl_power && bl_intensity)
771
 
        spitz_printf("LCD Backlight now at %i/63\n", bl_intensity);
 
533
        zaurus_printf("LCD Backlight now at %i/63\n", bl_intensity);
772
534
    else
773
 
        spitz_printf("LCD Backlight now off\n");
 
535
        zaurus_printf("LCD Backlight now off\n");
774
536
}
775
537
 
776
538
static inline void spitz_bl_bit5(void *opaque, int line, int level)
801
563
    switch (addr) {
802
564
    case LCDTG_RESCTL:
803
565
        if (value)
804
 
            spitz_printf("LCD in QVGA mode\n");
 
566
            zaurus_printf("LCD in QVGA mode\n");
805
567
        else
806
 
            spitz_printf("LCD in VGA mode\n");
 
568
            zaurus_printf("LCD in VGA mode\n");
807
569
        break;
808
570
 
809
571
    case LCDTG_DUTYCTRL:
937
699
 
938
700
/* CF Microdrive */
939
701
 
940
 
static void spitz_microdrive_attach(struct pxa2xx_state_s *cpu)
 
702
static void spitz_microdrive_attach(struct pxa2xx_state_s *cpu, int slot)
941
703
{
942
704
    struct pcmcia_card_s *md;
943
705
    int index;
949
711
    bs = drives_table[index].bdrv;
950
712
    if (bdrv_is_inserted(bs) && !bdrv_is_removable(bs)) {
951
713
        md = dscm1xxxx_init(bs);
952
 
        pxa2xx_pcmcia_attach(cpu->pcmcia[1], md);
 
714
        pxa2xx_pcmcia_attach(cpu->pcmcia[slot], md);
953
715
    }
954
716
}
955
717
 
1011
773
{
1012
774
    switch (line) {
1013
775
    case 0:
1014
 
        spitz_printf("Charging %s.\n", level ? "off" : "on");
 
776
        zaurus_printf("Charging %s.\n", level ? "off" : "on");
1015
777
        break;
1016
778
    case 1:
1017
 
        spitz_printf("Discharging %s.\n", level ? "on" : "off");
 
779
        zaurus_printf("Discharging %s.\n", level ? "on" : "off");
1018
780
        break;
1019
781
    case 2:
1020
 
        spitz_printf("Green LED %s.\n", level ? "on" : "off");
 
782
        zaurus_printf("Green LED %s.\n", level ? "on" : "off");
1021
783
        break;
1022
784
    case 3:
1023
 
        spitz_printf("Orange LED %s.\n", level ? "on" : "off");
 
785
        zaurus_printf("Orange LED %s.\n", level ? "on" : "off");
1024
786
        break;
1025
787
    case 4:
1026
788
        spitz_bl_bit5(opaque, line, level);
1050
812
#define SPITZ_SCP2_MIC_BIAS             9
1051
813
 
1052
814
static void spitz_scoop_gpio_setup(struct pxa2xx_state_s *cpu,
1053
 
                struct scoop_info_s *scp, int num)
 
815
                struct scoop_info_s *scp0, struct scoop_info_s *scp1)
1054
816
{
1055
817
    qemu_irq *outsignals = qemu_allocate_irqs(spitz_out_switch, cpu, 8);
1056
818
 
1057
 
    scoop_gpio_out_set(&scp[0], SPITZ_SCP_CHRG_ON, outsignals[0]);
1058
 
    scoop_gpio_out_set(&scp[0], SPITZ_SCP_JK_B, outsignals[1]);
1059
 
    scoop_gpio_out_set(&scp[0], SPITZ_SCP_LED_GREEN, outsignals[2]);
1060
 
    scoop_gpio_out_set(&scp[0], SPITZ_SCP_LED_ORANGE, outsignals[3]);
 
819
    scoop_gpio_out_set(scp0, SPITZ_SCP_CHRG_ON, outsignals[0]);
 
820
    scoop_gpio_out_set(scp0, SPITZ_SCP_JK_B, outsignals[1]);
 
821
    scoop_gpio_out_set(scp0, SPITZ_SCP_LED_GREEN, outsignals[2]);
 
822
    scoop_gpio_out_set(scp0, SPITZ_SCP_LED_ORANGE, outsignals[3]);
1061
823
 
1062
 
    if (num >= 2) {
1063
 
        scoop_gpio_out_set(&scp[1], SPITZ_SCP2_BACKLIGHT_CONT, outsignals[4]);
1064
 
        scoop_gpio_out_set(&scp[1], SPITZ_SCP2_BACKLIGHT_ON, outsignals[5]);
 
824
    if (scp1) {
 
825
        scoop_gpio_out_set(scp1, SPITZ_SCP2_BACKLIGHT_CONT, outsignals[4]);
 
826
        scoop_gpio_out_set(scp1, SPITZ_SCP2_BACKLIGHT_ON, outsignals[5]);
1065
827
    }
1066
828
 
1067
 
    scoop_gpio_out_set(&scp[0], SPITZ_SCP_ADC_TEMP_ON, outsignals[6]);
 
829
    scoop_gpio_out_set(scp0, SPITZ_SCP_ADC_TEMP_ON, outsignals[6]);
1068
830
}
1069
831
 
1070
832
#define SPITZ_GPIO_HSYNC                22
1134
896
                    spitz_gpio_invert[4]);
1135
897
}
1136
898
 
1137
 
/* Write the bootloader parameters memory area.  */
1138
 
 
1139
 
#define MAGIC_CHG(a, b, c, d)   ((d << 24) | (c << 16) | (b << 8) | a)
1140
 
 
1141
 
struct __attribute__ ((__packed__)) sl_param_info {
1142
 
    uint32_t comadj_keyword;
1143
 
    int32_t comadj;
1144
 
 
1145
 
    uint32_t uuid_keyword;
1146
 
    char uuid[16];
1147
 
 
1148
 
    uint32_t touch_keyword;
1149
 
    int32_t touch_xp;
1150
 
    int32_t touch_yp;
1151
 
    int32_t touch_xd;
1152
 
    int32_t touch_yd;
1153
 
 
1154
 
    uint32_t adadj_keyword;
1155
 
    int32_t adadj;
1156
 
 
1157
 
    uint32_t phad_keyword;
1158
 
    int32_t phadadj;
1159
 
} spitz_bootparam = {
1160
 
    .comadj_keyword     = MAGIC_CHG('C', 'M', 'A', 'D'),
1161
 
    .comadj             = 125,
1162
 
    .uuid_keyword       = MAGIC_CHG('U', 'U', 'I', 'D'),
1163
 
    .uuid               = { -1 },
1164
 
    .touch_keyword      = MAGIC_CHG('T', 'U', 'C', 'H'),
1165
 
    .touch_xp           = -1,
1166
 
    .adadj_keyword      = MAGIC_CHG('B', 'V', 'A', 'D'),
1167
 
    .adadj              = -1,
1168
 
    .phad_keyword       = MAGIC_CHG('P', 'H', 'A', 'D'),
1169
 
    .phadadj            = 0x01,
1170
 
};
1171
 
 
1172
 
static void sl_bootparam_write(uint32_t ptr)
1173
 
{
1174
 
    memcpy(phys_ram_base + ptr, &spitz_bootparam,
1175
 
                    sizeof(struct sl_param_info));
1176
 
}
1177
 
 
1178
 
#define SL_PXA_PARAM_BASE       0xa0000a00
1179
 
 
1180
899
/* Board init.  */
1181
900
enum spitz_model_e { spitz, akita, borzoi, terrier };
1182
901
 
1183
 
static void spitz_common_init(int ram_size, int vga_ram_size,
1184
 
                DisplayState *ds, const char *kernel_filename,
 
902
#define SPITZ_RAM       0x04000000
 
903
#define SPITZ_ROM       0x00800000
 
904
 
 
905
static struct arm_boot_info spitz_binfo = {
 
906
    .loader_start = PXA2XX_SDRAM_BASE,
 
907
    .ram_size = 0x04000000,
 
908
};
 
909
 
 
910
static void spitz_common_init(ram_addr_t ram_size, int vga_ram_size,
 
911
                const char *kernel_filename,
1185
912
                const char *kernel_cmdline, const char *initrd_filename,
1186
913
                const char *cpu_model, enum spitz_model_e model, int arm_id)
1187
914
{
1188
 
    uint32_t spitz_ram = 0x04000000;
1189
 
    uint32_t spitz_rom = 0x00800000;
1190
915
    struct pxa2xx_state_s *cpu;
1191
 
    struct scoop_info_s *scp;
 
916
    struct scoop_info_s *scp0, *scp1 = NULL;
1192
917
 
1193
918
    if (!cpu_model)
1194
919
        cpu_model = (model == terrier) ? "pxa270-c5" : "pxa270-c0";
1195
920
 
1196
921
    /* Setup CPU & memory */
1197
 
    if (ram_size < spitz_ram + spitz_rom + PXA2XX_INTERNAL_SIZE) {
 
922
    if (ram_size < SPITZ_RAM + SPITZ_ROM + PXA2XX_INTERNAL_SIZE) {
1198
923
        fprintf(stderr, "This platform requires %i bytes of memory\n",
1199
 
                        spitz_ram + spitz_rom + PXA2XX_INTERNAL_SIZE);
 
924
                        SPITZ_RAM + SPITZ_ROM + PXA2XX_INTERNAL_SIZE);
1200
925
        exit(1);
1201
926
    }
1202
 
    cpu = pxa270_init(spitz_ram, ds, cpu_model);
 
927
    cpu = pxa270_init(spitz_binfo.ram_size, cpu_model);
1203
928
 
1204
929
    sl_flash_register(cpu, (model == spitz) ? FLASH_128M : FLASH_1024M);
1205
930
 
1206
 
    cpu_register_physical_memory(0, spitz_rom,
1207
 
                    qemu_ram_alloc(spitz_rom) | IO_MEM_ROM);
 
931
    cpu_register_physical_memory(0, SPITZ_ROM,
 
932
                    qemu_ram_alloc(SPITZ_ROM) | IO_MEM_ROM);
1208
933
 
1209
934
    /* Setup peripherals */
1210
935
    spitz_keyboard_register(cpu);
1211
936
 
1212
937
    spitz_ssp_attach(cpu);
1213
938
 
1214
 
    scp = spitz_scoop_init(cpu, (model == akita) ? 1 : 2);
 
939
    scp0 = scoop_init(cpu, 0, 0x10800000);
 
940
    if (model != akita) {
 
941
            scp1 = scoop_init(cpu, 1, 0x08800040);
 
942
    }
1215
943
 
1216
 
    spitz_scoop_gpio_setup(cpu, scp, (model == akita) ? 1 : 2);
 
944
    spitz_scoop_gpio_setup(cpu, scp0, scp1);
1217
945
 
1218
946
    spitz_gpio_setup(cpu, (model == akita) ? 1 : 2);
1219
947
 
1224
952
 
1225
953
    if (model == terrier)
1226
954
        /* A 6.0 GB microdrive is permanently sitting in CF slot 1.  */
1227
 
        spitz_microdrive_attach(cpu);
 
955
        spitz_microdrive_attach(cpu, 1);
1228
956
    else if (model != akita)
1229
 
        /* A 4.0 GB microdrive is permanently sitting in CF slot 1.  */
1230
 
        spitz_microdrive_attach(cpu);
 
957
        /* A 4.0 GB microdrive is permanently sitting in CF slot 0.  */
 
958
        spitz_microdrive_attach(cpu, 0);
1231
959
 
1232
960
    /* Setup initial (reset) machine state */
1233
 
    cpu->env->regs[15] = PXA2XX_SDRAM_BASE;
 
961
    cpu->env->regs[15] = spitz_binfo.loader_start;
1234
962
 
1235
 
    arm_load_kernel(cpu->env, spitz_ram, kernel_filename, kernel_cmdline,
1236
 
                    initrd_filename, arm_id, PXA2XX_SDRAM_BASE);
 
963
    spitz_binfo.kernel_filename = kernel_filename;
 
964
    spitz_binfo.kernel_cmdline = kernel_cmdline;
 
965
    spitz_binfo.initrd_filename = initrd_filename;
 
966
    spitz_binfo.board_id = arm_id;
 
967
    arm_load_kernel(cpu->env, &spitz_binfo);
1237
968
    sl_bootparam_write(SL_PXA_PARAM_BASE - PXA2XX_SDRAM_BASE);
1238
969
}
1239
970
 
1240
 
static void spitz_init(int ram_size, int vga_ram_size,
1241
 
                const char *boot_device, DisplayState *ds,
 
971
static void spitz_init(ram_addr_t ram_size, int vga_ram_size,
 
972
                const char *boot_device,
1242
973
                const char *kernel_filename, const char *kernel_cmdline,
1243
974
                const char *initrd_filename, const char *cpu_model)
1244
975
{
1245
 
    spitz_common_init(ram_size, vga_ram_size, ds, kernel_filename,
 
976
    spitz_common_init(ram_size, vga_ram_size, kernel_filename,
1246
977
                kernel_cmdline, initrd_filename, cpu_model, spitz, 0x2c9);
1247
978
}
1248
979
 
1249
 
static void borzoi_init(int ram_size, int vga_ram_size,
1250
 
                const char *boot_device, DisplayState *ds,
 
980
static void borzoi_init(ram_addr_t ram_size, int vga_ram_size,
 
981
                const char *boot_device,
1251
982
                const char *kernel_filename, const char *kernel_cmdline,
1252
983
                const char *initrd_filename, const char *cpu_model)
1253
984
{
1254
 
    spitz_common_init(ram_size, vga_ram_size, ds, kernel_filename,
 
985
    spitz_common_init(ram_size, vga_ram_size, kernel_filename,
1255
986
                kernel_cmdline, initrd_filename, cpu_model, borzoi, 0x33f);
1256
987
}
1257
988
 
1258
 
static void akita_init(int ram_size, int vga_ram_size,
1259
 
                const char *boot_device, DisplayState *ds,
 
989
static void akita_init(ram_addr_t ram_size, int vga_ram_size,
 
990
                const char *boot_device,
1260
991
                const char *kernel_filename, const char *kernel_cmdline,
1261
992
                const char *initrd_filename, const char *cpu_model)
1262
993
{
1263
 
    spitz_common_init(ram_size, vga_ram_size, ds, kernel_filename,
 
994
    spitz_common_init(ram_size, vga_ram_size, kernel_filename,
1264
995
                kernel_cmdline, initrd_filename, cpu_model, akita, 0x2e8);
1265
996
}
1266
997
 
1267
 
static void terrier_init(int ram_size, int vga_ram_size,
1268
 
                const char *boot_device, DisplayState *ds,
 
998
static void terrier_init(ram_addr_t ram_size, int vga_ram_size,
 
999
                const char *boot_device,
1269
1000
                const char *kernel_filename, const char *kernel_cmdline,
1270
1001
                const char *initrd_filename, const char *cpu_model)
1271
1002
{
1272
 
    spitz_common_init(ram_size, vga_ram_size, ds, kernel_filename,
 
1003
    spitz_common_init(ram_size, vga_ram_size, kernel_filename,
1273
1004
                kernel_cmdline, initrd_filename, cpu_model, terrier, 0x33f);
1274
1005
}
1275
1006
 
1276
1007
QEMUMachine akitapda_machine = {
1277
 
    "akita",
1278
 
    "Akita PDA (PXA270)",
1279
 
    akita_init,
 
1008
    .name = "akita",
 
1009
    .desc = "Akita PDA (PXA270)",
 
1010
    .init = akita_init,
 
1011
    .ram_require = SPITZ_RAM + SPITZ_ROM + PXA2XX_INTERNAL_SIZE + RAMSIZE_FIXED,
1280
1012
};
1281
1013
 
1282
1014
QEMUMachine spitzpda_machine = {
1283
 
    "spitz",
1284
 
    "Spitz PDA (PXA270)",
1285
 
    spitz_init,
 
1015
    .name = "spitz",
 
1016
    .desc = "Spitz PDA (PXA270)",
 
1017
    .init = spitz_init,
 
1018
    .ram_require = SPITZ_RAM + SPITZ_ROM + PXA2XX_INTERNAL_SIZE + RAMSIZE_FIXED,
1286
1019
};
1287
1020
 
1288
1021
QEMUMachine borzoipda_machine = {
1289
 
    "borzoi",
1290
 
    "Borzoi PDA (PXA270)",
1291
 
    borzoi_init,
 
1022
    .name = "borzoi",
 
1023
    .desc = "Borzoi PDA (PXA270)",
 
1024
    .init = borzoi_init,
 
1025
    .ram_require = SPITZ_RAM + SPITZ_ROM + PXA2XX_INTERNAL_SIZE + RAMSIZE_FIXED,
1292
1026
};
1293
1027
 
1294
1028
QEMUMachine terrierpda_machine = {
1295
 
    "terrier",
1296
 
    "Terrier PDA (PXA270)",
1297
 
    terrier_init,
 
1029
    .name = "terrier",
 
1030
    .desc = "Terrier PDA (PXA270)",
 
1031
    .init = terrier_init,
 
1032
    .ram_require = SPITZ_RAM + SPITZ_ROM + PXA2XX_INTERNAL_SIZE + RAMSIZE_FIXED,
1298
1033
};