← Back to branch summary

~ahs3/+junk/cq-qemu

« back to all changes in this revision

Viewing changes to hw/pxa2xx.c

  • Committer: Al Stone
  • Date: 2012-02-09 01:17:20 UTC
  • Revision ID: albert.stone@canonical.com-20120209011720-tztl7ik3qayz80p4
first commit to bzr for qemu

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/pxa2xx.c
 
1
/*
 
2
 * Intel XScale PXA255/270 processor support.
 
3
 *
 
4
 * Copyright (c) 2006 Openedhand Ltd.
 
5
 * Written by Andrzej Zaborowski <balrog@zabor.org>
 
6
 *
 
7
 * This code is licensed under the GPL.
 
8
 */
 
9
 
 
10
#include "sysbus.h"
 
11
#include "pxa.h"
 
12
#include "sysemu.h"
 
13
#include "pc.h"
 
14
#include "i2c.h"
 
15
#include "ssi.h"
 
16
#include "qemu-char.h"
 
17
#include "blockdev.h"
 
18
 
 
19
static struct {
 
20
    target_phys_addr_t io_base;
 
21
    int irqn;
 
22
} pxa255_serial[] = {
 
23
    { 0x40100000, PXA2XX_PIC_FFUART },
 
24
    { 0x40200000, PXA2XX_PIC_BTUART },
 
25
    { 0x40700000, PXA2XX_PIC_STUART },
 
26
    { 0x41600000, PXA25X_PIC_HWUART },
 
27
    { 0, 0 }
 
28
}, pxa270_serial[] = {
 
29
    { 0x40100000, PXA2XX_PIC_FFUART },
 
30
    { 0x40200000, PXA2XX_PIC_BTUART },
 
31
    { 0x40700000, PXA2XX_PIC_STUART },
 
32
    { 0, 0 }
 
33
};
 
34
 
 
35
typedef struct PXASSPDef {
 
36
    target_phys_addr_t io_base;
 
37
    int irqn;
 
38
} PXASSPDef;
 
39
 
 
40
#if 0
 
41
static PXASSPDef pxa250_ssp[] = {
 
42
    { 0x41000000, PXA2XX_PIC_SSP },
 
43
    { 0, 0 }
 
44
};
 
45
#endif
 
46
 
 
47
static PXASSPDef pxa255_ssp[] = {
 
48
    { 0x41000000, PXA2XX_PIC_SSP },
 
49
    { 0x41400000, PXA25X_PIC_NSSP },
 
50
    { 0, 0 }
 
51
};
 
52
 
 
53
#if 0
 
54
static PXASSPDef pxa26x_ssp[] = {
 
55
    { 0x41000000, PXA2XX_PIC_SSP },
 
56
    { 0x41400000, PXA25X_PIC_NSSP },
 
57
    { 0x41500000, PXA26X_PIC_ASSP },
 
58
    { 0, 0 }
 
59
};
 
60
#endif
 
61
 
 
62
static PXASSPDef pxa27x_ssp[] = {
 
63
    { 0x41000000, PXA2XX_PIC_SSP },
 
64
    { 0x41700000, PXA27X_PIC_SSP2 },
 
65
    { 0x41900000, PXA2XX_PIC_SSP3 },
 
66
    { 0, 0 }
 
67
};
 
68
 
 
69
#define PMCR    0x00    /* Power Manager Control register */
 
70
#define PSSR    0x04    /* Power Manager Sleep Status register */
 
71
#define PSPR    0x08    /* Power Manager Scratch-Pad register */
 
72
#define PWER    0x0c    /* Power Manager Wake-Up Enable register */
 
73
#define PRER    0x10    /* Power Manager Rising-Edge Detect Enable register */
 
74
#define PFER    0x14    /* Power Manager Falling-Edge Detect Enable register */
 
75
#define PEDR    0x18    /* Power Manager Edge-Detect Status register */
 
76
#define PCFR    0x1c    /* Power Manager General Configuration register */
 
77
#define PGSR0   0x20    /* Power Manager GPIO Sleep-State register 0 */
 
78
#define PGSR1   0x24    /* Power Manager GPIO Sleep-State register 1 */
 
79
#define PGSR2   0x28    /* Power Manager GPIO Sleep-State register 2 */
 
80
#define PGSR3   0x2c    /* Power Manager GPIO Sleep-State register 3 */
 
81
#define RCSR    0x30    /* Reset Controller Status register */
 
82
#define PSLR    0x34    /* Power Manager Sleep Configuration register */
 
83
#define PTSR    0x38    /* Power Manager Standby Configuration register */
 
84
#define PVCR    0x40    /* Power Manager Voltage Change Control register */
 
85
#define PUCR    0x4c    /* Power Manager USIM Card Control/Status register */
 
86
#define PKWR    0x50    /* Power Manager Keyboard Wake-Up Enable register */
 
87
#define PKSR    0x54    /* Power Manager Keyboard Level-Detect Status */
 
88
#define PCMD0   0x80    /* Power Manager I2C Command register File 0 */
 
89
#define PCMD31  0xfc    /* Power Manager I2C Command register File 31 */
 
90
 
 
91
static uint64_t pxa2xx_pm_read(void *opaque, target_phys_addr_t addr,
 
92
                               unsigned size)
 
93
{
 
94
    PXA2xxState *s = (PXA2xxState *) opaque;
 
95
 
 
96
    switch (addr) {
 
97
    case PMCR ... PCMD31:
 
98
        if (addr & 3)
 
99
            goto fail;
 
100
 
 
101
        return s->pm_regs[addr >> 2];
 
102
    default:
 
103
    fail:
 
104
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
105
        break;
 
106
    }
 
107
    return 0;
 
108
}
 
109
 
 
110
static void pxa2xx_pm_write(void *opaque, target_phys_addr_t addr,
 
111
                            uint64_t value, unsigned size)
 
112
{
 
113
    PXA2xxState *s = (PXA2xxState *) opaque;
 
114
 
 
115
    switch (addr) {
 
116
    case PMCR:
 
117
        /* Clear the write-one-to-clear bits... */
 
118
        s->pm_regs[addr >> 2] &= ~(value & 0x2a);
 
119
        /* ...and set the plain r/w bits */
 
120
        s->pm_regs[addr >> 2] &= ~0x15;
 
121
        s->pm_regs[addr >> 2] |= value & 0x15;
 
122
        break;
 
123
 
 
124
    case PSSR:  /* Read-clean registers */
 
125
    case RCSR:
 
126
    case PKSR:
 
127
        s->pm_regs[addr >> 2] &= ~value;
 
128
        break;
 
129
 
 
130
    default:    /* Read-write registers */
 
131
        if (!(addr & 3)) {
 
132
            s->pm_regs[addr >> 2] = value;
 
133
            break;
 
134
        }
 
135
 
 
136
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
137
        break;
 
138
    }
 
139
}
 
140
 
 
141
static const MemoryRegionOps pxa2xx_pm_ops = {
 
142
    .read = pxa2xx_pm_read,
 
143
    .write = pxa2xx_pm_write,
 
144
    .endianness = DEVICE_NATIVE_ENDIAN,
 
145
};
 
146
 
 
147
static const VMStateDescription vmstate_pxa2xx_pm = {
 
148
    .name = "pxa2xx_pm",
 
149
    .version_id = 0,
 
150
    .minimum_version_id = 0,
 
151
    .minimum_version_id_old = 0,
 
152
    .fields      = (VMStateField[]) {
 
153
        VMSTATE_UINT32_ARRAY(pm_regs, PXA2xxState, 0x40),
 
154
        VMSTATE_END_OF_LIST()
 
155
    }
 
156
};
 
157
 
 
158
#define CCCR    0x00    /* Core Clock Configuration register */
 
159
#define CKEN    0x04    /* Clock Enable register */
 
160
#define OSCC    0x08    /* Oscillator Configuration register */
 
161
#define CCSR    0x0c    /* Core Clock Status register */
 
162
 
 
163
static uint64_t pxa2xx_cm_read(void *opaque, target_phys_addr_t addr,
 
164
                               unsigned size)
 
165
{
 
166
    PXA2xxState *s = (PXA2xxState *) opaque;
 
167
 
 
168
    switch (addr) {
 
169
    case CCCR:
 
170
    case CKEN:
 
171
    case OSCC:
 
172
        return s->cm_regs[addr >> 2];
 
173
 
 
174
    case CCSR:
 
175
        return s->cm_regs[CCCR >> 2] | (3 << 28);
 
176
 
 
177
    default:
 
178
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
179
        break;
 
180
    }
 
181
    return 0;
 
182
}
 
183
 
 
184
static void pxa2xx_cm_write(void *opaque, target_phys_addr_t addr,
 
185
                            uint64_t value, unsigned size)
 
186
{
 
187
    PXA2xxState *s = (PXA2xxState *) opaque;
 
188
 
 
189
    switch (addr) {
 
190
    case CCCR:
 
191
    case CKEN:
 
192
        s->cm_regs[addr >> 2] = value;
 
193
        break;
 
194
 
 
195
    case OSCC:
 
196
        s->cm_regs[addr >> 2] &= ~0x6c;
 
197
        s->cm_regs[addr >> 2] |= value & 0x6e;
 
198
        if ((value >> 1) & 1)                   /* OON */
 
199
            s->cm_regs[addr >> 2] |= 1 << 0;    /* Oscillator is now stable */
 
200
        break;
 
201
 
 
202
    default:
 
203
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
204
        break;
 
205
    }
 
206
}
 
207
 
 
208
static const MemoryRegionOps pxa2xx_cm_ops = {
 
209
    .read = pxa2xx_cm_read,
 
210
    .write = pxa2xx_cm_write,
 
211
    .endianness = DEVICE_NATIVE_ENDIAN,
 
212
};
 
213
 
 
214
static const VMStateDescription vmstate_pxa2xx_cm = {
 
215
    .name = "pxa2xx_cm",
 
216
    .version_id = 0,
 
217
    .minimum_version_id = 0,
 
218
    .minimum_version_id_old = 0,
 
219
    .fields      = (VMStateField[]) {
 
220
        VMSTATE_UINT32_ARRAY(cm_regs, PXA2xxState, 4),
 
221
        VMSTATE_UINT32(clkcfg, PXA2xxState),
 
222
        VMSTATE_UINT32(pmnc, PXA2xxState),
 
223
        VMSTATE_END_OF_LIST()
 
224
    }
 
225
};
 
226
 
 
227
static uint32_t pxa2xx_clkpwr_read(void *opaque, int op2, int reg, int crm)
 
228
{
 
229
    PXA2xxState *s = (PXA2xxState *) opaque;
 
230
 
 
231
    switch (reg) {
 
232
    case 6:     /* Clock Configuration register */
 
233
        return s->clkcfg;
 
234
 
 
235
    case 7:     /* Power Mode register */
 
236
        return 0;
 
237
 
 
238
    default:
 
239
        printf("%s: Bad register 0x%x\n", __FUNCTION__, reg);
 
240
        break;
 
241
    }
 
242
    return 0;
 
243
}
 
244
 
 
245
static void pxa2xx_clkpwr_write(void *opaque, int op2, int reg, int crm,
 
246
                uint32_t value)
 
247
{
 
248
    PXA2xxState *s = (PXA2xxState *) opaque;
 
249
    static const char *pwrmode[8] = {
 
250
        "Normal", "Idle", "Deep-idle", "Standby",
 
251
        "Sleep", "reserved (!)", "reserved (!)", "Deep-sleep",
 
252
    };
 
253
 
 
254
    switch (reg) {
 
255
    case 6:     /* Clock Configuration register */
 
256
        s->clkcfg = value & 0xf;
 
257
        if (value & 2)
 
258
            printf("%s: CPU frequency change attempt\n", __FUNCTION__);
 
259
        break;
 
260
 
 
261
    case 7:     /* Power Mode register */
 
262
        if (value & 8)
 
263
            printf("%s: CPU voltage change attempt\n", __FUNCTION__);
 
264
        switch (value & 7) {
 
265
        case 0:
 
266
            /* Do nothing */
 
267
            break;
 
268
 
 
269
        case 1:
 
270
            /* Idle */
 
271
            if (!(s->cm_regs[CCCR >> 2] & (1 << 31))) { /* CPDIS */
 
272
                cpu_interrupt(s->env, CPU_INTERRUPT_HALT);
 
273
                break;
 
274
            }
 
275
            /* Fall through.  */
 
276
 
 
277
        case 2:
 
278
            /* Deep-Idle */
 
279
            cpu_interrupt(s->env, CPU_INTERRUPT_HALT);
 
280
            s->pm_regs[RCSR >> 2] |= 0x8;       /* Set GPR */
 
281
            goto message;
 
282
 
 
283
        case 3:
 
284
            s->env->uncached_cpsr =
 
285
                    ARM_CPU_MODE_SVC | CPSR_A | CPSR_F | CPSR_I;
 
286
            s->env->cp15.c1_sys = 0;
 
287
            s->env->cp15.c1_coproc = 0;
 
288
            s->env->cp15.c2_base0 = 0;
 
289
            s->env->cp15.c3 = 0;
 
290
            s->pm_regs[PSSR >> 2] |= 0x8;       /* Set STS */
 
291
            s->pm_regs[RCSR >> 2] |= 0x8;       /* Set GPR */
 
292
 
 
293
            /*
 
294
             * The scratch-pad register is almost universally used
 
295
             * for storing the return address on suspend.  For the
 
296
             * lack of a resuming bootloader, perform a jump
 
297
             * directly to that address.
 
298
             */
 
299
            memset(s->env->regs, 0, 4 * 15);
 
300
            s->env->regs[15] = s->pm_regs[PSPR >> 2];
 
301
 
 
302
#if 0
 
303
            buffer = 0xe59ff000;        /* ldr     pc, [pc, #0] */
 
304
            cpu_physical_memory_write(0, &buffer, 4);
 
305
            buffer = s->pm_regs[PSPR >> 2];
 
306
            cpu_physical_memory_write(8, &buffer, 4);
 
307
#endif
 
308
 
 
309
            /* Suspend */
 
310
            cpu_interrupt(cpu_single_env, CPU_INTERRUPT_HALT);
 
311
 
 
312
            goto message;
 
313
 
 
314
        default:
 
315
        message:
 
316
            printf("%s: machine entered %s mode\n", __FUNCTION__,
 
317
                            pwrmode[value & 7]);
 
318
        }
 
319
        break;
 
320
 
 
321
    default:
 
322
        printf("%s: Bad register 0x%x\n", __FUNCTION__, reg);
 
323
        break;
 
324
    }
 
325
}
 
