hw/arm/strongarm.c

   1 /*
   2  * StrongARM SA-1100/SA-1110 emulation
   3  *
   4  * Copyright (C) 2011 Dmitry Eremin-Solenikov
   5  *
   6  * Largely based on StrongARM emulation:
   7  * Copyright (c) 2006 Openedhand Ltd.
   8  * Written by Andrzej Zaborowski <[email protected]>
   9  *
  10  * UART code based on QEMU 16550A UART emulation
  11  * Copyright (c) 2003-2004 Fabrice Bellard
  12  * Copyright (c) 2008 Citrix Systems, Inc.
  13  *
  14  *  This program is free software; you can redistribute it and/or modify
  15  *  it under the terms of the GNU General Public License version 2 as
  16  *  published by the Free Software Foundation.
  17  *
  18  *  This program is distributed in the hope that it will be useful,
  19  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *  GNU General Public License for more details.
  22  *
  23  *  You should have received a copy of the GNU General Public License along
  24  *  with this program; if not, see <http://www.gnu.org/licenses/>.
  25  *
  26  *  Contributions after 2012-01-13 are licensed under the terms of the
  27  *  GNU GPL, version 2 or (at your option) any later version.
  28  */
  29 #include "hw/sysbus.h"
  30 #include "strongarm.h"
  31 #include "qemu/error-report.h"
  32 #include "hw/arm/arm.h"
  33 #include "sysemu/char.h"
  34 #include "sysemu/sysemu.h"
  35 #include "hw/ssi.h"
  36
  37 //#define DEBUG
  38
  39 /*
  40  TODO
  41  - Implement cp15, c14 ?
  42  - Implement cp15, c15 !!! (idle used in L)
  43  - Implement idle mode handling/DIM
  44  - Implement sleep mode/Wake sources
  45  - Implement reset control
  46  - Implement memory control regs
  47  - PCMCIA handling
  48  - Maybe support MBGNT/MBREQ
  49  - DMA channels
  50  - GPCLK
  51  - IrDA
  52  - MCP
  53  - Enhance UART with modem signals
  54  */
  55
  56 #ifdef DEBUG
  57 # define DPRINTF(format, ...) printf(format , ## __VA_ARGS__)
  58 #else
  59 # define DPRINTF(format, ...) do { } while (0)
  60 #endif
  61
  62 static struct {
  63     hwaddr io_base;
  64     int irq;
  65 } sa_serial[] = {
  66     { 0x80010000, SA_PIC_UART1 },
  67     { 0x80030000, SA_PIC_UART2 },
  68     { 0x80050000, SA_PIC_UART3 },
  69     { 0, 0 }
  70 };
  71
  72 /* Interrupt Controller */
  73
  74 #define TYPE_STRONGARM_PIC "strongarm_pic"
  75 #define STRONGARM_PIC(obj) \
  76     OBJECT_CHECK(StrongARMPICState, (obj), TYPE_STRONGARM_PIC)
  77
  78 typedef struct StrongARMPICState {
  79     SysBusDevice parent_obj;
  80
  81     MemoryRegion iomem;
  82     qemu_irq    irq;
  83     qemu_irq    fiq;
  84
  85     uint32_t pending;
  86     uint32_t enabled;
  87     uint32_t is_fiq;
  88     uint32_t int_idle;
  89 } StrongARMPICState;
  90
  91 #define ICIP    0x00
  92 #define ICMR    0x04
  93 #define ICLR    0x08
  94 #define ICFP    0x10
  95 #define ICPR    0x20
  96 #define ICCR    0x0c
  97
  98 #define SA_PIC_SRCS     32
  99
 100
 101 static void strongarm_pic_update(void *opaque)
 102 {
 103     StrongARMPICState *s = opaque;
 104
 105     /* FIXME: reflect DIM */
 106     qemu_set_irq(s->fiq, s->pending & s->enabled &  s->is_fiq);
 107     qemu_set_irq(s->irq, s->pending & s->enabled & ~s->is_fiq);
 108 }
 109
 110 static void strongarm_pic_set_irq(void *opaque, int irq, int level)
 111 {
 112     StrongARMPICState *s = opaque;
 113
 114     if (level) {
 115         s->pending |= 1 << irq;
 116     } else {
 117         s->pending &= ~(1 << irq);
 118     }
 119
 120     strongarm_pic_update(s);
 121 }
 122
 123 static uint64_t strongarm_pic_mem_read(void *opaque, hwaddr offset,
 124                                        unsigned size)
 125 {
 126     StrongARMPICState *s = opaque;
 127
 128     switch (offset) {
 129     case ICIP:
 130         return s->pending & ~s->is_fiq & s->enabled;
 131     case ICMR:
 132         return s->enabled;
 133     case ICLR:
 134         return s->is_fiq;
 135     case ICCR:
 136         return s->int_idle == 0;
 137     case ICFP:
 138         return s->pending & s->is_fiq & s->enabled;
 139     case ICPR:
 140         return s->pending;
 141     default:
 142         printf("%s: Bad register offset 0x" TARGET_FMT_plx "\n",
 143                         __func__, offset);
 144         return 0;
 145     }
 146 }
 147
 148 static void strongarm_pic_mem_write(void *opaque, hwaddr offset,
 149                                     uint64_t value, unsigned size)
 150 {
 151     StrongARMPICState *s = opaque;
 152
 153     switch (offset) {
 154     case ICMR:
 155         s->enabled = value;
 156         break;
 157     case ICLR:
 158         s->is_fiq = value;
 159         break;
 160     case ICCR:
 161         s->int_idle = (value & 1) ? 0 : ~0;
 162         break;
 163     default:
 164         printf("%s: Bad register offset 0x" TARGET_FMT_plx "\n",
 165                         __func__, offset);
 166         break;
 167     }
 168     strongarm_pic_update(s);
 169 }
 170
 171 static const MemoryRegionOps strongarm_pic_ops = {
 172     .read = strongarm_pic_mem_read,
 173     .write = strongarm_pic_mem_write,
 174     .endianness = DEVICE_NATIVE_ENDIAN,
 175 };
 176
 177 static int strongarm_pic_initfn(SysBusDevice *sbd)
 178 {
 179     DeviceState *dev = DEVICE(sbd);
 180     StrongARMPICState *s = STRONGARM_PIC(dev);
 181
 182     qdev_init_gpio_in(dev, strongarm_pic_set_irq, SA_PIC_SRCS);
 183     memory_region_init_io(&s->iomem, OBJECT(s), &strongarm_pic_ops, s,
 184                           "pic", 0x1000);
 185     sysbus_init_mmio(sbd, &s->iomem);
 186     sysbus_init_irq(sbd, &s->irq);
 187     sysbus_init_irq(sbd, &s->fiq);
 188
 189     return 0;
 190 }
 191
 192 static int strongarm_pic_post_load(void *opaque, int version_id)
 193 {
 194     strongarm_pic_update(opaque);
 195     return 0;
 196 }
 197
 198 static VMStateDescription vmstate_strongarm_pic_regs = {
 199     .name = "strongarm_pic",
 200     .version_id = 0,
 201     .minimum_version_id = 0,
 202     .minimum_version_id_old = 0,
 203     .post_load = strongarm_pic_post_load,
 204     .fields = (VMStateField[]) {
 205         VMSTATE_UINT32(pending, StrongARMPICState),
 206         VMSTATE_UINT32(enabled, StrongARMPICState),
 207         VMSTATE_UINT32(is_fiq, StrongARMPICState),
 208         VMSTATE_UINT32(int_idle, StrongARMPICState),
 209         VMSTATE_END_OF_LIST(),
 210     },
 211 };
 212
 213 static void strongarm_pic_class_init(ObjectClass *klass, void *data)
 214 {
 215     DeviceClass *dc = DEVICE_CLASS(klass);
 216     SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
 217
 218     k->init = strongarm_pic_initfn;
 219     dc->desc = "StrongARM PIC";
 220     dc->vmsd = &vmstate_strongarm_pic_regs;
 221 }
 222
 223 static const TypeInfo strongarm_pic_info = {
 224     .name          = TYPE_STRONGARM_PIC,
 225     .parent        = TYPE_SYS_BUS_DEVICE,
 226     .instance_size = sizeof(StrongARMPICState),
 227     .class_init    = strongarm_pic_class_init,
 228 };
 229
 230 /* Real-Time Clock */
 231 #define RTAR 0x00 /* RTC Alarm register */
 232 #define RCNR 0x04 /* RTC Counter register */
 233 #define RTTR 0x08 /* RTC Timer Trim register */
 234 #define RTSR 0x10 /* RTC Status register */
 235
 236 #define RTSR_AL (1 << 0) /* RTC Alarm detected */
 237 #define RTSR_HZ (1 << 1) /* RTC 1Hz detected */
 238 #define RTSR_ALE (1 << 2) /* RTC Alarm enable */
 239 #define RTSR_HZE (1 << 3) /* RTC 1Hz enable */
 240
 241 /* 16 LSB of RTTR are clockdiv for internal trim logic,
 242  * trim delete isn't emulated, so
 243  * f = 32 768 / (RTTR_trim + 1) */
 244
 245 #define TYPE_STRONGARM_RTC "strongarm-rtc"
 246 #define STRONGARM_RTC(obj) \
 247     OBJECT_CHECK(StrongARMRTCState, (obj), TYPE_STRONGARM_RTC)
 248
 249 typedef struct StrongARMRTCState {
 250     SysBusDevice parent_obj;
 251
 252     MemoryRegion iomem;
 253     uint32_t rttr;
 254     uint32_t rtsr;
 255     uint32_t rtar;
 256     uint32_t last_rcnr;
 257     int64_t last_hz;
 258     QEMUTimer *rtc_alarm;
 259     QEMUTimer *rtc_hz;
 260     qemu_irq rtc_irq;
 261     qemu_irq rtc_hz_irq;
 262 } StrongARMRTCState;
 263
 264 static inline void strongarm_rtc_int_update(StrongARMRTCState *s)
 265 {
 266     qemu_set_irq(s->rtc_irq, s->rtsr & RTSR_AL);
 267     qemu_set_irq(s->rtc_hz_irq, s->rtsr & RTSR_HZ);
 268 }
 269
 270 static void strongarm_rtc_hzupdate(StrongARMRTCState *s)
 271 {
 272     int64_t rt = qemu_get_clock_ms(rtc_clock);
 273     s->last_rcnr += ((rt - s->last_hz) << 15) /
 274             (1000 * ((s->rttr & 0xffff) + 1));
 275     s->last_hz = rt;
 276 }
 277
 278 static inline void strongarm_rtc_timer_update(StrongARMRTCState *s)
 279 {
 280     if ((s->rtsr & RTSR_HZE) && !(s->rtsr & RTSR_HZ)) {
 281         qemu_mod_timer(s->rtc_hz, s->last_hz + 1000);
 282     } else {
 283         qemu_del_timer(s->rtc_hz);
 284     }
 285
 286     if ((s->rtsr & RTSR_ALE) && !(s->rtsr & RTSR_AL)) {
 287         qemu_mod_timer(s->rtc_alarm, s->last_hz +
 288                 (((s->rtar - s->last_rcnr) * 1000 *
 289                   ((s->rttr & 0xffff) + 1)) >> 15));
 290     } else {
 291         qemu_del_timer(s->rtc_alarm);
 292     }
 293 }
 294
 295 static inline void strongarm_rtc_alarm_tick(void *opaque)
 296 {
 297     StrongARMRTCState *s = opaque;
 298     s->rtsr |= RTSR_AL;
 299     strongarm_rtc_timer_update(s);
 300     strongarm_rtc_int_update(s);
 301 }
 302
 303 static inline void strongarm_rtc_hz_tick(void *opaque)
 304 {
 305     StrongARMRTCState *s = opaque;
 306     s->rtsr |= RTSR_HZ;
 307     strongarm_rtc_timer_update(s);
 308     strongarm_rtc_int_update(s);
 309 }
 310
 311 static uint64_t strongarm_rtc_read(void *opaque, hwaddr addr,
 312                                    unsigned size)
 313 {
 314     StrongARMRTCState *s = opaque;
 315
 316     switch (addr) {
 317     case RTTR:
 318         return s->rttr;
 319     case RTSR:
 320         return s->rtsr;
 321     case RTAR:
 322         return s->rtar;
 323     case RCNR:
 324         return s->last_rcnr +
 325                 ((qemu_get_clock_ms(rtc_clock) - s->last_hz) << 15) /
 326                 (1000 * ((s->rttr & 0xffff) + 1));
 327     default:
 328         printf("%s: Bad register 0x" TARGET_FMT_plx "\n", __func__, addr);
 329         return 0;
 330     }
 331 }
 332
 333 static void strongarm_rtc_write(void *opaque, hwaddr addr,
 334                                 uint64_t value, unsigned size)
 335 {
 336     StrongARMRTCState *s = opaque;
 337     uint32_t old_rtsr;
 338
 339     switch (addr) {
 340     case RTTR:
 341         strongarm_rtc_hzupdate(s);
 342         s->rttr = value;
 343         strongarm_rtc_timer_update(s);
 344         break;
 345
 346     case RTSR:
 347         old_rtsr = s->rtsr;
 348         s->rtsr = (value & (RTSR_ALE | RTSR_HZE)) |
 349                   (s->rtsr & ~(value & (RTSR_AL | RTSR_HZ)));
 350
 351         if (s->rtsr != old_rtsr) {
 352             strongarm_rtc_timer_update(s);
 353         }
 354
 355         strongarm_rtc_int_update(s);
 356         break;
 357
 358     case RTAR:
 359         s->rtar = value;
 360         strongarm_rtc_timer_update(s);
 361         break;
 362
 363     case RCNR:
 364         strongarm_rtc_hzupdate(s);
 365         s->last_rcnr = value;
 366         strongarm_rtc_timer_update(s);
 367         break;
 368
 369     default:
 370         printf("%s: Bad register 0x" TARGET_FMT_plx "\n", __func__, addr);
 371     }
 372 }
 373
 374 static const MemoryRegionOps strongarm_rtc_ops = {
 375     .read = strongarm_rtc_read,
 376     .write = strongarm_rtc_write,
 377     .endianness = DEVICE_NATIVE_ENDIAN,
 378 };
 379
 380 static int strongarm_rtc_init(SysBusDevice *dev)
 381 {
 382     StrongARMRTCState *s = STRONGARM_RTC(dev);
 383     struct tm tm;
 384
 385     s->rttr = 0x0;
 386     s->rtsr = 0;
 387
 388     qemu_get_timedate(&tm, 0);
 389
 390     s->last_rcnr = (uint32_t) mktimegm(&tm);
 391     s->last_hz = qemu_get_clock_ms(rtc_clock);
 392
 393     s->rtc_alarm = qemu_new_timer_ms(rtc_clock, strongarm_rtc_alarm_tick, s);
 394     s->rtc_hz = qemu_new_timer_ms(rtc_clock, strongarm_rtc_hz_tick, s);
 395
 396     sysbus_init_irq(dev, &s->rtc_irq);
 397     sysbus_init_irq(dev, &s->rtc_hz_irq);
 398
 399     memory_region_init_io(&s->iomem, OBJECT(s), &strongarm_rtc_ops, s,
 400                           "rtc", 0x10000);
 401     sysbus_init_mmio(dev, &s->iomem);
 402
 403     return 0;
 404 }
 405
 406 static void strongarm_rtc_pre_save(void *opaque)
 407 {
 408     StrongARMRTCState *s = opaque;
 409
 410     strongarm_rtc_hzupdate(s);
 411 }
 412
 413 static int strongarm_rtc_post_load(void *opaque, int version_id)
 414 {
 415     StrongARMRTCState *s = opaque;
 416
 417     strongarm_rtc_timer_update(s);
 418     strongarm_rtc_int_update(s);
 419
 420     return 0;
 421 }
 422
 423 static const VMStateDescription vmstate_strongarm_rtc_regs = {
 424     .name = "strongarm-rtc",
 425     .version_id = 0,
 426     .minimum_version_id = 0,
 427     .minimum_version_id_old = 0,
 428     .pre_save = strongarm_rtc_pre_save,
 429     .post_load = strongarm_rtc_post_load,
 430     .fields = (VMStateField[]) {
 431         VMSTATE_UINT32(rttr, StrongARMRTCState),
 432         VMSTATE_UINT32(rtsr, StrongARMRTCState),
 433         VMSTATE_UINT32(rtar, StrongARMRTCState),
 434         VMSTATE_UINT32(last_rcnr, StrongARMRTCState),
 435         VMSTATE_INT64(last_hz, StrongARMRTCState),
 436         VMSTATE_END_OF_LIST(),
 437     },
 438 };
 439
 440 static void strongarm_rtc_sysbus_class_init(ObjectClass *klass, void *data)
 441 {
 442     DeviceClass *dc = DEVICE_CLASS(klass);
 443     SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
 444
 445     k->init = strongarm_rtc_init;
 446     dc->desc = "StrongARM RTC Controller";
 447     dc->vmsd = &vmstate_strongarm_rtc_regs;
 448 }
 449
 450 static const TypeInfo strongarm_rtc_sysbus_info = {
 451     .name          = TYPE_STRONGARM_RTC,
 452     .parent        = TYPE_SYS_BUS_DEVICE,
 453     .instance_size = sizeof(StrongARMRTCState),
 454     .class_init    = strongarm_rtc_sysbus_class_init,
 455 };
 456
 457 /* GPIO */
 458 #define GPLR 0x00
 459 #define GPDR 0x04
 460 #define GPSR 0x08
 461 #define GPCR 0x0c
 462 #define GRER 0x10
 463 #define GFER 0x14
 464 #define GEDR 0x18
 465 #define GAFR 0x1c
 466
 467 #define TYPE_STRONGARM_GPIO "strongarm-gpio"
 468 #define STRONGARM_GPIO(obj) \
 469     OBJECT_CHECK(StrongARMGPIOInfo, (obj), TYPE_STRONGARM_GPIO)
 470
 471 typedef struct StrongARMGPIOInfo StrongARMGPIOInfo;
 472 struct StrongARMGPIOInfo {
 473     SysBusDevice busdev;
 474     MemoryRegion iomem;
 475     qemu_irq handler[28];
 476     qemu_irq irqs[11];
 477     qemu_irq irqX;
 478
 479     uint32_t ilevel;
 480     uint32_t olevel;
 481     uint32_t dir;
 482     uint32_t rising;
 483     uint32_t falling;
 484     uint32_t status;
 485     uint32_t gpsr;
 486     uint32_t gafr;
 487
 488     uint32_t prev_level;
 489 };
 490
 491
 492 static void strongarm_gpio_irq_update(StrongARMGPIOInfo *s)
 493 {
 494     int i;
 495     for (i = 0; i < 11; i++) {
 496         qemu_set_irq(s->irqs[i], s->status & (1 << i));
 497     }
 498
 499     qemu_set_irq(s->irqX, (s->status & ~0x7ff));
 500 }
 501
 502 static void strongarm_gpio_set(void *opaque, int line, int level)
 503 {
 504     StrongARMGPIOInfo *s = opaque;
 505     uint32_t mask;
 506
 507     mask = 1 << line;
 508
 509     if (level) {
 510         s->status |= s->rising & mask &
 511                 ~s->ilevel & ~s->dir;
 512         s->ilevel |= mask;
 513     } else {
 514         s->status |= s->falling & mask &
 515                 s->ilevel & ~s->dir;
 516         s->ilevel &= ~mask;
 517     }
 518
 519     if (s->status & mask) {
 520         strongarm_gpio_irq_update(s);
 521     }
 522 }
 523
 524 static void strongarm_gpio_handler_update(StrongARMGPIOInfo *s)
 525 {
 526     uint32_t level, diff;
 527     int bit;
 528
 529     level = s->olevel & s->dir;
 530
 531     for (diff = s->prev_level ^ level; diff; diff ^= 1 << bit) {
 532         bit = ffs(diff) - 1;
 533         qemu_set_irq(s->handler[bit], (level >> bit) & 1);
 534     }
 535
 536     s->prev_level = level;
 537 }
 538
 539 static uint64_t strongarm_gpio_read(void *opaque, hwaddr offset,
 540                                     unsigned size)
 541 {
 542     StrongARMGPIOInfo *s = opaque;
 543
 544     switch (offset) {
 545     case GPDR:        /* GPIO Pin-Direction registers */
 546         return s->dir;
 547
 548     case GPSR:        /* GPIO Pin-Output Set registers */
 549         DPRINTF("%s: Read from a write-only register 0x" TARGET_FMT_plx "\n",
 550                         __func__, offset);
 551         return s->gpsr;    /* Return last written value.  */
 552
 553     case GPCR:        /* GPIO Pin-Output Clear registers */
 554         DPRINTF("%s: Read from a write-only register 0x" TARGET_FMT_plx "\n",
 555                         __func__, offset);
 556         return 31337;        /* Specified as unpredictable in the docs.  */
 557
 558     case GRER:        /* GPIO Rising-Edge Detect Enable registers */
 559         return s->rising;
 560
 561     case GFER:        /* GPIO Falling-Edge Detect Enable registers */
 562         return s->falling;
 563
 564     case GAFR:        /* GPIO Alternate Function registers */
 565         return s->gafr;
 566
 567     case GPLR:        /* GPIO Pin-Level registers */
 568         return (s->olevel & s->dir) |
 569                (s->ilevel & ~s->dir);
 570
 571     case GEDR:        /* GPIO Edge Detect Status registers */
 572         return s->status;
 573
 574     default:
 575         printf("%s: Bad offset 0x" TARGET_FMT_plx "\n", __func__, offset);
 576     }
 577
 578     return 0;
 579 }
 580
 581 static void strongarm_gpio_write(void *opaque, hwaddr offset,
 582                                  uint64_t value, unsigned size)
 583 {
 584     StrongARMGPIOInfo *s = opaque;
 585
 586     switch (offset) {
 587     case GPDR:        /* GPIO Pin-Direction registers */
 588         s->dir = value;
 589         strongarm_gpio_handler_update(s);
 590         break;
 591
 592     case GPSR:        /* GPIO Pin-Output Set registers */
 593         s->olevel |= value;
 594         strongarm_gpio_handler_update(s);
 595         s->gpsr = value;
 596         break;
 597
 598     case GPCR:        /* GPIO Pin-Output Clear registers */
 599         s->olevel &= ~value;
 600         strongarm_gpio_handler_update(s);
 601         break;
 602
 603     case GRER:        /* GPIO Rising-Edge Detect Enable registers */
 604         s->rising = value;
 605         break;
 606
 607     case GFER:        /* GPIO Falling-Edge Detect Enable registers */
 608         s->falling = value;
 609         break;
 610
 611     case GAFR:        /* GPIO Alternate Function registers */
 612         s->gafr = value;
 613         break;
 614
 615     case GEDR:        /* GPIO Edge Detect Status registers */
 616         s->status &= ~value;
 617         strongarm_gpio_irq_update(s);
 618         break;
 619
 620     default:
 621         printf("%s: Bad offset 0x" TARGET_FMT_plx "\n", __func__, offset);
 622     }
 623 }
 624
 625 static const MemoryRegionOps strongarm_gpio_ops = {
 626     .read = strongarm_gpio_read,
 627     .write = strongarm_gpio_write,
 628     .endianness = DEVICE_NATIVE_ENDIAN,
 629 };
 630
 631 static DeviceState *strongarm_gpio_init(hwaddr base,
 632                 DeviceState *pic)
 633 {
 634     DeviceState *dev;
 635     int i;
 636
 637     dev = qdev_create(NULL, TYPE_STRONGARM_GPIO);
 638     qdev_init_nofail(dev);
 639
 640     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
 641     for (i = 0; i < 12; i++)
 642         sysbus_connect_irq(SYS_BUS_DEVICE(dev), i,
 643                     qdev_get_gpio_in(pic, SA_PIC_GPIO0_EDGE + i));
 644
 645     return dev;
 646 }
 647
 648 static int strongarm_gpio_initfn(SysBusDevice *sbd)
 649 {
 650     DeviceState *dev = DEVICE(sbd);
 651     StrongARMGPIOInfo *s = STRONGARM_GPIO(dev);
 652     int i;
 653
 654     qdev_init_gpio_in(dev, strongarm_gpio_set, 28);
 655     qdev_init_gpio_out(dev, s->handler, 28);
 656
 657     memory_region_init_io(&s->iomem, OBJECT(s), &strongarm_gpio_ops, s,
 658                           "gpio", 0x1000);
 659
 660     sysbus_init_mmio(sbd, &s->iomem);
 661     for (i = 0; i < 11; i++) {
 662         sysbus_init_irq(sbd, &s->irqs[i]);
 663     }
 664     sysbus_init_irq(sbd, &s->irqX);
 665
 666     return 0;
 667 }
 668
 669 static const VMStateDescription vmstate_strongarm_gpio_regs = {
 670     .name = "strongarm-gpio",
 671     .version_id = 0,
 672     .minimum_version_id = 0,
 673     .minimum_version_id_old = 0,
 674     .fields = (VMStateField[]) {
 675         VMSTATE_UINT32(ilevel, StrongARMGPIOInfo),
 676         VMSTATE_UINT32(olevel, StrongARMGPIOInfo),
 677         VMSTATE_UINT32(dir, StrongARMGPIOInfo),
 678         VMSTATE_UINT32(rising, StrongARMGPIOInfo),
 679         VMSTATE_UINT32(falling, StrongARMGPIOInfo),
 680         VMSTATE_UINT32(status, StrongARMGPIOInfo),
 681         VMSTATE_UINT32(gafr, StrongARMGPIOInfo),
 682         VMSTATE_END_OF_LIST(),
 683     },
 684 };
 685
 686 static void strongarm_gpio_class_init(ObjectClass *klass, void *data)
 687 {
 688     DeviceClass *dc = DEVICE_CLASS(klass);
 689     SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
 690
 691     k->init = strongarm_gpio_initfn;
 692     dc->desc = "StrongARM GPIO controller";
 693 }
 694
 695 static const TypeInfo strongarm_gpio_info = {
 696     .name          = TYPE_STRONGARM_GPIO,
 697     .parent        = TYPE_SYS_BUS_DEVICE,
 698     .instance_size = sizeof(StrongARMGPIOInfo),
 699     .class_init    = strongarm_gpio_class_init,
 700 };
 701
 702 /* Peripheral Pin Controller */
 703 #define PPDR 0x00
 704 #define PPSR 0x04
 705 #define PPAR 0x08
 706 #define PSDR 0x0c
 707 #define PPFR 0x10
 708
 709 #define TYPE_STRONGARM_PPC "strongarm-ppc"
 710 #define STRONGARM_PPC(obj) \
 711     OBJECT_CHECK(StrongARMPPCInfo, (obj), TYPE_STRONGARM_PPC)
 712
 713 typedef struct StrongARMPPCInfo StrongARMPPCInfo;
 714 struct StrongARMPPCInfo {
 715     SysBusDevice parent_obj;
 716
 717     MemoryRegion iomem;
 718     qemu_irq handler[28];
 719
 720     uint32_t ilevel;
 721     uint32_t olevel;
 722     uint32_t dir;
 723     uint32_t ppar;
 724     uint32_t psdr;
 725     uint32_t ppfr;
 726
 727     uint32_t prev_level;
 728 };
 729
 730 static void strongarm_ppc_set(void *opaque, int line, int level)
 731 {
 732     StrongARMPPCInfo *s = opaque;
 733
 734     if (level) {
 735         s->ilevel |= 1 << line;
 736     } else {
 737         s->ilevel &= ~(1 << line);
 738     }
 739 }
 740
 741 static void strongarm_ppc_handler_update(StrongARMPPCInfo *s)
 742 {
 743     uint32_t level, diff;
 744     int bit;
 745
 746     level = s->olevel & s->dir;
 747
 748     for (diff = s->prev_level ^ level; diff; diff ^= 1 << bit) {
 749         bit = ffs(diff) - 1;
 750         qemu_set_irq(s->handler[bit], (level >> bit) & 1);
 751     }
 752
 753     s->prev_level = level;
 754 }
 755
 756 static uint64_t strongarm_ppc_read(void *opaque, hwaddr offset,
 757                                    unsigned size)
 758 {
 759     StrongARMPPCInfo *s = opaque;
 760
 761     switch (offset) {
 762     case PPDR:        /* PPC Pin Direction registers */
 763         return s->dir | ~0x3fffff;
 764
 765     case PPSR:        /* PPC Pin State registers */
 766         return (s->olevel & s->dir) |
 767                (s->ilevel & ~s->dir) |
 768                ~0x3fffff;
 769
 770     case PPAR:
 771         return s->ppar | ~0x41000;
 772
 773     case PSDR:
 774         return s->psdr;
 775
 776     case PPFR:
 777         return s->ppfr | ~0x7f001;
 778
 779     default:
 780         printf("%s: Bad offset 0x" TARGET_FMT_plx "\n", __func__, offset);
 781     }
 782
 783     return 0;
 784 }
 785
 786 static void strongarm_ppc_write(void *opaque, hwaddr offset,
 787                                 uint64_t value, unsigned size)
 788 {
 789     StrongARMPPCInfo *s = opaque;
 790
 791     switch (offset) {
 792     case PPDR:        /* PPC Pin Direction registers */
 793         s->dir = value & 0x3fffff;
 794         strongarm_ppc_handler_update(s);
 795         break;
 796
 797     case PPSR:        /* PPC Pin State registers */
 798         s->olevel = value & s->dir & 0x3fffff;
 799         strongarm_ppc_handler_update(s);
 800         break;
 801
 802     case PPAR:
 803         s->ppar = value & 0x41000;
 804         break;
 805
 806     case PSDR:
 807         s->psdr = value & 0x3fffff;
 808         break;
 809
 810     case PPFR:
 811         s->ppfr = value & 0x7f001;
 812         break;
 813
 814     default:
 815         printf("%s: Bad offset 0x" TARGET_FMT_plx "\n", __func__, offset);
 816     }
 817 }
 818
 819 static const MemoryRegionOps strongarm_ppc_ops = {
 820     .read = strongarm_ppc_read,
 821     .write = strongarm_ppc_write,
 822     .endianness = DEVICE_NATIVE_ENDIAN,
 823 };
 824
 825 static int strongarm_ppc_init(SysBusDevice *sbd)
 826 {
 827     DeviceState *dev = DEVICE(sbd);
 828     StrongARMPPCInfo *s = STRONGARM_PPC(dev);
 829
 830     qdev_init_gpio_in(dev, strongarm_ppc_set, 22);
 831     qdev_init_gpio_out(dev, s->handler, 22);
 832
 833     memory_region_init_io(&s->iomem, OBJECT(s), &strongarm_ppc_ops, s,
 834                           "ppc", 0x1000);
 835
 836     sysbus_init_mmio(sbd, &s->iomem);
 837
 838     return 0;
 839 }
 840
 841 static const VMStateDescription vmstate_strongarm_ppc_regs = {
 842     .name = "strongarm-ppc",
 843     .version_id = 0,
 844     .minimum_version_id = 0,
 845     .minimum_version_id_old = 0,
 846     .fields = (VMStateField[]) {
 847         VMSTATE_UINT32(ilevel, StrongARMPPCInfo),
 848         VMSTATE_UINT32(olevel, StrongARMPPCInfo),
 849         VMSTATE_UINT32(dir, StrongARMPPCInfo),
 850         VMSTATE_UINT32(ppar, StrongARMPPCInfo),
 851         VMSTATE_UINT32(psdr, StrongARMPPCInfo),
 852         VMSTATE_UINT32(ppfr, StrongARMPPCInfo),
 853         VMSTATE_END_OF_LIST(),
 854     },
 855 };
 856
 857 static void strongarm_ppc_class_init(ObjectClass *klass, void *data)
 858 {
 859     DeviceClass *dc = DEVICE_CLASS(klass);
 860     SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
 861
 862     k->init = strongarm_ppc_init;
 863     dc->desc = "StrongARM PPC controller";
 864 }
 865
 866 static const TypeInfo strongarm_ppc_info = {
 867     .name          = TYPE_STRONGARM_PPC,
 868     .parent        = TYPE_SYS_BUS_DEVICE,
 869     .instance_size = sizeof(StrongARMPPCInfo),
 870     .class_init    = strongarm_ppc_class_init,
 871 };
 872
 873 /* UART Ports */
 874 #define UTCR0 0x00
 875 #define UTCR1 0x04
 876 #define UTCR2 0x08
 877 #define UTCR3 0x0c
 878 #define UTDR  0x14
 879 #define UTSR0 0x1c
 880 #define UTSR1 0x20
 881
 882 #define UTCR0_PE  (1 << 0) /* Parity enable */
 883 #define UTCR0_OES (1 << 1) /* Even parity */
 884 #define UTCR0_SBS (1 << 2) /* 2 stop bits */
 885 #define UTCR0_DSS (1 << 3) /* 8-bit data */
 886
 887 #define UTCR3_RXE (1 << 0) /* Rx enable */
 888 #define UTCR3_TXE (1 << 1) /* Tx enable */
 889 #define UTCR3_BRK (1 << 2) /* Force Break */
 890 #define UTCR3_RIE (1 << 3) /* Rx int enable */
 891 #define UTCR3_TIE (1 << 4) /* Tx int enable */
 892 #define UTCR3_LBM (1 << 5) /* Loopback */
 893
 894 #define UTSR0_TFS (1 << 0) /* Tx FIFO nearly empty */
 895 #define UTSR0_RFS (1 << 1) /* Rx FIFO nearly full */
 896 #define UTSR0_RID (1 << 2) /* Receiver Idle */
 897 #define UTSR0_RBB (1 << 3) /* Receiver begin break */
 898 #define UTSR0_REB (1 << 4) /* Receiver end break */
 899 #define UTSR0_EIF (1 << 5) /* Error in FIFO */
 900
 901 #define UTSR1_RNE (1 << 1) /* Receive FIFO not empty */
 902 #define UTSR1_TNF (1 << 2) /* Transmit FIFO not full */
 903 #define UTSR1_PRE (1 << 3) /* Parity error */
 904 #define UTSR1_FRE (1 << 4) /* Frame error */
 905 #define UTSR1_ROR (1 << 5) /* Receive Over Run */
 906
 907 #define RX_FIFO_PRE (1 << 8)
 908 #define RX_FIFO_FRE (1 << 9)
 909 #define RX_FIFO_ROR (1 << 10)
 910
 911 typedef struct {
 912     SysBusDevice busdev;
 913     MemoryRegion iomem;
 914     CharDriverState *chr;
 915     qemu_irq irq;
 916
 917     uint8_t utcr0;
 918     uint16_t brd;
 919     uint8_t utcr3;
 920     uint8_t utsr0;
 921     uint8_t utsr1;
 922
 923     uint8_t tx_fifo[8];
 924     uint8_t tx_start;
 925     uint8_t tx_len;
 926     uint16_t rx_fifo[12]; /* value + error flags in high bits */
 927     uint8_t rx_start;
 928     uint8_t rx_len;
 929
 930     uint64_t char_transmit_time; /* time to transmit a char in ticks*/
 931     bool wait_break_end;
 932     QEMUTimer *rx_timeout_timer;
 933     QEMUTimer *tx_timer;
 934 } StrongARMUARTState;
 935
 936 static void strongarm_uart_update_status(StrongARMUARTState *s)
 937 {
 938     uint16_t utsr1 = 0;
 939
 940     if (s->tx_len != 8) {
 941         utsr1 |= UTSR1_TNF;
 942     }
 943
 944     if (s->rx_len != 0) {
 945         uint16_t ent = s->rx_fifo[s->rx_start];
 946
 947         utsr1 |= UTSR1_RNE;
 948         if (ent & RX_FIFO_PRE) {
 949             s->utsr1 |= UTSR1_PRE;
 950         }
 951         if (ent & RX_FIFO_FRE) {
 952             s->utsr1 |= UTSR1_FRE;
 953         }
 954         if (ent & RX_FIFO_ROR) {
 955             s->utsr1 |= UTSR1_ROR;
 956         }
 957     }
 958
 959     s->utsr1 = utsr1;
 960 }
 961
 962 static void strongarm_uart_update_int_status(StrongARMUARTState *s)
 963 {
 964     uint16_t utsr0 = s->utsr0 &
 965             (UTSR0_REB | UTSR0_RBB | UTSR0_RID);
 966     int i;
 967
 968     if ((s->utcr3 & UTCR3_TXE) &&
 969                 (s->utcr3 & UTCR3_TIE) &&
 970                 s->tx_len <= 4) {
 971         utsr0 |= UTSR0_TFS;
 972     }
 973
 974     if ((s->utcr3 & UTCR3_RXE) &&
 975                 (s->utcr3 & UTCR3_RIE) &&
 976                 s->rx_len > 4) {
 977         utsr0 |= UTSR0_RFS;
 978     }
 979
 980     for (i = 0; i < s->rx_len && i < 4; i++)
 981         if (s->rx_fifo[(s->rx_start + i) % 12] & ~0xff) {
 982             utsr0 |= UTSR0_EIF;
 983             break;
 984         }
 985
 986     s->utsr0 = utsr0;
 987     qemu_set_irq(s->irq, utsr0);
 988 }
 989
 990 static void strongarm_uart_update_parameters(StrongARMUARTState *s)
 991 {
 992     int speed, parity, data_bits, stop_bits, frame_size;
 993     QEMUSerialSetParams ssp;
 994
 995     /* Start bit. */
 996     frame_size = 1;
 997     if (s->utcr0 & UTCR0_PE) {
 998         /* Parity bit. */
 999         frame_size++;
1000         if (s->utcr0 & UTCR0_OES) {
1001             parity = 'E';
1002         } else {
1003             parity = 'O';
1004         }
1005     } else {
1006             parity = 'N';
1007     }
1008     if (s->utcr0 & UTCR0_SBS) {
1009         stop_bits = 2;
1010     } else {
1011         stop_bits = 1;
1012     }
1013
1014     data_bits = (s->utcr0 & UTCR0_DSS) ? 8 : 7;
1015     frame_size += data_bits + stop_bits;
1016     speed = 3686400 / 16 / (s->brd + 1);
1017     ssp.speed = speed;
1018     ssp.parity = parity;
1019     ssp.data_bits = data_bits;
1020     ssp.stop_bits = stop_bits;
1021     s->char_transmit_time =  (get_ticks_per_sec() / speed) * frame_size;
1022     if (s->chr) {
1023         qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_SERIAL_SET_PARAMS, &ssp);
1024     }
1025
1026     DPRINTF(stderr, "%s speed=%d parity=%c data=%d stop=%d\n", s->chr->label,
1027             speed, parity, data_bits, stop_bits);
1028 }
1029
1030 static void strongarm_uart_rx_to(void *opaque)
1031 {
1032     StrongARMUARTState *s = opaque;
1033
1034     if (s->rx_len) {
1035         s->utsr0 |= UTSR0_RID;
1036         strongarm_uart_update_int_status(s);
1037     }
1038 }
1039
1040 static void strongarm_uart_rx_push(StrongARMUARTState *s, uint16_t c)
1041 {
1042     if ((s->utcr3 & UTCR3_RXE) == 0) {
1043         /* rx disabled */
1044         return;
1045     }
1046
1047     if (s->wait_break_end) {
1048         s->utsr0 |= UTSR0_REB;
1049         s->wait_break_end = false;
1050     }
1051
1052     if (s->rx_len < 12) {
1053         s->rx_fifo[(s->rx_start + s->rx_len) % 12] = c;
1054         s->rx_len++;
1055     } else
1056         s->rx_fifo[(s->rx_start + 11) % 12] |= RX_FIFO_ROR;
1057 }
1058
1059 static int strongarm_uart_can_receive(void *opaque)
1060 {
1061     StrongARMUARTState *s = opaque;
1062
1063     if (s->rx_len == 12) {
1064         return 0;
1065     }
1066     /* It's best not to get more than 2/3 of RX FIFO, so advertise that much */
1067     if (s->rx_len < 8) {
1068         return 8 - s->rx_len;
1069     }
1070     return 1;
1071 }
1072
1073 static void strongarm_uart_receive(void *opaque, const uint8_t *buf, int size)
1074 {
1075     StrongARMUARTState *s = opaque;
1076     int i;
1077
1078     for (i = 0; i < size; i++) {
1079         strongarm_uart_rx_push(s, buf[i]);
1080     }
1081
1082     /* call the timeout receive callback in 3 char transmit time */
1083     qemu_mod_timer(s->rx_timeout_timer,
1084                     qemu_get_clock_ns(vm_clock) + s->char_transmit_time * 3);
1085
1086     strongarm_uart_update_status(s);
1087     strongarm_uart_update_int_status(s);
1088 }
1089
1090 static void strongarm_uart_event(void *opaque, int event)
1091 {
1092     StrongARMUARTState *s = opaque;
1093     if (event == CHR_EVENT_BREAK) {
1094         s->utsr0 |= UTSR0_RBB;
1095         strongarm_uart_rx_push(s, RX_FIFO_FRE);
1096         s->wait_break_end = true;
1097         strongarm_uart_update_status(s);
1098         strongarm_uart_update_int_status(s);
1099     }
1100 }
1101
1102 static void strongarm_uart_tx(void *opaque)
1103 {
1104     StrongARMUARTState *s = opaque;
1105     uint64_t new_xmit_ts = qemu_get_clock_ns(vm_clock);
1106
1107     if (s->utcr3 & UTCR3_LBM) /* loopback */ {
1108         strongarm_uart_receive(s, &s->tx_fifo[s->tx_start], 1);
1109     } else if (s->chr) {
1110         qemu_chr_fe_write(s->chr, &s->tx_fifo[s->tx_start], 1);
1111     }
1112
1113     s->tx_start = (s->tx_start + 1) % 8;
1114     s->tx_len--;
1115     if (s->tx_len) {
1116         qemu_mod_timer(s->tx_timer, new_xmit_ts + s->char_transmit_time);
1117     }
1118     strongarm_uart_update_status(s);
1119     strongarm_uart_update_int_status(s);
1120 }
1121
1122 static uint64_t strongarm_uart_read(void *opaque, hwaddr addr,
1123                                     unsigned size)
1124 {
1125     StrongARMUARTState *s = opaque;
1126     uint16_t ret;
1127
1128     switch (addr) {
1129     case UTCR0:
1130         return s->utcr0;
1131
1132     case UTCR1:
1133         return s->brd >> 8;
1134
1135     case UTCR2:
1136         return s->brd & 0xff;
1137
1138     case UTCR3:
1139         return s->utcr3;
1140
1141     case UTDR:
1142         if (s->rx_len != 0) {
1143             ret = s->rx_fifo[s->rx_start];
1144             s->rx_start = (s->rx_start + 1) % 12;
1145             s->rx_len--;
1146             strongarm_uart_update_status(s);
1147             strongarm_uart_update_int_status(s);
1148             return ret;
1149         }
1150         return 0;
1151
1152     case UTSR0:
1153         return s->utsr0;
1154
1155     case UTSR1:
1156         return s->utsr1;
1157
1158     default:
1159         printf("%s: Bad register 0x" TARGET_FMT_plx "\n", __func__, addr);
1160         return 0;
1161     }
1162 }
1163
1164 static void strongarm_uart_write(void *opaque, hwaddr addr,
1165                                  uint64_t value, unsigned size)
1166 {
1167     StrongARMUARTState *s = opaque;
1168
1169     switch (addr) {
1170     case UTCR0:
1171         s->utcr0 = value & 0x7f;
1172         strongarm_uart_update_parameters(s);
1173         break;
1174
1175     case UTCR1:
1176         s->brd = (s->brd & 0xff) | ((value & 0xf) << 8);
1177         strongarm_uart_update_parameters(s);
1178         break;
1179
1180     case UTCR2:
1181         s->brd = (s->brd & 0xf00) | (value & 0xff);
1182         strongarm_uart_update_parameters(s);
1183         break;
1184
1185     case UTCR3:
1186         s->utcr3 = value & 0x3f;
1187         if ((s->utcr3 & UTCR3_RXE) == 0) {
1188             s->rx_len = 0;
1189         }
1190         if ((s->utcr3 & UTCR3_TXE) == 0) {
1191             s->tx_len = 0;
1192         }
1193         strongarm_uart_update_status(s);
1194         strongarm_uart_update_int_status(s);
1195         break;
1196
1197     case UTDR:
1198         if ((s->utcr3 & UTCR3_TXE) && s->tx_len != 8) {
1199             s->tx_fifo[(s->tx_start + s->tx_len) % 8] = value;
1200             s->tx_len++;
1201             strongarm_uart_update_status(s);
1202             strongarm_uart_update_int_status(s);
1203             if (s->tx_len == 1) {
1204                 strongarm_uart_tx(s);
1205             }
1206         }
1207         break;
1208
1209     case UTSR0:
1210         s->utsr0 = s->utsr0 & ~(value &
1211                 (UTSR0_REB | UTSR0_RBB | UTSR0_RID));
1212         strongarm_uart_update_int_status(s);
1213         break;
1214
1215     default:
1216         printf("%s: Bad register 0x" TARGET_FMT_plx "\n", __func__, addr);
1217     }
1218 }
1219
1220 static const MemoryRegionOps strongarm_uart_ops = {
1221     .read = strongarm_uart_read,
1222     .write = strongarm_uart_write,
1223     .endianness = DEVICE_NATIVE_ENDIAN,
1224 };
1225
1226 static int strongarm_uart_init(SysBusDevice *dev)
1227 {
1228     StrongARMUARTState *s = FROM_SYSBUS(StrongARMUARTState, dev);
1229
1230     memory_region_init_io(&s->iomem, OBJECT(s), &strongarm_uart_ops, s,
1231                           "uart", 0x10000);
1232     sysbus_init_mmio(dev, &s->iomem);
1233     sysbus_init_irq(dev, &s->irq);
1234
1235     s->rx_timeout_timer = qemu_new_timer_ns(vm_clock, strongarm_uart_rx_to, s);
1236     s->tx_timer = qemu_new_timer_ns(vm_clock, strongarm_uart_tx, s);
1237
1238     if (s->chr) {
1239         qemu_chr_add_handlers(s->chr,
1240                         strongarm_uart_can_receive,
1241                         strongarm_uart_receive,
1242                         strongarm_uart_event,
1243                         s);
1244     }
1245
1246     return 0;
1247 }
1248
1249 static void strongarm_uart_reset(DeviceState *dev)
1250 {
1251     StrongARMUARTState *s = DO_UPCAST(StrongARMUARTState, busdev.qdev, dev);
1252
1253     s->utcr0 = UTCR0_DSS; /* 8 data, no parity */
1254     s->brd = 23;    /* 9600 */
1255     /* enable send & recv - this actually violates spec */
1256     s->utcr3 = UTCR3_TXE | UTCR3_RXE;
1257
1258     s->rx_len = s->tx_len = 0;
1259
1260     strongarm_uart_update_parameters(s);
1261     strongarm_uart_update_status(s);
1262     strongarm_uart_update_int_status(s);
1263 }
1264
1265 static int strongarm_uart_post_load(void *opaque, int version_id)
1266 {
1267     StrongARMUARTState *s = opaque;
1268
1269     strongarm_uart_update_parameters(s);
1270     strongarm_uart_update_status(s);
1271     strongarm_uart_update_int_status(s);
1272
1273     /* tx and restart timer */
1274     if (s->tx_len) {
1275         strongarm_uart_tx(s);
1276     }
1277
1278     /* restart rx timeout timer */
1279     if (s->rx_len) {
1280         qemu_mod_timer(s->rx_timeout_timer,
1281                 qemu_get_clock_ns(vm_clock) + s->char_transmit_time * 3);
1282     }
1283
1284     return 0;
1285 }
1286
1287 static const VMStateDescription vmstate_strongarm_uart_regs = {
1288     .name = "strongarm-uart",
1289     .version_id = 0,
1290     .minimum_version_id = 0,
1291     .minimum_version_id_old = 0,
1292     .post_load = strongarm_uart_post_load,
1293     .fields = (VMStateField[]) {
1294         VMSTATE_UINT8(utcr0, StrongARMUARTState),
1295         VMSTATE_UINT16(brd, StrongARMUARTState),
1296         VMSTATE_UINT8(utcr3, StrongARMUARTState),
1297         VMSTATE_UINT8(utsr0, StrongARMUARTState),
1298         VMSTATE_UINT8_ARRAY(tx_fifo, StrongARMUARTState, 8),
1299         VMSTATE_UINT8(tx_start, StrongARMUARTState),
1300         VMSTATE_UINT8(tx_len, StrongARMUARTState),
1301         VMSTATE_UINT16_ARRAY(rx_fifo, StrongARMUARTState, 12),
1302         VMSTATE_UINT8(rx_start, StrongARMUARTState),
1303         VMSTATE_UINT8(rx_len, StrongARMUARTState),
1304         VMSTATE_BOOL(wait_break_end, StrongARMUARTState),
1305         VMSTATE_END_OF_LIST(),
1306     },
1307 };
1308
1309 static Property strongarm_uart_properties[] = {
1310     DEFINE_PROP_CHR("chardev", StrongARMUARTState, chr),
1311     DEFINE_PROP_END_OF_LIST(),
1312 };
1313
1314 static void strongarm_uart_class_init(ObjectClass *klass, void *data)
1315 {
1316     DeviceClass *dc = DEVICE_CLASS(klass);
1317     SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
1318
1319     k->init = strongarm_uart_init;
1320     dc->desc = "StrongARM UART controller";
1321     dc->reset = strongarm_uart_reset;
1322     dc->vmsd = &vmstate_strongarm_uart_regs;
1323     dc->props = strongarm_uart_properties;
1324 }
1325
1326 static const TypeInfo strongarm_uart_info = {
1327     .name          = "strongarm-uart",
1328     .parent        = TYPE_SYS_BUS_DEVICE,
1329     .instance_size = sizeof(StrongARMUARTState),
1330     .class_init    = strongarm_uart_class_init,
1331 };
1332
1333 /* Synchronous Serial Ports */
1334 typedef struct {
1335     SysBusDevice busdev;
1336     MemoryRegion iomem;
1337     qemu_irq irq;
1338     SSIBus *bus;
1339
1340     uint16_t sscr[2];
1341     uint16_t sssr;
1342
1343     uint16_t rx_fifo[8];
1344     uint8_t rx_level;
1345     uint8_t rx_start;
1346 } StrongARMSSPState;
1347
1348 #define SSCR0 0x60 /* SSP Control register 0 */
1349 #define SSCR1 0x64 /* SSP Control register 1 */
1350 #define SSDR  0x6c /* SSP Data register */
1351 #define SSSR  0x74 /* SSP Status register */
1352
1353 /* Bitfields for above registers */
1354 #define SSCR0_SPI(x)    (((x) & 0x30) == 0x00)
1355 #define SSCR0_SSP(x)    (((x) & 0x30) == 0x10)
1356 #define SSCR0_UWIRE(x)  (((x) & 0x30) == 0x20)
1357 #define SSCR0_PSP(x)    (((x) & 0x30) == 0x30)
1358 #define SSCR0_SSE       (1 << 7)
1359 #define SSCR0_DSS(x)    (((x) & 0xf) + 1)
1360 #define SSCR1_RIE       (1 << 0)
1361 #define SSCR1_TIE       (1 << 1)
1362 #define SSCR1_LBM       (1 << 2)
1363 #define SSSR_TNF        (1 << 2)
1364 #define SSSR_RNE        (1 << 3)
1365 #define SSSR_TFS        (1 << 5)
1366 #define SSSR_RFS        (1 << 6)
1367 #define SSSR_ROR        (1 << 7)
1368 #define SSSR_RW         0x0080
1369
1370 static void strongarm_ssp_int_update(StrongARMSSPState *s)
1371 {
1372     int level = 0;
1373
1374     level |= (s->sssr & SSSR_ROR);
1375     level |= (s->sssr & SSSR_RFS)  &&  (s->sscr[1] & SSCR1_RIE);
1376     level |= (s->sssr & SSSR_TFS)  &&  (s->sscr[1] & SSCR1_TIE);
1377     qemu_set_irq(s->irq, level);
1378 }
1379
1380 static void strongarm_ssp_fifo_update(StrongARMSSPState *s)
1381 {
1382     s->sssr &= ~SSSR_TFS;
1383     s->sssr &= ~SSSR_TNF;
1384     if (s->sscr[0] & SSCR0_SSE) {
1385         if (s->rx_level >= 4) {
1386             s->sssr |= SSSR_RFS;
1387         } else {
1388             s->sssr &= ~SSSR_RFS;
1389         }
1390         if (s->rx_level) {
1391             s->sssr |= SSSR_RNE;
1392         } else {
1393             s->sssr &= ~SSSR_RNE;
1394         }
1395         /* TX FIFO is never filled, so it is always in underrun
1396            condition if SSP is enabled */
1397         s->sssr |= SSSR_TFS;
1398         s->sssr |= SSSR_TNF;
1399     }
1400
1401     strongarm_ssp_int_update(s);
1402 }
1403
1404 static uint64_t strongarm_ssp_read(void *opaque, hwaddr addr,
1405                                    unsigned size)
1406 {
1407     StrongARMSSPState *s = opaque;
1408     uint32_t retval;
1409
1410     switch (addr) {
1411     case SSCR0:
1412         return s->sscr[0];
1413     case SSCR1:
1414         return s->sscr[1];
1415     case SSSR:
1416         return s->sssr;
1417     case SSDR:
1418         if (~s->sscr[0] & SSCR0_SSE) {
1419             return 0xffffffff;
1420         }
1421         if (s->rx_level < 1) {
1422             printf("%s: SSP Rx Underrun\n", __func__);
1423             return 0xffffffff;
1424         }
1425         s->rx_level--;
1426         retval = s->rx_fifo[s->rx_start++];
1427         s->rx_start &= 0x7;
1428         strongarm_ssp_fifo_update(s);
1429         return retval;
1430     default:
1431         printf("%s: Bad register 0x" TARGET_FMT_plx "\n", __func__, addr);
1432         break;
1433     }
1434     return 0;
1435 }
1436
1437 static void strongarm_ssp_write(void *opaque, hwaddr addr,
1438                                 uint64_t value, unsigned size)
1439 {
1440     StrongARMSSPState *s = opaque;
1441
1442     switch (addr) {
1443     case SSCR0:
1444         s->sscr[0] = value & 0xffbf;
1445         if ((s->sscr[0] & SSCR0_SSE) && SSCR0_DSS(value) < 4) {
1446             printf("%s: Wrong data size: %i bits\n", __func__,
1447                    (int)SSCR0_DSS(value));
1448         }
1449         if (!(value & SSCR0_SSE)) {
1450             s->sssr = 0;
1451             s->rx_level = 0;
1452         }
1453         strongarm_ssp_fifo_update(s);
1454         break;
1455
1456     case SSCR1:
1457         s->sscr[1] = value & 0x2f;
1458         if (value & SSCR1_LBM) {
1459             printf("%s: Attempt to use SSP LBM mode\n", __func__);
1460         }
1461         strongarm_ssp_fifo_update(s);
1462         break;
1463
1464     case SSSR:
1465         s->sssr &= ~(value & SSSR_RW);
1466         strongarm_ssp_int_update(s);
1467         break;
1468
1469     case SSDR:
1470         if (SSCR0_UWIRE(s->sscr[0])) {
1471             value &= 0xff;
1472         } else
1473             /* Note how 32bits overflow does no harm here */
1474             value &= (1 << SSCR0_DSS(s->sscr[0])) - 1;
1475
1476         /* Data goes from here to the Tx FIFO and is shifted out from
1477          * there directly to the slave, no need to buffer it.
1478          */
1479         if (s->sscr[0] & SSCR0_SSE) {
1480             uint32_t readval;
1481             if (s->sscr[1] & SSCR1_LBM) {
1482                 readval = value;
1483             } else {
1484                 readval = ssi_transfer(s->bus, value);
1485             }
1486
1487             if (s->rx_level < 0x08) {
1488                 s->rx_fifo[(s->rx_start + s->rx_level++) & 0x7] = readval;
1489             } else {
1490                 s->sssr |= SSSR_ROR;
1491             }
1492         }
1493         strongarm_ssp_fifo_update(s);
1494         break;
1495
1496     default:
1497         printf("%s: Bad register 0x" TARGET_FMT_plx "\n", __func__, addr);
1498         break;
1499     }
1500 }
1501
1502 static const MemoryRegionOps strongarm_ssp_ops = {
1503     .read = strongarm_ssp_read,
1504     .write = strongarm_ssp_write,
1505     .endianness = DEVICE_NATIVE_ENDIAN,
1506 };
1507
1508 static int strongarm_ssp_post_load(void *opaque, int version_id)
1509 {
1510     StrongARMSSPState *s = opaque;
1511
1512     strongarm_ssp_fifo_update(s);
1513
1514     return 0;
1515 }
1516
1517 static int strongarm_ssp_init(SysBusDevice *dev)
1518 {
1519     StrongARMSSPState *s = FROM_SYSBUS(StrongARMSSPState, dev);
1520
1521     sysbus_init_irq(dev, &s->irq);
1522
1523     memory_region_init_io(&s->iomem, OBJECT(s), &strongarm_ssp_ops, s,
1524                           "ssp", 0x1000);
1525     sysbus_init_mmio(dev, &s->iomem);
1526
1527     s->bus = ssi_create_bus(&dev->qdev, "ssi");
1528     return 0;
1529 }
1530
1531 static void strongarm_ssp_reset(DeviceState *dev)
1532 {
1533     StrongARMSSPState *s = DO_UPCAST(StrongARMSSPState, busdev.qdev, dev);
1534     s->sssr = 0x03; /* 3 bit data, SPI, disabled */
1535     s->rx_start = 0;
1536     s->rx_level = 0;
1537 }
1538
1539 static const VMStateDescription vmstate_strongarm_ssp_regs = {
1540     .name = "strongarm-ssp",
1541     .version_id = 0,
1542     .minimum_version_id = 0,
1543     .minimum_version_id_old = 0,
1544     .post_load = strongarm_ssp_post_load,
1545     .fields = (VMStateField[]) {
1546         VMSTATE_UINT16_ARRAY(sscr, StrongARMSSPState, 2),
1547         VMSTATE_UINT16(sssr, StrongARMSSPState),
1548         VMSTATE_UINT16_ARRAY(rx_fifo, StrongARMSSPState, 8),
1549         VMSTATE_UINT8(rx_start, StrongARMSSPState),
1550         VMSTATE_UINT8(rx_level, StrongARMSSPState),
1551         VMSTATE_END_OF_LIST(),
1552     },
1553 };
1554
1555 static void strongarm_ssp_class_init(ObjectClass *klass, void *data)
1556 {
1557     DeviceClass *dc = DEVICE_CLASS(klass);
1558     SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
1559
1560     k->init = strongarm_ssp_init;
1561     dc->desc = "StrongARM SSP controller";
1562     dc->reset = strongarm_ssp_reset;
1563     dc->vmsd = &vmstate_strongarm_ssp_regs;
1564 }
1565
1566 static const TypeInfo strongarm_ssp_info = {
1567     .name          = "strongarm-ssp",
1568     .parent        = TYPE_SYS_BUS_DEVICE,
1569     .instance_size = sizeof(StrongARMSSPState),
1570     .class_init    = strongarm_ssp_class_init,
1571 };
1572
1573 /* Main CPU functions */
1574 StrongARMState *sa1110_init(MemoryRegion *sysmem,
1575                             unsigned int sdram_size, const char *rev)
1576 {
1577     StrongARMState *s;
1578     qemu_irq *pic;
1579     int i;
1580
1581     s = g_malloc0(sizeof(StrongARMState));
1582
1583     if (!rev) {
1584         rev = "sa1110-b5";
1585     }
1586
1587     if (strncmp(rev, "sa1110", 6)) {
1588         error_report("Machine requires a SA1110 processor.");
1589         exit(1);
1590     }
1591
1592     s->cpu = cpu_arm_init(rev);
1593
1594     if (!s->cpu) {
1595         error_report("Unable to find CPU definition");
1596         exit(1);
1597     }
1598
1599     memory_region_init_ram(&s->sdram, NULL, "strongarm.sdram", sdram_size);
1600     vmstate_register_ram_global(&s->sdram);
1601     memory_region_add_subregion(sysmem, SA_SDCS0, &s->sdram);
1602
1603     pic = arm_pic_init_cpu(s->cpu);
1604     s->pic = sysbus_create_varargs("strongarm_pic", 0x90050000,
1605                     pic[ARM_PIC_CPU_IRQ], pic[ARM_PIC_CPU_FIQ], NULL);
1606
1607     sysbus_create_varargs("pxa25x-timer", 0x90000000,
1608                     qdev_get_gpio_in(s->pic, SA_PIC_OSTC0),
1609                     qdev_get_gpio_in(s->pic, SA_PIC_OSTC1),
1610                     qdev_get_gpio_in(s->pic, SA_PIC_OSTC2),
1611                     qdev_get_gpio_in(s->pic, SA_PIC_OSTC3),
1612                     NULL);
1613
1614     sysbus_create_simple(TYPE_STRONGARM_RTC, 0x90010000,
1615                     qdev_get_gpio_in(s->pic, SA_PIC_RTC_ALARM));
1616
1617     s->gpio = strongarm_gpio_init(0x90040000, s->pic);
1618
1619     s->ppc = sysbus_create_varargs(TYPE_STRONGARM_PPC, 0x90060000, NULL);
1620
1621     for (i = 0; sa_serial[i].io_base; i++) {
1622         DeviceState *dev = qdev_create(NULL, "strongarm-uart");
1623         qdev_prop_set_chr(dev, "chardev", serial_hds[i]);
1624         qdev_init_nofail(dev);
1625         sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0,
1626                 sa_serial[i].io_base);
1627         sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0,
1628                 qdev_get_gpio_in(s->pic, sa_serial[i].irq));
1629     }
1630
1631     s->ssp = sysbus_create_varargs("strongarm-ssp", 0x80070000,
1632                 qdev_get_gpio_in(s->pic, SA_PIC_SSP), NULL);
1633     s->ssp_bus = (SSIBus *)qdev_get_child_bus(s->ssp, "ssi");
1634
1635     return s;
1636 }
1637
1638 static void strongarm_register_types(void)
1639 {
1640     type_register_static(&strongarm_pic_info);
1641     type_register_static(&strongarm_rtc_sysbus_info);
1642     type_register_static(&strongarm_gpio_info);
1643     type_register_static(&strongarm_ppc_info);
1644     type_register_static(&strongarm_uart_info);
1645     type_register_static(&strongarm_ssp_info);
1646 }
1647
1648 type_init(strongarm_register_types)