← Back to branch summary

~ubuntu-branches/ubuntu/wily/qemu-kvm-spice/wily

« back to all changes in this revision

Viewing changes to hw/palm.c

  • Committer: Bazaar Package Importer
  • Author(s): Serge Hallyn
  • Date: 2011-10-19 10:44:56 UTC
  • Revision ID: james.westby@ubuntu.com-20111019104456-xgvskumk3sxi97f4
Tags: upstream-0.15.0+noroms
Import upstream version 0.15.0+noroms

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/palm.c
 
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
#include "hw.h"
 
20
#include "audio/audio.h"
 
21
#include "sysemu.h"
 
22
#include "console.h"
 
23
#include "omap.h"
 
24
#include "boards.h"
 
25
#include "arm-misc.h"
 
26
#include "devices.h"
 
27
#include "loader.h"
 
28
 
 
29
static uint32_t static_readb(void *opaque, target_phys_addr_t offset)
 
30
{
 
31
    uint32_t *val = (uint32_t *) opaque;
 
32
    return *val >> ((offset & 3) << 3);
 
33
}
 
34
 
 
35
static uint32_t static_readh(void *opaque, target_phys_addr_t offset)
 
36
{
 
37
    uint32_t *val = (uint32_t *) opaque;
 
38
    return *val >> ((offset & 1) << 3);
 
39
}
 
40
 
 
41
static uint32_t static_readw(void *opaque, target_phys_addr_t offset)
 
42
{
 
43
    uint32_t *val = (uint32_t *) opaque;
 
44
    return *val >> ((offset & 0) << 3);
 
45
}
 
46
 
 
47
static void static_write(void *opaque, target_phys_addr_t offset,
 
48
                uint32_t value)
 
49
{
 
50
#ifdef SPY
 
51
    printf("%s: value %08lx written at " PA_FMT "\n",
 
52
                    __FUNCTION__, value, offset);
 
53
#endif
 
54
}
 
55
 
 
56
static CPUReadMemoryFunc * const static_readfn[] = {
 
57
    static_readb,
 
58
    static_readh,
 
59
    static_readw,
 
60
};
 
61
 
 
62
static CPUWriteMemoryFunc * const static_writefn[] = {
 
63
    static_write,
 
64
    static_write,
 
65
    static_write,
 
66
};
 
67
 
 
68
/* Palm Tunsgten|E support */
 
69
 
 
70
/* Shared GPIOs */
 
71
#define PALMTE_USBDETECT_GPIO   0
 
72
#define PALMTE_USB_OR_DC_GPIO   1
 
73
#define PALMTE_TSC_GPIO         4
 
74
#define PALMTE_PINTDAV_GPIO     6
 
75
#define PALMTE_MMC_WP_GPIO      8
 
76
#define PALMTE_MMC_POWER_GPIO   9
 
77
#define PALMTE_HDQ_GPIO         11
 
78
#define PALMTE_HEADPHONES_GPIO  14
 
79
#define PALMTE_SPEAKER_GPIO     15
 
80
/* MPU private GPIOs */
 
81
#define PALMTE_DC_GPIO          2
 
82
#define PALMTE_MMC_SWITCH_GPIO  4
 
83
#define PALMTE_MMC1_GPIO        6
 
84
#define PALMTE_MMC2_GPIO        7
 
85
#define PALMTE_MMC3_GPIO        11
 
86
 
 
87
static MouseTransformInfo palmte_pointercal = {
 
88
    .x = 320,
 
89
    .y = 320,
 
90
    .a = { -5909, 8, 22465308, 104, 7644, -1219972, 65536 },
 
91
};
 
92
 
 
93
static void palmte_microwire_setup(struct omap_mpu_state_s *cpu)
 
94
{
 
95
    uWireSlave *tsc;
 
96
 
 
97
    tsc = tsc2102_init(omap_gpio_in_get(cpu->gpio)[PALMTE_PINTDAV_GPIO]);
 
98
 
 
99
    omap_uwire_attach(cpu->microwire, tsc, 0);
 
100
    omap_mcbsp_i2s_attach(cpu->mcbsp1, tsc210x_codec(tsc));
 
101
 
 
102
    tsc210x_set_transform(tsc, &palmte_pointercal);
 
103
}
 
104
 
 
105
static struct {
 
106
    int row;
 
107
    int column;
 
108
} palmte_keymap[0x80] = {
 
109
    [0 ... 0x7f] = { -1, -1 },
 
110
    [0x3b] = { 0, 0 },  /* F1   -> Calendar */
 
111
    [0x3c] = { 1, 0 },  /* F2   -> Contacts */
 
112
    [0x3d] = { 2, 0 },  /* F3   -> Tasks List */
 
113
    [0x3e] = { 3, 0 },  /* F4   -> Note Pad */
 
114
    [0x01] = { 4, 0 },  /* Esc  -> Power */
 
115
    [0x4b] = { 0, 1 },  /*         Left */
 
116
    [0x50] = { 1, 1 },  /*         Down */
 
117
    [0x48] = { 2, 1 },  /*         Up */
 
118
    [0x4d] = { 3, 1 },  /*         Right */
 
119
    [0x4c] = { 4, 1 },  /*         Centre */
 
120
    [0x39] = { 4, 1 },  /* Spc  -> Centre */
 
121
};
 