326
 
 
327
/* Performace Monitoring Registers */
 
328
#define CPPMNC          0       /* Performance Monitor Control register */
 
329
#define CPCCNT          1       /* Clock Counter register */
 
330
#define CPINTEN         4       /* Interrupt Enable register */
 
331
#define CPFLAG          5       /* Overflow Flag register */
 
332
#define CPEVTSEL        8       /* Event Selection register */
 
333
 
 
334
#define CPPMN0          0       /* Performance Count register 0 */
 
335
#define CPPMN1          1       /* Performance Count register 1 */
 
336
#define CPPMN2          2       /* Performance Count register 2 */
 
337
#define CPPMN3          3       /* Performance Count register 3 */
 
338
 
 
339
static uint32_t pxa2xx_perf_read(void *opaque, int op2, int reg, int crm)
 
340
{
 
341
    PXA2xxState *s = (PXA2xxState *) opaque;
 
342
 
 
343
    switch (reg) {
 
344
    case CPPMNC:
 
345
        return s->pmnc;
 
346
    case CPCCNT:
 
347
        if (s->pmnc & 1)
 
348
            return qemu_get_clock_ns(vm_clock);
 
349
        else
 
350
            return 0;
 
351
    case CPINTEN:
 
352
    case CPFLAG:
 
353
    case CPEVTSEL:
 
354
        return 0;
 
355
 
 
356
    default:
 
357
        printf("%s: Bad register 0x%x\n", __FUNCTION__, reg);
 
358
        break;
 
359
    }
 
360
    return 0;
 
361
}
 
362
 
 
363
static void pxa2xx_perf_write(void *opaque, int op2, int reg, int crm,
 
364
                uint32_t value)
 
365
{
 
366
    PXA2xxState *s = (PXA2xxState *) opaque;
 
367
 
 
368
    switch (reg) {
 
369
    case CPPMNC:
 
370
        s->pmnc = value;
 
371
        break;
 
372
 
 
373
    case CPCCNT:
 
374
    case CPINTEN:
 
375
    case CPFLAG:
 
376
    case CPEVTSEL:
 
377
        break;
 
378
 
 
379
    default:
 
380
        printf("%s: Bad register 0x%x\n", __FUNCTION__, reg);
 
381
        break;
 
382
    }
 
383
}
 
384
 
 
385
static uint32_t pxa2xx_cp14_read(void *opaque, int op2, int reg, int crm)
 
386
{
 
387
    switch (crm) {
 
388
    case 0:
 
389
        return pxa2xx_clkpwr_read(opaque, op2, reg, crm);
 
390
    case 1:
 
391
        return pxa2xx_perf_read(opaque, op2, reg, crm);
 
392
    case 2:
 
393
        switch (reg) {
 
394
        case CPPMN0:
 
395
        case CPPMN1:
 
396
        case CPPMN2:
 
397
        case CPPMN3:
 
398
            return 0;
 
399
        }
 
400
        /* Fall through */
 
401
    default:
 
402
        printf("%s: Bad register 0x%x\n", __FUNCTION__, reg);
 
403
        break;
 
404
    }
 
405
    return 0;
 
406
}
 
407
 
 
408
static void pxa2xx_cp14_write(void *opaque, int op2, int reg, int crm,
 
409
                uint32_t value)
 
410
{
 
411
    switch (crm) {
 
412
    case 0:
 
413
        pxa2xx_clkpwr_write(opaque, op2, reg, crm, value);
 
414
        break;
 
415
    case 1:
 
416
        pxa2xx_perf_write(opaque, op2, reg, crm, value);
 
417
        break;
 
418
    case 2:
 
419
        switch (reg) {
 
420
        case CPPMN0:
 
421
        case CPPMN1:
 
422
        case CPPMN2:
 
423
        case CPPMN3:
 
424
            return;
 
425
        }
 
426
        /* Fall through */
 
427
    default:
 
428
        printf("%s: Bad register 0x%x\n", __FUNCTION__, reg);
 
429
        break;
 
430
    }
 
431
}
 
432
 
 
433
#define MDCNFG          0x00    /* SDRAM Configuration register */
 
434
#define MDREFR          0x04    /* SDRAM Refresh Control register */
 
435
#define MSC0            0x08    /* Static Memory Control register 0 */
 
436
#define MSC1            0x0c    /* Static Memory Control register 1 */
 
437
#define MSC2            0x10    /* Static Memory Control register 2 */
 
438
#define MECR            0x14    /* Expansion Memory Bus Config register */
 
439
#define SXCNFG          0x1c    /* Synchronous Static Memory Config register */
 
440
#define MCMEM0          0x28    /* PC Card Memory Socket 0 Timing register */
 
441
#define MCMEM1          0x2c    /* PC Card Memory Socket 1 Timing register */
 
442
#define MCATT0          0x30    /* PC Card Attribute Socket 0 register */
 
443
#define MCATT1          0x34    /* PC Card Attribute Socket 1 register */
 
444
#define MCIO0           0x38    /* PC Card I/O Socket 0 Timing register */
 
445
#define MCIO1           0x3c    /* PC Card I/O Socket 1 Timing register */
 
446
#define MDMRS           0x40    /* SDRAM Mode Register Set Config register */
 
447
#define BOOT_DEF        0x44    /* Boot-time Default Configuration register */
 
448
#define ARB_CNTL        0x48    /* Arbiter Control register */
 
449
#define BSCNTR0         0x4c    /* Memory Buffer Strength Control register 0 */
 
450
#define BSCNTR1         0x50    /* Memory Buffer Strength Control register 1 */
 
451
#define LCDBSCNTR       0x54    /* LCD Buffer Strength Control register */
 
452
#define MDMRSLP         0x58    /* Low Power SDRAM Mode Set Config register */
 
453
#define BSCNTR2         0x5c    /* Memory Buffer Strength Control register 2 */
 
454
#define BSCNTR3         0x60    /* Memory Buffer Strength Control register 3 */
 
455
#define SA1110          0x64    /* SA-1110 Memory Compatibility register */
 
456
 
 
457
static uint64_t pxa2xx_mm_read(void *opaque, target_phys_addr_t addr,
 
458
                               unsigned size)
 
459
{
 
460
    PXA2xxState *s = (PXA2xxState *) opaque;
 
461
 
 
462
    switch (addr) {
 
463
    case MDCNFG ... SA1110:
 
464
        if ((addr & 3) == 0)
 
465
            return s->mm_regs[addr >> 2];
 
466
 
 
467
    default:
 
468
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
469
        break;
 
470
    }
 
471
    return 0;
 
472
}
 
473
 
 
474
static void pxa2xx_mm_write(void *opaque, target_phys_addr_t addr,
 
475
                            uint64_t value, unsigned size)
 
476
{
 
477
    PXA2xxState *s = (PXA2xxState *) opaque;
 
478
 
 
479
    switch (addr) {
 
480
    case MDCNFG ... SA1110:
 
481
        if ((addr & 3) == 0) {
 
482
            s->mm_regs[addr >> 2] = value;
 
483
            break;
 
484
        }
 
485
 
 
486
    default:
 
487
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
488
        break;
 
489
    }
 
490
}
 
491
 
 
492
static const MemoryRegionOps pxa2xx_mm_ops = {
 
493
    .read = pxa2xx_mm_read,
 
494
    .write = pxa2xx_mm_write,
 
495
    .endianness = DEVICE_NATIVE_ENDIAN,
 
496
};
 
497
 
 
498
static const VMStateDescription vmstate_pxa2xx_mm = {
 
499
    .name = "pxa2xx_mm",
 
500
    .version_id = 0,
 
501
    .minimum_version_id = 0,
 
502
    .minimum_version_id_old = 0,
 
503
    .fields      = (VMStateField[]) {
 
504
        VMSTATE_UINT32_ARRAY(mm_regs, PXA2xxState, 0x1a),
 
505
        VMSTATE_END_OF_LIST()
 
506
    }
 
507
};
 
508
 
 
509
/* Synchronous Serial Ports */
 
510
typedef struct {
 
511
    SysBusDevice busdev;
 
512
    MemoryRegion iomem;
 
513
    qemu_irq irq;
 
514
    int enable;
 
515
    SSIBus *bus;
 
516
 
 
517
    uint32_t sscr[2];
 
518
    uint32_t sspsp;
 
519
    uint32_t ssto;
 
520
    uint32_t ssitr;
 
521
    uint32_t sssr;
 
522
    uint8_t sstsa;
 
523
    uint8_t ssrsa;
 
524
    uint8_t ssacd;
 
525
 
 
526
    uint32_t rx_fifo[16];
 
527
    int rx_level;
 
528
    int rx_start;
 
529
} PXA2xxSSPState;
 
530
 
 
531
#define SSCR0   0x00    /* SSP Control register 0 */
 
532
#define SSCR1   0x04    /* SSP Control register 1 */
 
533
#define SSSR    0x08    /* SSP Status register */
 
534
#define SSITR   0x0c    /* SSP Interrupt Test register */
 
535
#define SSDR    0x10    /* SSP Data register */
 
536
#define SSTO    0x28    /* SSP Time-Out register */
 
537
#define SSPSP   0x2c    /* SSP Programmable Serial Protocol register */
 
538
#define SSTSA   0x30    /* SSP TX Time Slot Active register */
 
539
#define SSRSA   0x34    /* SSP RX Time Slot Active register */
 
540
#define SSTSS   0x38    /* SSP Time Slot Status register */
 
541
#define SSACD   0x3c    /* SSP Audio Clock Divider register */
 
542
 
 
543
/* Bitfields for above registers */
 
544
#define SSCR0_SPI(x)    (((x) & 0x30) == 0x00)
 
545
#define SSCR0_SSP(x)    (((x) & 0x30) == 0x10)
 
546
#define SSCR0_UWIRE(x)  (((x) & 0x30) == 0x20)
 
547
#define SSCR0_PSP(x)    (((x) & 0x30) == 0x30)
 
548
#define SSCR0_SSE       (1 << 7)
 
549
#define SSCR0_RIM       (1 << 22)
 
550
#define SSCR0_TIM       (1 << 23)
 
551
#define SSCR0_MOD       (1 << 31)
 
552
#define SSCR0_DSS(x)    (((((x) >> 16) & 0x10) | ((x) & 0xf)) + 1)
 
553
#define SSCR1_RIE       (1 << 0)
 
554
#define SSCR1_TIE       (1 << 1)
 
555
#define SSCR1_LBM       (1 << 2)
 
556
#define SSCR1_MWDS      (1 << 5)
 
557
#define SSCR1_TFT(x)    ((((x) >> 6) & 0xf) + 1)
 
558
#define SSCR1_RFT(x)    ((((x) >> 10) & 0xf) + 1)
 
559
#define SSCR1_EFWR      (1 << 14)
 
560
#define SSCR1_PINTE     (1 << 18)
 
561
#define SSCR1_TINTE     (1 << 19)
 
562
#define SSCR1_RSRE      (1 << 20)
 
563
#define SSCR1_TSRE      (1 << 21)
 
564
#define SSCR1_EBCEI     (1 << 29)
 
565
#define SSITR_INT       (7 << 5)
 
566
#define SSSR_TNF        (1 << 2)
 
567
#define SSSR_RNE        (1 << 3)
 
568
#define SSSR_TFS        (1 << 5)
 
569
#define SSSR_RFS        (1 << 6)
 
570
#define SSSR_ROR        (1 << 7)
 
571
#define SSSR_PINT       (1 << 18)
 
572
#define SSSR_TINT       (1 << 19)
 
573
#define SSSR_EOC        (1 << 20)
 
574
#define SSSR_TUR        (1 << 21)
 
575
#define SSSR_BCE        (1 << 23)
 
576
#define SSSR_RW         0x00bc0080
 
577
 
 
578
static void pxa2xx_ssp_int_update(PXA2xxSSPState *s)
 
579
{
 
580
    int level = 0;
 
581
 
 
582
    level |= s->ssitr & SSITR_INT;
 
583
    level |= (s->sssr & SSSR_BCE)  &&  (s->sscr[1] & SSCR1_EBCEI);
 
584
    level |= (s->sssr & SSSR_TUR)  && !(s->sscr[0] & SSCR0_TIM);
 
585
    level |= (s->sssr & SSSR_EOC)  &&  (s->sssr & (SSSR_TINT | SSSR_PINT));
 
586
    level |= (s->sssr & SSSR_TINT) &&  (s->sscr[1] & SSCR1_TINTE);
 
587
    level |= (s->sssr & SSSR_PINT) &&  (s->sscr[1] & SSCR1_PINTE);
 
588
    level |= (s->sssr & SSSR_ROR)  && !(s->sscr[0] & SSCR0_RIM);
 
589
    level |= (s->sssr & SSSR_RFS)  &&  (s->sscr[1] & SSCR1_RIE);
 
590
    level |= (s->sssr & SSSR_TFS)  &&  (s->sscr[1] & SSCR1_TIE);
 
591
    qemu_set_irq(s->irq, !!level);
 
592
}
 
593
 
 
594
static void pxa2xx_ssp_fifo_update(PXA2xxSSPState *s)
 
