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,
22
#include "audio/audio.h"
29
static uint32_t static_readb(void *opaque, target_phys_addr_t offset)
31
uint32_t *val = (uint32_t *) opaque;
32
return *val >> ((offset & 3) << 3);
35
static uint32_t static_readh(void *opaque, target_phys_addr_t offset) {
36
uint32_t *val = (uint32_t *) opaque;
37
return *val >> ((offset & 1) << 3);
40
static uint32_t static_readw(void *opaque, target_phys_addr_t offset) {
41
uint32_t *val = (uint32_t *) opaque;
42
return *val >> ((offset & 0) << 3);
45
static void static_write(void *opaque, target_phys_addr_t offset,
49
printf("%s: value %08lx written at " PA_FMT "\n",
50
__FUNCTION__, value, offset);
54
static CPUReadMemoryFunc *static_readfn[] = {
60
static CPUWriteMemoryFunc *static_writefn[] = {
66
/* Palm Tunsgten|E support */
69
#define PALMTE_USBDETECT_GPIO 0
70
#define PALMTE_USB_OR_DC_GPIO 1
71
#define PALMTE_TSC_GPIO 4
72
#define PALMTE_PINTDAV_GPIO 6
73
#define PALMTE_MMC_WP_GPIO 8
74
#define PALMTE_MMC_POWER_GPIO 9
75
#define PALMTE_HDQ_GPIO 11
76
#define PALMTE_HEADPHONES_GPIO 14
77
#define PALMTE_SPEAKER_GPIO 15
78
/* MPU private GPIOs */
79
#define PALMTE_DC_GPIO 2
80
#define PALMTE_MMC_SWITCH_GPIO 4
81
#define PALMTE_MMC1_GPIO 6
82
#define PALMTE_MMC2_GPIO 7
83
#define PALMTE_MMC3_GPIO 11
85
static void palmte_microwire_setup(struct omap_mpu_state_s *cpu)
87
struct uwire_slave_s *tsc;
88
AudioState *audio = 0;
94
tsc = tsc2102_init(omap_gpio_in_get(cpu->gpio)[PALMTE_PINTDAV_GPIO],
97
omap_uwire_attach(cpu->microwire, tsc, 0);
98
omap_mcbsp_i2s_attach(cpu->mcbsp1, tsc210x_codec(tsc));
104
} palmte_keymap[0x80] = {
105
[0 ... 0x7f] = { -1, -1 },
106
[0x3b] = { 0, 0 }, /* F1 -> Calendar */
107
[0x3c] = { 1, 0 }, /* F2 -> Contacts */
108
[0x3d] = { 2, 0 }, /* F3 -> Tasks List */
109
[0x3e] = { 3, 0 }, /* F4 -> Note Pad */
110
[0x01] = { 4, 0 }, /* Esc -> Power */
111
[0x4b] = { 0, 1 }, /* Left */
112
[0x50] = { 1, 1 }, /* Down */
113
[0x48] = { 2, 1 }, /* Up */
114
[0x4d] = { 3, 1 }, /* Right */
115
[0x4c] = { 4, 1 }, /* Centre */
116
[0x39] = { 4, 1 }, /* Spc -> Centre */
119
static void palmte_button_event(void *opaque, int keycode)
121
struct omap_mpu_state_s *cpu = (struct omap_mpu_state_s *) opaque;
123
if (palmte_keymap[keycode & 0x7f].row != -1)
124
omap_mpuio_key(cpu->mpuio,
125
palmte_keymap[keycode & 0x7f].row,
126
palmte_keymap[keycode & 0x7f].column,
130
static void palmte_onoff_gpios(void *opaque, int line, int level)
134
printf("%s: current to MMC/SD card %sabled.\n",
135
__FUNCTION__, level ? "dis" : "en");
138
printf("%s: internal speaker amplifier %s.\n",
139
__FUNCTION__, level ? "down" : "on");
142
/* These LCD & Audio output signals have not been identified yet. */
146
printf("%s: LCD GPIO%i %s.\n",
147
__FUNCTION__, line - 1, level ? "high" : "low");
151
printf("%s: Audio GPIO%i %s.\n",
152
__FUNCTION__, line - 4, level ? "high" : "low");
157
static void palmte_gpio_setup(struct omap_mpu_state_s *cpu)
161
omap_mmc_handlers(cpu->mmc,
162
omap_gpio_in_get(cpu->gpio)[PALMTE_MMC_WP_GPIO],
163
qemu_irq_invert(omap_mpuio_in_get(cpu->mpuio)
164
[PALMTE_MMC_SWITCH_GPIO]));
166
misc_gpio = qemu_allocate_irqs(palmte_onoff_gpios, cpu, 7);
167
omap_gpio_out_set(cpu->gpio, PALMTE_MMC_POWER_GPIO, misc_gpio[0]);
168
omap_gpio_out_set(cpu->gpio, PALMTE_SPEAKER_GPIO, misc_gpio[1]);
169
omap_gpio_out_set(cpu->gpio, 11, misc_gpio[2]);
170
omap_gpio_out_set(cpu->gpio, 12, misc_gpio[3]);
171
omap_gpio_out_set(cpu->gpio, 13, misc_gpio[4]);
172
omap_mpuio_out_set(cpu->mpuio, 1, misc_gpio[5]);
173
omap_mpuio_out_set(cpu->mpuio, 3, misc_gpio[6]);
175
/* Reset some inputs to initial state. */
176
qemu_irq_lower(omap_gpio_in_get(cpu->gpio)[PALMTE_USBDETECT_GPIO]);
177
qemu_irq_lower(omap_gpio_in_get(cpu->gpio)[PALMTE_USB_OR_DC_GPIO]);
178
qemu_irq_lower(omap_gpio_in_get(cpu->gpio)[4]);
179
qemu_irq_lower(omap_gpio_in_get(cpu->gpio)[PALMTE_HEADPHONES_GPIO]);
180
qemu_irq_lower(omap_mpuio_in_get(cpu->mpuio)[PALMTE_DC_GPIO]);
181
qemu_irq_raise(omap_mpuio_in_get(cpu->mpuio)[6]);
182
qemu_irq_raise(omap_mpuio_in_get(cpu->mpuio)[7]);
183
qemu_irq_raise(omap_mpuio_in_get(cpu->mpuio)[11]);
186
static void palmte_init(int ram_size, int vga_ram_size,
187
const char *boot_device, DisplayState *ds,
188
const char *kernel_filename, const char *kernel_cmdline,
189
const char *initrd_filename, const char *cpu_model)
191
struct omap_mpu_state_s *cpu;
192
int flash_size = 0x00800000;
193
int sdram_size = 0x02000000;
195
static uint32_t cs0val = 0xffffffff;
196
static uint32_t cs1val = 0x0000e1a0;
197
static uint32_t cs2val = 0x0000e1a0;
198
static uint32_t cs3val = 0xe1a0e1a0;
199
ram_addr_t phys_flash;
200
int rom_size, rom_loaded = 0;
202
if (ram_size < flash_size + sdram_size + OMAP15XX_SRAM_SIZE) {
203
fprintf(stderr, "This architecture uses %i bytes of memory\n",
204
flash_size + sdram_size + OMAP15XX_SRAM_SIZE);
208
cpu = omap310_mpu_init(sdram_size, ds, cpu_model);
210
/* External Flash (EMIFS) */
211
cpu_register_physical_memory(OMAP_CS0_BASE, flash_size,
212
(phys_flash = qemu_ram_alloc(flash_size)) | IO_MEM_ROM);
214
io = cpu_register_io_memory(0, static_readfn, static_writefn, &cs0val);
215
cpu_register_physical_memory(OMAP_CS0_BASE + flash_size,
216
OMAP_CS0_SIZE - flash_size, io);
217
io = cpu_register_io_memory(0, static_readfn, static_writefn, &cs1val);
218
cpu_register_physical_memory(OMAP_CS1_BASE, OMAP_CS1_SIZE, io);
219
io = cpu_register_io_memory(0, static_readfn, static_writefn, &cs2val);
220
cpu_register_physical_memory(OMAP_CS2_BASE, OMAP_CS2_SIZE, io);
221
io = cpu_register_io_memory(0, static_readfn, static_writefn, &cs3val);
222
cpu_register_physical_memory(OMAP_CS3_BASE, OMAP_CS3_SIZE, io);
224
palmte_microwire_setup(cpu);
226
qemu_add_kbd_event_handler(palmte_button_event, cpu);
228
palmte_gpio_setup(cpu);
230
/* Setup initial (reset) machine state */
231
if (nb_option_roms) {
232
rom_size = get_image_size(option_rom[0]);
233
if (rom_size > flash_size)
234
fprintf(stderr, "%s: ROM image too big (%x > %x)\n",
235
__FUNCTION__, rom_size, flash_size);
236
else if (rom_size > 0 && load_image(option_rom[0],
237
phys_ram_base + phys_flash) > 0) {
239
cpu->env->regs[15] = 0x00000000;
241
fprintf(stderr, "%s: error loading '%s'\n",
242
__FUNCTION__, option_rom[0]);
245
if (!rom_loaded && !kernel_filename) {
246
fprintf(stderr, "Kernel or ROM image must be specified\n");
250
/* Load the kernel. */
251
if (kernel_filename) {
252
/* Start at bootloader. */
253
cpu->env->regs[15] = OMAP_EMIFF_BASE;
255
arm_load_kernel(cpu->env, sdram_size, kernel_filename, kernel_cmdline,
256
initrd_filename, 0x331, OMAP_EMIFF_BASE);
259
dpy_resize(ds, 320, 320);
262
QEMUMachine palmte_machine = {
264
"Palm Tungsten|E aka. Cheetah PDA (OMAP310)",
added
removed
hw/palm.c
