hw/s5pc1xx_pmu.c

   1 /*
   2  * S5PC1XX Power Management Unit controller,
   3  * Maxim MAX17040 Fuel Gauge,
   4  * Maxim MAX8998 Battery Charger and Real Time Clock.
   5  *
   6  * Copyright (c) 2009 Samsung Electronics.
   7  * Contributed by Dmitry Zhurikhin <zhur@ispras.ru>
   8  *                Vladimir Monakhov <vladimir.monakhov@ispras.ru>
   9  */
  10
  11 #include "sysemu.h"
  12 #include "sysbus.h"
  13 #include "smbus.h"
  14 #include "s5pc1xx.h"
  15 #include "qemu-timer.h"
  16
  17
  18 #define S5PC110_PMU_SFR_SIZE 0x8000
  19
  20
  21 typedef struct S5pc1xxPMUState {
  22     SysBusDevice busdev;
  23
  24     uint32_t osc_con;
  25     uint32_t rst_stat;
  26     uint32_t pwr_cfg;
  27     uint32_t eint_wakeup_mask;
  28     uint32_t wakeup_mask;
  29     uint32_t pwr_mode;
  30     uint32_t normal_cfg;
  31     uint32_t idle_cfg;
  32     uint32_t stop_cfg;
  33     uint32_t stop_mem_cfg;
  34     uint32_t sleep_cfg;
  35     uint32_t osc_freq;
  36     uint32_t osc_stable;
  37     uint32_t pwr_stable;
  38     uint32_t mtc_stable;
  39     uint32_t clamp_stable;
  40     uint32_t wakeup_stat;
  41     uint32_t blk_pwr_stat;
  42     uint32_t body_bias_con;
  43     uint32_t ion_skew_con;
  44     uint32_t ion_skew_mon;
  45     uint32_t ioff_skew_con;
  46     uint32_t ioff_skew_mon;
  47     uint32_t others;
  48     uint32_t om_stat;
  49     uint32_t mie_control;
  50     uint32_t hdmi_control;
  51     uint32_t usb_phy_control;
  52     uint32_t dac_control;
  53     uint32_t mipi_dphy_control;
  54     uint32_t adc_control;
  55     uint32_t ps_hold_control;
  56     uint32_t inform0;
  57     uint32_t inform1;
  58     uint32_t inform2;
  59     uint32_t inform3;
  60     uint32_t inform4;
  61     uint32_t inform5;
  62     uint32_t inform6;
  63     uint32_t inform7;
  64 } S5pc1xxPMUState;
  65
  66
  67 static uint32_t s5pc1xx_pmu_read(void *opaque, target_phys_addr_t offset)
  68 {
  69     S5pc1xxPMUState *s = (S5pc1xxPMUState *)opaque;
  70     target_phys_addr_t test_offset = offset + 0x8000;
  71
  72     if (offset & 3) {
  73         hw_error("s5pc1xx.pmu: bad read offset " TARGET_FMT_plx "\n", offset);
  74     }
  75
  76     switch (test_offset) {
  77     case 0x8000:
  78         return s->osc_con;
  79     case 0xA000:
  80         return s->rst_stat;
  81     case 0xC000:
  82         return s->pwr_cfg;
  83     case 0xC004:
  84         return s->eint_wakeup_mask;
  85     case 0xC008:
  86         return s->wakeup_mask;
  87     case 0xC00C:
  88         return s->pwr_mode;
  89     case 0xC010:
  90         return s->normal_cfg;
  91     case 0xC020:
  92         return s->idle_cfg;
  93     case 0xC030:
  94         return s->stop_cfg;
  95     case 0xC034:
  96         return s->stop_mem_cfg;
  97     case 0xC040:
  98         return s->sleep_cfg;
  99     case 0xC100:
 100         return s->osc_freq;
 101     case 0xC104:
 102         return s->osc_stable;
 103     case 0xC108:
 104         return s->pwr_stable;
 105     case 0xC110:
 106         return s->mtc_stable;
 107     case 0xC114:
 108         return s->clamp_stable;
 109     case 0xC200:
 110         return s->wakeup_stat;
 111     case 0xC204:
 112         return s->blk_pwr_stat;
 113     case 0xC300:
 114         return s->body_bias_con;
 115     case 0xC310:
 116         return s->ion_skew_con;
 117     case 0xC314:
 118         return s->ion_skew_mon;
 119     case 0xC320:
 120         return s->ioff_skew_con;
 121     case 0xC324:
 122         return s->ioff_skew_mon;
 123     case 0xE000:
 124         return s->others;
 125     case 0xE100:
 126         return s->om_stat;
 127     case 0xE800:
 128         return s->mie_control;
 129     case 0xE804:
 130         return s->hdmi_control;
 131     case 0xE80C:
 132         return s->usb_phy_control;
 133     case 0xE810:
 134         return s->dac_control;
 135     case 0xE814:
 136         return s->mipi_dphy_control;
 137     case 0xE818:
 138         return s->adc_control;
 139     case 0xE81C:
 140         return s->ps_hold_control;
 141     case 0xF000:
 142         return s->inform0;
 143     case 0xF004:
 144         return s->inform1;
 145     case 0xF008:
 146         return s->inform2;
 147     case 0xF00C:
 148         return s->inform3;
 149     case 0xF010:
 150         return s->inform4;
 151     case 0xF014:
 152         return s->inform5;
 153     case 0xF018:
 154         return s->inform6;
 155     case 0xF01C:
 156         return s->inform7;
 157     default:
 158         hw_error("s5pc1xx.pmu: bad read offset " TARGET_FMT_plx "\n", offset);
 159     }
 160 }
 161
 162 static void s5pc1xx_pmu_write(void *opaque, target_phys_addr_t offset,
 163                               uint32_t val)
 164 {
 165     S5pc1xxPMUState *s = (S5pc1xxPMUState *)opaque;
 166     target_phys_addr_t test_offset = offset + 0x8000;
 167
 168     /* TODO: Check if writing any values should change emulation flow */
 169
 170     if (offset & 3) {
 171         hw_error("s5pc1xx.pmu: bad write offset " TARGET_FMT_plx "\n", offset);
 172     }
 173
 174     switch (test_offset) {
 175     case 0x8000:
 176         s->osc_con = val;
 177         break;
 178     case 0xC000:
 179         s->pwr_cfg = val;
 180         break;
 181     case 0xC004:
 182         s->eint_wakeup_mask = val;
 183         break;
 184     case 0xC008:
 185         s->wakeup_mask = val;
 186         break;
 187     case 0xC00C:
 188         s->pwr_mode = val;
 189         break;
 190     case 0xC010:
 191         s->normal_cfg = val;
 192         break;
 193     case 0xC020:
 194         s->idle_cfg = val;
 195         break;
 196     case 0xC030:
 197         s->stop_cfg = val;
 198         break;
 199     case 0xC034:
 200         s->stop_mem_cfg = val;
 201         break;
 202     case 0xC040:
 203         s->sleep_cfg = val;
 204         break;
 205     case 0xC100:
 206         s->osc_freq = val;
 207         break;
 208     case 0xC104:
 209         s->osc_stable = val;
 210         break;
 211     case 0xC108:
 212         s->pwr_stable = val;
 213         break;
 214     case 0xC110:
 215         s->mtc_stable = val;
 216         break;
 217     case 0xC114:
 218         s->clamp_stable = val;
 219         break;
 220     case 0xC200:
 221         s->wakeup_stat = val;
 222         break;
 223     case 0xC300:
 224         s->body_bias_con = val;
 225         break;
 226     case 0xC310:
 227         s->ion_skew_con = val;
 228         break;
 229     case 0xC320:
 230         s->ioff_skew_con = val;
 231         break;
 232     case 0xE000:
 233         s->others = val;
 234         break;
 235     case 0xE800:
 236         s->mie_control = val;
 237         break;
 238     case 0xE804:
 239         s->hdmi_control = val;
 240         break;
 241     case 0xE80C:
 242         s->usb_phy_control = val;
 243         break;
 244     case 0xE810:
 245         s->dac_control = val;
 246         break;
 247     case 0xE814:
 248         s->mipi_dphy_control = val;
 249         break;
 250     case 0xE818:
 251         s->adc_control = val;
 252         break;
 253     case 0xE81C:
 254         s->ps_hold_control = val;
 255         if ((val & (1 << 8)) == 0) {
 256             qemu_system_shutdown_request();
 257         }
 258         break;
 259     case 0xF000:
 260         s->inform0 = val;
 261         break;
 262     case 0xF004:
 263         s->inform1 = val;
 264         break;
 265     case 0xF008:
 266         s->inform2 = val;
 267         break;
 268     case 0xF00C:
 269         s->inform3 = val;
 270         break;
 271     case 0xF010:
 272         s->inform4 = val;
 273         break;
 274     case 0xF014:
 275         s->inform5 = val;
 276         break;
 277     case 0xF018:
 278         s->inform6 = val;
 279         break;
 280     case 0xF01C:
 281         s->inform7 = val;
 282         break;
 283     case 0xA000: /* rst_stat */
 284     case 0xC204: /* blk_pwr_stat */
 285     case 0xC314: /* ion_skew_mon */
 286     case 0xC324: /* ioff_skew_mon */
 287     case 0xE100: /* om_stat */
 288         hw_error("s5pc1xx.pmu: bad write offset " TARGET_FMT_plx "\n", offset);
 289         break;
 290     default:
 291         hw_error("s5pc1xx.pmu: bad write offset " TARGET_FMT_plx "\n", offset);
 292     }
 293 }
 294
 295 static CPUReadMemoryFunc * const s5pc1xx_pmu_readfn[] = {
 296     s5pc1xx_pmu_read,
 297     s5pc1xx_pmu_read,
 298     s5pc1xx_pmu_read
 299 };
 300
 301 static CPUWriteMemoryFunc * const s5pc1xx_pmu_writefn[] = {
 302     s5pc1xx_pmu_write,
 303     s5pc1xx_pmu_write,
 304     s5pc1xx_pmu_write
 305 };
 306
 307 static void s5pc1xx_pmu_save(QEMUFile *f, void *opaque)
 308 {
 309     S5pc1xxPMUState *s = (S5pc1xxPMUState *)opaque;
 310
 311     qemu_put_be32s(f, &s->osc_con);
 312     qemu_put_be32s(f, &s->rst_stat);
 313     qemu_put_be32s(f, &s->pwr_cfg);
 314     qemu_put_be32s(f, &s->eint_wakeup_mask);
 315     qemu_put_be32s(f, &s->wakeup_mask);
 316     qemu_put_be32s(f, &s->pwr_mode);
 317     qemu_put_be32s(f, &s->normal_cfg);
 318     qemu_put_be32s(f, &s->idle_cfg);
 319     qemu_put_be32s(f, &s->stop_cfg);
 320     qemu_put_be32s(f, &s->stop_mem_cfg);
 321     qemu_put_be32s(f, &s->sleep_cfg);
 322     qemu_put_be32s(f, &s->osc_freq);
 323     qemu_put_be32s(f, &s->osc_stable);
 324     qemu_put_be32s(f, &s->pwr_stable);
 325     qemu_put_be32s(f, &s->mtc_stable);
 326     qemu_put_be32s(f, &s->clamp_stable);
 327     qemu_put_be32s(f, &s->wakeup_stat);
 328     qemu_put_be32s(f, &s->blk_pwr_stat);
 329     qemu_put_be32s(f, &s->body_bias_con);
 330     qemu_put_be32s(f, &s->ion_skew_con);
 331     qemu_put_be32s(f, &s->ion_skew_mon);
 332     qemu_put_be32s(f, &s->ioff_skew_con);
 333     qemu_put_be32s(f, &s->ioff_skew_mon);
 334     qemu_put_be32s(f, &s->others);
 335     qemu_put_be32s(f, &s->om_stat);
 336     qemu_put_be32s(f, &s->mie_control);
 337     qemu_put_be32s(f, &s->hdmi_control);
 338     qemu_put_be32s(f, &s->usb_phy_control);
 339     qemu_put_be32s(f, &s->dac_control);
 340     qemu_put_be32s(f, &s->mipi_dphy_control);
 341     qemu_put_be32s(f, &s->adc_control);
 342     qemu_put_be32s(f, &s->ps_hold_control);
 343     qemu_put_be32s(f, &s->inform0);
 344     qemu_put_be32s(f, &s->inform1);
 345     qemu_put_be32s(f, &s->inform2);
 346     qemu_put_be32s(f, &s->inform3);
 347     qemu_put_be32s(f, &s->inform4);
 348     qemu_put_be32s(f, &s->inform5);
 349     qemu_put_be32s(f, &s->inform6);
 350     qemu_put_be32s(f, &s->inform7);
 351 }
 352
 353 static int s5pc1xx_pmu_load(QEMUFile *f, void *opaque, int version_id)
 354 {
 355     S5pc1xxPMUState *s = (S5pc1xxPMUState *)opaque;
 356
 357     if (version_id != 1) {
 358         return -EINVAL;
 359     }
 360
 361     qemu_get_be32s(f, &s->osc_con);
 362     qemu_get_be32s(f, &s->rst_stat);
 363     qemu_get_be32s(f, &s->pwr_cfg);
 364     qemu_get_be32s(f, &s->eint_wakeup_mask);
 365     qemu_get_be32s(f, &s->wakeup_mask);
 366     qemu_get_be32s(f, &s->pwr_mode);
 367     qemu_get_be32s(f, &s->normal_cfg);
 368     qemu_get_be32s(f, &s->idle_cfg);
 369     qemu_get_be32s(f, &s->stop_cfg);
 370     qemu_get_be32s(f, &s->stop_mem_cfg);
 371     qemu_get_be32s(f, &s->sleep_cfg);
 372     qemu_get_be32s(f, &s->osc_freq);
 373     qemu_get_be32s(f, &s->osc_stable);
 374     qemu_get_be32s(f, &s->pwr_stable);
 375     qemu_get_be32s(f, &s->mtc_stable);
 376     qemu_get_be32s(f, &s->clamp_stable);
 377     qemu_get_be32s(f, &s->wakeup_stat);
 378     qemu_get_be32s(f, &s->blk_pwr_stat);
 379     qemu_get_be32s(f, &s->body_bias_con);
 380     qemu_get_be32s(f, &s->ion_skew_con);
 381     qemu_get_be32s(f, &s->ion_skew_mon);
 382     qemu_get_be32s(f, &s->ioff_skew_con);
 383     qemu_get_be32s(f, &s->ioff_skew_mon);
 384     qemu_get_be32s(f, &s->others);
 385     qemu_get_be32s(f, &s->om_stat);
 386     qemu_get_be32s(f, &s->mie_control);
 387     qemu_get_be32s(f, &s->hdmi_control);
 388     qemu_get_be32s(f, &s->usb_phy_control);
 389     qemu_get_be32s(f, &s->dac_control);
 390     qemu_get_be32s(f, &s->mipi_dphy_control);
 391     qemu_get_be32s(f, &s->adc_control);
 392     qemu_get_be32s(f, &s->ps_hold_control);
 393     qemu_get_be32s(f, &s->inform0);
 394     qemu_get_be32s(f, &s->inform1);
 395     qemu_get_be32s(f, &s->inform2);
 396     qemu_get_be32s(f, &s->inform3);
 397     qemu_get_be32s(f, &s->inform4);
 398     qemu_get_be32s(f, &s->inform5);
 399     qemu_get_be32s(f, &s->inform6);
 400     qemu_get_be32s(f, &s->inform7);
 401
 402     return 0;
 403 }
 404
 405 static void s5pc1xx_pmu_reset(void *opaque)
 406 {
 407     S5pc1xxPMUState *s = (S5pc1xxPMUState *)opaque;
 408
 409     s->osc_con         = 0x00000003;
 410     s->rst_stat        = 0x00000001;
 411     s->normal_cfg      = 0xFFFFFFBF;
 412     s->idle_cfg        = 0x60000000;
 413     s->stop_cfg        = 0x96000000;
 414     s->stop_mem_cfg    = 0x000000FF;
 415     s->osc_freq        = 0x0000000F;
 416     s->osc_stable      = 0x000FFFFF;
 417     s->mtc_stable      = 0xFFFFFFFF;
 418     s->clamp_stable    = 0x03FF03FF;
 419     s->blk_pwr_stat    = 0x000000BF;
 420     s->body_bias_con   = 0x00000606;
 421     s->mie_control     = 0x00000001;
 422     s->hdmi_control    = 0x00960000;
 423     s->dac_control     = 0x00000001;
 424     s->ps_hold_control = 0x00005301;
 425 }
 426
 427 static int s5pc1xx_pmu_init(SysBusDevice *dev)
 428 {
 429     S5pc1xxPMUState *s = FROM_SYSBUS(S5pc1xxPMUState, dev);
 430     int iomemtype;
 431
 432     iomemtype =
 433         cpu_register_io_memory(s5pc1xx_pmu_readfn, s5pc1xx_pmu_writefn, s, DEVICE_NATIVE_ENDIAN);
 434     sysbus_init_mmio(dev, S5PC110_PMU_SFR_SIZE, iomemtype);
 435
 436     s5pc1xx_pmu_reset(s);
 437
 438     qemu_register_reset(s5pc1xx_pmu_reset, s);
 439     register_savevm(&dev->qdev, "s5pc1xx.pmu", -1, 1,
 440                     s5pc1xx_pmu_save, s5pc1xx_pmu_load, s);
 441
 442     return 0;
 443 }
 444
 445
 446 /* Maxim MAX17040 Fuel Gauge */
 447
 448 #define MAX17040_VCELL_MSB      0x02
 449 #define MAX17040_VCELL_LSB      0x03
 450 #define MAX17040_SOC_MSB        0x04
 451 #define MAX17040_SOC_LSB        0x05
 452 #define MAX17040_MODE_MSB       0x06
 453 #define MAX17040_MODE_LSB       0x07
 454 #define MAX17040_VER_MSB        0x08
 455 #define MAX17040_VER_LSB        0x09
 456 #define MAX17040_RCOMP_MSB      0x0C
 457 #define MAX17040_RCOMP_LSB      0x0D
 458 #define MAX17040_CMD_MSB        0xFE
 459 #define MAX17040_CMD_LSB        0xFF
 460
 461 #define MAX17040_DELAY          1000
 462 #define MAX17040_BATTERY_FULL   95
 463 #define MAX17040_BATTERY_CHARGE 40
 464
 465
 466 typedef struct MAX17040State {
 467     SMBusDevice smbusdev;
 468
 469     uint16_t charge;
 470     uint16_t vcell;
 471     uint16_t mode;
 472     uint16_t ver;
 473     uint16_t rcomp;
 474     uint16_t cmd;
 475 } MAX17040State;
 476
 477 static void max17040_reset(void *opaque)
 478 {
 479     MAX17040State *s = (MAX17040State *)opaque;
 480
 481     s->charge = MAX17040_BATTERY_CHARGE << 8;
 482     s->vcell = 4200;
 483     s->mode = 0;
 484     s->ver = 0xAA28;
 485     s->rcomp = 0;
 486     s->cmd = 0;
 487 }
 488
 489 static void max17040_write_data(SMBusDevice *dev, uint8_t cmd,
 490                                 uint8_t *buf, int len)
 491 {
 492     MAX17040State *s = (MAX17040State *)dev;
 493     int shift = 0, i;
 494     uint16_t *reg = NULL;
 495
 496     switch (cmd) {
 497     case MAX17040_VCELL_LSB:
 498         shift = 1;
 499     case MAX17040_VCELL_MSB:
 500         reg = &s->vcell;
 501         break;
 502     case MAX17040_SOC_LSB:
 503         shift = 1;
 504     case MAX17040_SOC_MSB:
 505         reg = &s->charge;
 506         break;
 507     case MAX17040_MODE_LSB:
 508         shift = 1;
 509     case MAX17040_MODE_MSB:
 510         reg = &s->mode;
 511         break;
 512     case MAX17040_VER_LSB:
 513         shift = 1;
 514     case MAX17040_VER_MSB:
 515         reg = &s->ver;
 516         break;
 517     case MAX17040_RCOMP_LSB:
 518         shift = 1;
 519     case MAX17040_RCOMP_MSB:
 520         reg = &s->rcomp;
 521         break;
 522     case MAX17040_CMD_LSB:
 523         shift = 1;
 524     case MAX17040_CMD_MSB:
 525         reg = &s->cmd;
 526         break;
 527     default:
 528         hw_error("max17040: bad write offset 0x%x\n", cmd);
 529     }
 530
 531     if (len > 2 - shift) {
 532         hw_error("max17040: bad write length %d\n", len);
 533     }
 534
 535     for (i = 0; i < len; i++) {
 536         *((uint8_t *)reg + i + shift) = buf[i];
 537     }
 538 }
 539
 540 static uint8_t max17040_read_data(SMBusDevice *dev, uint8_t cmd, int n)
 541 {
 542     MAX17040State *s = (MAX17040State *)dev;
 543     int shift = 0;
 544     uint16_t val;
 545
 546     if (n > 0) {
 547                 //bypass => todo check!!
 548         //hw_error("max17040: bad read length %d\n", n);
 549     }
 550
 551     switch (cmd) {
 552     case MAX17040_VCELL_MSB:
 553         shift = 1;
 554     case MAX17040_VCELL_LSB:
 555         val = s->vcell;
 556         break;
 557     case MAX17040_SOC_MSB:
 558         shift = 1;
 559     case MAX17040_SOC_LSB:
 560         val = s->charge;
 561         break;
 562     case MAX17040_MODE_MSB:
 563         shift = 1;
 564     case MAX17040_MODE_LSB:
 565         val = s->mode;
 566         break;
 567     case MAX17040_VER_MSB:
 568         shift = 1;
 569     case MAX17040_VER_LSB:
 570         val = s->ver;
 571         break;
 572     case MAX17040_RCOMP_MSB:
 573         shift = 1;
 574     case MAX17040_RCOMP_LSB:
 575         val = s->rcomp;
 576         break;
 577     case MAX17040_CMD_MSB:
 578         shift = 1;
 579     case MAX17040_CMD_LSB:
 580         val = s->cmd;
 581         break;
 582     default:
 583         hw_error("max17040: bad read offset 0x%x\n", cmd);
 584     }
 585
 586     return ((val >> (shift * 8)) & 0xFF);
 587 }
 588
 589 static void max17040_save(QEMUFile *f, void *opaque)
 590 {
 591     MAX17040State *s = (MAX17040State *)opaque;
 592
 593     qemu_put_be16s(f, &s->charge);
 594     qemu_put_be16s(f, &s->vcell);
 595     qemu_put_be16s(f, &s->mode);
 596     qemu_put_be16s(f, &s->ver);
 597     qemu_put_be16s(f, &s->rcomp);
 598     qemu_put_be16s(f, &s->cmd);
 599 }
 600
 601 static int max17040_load(QEMUFile *f, void *opaque, int version_id)
 602 {
 603     MAX17040State *s = (MAX17040State *)opaque;
 604
 605     if (version_id != 1) {
 606         return -EINVAL;
 607     }
 608
 609     qemu_get_be16s(f, &s->charge);
 610     qemu_get_be16s(f, &s->vcell);
 611     qemu_get_be16s(f, &s->mode);
 612     qemu_get_be16s(f, &s->ver);
 613     qemu_get_be16s(f, &s->rcomp);
 614     qemu_get_be16s(f, &s->cmd);
 615
 616     return 0;
 617 }
 618
 619 DeviceState *max17040_init(i2c_bus *bus, int addr)
 620 {
 621     DeviceState *dev = qdev_create((BusState *)bus, "max17040");
 622     qdev_init_nofail(dev);
 623     i2c_set_slave_address((i2c_slave *)dev, addr);
 624     return dev;
 625 }
 626
 627 static int max17040_init1(SMBusDevice *dev)
 628 {
 629     MAX17040State *s = (MAX17040State *) dev;
 630     max17040_reset(s);
 631     qemu_register_reset(max17040_reset, s);
 632     register_savevm(&dev->i2c.qdev, "max17040", -1, 1,
 633                     max17040_save, max17040_load, s);
 634     return 0;
 635 }
 636
 637 static SMBusDeviceInfo max17040_info = {
 638     .i2c.qdev.name = "max17040",
 639     .i2c.qdev.size = sizeof(MAX17040State),
 640     .init = max17040_init1,
 641     .write_data = max17040_write_data,
 642     .read_data = max17040_read_data
 643 };
 644
 645
 646 /* Maxim MAX8998 Battery Charger */
 647
 648 #define MAX8998_REG_IRQ1                   0
 649 #define MAX8998_REG_IRQ2                   1
 650 #define MAX8998_REG_IRQ3                   2
 651 #define MAX8998_REG_IRQ4                   3
 652 #define MAX8998_REG_IRQM1                  4
 653 #define MAX8998_REG_IRQM2                  5
 654 #define MAX8998_REG_IRQM3                  6
 655 #define MAX8998_REG_IRQM4                  7
 656 #define MAX8998_REG_STATUS1                8
 657 #define MAX8998_REG_STATUS2                9
 658 #define MAX8998_REG_STATUSM1               10
 659 #define MAX8998_REG_STATUSM2               11
 660 #define MAX8998_REG_CHGR1                  12
 661 #define MAX8998_REG_CHGR2                  13
 662 #define MAX8998_REG_LDO_ACTIVE_DISCHARGE1  14
 663 #define MAX8998_REG_LDO_ACTIVE_DISCHARGE2  15
 664 #define MAX8998_REG_BUCK_ACTIVE_DISCHARGE3 16
 665 #define MAX8998_REG_ONOFF1                 17
 666 #define MAX8998_REG_ONOFF2                 18
 667 #define MAX8998_REG_ONOFF3                 19
 668 #define MAX8998_REG_ONOFF4                 20
 669 #define MAX8998_REG_BUCK1_DVSARM1          21
 670 #define MAX8998_REG_BUCK1_DVSARM2          22
 671 #define MAX8998_REG_BUCK1_DVSARM3          23
 672 #define MAX8998_REG_BUCK1_DVSARM4          24
 673 #define MAX8998_REG_BUCK2_DVSINT1          25
 674 #define MAX8998_REG_BUCK2_DVSINT2          26
 675 #define MAX8998_REG_BUCK3                  27
 676 #define MAX8998_REG_BUCK4                  28
 677 #define MAX8998_REG_LDO2_LDO3              29
 678 #define MAX8998_REG_LDO4                   30
 679 #define MAX8998_REG_LDO5                   31
 680 #define MAX8998_REG_LDO6                   32
 681 #define MAX8998_REG_LDO7                   33
 682 #define MAX8998_REG_LDO8_LDO9              34
 683 #define MAX8998_REG_LDO10_LDO11            35
 684 #define MAX8998_REG_LDO12                  36
 685 #define MAX8998_REG_LDO13                  37
 686 #define MAX8998_REG_LDO14                  38
 687 #define MAX8998_REG_LDO15                  39
 688 #define MAX8998_REG_LDO16                  40
 689 #define MAX8998_REG_LDO17                  41
 690 #define MAX8998_REG_BKCHR                  42
 691 #define MAX8998_REG_LBCNFG1                43
 692 #define MAX8998_REG_LBCNFG2                44
 693
 694
 695 typedef struct MAX8998State {
 696     SMBusDevice smbusdev;
 697
 698     uint32_t irq;
 699     uint32_t irqm;
 700     uint16_t status;
 701     uint16_t statusm;
 702     uint16_t chgr;
 703     uint16_t ldo_active_discharge;
 704     uint8_t  buck_active_discharge;
 705     uint32_t onoff;
 706     uint32_t buck1_dvsarm;
 707     uint16_t buck2_dvsint;
 708     uint8_t  buck3;
 709     uint8_t  buck4;
 710     uint32_t ldo23_4_5_6;
 711     uint32_t ldo7_89_1011_12;
 712     uint32_t ldo13_14_15_16;
 713     uint8_t  ldo17;
 714     uint8_t  bkchr;
 715     uint16_t lbcnfg;
 716 } MAX8998State;
 717
 718 static void max8998_reset(void *opaque)
 719 {
 720     MAX8998State *s = (MAX8998State *)opaque;
 721
 722     s->irq             = 0;
 723     s->irqm            = 0;
 724     s->status          = 0;
 725     s->statusm         = 0xEFFF;
 726     s->chgr            = 0xA80;
 727     s->ldo_active_discharge = 0;
 728     s->buck_active_discharge = 0;
 729     s->onoff           = 0;
 730     s->buck1_dvsarm    = 0;
 731     s->buck2_dvsint    = 0;
 732     s->buck3           = 0;
 733     s->buck4           = 0;
 734     s->ldo23_4_5_6     = 0;
 735     s->ldo7_89_1011_12 = 0;
 736     s->ldo13_14_15_16  = 0;
 737     s->ldo17           = 0;
 738     s->bkchr           = 0;
 739     s->lbcnfg          = 0;
 740 }
 741
 742 static uint8_t *max8998_get_reg_addr(MAX8998State *s, uint8_t cmd)
 743 {
 744     int shift = 0;
 745     uint8_t *reg = NULL;
 746
 747     switch (cmd) {
 748     case MAX8998_REG_IRQ4:
 749     case MAX8998_REG_IRQM4:
 750     case MAX8998_REG_STATUS2:
 751     case MAX8998_REG_STATUSM2:
 752     case MAX8998_REG_CHGR2:
 753     case MAX8998_REG_LDO_ACTIVE_DISCHARGE2:
 754     case MAX8998_REG_BUCK_ACTIVE_DISCHARGE3:
 755     case MAX8998_REG_ONOFF4:
 756     case MAX8998_REG_BUCK1_DVSARM4:
 757     case MAX8998_REG_BUCK2_DVSINT2:
 758     case MAX8998_REG_BUCK3:
 759     case MAX8998_REG_BUCK4:
 760     case MAX8998_REG_LDO6:
 761     case MAX8998_REG_LDO12:
 762     case MAX8998_REG_LDO16:
 763     case MAX8998_REG_LDO17:
 764     case MAX8998_REG_BKCHR:
 765     case MAX8998_REG_LBCNFG2:
 766         break;
 767     case MAX8998_REG_IRQ3:
 768     case MAX8998_REG_IRQM3:
 769     case MAX8998_REG_STATUS1:
 770     case MAX8998_REG_STATUSM1:
 771     case MAX8998_REG_CHGR1:
 772     case MAX8998_REG_LDO_ACTIVE_DISCHARGE1:
 773     case MAX8998_REG_ONOFF3:
 774     case MAX8998_REG_BUCK1_DVSARM3:
 775     case MAX8998_REG_BUCK2_DVSINT1:
 776     case MAX8998_REG_LDO5:
 777     case MAX8998_REG_LDO10_LDO11:
 778     case MAX8998_REG_LDO15:
 779     case MAX8998_REG_LBCNFG1:
 780         shift = 1;
 781         break;
 782     case MAX8998_REG_IRQ2:
 783     case MAX8998_REG_IRQM2:
 784     case MAX8998_REG_ONOFF2:
 785     case MAX8998_REG_BUCK1_DVSARM2:
 786     case MAX8998_REG_LDO4:
 787     case MAX8998_REG_LDO8_LDO9:
 788     case MAX8998_REG_LDO14:
 789         shift = 2;
 790         break;
 791     case MAX8998_REG_IRQ1:
 792     case MAX8998_REG_IRQM1:
 793     case MAX8998_REG_ONOFF1:
 794     case MAX8998_REG_BUCK1_DVSARM1:
 795     case MAX8998_REG_LDO2_LDO3:
 796     case MAX8998_REG_LDO7:
 797     case MAX8998_REG_LDO13:
 798         shift = 3;
 799         break;
 800     default:
 801         hw_error("max8998: bad write offset 0x%x\n", cmd);
 802     }
 803
 804     switch (cmd) {
 805     case MAX8998_REG_IRQ1:
 806     case MAX8998_REG_IRQ2:
 807     case MAX8998_REG_IRQ3:
 808     case MAX8998_REG_IRQ4:
 809         reg = (uint8_t *)&s->irq;
 810         break;
 811     case MAX8998_REG_IRQM1:
 812     case MAX8998_REG_IRQM2:
 813     case MAX8998_REG_IRQM3:
 814     case MAX8998_REG_IRQM4:
 815         reg = (uint8_t *)&s->irqm;
 816         break;
 817     case MAX8998_REG_STATUS1:
 818     case MAX8998_REG_STATUS2:
 819         reg = (uint8_t *)&s->status;
 820         break;
 821     case MAX8998_REG_STATUSM1:
 822     case MAX8998_REG_STATUSM2:
 823         reg = (uint8_t *)&s->statusm;
 824         break;
 825     case MAX8998_REG_CHGR1:
 826     case MAX8998_REG_CHGR2:
 827         reg = (uint8_t *)&s->chgr;
 828         break;
 829     case MAX8998_REG_LDO_ACTIVE_DISCHARGE1:
 830     case MAX8998_REG_LDO_ACTIVE_DISCHARGE2:
 831         reg = (uint8_t *)&s->ldo_active_discharge;
 832         break;
 833     case MAX8998_REG_BUCK_ACTIVE_DISCHARGE3:
 834         reg = (uint8_t *)&s->buck_active_discharge;
 835         break;
 836     case MAX8998_REG_ONOFF1:
 837     case MAX8998_REG_ONOFF2:
 838     case MAX8998_REG_ONOFF3:
 839     case MAX8998_REG_ONOFF4:
 840         reg = (uint8_t *)&s->onoff;
 841         break;
 842     case MAX8998_REG_BUCK1_DVSARM1:
 843     case MAX8998_REG_BUCK1_DVSARM2:
 844     case MAX8998_REG_BUCK1_DVSARM3:
 845     case MAX8998_REG_BUCK1_DVSARM4:
 846         reg = (uint8_t *)&s->buck1_dvsarm;
 847         break;
 848     case MAX8998_REG_BUCK2_DVSINT1:
 849     case MAX8998_REG_BUCK2_DVSINT2:
 850         reg = (uint8_t *)&s->buck2_dvsint;
 851         break;
 852     case MAX8998_REG_BUCK3:
 853         reg = (uint8_t *)&s->buck3;
 854         break;
 855     case MAX8998_REG_BUCK4:
 856         reg = (uint8_t *)&s->buck4;
 857         break;
 858     case MAX8998_REG_LDO2_LDO3:
 859     case MAX8998_REG_LDO4:
 860     case MAX8998_REG_LDO5:
 861     case MAX8998_REG_LDO6:
 862         reg = (uint8_t *)&s->ldo23_4_5_6;
 863         break;
 864     case MAX8998_REG_LDO7:
 865     case MAX8998_REG_LDO8_LDO9:
 866     case MAX8998_REG_LDO10_LDO11:
 867     case MAX8998_REG_LDO12:
 868         reg = (uint8_t *)&s->ldo7_89_1011_12;
 869         break;
 870     case MAX8998_REG_LDO13:
 871     case MAX8998_REG_LDO14:
 872     case MAX8998_REG_LDO15:
 873     case MAX8998_REG_LDO16:
 874         reg = (uint8_t *)&s->ldo13_14_15_16;
 875         break;
 876     case MAX8998_REG_LDO17:
 877         reg = (uint8_t *)&s->ldo17;
 878         break;
 879     case MAX8998_REG_BKCHR:
 880         reg = (uint8_t *)&s->bkchr;
 881         break;
 882     case MAX8998_REG_LBCNFG1:
 883     case MAX8998_REG_LBCNFG2:
 884         reg = (uint8_t *)&s->lbcnfg;
 885         break;
 886     default:
 887         hw_error("max8998: bad write offset 0x%x\n", cmd);
 888     }
 889
 890     return (reg + shift);
 891 }
 892
 893 static void max8998_write_data(SMBusDevice *dev, uint8_t cmd,
 894                                uint8_t *buf, int len)
 895 {
 896     MAX8998State *s = (MAX8998State *)dev;
 897
 898     if (len > 1) {
 899         hw_error("max8998: bad write length %d\n", len);
 900     }
 901
 902     *(max8998_get_reg_addr(s, cmd)) = buf[0];
 903 }
 904
 905 static uint8_t max8998_read_data(SMBusDevice *dev, uint8_t cmd, int n)
 906 {
 907     MAX8998State *s = (MAX8998State *)dev;
 908
 909     if (n > 0 && cmd != MAX8998_REG_IRQ1) {
 910         hw_error("max8998: bad read length %d\n", n);
 911     }
 912
 913     return *(max8998_get_reg_addr(s, cmd) + n);
 914 }
 915
 916 static void max8998_save(QEMUFile *f, void *opaque)
 917 {
 918     MAX8998State *s = (MAX8998State *)opaque;
 919
 920     qemu_put_be32s(f, &s->irq);
 921     qemu_put_be32s(f, &s->irqm);
 922     qemu_put_be16s(f, &s->status);
 923     qemu_put_be16s(f, &s->statusm);
 924     qemu_put_be16s(f, &s->chgr);
 925     qemu_put_be16s(f, &s->ldo_active_discharge);
 926     qemu_put_8s   (f, &s->buck_active_discharge);
 927     qemu_put_be32s(f, &s->onoff);
 928     qemu_put_be32s(f, &s->buck1_dvsarm);
 929     qemu_put_be16s(f, &s->buck2_dvsint);
 930     qemu_put_8s   (f, &s->buck3);
 931     qemu_put_8s   (f, &s->buck4);
 932     qemu_put_be32s(f, &s->ldo23_4_5_6);
 933     qemu_put_be32s(f, &s->ldo7_89_1011_12);
 934     qemu_put_be32s(f, &s->ldo13_14_15_16);
 935     qemu_put_8s   (f, &s->ldo17);
 936     qemu_put_8s   (f, &s->bkchr);
 937     qemu_put_be16s(f, &s->lbcnfg);
 938 }
 939
 940 static int max8998_load(QEMUFile *f, void *opaque, int version_id)
 941 {
 942     MAX8998State *s = (MAX8998State *)opaque;
 943
 944     if (version_id != 1) {
 945         return -EINVAL;
 946     }
 947
 948     qemu_get_be32s(f, &s->irq);
 949     qemu_get_be32s(f, &s->irqm);
 950     qemu_get_be16s(f, &s->status);
 951     qemu_get_be16s(f, &s->statusm);
 952     qemu_get_be16s(f, &s->chgr);
 953     qemu_get_be16s(f, &s->ldo_active_discharge);
 954     qemu_get_8s   (f, &s->buck_active_discharge);
 955     qemu_get_be32s(f, &s->onoff);
 956     qemu_get_be32s(f, &s->buck1_dvsarm);
 957     qemu_get_be16s(f, &s->buck2_dvsint);
 958     qemu_get_8s   (f, &s->buck3);
 959     qemu_get_8s   (f, &s->buck4);
 960     qemu_get_be32s(f, &s->ldo23_4_5_6);
 961     qemu_get_be32s(f, &s->ldo7_89_1011_12);
 962     qemu_get_be32s(f, &s->ldo13_14_15_16);
 963     qemu_get_8s   (f, &s->ldo17);
 964     qemu_get_8s   (f, &s->bkchr);
 965     qemu_get_be16s(f, &s->lbcnfg);
 966
 967     return 0;
 968 }
 969
 970 DeviceState *max8998_init(i2c_bus *bus, int addr)
 971 {
 972     DeviceState *dev = qdev_create((BusState *)bus, "max8998");
 973     qdev_init_nofail(dev);
 974     i2c_set_slave_address((i2c_slave *)dev, addr);
 975     return dev;
 976 }
 977
 978 static int max8998_init1(SMBusDevice *dev)
 979 {
 980     MAX8998State *s = (MAX8998State *) dev;
 981     max8998_reset(s);
 982     qemu_register_reset(max8998_reset, s);
 983     register_savevm(&dev->i2c.qdev, "max8998", -1, 1,
 984                     max8998_save, max8998_load, s);
 985     return 0;
 986 }
 987
 988 static SMBusDeviceInfo max8998_info = {
 989     .i2c.qdev.name = "max8998",
 990     .i2c.qdev.size = sizeof(MAX8998State),
 991     .init = max8998_init1,
 992     .write_data = max8998_write_data,
 993     .read_data = max8998_read_data
 994 };
 995
 996
 997 /* Maxim MAX8998 Real Time Clock */
 998
 999 /* MX8998 RTC I2C MAP */