595
{
 
596
    s->sssr &= ~(0xf << 12);    /* Clear RFL */
 
597
    s->sssr &= ~(0xf << 8);     /* Clear TFL */
 
598
    s->sssr &= ~SSSR_TFS;
 
599
    s->sssr &= ~SSSR_TNF;
 
600
    if (s->enable) {
 
601
        s->sssr |= ((s->rx_level - 1) & 0xf) << 12;
 
602
        if (s->rx_level >= SSCR1_RFT(s->sscr[1]))
 
603
            s->sssr |= SSSR_RFS;
 
604
        else
 
605
            s->sssr &= ~SSSR_RFS;
 
606
        if (s->rx_level)
 
607
            s->sssr |= SSSR_RNE;
 
608
        else
 
609
            s->sssr &= ~SSSR_RNE;
 
610
        /* TX FIFO is never filled, so it is always in underrun
 
611
           condition if SSP is enabled */
 
612
        s->sssr |= SSSR_TFS;
 
613
        s->sssr |= SSSR_TNF;
 
614
    }
 
615
 
 
616
    pxa2xx_ssp_int_update(s);
 
617
}
 
618
 
 
619
static uint64_t pxa2xx_ssp_read(void *opaque, target_phys_addr_t addr,
 
620
                                unsigned size)
 
621
{
 
622
    PXA2xxSSPState *s = (PXA2xxSSPState *) opaque;
 
623
    uint32_t retval;
 
624
 
 
625
    switch (addr) {
 
626
    case SSCR0:
 
627
        return s->sscr[0];
 
628
    case SSCR1:
 
629
        return s->sscr[1];
 
630
    case SSPSP:
 
631
        return s->sspsp;
 
632
    case SSTO:
 
633
        return s->ssto;
 
634
    case SSITR:
 
635
        return s->ssitr;
 
636
    case SSSR:
 
637
        return s->sssr | s->ssitr;
 
638
    case SSDR:
 
639
        if (!s->enable)
 
640
            return 0xffffffff;
 
641
        if (s->rx_level < 1) {
 
642
            printf("%s: SSP Rx Underrun\n", __FUNCTION__);
 
643
            return 0xffffffff;
 
644
        }
 
645
        s->rx_level --;
 
646
        retval = s->rx_fifo[s->rx_start ++];
 
647
        s->rx_start &= 0xf;
 
648
        pxa2xx_ssp_fifo_update(s);
 
649
        return retval;
 
650
    case SSTSA:
 
651
        return s->sstsa;
 
652
    case SSRSA:
 
653
        return s->ssrsa;
 
654
    case SSTSS:
 
655
        return 0;
 
656
    case SSACD:
 
657
        return s->ssacd;
 
658
    default:
 
659
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
660
        break;
 
661
    }
 
662
    return 0;
 
663
}
 
664
 
 
665
static void pxa2xx_ssp_write(void *opaque, target_phys_addr_t addr,
 
666
                             uint64_t value64, unsigned size)
 
667
{
 
668
    PXA2xxSSPState *s = (PXA2xxSSPState *) opaque;
 
669
    uint32_t value = value64;
 
670
 
 
671
    switch (addr) {
 
672
    case SSCR0:
 
673
        s->sscr[0] = value & 0xc7ffffff;
 
674
        s->enable = value & SSCR0_SSE;
 
675
        if (value & SSCR0_MOD)
 
676
            printf("%s: Attempt to use network mode\n", __FUNCTION__);
 
677
        if (s->enable && SSCR0_DSS(value) < 4)
 
678
            printf("%s: Wrong data size: %i bits\n", __FUNCTION__,
 
679
                            SSCR0_DSS(value));
 
680
        if (!(value & SSCR0_SSE)) {
 
681
            s->sssr = 0;
 
682
            s->ssitr = 0;
 
683
            s->rx_level = 0;
 
684
        }
 
685
        pxa2xx_ssp_fifo_update(s);
 
686
        break;
 
687
 
 
688
    case SSCR1:
 
689
        s->sscr[1] = value;
 
690
        if (value & (SSCR1_LBM | SSCR1_EFWR))
 
691
            printf("%s: Attempt to use SSP test mode\n", __FUNCTION__);
 
692
        pxa2xx_ssp_fifo_update(s);
 
693
        break;
 
694
 
 
695
    case SSPSP:
 
696
        s->sspsp = value;
 
697
        break;
 
698
 
 
699
    case SSTO:
 
700
        s->ssto = value;
 
701
        break;
 
702
 
 
703
    case SSITR:
 
704
        s->ssitr = value & SSITR_INT;
 
705
        pxa2xx_ssp_int_update(s);
 
706
        break;
 
707
 
 
708
    case SSSR:
 
709
        s->sssr &= ~(value & SSSR_RW);
 
710
        pxa2xx_ssp_int_update(s);
 
711
        break;
 
712
 
 
713
    case SSDR:
 
714
        if (SSCR0_UWIRE(s->sscr[0])) {
 
715
            if (s->sscr[1] & SSCR1_MWDS)
 
716
                value &= 0xffff;
 
717
            else
 
718
                value &= 0xff;
 
719
        } else
 
720
            /* Note how 32bits overflow does no harm here */
 
721
            value &= (1 << SSCR0_DSS(s->sscr[0])) - 1;
 
722
 
 
723
        /* Data goes from here to the Tx FIFO and is shifted out from
 
724
         * there directly to the slave, no need to buffer it.
 
725
         */
 
726
        if (s->enable) {
 
727
            uint32_t readval;
 
728
            readval = ssi_transfer(s->bus, value);
 
729
            if (s->rx_level < 0x10) {
 
730
                s->rx_fifo[(s->rx_start + s->rx_level ++) & 0xf] = readval;
 
731
            } else {
 
732
                s->sssr |= SSSR_ROR;
 
733
            }
 
734
        }
 
735
        pxa2xx_ssp_fifo_update(s);
 
736
        break;
 
737
 
 
738
    case SSTSA:
 
739
        s->sstsa = value;
 
740
        break;
 
741
 
 
742
    case SSRSA:
 
743
        s->ssrsa = value;
 
744
        break;
 
745
 
 
746
    case SSACD:
 
747
        s->ssacd = value;
 
748
        break;
 
749
 
 
750
    default:
 
751
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
752
        break;
 
753
    }
 
754
}
 
755
 
 
756
static const MemoryRegionOps pxa2xx_ssp_ops = {
 
757
    .read = pxa2xx_ssp_read,
 
758
    .write = pxa2xx_ssp_write,
 
759
    .endianness = DEVICE_NATIVE_ENDIAN,
 
760
};
 
761
 
 
762
static void pxa2xx_ssp_save(QEMUFile *f, void *opaque)
 
763
{
 
764
    PXA2xxSSPState *s = (PXA2xxSSPState *) opaque;
 
765
    int i;
 
766
 
 
767
    qemu_put_be32(f, s->enable);
 
768
 
 
769
    qemu_put_be32s(f, &s->sscr[0]);
 
770
    qemu_put_be32s(f, &s->sscr[1]);
 
771
    qemu_put_be32s(f, &s->sspsp);
 
772
    qemu_put_be32s(f, &s->ssto);
 
773
    qemu_put_be32s(f, &s->ssitr);
 
774
    qemu_put_be32s(f, &s->sssr);
 
775
    qemu_put_8s(f, &s->sstsa);
 
776
    qemu_put_8s(f, &s->ssrsa);
 
777
    qemu_put_8s(f, &s->ssacd);
 
778
 
 
779
    qemu_put_byte(f, s->rx_level);
 
780
    for (i = 0; i < s->rx_level; i ++)
 
781
        qemu_put_byte(f, s->rx_fifo[(s->rx_start + i) & 0xf]);
 
782
}
 
783
 
 
784
static int pxa2xx_ssp_load(QEMUFile *f, void *opaque, int version_id)
 
785
{
 
786
    PXA2xxSSPState *s = (PXA2xxSSPState *) opaque;
 
787
    int i;
 
788
 
 
789
    s->enable = qemu_get_be32(f);
 
790
 
 
791
    qemu_get_be32s(f, &s->sscr[0]);
 
792
    qemu_get_be32s(f, &s->sscr[1]);
 
793
    qemu_get_be32s(f, &s->sspsp);
 
794
    qemu_get_be32s(f, &s->ssto);
 
795
    qemu_get_be32s(f, &s->ssitr);
 
796
    qemu_get_be32s(f, &s->sssr);
 
797
    qemu_get_8s(f, &s->sstsa);
 
798
    qemu_get_8s(f, &s->ssrsa);
 
799
    qemu_get_8s(f, &s->ssacd);
 
800
 
 
801
    s->rx_level = qemu_get_byte(f);
 
802
    s->rx_start = 0;
 
803
    for (i = 0; i < s->rx_level; i ++)
 
804
        s->rx_fifo[i] = qemu_get_byte(f);
 
805
 
 
806
    return 0;
 
807
}
 
808
 
 
809
static int pxa2xx_ssp_init(SysBusDevice *dev)
 
810
{
 
811
    PXA2xxSSPState *s = FROM_SYSBUS(PXA2xxSSPState, dev);
 
812
 
 
813
    sysbus_init_irq(dev, &s->irq);
 
814
 
 
815
    memory_region_init_io(&s->iomem, &pxa2xx_ssp_ops, s, "pxa2xx-ssp", 0x1000);
 
816
    sysbus_init_mmio_region(dev, &s->iomem);
 
817
    register_savevm(&dev->qdev, "pxa2xx_ssp", -1, 0,
 
818
                    pxa2xx_ssp_save, pxa2xx_ssp_load, s);
 
819
 
 
820
    s->bus = ssi_create_bus(&dev->qdev, "ssi");
 
821
    return 0;
 
822
}
 
823
 
 
824
/* Real-Time Clock */
 
825
#define RCNR            0x00    /* RTC Counter register */
 
826
#define RTAR            0x04    /* RTC Alarm register */
 
827
#define RTSR            0x08    /* RTC Status register */
 
828
#define RTTR            0x0c    /* RTC Timer Trim register */
 
829
#define RDCR            0x10    /* RTC Day Counter register */
 
830
#define RYCR            0x14    /* RTC Year Counter register */
 
831
#define RDAR1           0x18    /* RTC Wristwatch Day Alarm register 1 */
 
832
#define RYAR1           0x1c    /* RTC Wristwatch Year Alarm register 1 */
 
833
#define RDAR2           0x20    /* RTC Wristwatch Day Alarm register 2 */
 
834
#define RYAR2           0x24    /* RTC Wristwatch Year Alarm register 2 */
 
835
#define SWCR            0x28    /* RTC Stopwatch Counter register */
 
836
#define SWAR1           0x2c    /* RTC Stopwatch Alarm register 1 */
 
837
#define SWAR2           0x30    /* RTC Stopwatch Alarm register 2 */
 
838
#define RTCPICR         0x34    /* RTC Periodic Interrupt Counter register */
 
839
#define PIAR            0x38    /* RTC Periodic Interrupt Alarm register */
 
840
 
 
841
typedef struct {
 
842
    SysBusDevice busdev;
 
843
    MemoryRegion iomem;
 
844
    uint32_t rttr;
 
845
    uint32_t rtsr;
 
846
    uint32_t rtar;
 
847
    uint32_t rdar1;
 
848
    uint32_t rdar2;
 
849
    uint32_t ryar1;
 
850
    uint32_t ryar2;
 
851
    uint32_t swar1;
 
852
    uint32_t swar2;
 
853
    uint32_t piar;
 
854
    uint32_t last_rcnr;
 
855
    uint32_t last_rdcr;
 
856
    uint32_t last_rycr;
 
857
    uint32_t last_swcr;
 
858
    uint32_t last_rtcpicr;
 
859
    int64_t last_hz;
 
860
    int64_t last_sw;
 
861
    int64_t last_pi;
 
862
    QEMUTimer *rtc_hz;
 
863
    QEMUTimer *rtc_rdal1;
 
864
    QEMUTimer *rtc_rdal2;
 
865
    QEMUTimer *rtc_swal1;
 
866
    QEMUTimer *rtc_swal2;
 
867
    QEMUTimer *rtc_pi;
 
868
    qemu_irq rtc_irq;
 
869
} PXA2xxRTCState;
 
870
 
 
871
static inline void pxa2xx_rtc_int_update(PXA2xxRTCState *s)
 
872
{
 
873
    qemu_set_irq(s->rtc_irq, !!(s->rtsr & 0x2553));
 
874
}
 
875
 
 
876
static void pxa2xx_rtc_hzupdate(PXA2xxRTCState *s)
 
877
{
 
878
    int64_t rt = qemu_get_clock_ms(rt_clock);
 
879
    s->last_rcnr += ((rt - s->last_hz) << 15) /
 
880
            (1000 * ((s->rttr & 0xffff) + 1));
 
881
    s->last_rdcr += ((rt - s->last_hz) << 15) /
 
882
            (1000 * ((s->rttr & 0xffff) + 1));
 
883
    s->last_hz = rt;
 
884
}
 
885
 
 
886
static void pxa2xx_rtc_swupdate(PXA2xxRTCState *s)
 
887
{
 
888
    int64_t rt = qemu_get_clock_ms(rt_clock);
 
889
    if (s->rtsr & (1 << 12))
 
890
        s->last_swcr += (rt - s->last_sw) / 10;
 
891
    s->last_sw = rt;
 
892
}
 
893
 
 
894
static void pxa2xx_rtc_piupdate(PXA2xxRTCState *s)
 
895
{
 
896
    int64_t rt = qemu_get_clock_ms(rt_clock);
 
897
    if (s->rtsr & (1 << 15))
 
898
        s->last_swcr += rt - s->last_pi;
 
899
    s->last_pi = rt;
 
900
}
 
901
 
 
902
static inline void pxa2xx_rtc_alarm_update(PXA2xxRTCState *s,
 
903
                uint32_t rtsr)
 
