1 | /* |
2 | * PalmOne's (TM) PDAs. |
3 | * |
4 | * Copyright (C) 2006-2007 Andrzej Zaborowski <balrog@zabor.org> |
5 | * |
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. |
10 | * |
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. |
15 | * |
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/>. |
18 | */ |
19 | |
20 | #include "qemu/osdep.h" |
21 | #include "qapi/error.h" |
22 | #include "audio/audio.h" |
23 | #include "sysemu/sysemu.h" |
24 | #include "sysemu/qtest.h" |
25 | #include "ui/console.h" |
26 | #include "hw/arm/omap.h" |
27 | #include "hw/boards.h" |
28 | #include "hw/arm/boot.h" |
29 | #include "hw/input/tsc2xxx.h" |
30 | #include "hw/irq.h" |
31 | #include "hw/loader.h" |
32 | #include "exec/address-spaces.h" |
33 | #include "cpu.h" |
34 | |
35 | static uint64_t static_read(void *opaque, hwaddr offset, unsigned size) |
36 | { |
37 | uint32_t *val = (uint32_t *)opaque; |
38 | uint32_t sizemask = 7 >> size; |
39 | |
40 | return *val >> ((offset & sizemask) << 3); |
41 | } |
42 | |
43 | static void static_write(void *opaque, hwaddr offset, uint64_t value, |
44 | unsigned size) |
45 | { |
46 | #ifdef SPY |
47 | printf("%s: value %08lx written at " PA_FMT "\n" , |
48 | __func__, value, offset); |
49 | #endif |
50 | } |
51 | |
52 | static const MemoryRegionOps static_ops = { |
53 | .read = static_read, |
54 | .write = static_write, |
55 | .valid.min_access_size = 1, |
56 | .valid.max_access_size = 4, |
57 | .endianness = DEVICE_NATIVE_ENDIAN, |
58 | }; |
59 | |
60 | /* Palm Tunsgten|E support */ |
61 | |
62 | /* Shared GPIOs */ |
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 |
78 | |
79 | static MouseTransformInfo palmte_pointercal = { |
80 | .x = 320, |
81 | .y = 320, |
82 | .a = { -5909, 8, 22465308, 104, 7644, -1219972, 65536 }, |
83 | }; |
84 | |
85 | static void palmte_microwire_setup(struct omap_mpu_state_s *cpu) |
86 | { |
87 | uWireSlave *tsc; |
88 | |
89 | tsc = tsc2102_init(qdev_get_gpio_in(cpu->gpio, PALMTE_PINTDAV_GPIO)); |
90 | |
91 | omap_uwire_attach(cpu->microwire, tsc, 0); |
92 | omap_mcbsp_i2s_attach(cpu->mcbsp1, tsc210x_codec(tsc)); |
93 | |
94 | tsc210x_set_transform(tsc, &palmte_pointercal); |
95 | } |
96 | |
97 | static struct { |
98 | int row; |
99 | int column; |
100 | } palmte_keymap[0x80] = { |
101 | [0 ... 0x7f] = { -1, -1 }, |
102 | [0x3b] = { 0, 0 }, /* F1 -> Calendar */ |
103 | [0x3c] = { 1, 0 }, /* F2 -> Contacts */ |
104 | [0x3d] = { 2, 0 }, /* F3 -> Tasks List */ |
105 | [0x3e] = { 3, 0 }, /* F4 -> Note Pad */ |
106 | [0x01] = { 4, 0 }, /* Esc -> Power */ |
107 | [0x4b] = { 0, 1 }, /* Left */ |
108 | [0x50] = { 1, 1 }, /* Down */ |
109 | [0x48] = { 2, 1 }, /* Up */ |
110 | [0x4d] = { 3, 1 }, /* Right */ |
111 | [0x4c] = { 4, 1 }, /* Centre */ |
112 | [0x39] = { 4, 1 }, /* Spc -> Centre */ |
113 | }; |
114 | |
115 | static void palmte_button_event(void *opaque, int keycode) |
116 | { |
117 | struct omap_mpu_state_s *cpu = (struct omap_mpu_state_s *) opaque; |
118 | |
119 | if (palmte_keymap[keycode & 0x7f].row != -1) |
120 | omap_mpuio_key(cpu->mpuio, |
121 | palmte_keymap[keycode & 0x7f].row, |
122 | palmte_keymap[keycode & 0x7f].column, |
123 | !(keycode & 0x80)); |
124 | } |
125 | |
126 | static void palmte_onoff_gpios(void *opaque, int line, int level) |
127 | { |
128 | switch (line) { |
129 | case 0: |
130 | printf("%s: current to MMC/SD card %sabled.\n" , |
131 | __func__, level ? "dis" : "en" ); |
132 | break; |
133 | case 1: |
134 | printf("%s: internal speaker amplifier %s.\n" , |
135 | __func__, level ? "down" : "on" ); |
136 | break; |
137 | |
138 | /* These LCD & Audio output signals have not been identified yet. */ |
139 | case 2: |
140 | case 3: |
141 | case 4: |
142 | printf("%s: LCD GPIO%i %s.\n" , |
143 | __func__, line - 1, level ? "high" : "low" ); |
144 | break; |
145 | case 5: |
146 | case 6: |
147 | printf("%s: Audio GPIO%i %s.\n" , |
148 | __func__, line - 4, level ? "high" : "low" ); |
149 | break; |
150 | } |
151 | } |
152 | |
153 | static void palmte_gpio_setup(struct omap_mpu_state_s *cpu) |
154 | { |
155 | qemu_irq *misc_gpio; |
156 | |
157 | omap_mmc_handlers(cpu->mmc, |
158 | qdev_get_gpio_in(cpu->gpio, PALMTE_MMC_WP_GPIO), |
159 | qemu_irq_invert(omap_mpuio_in_get(cpu->mpuio) |
160 | [PALMTE_MMC_SWITCH_GPIO])); |
161 | |
162 | misc_gpio = qemu_allocate_irqs(palmte_onoff_gpios, cpu, 7); |
163 | qdev_connect_gpio_out(cpu->gpio, PALMTE_MMC_POWER_GPIO, misc_gpio[0]); |
164 | qdev_connect_gpio_out(cpu->gpio, PALMTE_SPEAKER_GPIO, misc_gpio[1]); |
165 | qdev_connect_gpio_out(cpu->gpio, 11, misc_gpio[2]); |
166 | qdev_connect_gpio_out(cpu->gpio, 12, misc_gpio[3]); |
167 | qdev_connect_gpio_out(cpu->gpio, 13, misc_gpio[4]); |
168 | omap_mpuio_out_set(cpu->mpuio, 1, misc_gpio[5]); |
169 | omap_mpuio_out_set(cpu->mpuio, 3, misc_gpio[6]); |
170 | |
171 | /* Reset some inputs to initial state. */ |
172 | qemu_irq_lower(qdev_get_gpio_in(cpu->gpio, PALMTE_USBDETECT_GPIO)); |
173 | qemu_irq_lower(qdev_get_gpio_in(cpu->gpio, PALMTE_USB_OR_DC_GPIO)); |
174 | qemu_irq_lower(qdev_get_gpio_in(cpu->gpio, 4)); |
175 | qemu_irq_lower(qdev_get_gpio_in(cpu->gpio, PALMTE_HEADPHONES_GPIO)); |
176 | qemu_irq_lower(omap_mpuio_in_get(cpu->mpuio)[PALMTE_DC_GPIO]); |
177 | qemu_irq_raise(omap_mpuio_in_get(cpu->mpuio)[6]); |
178 | qemu_irq_raise(omap_mpuio_in_get(cpu->mpuio)[7]); |
179 | qemu_irq_raise(omap_mpuio_in_get(cpu->mpuio)[11]); |
180 | } |
181 | |
182 | static struct arm_boot_info palmte_binfo = { |
183 | .loader_start = OMAP_EMIFF_BASE, |
184 | .ram_size = 0x02000000, |
185 | .board_id = 0x331, |
186 | }; |
187 | |
188 | static void palmte_init(MachineState *machine) |
189 | { |
190 | MemoryRegion *address_space_mem = get_system_memory(); |
191 | struct omap_mpu_state_s *mpu; |
192 | int flash_size = 0x00800000; |
193 | int sdram_size = palmte_binfo.ram_size; |
194 | static uint32_t cs0val = 0xffffffff; |
195 | static uint32_t cs1val = 0x0000e1a0; |
196 | static uint32_t cs2val = 0x0000e1a0; |
197 | static uint32_t cs3val = 0xe1a0e1a0; |
198 | int rom_size, rom_loaded = 0; |
199 | MemoryRegion *flash = g_new(MemoryRegion, 1); |
200 | MemoryRegion *cs = g_new(MemoryRegion, 4); |
201 | |
202 | mpu = omap310_mpu_init(address_space_mem, sdram_size, machine->cpu_type); |
203 | |
204 | /* External Flash (EMIFS) */ |
205 | memory_region_init_ram(flash, NULL, "palmte.flash" , flash_size, |
206 | &error_fatal); |
207 | memory_region_set_readonly(flash, true); |
208 | memory_region_add_subregion(address_space_mem, OMAP_CS0_BASE, flash); |
209 | |
210 | memory_region_init_io(&cs[0], NULL, &static_ops, &cs0val, "palmte-cs0" , |
211 | OMAP_CS0_SIZE - flash_size); |
212 | memory_region_add_subregion(address_space_mem, OMAP_CS0_BASE + flash_size, |
213 | &cs[0]); |
214 | memory_region_init_io(&cs[1], NULL, &static_ops, &cs1val, "palmte-cs1" , |
215 | OMAP_CS1_SIZE); |
216 | memory_region_add_subregion(address_space_mem, OMAP_CS1_BASE, &cs[1]); |
217 | memory_region_init_io(&cs[2], NULL, &static_ops, &cs2val, "palmte-cs2" , |
218 | OMAP_CS2_SIZE); |
219 | memory_region_add_subregion(address_space_mem, OMAP_CS2_BASE, &cs[2]); |
220 | memory_region_init_io(&cs[3], NULL, &static_ops, &cs3val, "palmte-cs3" , |
221 | OMAP_CS3_SIZE); |
222 | memory_region_add_subregion(address_space_mem, OMAP_CS3_BASE, &cs[3]); |
223 | |
224 | palmte_microwire_setup(mpu); |
225 | |
226 | qemu_add_kbd_event_handler(palmte_button_event, mpu); |
227 | |
228 | palmte_gpio_setup(mpu); |
229 | |
230 | /* Setup initial (reset) machine state */ |
231 | if (nb_option_roms) { |
232 | rom_size = get_image_size(option_rom[0].name); |
233 | if (rom_size > flash_size) { |
234 | fprintf(stderr, "%s: ROM image too big (%x > %x)\n" , |
235 | __func__, rom_size, flash_size); |
236 | rom_size = 0; |
237 | } |
238 | if (rom_size > 0) { |
239 | rom_size = load_image_targphys(option_rom[0].name, OMAP_CS0_BASE, |
240 | flash_size); |
241 | rom_loaded = 1; |
242 | } |
243 | if (rom_size < 0) { |
244 | fprintf(stderr, "%s: error loading '%s'\n" , |
245 | __func__, option_rom[0].name); |
246 | } |
247 | } |
248 | |
249 | if (!rom_loaded && !machine->kernel_filename && !qtest_enabled()) { |
250 | fprintf(stderr, "Kernel or ROM image must be specified\n" ); |
251 | exit(1); |
252 | } |
253 | |
254 | /* Load the kernel. */ |
255 | arm_load_kernel(mpu->cpu, machine, &palmte_binfo); |
256 | } |
257 | |
258 | static void palmte_machine_init(MachineClass *mc) |
259 | { |
260 | mc->desc = "Palm Tungsten|E aka. Cheetah PDA (OMAP310)" ; |
261 | mc->init = palmte_init; |
262 | mc->ignore_memory_transaction_failures = true; |
263 | mc->default_cpu_type = ARM_CPU_TYPE_NAME("ti925t" ); |
264 | } |
265 | |
266 | DEFINE_MACHINE("cheetah" , palmte_machine_init) |
267 | |