← Back to branch summary

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

« back to all changes in this revision

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