904
{
 
905
    if ((rtsr & (1 << 2)) && !(rtsr & (1 << 0)))
 
906
        qemu_mod_timer(s->rtc_hz, s->last_hz +
 
907
                (((s->rtar - s->last_rcnr) * 1000 *
 
908
                  ((s->rttr & 0xffff) + 1)) >> 15));
 
909
    else
 
910
        qemu_del_timer(s->rtc_hz);
 
911
 
 
912
    if ((rtsr & (1 << 5)) && !(rtsr & (1 << 4)))
 
913
        qemu_mod_timer(s->rtc_rdal1, s->last_hz +
 
914
                (((s->rdar1 - s->last_rdcr) * 1000 *
 
915
                  ((s->rttr & 0xffff) + 1)) >> 15)); /* TODO: fixup */
 
916
    else
 
917
        qemu_del_timer(s->rtc_rdal1);
 
918
 
 
919
    if ((rtsr & (1 << 7)) && !(rtsr & (1 << 6)))
 
920
        qemu_mod_timer(s->rtc_rdal2, s->last_hz +
 
921
                (((s->rdar2 - s->last_rdcr) * 1000 *
 
922
                  ((s->rttr & 0xffff) + 1)) >> 15)); /* TODO: fixup */
 
923
    else
 
924
        qemu_del_timer(s->rtc_rdal2);
 
925
 
 
926
    if ((rtsr & 0x1200) == 0x1200 && !(rtsr & (1 << 8)))
 
927
        qemu_mod_timer(s->rtc_swal1, s->last_sw +
 
928
                        (s->swar1 - s->last_swcr) * 10); /* TODO: fixup */
 
929
    else
 
930
        qemu_del_timer(s->rtc_swal1);
 
931
 
 
932
    if ((rtsr & 0x1800) == 0x1800 && !(rtsr & (1 << 10)))
 
933
        qemu_mod_timer(s->rtc_swal2, s->last_sw +
 
934
                        (s->swar2 - s->last_swcr) * 10); /* TODO: fixup */
 
935
    else
 
936
        qemu_del_timer(s->rtc_swal2);
 
937
 
 
938
    if ((rtsr & 0xc000) == 0xc000 && !(rtsr & (1 << 13)))
 
939
        qemu_mod_timer(s->rtc_pi, s->last_pi +
 
940
                        (s->piar & 0xffff) - s->last_rtcpicr);
 
941
    else
 
942
        qemu_del_timer(s->rtc_pi);
 
943
}
 
944
 
 
945
static inline void pxa2xx_rtc_hz_tick(void *opaque)
 
946
{
 
947
    PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
 
948
    s->rtsr |= (1 << 0);
 
949
    pxa2xx_rtc_alarm_update(s, s->rtsr);
 
950
    pxa2xx_rtc_int_update(s);
 
951
}
 
952
 
 
953
static inline void pxa2xx_rtc_rdal1_tick(void *opaque)
 
954
{
 
955
    PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
 
956
    s->rtsr |= (1 << 4);
 
957
    pxa2xx_rtc_alarm_update(s, s->rtsr);
 
958
    pxa2xx_rtc_int_update(s);
 
959
}
 
960
 
 
961
static inline void pxa2xx_rtc_rdal2_tick(void *opaque)
 
962
{
 
963
    PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
 
964
    s->rtsr |= (1 << 6);
 
965
    pxa2xx_rtc_alarm_update(s, s->rtsr);
 
966
    pxa2xx_rtc_int_update(s);
 
967
}
 
968
 
 
969
static inline void pxa2xx_rtc_swal1_tick(void *opaque)
 
970
{
 
971
    PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
 
972
    s->rtsr |= (1 << 8);
 
973
    pxa2xx_rtc_alarm_update(s, s->rtsr);
 
974
    pxa2xx_rtc_int_update(s);
 
975
}
 
976
 
 
977
static inline void pxa2xx_rtc_swal2_tick(void *opaque)
 
978
{
 
979
    PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
 
980
    s->rtsr |= (1 << 10);
 
981
    pxa2xx_rtc_alarm_update(s, s->rtsr);
 
982
    pxa2xx_rtc_int_update(s);
 
983
}
 
984
 
 
985
static inline void pxa2xx_rtc_pi_tick(void *opaque)
 
986
{
 
987
    PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
 
988
    s->rtsr |= (1 << 13);
 
989
    pxa2xx_rtc_piupdate(s);
 
990
    s->last_rtcpicr = 0;
 
991
    pxa2xx_rtc_alarm_update(s, s->rtsr);
 
992
    pxa2xx_rtc_int_update(s);
 
993
}
 
994
 
 
995
static uint64_t pxa2xx_rtc_read(void *opaque, target_phys_addr_t addr,
 
996
                                unsigned size)
 
997
{
 
998
    PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
 
999
 
 
1000
    switch (addr) {
 
1001
    case RTTR:
 
1002
        return s->rttr;
 
1003
    case RTSR:
 
1004
        return s->rtsr;
 
1005
    case RTAR:
 
1006
        return s->rtar;
 
1007
    case RDAR1:
 
1008
        return s->rdar1;
 
1009
    case RDAR2:
 
1010
        return s->rdar2;
 
1011
    case RYAR1:
 
1012
        return s->ryar1;
 
1013
    case RYAR2:
 
1014
        return s->ryar2;
 
1015
    case SWAR1:
 
1016
        return s->swar1;
 
1017
    case SWAR2:
 
1018
        return s->swar2;
 
1019
    case PIAR:
 
1020
        return s->piar;
 
1021
    case RCNR:
 
1022
        return s->last_rcnr + ((qemu_get_clock_ms(rt_clock) - s->last_hz) << 15) /
 
1023
                (1000 * ((s->rttr & 0xffff) + 1));
 
1024
    case RDCR:
 
1025
        return s->last_rdcr + ((qemu_get_clock_ms(rt_clock) - s->last_hz) << 15) /
 
1026
                (1000 * ((s->rttr & 0xffff) + 1));
 
1027
    case RYCR:
 
1028
        return s->last_rycr;
 
1029
    case SWCR:
 
1030
        if (s->rtsr & (1 << 12))
 
1031
            return s->last_swcr + (qemu_get_clock_ms(rt_clock) - s->last_sw) / 10;
 
1032
        else
 
1033
            return s->last_swcr;
 
1034
    default:
 
1035
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
1036
        break;
 
1037
    }
 
1038
    return 0;
 
1039
}
 
1040
 
 
1041
static void pxa2xx_rtc_write(void *opaque, target_phys_addr_t addr,
 
1042
                             uint64_t value64, unsigned size)
 
1043
{
 
1044
    PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
 
1045
    uint32_t value = value64;
 
1046
 
 
1047
    switch (addr) {
 
1048
    case RTTR:
 
1049
        if (!(s->rttr & (1 << 31))) {
 
1050
            pxa2xx_rtc_hzupdate(s);
 
1051
            s->rttr = value;
 
1052
            pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1053
        }
 
1054
        break;
 
1055
 
 
1056
    case RTSR:
 
1057
        if ((s->rtsr ^ value) & (1 << 15))
 
1058
            pxa2xx_rtc_piupdate(s);
 
1059
 
 
1060
        if ((s->rtsr ^ value) & (1 << 12))
 
1061
            pxa2xx_rtc_swupdate(s);
 
1062
 
 
1063
        if (((s->rtsr ^ value) & 0x4aac) | (value & ~0xdaac))
 
1064
            pxa2xx_rtc_alarm_update(s, value);
 
1065
 
 
1066
        s->rtsr = (value & 0xdaac) | (s->rtsr & ~(value & ~0xdaac));
 
1067
        pxa2xx_rtc_int_update(s);
 
1068
        break;
 
1069
 
 
1070
    case RTAR:
 
1071
        s->rtar = value;
 
1072
        pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1073
        break;
 
1074
 
 
1075
    case RDAR1:
 
1076
        s->rdar1 = value;
 
1077
        pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1078
        break;
 
1079
 
 
1080
    case RDAR2:
 
1081
        s->rdar2 = value;
 
1082
        pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1083
        break;
 
1084
 
 
1085
    case RYAR1:
 
1086
        s->ryar1 = value;
 
1087
        pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1088
        break;
 
1089
 
 
1090
    case RYAR2:
 
1091
        s->ryar2 = value;
 
1092
        pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1093
        break;
 
1094
 
 
1095
    case SWAR1:
 
1096
        pxa2xx_rtc_swupdate(s);
 
1097
        s->swar1 = value;
 
1098
        s->last_swcr = 0;
 
1099
        pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1100
        break;
 
1101
 
 
1102
    case SWAR2:
 
1103
        s->swar2 = value;
 
1104
        pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1105
        break;
 
1106
 
 
1107
    case PIAR:
 
1108
        s->piar = value;
 
1109
        pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1110
        break;
 
1111
 
 
1112
    case RCNR:
 
1113
        pxa2xx_rtc_hzupdate(s);
 
1114
        s->last_rcnr = value;
 
1115
        pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1116
        break;
 
1117
 
 
1118
    case RDCR:
 
1119
        pxa2xx_rtc_hzupdate(s);
 
1120
        s->last_rdcr = value;
 
1121
        pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1122
        break;
 
1123
 
 
1124
    case RYCR:
 
1125
        s->last_rycr = value;
 
1126
        break;
 
1127
 
 
1128
    case SWCR:
 
1129
        pxa2xx_rtc_swupdate(s);
 
1130
        s->last_swcr = value;
 
1131
        pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1132
        break;
 
1133
 
 
1134
    case RTCPICR:
 
1135
        pxa2xx_rtc_piupdate(s);
 
1136
        s->last_rtcpicr = value & 0xffff;
 
1137
        pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1138
        break;
 
1139
 
 
1140
    default:
 
1141
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
1142
    }
 
1143
}
 
1144
 
 
1145
static const MemoryRegionOps pxa2xx_rtc_ops = {
 
1146
    .read = pxa2xx_rtc_read,
 
1147
    .write = pxa2xx_rtc_write,
 
1148
    .endianness = DEVICE_NATIVE_ENDIAN,
 
1149
};
 
1150
 
 
1151
static int pxa2xx_rtc_init(SysBusDevice *dev)
 
1152
{
 
1153
    PXA2xxRTCState *s = FROM_SYSBUS(PXA2xxRTCState, dev);
 
1154
    struct tm tm;
 
1155
    int wom;
 
1156
 
 
1157
    s->rttr = 0x7fff;
 
1158
    s->rtsr = 0;
 
1159
 
 
1160
    qemu_get_timedate(&tm, 0);
 
1161
    wom = ((tm.tm_mday - 1) / 7) + 1;
 
1162
 
 
1163
    s->last_rcnr = (uint32_t) mktimegm(&tm);
 
1164
    s->last_rdcr = (wom << 20) | ((tm.tm_wday + 1) << 17) |
 
1165
            (tm.tm_hour << 12) | (tm.tm_min << 6) | tm.tm_sec;
 
1166
    s->last_rycr = ((tm.tm_year + 1900) << 9) |
 
1167
            ((tm.tm_mon + 1) << 5) | tm.tm_mday;
 
1168
    s->last_swcr = (tm.tm_hour << 19) |
 
1169
            (tm.tm_min << 13) | (tm.tm_sec << 7);
 
1170
    s->last_rtcpicr = 0;
 
1171
    s->last_hz = s->last_sw = s->last_pi = qemu_get_clock_ms(rt_clock);
 
1172
 
 
1173
    s->rtc_hz    = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_hz_tick,    s);
 
1174
    s->rtc_rdal1 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_rdal1_tick, s);
 
1175
    s->rtc_rdal2 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_rdal2_tick, s);
 
1176
    s->rtc_swal1 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_swal1_tick, s);
 
1177
    s->rtc_swal2 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_swal2_tick, s);
 
1178
    s->rtc_pi    = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_pi_tick,    s);
 
1179
 
 
1180
    sysbus_init_irq(dev, &s->rtc_irq);
 
1181
 
 
1182
    memory_region_init_io(&s->iomem, &pxa2xx_rtc_ops, s, "pxa2xx-rtc", 0x10000);
 
1183
    sysbus_init_mmio_region(dev, &s->iomem);
 
1184
 
 
1185
    return 0;
 
1186
}
 
1187
 
 
1188
static void pxa2xx_rtc_pre_save(void *opaque)
 
1189
{
 
1190
    PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
 
1191
 
 
1192
    pxa2xx_rtc_hzupdate(s);
 
1193
    pxa2xx_rtc_piupdate(s);
 
1194
    pxa2xx_rtc_swupdate(s);
 
1195
}
 
1196
 
 
1197
static int pxa2xx_rtc_post_load(void *opaque, int version_id)
 
1198
{
 
1199
    PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
 
1200
 
 
1201
    pxa2xx_rtc_alarm_update(s, s->rtsr);
 
1202
 
 
1203
    return 0;
 
1204
}
 