1000 #define RTC_SEC         0x0         /* second 00-59 */
1001 #define RTC_MIN         0x1         /* minute 00-59 */
1002 #define RTC_HR          0x2         /* hour AM/PM 1-12 or 00-23 */
1003 #define RTC_DAY         0x3         /* weekday 1-7 */
1004 #define RTC_DATE        0x4         /* date 01-31 */
1005 #define RTC_MT          0x5         /* month 01-12 */
1006 #define RTC_YEAR        0x6         /* year 00-99 */
1007 #define RTC_CEN         0x7         /* century 00-99 */
1008
1009 #define RTC_CON         0x1A
1010     #define RTC_EN          0x01    /* RTC control enable */
1011
1012 #define MAX8998_REG(x, y)   (0x8 * y + x)
1013
1014 /* Time Keeper */
1015 #define MAX8998_RTC         0
1016 /* Alarm0 */
1017 #define MAX8998_ALRM0       1
1018 /* Alarm1 */
1019 #define MAX8998_ALRM1       2
1020 /* Conf */
1021 #define MAX8998_ALRM0_CONF  0x18
1022 #define MAX8998_ALRM1_CONF  0x19
1023
1024 #define MAX8998_ALRM_ON     0x77
1025 #define MAX8998_ALRM_OFF    0x0
1026
1027
1028 typedef struct MAX8998RTCState {
1029     SMBusDevice smbusdev;
1030
1031     uint8_t  regs[RTC_CON + 1];
1032
1033     /* seconds update */
1034     QEMUTimer *seconds_timer;
1035     struct tm current_tm;
1036 } MAX8998RTCState;
1037
1038 static void max8998_rtc_seconds_update(void *opaque);
1039
1040 /* Set default values for all fields */
1041 static void max8998_rtc_reset(void *opaque)
1042 {
1043     MAX8998RTCState *s = (MAX8998RTCState *)opaque;
1044     short i;
1045
1046     /* stop seconds timer */
1047     s->regs[RTC_CON] = 0x0;
1048     max8998_rtc_seconds_update(s);
1049
1050     for (i = RTC_SEC; i <= RTC_CEN; i++) {
1051         s->regs[MAX8998_REG(i, MAX8998_RTC)] = 0;
1052     }
1053     /* get time from host */
1054     qemu_get_timedate(&s->current_tm, 0);
1055
1056     /* start seconds timer */
1057     s->regs[RTC_CON] |= RTC_EN;
1058     max8998_rtc_seconds_update(s);
1059 }
1060
1061 /* Get days in month. Month is between 0 and 11 */
1062 static int get_days_in_month(int month, int year)
1063 {
1064     short d;
1065     static const int days_tab[12] = {
1066         31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
1067     };
1068
1069     if ((unsigned)month >= 12) {
1070         return 31;
1071     }
1072     d = days_tab[month];
1073     if (month == 1) {
1074         if ((year % 4) == 0) {
1075             d++;
1076         }
1077     }
1078     return d;
1079 }
1080
1081 /* Update 'struct tm' to the next second */
1082 static void max8998_rtc_next_second(struct tm *tm)
1083 {
1084     int days_in_month;
1085
1086     tm->tm_sec++;
1087     if ((unsigned)tm->tm_sec >= 60) {
1088         tm->tm_sec = 0;
1089         tm->tm_min++;
1090         if ((unsigned)tm->tm_min >= 60) {
1091             tm->tm_min = 0;
1092             tm->tm_hour++;
1093             if ((unsigned)tm->tm_hour >= 24) {
1094                 tm->tm_hour = 0;
1095                 /* next day */
1096                 tm->tm_wday++;
1097                 if ((unsigned)tm->tm_wday >= 8) {
1098                     tm->tm_wday = 1;
1099                 }
1100                 days_in_month = get_days_in_month(tm->tm_mon, tm->tm_year);
1101                 tm->tm_mday++;
1102                 if (tm->tm_mday < 1) {
1103                     tm->tm_mday = 1;
1104                 } else if (tm->tm_mday > days_in_month) {
1105                     tm->tm_mday = 1;
1106                     tm->tm_mon++;
1107                     if (tm->tm_mon >= 12) {
1108                         tm->tm_mon = 0;
1109                         tm->tm_year++;
1110                     }
1111                 }
1112             }
1113         }
1114     }
1115 }
1116
1117 /* Using of qemu_timer to increase seconds */
1118 static void max8998_rtc_seconds_update(void *opaque)
1119 {
1120     MAX8998RTCState *s = (MAX8998RTCState *)opaque;
1121     uint64_t next_seconds_time;
1122
1123     if (s->regs[RTC_CON] & RTC_EN) {
1124         max8998_rtc_next_second(&(s->current_tm));
1125         next_seconds_time = qemu_get_clock(vm_clock) + get_ticks_per_sec();
1126         qemu_mod_timer(s->seconds_timer, next_seconds_time);
1127     } else {
1128         qemu_del_timer(s->seconds_timer);
1129     }
1130 }
1131
1132 /* Convert time from bcd */
1133 static void max8998_rtc_set_time(MAX8998RTCState *s)
1134 {
1135     struct tm *tm = &(s->current_tm);
1136
1137     tm->tm_sec  = from_bcd(s->regs[RTC_SEC]);
1138     tm->tm_min  = from_bcd(s->regs[RTC_MIN]);
1139     tm->tm_hour = from_bcd(s->regs[RTC_HR] & 0x3f);
1140     tm->tm_mday = from_bcd(s->regs[RTC_DATE]);
1141     tm->tm_mon  = from_bcd(s->regs[RTC_MT]);
1142     tm->tm_year = from_bcd(s->regs[RTC_YEAR]) +
1143                   from_bcd(s->regs[RTC_CEN]) * 100 - 1900;
1144     tm->tm_wday = s->regs[RTC_DAY]; /* one decimal digit */
1145 }
1146
1147 /* Convert time to bcd */
1148 static void max8998_rtc_read_time(MAX8998RTCState *s)
1149 {
1150     const struct tm *tm = &(s->current_tm);
1151
1152     s->regs[RTC_SEC]  = to_bcd(tm->tm_sec);
1153     s->regs[RTC_MIN]  = to_bcd(tm->tm_min);
1154     s->regs[RTC_HR]   = to_bcd(tm->tm_hour);
1155     s->regs[RTC_DATE] = to_bcd(tm->tm_mday);
1156     s->regs[RTC_MT]   = to_bcd(tm->tm_mon);
1157     s->regs[RTC_YEAR] = to_bcd(tm->tm_year % 100);
1158     s->regs[RTC_CEN]  = to_bcd((tm->tm_year + 1900) / 100);
1159     s->regs[RTC_DAY]  = tm->tm_wday; /* one decimal digit */
1160 }
1161
1162 /* Write RTC MAX8998 by I2C through SMBus */
1163 static void max8998_rtc_write(SMBusDevice *dev, uint8_t cmd,
1164                               uint8_t *buf, int len)
1165 {
1166     MAX8998RTCState *s = (MAX8998RTCState *)dev;
1167     uint8_t *reg = NULL;
1168     int i;
1169
1170     switch (cmd) {
1171     case MAX8998_REG(RTC_SEC, MAX8998_RTC) ...
1172          MAX8998_REG(RTC_CEN, MAX8998_RTC):
1173     case MAX8998_ALRM0_CONF:
1174     case MAX8998_ALRM1_CONF:
1175         reg = &s->regs[cmd];
1176         break;
1177
1178     /* TODO: Implement alarm support */
1179     case MAX8998_REG(RTC_SEC, MAX8998_ALRM0) ...
1180          MAX8998_REG(RTC_CEN, MAX8998_ALRM1):
1181         return;
1182
1183     default:
1184         hw_error("max8998-rtc: bad write offset 0x%x\n", cmd);
1185     }
1186
1187     for (i = 0; i < len; i++) {
1188         *((uint8_t *)reg + i) = buf[i];
1189     }
1190
1191     if (cmd <= MAX8998_REG(RTC_CEN, MAX8998_RTC)) {
1192         max8998_rtc_set_time(s);
1193     }
1194 }
1195
1196 /* Read RTC MAX8998 by I2C through SMBus */
1197 static uint8_t max8998_rtc_read(SMBusDevice *dev, uint8_t cmd, int n)
1198 {
1199     MAX8998RTCState *s = (MAX8998RTCState *)dev;
1200     uint16_t val;
1201
1202     if (n > 0) {
1203         hw_error("max8998-rtc: bad read length %d\n", n);
1204     }
1205
1206     switch (cmd) {
1207     case MAX8998_REG(RTC_SEC, MAX8998_RTC) ...
1208          MAX8998_REG(RTC_CEN, MAX8998_RTC):
1209         max8998_rtc_read_time(s);
1210     case MAX8998_ALRM0_CONF:
1211     case MAX8998_ALRM1_CONF:
1212         val = s->regs[cmd];
1213         break;
1214
1215     /* TODO: Implement alarm support */
1216     case MAX8998_REG(RTC_SEC, MAX8998_ALRM0) ...
1217          MAX8998_REG(RTC_CEN, MAX8998_ALRM1):
1218         return 0;
1219
1220     default:
1221         hw_error("max8998-rtc: bad read offset 0x%x\n", cmd);
1222     }
1223
1224     return (val & 0xFF);
1225 }
1226
1227 static void max8998_rtc_save(QEMUFile *f, void *opaque)
1228 {
1229     MAX8998RTCState *s = (MAX8998RTCState *)opaque;
1230
1231     max8998_rtc_read_time(s);
1232
1233     qemu_put_buffer(f, s->regs, sizeof(s->regs));
1234     qemu_put_timer(f, s->seconds_timer);
1235 }
1236
1237 static int max8998_rtc_load(QEMUFile *f, void *opaque, int version_id)
1238 {
1239     MAX8998RTCState *s = (MAX8998RTCState *)opaque;
1240
1241     if (version_id != 1) {
1242         return -EINVAL;
1243     }
1244
1245     qemu_get_buffer(f, s->regs, sizeof(s->regs));
1246
1247     qemu_get_timedate(&s->current_tm, 0);
1248     max8998_rtc_read_time(s);
1249
1250     qemu_get_timer(f, s->seconds_timer);
1251
1252     return 0;
1253 }
1254
1255 DeviceState *max8998_rtc_init(i2c_bus *bus, int addr)
1256 {
1257     DeviceState *dev = qdev_create((BusState *)bus, "max8998-rtc");
1258     qdev_init_nofail(dev);
1259     i2c_set_slave_address((i2c_slave *)dev, addr);
1260     return dev;
1261 }
1262
1263 static int max8998_rtc_init1(SMBusDevice *dev)
1264 {
1265     MAX8998RTCState *s = (MAX8998RTCState *) dev;
1266
1267     s->seconds_timer = qemu_new_timer(vm_clock, max8998_rtc_seconds_update, s);
1268
1269     /* initialize values */
1270     max8998_rtc_reset(s);
1271
1272     qemu_register_reset(max8998_rtc_reset, s);
1273     register_savevm(&dev->i2c.qdev, "max8998-rtc", -1, 1,
1274                     max8998_rtc_save, max8998_rtc_load, s);
1275
1276     return 0;
1277 }
1278
1279 static SMBusDeviceInfo max8998_rtc_info = {
1280     .i2c.qdev.name = "max8998-rtc",
1281     .i2c.qdev.size = sizeof(MAX8998RTCState),
1282     .init          = max8998_rtc_init1,
1283     .write_data    = max8998_rtc_write,
1284     .read_data     = max8998_rtc_read
1285 };
1286
1287 static void s5pc1xx_pmu_register_devices(void)
1288 {
1289     sysbus_register_dev("s5pc1xx.pmu", sizeof(S5pc1xxPMUState), s5pc1xx_pmu_init);
1290     smbus_register_device(&max17040_info);
1291     smbus_register_device(&max8998_info);
1292     smbus_register_device(&max8998_rtc_info);
1293 }
1294
1295 device_init(s5pc1xx_pmu_register_devices)