← Back to branch summary

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

« back to all changes in this revision

Viewing changes to .pc/linaro-patches-1.5.0/0050-hw-nseries.c-Add-debug-trace-to-MIPID.patch/hw/arm/nseries.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-10-22 22:47:07 UTC
  • mfrom: (1.8.3) (10.1.42 sid)
  • Revision ID: package-import@ubuntu.com-20131022224707-1lya34fw3k3f24tv
Tags: 1.6.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.6.0~rc0+dfsg-2exp from debian experimental.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
      - drop openbios-ppc and openhackware Depends to Suggests (for now)
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - New linaro patches from qemu-linaro rebasing branch
  - Dropped patches:
    * xen-simplify-xen_enabled.patch
    * sparc-linux-user-fix-missing-symbols-in-.rel-.rela.plt-sections.patch
    * main_loop-do-not-set-nonblocking-if-xen_enabled.patch
    * xen_machine_pv-do-not-create-a-dummy-CPU-in-machine-.patch
    * virtio-rng-fix-crash
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * linaro arm patches from qemu-linaro rebasing branch
  - New patches:
    * fix-pci-add: change CONFIG variable in ifdef to make sure that
      pci_add is defined.
* Add linaro patches
* Add experimental mach-virt patches for arm virtualization.
* qemu-system-common.install: add debian/tmp/usr/lib to install the
  qemu-bridge-helper

Show diffs side-by-side

added added

removed removed

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