1205
 
 
1206
static const VMStateDescription vmstate_pxa2xx_rtc_regs = {
 
1207
    .name = "pxa2xx_rtc",
 
1208
    .version_id = 0,
 
1209
    .minimum_version_id = 0,
 
1210
    .minimum_version_id_old = 0,
 
1211
    .pre_save = pxa2xx_rtc_pre_save,
 
1212
    .post_load = pxa2xx_rtc_post_load,
 
1213
    .fields = (VMStateField[]) {
 
1214
        VMSTATE_UINT32(rttr, PXA2xxRTCState),
 
1215
        VMSTATE_UINT32(rtsr, PXA2xxRTCState),
 
1216
        VMSTATE_UINT32(rtar, PXA2xxRTCState),
 
1217
        VMSTATE_UINT32(rdar1, PXA2xxRTCState),
 
1218
        VMSTATE_UINT32(rdar2, PXA2xxRTCState),
 
1219
        VMSTATE_UINT32(ryar1, PXA2xxRTCState),
 
1220
        VMSTATE_UINT32(ryar2, PXA2xxRTCState),
 
1221
        VMSTATE_UINT32(swar1, PXA2xxRTCState),
 
1222
        VMSTATE_UINT32(swar2, PXA2xxRTCState),
 
1223
        VMSTATE_UINT32(piar, PXA2xxRTCState),
 
1224
        VMSTATE_UINT32(last_rcnr, PXA2xxRTCState),
 
1225
        VMSTATE_UINT32(last_rdcr, PXA2xxRTCState),
 
1226
        VMSTATE_UINT32(last_rycr, PXA2xxRTCState),
 
1227
        VMSTATE_UINT32(last_swcr, PXA2xxRTCState),
 
1228
        VMSTATE_UINT32(last_rtcpicr, PXA2xxRTCState),
 
1229
        VMSTATE_INT64(last_hz, PXA2xxRTCState),
 
1230
        VMSTATE_INT64(last_sw, PXA2xxRTCState),
 
1231
        VMSTATE_INT64(last_pi, PXA2xxRTCState),
 
1232
        VMSTATE_END_OF_LIST(),
 
1233
    },
 
1234
};
 
1235
 
 
1236
static SysBusDeviceInfo pxa2xx_rtc_sysbus_info = {
 
1237
    .init       = pxa2xx_rtc_init,
 
1238
    .qdev.name  = "pxa2xx_rtc",
 
1239
    .qdev.desc  = "PXA2xx RTC Controller",
 
1240
    .qdev.size  = sizeof(PXA2xxRTCState),
 
1241
    .qdev.vmsd  = &vmstate_pxa2xx_rtc_regs,
 
1242
};
 
1243
 
 
1244
/* I2C Interface */
 
1245
typedef struct {
 
1246
    i2c_slave i2c;
 
1247
    PXA2xxI2CState *host;
 
1248
} PXA2xxI2CSlaveState;
 
1249
 
 
1250
struct PXA2xxI2CState {
 
1251
    SysBusDevice busdev;
 
1252
    MemoryRegion iomem;
 
1253
    PXA2xxI2CSlaveState *slave;
 
1254
    i2c_bus *bus;
 
1255
    qemu_irq irq;
 
1256
    uint32_t offset;
 
1257
    uint32_t region_size;
 
1258
 
 
1259
    uint16_t control;
 
1260
    uint16_t status;
 
1261
    uint8_t ibmr;
 
1262
    uint8_t data;
 
1263
};
 
1264
 
 
1265
#define IBMR    0x80    /* I2C Bus Monitor register */
 
1266
#define IDBR    0x88    /* I2C Data Buffer register */
 
1267
#define ICR     0x90    /* I2C Control register */
 
1268
#define ISR     0x98    /* I2C Status register */
 
1269
#define ISAR    0xa0    /* I2C Slave Address register */
 
1270
 
 
1271
static void pxa2xx_i2c_update(PXA2xxI2CState *s)
 
1272
{
 
1273
    uint16_t level = 0;
 
1274
    level |= s->status & s->control & (1 << 10);                /* BED */
 
1275
    level |= (s->status & (1 << 7)) && (s->control & (1 << 9)); /* IRF */
 
1276
    level |= (s->status & (1 << 6)) && (s->control & (1 << 8)); /* ITE */
 
1277
    level |= s->status & (1 << 9);                              /* SAD */
 
1278
    qemu_set_irq(s->irq, !!level);
 
1279
}
 
1280
 
 
1281
/* These are only stubs now.  */
 
1282
static void pxa2xx_i2c_event(i2c_slave *i2c, enum i2c_event event)
 
1283
{
 
1284
    PXA2xxI2CSlaveState *slave = FROM_I2C_SLAVE(PXA2xxI2CSlaveState, i2c);
 
1285
    PXA2xxI2CState *s = slave->host;
 
1286
 
 
1287
    switch (event) {
 
1288
    case I2C_START_SEND:
 
1289
        s->status |= (1 << 9);                          /* set SAD */
 
1290
        s->status &= ~(1 << 0);                         /* clear RWM */
 
1291
        break;
 
1292
    case I2C_START_RECV:
 
1293
        s->status |= (1 << 9);                          /* set SAD */
 
1294
        s->status |= 1 << 0;                            /* set RWM */
 
1295
        break;
 
1296
    case I2C_FINISH:
 
1297
        s->status |= (1 << 4);                          /* set SSD */
 
1298
        break;
 
1299
    case I2C_NACK:
 
1300
        s->status |= 1 << 1;                            /* set ACKNAK */
 
1301
        break;
 
1302
    }
 
1303
    pxa2xx_i2c_update(s);
 
1304
}
 
1305
 
 
1306
static int pxa2xx_i2c_rx(i2c_slave *i2c)
 
1307
{
 
1308
    PXA2xxI2CSlaveState *slave = FROM_I2C_SLAVE(PXA2xxI2CSlaveState, i2c);
 
1309
    PXA2xxI2CState *s = slave->host;
 
1310
    if ((s->control & (1 << 14)) || !(s->control & (1 << 6)))
 
1311
        return 0;
 
1312
 
 
1313
    if (s->status & (1 << 0)) {                 /* RWM */
 
1314
        s->status |= 1 << 6;                    /* set ITE */
 
1315
    }
 
1316
    pxa2xx_i2c_update(s);
 
1317
 
 
1318
    return s->data;
 
1319
}
 
1320
 
 
1321
static int pxa2xx_i2c_tx(i2c_slave *i2c, uint8_t data)
 
1322
{
 
1323
    PXA2xxI2CSlaveState *slave = FROM_I2C_SLAVE(PXA2xxI2CSlaveState, i2c);
 
1324
    PXA2xxI2CState *s = slave->host;
 
1325
    if ((s->control & (1 << 14)) || !(s->control & (1 << 6)))
 
1326
        return 1;
 
1327
 
 
1328
    if (!(s->status & (1 << 0))) {              /* RWM */
 
1329
        s->status |= 1 << 7;                    /* set IRF */
 
1330
        s->data = data;
 
1331
    }
 
1332
    pxa2xx_i2c_update(s);
 
1333
 
 
1334
    return 1;
 
1335
}
 
1336
 
 
1337
static uint64_t pxa2xx_i2c_read(void *opaque, target_phys_addr_t addr,
 
1338
                                unsigned size)
 
1339
{
 
1340
    PXA2xxI2CState *s = (PXA2xxI2CState *) opaque;
 
1341
 
 
1342
    addr -= s->offset;
 
1343
    switch (addr) {
 
1344
    case ICR:
 
1345
        return s->control;
 
1346
    case ISR:
 
1347
        return s->status | (i2c_bus_busy(s->bus) << 2);
 
1348
    case ISAR:
 
1349
        return s->slave->i2c.address;
 
1350
    case IDBR:
 
1351
        return s->data;
 
1352
    case IBMR:
 
1353
        if (s->status & (1 << 2))
 
1354
            s->ibmr ^= 3;       /* Fake SCL and SDA pin changes */
 
1355
        else
 
1356
            s->ibmr = 0;
 
1357
        return s->ibmr;
 
1358
    default:
 
1359
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
1360
        break;
 
1361
    }
 
1362
    return 0;
 
1363
}
 
1364
 
 
1365
static void pxa2xx_i2c_write(void *opaque, target_phys_addr_t addr,
 
1366
                             uint64_t value64, unsigned size)
 
1367
{
 
1368
    PXA2xxI2CState *s = (PXA2xxI2CState *) opaque;
 
1369
    uint32_t value = value64;
 
1370
    int ack;
 
1371
 
 
1372
    addr -= s->offset;
 
1373
    switch (addr) {
 
1374
    case ICR:
 
1375
        s->control = value & 0xfff7;
 
1376
        if ((value & (1 << 3)) && (value & (1 << 6))) { /* TB and IUE */
 
1377
            /* TODO: slave mode */
 
1378
            if (value & (1 << 0)) {                     /* START condition */
 
1379
                if (s->data & 1)
 
1380
                    s->status |= 1 << 0;                /* set RWM */
 
1381
                else
 
1382
                    s->status &= ~(1 << 0);             /* clear RWM */
 
1383
                ack = !i2c_start_transfer(s->bus, s->data >> 1, s->data & 1);
 
1384
            } else {
 
1385
                if (s->status & (1 << 0)) {             /* RWM */
 
1386
                    s->data = i2c_recv(s->bus);
 
1387
                    if (value & (1 << 2))               /* ACKNAK */
 
1388
                        i2c_nack(s->bus);
 
1389
                    ack = 1;
 
1390
                } else
 
1391
                    ack = !i2c_send(s->bus, s->data);
 
1392
            }
 
1393
 
 
1394
            if (value & (1 << 1))                       /* STOP condition */
 
1395
                i2c_end_transfer(s->bus);
 
1396
 
 
1397
            if (ack) {
 
1398
                if (value & (1 << 0))                   /* START condition */
 
1399
                    s->status |= 1 << 6;                /* set ITE */
 
1400
                else
 
1401
                    if (s->status & (1 << 0))           /* RWM */
 
1402
                        s->status |= 1 << 7;            /* set IRF */
 
1403
                    else
 
1404
                        s->status |= 1 << 6;            /* set ITE */
 
1405
                s->status &= ~(1 << 1);                 /* clear ACKNAK */
 
1406
            } else {
 
1407
                s->status |= 1 << 6;                    /* set ITE */
 
1408
                s->status |= 1 << 10;                   /* set BED */
 
1409
                s->status |= 1 << 1;                    /* set ACKNAK */
 
1410
            }
 
1411
        }
 
1412
        if (!(value & (1 << 3)) && (value & (1 << 6)))  /* !TB and IUE */
 
1413
            if (value & (1 << 4))                       /* MA */
 
1414
                i2c_end_transfer(s->bus);
 
1415
        pxa2xx_i2c_update(s);
 
1416
        break;
 
1417
 
 
1418
    case ISR:
 
1419
        s->status &= ~(value & 0x07f0);
 
1420
        pxa2xx_i2c_update(s);
 
1421
        break;
 
1422
 
 
1423
    case ISAR:
 
1424
        i2c_set_slave_address(&s->slave->i2c, value & 0x7f);
 
1425
        break;
 
1426
 
 
1427
    case IDBR:
 
1428
        s->data = value & 0xff;
 
1429
        break;
 
1430
 
 
1431
    default:
 
1432
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
1433
    }
 
1434
}
 
1435
 
 
1436
static const MemoryRegionOps pxa2xx_i2c_ops = {
 
1437
    .read = pxa2xx_i2c_read,
 
1438
    .write = pxa2xx_i2c_write,
 
1439
    .endianness = DEVICE_NATIVE_ENDIAN,
 
1440
};
 
1441
 
 
1442
static const VMStateDescription vmstate_pxa2xx_i2c_slave = {
 
1443
    .name = "pxa2xx_i2c_slave",
 
1444
    .version_id = 1,
 
1445
    .minimum_version_id = 1,
 
1446
    .minimum_version_id_old = 1,
 
1447
    .fields      = (VMStateField []) {
 
1448
        VMSTATE_I2C_SLAVE(i2c, PXA2xxI2CSlaveState),
 
1449
        VMSTATE_END_OF_LIST()
 
1450
    }
 
1451
};
 
1452
 
 
1453
static const VMStateDescription vmstate_pxa2xx_i2c = {
 
1454
    .name = "pxa2xx_i2c",
 
1455
    .version_id = 1,
 
1456
    .minimum_version_id = 1,
 
1457
    .minimum_version_id_old = 1,
 
1458
    .fields      = (VMStateField []) {
 
1459
        VMSTATE_UINT16(control, PXA2xxI2CState),
 
1460
        VMSTATE_UINT16(status, PXA2xxI2CState),
 
1461
        VMSTATE_UINT8(ibmr, PXA2xxI2CState),
 
1462
        VMSTATE_UINT8(data, PXA2xxI2CState),
 
1463
        VMSTATE_STRUCT_POINTER(slave, PXA2xxI2CState,
 
1464
                               vmstate_pxa2xx_i2c_slave, PXA2xxI2CSlaveState *),
 
1465
        VMSTATE_END_OF_LIST()
 
1466
    }
 
1467
};
 
1468
 
 
1469
static int pxa2xx_i2c_slave_init(i2c_slave *i2c)
 
1470
{
 
1471
    /* Nothing to do.  */
 
1472
    return 0;
 
1473
}
 
1474
 
 
1475
static I2CSlaveInfo pxa2xx_i2c_slave_info = {
 
1476
    .qdev.name = "pxa2xx-i2c-slave",
 
1477
    .qdev.size = sizeof(PXA2xxI2CSlaveState),
 
1478
    .init = pxa2xx_i2c_slave_init,
 
1479
    .event = pxa2xx_i2c_event,
 
1480
    .recv = pxa2xx_i2c_rx,
 
1481
    .send = pxa2xx_i2c_tx
 
1482
};
 
1483
 
 
1484
PXA2xxI2CState *pxa2xx_i2c_init(target_phys_addr_t base,
 
1485
                qemu_irq irq, uint32_t region_size)
 
