4 * Copyright (C) 2006-2007 Andrzej Zaborowski <balrog@zabor.org>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation; either version 2 of
9 * the License, or (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23 static uint32_t static_readb(void *opaque
, target_phys_addr_t offset
)
25 uint32_t *val
= (uint32_t *) opaque
;
26 return *val
>> ((offset
& 3) << 3);
29 static uint32_t static_readh(void *opaque
, target_phys_addr_t offset
) {
30 uint32_t *val
= (uint32_t *) opaque
;
31 return *val
>> ((offset
& 1) << 3);
34 static uint32_t static_readw(void *opaque
, target_phys_addr_t offset
) {
35 uint32_t *val
= (uint32_t *) opaque
;
36 return *val
>> ((offset
& 0) << 3);
39 static void static_write(void *opaque
, target_phys_addr_t offset
,
43 printf("%s: value %08lx written at " PA_FMT
"\n",
44 __FUNCTION__
, value
, offset
);
48 static CPUReadMemoryFunc
*static_readfn
[] = {
54 static CPUWriteMemoryFunc
*static_writefn
[] = {
60 /* Palm Tunsgten|E support */
63 #define PALMTE_USBDETECT_GPIO 0
64 #define PALMTE_USB_OR_DC_GPIO 1
65 #define PALMTE_TSC_GPIO 4
66 #define PALMTE_PINTDAV_GPIO 6
67 #define PALMTE_MMC_WP_GPIO 8
68 #define PALMTE_MMC_POWER_GPIO 9
69 #define PALMTE_HDQ_GPIO 11
70 #define PALMTE_HEADPHONES_GPIO 14
71 #define PALMTE_SPEAKER_GPIO 15
72 /* MPU private GPIOs */
73 #define PALMTE_DC_GPIO 2
74 #define PALMTE_MMC_SWITCH_GPIO 4
75 #define PALMTE_MMC1_GPIO 6
76 #define PALMTE_MMC2_GPIO 7
77 #define PALMTE_MMC3_GPIO 11
79 static void palmte_microwire_setup(struct omap_mpu_state_s
*cpu
)
84 omap_gpio_in_get(cpu
->gpio
)[PALMTE_PINTDAV_GPIO
]),
91 } palmte_keymap
[0x80] = {
92 [0 ... 0x7f] = { -1, -1 },
93 [0x3b] = { 0, 0 }, /* F1 -> Calendar */
94 [0x3c] = { 1, 0 }, /* F2 -> Contacts */
95 [0x3d] = { 2, 0 }, /* F3 -> Tasks List */
96 [0x3e] = { 3, 0 }, /* F4 -> Note Pad */
97 [0x01] = { 4, 0 }, /* Esc -> Power */
98 [0x4b] = { 0, 1 }, /* Left */
99 [0x50] = { 1, 1 }, /* Down */
100 [0x48] = { 2, 1 }, /* Up */
101 [0x4d] = { 3, 1 }, /* Right */
102 [0x4c] = { 4, 1 }, /* Centre */
103 [0x39] = { 4, 1 }, /* Spc -> Centre */
106 static void palmte_button_event(void *opaque
, int keycode
)
108 struct omap_mpu_state_s
*cpu
= (struct omap_mpu_state_s
*) opaque
;
110 if (palmte_keymap
[keycode
& 0x7f].row
!= -1)
111 omap_mpuio_key(cpu
->mpuio
,
112 palmte_keymap
[keycode
& 0x7f].row
,
113 palmte_keymap
[keycode
& 0x7f].column
,
117 static void palmte_onoff_gpios(void *opaque
, int line
, int level
)
121 printf("%s: current to MMC/SD card %sabled.\n",
122 __FUNCTION__
, level
? "dis" : "en");
125 printf("%s: internal speaker amplifier %s.\n",
126 __FUNCTION__
, level
? "down" : "on");
129 /* These LCD & Audio output signals have not been identified yet. */
133 printf("%s: LCD GPIO%i %s.\n",
134 __FUNCTION__
, line
- 1, level
? "high" : "low");
138 printf("%s: Audio GPIO%i %s.\n",
139 __FUNCTION__
, line
- 4, level
? "high" : "low");
144 static void palmte_gpio_setup(struct omap_mpu_state_s
*cpu
)
148 omap_mmc_handlers(cpu
->mmc
,
149 omap_gpio_in_get(cpu
->gpio
)[PALMTE_MMC_WP_GPIO
],
150 qemu_irq_invert(omap_mpuio_in_get(cpu
->mpuio
)
151 [PALMTE_MMC_SWITCH_GPIO
]));
153 misc_gpio
= qemu_allocate_irqs(palmte_onoff_gpios
, cpu
, 7);
154 omap_gpio_out_set(cpu
->gpio
, PALMTE_MMC_POWER_GPIO
, misc_gpio
[0]);
155 omap_gpio_out_set(cpu
->gpio
, PALMTE_SPEAKER_GPIO
, misc_gpio
[1]);
156 omap_gpio_out_set(cpu
->gpio
, 11, misc_gpio
[2]);
157 omap_gpio_out_set(cpu
->gpio
, 12, misc_gpio
[3]);
158 omap_gpio_out_set(cpu
->gpio
, 13, misc_gpio
[4]);
159 omap_mpuio_out_set(cpu
->mpuio
, 1, misc_gpio
[5]);
160 omap_mpuio_out_set(cpu
->mpuio
, 3, misc_gpio
[6]);
162 /* Reset some inputs to initial state. */
163 qemu_irq_lower(omap_gpio_in_get(cpu
->gpio
)[PALMTE_USBDETECT_GPIO
]);
164 qemu_irq_lower(omap_gpio_in_get(cpu
->gpio
)[PALMTE_USB_OR_DC_GPIO
]);
165 qemu_irq_lower(omap_gpio_in_get(cpu
->gpio
)[4]);
166 qemu_irq_lower(omap_gpio_in_get(cpu
->gpio
)[PALMTE_HEADPHONES_GPIO
]);
167 qemu_irq_lower(omap_mpuio_in_get(cpu
->mpuio
)[PALMTE_DC_GPIO
]);
168 qemu_irq_raise(omap_mpuio_in_get(cpu
->mpuio
)[6]);
169 qemu_irq_raise(omap_mpuio_in_get(cpu
->mpuio
)[7]);
170 qemu_irq_raise(omap_mpuio_in_get(cpu
->mpuio
)[11]);
173 static void palmte_init(int ram_size
, int vga_ram_size
,
174 const char *boot_device
, DisplayState
*ds
,
175 const char **fd_filename
, int snapshot
,
176 const char *kernel_filename
, const char *kernel_cmdline
,
177 const char *initrd_filename
, const char *cpu_model
)
179 struct omap_mpu_state_s
*cpu
;
180 int flash_size
= 0x00800000;
181 int sdram_size
= 0x02000000;
183 static uint32_t cs0val
= 0xffffffff;
184 static uint32_t cs1val
= 0x0000e1a0;
185 static uint32_t cs2val
= 0x0000e1a0;
186 static uint32_t cs3val
= 0xe1a0e1a0;
187 ram_addr_t phys_flash
;
188 int rom_size
, rom_loaded
= 0;
190 if (ram_size
< flash_size
+ sdram_size
+ OMAP15XX_SRAM_SIZE
) {
191 fprintf(stderr
, "This architecture uses %i bytes of memory\n",
192 flash_size
+ sdram_size
+ OMAP15XX_SRAM_SIZE
);
196 cpu
= omap310_mpu_init(sdram_size
, ds
, cpu_model
);
198 /* External Flash (EMIFS) */
199 cpu_register_physical_memory(OMAP_CS0_BASE
, flash_size
,
200 (phys_flash
= qemu_ram_alloc(flash_size
)) | IO_MEM_ROM
);
202 io
= cpu_register_io_memory(0, static_readfn
, static_writefn
, &cs0val
);
203 cpu_register_physical_memory(OMAP_CS0_BASE
+ flash_size
,
204 OMAP_CS0_SIZE
- flash_size
, io
);
205 io
= cpu_register_io_memory(0, static_readfn
, static_writefn
, &cs1val
);
206 cpu_register_physical_memory(OMAP_CS1_BASE
, OMAP_CS1_SIZE
, io
);
207 io
= cpu_register_io_memory(0, static_readfn
, static_writefn
, &cs2val
);
208 cpu_register_physical_memory(OMAP_CS2_BASE
, OMAP_CS2_SIZE
, io
);
209 io
= cpu_register_io_memory(0, static_readfn
, static_writefn
, &cs3val
);
210 cpu_register_physical_memory(OMAP_CS3_BASE
, OMAP_CS3_SIZE
, io
);
212 palmte_microwire_setup(cpu
);
214 qemu_add_kbd_event_handler(palmte_button_event
, cpu
);
216 palmte_gpio_setup(cpu
);
218 /* Setup initial (reset) machine state */
219 if (nb_option_roms
) {
220 rom_size
= get_image_size(option_rom
[0]);
221 if (rom_size
> flash_size
)
222 fprintf(stderr
, "%s: ROM image too big (%x > %x)\n",
223 __FUNCTION__
, rom_size
, flash_size
);
224 else if (rom_size
> 0 && load_image(option_rom
[0],
225 phys_ram_base
+ phys_flash
) > 0) {
227 cpu
->env
->regs
[15] = 0x00000000;
229 fprintf(stderr
, "%s: error loading '%s'\n",
230 __FUNCTION__
, option_rom
[0]);
233 if (!rom_loaded
&& !kernel_filename
) {
234 fprintf(stderr
, "Kernel or ROM image must be specified\n");
238 /* Load the kernel. */
239 if (kernel_filename
) {
240 /* Start at bootloader. */
241 cpu
->env
->regs
[15] = OMAP_EMIFF_BASE
;
243 arm_load_kernel(cpu
->env
, sdram_size
, kernel_filename
, kernel_cmdline
,
244 initrd_filename
, 0x331, OMAP_EMIFF_BASE
);
247 dpy_resize(ds
, 320, 320);
250 QEMUMachine palmte_machine
= {
252 "Palm Tungsten|E aka. Cheetah PDA (OMAP310)",