← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to .pc/ubuntu/linaro/0051-hw-nseries.c-Add-support-for-n900-MIPID.patch/hw/arm/nseries.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2014-02-04 12:13:08 UTC
  • mfrom: (10.1.45 sid)
  • Revision ID: package-import@ubuntu.com-20140204121308-1xq92lrfs75agw2g
Tags: 1.7.0+dfsg-3ubuntu1~ppa1
* Merge 1.7.0+dfsg-3 from debian.  Remaining changes:
  - debian/patches/ubuntu:
    * expose-vmx_qemu64cpu.patch
    * linaro (omap3) and arm64 patches
    * ubuntu/target-ppc-add-stubs-for-kvm-breakpoints: fix FTBFS
      on ppc
    * ubuntu/CVE-2013-4377.patch: fix denial of service via virtio
  - debian/qemu-system-x86.modprobe: set kvm_intel nested=1 options
  - debian/control:
    * add arm64 to Architectures
    * add qemu-common and qemu-system-aarch64 packages
  - debian/qemu-system-common.install: add debian/tmp/usr/lib
  - debian/qemu-system-common.preinst: add kvm group
  - debian/qemu-system-common.postinst: remove acl placed by udev,
    and add udevadm trigger.
  - qemu-system-x86.links: add eepro100.rom, remove pxe-virtio,
    pxe-e1000 and pxe-rtl8139.
  - add qemu-system-x86.qemu-kvm.upstart and .default
  - qemu-user-static.postinst-in: remove arm64 binfmt
  - debian/rules:
    * allow parallel build
    * add aarch64 to system_targets and sys_systems
    * add qemu-kvm-spice links
    * install qemu-system-x86.modprobe
  - add debian/qemu-system-common.links for OVMF.fd link
* Remove kvm-img, kvm-nbd, kvm-ifup and kvm-ifdown symlinks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/ubuntu/linaro/0051-hw-nseries.c-Add-support-for-n900-MIPID.patch/hw/arm/nseries.c
 
1
/*
 
2
 * Nokia N-series internet tablets.
 
3
 *
 
4
 * Copyright (C) 2007 Nokia Corporation
 
5
 * Written by Andrzej Zaborowski <andrew@openedhand.com>
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or
 
8
 * modify it under the terms of the GNU General Public License as
 
9
 * published by the Free Software Foundation; either version 2 or
 
10
 * (at your option) version 3 of the License.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU General Public License along
 
18
 * with this program; if not, see <http://www.gnu.org/licenses/>.
 
19
 */
 
20
 
 
21
#include "qemu-common.h"
 
22
#include "sysemu/sysemu.h"
 
23
#include "hw/arm/omap.h"
 
24
#include "hw/arm/arm.h"
 
25
#include "hw/irq.h"
 
26
#include "ui/console.h"
 
27
#include "hw/boards.h"
 
28
#include "hw/i2c/i2c.h"
 
29
#include "hw/devices.h"
 
30
#include "hw/block/flash.h"
 
31
#include "hw/spi.h"
 
32
#include "hw/hw.h"
 
33
#include "hw/bt.h"
 
34
#include "hw/loader.h"
 
35
#include "sysemu/blockdev.h"
 
36
#include "hw/sysbus.h"
 
37
#include "exec/address-spaces.h"
 
38
 
 
39
//#define MIPID_DEBUG
 
40
 
 
41
#ifdef MIPID_DEBUG
 
42
#define TRACE_MIPID(fmt, ...) \
 