1486
{
 
1487
    DeviceState *dev;
 
1488
    SysBusDevice *i2c_dev;
 
1489
    PXA2xxI2CState *s;
 
1490
 
 
1491
    i2c_dev = sysbus_from_qdev(qdev_create(NULL, "pxa2xx_i2c"));
 
1492
    qdev_prop_set_uint32(&i2c_dev->qdev, "size", region_size + 1);
 
1493
    qdev_prop_set_uint32(&i2c_dev->qdev, "offset",
 
1494
            base - (base & (~region_size) & TARGET_PAGE_MASK));
 
1495
 
 
1496
    qdev_init_nofail(&i2c_dev->qdev);
 
1497
 
 
1498
    sysbus_mmio_map(i2c_dev, 0, base & ~region_size);
 
1499
    sysbus_connect_irq(i2c_dev, 0, irq);
 
1500
 
 
1501
    s = FROM_SYSBUS(PXA2xxI2CState, i2c_dev);
 
1502
    /* FIXME: Should the slave device really be on a separate bus?  */
 
1503
    dev = i2c_create_slave(i2c_init_bus(NULL, "dummy"), "pxa2xx-i2c-slave", 0);
 
1504
    s->slave = FROM_I2C_SLAVE(PXA2xxI2CSlaveState, I2C_SLAVE_FROM_QDEV(dev));
 
1505
    s->slave->host = s;
 
1506
 
 
1507
    return s;
 
1508
}
 
1509
 
 
1510
static int pxa2xx_i2c_initfn(SysBusDevice *dev)
 
1511
{
 
1512
    PXA2xxI2CState *s = FROM_SYSBUS(PXA2xxI2CState, dev);
 
1513
 
 
1514
    s->bus = i2c_init_bus(&dev->qdev, "i2c");
 
1515
 
 
1516
    memory_region_init_io(&s->iomem, &pxa2xx_i2c_ops, s,
 
1517
                          "pxa2xx-i2x", s->region_size);
 
1518
    sysbus_init_mmio_region(dev, &s->iomem);
 
1519
    sysbus_init_irq(dev, &s->irq);
 
1520
 
 
1521
    return 0;
 
1522
}
 
1523
 
 
1524
i2c_bus *pxa2xx_i2c_bus(PXA2xxI2CState *s)
 
1525
{
 
1526
    return s->bus;
 
1527
}
 
1528
 
 
1529
static SysBusDeviceInfo pxa2xx_i2c_info = {
 
1530
    .init       = pxa2xx_i2c_initfn,
 
1531
    .qdev.name  = "pxa2xx_i2c",
 
1532
    .qdev.desc  = "PXA2xx I2C Bus Controller",
 
1533
    .qdev.size  = sizeof(PXA2xxI2CState),
 
1534
    .qdev.vmsd  = &vmstate_pxa2xx_i2c,
 
1535
    .qdev.props = (Property[]) {
 
1536
        DEFINE_PROP_UINT32("size", PXA2xxI2CState, region_size, 0x10000),
 
1537
        DEFINE_PROP_UINT32("offset", PXA2xxI2CState, offset, 0),
 
1538
        DEFINE_PROP_END_OF_LIST(),
 
1539
    },
 
1540
};
 
1541
 
 
1542
/* PXA Inter-IC Sound Controller */
 
1543
static void pxa2xx_i2s_reset(PXA2xxI2SState *i2s)
 
1544
{
 
1545
    i2s->rx_len = 0;
 
1546
    i2s->tx_len = 0;
 
1547
    i2s->fifo_len = 0;
 
1548
    i2s->clk = 0x1a;
 
1549
    i2s->control[0] = 0x00;
 
1550
    i2s->control[1] = 0x00;
 
1551
    i2s->status = 0x00;
 
1552
    i2s->mask = 0x00;
 
1553
}
 
1554
 
 
1555
#define SACR_TFTH(val)  ((val >> 8) & 0xf)
 
1556
#define SACR_RFTH(val)  ((val >> 12) & 0xf)
 
1557
#define SACR_DREC(val)  (val & (1 << 3))
 
1558
#define SACR_DPRL(val)  (val & (1 << 4))
 
1559
 
 
1560
static inline void pxa2xx_i2s_update(PXA2xxI2SState *i2s)
 
1561
{
 
1562
    int rfs, tfs;
 
1563
    rfs = SACR_RFTH(i2s->control[0]) < i2s->rx_len &&
 
1564
            !SACR_DREC(i2s->control[1]);
 
1565
    tfs = (i2s->tx_len || i2s->fifo_len < SACR_TFTH(i2s->control[0])) &&
 
1566
            i2s->enable && !SACR_DPRL(i2s->control[1]);
 
1567
 
 
1568
    qemu_set_irq(i2s->rx_dma, rfs);
 
1569
    qemu_set_irq(i2s->tx_dma, tfs);
 
1570
 
 
1571
    i2s->status &= 0xe0;
 
1572
    if (i2s->fifo_len < 16 || !i2s->enable)
 
1573
        i2s->status |= 1 << 0;                  /* TNF */
 
1574
    if (i2s->rx_len)
 
1575
        i2s->status |= 1 << 1;                  /* RNE */
 
1576
    if (i2s->enable)
 
1577
        i2s->status |= 1 << 2;                  /* BSY */
 
1578
    if (tfs)
 
1579
        i2s->status |= 1 << 3;                  /* TFS */
 
1580
    if (rfs)
 
1581
        i2s->status |= 1 << 4;                  /* RFS */
 
1582
    if (!(i2s->tx_len && i2s->enable))
 
1583
        i2s->status |= i2s->fifo_len << 8;      /* TFL */
 
1584
    i2s->status |= MAX(i2s->rx_len, 0xf) << 12; /* RFL */
 
1585
 
 
1586
    qemu_set_irq(i2s->irq, i2s->status & i2s->mask);
 
1587
}
 
1588
 
 
1589
#define SACR0   0x00    /* Serial Audio Global Control register */
 
1590
#define SACR1   0x04    /* Serial Audio I2S/MSB-Justified Control register */
 
1591
#define SASR0   0x0c    /* Serial Audio Interface and FIFO Status register */
 
1592
#define SAIMR   0x14    /* Serial Audio Interrupt Mask register */
 
1593
#define SAICR   0x18    /* Serial Audio Interrupt Clear register */
 
1594
#define SADIV   0x60    /* Serial Audio Clock Divider register */
 
1595
#define SADR    0x80    /* Serial Audio Data register */
 
1596
 
 
1597
static uint64_t pxa2xx_i2s_read(void *opaque, target_phys_addr_t addr,
 
1598
                                unsigned size)
 
1599
{
 
1600
    PXA2xxI2SState *s = (PXA2xxI2SState *) opaque;
 
1601
 
 
1602
    switch (addr) {
 
1603
    case SACR0:
 
1604
        return s->control[0];
 
1605
    case SACR1:
 
1606
        return s->control[1];
 
1607
    case SASR0:
 
1608
        return s->status;
 
1609
    case SAIMR:
 
1610
        return s->mask;
 
1611
    case SAICR:
 
1612
        return 0;
 
1613
    case SADIV:
 
1614
        return s->clk;
 
1615
    case SADR:
 
1616
        if (s->rx_len > 0) {
 
1617
            s->rx_len --;
 
1618
            pxa2xx_i2s_update(s);
 
1619
            return s->codec_in(s->opaque);
 
1620
        }
 
1621
        return 0;
 
1622
    default:
 
1623
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
1624
        break;
 
1625
    }
 
1626
    return 0;
 
1627
}
 
1628
 
 
1629
static void pxa2xx_i2s_write(void *opaque, target_phys_addr_t addr,
 
1630
                             uint64_t value, unsigned size)
 
1631
{
 
1632
    PXA2xxI2SState *s = (PXA2xxI2SState *) opaque;
 
1633
    uint32_t *sample;
 
1634
 
 
1635
    switch (addr) {
 
1636
    case SACR0:
 
1637
        if (value & (1 << 3))                           /* RST */
 
1638
            pxa2xx_i2s_reset(s);
 
1639
        s->control[0] = value & 0xff3d;
 
1640
        if (!s->enable && (value & 1) && s->tx_len) {   /* ENB */
 
1641
            for (sample = s->fifo; s->fifo_len > 0; s->fifo_len --, sample ++)
 
1642
                s->codec_out(s->opaque, *sample);
 
1643
            s->status &= ~(1 << 7);                     /* I2SOFF */
 
1644
        }
 
1645
        if (value & (1 << 4))                           /* EFWR */
 
1646
            printf("%s: Attempt to use special function\n", __FUNCTION__);
 
1647
        s->enable = (value & 9) == 1;                   /* ENB && !RST*/
 
1648
        pxa2xx_i2s_update(s);
 
1649
        break;
 
1650
    case SACR1:
 
1651
        s->control[1] = value & 0x0039;
 
1652
        if (value & (1 << 5))                           /* ENLBF */
 
1653
            printf("%s: Attempt to use loopback function\n", __FUNCTION__);
 
1654
        if (value & (1 << 4))                           /* DPRL */
 
1655
            s->fifo_len = 0;
 
1656
        pxa2xx_i2s_update(s);
 
1657
        break;
 
1658
    case SAIMR:
 
1659
        s->mask = value & 0x0078;
 
1660
        pxa2xx_i2s_update(s);
 
1661
        break;
 
1662
    case SAICR:
 
1663
        s->status &= ~(value & (3 << 5));
 
1664
        pxa2xx_i2s_update(s);
 
1665
        break;
 
1666
    case SADIV:
 
1667
        s->clk = value & 0x007f;
 
1668
        break;
 
1669
    case SADR:
 
1670
        if (s->tx_len && s->enable) {
 
1671
            s->tx_len --;
 
1672
            pxa2xx_i2s_update(s);
 
1673
            s->codec_out(s->opaque, value);
 
1674
        } else if (s->fifo_len < 16) {
 
1675
            s->fifo[s->fifo_len ++] = value;
 
1676
            pxa2xx_i2s_update(s);
 
1677
        }
 
1678
        break;
 
1679
    default:
 
1680
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
1681
    }
 
1682
}
 
1683
 
 
1684
static const MemoryRegionOps pxa2xx_i2s_ops = {
 
1685
    .read = pxa2xx_i2s_read,
 
1686
    .write = pxa2xx_i2s_write,
 
1687
    .endianness = DEVICE_NATIVE_ENDIAN,
 
1688
};
 
1689
 
 
1690
static const VMStateDescription vmstate_pxa2xx_i2s = {
 
1691
    .name = "pxa2xx_i2s",
 
1692
    .version_id = 0,
 
1693
    .minimum_version_id = 0,
 
1694
    .minimum_version_id_old = 0,
 
1695
    .fields      = (VMStateField[]) {
 
1696
        VMSTATE_UINT32_ARRAY(control, PXA2xxI2SState, 2),
 
1697
        VMSTATE_UINT32(status, PXA2xxI2SState),
 
1698
        VMSTATE_UINT32(mask, PXA2xxI2SState),
 
1699
        VMSTATE_UINT32(clk, PXA2xxI2SState),
 
1700
        VMSTATE_INT32(enable, PXA2xxI2SState),
 
1701
        VMSTATE_INT32(rx_len, PXA2xxI2SState),
 
1702
        VMSTATE_INT32(tx_len, PXA2xxI2SState),
 
1703
        VMSTATE_INT32(fifo_len, PXA2xxI2SState),
 
1704
        VMSTATE_END_OF_LIST()
 
1705
    }
 
1706
};
 
1707
 
 
1708
static void pxa2xx_i2s_data_req(void *opaque, int tx, int rx)
 
1709
{
 
1710
    PXA2xxI2SState *s = (PXA2xxI2SState *) opaque;
 
1711
    uint32_t *sample;
 
1712
 
 
1713
    /* Signal FIFO errors */
 
1714
    if (s->enable && s->tx_len)
 
1715
        s->status |= 1 << 5;            /* TUR */
 
1716
    if (s->enable && s->rx_len)
 
1717
        s->status |= 1 << 6;            /* ROR */
 
1718
 
 
1719
    /* Should be tx - MIN(tx, s->fifo_len) but we don't really need to
 
1720
     * handle the cases where it makes a difference.  */
 
1721
    s->tx_len = tx - s->fifo_len;
 
1722
    s->rx_len = rx;
 
1723
    /* Note that is s->codec_out wasn't set, we wouldn't get called.  */
 
1724
    if (s->enable)
 
1725
        for (sample = s->fifo; s->fifo_len; s->fifo_len --, sample ++)
 
1726
            s->codec_out(s->opaque, *sample);
 
1727
    pxa2xx_i2s_update(s);
 
1728
}
 
1729
 
 
1730
static PXA2xxI2SState *pxa2xx_i2s_init(MemoryRegion *sysmem,
 
1731
                target_phys_addr_t base,
 
1732
                qemu_irq irq, qemu_irq rx_dma, qemu_irq tx_dma)
 
1733
{
 
1734
    PXA2xxI2SState *s = (PXA2xxI2SState *)
 
1735
            g_malloc0(sizeof(PXA2xxI2SState));
 
1736
 
 
1737
    s->irq = irq;
 
1738
    s->rx_dma = rx_dma;
 
1739
    s->tx_dma = tx_dma;
 
1740
    s->data_req = pxa2xx_i2s_data_req;
 
1741
 
 
1742
    pxa2xx_i2s_reset(s);
 
1743
 
 
1744
    memory_region_init_io(&s->iomem, &pxa2xx_i2s_ops, s,
 
1745
                          "pxa2xx-i2s", 0x100000);
 
1746
    memory_region_add_subregion(sysmem, base, &s->iomem);
 
1747
 
 
1748
    vmstate_register(NULL, base, &vmstate_pxa2xx_i2s, s);
 
1749
 
 
1750
    return s;
 
1751
}
 
1752
 
 
1753
/* PXA Fast Infra-red Communications Port */
 
1754
struct PXA2xxFIrState {
 
1755
    MemoryRegion iomem;
 
1756
    qemu_irq irq;
 
1757
    qemu_irq rx_dma;
 
1758
    qemu_irq tx_dma;
 
1759
    int enable;
 
1760
    CharDriverState *chr;
 
1761
 
 
1762
    uint8_t control[3];
 
1763
    uint8_t status[2];
 
1764
 
 
1765
    int rx_len;
 
1766
    int rx_start;
 
1767
    uint8_t rx_fifo[64];
 
1768
};
 
1769
 
 
1770
static void pxa2xx_fir_reset(PXA2xxFIrState *s)
 
