← Back to branch summary

~ubuntu-branches/ubuntu/saucy/qemu/saucy

« back to all changes in this revision

Viewing changes to .pc/patches-arm-1.4.0/0033-hw-omap_uart.c-omap_uart_attach-add-label-argument.patch/hw/nseries.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-05-28 08:18:30 UTC
  • mfrom: (1.8.2) (10.1.37 sid)
  • Revision ID: package-import@ubuntu.com-20130528081830-87xl2z9fq516a814
Tags: 1.5.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.5.0+dfs-2 from debian unstable.  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
    * 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.
  - Dropped patches:
    * 0001-fix-wrong-output-with-info-chardev-for-tcp-socket.patch
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * gridcentric patch - updated
    * linaro arm patches from qemu-linaro rebasing branch

Show diffs side-by-side

added added

removed removed

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