122
 
 
123
static void palmte_button_event(void *opaque, int keycode)
 
124
{
 
125
    struct omap_mpu_state_s *cpu = (struct omap_mpu_state_s *) opaque;
 
126
 
 
127
    if (palmte_keymap[keycode & 0x7f].row != -1)
 
128
        omap_mpuio_key(cpu->mpuio,
 
129
                        palmte_keymap[keycode & 0x7f].row,
 
130
                        palmte_keymap[keycode & 0x7f].column,
 
131
                        !(keycode & 0x80));
 
132
}
 
133
 
 
134
static void palmte_onoff_gpios(void *opaque, int line, int level)
 
135
{
 
136
    switch (line) {
 
137
    case 0:
 
138
        printf("%s: current to MMC/SD card %sabled.\n",
 
139
                        __FUNCTION__, level ? "dis" : "en");
 
140
        break;
 
141
    case 1:
 
142
        printf("%s: internal speaker amplifier %s.\n",
 
143
                        __FUNCTION__, level ? "down" : "on");
 
144
        break;
 
145
 
 
146
    /* These LCD & Audio output signals have not been identified yet.  */
 
147
    case 2:
 
148
    case 3:
 
149
    case 4:
 
150
        printf("%s: LCD GPIO%i %s.\n",
 
151
                        __FUNCTION__, line - 1, level ? "high" : "low");
 
152
        break;
 
153
    case 5:
 
154
    case 6:
 
155
        printf("%s: Audio GPIO%i %s.\n",
 
156
                        __FUNCTION__, line - 4, level ? "high" : "low");
 
157
        break;
 
158
    }
 
159
}
 
160
 
 
161
static void palmte_gpio_setup(struct omap_mpu_state_s *cpu)
 
162
{
 
163
    qemu_irq *misc_gpio;
 
164
 
 
165
    omap_mmc_handlers(cpu->mmc,
 
166
                    omap_gpio_in_get(cpu->gpio)[PALMTE_MMC_WP_GPIO],
 
167
                    qemu_irq_invert(omap_mpuio_in_get(cpu->mpuio)
 
168
                            [PALMTE_MMC_SWITCH_GPIO]));
 
169
 
 
170
    misc_gpio = qemu_allocate_irqs(palmte_onoff_gpios, cpu, 7);
 
171
    omap_gpio_out_set(cpu->gpio, PALMTE_MMC_POWER_GPIO, misc_gpio[0]);
 
172
    omap_gpio_out_set(cpu->gpio, PALMTE_SPEAKER_GPIO,   misc_gpio[1]);
 
173
    omap_gpio_out_set(cpu->gpio, 11,                    misc_gpio[2]);
 
174
    omap_gpio_out_set(cpu->gpio, 12,                    misc_gpio[3]);
 
175
    omap_gpio_out_set(cpu->gpio, 13,                    misc_gpio[4]);
 
176
    omap_mpuio_out_set(cpu->mpuio, 1,                   misc_gpio[5]);
 
177
    omap_mpuio_out_set(cpu->mpuio, 3,                   misc_gpio[6]);
 
178
 
 
179
    /* Reset some inputs to initial state.  */
 
180
    qemu_irq_lower(omap_gpio_in_get(cpu->gpio)[PALMTE_USBDETECT_GPIO]);
 
181
    qemu_irq_lower(omap_gpio_in_get(cpu->gpio)[PALMTE_USB_OR_DC_GPIO]);
 
182
    qemu_irq_lower(omap_gpio_in_get(cpu->gpio)[4]);
 
183
    qemu_irq_lower(omap_gpio_in_get(cpu->gpio)[PALMTE_HEADPHONES_GPIO]);
 
184
    qemu_irq_lower(omap_mpuio_in_get(cpu->mpuio)[PALMTE_DC_GPIO]);
 
185
    qemu_irq_raise(omap_mpuio_in_get(cpu->mpuio)[6]);
 
186
    qemu_irq_raise(omap_mpuio_in_get(cpu->mpuio)[7]);
 
187
    qemu_irq_raise(omap_mpuio_in_get(cpu->mpuio)[11]);
 
188
}
 
189
 
 
190
static struct arm_boot_info palmte_binfo = {
 
191
    .loader_start = OMAP_EMIFF_BASE,
 
192
    .ram_size = 0x02000000,
 
193
    .board_id = 0x331,
 
194
};
 