1771
{
 
1772
    s->control[0] = 0x00;
 
1773
    s->control[1] = 0x00;
 
1774
    s->control[2] = 0x00;
 
1775
    s->status[0] = 0x00;
 
1776
    s->status[1] = 0x00;
 
1777
    s->enable = 0;
 
1778
}
 
1779
 
 
1780
static inline void pxa2xx_fir_update(PXA2xxFIrState *s)
 
1781
{
 
1782
    static const int tresh[4] = { 8, 16, 32, 0 };
 
1783
    int intr = 0;
 
1784
    if ((s->control[0] & (1 << 4)) &&                   /* RXE */
 
1785
                    s->rx_len >= tresh[s->control[2] & 3])      /* TRIG */
 
1786
        s->status[0] |= 1 << 4;                         /* RFS */
 
1787
    else
 
1788
        s->status[0] &= ~(1 << 4);                      /* RFS */
 
1789
    if (s->control[0] & (1 << 3))                       /* TXE */
 
1790
        s->status[0] |= 1 << 3;                         /* TFS */
 
1791
    else
 
1792
        s->status[0] &= ~(1 << 3);                      /* TFS */
 
1793
    if (s->rx_len)
 
1794
        s->status[1] |= 1 << 2;                         /* RNE */
 
1795
    else
 
1796
        s->status[1] &= ~(1 << 2);                      /* RNE */
 
1797
    if (s->control[0] & (1 << 4))                       /* RXE */
 
1798
        s->status[1] |= 1 << 0;                         /* RSY */
 
1799
    else
 
1800
        s->status[1] &= ~(1 << 0);                      /* RSY */
 
1801
 
 
1802
    intr |= (s->control[0] & (1 << 5)) &&               /* RIE */
 
1803
            (s->status[0] & (1 << 4));                  /* RFS */
 
1804
    intr |= (s->control[0] & (1 << 6)) &&               /* TIE */
 
1805
            (s->status[0] & (1 << 3));                  /* TFS */
 
1806
    intr |= (s->control[2] & (1 << 4)) &&               /* TRAIL */
 
1807
            (s->status[0] & (1 << 6));                  /* EOC */
 
1808
    intr |= (s->control[0] & (1 << 2)) &&               /* TUS */
 
1809
            (s->status[0] & (1 << 1));                  /* TUR */
 
1810
    intr |= s->status[0] & 0x25;                        /* FRE, RAB, EIF */
 
1811
 
 
1812
    qemu_set_irq(s->rx_dma, (s->status[0] >> 4) & 1);
 
1813
    qemu_set_irq(s->tx_dma, (s->status[0] >> 3) & 1);
 
1814
 
 
1815
    qemu_set_irq(s->irq, intr && s->enable);
 
1816
}
 
1817
 
 
1818
#define ICCR0   0x00    /* FICP Control register 0 */
 
1819
#define ICCR1   0x04    /* FICP Control register 1 */
 
1820
#define ICCR2   0x08    /* FICP Control register 2 */
 
1821
#define ICDR    0x0c    /* FICP Data register */
 
1822
#define ICSR0   0x14    /* FICP Status register 0 */
 
1823
#define ICSR1   0x18    /* FICP Status register 1 */
 
1824
#define ICFOR   0x1c    /* FICP FIFO Occupancy Status register */
 
1825
 
 
1826
static uint64_t pxa2xx_fir_read(void *opaque, target_phys_addr_t addr,
 
1827
                                unsigned size)
 
1828
{
 
1829
    PXA2xxFIrState *s = (PXA2xxFIrState *) opaque;
 
1830
    uint8_t ret;
 
1831
 
 
1832
    switch (addr) {
 
1833
    case ICCR0:
 
1834
        return s->control[0];
 
1835
    case ICCR1:
 
1836
        return s->control[1];
 
1837
    case ICCR2:
 
1838
        return s->control[2];
 
1839
    case ICDR:
 
1840
        s->status[0] &= ~0x01;
 
1841
        s->status[1] &= ~0x72;
 
1842
        if (s->rx_len) {
 
1843
            s->rx_len --;
 
1844
            ret = s->rx_fifo[s->rx_start ++];
 
1845
            s->rx_start &= 63;
 
1846
            pxa2xx_fir_update(s);
 
1847
            return ret;
 
1848
        }
 
1849
        printf("%s: Rx FIFO underrun.\n", __FUNCTION__);
 
1850
        break;
 
1851
    case ICSR0:
 
1852
        return s->status[0];
 
1853
    case ICSR1:
 
1854
        return s->status[1] | (1 << 3);                 /* TNF */
 
1855
    case ICFOR:
 
1856
        return s->rx_len;
 
1857
    default:
 
1858
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
1859
        break;
 
1860
    }
 
1861
    return 0;
 
1862
}
 
1863
 
 
1864
static void pxa2xx_fir_write(void *opaque, target_phys_addr_t addr,
 
1865
                             uint64_t value64, unsigned size)
 
1866
{
 
1867
    PXA2xxFIrState *s = (PXA2xxFIrState *) opaque;
 
1868
    uint32_t value = value64;
 
1869
    uint8_t ch;
 
1870
 
 
1871
    switch (addr) {
 
1872
    case ICCR0:
 
1873
        s->control[0] = value;
 
1874
        if (!(value & (1 << 4)))                        /* RXE */
 
1875
            s->rx_len = s->rx_start = 0;
 
1876
        if (!(value & (1 << 3))) {                      /* TXE */
 
1877
            /* Nop */
 
1878
        }
 
1879
        s->enable = value & 1;                          /* ITR */
 
1880
        if (!s->enable)
 
1881
            s->status[0] = 0;
 
1882
        pxa2xx_fir_update(s);
 
1883
        break;
 
1884
    case ICCR1:
 
1885
        s->control[1] = value;
 
1886
        break;
 
1887
    case ICCR2:
 
1888
        s->control[2] = value & 0x3f;
 
1889
        pxa2xx_fir_update(s);
 
1890
        break;
 
1891
    case ICDR:
 
1892
        if (s->control[2] & (1 << 2))                   /* TXP */
 
1893
            ch = value;
 
1894
        else
 
1895
            ch = ~value;
 
1896
        if (s->chr && s->enable && (s->control[0] & (1 << 3)))  /* TXE */
 
1897
            qemu_chr_fe_write(s->chr, &ch, 1);
 
1898
        break;
 
1899
    case ICSR0:
 
1900
        s->status[0] &= ~(value & 0x66);
 
1901
        pxa2xx_fir_update(s);
 
1902
        break;
 
1903
    case ICFOR:
 
1904
        break;
 
1905
    default:
 
1906
        printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
 
1907
    }
 
1908
}
 
1909
 
 
1910
static const MemoryRegionOps pxa2xx_fir_ops = {
 
1911
    .read = pxa2xx_fir_read,
 
1912
    .write = pxa2xx_fir_write,
 
1913
    .endianness = DEVICE_NATIVE_ENDIAN,
 
1914
};
 
1915
 
 
1916
static int pxa2xx_fir_is_empty(void *opaque)
 
1917
{
 
1918
    PXA2xxFIrState *s = (PXA2xxFIrState *) opaque;
 
1919
    return (s->rx_len < 64);
 
1920
}
 
1921
 
 
1922
static void pxa2xx_fir_rx(void *opaque, const uint8_t *buf, int size)
 
1923
{
 
1924
    PXA2xxFIrState *s = (PXA2xxFIrState *) opaque;
 
1925
    if (!(s->control[0] & (1 << 4)))                    /* RXE */
 
1926
        return;
 
1927
 
 
1928
    while (size --) {
 
1929
        s->status[1] |= 1 << 4;                         /* EOF */
 
1930
        if (s->rx_len >= 64) {
 
1931
            s->status[1] |= 1 << 6;                     /* ROR */
 
1932
            break;
 
1933
        }
 
1934
 
 
1935
        if (s->control[2] & (1 << 3))                   /* RXP */
 
1936
            s->rx_fifo[(s->rx_start + s->rx_len ++) & 63] = *(buf ++);
 
1937
        else
 
1938
            s->rx_fifo[(s->rx_start + s->rx_len ++) & 63] = ~*(buf ++);
 
1939
    }
 
1940
 
 
1941
    pxa2xx_fir_update(s);
 
1942
}
 
1943
 
 
1944
static void pxa2xx_fir_event(void *opaque, int event)
 
1945
{
 
1946
}
 
1947
 
 
1948
static void pxa2xx_fir_save(QEMUFile *f, void *opaque)
 
1949
{
 
1950
    PXA2xxFIrState *s = (PXA2xxFIrState *) opaque;
 
1951
    int i;
 
1952
 
 
1953
    qemu_put_be32(f, s->enable);
 
1954
 
 
1955
    qemu_put_8s(f, &s->control[0]);
 
1956
    qemu_put_8s(f, &s->control[1]);
 
1957
    qemu_put_8s(f, &s->control[2]);
 
1958
    qemu_put_8s(f, &s->status[0]);
 
1959
    qemu_put_8s(f, &s->status[1]);
 
1960
 
 
1961
    qemu_put_byte(f, s->rx_len);
 
1962
    for (i = 0; i < s->rx_len; i ++)
 
1963
        qemu_put_byte(f, s->rx_fifo[(s->rx_start + i) & 63]);
 
1964
}
 
1965
 
 
1966
static int pxa2xx_fir_load(QEMUFile *f, void *opaque, int version_id)
 
1967
{
 
1968
    PXA2xxFIrState *s = (PXA2xxFIrState *) opaque;
 
1969
    int i;
 
1970
 
 
1971
    s->enable = qemu_get_be32(f);
 
1972
 
 
1973
    qemu_get_8s(f, &s->control[0]);
 
1974
    qemu_get_8s(f, &s->control[1]);
 
1975
    qemu_get_8s(f, &s->control[2]);
 
1976
    qemu_get_8s(f, &s->status[0]);
 
1977
    qemu_get_8s(f, &s->status[1]);
 
1978
 
 
1979
    s->rx_len = qemu_get_byte(f);
 
1980
    s->rx_start = 0;
 
1981
    for (i = 0; i < s->rx_len; i ++)
 
1982
        s->rx_fifo[i] = qemu_get_byte(f);
 
1983
 
 
1984
    return 0;
 
1985
}
 
1986
 
 
1987
static PXA2xxFIrState *pxa2xx_fir_init(MemoryRegion *sysmem,
 
1988
                target_phys_addr_t base,
 
1989
                qemu_irq irq, qemu_irq rx_dma, qemu_irq tx_dma,
 
1990
                CharDriverState *chr)
 
1991
{
 
1992
    PXA2xxFIrState *s = (PXA2xxFIrState *)
 
1993
            g_malloc0(sizeof(PXA2xxFIrState));
 
1994
 
 
1995
    s->irq = irq;
 
1996
    s->rx_dma = rx_dma;
 
1997
    s->tx_dma = tx_dma;
 
1998
    s->chr = chr;
 
1999
 
 
2000
    pxa2xx_fir_reset(s);
 
2001
 
 
2002
    memory_region_init_io(&s->iomem, &pxa2xx_fir_ops, s, "pxa2xx-fir", 0x1000);
 
2003
    memory_region_add_subregion(sysmem, base, &s->iomem);
 
2004
 
 
2005
    if (chr)
 
2006
        qemu_chr_add_handlers(chr, pxa2xx_fir_is_empty,
 
2007
                        pxa2xx_fir_rx, pxa2xx_fir_event, s);
 
2008
 
 
2009
    register_savevm(NULL, "pxa2xx_fir", 0, 0, pxa2xx_fir_save,
 
2010
                    pxa2xx_fir_load, s);
 
2011
 
 
2012
    return s;
 
2013
}
 
2014
 
 
2015
static void pxa2xx_reset(void *opaque, int line, int level)
 
2016
{
 
2017
    PXA2xxState *s = (PXA2xxState *) opaque;
 
2018
 
 
2019
    if (level && (s->pm_regs[PCFR >> 2] & 0x10)) {      /* GPR_EN */
 
2020
        cpu_reset(s->env);
 
2021
        /* TODO: reset peripherals */
 
2022
    }
 
2023
}
 
2024
 
 
2025
/* Initialise a PXA270 integrated chip (ARM based core).  */
 
2026
PXA2xxState *pxa270_init(MemoryRegion *address_space,
 
2027
                         unsigned int sdram_size, const char *revision)
 
2028
{
 
2029
    PXA2xxState *s;
 
2030
    int i;
 
2031
    DriveInfo *dinfo;
 
2032
    s = (PXA2xxState *) g_malloc0(sizeof(PXA2xxState));
 
2033
 
 
2034
    if (revision && strncmp(revision, "pxa27", 5)) {
 
2035
        fprintf(stderr, "Machine requires a PXA27x processor.\n");
 
2036
        exit(1);
 
2037
    }
 
2038
    if (!revision)
 
2039
        revision = "pxa270";
 
2040
    
 
2041
    s->env = cpu_init(revision);
 
2042
    if (!s->env) {
 
2043
        fprintf(stderr, "Unable to find CPU definition\n");
 
2044
        exit(1);
 
2045
    }
 
2046
    s->reset = qemu_allocate_irqs(pxa2xx_reset, s, 1)[0];
 
2047
 
 
2048
    /* SDRAM & Internal Memory Storage */
 
2049
    memory_region_init_ram(&s->sdram, NULL, "pxa270.sdram", sdram_size);
 
2050
    memory_region_add_subregion(address_space, PXA2XX_SDRAM_BASE, &s->sdram);
 
2051
    memory_region_init_ram(&s->internal, NULL, "pxa270.internal", 0x40000);
 
2052
    memory_region_add_subregion(address_space, PXA2XX_INTERNAL_BASE,
 
2053
                                &s->internal);
 
2054
 
 
2055
    s->pic = pxa2xx_pic_init(0x40d00000, s->env);
 
2056
 
 
2057
    s->dma = pxa27x_dma_init(0x40000000,
 
2058
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_DMA));
 
