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 or
9 * (at your option) version 3 of the License.
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 along
17 * with this program; if not, see <http://www.gnu.org/licenses/>.
20 #include "audio/audio.h"
28 #include "exec-memory.h"
30 static uint32_t static_readb(void *opaque
, target_phys_addr_t offset
)
32 uint32_t *val
= (uint32_t *) opaque
;
33 return *val
>> ((offset
& 3) << 3);
36 static uint32_t static_readh(void *opaque
, target_phys_addr_t offset
)
38 uint32_t *val
= (uint32_t *) opaque
;
39 return *val
>> ((offset
& 1) << 3);
42 static uint32_t static_readw(void *opaque
, target_phys_addr_t offset
)
44 uint32_t *val
= (uint32_t *) opaque
;
45 return *val
>> ((offset
& 0) << 3);
48 static void static_write(void *opaque
, target_phys_addr_t offset
,
52 printf("%s: value %08lx written at " PA_FMT
"\n",
53 __FUNCTION__
, value
, offset
);
57 static CPUReadMemoryFunc
* const static_readfn
[] = {
63 static CPUWriteMemoryFunc
* const static_writefn
[] = {
69 /* Palm Tunsgten|E support */
72 #define PALMTE_USBDETECT_GPIO 0
73 #define PALMTE_USB_OR_DC_GPIO 1
74 #define PALMTE_TSC_GPIO 4
75 #define PALMTE_PINTDAV_GPIO 6
76 #define PALMTE_MMC_WP_GPIO 8
77 #define PALMTE_MMC_POWER_GPIO 9
78 #define PALMTE_HDQ_GPIO 11
79 #define PALMTE_HEADPHONES_GPIO 14
80 #define PALMTE_SPEAKER_GPIO 15
81 /* MPU private GPIOs */
82 #define PALMTE_DC_GPIO 2
83 #define PALMTE_MMC_SWITCH_GPIO 4
84 #define PALMTE_MMC1_GPIO 6
85 #define PALMTE_MMC2_GPIO 7
86 #define PALMTE_MMC3_GPIO 11
88 static MouseTransformInfo palmte_pointercal
= {
91 .a
= { -5909, 8, 22465308, 104, 7644, -1219972, 65536 },
94 static void palmte_microwire_setup(struct omap_mpu_state_s
*cpu
)
98 tsc
= tsc2102_init(qdev_get_gpio_in(cpu
->gpio
, PALMTE_PINTDAV_GPIO
));
100 omap_uwire_attach(cpu
->microwire
, tsc
, 0);
101 omap_mcbsp_i2s_attach(cpu
->mcbsp1
, tsc210x_codec(tsc
));
103 tsc210x_set_transform(tsc
, &palmte_pointercal
);
109 } palmte_keymap
[0x80] = {
110 [0 ... 0x7f] = { -1, -1 },
111 [0x3b] = { 0, 0 }, /* F1 -> Calendar */
112 [0x3c] = { 1, 0 }, /* F2 -> Contacts */
113 [0x3d] = { 2, 0 }, /* F3 -> Tasks List */
114 [0x3e] = { 3, 0 }, /* F4 -> Note Pad */
115 [0x01] = { 4, 0 }, /* Esc -> Power */
116 [0x4b] = { 0, 1 }, /* Left */
117 [0x50] = { 1, 1 }, /* Down */
118 [0x48] = { 2, 1 }, /* Up */
119 [0x4d] = { 3, 1 }, /* Right */
120 [0x4c] = { 4, 1 }, /* Centre */
121 [0x39] = { 4, 1 }, /* Spc -> Centre */
124 static void palmte_button_event(void *opaque
, int keycode
)
126 struct omap_mpu_state_s
*cpu
= (struct omap_mpu_state_s
*) opaque
;
128 if (palmte_keymap
[keycode
& 0x7f].row
!= -1)
129 omap_mpuio_key(cpu
->mpuio
,
130 palmte_keymap
[keycode
& 0x7f].row
,
131 palmte_keymap
[keycode
& 0x7f].column
,
135 static void palmte_onoff_gpios(void *opaque
, int line
, int level
)
139 printf("%s: current to MMC/SD card %sabled.\n",
140 __FUNCTION__
, level
? "dis" : "en");
143 printf("%s: internal speaker amplifier %s.\n",
144 __FUNCTION__
, level
? "down" : "on");
147 /* These LCD & Audio output signals have not been identified yet. */
151 printf("%s: LCD GPIO%i %s.\n",
152 __FUNCTION__
, line
- 1, level
? "high" : "low");
156 printf("%s: Audio GPIO%i %s.\n",
157 __FUNCTION__
, line
- 4, level
? "high" : "low");
162 static void palmte_gpio_setup(struct omap_mpu_state_s
*cpu
)
166 omap_mmc_handlers(cpu
->mmc
,
167 qdev_get_gpio_in(cpu
->gpio
, PALMTE_MMC_WP_GPIO
),
168 qemu_irq_invert(omap_mpuio_in_get(cpu
->mpuio
)
169 [PALMTE_MMC_SWITCH_GPIO
]));
171 misc_gpio
= qemu_allocate_irqs(palmte_onoff_gpios
, cpu
, 7);
172 qdev_connect_gpio_out(cpu
->gpio
, PALMTE_MMC_POWER_GPIO
, misc_gpio
[0]);
173 qdev_connect_gpio_out(cpu
->gpio
, PALMTE_SPEAKER_GPIO
, misc_gpio
[1]);
174 qdev_connect_gpio_out(cpu
->gpio
, 11, misc_gpio
[2]);
175 qdev_connect_gpio_out(cpu
->gpio
, 12, misc_gpio
[3]);
176 qdev_connect_gpio_out(cpu
->gpio
, 13, misc_gpio
[4]);
177 omap_mpuio_out_set(cpu
->mpuio
, 1, misc_gpio
[5]);
178 omap_mpuio_out_set(cpu
->mpuio
, 3, misc_gpio
[6]);
180 /* Reset some inputs to initial state. */
181 qemu_irq_lower(qdev_get_gpio_in(cpu
->gpio
, PALMTE_USBDETECT_GPIO
));
182 qemu_irq_lower(qdev_get_gpio_in(cpu
->gpio
, PALMTE_USB_OR_DC_GPIO
));
183 qemu_irq_lower(qdev_get_gpio_in(cpu
->gpio
, 4));
184 qemu_irq_lower(qdev_get_gpio_in(cpu
->gpio
, PALMTE_HEADPHONES_GPIO
));
185 qemu_irq_lower(omap_mpuio_in_get(cpu
->mpuio
)[PALMTE_DC_GPIO
]);
186 qemu_irq_raise(omap_mpuio_in_get(cpu
->mpuio
)[6]);
187 qemu_irq_raise(omap_mpuio_in_get(cpu
->mpuio
)[7]);
188 qemu_irq_raise(omap_mpuio_in_get(cpu
->mpuio
)[11]);
191 static struct arm_boot_info palmte_binfo
= {
192 .loader_start
= OMAP_EMIFF_BASE
,
193 .ram_size
= 0x02000000,
197 static void palmte_init(ram_addr_t ram_size
,
198 const char *boot_device
,
199 const char *kernel_filename
, const char *kernel_cmdline
,
200 const char *initrd_filename
, const char *cpu_model
)
202 MemoryRegion
*address_space_mem
= get_system_memory();
203 struct omap_mpu_state_s
*cpu
;
204 int flash_size
= 0x00800000;
205 int sdram_size
= palmte_binfo
.ram_size
;
207 static uint32_t cs0val
= 0xffffffff;
208 static uint32_t cs1val
= 0x0000e1a0;
209 static uint32_t cs2val
= 0x0000e1a0;
210 static uint32_t cs3val
= 0xe1a0e1a0;
211 int rom_size
, rom_loaded
= 0;
212 DisplayState
*ds
= get_displaystate();
214 cpu
= omap310_mpu_init(address_space_mem
, sdram_size
, cpu_model
);
216 /* External Flash (EMIFS) */
217 cpu_register_physical_memory(OMAP_CS0_BASE
, flash_size
,
218 qemu_ram_alloc(NULL
, "palmte.flash",
219 flash_size
) | IO_MEM_ROM
);
221 io
= cpu_register_io_memory(static_readfn
, static_writefn
, &cs0val
,
222 DEVICE_NATIVE_ENDIAN
);
223 cpu_register_physical_memory(OMAP_CS0_BASE
+ flash_size
,
224 OMAP_CS0_SIZE
- flash_size
, io
);
225 io
= cpu_register_io_memory(static_readfn
, static_writefn
, &cs1val
,
226 DEVICE_NATIVE_ENDIAN
);
227 cpu_register_physical_memory(OMAP_CS1_BASE
, OMAP_CS1_SIZE
, io
);
228 io
= cpu_register_io_memory(static_readfn
, static_writefn
, &cs2val
,
229 DEVICE_NATIVE_ENDIAN
);
230 cpu_register_physical_memory(OMAP_CS2_BASE
, OMAP_CS2_SIZE
, io
);
231 io
= cpu_register_io_memory(static_readfn
, static_writefn
, &cs3val
,
232 DEVICE_NATIVE_ENDIAN
);
233 cpu_register_physical_memory(OMAP_CS3_BASE
, OMAP_CS3_SIZE
, io
);
235 palmte_microwire_setup(cpu
);
237 qemu_add_kbd_event_handler(palmte_button_event
, cpu
);
239 palmte_gpio_setup(cpu
);
241 /* Setup initial (reset) machine state */
242 if (nb_option_roms
) {
243 rom_size
= get_image_size(option_rom
[0].name
);
244 if (rom_size
> flash_size
) {
245 fprintf(stderr
, "%s: ROM image too big (%x > %x)\n",
246 __FUNCTION__
, rom_size
, flash_size
);
250 rom_size
= load_image_targphys(option_rom
[0].name
, OMAP_CS0_BASE
,
255 fprintf(stderr
, "%s: error loading '%s'\n",
256 __FUNCTION__
, option_rom
[0].name
);
260 if (!rom_loaded
&& !kernel_filename
) {
261 fprintf(stderr
, "Kernel or ROM image must be specified\n");
265 /* Load the kernel. */
266 if (kernel_filename
) {
267 palmte_binfo
.kernel_filename
= kernel_filename
;
268 palmte_binfo
.kernel_cmdline
= kernel_cmdline
;
269 palmte_binfo
.initrd_filename
= initrd_filename
;
270 arm_load_kernel(cpu
->env
, &palmte_binfo
);
273 /* FIXME: We shouldn't really be doing this here. The LCD controller
274 will set the size once configured, so this just sets an initial
275 size until the guest activates the display. */
276 ds
->surface
= qemu_resize_displaysurface(ds
, 320, 320);
280 static QEMUMachine palmte_machine
= {
282 .desc
= "Palm Tungsten|E aka. Cheetah PDA (OMAP310)",
286 static void palmte_machine_init(void)
288 qemu_register_machine(&palmte_machine
);
291 machine_init(palmte_machine_init
);