195
 
 
196
static void palmte_init(ram_addr_t ram_size,
 
197
                const char *boot_device,
 
198
                const char *kernel_filename, const char *kernel_cmdline,
 
199
                const char *initrd_filename, const char *cpu_model)
 
200
{
 
201
    struct omap_mpu_state_s *cpu;
 
202
    int flash_size = 0x00800000;
 
203
    int sdram_size = palmte_binfo.ram_size;
 
204
    int io;
 
205
    static uint32_t cs0val = 0xffffffff;
 
206
    static uint32_t cs1val = 0x0000e1a0;
 
207
    static uint32_t cs2val = 0x0000e1a0;
 
208
    static uint32_t cs3val = 0xe1a0e1a0;
 
209
    int rom_size, rom_loaded = 0;
 
210
    DisplayState *ds = get_displaystate();
 
211
 
 
212
    cpu = omap310_mpu_init(sdram_size, cpu_model);
 
213
 
 
214
    /* External Flash (EMIFS) */
 
215
    cpu_register_physical_memory(OMAP_CS0_BASE, flash_size,
 
216
                                 qemu_ram_alloc(NULL, "palmte.flash",
 
217
                                                flash_size) | IO_MEM_ROM);
 
218
 
 
219
    io = cpu_register_io_memory(static_readfn, static_writefn, &cs0val,
 
220
                                DEVICE_NATIVE_ENDIAN);
 
221
    cpu_register_physical_memory(OMAP_CS0_BASE + flash_size,
 
222
                    OMAP_CS0_SIZE - flash_size, io);
 
223
    io = cpu_register_io_memory(static_readfn, static_writefn, &cs1val,
 
224
                                DEVICE_NATIVE_ENDIAN);
 
225
    cpu_register_physical_memory(OMAP_CS1_BASE, OMAP_CS1_SIZE, io);
 
226
    io = cpu_register_io_memory(static_readfn, static_writefn, &cs2val,
 
227
                                DEVICE_NATIVE_ENDIAN);
 
228
    cpu_register_physical_memory(OMAP_CS2_BASE, OMAP_CS2_SIZE, io);
 
229
    io = cpu_register_io_memory(static_readfn, static_writefn, &cs3val,
 
230
                                DEVICE_NATIVE_ENDIAN);
 
231
    cpu_register_physical_memory(OMAP_CS3_BASE, OMAP_CS3_SIZE, io);
 
232
 
 
233
    palmte_microwire_setup(cpu);
 
234
 
 
235
    qemu_add_kbd_event_handler(palmte_button_event, cpu);
 
236
 
 
237
    palmte_gpio_setup(cpu);
 
238
 
 
239
    /* Setup initial (reset) machine state */
 
240
    if (nb_option_roms) {
 
241
        rom_size = get_image_size(option_rom[0].name);
 
242
        if (rom_size > flash_size) {
 
243
            fprintf(stderr, "%s: ROM image too big (%x > %x)\n",
 
244
                            __FUNCTION__, rom_size, flash_size);
 
245
            rom_size = 0;
 
246
        }
 
247
        if (rom_size > 0) {
 
248
            rom_size = load_image_targphys(option_rom[0].name, OMAP_CS0_BASE,
 
249
                                           flash_size);
 
250
            rom_loaded = 1;
 
251
        }
 
252
        if (rom_size < 0) {
 
253
            fprintf(stderr, "%s: error loading '%s'\n",
 
254
                            __FUNCTION__, option_rom[0].name);
 
255
        }
 
256
    }
 
257
 
 
258
    if (!rom_loaded && !kernel_filename) {
 
259
        fprintf(stderr, "Kernel or ROM image must be specified\n");
 
260
        exit(1);
 
261
    }
 
262
 
 
263
    /* Load the kernel.  */
 
264
    if (kernel_filename) {
 
265
        palmte_binfo.kernel_filename = kernel_filename;
 
266
        palmte_binfo.kernel_cmdline = kernel_cmdline;
 
267
        palmte_binfo.initrd_filename = initrd_filename;
 
268
        arm_load_kernel(cpu->env, &palmte_binfo);
 
269
    }
 
270
 
 
271
    /* FIXME: We shouldn't really be doing this here.  The LCD controller
 
272
       will set the size once configured, so this just sets an initial
 
273
       size until the guest activates the display.  */
 
274
    ds->surface = qemu_resize_displaysurface(ds, 320, 320);
 
275
    dpy_resize(ds);
 
276
}
 
277
 
 
278
static QEMUMachine palmte_machine = {
 
279
    .name = "cheetah",
 
280
    .desc = "Palm Tungsten|E aka. Cheetah PDA (OMAP310)",
 
281
    .init = palmte_init,
 
282
};
 
283
 
 
284
static void palmte_machine_init(void)
 
285
{
 
286
    qemu_register_machine(&palmte_machine);
 
287
}
 
288
 
 
289
machine_init(palmte_machine_init);