2059
 
 
2060
    sysbus_create_varargs("pxa27x-timer", 0x40a00000,
 
2061
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 0),
 
2062
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 1),
 
2063
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 2),
 
2064
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 3),
 
2065
                    qdev_get_gpio_in(s->pic, PXA27X_PIC_OST_4_11),
 
2066
                    NULL);
 
2067
 
 
2068
    s->gpio = pxa2xx_gpio_init(0x40e00000, s->env, s->pic, 121);
 
2069
 
 
2070
    dinfo = drive_get(IF_SD, 0, 0);
 
2071
    if (!dinfo) {
 
2072
        fprintf(stderr, "qemu: missing SecureDigital device\n");
 
2073
        exit(1);
 
2074
    }
 
2075
    s->mmc = pxa2xx_mmci_init(0x41100000, dinfo->bdrv,
 
2076
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC),
 
2077
                    qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),
 
2078
                    qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI));
 
2079
 
 
2080
    for (i = 0; pxa270_serial[i].io_base; i++) {
 
2081
        if (serial_hds[i]) {
 
2082
            serial_mm_init(address_space, pxa270_serial[i].io_base, 2,
 
2083
                           qdev_get_gpio_in(s->pic, pxa270_serial[i].irqn),
 
2084
                           14857000 / 16, serial_hds[i],
 
2085
                           DEVICE_NATIVE_ENDIAN);
 
2086
        } else {
 
2087
            break;
 
2088
        }
 
2089
    }
 
2090
    if (serial_hds[i])
 
2091
        s->fir = pxa2xx_fir_init(address_space, 0x40800000,
 
2092
                        qdev_get_gpio_in(s->pic, PXA2XX_PIC_ICP),
 
2093
                        qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_ICP),
 
2094
                        qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_ICP),
 
2095
                        serial_hds[i]);
 
2096
 
 
2097
    s->lcd = pxa2xx_lcdc_init(0x44000000,
 
2098
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_LCD));
 
2099
 
 
2100
    s->cm_base = 0x41300000;
 
2101
    s->cm_regs[CCCR >> 2] = 0x02000210; /* 416.0 MHz */
 
2102
    s->clkcfg = 0x00000009;             /* Turbo mode active */
 
2103
    memory_region_init_io(&s->cm_iomem, &pxa2xx_cm_ops, s, "pxa2xx-cm", 0x1000);
 
2104
    memory_region_add_subregion(address_space, s->cm_base, &s->cm_iomem);
 
2105
    vmstate_register(NULL, 0, &vmstate_pxa2xx_cm, s);
 
2106
 
 
2107
    cpu_arm_set_cp_io(s->env, 14, pxa2xx_cp14_read, pxa2xx_cp14_write, s);
 
2108
 
 
2109
    s->mm_base = 0x48000000;
 
2110
    s->mm_regs[MDMRS >> 2] = 0x00020002;
 
2111
    s->mm_regs[MDREFR >> 2] = 0x03ca4000;
 
2112
    s->mm_regs[MECR >> 2] = 0x00000001; /* Two PC Card sockets */
 
2113
    memory_region_init_io(&s->mm_iomem, &pxa2xx_mm_ops, s, "pxa2xx-mm", 0x1000);
 
2114
    memory_region_add_subregion(address_space, s->mm_base, &s->mm_iomem);
 
2115
    vmstate_register(NULL, 0, &vmstate_pxa2xx_mm, s);
 
2116
 
 
2117
    s->pm_base = 0x40f00000;
 
2118
    memory_region_init_io(&s->pm_iomem, &pxa2xx_pm_ops, s, "pxa2xx-pm", 0x100);
 
2119
    memory_region_add_subregion(address_space, s->pm_base, &s->pm_iomem);
 
2120
    vmstate_register(NULL, 0, &vmstate_pxa2xx_pm, s);
 
2121
 
 
2122
    for (i = 0; pxa27x_ssp[i].io_base; i ++);
 
2123
    s->ssp = (SSIBus **)g_malloc0(sizeof(SSIBus *) * i);
 
2124
    for (i = 0; pxa27x_ssp[i].io_base; i ++) {
 
2125
        DeviceState *dev;
 
2126
        dev = sysbus_create_simple("pxa2xx-ssp", pxa27x_ssp[i].io_base,
 
2127
                        qdev_get_gpio_in(s->pic, pxa27x_ssp[i].irqn));
 
2128
        s->ssp[i] = (SSIBus *)qdev_get_child_bus(dev, "ssi");
 
2129
    }
 
2130
 
 
2131
    if (usb_enabled) {
 
2132
        sysbus_create_simple("sysbus-ohci", 0x4c000000,
 
2133
                        qdev_get_gpio_in(s->pic, PXA2XX_PIC_USBH1));
 
2134
    }
 
2135
 
 
2136
    s->pcmcia[0] = pxa2xx_pcmcia_init(0x20000000);
 
2137
    s->pcmcia[1] = pxa2xx_pcmcia_init(0x30000000);
 
2138
 
 
2139
    sysbus_create_simple("pxa2xx_rtc", 0x40900000,
 
2140
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_RTCALARM));
 
2141
 
 
2142
    s->i2c[0] = pxa2xx_i2c_init(0x40301600,
 
2143
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2C), 0xffff);
 
2144
    s->i2c[1] = pxa2xx_i2c_init(0x40f00100,
 
2145
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_PWRI2C), 0xff);
 
2146
 
 
2147
    s->i2s = pxa2xx_i2s_init(address_space, 0x40400000,
 
2148
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2S),
 
2149
                    qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_I2S),
 
2150
                    qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_I2S));
 
2151
 
 
2152
    s->kp = pxa27x_keypad_init(0x41500000,
 
2153
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_KEYPAD));
 
2154
 
 
2155
    /* GPIO1 resets the processor */
 
2156
    /* The handler can be overridden by board-specific code */
 
2157
    qdev_connect_gpio_out(s->gpio, 1, s->reset);
 
2158
    return s;
 
2159
}
 
2160
 
 
2161
/* Initialise a PXA255 integrated chip (ARM based core).  */
 
2162
PXA2xxState *pxa255_init(MemoryRegion *address_space, unsigned int sdram_size)
 
2163
{
 
2164
    PXA2xxState *s;
 
2165
    int i;
 
2166
    DriveInfo *dinfo;
 
2167
 
 
2168
    s = (PXA2xxState *) g_malloc0(sizeof(PXA2xxState));
 
2169
 
 
2170
    s->env = cpu_init("pxa255");
 
2171
    if (!s->env) {
 
2172
        fprintf(stderr, "Unable to find CPU definition\n");
 
2173
        exit(1);
 
2174
    }
 
2175
    s->reset = qemu_allocate_irqs(pxa2xx_reset, s, 1)[0];
 
2176
 
 
2177
    /* SDRAM & Internal Memory Storage */
 
2178
    memory_region_init_ram(&s->sdram, NULL, "pxa255.sdram", sdram_size);
 
2179
    memory_region_add_subregion(address_space, PXA2XX_SDRAM_BASE, &s->sdram);
 
2180
    memory_region_init_ram(&s->internal, NULL, "pxa255.internal",
 
2181
                           PXA2XX_INTERNAL_SIZE);
 
2182
    memory_region_add_subregion(address_space, PXA2XX_INTERNAL_BASE,
 
2183
                                &s->internal);
 
2184
 
 
2185
    s->pic = pxa2xx_pic_init(0x40d00000, s->env);
 
2186
 
 
2187
    s->dma = pxa255_dma_init(0x40000000,
 
2188
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_DMA));
 
2189
 
 
2190
    sysbus_create_varargs("pxa25x-timer", 0x40a00000,
 
2191
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 0),
 
2192
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 1),
 
2193
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 2),
 
2194
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 3),
 
2195
                    NULL);
 
2196
 
 
2197
    s->gpio = pxa2xx_gpio_init(0x40e00000, s->env, s->pic, 85);
 
2198
 
 
2199
    dinfo = drive_get(IF_SD, 0, 0);
 
2200
    if (!dinfo) {
 
2201
        fprintf(stderr, "qemu: missing SecureDigital device\n");
 
2202
        exit(1);
 
2203
    }
 
2204
    s->mmc = pxa2xx_mmci_init(0x41100000, dinfo->bdrv,
 
2205
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC),
 
2206
                    qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),
 
2207
                    qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI));
 
2208
 
 
2209
    for (i = 0; pxa255_serial[i].io_base; i++) {
 
2210
        if (serial_hds[i]) {
 
2211
            serial_mm_init(address_space, pxa255_serial[i].io_base, 2,
 
2212
                           qdev_get_gpio_in(s->pic, pxa255_serial[i].irqn),
 
2213
                           14745600 / 16, serial_hds[i],
 
2214
                           DEVICE_NATIVE_ENDIAN);
 
2215
        } else {
 
2216
            break;
 
2217
        }
 
2218
    }
 
2219
    if (serial_hds[i])
 
2220
        s->fir = pxa2xx_fir_init(address_space, 0x40800000,
 
2221
                        qdev_get_gpio_in(s->pic, PXA2XX_PIC_ICP),
 
2222
                        qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_ICP),
 
2223
                        qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_ICP),
 
2224
                        serial_hds[i]);
 
2225
 
 
2226
    s->lcd = pxa2xx_lcdc_init(0x44000000,
 
2227
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_LCD));
 
2228
 
 
2229
    s->cm_base = 0x41300000;
 
2230
    s->cm_regs[CCCR >> 2] = 0x02000210; /* 416.0 MHz */
 
2231
    s->clkcfg = 0x00000009;             /* Turbo mode active */
 
2232
    memory_region_init_io(&s->cm_iomem, &pxa2xx_cm_ops, s, "pxa2xx-cm", 0x1000);
 
2233
    memory_region_add_subregion(address_space, s->cm_base, &s->cm_iomem);
 
2234
    vmstate_register(NULL, 0, &vmstate_pxa2xx_cm, s);
 
2235
 
 
2236
    cpu_arm_set_cp_io(s->env, 14, pxa2xx_cp14_read, pxa2xx_cp14_write, s);
 
2237
 
 
2238
    s->mm_base = 0x48000000;
 
2239
    s->mm_regs[MDMRS >> 2] = 0x00020002;
 
2240
    s->mm_regs[MDREFR >> 2] = 0x03ca4000;
 
2241
    s->mm_regs[MECR >> 2] = 0x00000001; /* Two PC Card sockets */
 
2242
    memory_region_init_io(&s->mm_iomem, &pxa2xx_mm_ops, s, "pxa2xx-mm", 0x1000);
 
2243
    memory_region_add_subregion(address_space, s->mm_base, &s->mm_iomem);
 
2244
    vmstate_register(NULL, 0, &vmstate_pxa2xx_mm, s);
 
2245
 
 
2246
    s->pm_base = 0x40f00000;
 
2247
    memory_region_init_io(&s->pm_iomem, &pxa2xx_pm_ops, s, "pxa2xx-pm", 0x100);
 
2248
    memory_region_add_subregion(address_space, s->pm_base, &s->pm_iomem);
 
2249
    vmstate_register(NULL, 0, &vmstate_pxa2xx_pm, s);
 
2250
 
 
2251
    for (i = 0; pxa255_ssp[i].io_base; i ++);
 
2252
    s->ssp = (SSIBus **)g_malloc0(sizeof(SSIBus *) * i);
 
2253
    for (i = 0; pxa255_ssp[i].io_base; i ++) {
 
2254
        DeviceState *dev;
 
2255
        dev = sysbus_create_simple("pxa2xx-ssp", pxa255_ssp[i].io_base,
 
2256
                        qdev_get_gpio_in(s->pic, pxa255_ssp[i].irqn));
 
2257
        s->ssp[i] = (SSIBus *)qdev_get_child_bus(dev, "ssi");
 
2258
    }
 
2259
 
 
2260
    if (usb_enabled) {
 
2261
        sysbus_create_simple("sysbus-ohci", 0x4c000000,
 
2262
                        qdev_get_gpio_in(s->pic, PXA2XX_PIC_USBH1));
 
2263
    }
 
2264
 
 
2265
    s->pcmcia[0] = pxa2xx_pcmcia_init(0x20000000);
 
2266
    s->pcmcia[1] = pxa2xx_pcmcia_init(0x30000000);
 
2267
 
 
2268
    sysbus_create_simple("pxa2xx_rtc", 0x40900000,
 
2269
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_RTCALARM));
 
2270
 
 
2271
    s->i2c[0] = pxa2xx_i2c_init(0x40301600,
 
2272
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2C), 0xffff);
 
2273
    s->i2c[1] = pxa2xx_i2c_init(0x40f00100,
 
2274
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_PWRI2C), 0xff);
 
2275
 
 
2276
    s->i2s = pxa2xx_i2s_init(address_space, 0x40400000,
 
2277
                    qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2S),
 
2278
                    qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_I2S),
 
2279
                    qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_I2S));
 
2280
 
 
2281
    /* GPIO1 resets the processor */
 
2282
    /* The handler can be overridden by board-specific code */
 
2283
    qdev_connect_gpio_out(s->gpio, 1, s->reset);
 
2284
    return s;
 
2285
}
 
2286
 
 
2287
static void pxa2xx_register_devices(void)
 
2288
{
 
2289
    i2c_register_slave(&pxa2xx_i2c_slave_info);
 
2290
    sysbus_register_dev("pxa2xx-ssp", sizeof(PXA2xxSSPState), pxa2xx_ssp_init);
 
2291
    sysbus_register_withprop(&pxa2xx_i2c_info);
 
2292
    sysbus_register_withprop(&pxa2xx_rtc_sysbus_info);
 
2293
}
 
2294
 
 
2295
device_init(pxa2xx_register_devices)