43
    fprintf(stderr, "%s@%d: " fmt "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__)
 
44
#else
 
45
#define TRACE_MIPID(...)
 
46
#endif
 
47
 
 
48
/* Nokia N8x0 support */
 
49
struct n800_s {
 
50
    struct omap_mpu_state_s *mpu;
 
51
 
 
52
    struct rfbi_chip_s blizzard;
 
53
    DeviceState *mipid;
 
54
    DeviceState *tsc;
 
55
 
 
56
    int keymap[0x80];
 
57
    DeviceState *kbd;
 
58
 
 
59
    DeviceState *usb;
 
60
    void *retu;
 
61
    void *tahvo;
 
62
    DeviceState *nand;
 
63
};
 
64
 
 
65
/* GPIO pins */
 
66
#define N8X0_TUSB_ENABLE_GPIO           0
 
67
#define N800_MMC2_WP_GPIO               8
 
68
#define N800_UNKNOWN_GPIO0              9       /* out */
 
69
#define N810_MMC2_VIOSD_GPIO            9
 
70
#define N810_HEADSET_AMP_GPIO           10
 
71
#define N800_CAM_TURN_GPIO              12
 
72
#define N810_GPS_RESET_GPIO             12
 
73
#define N800_BLIZZARD_POWERDOWN_GPIO    15
 
74
#define N800_MMC1_WP_GPIO               23
 
75
#define N810_MMC2_VSD_GPIO              23
 
76
#define N8X0_ONENAND_GPIO               26
 
77
#define N810_BLIZZARD_RESET_GPIO        30
 
78
#define N800_UNKNOWN_GPIO2              53      /* out */
 
79
#define N8X0_TUSB_INT_GPIO              58
 
80
#define N8X0_BT_WKUP_GPIO               61
 
81
#define N8X0_STI_GPIO                   62
 
82
#define N8X0_CBUS_SEL_GPIO              64
 
83
#define N8X0_CBUS_DAT_GPIO              65
 
84
#define N8X0_CBUS_CLK_GPIO              66
 
85
#define N8X0_WLAN_IRQ_GPIO              87
 
86
#define N8X0_BT_RESET_GPIO              92
 
87
#define N8X0_TEA5761_CS_GPIO            93
 
88
#define N800_UNKNOWN_GPIO               94
 
89
#define N810_TSC_RESET_GPIO             94
 
90
#define N800_CAM_ACT_GPIO               95
 
91
#define N810_GPS_WAKEUP_GPIO            95
 
92
#define N8X0_MMC_CS_GPIO                96
 
93
#define N8X0_WLAN_PWR_GPIO              97
 
94
#define N8X0_BT_HOST_WKUP_GPIO          98
 
95
#define N810_SPEAKER_AMP_GPIO           101
 
96
#define N810_KB_LOCK_GPIO               102
 
97
#define N800_TSC_TS_GPIO                103
 
98
#define N810_TSC_TS_GPIO                106
 
99
#define N8X0_HEADPHONE_GPIO             107
 
100
#define N8X0_RETU_GPIO                  108
 
101
#define N800_TSC_KP_IRQ_GPIO            109
 
102
#define N810_KEYBOARD_GPIO              109
 
103
#define N800_BAT_COVER_GPIO             110
 
104
#define N810_SLIDE_GPIO                 110
 
105
#define N8X0_TAHVO_GPIO                 111
 
106
#define N800_UNKNOWN_GPIO4              112     /* out */
 
107
#define N810_SLEEPX_LED_GPIO            112
 
108
#define N800_TSC_RESET_GPIO             118     /* ? */
 
109
#define N810_AIC33_RESET_GPIO           118
 
110
#define N800_TSC_UNKNOWN_GPIO           119     /* out */
 
111
#define N8X0_TMP105_GPIO                125
 
112
 
 
113
/* Config */
 
114
#define BT_UART                         0
 
115
#define XLDR_LL_UART                    1
 
116
 
 
117
/* Addresses on the I2C bus 0 */
 
118
#define N810_TLV320AIC33_ADDR           0x18    /* Audio CODEC */
 
119
#define N8X0_TCM825x_ADDR               0x29    /* Camera */
 
120
#define N810_LP5521_ADDR                0x32    /* LEDs */
 
121
#define N810_TSL2563_ADDR               0x3d    /* Light sensor */
 
122
#define N810_LM8323_ADDR                0x45    /* Keyboard */
 
123
/* Addresses on the I2C bus 1 */
 
124
#define N8X0_TMP105_ADDR                0x48    /* Temperature sensor */
 
125
#define N8X0_MENELAUS_ADDR              0x72    /* Power management */
 
126
 
 
127
/* Chipselects on GPMC NOR interface */
 
128
#define N8X0_ONENAND_CS                 0
 
129
#define N8X0_USB_ASYNC_CS               1
 
130
#define N8X0_USB_SYNC_CS                4
 
131
 
 
132
#define N8X0_BD_ADDR                    0x00, 0x1a, 0x89, 0x9e, 0x3e, 0x81
 
133
 
 
134
static void n800_mmc_cs_cb(void *opaque, int line, int level)
 
135
{
 
136
    /* TODO: this seems to actually be connected to the menelaus, to
 
137
     * which also both MMC slots connect.  */
 
138
    omap_mmc_enable((struct omap_mmc_s *) opaque, !level);
 
139
}
 
140
 
 
141
static void n8x0_gpio_setup(struct n800_s *s)
 
142
{
 
143
    qemu_irq *mmc_cs = qemu_allocate_irqs(n800_mmc_cs_cb, s->mpu->mmc, 1);
 
144
    qdev_connect_gpio_out(s->mpu->gpio, N8X0_MMC_CS_GPIO, mmc_cs[0]);
 
145
 
 
146
    qemu_irq_lower(qdev_get_gpio_in(s->mpu->gpio, N800_BAT_COVER_GPIO));
 
147
}
 
148
 
 
149
#define MAEMO_CAL_HEADER(...)                           \
 
150
    'C',  'o',  'n',  'F',  0x02, 0x00, 0x04, 0x00,     \
 
151
    __VA_ARGS__,                                        \
 
152
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
153
 
 
154
static const uint8_t n8x0_cal_wlan_mac[] = {
 
155
    MAEMO_CAL_HEADER('w', 'l', 'a', 'n', '-', 'm', 'a', 'c')
 
156
    0x1c, 0x00, 0x00, 0x00, 0x47, 0xd6, 0x69, 0xb3,
 
157
    0x30, 0x08, 0xa0, 0x83, 0x00, 0x00, 0x00, 0x00,
 
158
    0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
 
159
    0x89, 0x00, 0x00, 0x00, 0x9e, 0x00, 0x00, 0x00,
 
160
    0x5d, 0x00, 0x00, 0x00, 0xc1, 0x00, 0x00, 0x00,
 
161
};
 
162
 
 
163
static const uint8_t n8x0_cal_bt_id[] = {
 
164
    MAEMO_CAL_HEADER('b', 't', '-', 'i', 'd', 0, 0, 0)
 
165
    0x0a, 0x00, 0x00, 0x00, 0xa3, 0x4b, 0xf6, 0x96,
 
166
    0xa8, 0xeb, 0xb2, 0x41, 0x00, 0x00, 0x00, 0x00,
 
167
    N8X0_BD_ADDR,
 
168
};
 
169
 
 
170
static void n8x0_nand_setup(struct n800_s *s)
 
171
{
 
172
    char *otp_region;
 
173
    DriveInfo *dinfo;
 
174
 
 
175
    s->nand = qdev_create(NULL, "onenand");
 
176
    qdev_prop_set_uint16(s->nand, "manufacturer_id", NAND_MFR_SAMSUNG);
 
177
    /* Either 0x40 or 0x48 are OK for the device ID */
 
178
    qdev_prop_set_uint16(s->nand, "device_id", 0x48);
 
179
    qdev_prop_set_uint16(s->nand, "version_id", 0);
 
180
    qdev_prop_set_int32(s->nand, "shift", 1);
 
181
    dinfo = drive_get(IF_MTD, 0, 0);
 
182
    if (dinfo && dinfo->bdrv) {
 
183
        qdev_prop_set_drive_nofail(s->nand, "drive", dinfo->bdrv);
 
184
    }
 
185
    qdev_init_nofail(s->nand);
 
186
    sysbus_connect_irq(SYS_BUS_DEVICE(s->nand), 0,
 
187
                       qdev_get_gpio_in(s->mpu->gpio, N8X0_ONENAND_GPIO));
 
188
    omap_gpmc_attach(s->mpu->gpmc, N8X0_ONENAND_CS,
 
189
                     sysbus_mmio_get_region(SYS_BUS_DEVICE(s->nand), 0));
 
190
    otp_region = onenand_raw_otp(s->nand);
 
191
 
 
192
    memcpy(otp_region + 0x000, n8x0_cal_wlan_mac, sizeof(n8x0_cal_wlan_mac));
 
193
    memcpy(otp_region + 0x800, n8x0_cal_bt_id, sizeof(n8x0_cal_bt_id));
 
194
    /* XXX: in theory should also update the OOB for both pages */
 
195
}
 
196
 
 
197
static qemu_irq n8x0_system_powerdown;
 
198
 
 
199
static void n8x0_powerdown_req(Notifier *n, void *opaque)
 
200
{
 
201
    qemu_irq_raise(n8x0_system_powerdown);
 
202
}
 
203
 
 
204
static Notifier n8x0_system_powerdown_notifier = {
 
205
    .notify = n8x0_powerdown_req
 
206
};
 
207
 
 
208
static void n8x0_i2c_setup(struct n800_s *s)
 
209
{
 
210
    DeviceState *dev;
 
211
    qemu_irq tmp_irq = qdev_get_gpio_in(s->mpu->gpio, N8X0_TMP105_GPIO);
 
212
    i2c_bus *i2c = omap_i2c_bus(s->mpu->i2c[0]);
 
213
 
 
214
    /* Attach a menelaus PM chip */
 
215
    dev = i2c_create_slave(i2c, "twl92230", N8X0_MENELAUS_ADDR);
 
216
    qdev_connect_gpio_out(dev, 3,
 
217
                          qdev_get_gpio_in(s->mpu->ih[0],
 
218
                                           OMAP_INT_24XX_SYS_NIRQ));
 
219
 
 
220
    n8x0_system_powerdown = qdev_get_gpio_in(dev, 3);
 
221
    qemu_register_powerdown_notifier(&n8x0_system_powerdown_notifier);
 
222
 
 
223
    /* Attach a TMP105 PM chip (A0 wired to ground) */
 
224
    dev = i2c_create_slave(i2c, "tmp105", N8X0_TMP105_ADDR);
 
225
    qdev_connect_gpio_out(dev, 0, tmp_irq);
 
226
}
 
227
 
 
228
/* Touchscreen and keypad controller */
 
229
static MouseTransformInfo n800_pointercal = {
 
230
    .x = 800,
 
231
    .y = 480,
 
232
    .a = { 14560, -68, -3455208, -39, -9621, 35152972, 65536 },
 
233
};
 
234
 
 
235
static MouseTransformInfo n810_pointercal = {
 
236
    .x = 800,
 
237
    .y = 480,
 
238
    .a = { 15041, 148, -4731056, 171, -10238, 35933380, 65536 },
 
239
};
 
240
 
 
241
#define RETU_KEYCODE    61      /* F3 */
 
242
 
 
243
static void n800_key_event(void *opaque, int keycode)
 
244
{
 
245
    struct n800_s *s = (struct n800_s *) opaque;
 
246
    int code = s->keymap[keycode & 0x7f];
 
247
 
 
248
    if (code == -1) {
 
249
        if ((keycode & 0x7f) == RETU_KEYCODE)
 
250
            retu_key_event(s->retu, !(keycode & 0x80));
 
251
        return;
 
252
    }
 
253
 
 
254
    tsc2301_key_event(s->tsc, code, !(keycode & 0x80));
 
255
}
 
256
 
 
257
static const int n800_keys[16] = {
 
258
    -1,
 
259
    72, /* Up */
 
260
    63, /* Home (F5) */
 
261
    -1,
 
262
    75, /* Left */
 
263
    28, /* Enter */
 
264
    77, /* Right */
 
265
    -1,
 
266
     1, /* Cycle (ESC) */
 
267
    80, /* Down */
 
268
    62, /* Menu (F4) */
 
269
    -1,
 
270
    66, /* Zoom- (F8) */
 
271
    64, /* FullScreen (F6) */
 
272
    65, /* Zoom+ (F7) */
 
273
    -1,
 
274
};
 
275
 
 
276
static void n800_tsc_kbd_setup(struct n800_s *s)
 
277
{
 
278
    int i;
 
279
 
 
280
    /* XXX: are the three pins inverted inside the chip between the
 
281
     * tsc and the cpu (N4111)?  */
 
282
    s->tsc = spi_create_device(omap_mcspi_bus(s->mpu->mcspi, 0), "tsc2301", 0);
 
283
    /* penirq NC */
 
284
    qdev_connect_gpio_out(s->tsc, 1, qdev_get_gpio_in(s->mpu->gpio,
 
285
                                                      N800_TSC_KP_IRQ_GPIO));
 
286
    qdev_connect_gpio_out(s->tsc, 2, qdev_get_gpio_in(s->mpu->gpio,
 
287
                                                      N800_TSC_TS_GPIO));
 
288
 
 
289
    for (i = 0; i < 0x80; i ++)
 
290
        s->keymap[i] = -1;
 
291
    for (i = 0; i < 0x10; i ++)
 
292
        if (n800_keys[i] >= 0)
 
293
            s->keymap[n800_keys[i]] = i;
 
294
 
 
295
    qemu_add_kbd_event_handler(n800_key_event, s);
 
296
 
 
297
    tsc2301_set_transform(s->tsc, &n800_pointercal);
 
298
}
 
299
 
 
300
static void n810_tsc_setup(struct n800_s *s)
 
301
{
 
302
    s->tsc = spi_create_device(omap_mcspi_bus(s->mpu->mcspi, 0), "tsc2005", 0);
 
303
    qdev_connect_gpio_out(s->tsc, 0, qdev_get_gpio_in(s->mpu->gpio,
 
304
                                                      N810_TSC_TS_GPIO));
 
305
    tsc2005_set_transform(s->tsc, &n810_pointercal, 400, 4000);
 
306
}
 
307
 
 
308
/* N810 Keyboard controller */
 
309
static void n810_key_event(void *opaque, int keycode)
 
310
{
 
311
    struct n800_s *s = (struct n800_s *) opaque;
 
312
    int code = s->keymap[keycode & 0x7f];
 
313
 
 
314
    if (code == -1) {
 
315
        if ((keycode & 0x7f) == RETU_KEYCODE)
 
316
            retu_key_event(s->retu, !(keycode & 0x80));
 
317
        return;
 
318
    }
 
319
 
 
320
    lm832x_key_event(s->kbd, code, !(keycode & 0x80));
 
321
}
 
322
 
 
323
#define M       0
 
324
 
 
325
static int n810_keys[0x80] = {
 
326
    [0x01] = 16,        /* Q */
 
327
    [0x02] = 37,        /* K */
 
328
    [0x03] = 24,        /* O */
 
329
    [0x04] = 25,        /* P */
 
330
    [0x05] = 14,        /* Backspace */
 
331
    [0x06] = 30,        /* A */
 
332
    [0x07] = 31,        /* S */
 
333
    [0x08] = 32,        /* D */
 
334
    [0x09] = 33,        /* F */
 
335
    [0x0a] = 34,        /* G */
 
336
    [0x0b] = 35,        /* H */
 
337
    [0x0c] = 36,        /* J */
 
338
 
 
339
    [0x11] = 17,        /* W */
 
340
    [0x12] = 62,        /* Menu (F4) */
 
341
    [0x13] = 38,        /* L */
 
342
    [0x14] = 40,        /* ' (Apostrophe) */
 
343
    [0x16] = 44,        /* Z */
 
344
    [0x17] = 45,        /* X */
 
345
    [0x18] = 46,        /* C */
 
346
    [0x19] = 47,        /* V */
 
347
    [0x1a] = 48,        /* B */
 
348
    [0x1b] = 49,        /* N */
 
349
    [0x1c] = 42,        /* Shift (Left shift) */
 
350
    [0x1f] = 65,        /* Zoom+ (F7) */
 
351
 
 
352
    [0x21] = 18,        /* E */
 
353
    [0x22] = 39,        /* ; (Semicolon) */
 
354
    [0x23] = 12,        /* - (Minus) */
 
355
    [0x24] = 13,        /* = (Equal) */
 
356
    [0x2b] = 56,        /* Fn (Left Alt) */
 
357
    [0x2c] = 50,        /* M */
 
358
    [0x2f] = 66,        /* Zoom- (F8) */
 
359
 
 
360
    [0x31] = 19,        /* R */
 
361
    [0x32] = 29 | M,    /* Right Ctrl */
 
362
    [0x34] = 57,        /* Space */
 
363
    [0x35] = 51,        /* , (Comma) */
 
364
    [0x37] = 72 | M,    /* Up */
 
365
    [0x3c] = 82 | M,    /* Compose (Insert) */
 
366
    [0x3f] = 64,        /* FullScreen (F6) */
 
367
 
 
368
    [0x41] = 20,        /* T */
 
369
    [0x44] = 52,        /* . (Dot) */
 
370
    [0x46] = 77 | M,    /* Right */
 
371
    [0x4f] = 63,        /* Home (F5) */
 
372
    [0x51] = 21,        /* Y */
 
373
    [0x53] = 80 | M,    /* Down */
 
374
    [0x55] = 28,        /* Enter */
 
375
    [0x5f] =  1,        /* Cycle (ESC) */
 
376
 
 
377
    [0x61] = 22,        /* U */
 
378
    [0x64] = 75 | M,    /* Left */
 
379
 
 
380
    [0x71] = 23,        /* I */
 
381
#if 0
 
382
    [0x75] = 28 | M,    /* KP Enter (KP Enter) */
 
383
#else
 
384
    [0x75] = 15,        /* KP Enter (Tab) */
 
385
#endif
 
386
};
 
387
 
 
388
#undef M
 
389
 
 
390
static void n810_kbd_setup(struct n800_s *s)
 
391
{
 
392
    qemu_irq kbd_irq = qdev_get_gpio_in(s->mpu->gpio, N810_KEYBOARD_GPIO);
 
393
    int i;
 
394
 
 
395
    for (i = 0; i < 0x80; i ++)
 
396
        s->keymap[i] = -1;
 
397
    for (i = 0; i < 0x80; i ++)
 
398
        if (n810_keys[i] > 0)
 
399
            s->keymap[n810_keys[i]] = i;
 
400
 
 
401
    qemu_add_kbd_event_handler(n810_key_event, s);
 
402
 
 
403
    /* Attach the LM8322 keyboard to the I2C bus,
 
404
     * should happen in n8x0_i2c_setup and s->kbd be initialised here.  */
 
405
    s->kbd = i2c_create_slave(omap_i2c_bus(s->mpu->i2c[0]),
 
406
                           "lm8323", N810_LM8323_ADDR);
 
407
    qdev_connect_gpio_out(s->kbd, 0, kbd_irq);
 
408
}
 
409
 
 
410
/* LCD MIPI DBI-C controller (URAL) */
 
411
struct mipid_s {
 
412
    SPIDevice spi;
 
413
    int resp[4];
 
414
    int param[4];
 
415
    int p;
 
416
    int pm;
 
417
    int cmd;
 
418
 
 
419
    int sleep;
 
420
    int booster;
 
421
    int te;
 
422
    int selfcheck;
 
423
    int partial;
 
424
    int normal;
 
425
    int vscr;
 
426
    int invert;
 
427
    int onoff;
 
428
    int gamma;
 
429
    uint32_t id;
 
430
};
 
431
 
 
432
static void mipid_reset(DeviceState *qdev)
 
433
{
 
434
    struct mipid_s *s = FROM_SPI_DEVICE(struct mipid_s,
 
435
                                        SPI_DEVICE_FROM_QDEV(qdev));
 
436
 
 
437
    s->pm = 0;
 
438
    s->cmd = 0;
 
439
 
 
440
    s->sleep = 1;
 
441
    s->booster = 0;
 
442
    s->selfcheck =
 
443
            (1 << 7) |  /* Register loading OK.  */
 
444
            (1 << 5) |  /* The chip is attached.  */
 
445
            (1 << 4);   /* Display glass still in one piece.  */
 
446
    s->te = 0;
 
447
    s->partial = 0;
 
448
    s->normal = 1;
 
449
    s->vscr = 0;
 
450
    s->invert = 0;
 
451
    s->onoff = 1;
 
452
    s->gamma = 0;
 
453
}
 
454
 
 
455
static uint32_t mipid_txrx(SPIDevice *spidev, uint32_t cmd, int len)
 
456
{
 
457
    struct mipid_s *s = FROM_SPI_DEVICE(struct mipid_s, spidev);
 
458
    uint8_t ret;
 
459
 
 
460
    if (len > 9)
 
461
        hw_error("%s: FIXME: bad SPI word width %i\n", __FUNCTION__, len);
 
462
 
 
463
    if (s->p >= ARRAY_SIZE(s->resp))
 
464
        ret = 0;
 
465
    else
 
466
        ret = s->resp[s->p ++];
 
467
    if (s->pm --> 0)
 
468
        s->param[s->pm] = cmd;
 
469
    else
 
470
        s->cmd = cmd;
 
471
 
 
472
    switch (s->cmd) {
 
473
    case 0x00:  /* NOP */
 
474
        TRACE_MIPID("NOP");
 
475
        break;
 
476
 
 
477
    case 0x01:  /* SWRESET */
 
478
        TRACE_MIPID("SWRESET");
 
479
        mipid_reset(&s->spi.qdev);
 
480
        break;
 
481
 
 
482
    case 0x02:  /* BSTROFF */
 
483
        TRACE_MIPID("BSTROFF");
 
484
        s->booster = 0;
 
485
        break;
 
486
    case 0x03:  /* BSTRON */
 
487
        TRACE_MIPID("BSTRON");
 
488
        s->booster = 1;
 
489
        break;
 
490
 
 
491
    case 0x04:  /* RDDID */
 
492
        s->p = 0;
 
493
        s->resp[0] = (s->id >> 16) & 0xff;
 
494
        s->resp[1] = (s->id >>  8) & 0xff;
 
495
        s->resp[2] = (s->id >>  0) & 0xff;
 
496
        TRACE_MIPID("RDDID 0x%02x 0x%02x 0x%02x",
 
497
                    s->resp[0], s->resp[1], s->resp[2]);
 
498
        break;
 
499
 
 
500
    case 0x06:  /* RD_RED */
 
501
    case 0x07:  /* RD_GREEN */
 
502
        /* XXX the bootloader sometimes issues RD_BLUE meaning RDDID so
 
503
         * for the bootloader one needs to change this.  */
 
504
    case 0x08:  /* RD_BLUE */
 
505
        TRACE_MIPID("RD_RED/GREEN_BLUE 0x01");
 
506
        s->p = 0;
 
507
        /* TODO: return first pixel components */
 
508
        s->resp[0] = 0x01;
 
509
        break;
 
510
 
 
511
    case 0x09:  /* RDDST */
 
512
        s->p = 0;
 
513
        s->resp[0] = s->booster << 7;
 
514
        s->resp[1] = (5 << 4) | (s->partial << 2) |
 
515
                (s->sleep << 1) | s->normal;
 
516
        s->resp[2] = (s->vscr << 7) | (s->invert << 5) |
 
517
                (s->onoff << 2) | (s->te << 1) | (s->gamma >> 2);
 
518
        s->resp[3] = s->gamma << 6;
 
519
        TRACE_MIPID("RDDST 0x%02x 0x%02x 0x%02x 0x%02x",
 
520
                    s->resp[0], s->resp[1], s->resp[2], s->resp[3]);
 
521
        break;
 
522
 
 
523
    case 0x0a:  /* RDDPM */
 
524
        s->p = 0;
 
525
        s->resp[0] = (s->onoff << 2) | (s->normal << 3) | (s->sleep << 4) |
 
526
                (s->partial << 5) | (s->sleep << 6) | (s->booster << 7);
 
527
        TRACE_MIPID("RDDPM 0x%02x", s->resp[0]);
 
528
        break;
 
529
    case 0x0b:  /* RDDMADCTR */
 
530
        s->p = 0;
 
531
        s->resp[0] = 0;
 
532
        TRACE_MIPID("RDDMACTR 0x%02x", s->resp[0]);
 
533
        break;
 
534
    case 0x0c:  /* RDDCOLMOD */
 
535
        s->p = 0;
 
536
        s->resp[0] = 5; /* 65K colours */
 
537
        TRACE_MIPID("RDDCOLMOD 0x%02x", s->resp[0]);
 
538
        break;
 
539
    case 0x0d:  /* RDDIM */
 
540
        s->p = 0;
 
541
        s->resp[0] = (s->invert << 5) | (s->vscr << 7) | s->gamma;
 
542
        TRACE_MIPID("RDDIM 0x%02x", s->resp[0]);
 
543
        break;
 
544
    case 0x0e:  /* RDDSM */
 
545
        s->p = 0;
 
546
        s->resp[0] = s->te << 7;
 
547
        TRACE_MIPID("RDDSM 0x%02x", s->resp[0]);
 
548
        break;
 
549
    case 0x0f:  /* RDDSDR */
 
550
        s->p = 0;
 
551
        s->resp[0] = s->selfcheck;
 
552
        TRACE_MIPID("RDDSDR 0x%02x", s->resp[0]);
 
553
        break;
 
554
 
 
555
    case 0x10:  /* SLPIN */
 
556
        TRACE_MIPID("SLPIN");
 
557
        s->sleep = 1;
 
558
        break;
 
559
    case 0x11:  /* SLPOUT */
 
560
        TRACE_MIPID("SLPOUT");
 
561
        s->sleep = 0;
 
562
        s->selfcheck ^= 1 << 6; /* POFF self-diagnosis Ok */
 
563
        break;
 
564
 
 
565
    case 0x12:  /* PTLON */
 
566
        TRACE_MIPID("PTLON");
 
567
        s->partial = 1;
 
568
        s->normal = 0;
 
569
        s->vscr = 0;
 
570
        break;
 
571
    case 0x13:  /* NORON */
 
572
        TRACE_MIPID("NORON");
 
573
        s->partial = 0;
 
574
        s->normal = 1;
 
575
        s->vscr = 0;
 
576
        break;
 
577
 
 
578
    case 0x20:  /* INVOFF */
 
579
        TRACE_MIPID("INVOFF");
 
580
        s->invert = 0;
 
581
        break;
 
582
    case 0x21:  /* INVON */
 
583
        TRACE_MIPID("INVON");
 
584
        s->invert = 1;
 
585
        break;
 
586
 
 
587
    case 0x22:  /* APOFF */
 
588
    case 0x23:  /* APON */
 
589
        TRACE_MIPID("APON/OFF");
 
590
        goto bad_cmd;
 
591
 
 
592
    case 0x25:  /* WRCNTR */
 
593
        TRACE_MIPID("WRCNTR");
 
594
        if (s->pm < 0)
 
595
            s->pm = 1;
 
596
        goto bad_cmd;
 
597
 
 
598
    case 0x26:  /* GAMSET */
 
599
        if (!s->pm) {
 
600
            s->gamma = ffs(s->param[0] & 0xf) - 1;
 
601
            TRACE_MIPID("GAMSET 0x%02x", s->gamma);
 
602
        } else if (s->pm < 0) {
 
603
            s->pm = 1;
 
604
        }
 
605
        break;
 
606
 
 
607
    case 0x28:  /* DISPOFF */
 
608
        TRACE_MIPID("DISPOFF");
 
609
        s->onoff = 0;
 
610
        break;
 
611
    case 0x29:  /* DISPON */
 
612
        TRACE_MIPID("DISPON");
 
613
        s->onoff = 1;
 
614
        break;
 
615
 
 
616
    case 0x2a:  /* CASET */
 
617
    case 0x2b:  /* RASET */
 
618
    case 0x2c:  /* RAMWR */
 
619
    case 0x2d:  /* RGBSET */
 
620
    case 0x2e:  /* RAMRD */
 
621
    case 0x30:  /* PTLAR */
 
622
    case 0x33:  /* SCRLAR */
 
623
        goto bad_cmd;
 
624
 
 
625
    case 0x34:  /* TEOFF */
 
626
        TRACE_MIPID("TEOFF");
 
627
        s->te = 0;
 
628
        break;
 
629
    case 0x35:  /* TEON */
 
630
        if (!s->pm) {
 
631
            s->te = 1;
 
632
            TRACE_MIPID("TEON 0x%02x", s->param[0] & 0xff);
 
633
        } else if (s->pm < 0) {
 
634
            s->pm = 1;
 
635
        }
 
636
        break;
 
637
 
 
638
    case 0x36:  /* MADCTR */
 
639
        TRACE_MIPID("MADCTR");
 
640
        goto bad_cmd;
 
641
 
 
642
    case 0x37:  /* VSCSAD */
 
643
        TRACE_MIPID("VSCSAD");
 
644
        s->partial = 0;
 
645
        s->normal = 0;
 
646
        s->vscr = 1;
 
647
        break;
 
648
 
 
649
    case 0x38:  /* IDMOFF */
 
650
    case 0x39:  /* IDMON */
 
651
    case 0x3a:  /* COLMOD */
 
652
        goto bad_cmd;
 
653
 
 
654
    case 0xb0:  /* CLKINT / DISCTL */
 
655
    case 0xb1:  /* CLKEXT */
 
656
        if (s->pm < 0)
 
657
            s->pm = 2;
 
658
        break;
 
659
 
 
660
    case 0xb4:  /* FRMSEL */
 
661
        TRACE_MIPID("FRMSEL");
 
662
        break;
 
663
 
 
664
    case 0xb5:  /* FRM8SEL */
 
665
    case 0xb6:  /* TMPRNG / INIESC */
 
666
    case 0xb7:  /* TMPHIS / NOP2 */
 
667
    case 0xb8:  /* TMPREAD / MADCTL */
 
668
    case 0xba:  /* DISTCTR */
 
669
    case 0xbb:  /* EPVOL */
 
670
        goto bad_cmd;
 
671
 
 
672
    case 0xbd:  /* Unknown */
 
673
        s->p = 0;
 
674
        s->resp[0] = 0;
 
675
        s->resp[1] = 1;
 
676
        TRACE_MIPID("??? 0x%02x 0x%02x", s->resp[0], s->resp[1]);
 
677
        break;
 
678
 
 
679
    case 0xc2:  /* IFMOD */
 
680
        if (s->pm < 0)
 
681
            s->pm = 2;
 
682
        break;
 
683
 
 
684
    case 0xc6:  /* PWRCTL */
 
685
    case 0xc7:  /* PPWRCTL */
 
686
    case 0xd0:  /* EPWROUT */
 
687
    case 0xd1:  /* EPWRIN */
 
688
    case 0xd4:  /* RDEV */
 
689
    case 0xd5:  /* RDRR */
 
690
        goto bad_cmd;
 
691
 
 
692
    case 0xda:  /* RDID1 */
 
693
        s->p = 0;
 
694
        s->resp[0] = (s->id >> 16) & 0xff;
 
695
        TRACE_MIPID("RDID1 0x%02x", s->resp[0]);
 
696
        break;
 
697
    case 0xdb:  /* RDID2 */
 
698
        s->p = 0;
 
699
        s->resp[0] = (s->id >>  8) & 0xff;
 
700
        TRACE_MIPID("RDID2 0x%02x", s->resp[0]);
 
701
        break;
 
702
    case 0xdc:  /* RDID3 */
 
703
        s->p = 0;
 
704
        s->resp[0] = (s->id >>  0) & 0xff;
 
705
        TRACE_MIPID("RDID3 0x%02x", s->resp[0]);
 
706
        break;
 
707
 
 
708
    default:
 
709
    bad_cmd:
 
710
        qemu_log_mask(LOG_GUEST_ERROR,
 
711
                      "%s: unknown command %02x\n", __func__, s->cmd);
 
712
        break;
 
713
    }
 
714
 
 
715
    return ret;
 
716
}
 
717
 
 
718
static int mipid_init(SPIDevice *spidev)
 
719
{
 
720
    return 0;
 
721
}
 
722
 
 
723
static Property mipid_properties[] = {
 
724
    DEFINE_PROP_UINT32("id", struct mipid_s, id, 0),
 
725
    DEFINE_PROP_END_OF_LIST()
 
726
};
 
727
 
 
728
static void mipid_class_init(ObjectClass *klass, void *data)
 
729
{
 
730
    DeviceClass *dc = DEVICE_CLASS(klass);
 
731
    SPIDeviceClass *k = SPI_DEVICE_CLASS(klass);
 
732
 
 
733
    k->init = mipid_init;
 
734
    k->txrx = mipid_txrx;
 
735
    dc->reset = mipid_reset;
 
736
    dc->props = mipid_properties;
 
737
}
 
738
 
 
739
static TypeInfo mipid_info = {
 
740
    .name = "lcd_mipid",
 
741
    .parent = TYPE_SPI_DEVICE,
 
742
    .instance_size = sizeof(struct mipid_s),
 
743
    .class_init = mipid_class_init,
 
744
};
 
745
 
 
746
static void n8x0_spi_setup(struct n800_s *s)
 
747
{
 
748
    s->mipid = spi_create_device_noinit(omap_mcspi_bus(s->mpu->mcspi, 0),
 
749
                                        "lcd_mipid", 1);
 
750
    qdev_prop_set_uint32(s->mipid, "id", 0x838f03);
 
751
    qdev_init_nofail(s->mipid);
 
752
}
 
753
 
 
754
/* This task is normally performed by the bootloader.  If we're loading
 
755
 * a kernel directly, we need to enable the Blizzard ourselves.  */
 
756
static void n800_dss_init(struct rfbi_chip_s *chip)
 
757
{
 
758
    uint8_t *fb_blank;
 
759
 
 
760
    chip->write(chip->opaque, 0, 0x2a);         /* LCD Width register */
 
761
    chip->write(chip->opaque, 1, 0x64);
 
762
    chip->write(chip->opaque, 0, 0x2c);         /* LCD HNDP register */
 
763
    chip->write(chip->opaque, 1, 0x1e);
 
764
    chip->write(chip->opaque, 0, 0x2e);         /* LCD Height 0 register */
 
765
    chip->write(chip->opaque, 1, 0xe0);
 
766
    chip->write(chip->opaque, 0, 0x30);         /* LCD Height 1 register */
 
767
    chip->write(chip->opaque, 1, 0x01);
 
768
    chip->write(chip->opaque, 0, 0x32);         /* LCD VNDP register */
 
769
    chip->write(chip->opaque, 1, 0x06);
 
770
    chip->write(chip->opaque, 0, 0x68);         /* Display Mode register */
 
771
    chip->write(chip->opaque, 1, 1);            /* Enable bit */
 
772
 
 
773
    chip->write(chip->opaque, 0, 0x6c); 
 
774
    chip->write(chip->opaque, 1, 0x00);         /* Input X Start Position */
 
775
    chip->write(chip->opaque, 1, 0x00);         /* Input X Start Position */
 
776
    chip->write(chip->opaque, 1, 0x00);         /* Input Y Start Position */
 
777
    chip->write(chip->opaque, 1, 0x00);         /* Input Y Start Position */
 
778
    chip->write(chip->opaque, 1, 0x1f);         /* Input X End Position */
 
779
    chip->write(chip->opaque, 1, 0x03);         /* Input X End Position */
 
780
    chip->write(chip->opaque, 1, 0xdf);         /* Input Y End Position */
 
781
    chip->write(chip->opaque, 1, 0x01);         /* Input Y End Position */
 
782
    chip->write(chip->opaque, 1, 0x00);         /* Output X Start Position */
 
783
    chip->write(chip->opaque, 1, 0x00);         /* Output X Start Position */
 
784
    chip->write(chip->opaque, 1, 0x00);         /* Output Y Start Position */
 
785
    chip->write(chip->opaque, 1, 0x00);         /* Output Y Start Position */
 
786
    chip->write(chip->opaque, 1, 0x1f);         /* Output X End Position */
 
787
    chip->write(chip->opaque, 1, 0x03);         /* Output X End Position */
 
788
    chip->write(chip->opaque, 1, 0xdf);         /* Output Y End Position */
 
789
    chip->write(chip->opaque, 1, 0x01);         /* Output Y End Position */
 
790
    chip->write(chip->opaque, 1, 0x01);         /* Input Data Format */
 
791
    chip->write(chip->opaque, 1, 0x01);         /* Data Source Select */
 
792
 
 
793
    fb_blank = memset(g_malloc(800 * 480 * 2), 0xff, 800 * 480 * 2);
 
794
    /* Display Memory Data Port */
 
795
    chip->block(chip->opaque, 1, fb_blank, 800 * 480 * 2, 800);
 
796
    g_free(fb_blank);
 
797
}
 
798
 
 
799
static void n8x0_dss_setup(struct n800_s *s)
 
800
{
 
801
    s->blizzard.opaque = s1d13745_init(NULL);
 
802
    s->blizzard.block = s1d13745_write_block;
 
803
    s->blizzard.write = s1d13745_write;
 
804
    s->blizzard.read = s1d13745_read;
 
805
 
 
806
    omap_rfbi_attach(s->mpu->dss, 0, &s->blizzard);
 
807
}
 
808
 
 
809
static void n8x0_cbus_setup(struct n800_s *s)
 
810
{
 
811
    qemu_irq dat_out = qdev_get_gpio_in(s->mpu->gpio, N8X0_CBUS_DAT_GPIO);
 
812
    qemu_irq retu_irq = qdev_get_gpio_in(s->mpu->gpio, N8X0_RETU_GPIO);
 
813
    qemu_irq tahvo_irq = qdev_get_gpio_in(s->mpu->gpio, N8X0_TAHVO_GPIO);
 
814
 
 
815
    CBus *cbus = cbus_init(dat_out);
 
816
 
 
817
    qdev_connect_gpio_out(s->mpu->gpio, N8X0_CBUS_CLK_GPIO, cbus->clk);
 
818
    qdev_connect_gpio_out(s->mpu->gpio, N8X0_CBUS_DAT_GPIO, cbus->dat);
 
819
    qdev_connect_gpio_out(s->mpu->gpio, N8X0_CBUS_SEL_GPIO, cbus->sel);
 
820
 
 
821
    cbus_attach(cbus, s->retu = retu_init(retu_irq, 1));
 
822
    cbus_attach(cbus, s->tahvo = tahvo_init(tahvo_irq, 1));
 
823
}
 
824
 
 
825
static void n8x0_uart_setup(struct n800_s *s)
 
826
{
 
827
    CharDriverState *radio = uart_hci_init(
 
828
                    qdev_get_gpio_in(s->mpu->gpio, N8X0_BT_HOST_WKUP_GPIO));
 
829
 
 
830
    qdev_connect_gpio_out(s->mpu->gpio, N8X0_BT_RESET_GPIO,
 
831
                    csrhci_pins_get(radio)[csrhci_pin_reset]);
 
832
    qdev_connect_gpio_out(s->mpu->gpio, N8X0_BT_WKUP_GPIO,
 
833
                    csrhci_pins_get(radio)[csrhci_pin_wakeup]);
 
834
 
 
835
    omap_uart_attach(s->mpu->uart[BT_UART], radio, "bt-uart");
 
836
}
 
837
 
 
838
static void n8x0_usb_setup(struct n800_s *s)
 
839
{
 
840
    SysBusDevice *dev;
 
841
    s->usb = qdev_create(NULL, "tusb6010");
 
842
    dev = SYS_BUS_DEVICE(s->usb);
 
843
    qdev_init_nofail(s->usb);
 
844
    sysbus_connect_irq(dev, 0,
 
845
                       qdev_get_gpio_in(s->mpu->gpio, N8X0_TUSB_INT_GPIO));
 
846
    /* Using the NOR interface */
 
847
    omap_gpmc_attach(s->mpu->gpmc, N8X0_USB_ASYNC_CS,
 
848
                     sysbus_mmio_get_region(dev, 0));
 
849
    omap_gpmc_attach(s->mpu->gpmc, N8X0_USB_SYNC_CS,
 
850
                     sysbus_mmio_get_region(dev, 1));
 
851
    qdev_connect_gpio_out(s->mpu->gpio, N8X0_TUSB_ENABLE_GPIO,
 
852
                          qdev_get_gpio_in(s->usb, 0)); /* tusb_pwr */
 
853
}
 
854
 
 
855
/* Setup done before the main bootloader starts by some early setup code
 
856
 * - used when we want to run the main bootloader in emulation.  This
 
857
 * isn't documented.  */
 
858
static uint32_t n800_pinout[104] = {
 
859
    0x080f00d8, 0x00d40808, 0x03080808, 0x080800d0,
 
860
    0x00dc0808, 0x0b0f0f00, 0x080800b4, 0x00c00808,
 
861
    0x08080808, 0x180800c4, 0x00b80000, 0x08080808,
 
862
    0x080800bc, 0x00cc0808, 0x08081818, 0x18180128,
 
863
    0x01241800, 0x18181818, 0x000000f0, 0x01300000,
 
864
    0x00001b0b, 0x1b0f0138, 0x00e0181b, 0x1b031b0b,
 
865
    0x180f0078, 0x00740018, 0x0f0f0f1a, 0x00000080,
 
866
    0x007c0000, 0x00000000, 0x00000088, 0x00840000,
 
867
    0x00000000, 0x00000094, 0x00980300, 0x0f180003,
 
868
    0x0000008c, 0x00900f0f, 0x0f0f1b00, 0x0f00009c,
 
869
    0x01140000, 0x1b1b0f18, 0x0818013c, 0x01400008,
 
870
    0x00001818, 0x000b0110, 0x010c1800, 0x0b030b0f,
 
871
    0x181800f4, 0x00f81818, 0x00000018, 0x000000fc,
 
872
    0x00401808, 0x00000000, 0x0f1b0030, 0x003c0008,
 
873
    0x00000000, 0x00000038, 0x00340000, 0x00000000,
 
874
    0x1a080070, 0x00641a1a, 0x08080808, 0x08080060,
 
875
    0x005c0808, 0x08080808, 0x08080058, 0x00540808,
 
876
    0x08080808, 0x0808006c, 0x00680808, 0x08080808,
 
877
    0x000000a8, 0x00b00000, 0x08080808, 0x000000a0,
 
878
    0x00a40000, 0x00000000, 0x08ff0050, 0x004c0808,
 
879
    0xffffffff, 0xffff0048, 0x0044ffff, 0xffffffff,
 
880
    0x000000ac, 0x01040800, 0x08080b0f, 0x18180100,
 
881
    0x01081818, 0x0b0b1808, 0x1a0300e4, 0x012c0b1a,
 
882
    0x02020018, 0x0b000134, 0x011c0800, 0x0b1b1b00,
 
883
    0x0f0000c8, 0x00ec181b, 0x000f0f02, 0x00180118,
 
884
    0x01200000, 0x0f0b1b1b, 0x0f0200e8, 0x0000020b,
 
885
};
 
886
 
 
887
static void n800_setup_nolo_tags(void *sram_base)
 
888
{
 
889
    int i;
 
890
    uint32_t *p = sram_base + 0x8000;
 
891
    uint32_t *v = sram_base + 0xa000;
 
892
 
 
893
    memset(p, 0, 0x3000);
 
894
 
 
895
    strcpy((void *) (p + 0), "QEMU N800");
 
896
 
 
897
    strcpy((void *) (p + 8), "F5");
 
898
 
 
899
    stl_raw(p + 10, 0x04f70000);
 
900
    strcpy((void *) (p + 9), "RX-34");
 
901
 
 
902
    /* RAM size in MB? */
 
903
    stl_raw(p + 12, 0x80);
 
904
 
 
905
    /* Pointer to the list of tags */
 
906
    stl_raw(p + 13, OMAP2_SRAM_BASE + 0x9000);
 
907
 
 
908
    /* The NOLO tags start here */
 
909
    p = sram_base + 0x9000;
 
910
#define ADD_TAG(tag, len)                               \
 
911
    stw_raw((uint16_t *) p + 0, tag);                   \
 
912
    stw_raw((uint16_t *) p + 1, len); p ++;             \
 
913
    stl_raw(p ++, OMAP2_SRAM_BASE | (((void *) v - sram_base) & 0xffff));
 
914
 
 
915
    /* OMAP STI console? Pin out settings? */
 
916
    ADD_TAG(0x6e01, 414);
 
917
    for (i = 0; i < ARRAY_SIZE(n800_pinout); i ++)
 
918
        stl_raw(v ++, n800_pinout[i]);
 
919
 
 
920
    /* Kernel memsize? */
 
921
    ADD_TAG(0x6e05, 1);
 
922
    stl_raw(v ++, 2);
 
923
 
 
924
    /* NOLO serial console */
 
925
    ADD_TAG(0x6e02, 4);
 
926
    stl_raw(v ++, XLDR_LL_UART);        /* UART number (1 - 3) */
 
927
 
 
928
#if 0
 
929
    /* CBUS settings (Retu/AVilma) */
 
930
    ADD_TAG(0x6e03, 6);
 
931
    stw_raw((uint16_t *) v + 0, 65);    /* CBUS GPIO0 */
 
932
    stw_raw((uint16_t *) v + 1, 66);    /* CBUS GPIO1 */
 
933
    stw_raw((uint16_t *) v + 2, 64);    /* CBUS GPIO2 */
 
934
    v += 2;
 
935
#endif
 
936
 
 
937
    /* Nokia ASIC BB5 (Retu/Tahvo) */
 
938
    ADD_TAG(0x6e0a, 4);
 
939
    stw_raw((uint16_t *) v + 0, 111);   /* "Retu" interrupt GPIO */
 
940
    stw_raw((uint16_t *) v + 1, 108);   /* "Tahvo" interrupt GPIO */
 
941
    v ++;
 
942
 
 
943
    /* LCD console? */
 
944
    ADD_TAG(0x6e04, 4);
 
945
    stw_raw((uint16_t *) v + 0, 30);    /* ??? */
 
946
    stw_raw((uint16_t *) v + 1, 24);    /* ??? */
 
947
    v ++;
 
948
 
 
949
#if 0
 
950
    /* LCD settings */
 
951
    ADD_TAG(0x6e06, 2);
 
952
    stw_raw((uint16_t *) (v ++), 15);   /* ??? */
 
953
#endif
 
954
 
 
955
    /* I^2C (Menelaus) */
 
956
    ADD_TAG(0x6e07, 4);
 
957
    stl_raw(v ++, 0x00720000);          /* ??? */
 
958
 
 
959
    /* Unknown */
 
960
    ADD_TAG(0x6e0b, 6);
 
961
    stw_raw((uint16_t *) v + 0, 94);    /* ??? */
 
962
    stw_raw((uint16_t *) v + 1, 23);    /* ??? */
 
963
    stw_raw((uint16_t *) v + 2, 0);     /* ??? */
 
964
    v += 2;
 
965
 
 
966
    /* OMAP gpio switch info */
 
967
    ADD_TAG(0x6e0c, 80);
 
968
    strcpy((void *) v, "bat_cover");    v += 3;
 
969
    stw_raw((uint16_t *) v + 0, 110);   /* GPIO num ??? */
 
970
    stw_raw((uint16_t *) v + 1, 1);     /* GPIO num ??? */
 
971
    v += 2;
 
972
    strcpy((void *) v, "cam_act");      v += 3;
 
973
    stw_raw((uint16_t *) v + 0, 95);    /* GPIO num ??? */
 
974
    stw_raw((uint16_t *) v + 1, 32);    /* GPIO num ??? */
 
975
    v += 2;
 
976
    strcpy((void *) v, "cam_turn");     v += 3;
 
977
    stw_raw((uint16_t *) v + 0, 12);    /* GPIO num ??? */
 
978
    stw_raw((uint16_t *) v + 1, 33);    /* GPIO num ??? */
 
979
    v += 2;
 
980
    strcpy((void *) v, "headphone");    v += 3;
 
981
    stw_raw((uint16_t *) v + 0, 107);   /* GPIO num ??? */
 
982
    stw_raw((uint16_t *) v + 1, 17);    /* GPIO num ??? */
 
983
    v += 2;
 
984
 
 
985
    /* Bluetooth */
 
986
    ADD_TAG(0x6e0e, 12);
 
987
    stl_raw(v ++, 0x5c623d01);          /* ??? */
 
988
    stl_raw(v ++, 0x00000201);          /* ??? */
 
989
    stl_raw(v ++, 0x00000000);          /* ??? */
 
990
 
 
991
    /* CX3110x WLAN settings */
 
992
    ADD_TAG(0x6e0f, 8);
 
993
    stl_raw(v ++, 0x00610025);          /* ??? */
 
994
    stl_raw(v ++, 0xffff0057);          /* ??? */
 
995
 
 
996
    /* MMC host settings */
 
997
    ADD_TAG(0x6e10, 12);
 
998
    stl_raw(v ++, 0xffff000f);          /* ??? */
 
999
    stl_raw(v ++, 0xffffffff);          /* ??? */
 
1000
    stl_raw(v ++, 0x00000060);          /* ??? */
 
1001
 
 
1002
    /* OneNAND chip select */
 
1003
    ADD_TAG(0x6e11, 10);
 
1004
    stl_raw(v ++, 0x00000401);          /* ??? */
 
1005
    stl_raw(v ++, 0x0002003a);          /* ??? */
 
1006
    stl_raw(v ++, 0x00000002);          /* ??? */
 
1007
 
 
1008
    /* TEA5761 sensor settings */
 
1009
    ADD_TAG(0x6e12, 2);
 
1010
    stl_raw(v ++, 93);                  /* GPIO num ??? */
 
1011
 
 
1012
#if 0
 
1013
    /* Unknown tag */
 
1014
    ADD_TAG(6e09, 0);
 
1015
 
 
1016
    /* Kernel UART / console */
 
1017
    ADD_TAG(6e12, 0);
 
1018
#endif
 
1019
 
 
1020
    /* End of the list */
 
1021
    stl_raw(p ++, 0x00000000);
 
1022
    stl_raw(p ++, 0x00000000);
 
1023
}
 
1024
 
 
1025
/* This task is normally performed by the bootloader.  If we're loading
 
1026
 * a kernel directly, we need to set up GPMC mappings ourselves.  */
 
1027
static void n800_gpmc_init(struct n800_s *s)
 
1028
{
 
1029
    uint32_t config7 =
 
1030
            (0xf << 8) |        /* MASKADDRESS */
 
1031
            (1 << 6) |          /* CSVALID */
 
1032
            (4 << 0);           /* BASEADDRESS */
 
1033
 
 
1034
    cpu_physical_memory_write(0x6800a078,               /* GPMC_CONFIG7_0 */
 
1035
                              &config7, sizeof(config7));
 
1036
}
 
1037
 
 
1038
/* Setup sequence done by the bootloader */
 
1039
static void n8x0_boot_init(void *opaque)
 
1040
{
 
1041
    struct n800_s *s = (struct n800_s *) opaque;
 
1042
    uint32_t buf;
 
1043
 
 
1044
    /* PRCM setup */
 
1045
#define omap_writel(addr, val)  \
 
1046
    buf = (val);                        \
 
1047
    cpu_physical_memory_write(addr, &buf, sizeof(buf))
 
1048
 
 
1049
    omap_writel(0x48008060, 0x41);              /* PRCM_CLKSRC_CTRL */
 
1050
    omap_writel(0x48008070, 1);                 /* PRCM_CLKOUT_CTRL */
 
1051
    omap_writel(0x48008078, 0);                 /* PRCM_CLKEMUL_CTRL */
 
1052
    omap_writel(0x48008090, 0);                 /* PRCM_VOLTSETUP */
 
1053
    omap_writel(0x48008094, 0);                 /* PRCM_CLKSSETUP */
 
1054
    omap_writel(0x48008098, 0);                 /* PRCM_POLCTRL */
 
1055
    omap_writel(0x48008140, 2);                 /* CM_CLKSEL_MPU */
 
1056
    omap_writel(0x48008148, 0);                 /* CM_CLKSTCTRL_MPU */
 
1057
    omap_writel(0x48008158, 1);                 /* RM_RSTST_MPU */
 
1058
    omap_writel(0x480081c8, 0x15);              /* PM_WKDEP_MPU */
 
1059
    omap_writel(0x480081d4, 0x1d4);             /* PM_EVGENCTRL_MPU */
 
1060
    omap_writel(0x480081d8, 0);                 /* PM_EVEGENONTIM_MPU */
 
1061
    omap_writel(0x480081dc, 0);                 /* PM_EVEGENOFFTIM_MPU */
 
1062
    omap_writel(0x480081e0, 0xc);               /* PM_PWSTCTRL_MPU */
 
1063
    omap_writel(0x48008200, 0x047e7ff7);        /* CM_FCLKEN1_CORE */
 
1064
    omap_writel(0x48008204, 0x00000004);        /* CM_FCLKEN2_CORE */
 
1065
    omap_writel(0x48008210, 0x047e7ff1);        /* CM_ICLKEN1_CORE */
 
1066
    omap_writel(0x48008214, 0x00000004);        /* CM_ICLKEN2_CORE */
 
1067
    omap_writel(0x4800821c, 0x00000000);        /* CM_ICLKEN4_CORE */
 
1068
    omap_writel(0x48008230, 0);                 /* CM_AUTOIDLE1_CORE */
 
1069
    omap_writel(0x48008234, 0);                 /* CM_AUTOIDLE2_CORE */
 
1070
    omap_writel(0x48008238, 7);                 /* CM_AUTOIDLE3_CORE */
 
1071
    omap_writel(0x4800823c, 0);                 /* CM_AUTOIDLE4_CORE */
 
1072
    omap_writel(0x48008240, 0x04360626);        /* CM_CLKSEL1_CORE */
 
1073
    omap_writel(0x48008244, 0x00000014);        /* CM_CLKSEL2_CORE */
 
1074
    omap_writel(0x48008248, 0);                 /* CM_CLKSTCTRL_CORE */
 
1075
    omap_writel(0x48008300, 0x00000000);        /* CM_FCLKEN_GFX */
 
1076
    omap_writel(0x48008310, 0x00000000);        /* CM_ICLKEN_GFX */
 
1077
    omap_writel(0x48008340, 0x00000001);        /* CM_CLKSEL_GFX */
 
1078
    omap_writel(0x48008400, 0x00000004);        /* CM_FCLKEN_WKUP */
 
1079
    omap_writel(0x48008410, 0x00000004);        /* CM_ICLKEN_WKUP */
 
1080
    omap_writel(0x48008440, 0x00000000);        /* CM_CLKSEL_WKUP */
 
1081
    omap_writel(0x48008500, 0x000000cf);        /* CM_CLKEN_PLL */
 
1082
    omap_writel(0x48008530, 0x0000000c);        /* CM_AUTOIDLE_PLL */
 
1083
    omap_writel(0x48008540,                     /* CM_CLKSEL1_PLL */
 
1084
                    (0x78 << 12) | (6 << 8));
 
1085
    omap_writel(0x48008544, 2);                 /* CM_CLKSEL2_PLL */
 
1086
 
 
1087
    /* GPMC setup */
 
1088
    n800_gpmc_init(s);
 
1089
 
 
1090
    /* Video setup */
 
1091
    n800_dss_init(&s->blizzard);
 
1092
 
 
1093
    /* CPU setup */
 
1094
    s->mpu->cpu->env.GE = 0x5;
 
1095
 
 
1096
    /* If the machine has a slided keyboard, open it */
 
1097
    if (s->kbd)
 
1098
        qemu_irq_raise(qdev_get_gpio_in(s->mpu->gpio, N810_SLIDE_GPIO));
 
1099
}
 
1100
 
 
1101
#define OMAP_TAG_NOKIA_BT       0x4e01
 
1102
#define OMAP_TAG_WLAN_CX3110X   0x4e02
 
1103
#define OMAP_TAG_CBUS           0x4e03
 
1104
#define OMAP_TAG_EM_ASIC_BB5    0x4e04
 
1105
 
 
1106
static struct omap_gpiosw_info_s {
 
1107
    const char *name;
 
1108
    int line;
 
1109
    int type;
 
1110
} n800_gpiosw_info[] = {
 
1111
    {
 
1112
        "bat_cover", N800_BAT_COVER_GPIO,
 
1113
        OMAP_GPIOSW_TYPE_COVER | OMAP_GPIOSW_INVERTED,
 
1114
    }, {
 
1115
        "cam_act", N800_CAM_ACT_GPIO,
 
1116
        OMAP_GPIOSW_TYPE_ACTIVITY,
 
1117
    }, {
 
1118
        "cam_turn", N800_CAM_TURN_GPIO,
 
1119
        OMAP_GPIOSW_TYPE_ACTIVITY | OMAP_GPIOSW_INVERTED,
 
1120
    }, {
 
1121
        "headphone", N8X0_HEADPHONE_GPIO,
 
1122
        OMAP_GPIOSW_TYPE_CONNECTION | OMAP_GPIOSW_INVERTED,
 
1123
    },
 
1124
    { NULL }
 
1125
}, n810_gpiosw_info[] = {
 
1126
    {
 
1127
        "gps_reset", N810_GPS_RESET_GPIO,
 
1128
        OMAP_GPIOSW_TYPE_ACTIVITY | OMAP_GPIOSW_OUTPUT,
 
1129
    }, {
 
1130
        "gps_wakeup", N810_GPS_WAKEUP_GPIO,
 
1131
        OMAP_GPIOSW_TYPE_ACTIVITY | OMAP_GPIOSW_OUTPUT,
 
1132
    }, {
 
1133
        "headphone", N8X0_HEADPHONE_GPIO,
 
1134
        OMAP_GPIOSW_TYPE_CONNECTION | OMAP_GPIOSW_INVERTED,
 
1135
    }, {
 
1136
        "kb_lock", N810_KB_LOCK_GPIO,
 
1137
        OMAP_GPIOSW_TYPE_COVER | OMAP_GPIOSW_INVERTED,
 
1138
    }, {
 
1139
        "sleepx_led", N810_SLEEPX_LED_GPIO,
 
1140
        OMAP_GPIOSW_TYPE_ACTIVITY | OMAP_GPIOSW_INVERTED | OMAP_GPIOSW_OUTPUT,
 
1141
    }, {
 
1142
        "slide", N810_SLIDE_GPIO,
 
1143
        OMAP_GPIOSW_TYPE_COVER | OMAP_GPIOSW_INVERTED,
 
1144
    },
 
1145
    { NULL }
 
1146
};
 
1147
 
 
1148
static struct omap_partition_info_s {
 
1149
    uint32_t offset;
 
1150
    uint32_t size;
 
1151
    int mask;
 
1152
    const char *name;
 
1153
} n800_part_info[] = {
 
1154
    { 0x00000000, 0x00020000, 0x3, "bootloader" },
 
1155
    { 0x00020000, 0x00060000, 0x0, "config" },
 
1156
    { 0x00080000, 0x00200000, 0x0, "kernel" },
 
1157
    { 0x00280000, 0x00200000, 0x3, "initfs" },
 
1158
    { 0x00480000, 0x0fb80000, 0x3, "rootfs" },
 
1159
 
 
1160
    { 0, 0, 0, NULL }
 
1161
}, n810_part_info[] = {
 
1162
    { 0x00000000, 0x00020000, 0x3, "bootloader" },
 
1163
    { 0x00020000, 0x00060000, 0x0, "config" },
 
1164
    { 0x00080000, 0x00220000, 0x0, "kernel" },
 
1165
    { 0x002a0000, 0x00400000, 0x0, "initfs" },
 
1166
    { 0x006a0000, 0x0f960000, 0x0, "rootfs" },
 
1167
 
 
1168
    { 0, 0, 0, NULL }
 
1169
};
 
1170
 
 
1171
static bdaddr_t n8x0_bd_addr = {{ N8X0_BD_ADDR }};
 
1172
 
 
1173
static int n8x0_atag_setup(void *p, int model)
 
1174
{
 
1175
    uint8_t *b;
 
1176
    uint16_t *w;
 
1177
    uint32_t *l;
 
1178
    struct omap_gpiosw_info_s *gpiosw;
 
1179
    struct omap_partition_info_s *partition;
 
1180
    const char *tag;
 
1181
 
 
1182
    w = p;
 
1183
 
 
1184
    stw_raw(w ++, OMAP_TAG_UART);               /* u16 tag */
 
1185
    stw_raw(w ++, 4);                           /* u16 len */
 
1186
    stw_raw(w ++, (1 << 2) | (1 << 1) | (1 << 0)); /* uint enabled_uarts */
 
1187
    w ++;
 
1188
 
 
1189
#if 0
 
1190
    stw_raw(w ++, OMAP_TAG_SERIAL_CONSOLE);     /* u16 tag */
 
1191
    stw_raw(w ++, 4);                           /* u16 len */
 
1192
    stw_raw(w ++, XLDR_LL_UART + 1);            /* u8 console_uart */
 
1193
    stw_raw(w ++, 115200);                      /* u32 console_speed */
 
1194
#endif
 
1195
 
 
1196
    stw_raw(w ++, OMAP_TAG_LCD);                /* u16 tag */
 
1197
    stw_raw(w ++, 36);                          /* u16 len */
 
1198
    strcpy((void *) w, "QEMU LCD panel");       /* char panel_name[16] */
 
1199
    w += 8;
 
1200
    strcpy((void *) w, "blizzard");             /* char ctrl_name[16] */
 
1201
    w += 8;
 
1202
    stw_raw(w ++, N810_BLIZZARD_RESET_GPIO);    /* TODO: n800 s16 nreset_gpio */
 
1203
    stw_raw(w ++, 24);                          /* u8 data_lines */
 
1204
 
 
1205
    stw_raw(w ++, OMAP_TAG_CBUS);               /* u16 tag */
 
1206
    stw_raw(w ++, 8);                           /* u16 len */
 
1207
    stw_raw(w ++, N8X0_CBUS_CLK_GPIO);          /* s16 clk_gpio */
 
1208
    stw_raw(w ++, N8X0_CBUS_DAT_GPIO);          /* s16 dat_gpio */
 
1209
    stw_raw(w ++, N8X0_CBUS_SEL_GPIO);          /* s16 sel_gpio */
 
1210
    w ++;
 
1211
 
 
1212
    stw_raw(w ++, OMAP_TAG_EM_ASIC_BB5);        /* u16 tag */
 
1213
    stw_raw(w ++, 4);                           /* u16 len */
 
1214
    stw_raw(w ++, N8X0_RETU_GPIO);              /* s16 retu_irq_gpio */
 
1215
    stw_raw(w ++, N8X0_TAHVO_GPIO);             /* s16 tahvo_irq_gpio */
 
1216
 
 
1217
    gpiosw = (model == 810) ? n810_gpiosw_info : n800_gpiosw_info;
 
1218
    for (; gpiosw->name; gpiosw ++) {
 
1219
        stw_raw(w ++, OMAP_TAG_GPIO_SWITCH);    /* u16 tag */
 
1220
        stw_raw(w ++, 20);                      /* u16 len */
 
1221
        strcpy((void *) w, gpiosw->name);       /* char name[12] */
 
1222
        w += 6;
 
1223
        stw_raw(w ++, gpiosw->line);            /* u16 gpio */
 
1224
        stw_raw(w ++, gpiosw->type);
 
1225
        stw_raw(w ++, 0);
 
1226
        stw_raw(w ++, 0);
 
1227
    }
 
1228
 
 
1229
    stw_raw(w ++, OMAP_TAG_NOKIA_BT);           /* u16 tag */
 
1230
    stw_raw(w ++, 12);                          /* u16 len */
 
1231
    b = (void *) w;
 
1232
    stb_raw(b ++, 0x01);                        /* u8 chip_type (CSR) */
 
1233
    stb_raw(b ++, N8X0_BT_WKUP_GPIO);           /* u8 bt_wakeup_gpio */
 
1234
    stb_raw(b ++, N8X0_BT_HOST_WKUP_GPIO);      /* u8 host_wakeup_gpio */
 
1235
    stb_raw(b ++, N8X0_BT_RESET_GPIO);          /* u8 reset_gpio */
 
1236
    stb_raw(b ++, BT_UART + 1);                 /* u8 bt_uart */
 
1237
    memcpy(b, &n8x0_bd_addr, 6);                /* u8 bd_addr[6] */
 
1238
    b += 6;
 
1239
    stb_raw(b ++, 0x02);                        /* u8 bt_sysclk (38.4) */
 
1240
    w = (void *) b;
 
1241
 
 
1242
    stw_raw(w ++, OMAP_TAG_WLAN_CX3110X);       /* u16 tag */
 
1243
    stw_raw(w ++, 8);                           /* u16 len */
 
1244
    stw_raw(w ++, 0x25);                        /* u8 chip_type */
 
1245
    stw_raw(w ++, N8X0_WLAN_PWR_GPIO);          /* s16 power_gpio */
 
1246
    stw_raw(w ++, N8X0_WLAN_IRQ_GPIO);          /* s16 irq_gpio */
 
1247
    stw_raw(w ++, -1);                          /* s16 spi_cs_gpio */
 
1248
 
 
1249
    stw_raw(w ++, OMAP_TAG_MMC);                /* u16 tag */
 
1250
    stw_raw(w ++, 16);                          /* u16 len */
 
1251
    if (model == 810) {
 
1252
        stw_raw(w ++, 0x23f);                   /* unsigned flags */
 
1253
        stw_raw(w ++, -1);                      /* s16 power_pin */
 
1254
        stw_raw(w ++, -1);                      /* s16 switch_pin */
 
1255
        stw_raw(w ++, -1);                      /* s16 wp_pin */
 
1256
        stw_raw(w ++, 0x240);                   /* unsigned flags */
 
1257
        stw_raw(w ++, 0xc000);                  /* s16 power_pin */
 
1258
        stw_raw(w ++, 0x0248);                  /* s16 switch_pin */
 
1259
        stw_raw(w ++, 0xc000);                  /* s16 wp_pin */
 
1260
    } else {
 
1261
        stw_raw(w ++, 0xf);                     /* unsigned flags */
 
1262
        stw_raw(w ++, -1);                      /* s16 power_pin */
 
1263
        stw_raw(w ++, -1);                      /* s16 switch_pin */
 
1264
        stw_raw(w ++, -1);                      /* s16 wp_pin */
 
1265
        stw_raw(w ++, 0);                       /* unsigned flags */
 
1266
        stw_raw(w ++, 0);                       /* s16 power_pin */
 
1267
        stw_raw(w ++, 0);                       /* s16 switch_pin */
 
1268
        stw_raw(w ++, 0);                       /* s16 wp_pin */
 
1269
    }
 
1270
 
 
1271
    stw_raw(w ++, OMAP_TAG_TEA5761);            /* u16 tag */
 
1272
    stw_raw(w ++, 4);                           /* u16 len */
 
1273
    stw_raw(w ++, N8X0_TEA5761_CS_GPIO);        /* u16 enable_gpio */
 
1274
    w ++;
 
1275
 
 
1276
    partition = (model == 810) ? n810_part_info : n800_part_info;
 
1277
    for (; partition->name; partition ++) {
 
1278
        stw_raw(w ++, OMAP_TAG_PARTITION);      /* u16 tag */
 
1279
        stw_raw(w ++, 28);                      /* u16 len */
 
1280
        strcpy((void *) w, partition->name);    /* char name[16] */
 
1281
        l = (void *) (w + 8);
 
1282
        stl_raw(l ++, partition->size);         /* unsigned int size */
 
1283
        stl_raw(l ++, partition->offset);       /* unsigned int offset */
 
1284
        stl_raw(l ++, partition->mask);         /* unsigned int mask_flags */
 
1285
        w = (void *) l;
 
1286
    }
 
1287
 
 
1288
    stw_raw(w ++, OMAP_TAG_BOOT_REASON);        /* u16 tag */
 
1289
    stw_raw(w ++, 12);                          /* u16 len */
 
1290
#if 0
 
1291
    strcpy((void *) w, "por");                  /* char reason_str[12] */
 
1292
    strcpy((void *) w, "charger");              /* char reason_str[12] */
 
1293
    strcpy((void *) w, "32wd_to");              /* char reason_str[12] */
 
1294
    strcpy((void *) w, "sw_rst");               /* char reason_str[12] */
 
1295
    strcpy((void *) w, "mbus");                 /* char reason_str[12] */
 
1296
    strcpy((void *) w, "unknown");              /* char reason_str[12] */
 
1297
    strcpy((void *) w, "swdg_to");              /* char reason_str[12] */
 
1298
    strcpy((void *) w, "sec_vio");              /* char reason_str[12] */
 
1299
    strcpy((void *) w, "pwr_key");              /* char reason_str[12] */
 
1300
    strcpy((void *) w, "rtc_alarm");            /* char reason_str[12] */
 
1301
#else
 
1302
    strcpy((void *) w, "pwr_key");              /* char reason_str[12] */
 
1303
#endif
 
1304
    w += 6;
 
1305
 
 
1306
    tag = (model == 810) ? "RX-44" : "RX-34";
 
1307
    stw_raw(w ++, OMAP_TAG_VERSION_STR);        /* u16 tag */
 
1308
    stw_raw(w ++, 24);                          /* u16 len */
 
1309
    strcpy((void *) w, "product");              /* char component[12] */
 
1310
    w += 6;
 
1311
    strcpy((void *) w, tag);                    /* char version[12] */
 
1312
    w += 6;
 
1313
 
 
1314
    stw_raw(w ++, OMAP_TAG_VERSION_STR);        /* u16 tag */
 
1315
    stw_raw(w ++, 24);                          /* u16 len */
 
1316
    strcpy((void *) w, "hw-build");             /* char component[12] */
 
1317
    w += 6;
 
1318
    strcpy((void *) w, "QEMU ");
 
1319
    pstrcat((void *) w, 12, qemu_get_version()); /* char version[12] */
 
1320
    w += 6;
 
1321
 
 
1322
    tag = (model == 810) ? "1.1.10-qemu" : "1.1.6-qemu";
 
1323
    stw_raw(w ++, OMAP_TAG_VERSION_STR);        /* u16 tag */
 
1324
    stw_raw(w ++, 24);                          /* u16 len */
 
1325
    strcpy((void *) w, "nolo");                 /* char component[12] */
 
1326
    w += 6;
 
1327
    strcpy((void *) w, tag);                    /* char version[12] */
 
1328
    w += 6;
 
1329
 
 
1330
    return (void *) w - p;
 
1331
}
 
1332
 
 
1333
static int n800_atag_setup(const struct arm_boot_info *info, void *p)
 
1334
{
 
1335
    return n8x0_atag_setup(p, 800);
 
1336
}
 
1337
 
 
1338
static int n810_atag_setup(const struct arm_boot_info *info, void *p)
 
1339
{
 
1340
    return n8x0_atag_setup(p, 810);
 
1341
}
 
1342
 
 
1343
static void n8x0_init(QEMUMachineInitArgs *args,
 
1344
                      struct arm_boot_info *binfo, int model)
 
1345
{
 
1346
    MemoryRegion *sysmem = get_system_memory();
 
1347
    struct n800_s *s = (struct n800_s *) g_malloc0(sizeof(*s));
 
1348
    int sdram_size = binfo->ram_size;
 
1349
 
 
1350
    s->mpu = omap2420_mpu_init(sysmem, sdram_size, args->cpu_model);
 
1351
 
 
1352
    /* Setup peripherals
 
1353
     *
 
1354
     * Believed external peripherals layout in the N810:
 
1355
     * (spi bus 1)
 
1356
     *   tsc2005
 
1357
     *   lcd_mipid
 
1358
     * (spi bus 2)
 
1359
     *   Conexant cx3110x (WLAN)
 
1360
     *   optional: pc2400m (WiMAX)
 
1361
     * (i2c bus 0)
 
1362
     *   TLV320AIC33 (audio codec)
 
1363
     *   TCM825x (camera by Toshiba)
 
1364
     *   lp5521 (clever LEDs)
 
1365
     *   tsl2563 (light sensor, hwmon, model 7, rev. 0)
 
1366
     *   lm8323 (keypad, manf 00, rev 04)
 
1367
     * (i2c bus 1)
 
1368
     *   tmp105 (temperature sensor, hwmon)
 
1369
     *   menelaus (pm)
 
1370
     * (somewhere on i2c - maybe N800-only)
 
1371
     *   tea5761 (FM tuner)
 
1372
     * (serial 0)
 
1373
     *   GPS
 
1374
     * (some serial port)
 
1375
     *   csr41814 (Bluetooth)
 
1376
     */
 
1377
    n8x0_gpio_setup(s);
 
1378
    n8x0_nand_setup(s);
 
1379
    n8x0_i2c_setup(s);
 
1380
    if (model == 800)
 
1381
        n800_tsc_kbd_setup(s);
 
1382
    else if (model == 810) {
 
1383
        n810_tsc_setup(s);
 
1384
        n810_kbd_setup(s);
 
1385
    }
 
1386
    n8x0_spi_setup(s);
 
1387
    n8x0_dss_setup(s);
 
1388
    n8x0_cbus_setup(s);
 
1389
    n8x0_uart_setup(s);
 
1390
    if (usb_enabled(false)) {
 
1391
        n8x0_usb_setup(s);
 
1392
    }
 
1393
 
 
1394
    if (args->kernel_filename) {
 
1395
        /* Or at the linux loader.  */
 
1396
        binfo->kernel_filename = args->kernel_filename;
 
1397
        binfo->kernel_cmdline = args->kernel_cmdline;
 
1398
        binfo->initrd_filename = args->initrd_filename;
 
1399
        arm_load_kernel(s->mpu->cpu, binfo);
 
1400
 
 
1401
        qemu_register_reset(n8x0_boot_init, s);
 
1402
    }
 
1403
 
 
1404
    if (option_rom[0].name &&
 
1405
        (args->boot_order[0] == 'n' || !args->kernel_filename)) {
 
1406
        uint8_t nolo_tags[0x10000];
 
1407
        /* No, wait, better start at the ROM.  */
 
1408
        s->mpu->cpu->env.regs[15] = OMAP2_Q2_BASE + 0x400000;
 
1409
 
 
1410
        /* This is intended for loading the `secondary.bin' program from
 
1411
         * Nokia images (the NOLO bootloader).  The entry point seems
 
1412
         * to be at OMAP2_Q2_BASE + 0x400000.
 
1413
         *
 
1414
         * The `2nd.bin' files contain some kind of earlier boot code and
 
1415
         * for them the entry point needs to be set to OMAP2_SRAM_BASE.
 
1416
         *
 
1417
         * The code above is for loading the `zImage' file from Nokia
 
1418
         * images.  */
 
1419
        load_image_targphys(option_rom[0].name,
 
1420
                            OMAP2_Q2_BASE + 0x400000,
 
1421
                            sdram_size - 0x400000);
 
1422
 
 
1423
        n800_setup_nolo_tags(nolo_tags);
 
1424
        cpu_physical_memory_write(OMAP2_SRAM_BASE, nolo_tags, 0x10000);
 
1425
    }
 
1426
}
 
1427
 
 
1428
static struct arm_boot_info n800_binfo = {
 
1429
    .loader_start = OMAP2_Q2_BASE,
 
1430
    /* Actually two chips of 0x4000000 bytes each */
 
1431
    .ram_size = 0x08000000,
 
1432
    .board_id = 0x4f7,
 
1433
    .atag_board = n800_atag_setup,
 
1434
};
 
1435
 
 
1436
static struct arm_boot_info n810_binfo = {
 
1437
    .loader_start = OMAP2_Q2_BASE,
 
1438
    /* Actually two chips of 0x4000000 bytes each */
 
1439
    .ram_size = 0x08000000,
 
1440
    /* 0x60c and 0x6bf (WiMAX Edition) have been assigned but are not
 
1441
     * used by some older versions of the bootloader and 5555 is used
 
1442
     * instead (including versions that shipped with many devices).  */
 
1443
    .board_id = 0x60c,
 
1444
    .atag_board = n810_atag_setup,
 
1445
};
 
1446
 
 
1447
static void n800_init(QEMUMachineInitArgs *args)
 
1448
{
 
1449
    return n8x0_init(args, &n800_binfo, 800);
 
1450
}
 
1451
 
 
1452
static void n810_init(QEMUMachineInitArgs *args)
 
1453
{
 
1454
    return n8x0_init(args, &n810_binfo, 810);
 
1455
}
 
1456
 
 
1457
static QEMUMachine n800_machine = {
 
1458
    .name = "n800",
 
1459
    .desc = "Nokia N800 tablet aka. RX-34 (OMAP2420)",
 
1460
    .init = n800_init,
 
1461
    .default_boot_order = "",
 
1462
};
 
1463
 
 
1464
static QEMUMachine n810_machine = {
 
1465
    .name = "n810",
 
1466
    .desc = "Nokia N810 tablet aka. RX-44 (OMAP2420)",
 
1467
    .init = n810_init,
 
1468
    .default_boot_order = "",
 
1469
};
 
1470
 
 
1471
static void nseries_register_types(void)
 
1472
{
 
1473
    type_register_static(&mipid_info);
 
1474
}
 
1475
 
 
1476
static void nseries_machine_init(void)
 
1477
{
 
1478
    qemu_register_machine(&n800_machine);
 
1479
    qemu_register_machine(&n810_machine);
 
1480
}
 
1481
 
 
1482
type_init(nseries_register_types);
 
1483
machine_init(nseries_machine_init);