Revision f0495f56
| b/hw/twl92230.c | ||
|---|---|---|
| 60 | 60 |
int alm_sec; |
| 61 | 61 |
int next_comp; |
| 62 | 62 |
} rtc; |
| 63 |
uint16_t rtc_next_vmstate; |
|
| 63 | 64 |
qemu_irq out[4]; |
| 64 | 65 |
qemu_irq *in; |
| 65 | 66 |
uint8_t pwrbtn_state; |
| ... | ... | |
| 747 | 748 |
return menelaus_read(s, s->reg ++); |
| 748 | 749 |
} |
| 749 | 750 |
|
| 750 |
static void tm_put(QEMUFile *f, struct tm *tm) {
|
|
| 751 |
qemu_put_be16(f, tm->tm_sec); |
|
| 752 |
qemu_put_be16(f, tm->tm_min); |
|
| 753 |
qemu_put_be16(f, tm->tm_hour); |
|
| 754 |
qemu_put_be16(f, tm->tm_mday); |
|
| 755 |
qemu_put_be16(f, tm->tm_min); |
|
| 756 |
qemu_put_be16(f, tm->tm_year); |
|
| 757 |
} |
|
| 751 |
/* Save restore 32 bit int as uint16_t |
|
| 752 |
This is a Big hack, but it is how the old state did it. |
|
| 753 |
Or we broke compatibility in the state, or we can't use struct tm |
|
| 754 |
*/ |
|
| 758 | 755 |
|
| 759 |
static void tm_get(QEMUFile *f, struct tm *tm) {
|
|
| 760 |
tm->tm_sec = qemu_get_be16(f); |
|
| 761 |
tm->tm_min = qemu_get_be16(f); |
|
| 762 |
tm->tm_hour = qemu_get_be16(f); |
|
| 763 |
tm->tm_mday = qemu_get_be16(f); |
|
| 764 |
tm->tm_min = qemu_get_be16(f); |
|
| 765 |
tm->tm_year = qemu_get_be16(f); |
|
| 756 |
static int get_int32_as_uint16(QEMUFile *f, void *pv, size_t size) |
|
| 757 |
{
|
|
| 758 |
int *v = pv; |
|
| 759 |
*v = qemu_get_be16(f); |
|
| 760 |
return 0; |
|
| 766 | 761 |
} |
| 767 | 762 |
|
| 768 |
static void menelaus_save(QEMUFile *f, void *opaque)
|
|
| 763 |
static void put_int32_as_uint16(QEMUFile *f, void *pv, size_t size)
|
|
| 769 | 764 |
{
|
| 770 |
MenelausState *s = (MenelausState *) opaque; |
|
| 765 |
int *v = pv; |
|
| 766 |
qemu_put_be16(f, *v); |
|
| 767 |
} |
|
| 771 | 768 |
|
| 772 |
qemu_put_be32(f, s->firstbyte); |
|
| 773 |
qemu_put_8s(f, &s->reg); |
|
| 774 |
|
|
| 775 |
qemu_put_8s(f, &s->vcore[0]); |
|
| 776 |
qemu_put_8s(f, &s->vcore[1]); |
|
| 777 |
qemu_put_8s(f, &s->vcore[2]); |
|
| 778 |
qemu_put_8s(f, &s->vcore[3]); |
|
| 779 |
qemu_put_8s(f, &s->vcore[4]); |
|
| 780 |
qemu_put_8s(f, &s->dcdc[0]); |
|
| 781 |
qemu_put_8s(f, &s->dcdc[1]); |
|
| 782 |
qemu_put_8s(f, &s->dcdc[2]); |
|
| 783 |
qemu_put_8s(f, &s->ldo[0]); |
|
| 784 |
qemu_put_8s(f, &s->ldo[1]); |
|
| 785 |
qemu_put_8s(f, &s->ldo[2]); |
|
| 786 |
qemu_put_8s(f, &s->ldo[3]); |
|
| 787 |
qemu_put_8s(f, &s->ldo[4]); |
|
| 788 |
qemu_put_8s(f, &s->ldo[5]); |
|
| 789 |
qemu_put_8s(f, &s->ldo[6]); |
|
| 790 |
qemu_put_8s(f, &s->ldo[7]); |
|
| 791 |
qemu_put_8s(f, &s->sleep[0]); |
|
| 792 |
qemu_put_8s(f, &s->sleep[1]); |
|
| 793 |
qemu_put_8s(f, &s->osc); |
|
| 794 |
qemu_put_8s(f, &s->detect); |
|
| 795 |
qemu_put_be16s(f, &s->mask); |
|
| 796 |
qemu_put_be16s(f, &s->status); |
|
| 797 |
qemu_put_8s(f, &s->dir); |
|
| 798 |
qemu_put_8s(f, &s->inputs); |
|
| 799 |
qemu_put_8s(f, &s->outputs); |
|
| 800 |
qemu_put_8s(f, &s->bbsms); |
|
| 801 |
qemu_put_8s(f, &s->pull[0]); |
|
| 802 |
qemu_put_8s(f, &s->pull[1]); |
|
| 803 |
qemu_put_8s(f, &s->pull[2]); |
|
| 804 |
qemu_put_8s(f, &s->pull[3]); |
|
| 805 |
qemu_put_8s(f, &s->mmc_ctrl[0]); |
|
| 806 |
qemu_put_8s(f, &s->mmc_ctrl[1]); |
|
| 807 |
qemu_put_8s(f, &s->mmc_ctrl[2]); |
|
| 808 |
qemu_put_8s(f, &s->mmc_debounce); |
|
| 809 |
qemu_put_8s(f, &s->rtc.ctrl); |
|
| 810 |
qemu_put_be16s(f, &s->rtc.comp); |
|
| 811 |
/* Should be <= 1000 */ |
|
| 812 |
qemu_put_be16(f, s->rtc.next - qemu_get_clock(rt_clock)); |
|
| 813 |
tm_put(f, &s->rtc.new); |
|
| 814 |
tm_put(f, &s->rtc.alm); |
|
| 815 |
qemu_put_byte(f, s->pwrbtn_state); |
|
| 769 |
const VMStateInfo vmstate_hack_int32_as_uint16 = {
|
|
| 770 |
.name = "int32_as_uint16", |
|
| 771 |
.get = get_int32_as_uint16, |
|
| 772 |
.put = put_int32_as_uint16, |
|
| 773 |
}; |
|
| 816 | 774 |
|
| 817 |
i2c_slave_save(f, &s->i2c); |
|
| 818 |
} |
|
| 775 |
#define VMSTATE_UINT16_HACK(_f, _s) \ |
|
| 776 |
VMSTATE_SINGLE(_f, _s, 0, vmstate_hack_int32_as_uint16, int32_t) |
|
| 777 |
|
|
| 778 |
|
|
| 779 |
static const VMStateDescription vmstate_menelaus_tm = {
|
|
| 780 |
.name = "menelaus_tm", |
|
| 781 |
.version_id = 0, |
|
| 782 |
.minimum_version_id = 0, |
|
| 783 |
.minimum_version_id_old = 0, |
|
| 784 |
.fields = (VMStateField []) {
|
|
| 785 |
VMSTATE_UINT16_HACK(tm_sec, struct tm), |
|
| 786 |
VMSTATE_UINT16_HACK(tm_min, struct tm), |
|
| 787 |
VMSTATE_UINT16_HACK(tm_hour, struct tm), |
|
| 788 |
VMSTATE_UINT16_HACK(tm_mday, struct tm), |
|
| 789 |
VMSTATE_UINT16_HACK(tm_min, struct tm), |
|
| 790 |
VMSTATE_UINT16_HACK(tm_year, struct tm), |
|
| 791 |
VMSTATE_END_OF_LIST() |
|
| 792 |
} |
|
| 793 |
}; |
|
| 819 | 794 |
|
| 820 |
static int menelaus_load(QEMUFile *f, void *opaque, int version_id)
|
|
| 795 |
static void menelaus_pre_save(void *opaque)
|
|
| 821 | 796 |
{
|
| 822 |
MenelausState *s = (MenelausState *) opaque; |
|
| 797 |
MenelausState *s = opaque; |
|
| 798 |
/* Should be <= 1000 */ |
|
| 799 |
s->rtc_next_vmstate = s->rtc.next - qemu_get_clock(rt_clock); |
|
| 800 |
} |
|
| 823 | 801 |
|
| 824 |
s->firstbyte = qemu_get_be32(f); |
|
| 825 |
qemu_get_8s(f, &s->reg); |
|
| 802 |
static int menelaus_post_load(void *opaque, int version_id) |
|
| 803 |
{
|
|
| 804 |
MenelausState *s = opaque; |
|
| 826 | 805 |
|
| 827 | 806 |
if (s->rtc.ctrl & 1) /* RTC_EN */ |
| 828 | 807 |
menelaus_rtc_stop(s); |
| 829 |
qemu_get_8s(f, &s->vcore[0]); |
|
| 830 |
qemu_get_8s(f, &s->vcore[1]); |
|
| 831 |
qemu_get_8s(f, &s->vcore[2]); |
|
| 832 |
qemu_get_8s(f, &s->vcore[3]); |
|
| 833 |
qemu_get_8s(f, &s->vcore[4]); |
|
| 834 |
qemu_get_8s(f, &s->dcdc[0]); |
|
| 835 |
qemu_get_8s(f, &s->dcdc[1]); |
|
| 836 |
qemu_get_8s(f, &s->dcdc[2]); |
|
| 837 |
qemu_get_8s(f, &s->ldo[0]); |
|
| 838 |
qemu_get_8s(f, &s->ldo[1]); |
|
| 839 |
qemu_get_8s(f, &s->ldo[2]); |
|
| 840 |
qemu_get_8s(f, &s->ldo[3]); |
|
| 841 |
qemu_get_8s(f, &s->ldo[4]); |
|
| 842 |
qemu_get_8s(f, &s->ldo[5]); |
|
| 843 |
qemu_get_8s(f, &s->ldo[6]); |
|
| 844 |
qemu_get_8s(f, &s->ldo[7]); |
|
| 845 |
qemu_get_8s(f, &s->sleep[0]); |
|
| 846 |
qemu_get_8s(f, &s->sleep[1]); |
|
| 847 |
qemu_get_8s(f, &s->osc); |
|
| 848 |
qemu_get_8s(f, &s->detect); |
|
| 849 |
qemu_get_be16s(f, &s->mask); |
|
| 850 |
qemu_get_be16s(f, &s->status); |
|
| 851 |
qemu_get_8s(f, &s->dir); |
|
| 852 |
qemu_get_8s(f, &s->inputs); |
|
| 853 |
qemu_get_8s(f, &s->outputs); |
|
| 854 |
qemu_get_8s(f, &s->bbsms); |
|
| 855 |
qemu_get_8s(f, &s->pull[0]); |
|
| 856 |
qemu_get_8s(f, &s->pull[1]); |
|
| 857 |
qemu_get_8s(f, &s->pull[2]); |
|
| 858 |
qemu_get_8s(f, &s->pull[3]); |
|
| 859 |
qemu_get_8s(f, &s->mmc_ctrl[0]); |
|
| 860 |
qemu_get_8s(f, &s->mmc_ctrl[1]); |
|
| 861 |
qemu_get_8s(f, &s->mmc_ctrl[2]); |
|
| 862 |
qemu_get_8s(f, &s->mmc_debounce); |
|
| 863 |
qemu_get_8s(f, &s->rtc.ctrl); |
|
| 864 |
qemu_get_be16s(f, &s->rtc.comp); |
|
| 865 |
s->rtc.next = qemu_get_be16(f); |
|
| 866 |
tm_get(f, &s->rtc.new); |
|
| 867 |
tm_get(f, &s->rtc.alm); |
|
| 868 |
s->pwrbtn_state = qemu_get_byte(f); |
|
| 808 |
|
|
| 809 |
s->rtc.next = s->rtc_next_vmstate; |
|
| 810 |
|
|
| 869 | 811 |
menelaus_alm_update(s); |
| 870 | 812 |
menelaus_update(s); |
| 871 | 813 |
if (s->rtc.ctrl & 1) /* RTC_EN */ |
| 872 | 814 |
menelaus_rtc_start(s); |
| 873 |
|
|
| 874 |
i2c_slave_load(f, &s->i2c); |
|
| 875 | 815 |
return 0; |
| 876 | 816 |
} |
| 877 | 817 |
|
| 818 |
static const VMStateDescription vmstate_menelaus = {
|
|
| 819 |
.name = "menelaus", |
|
| 820 |
.version_id = 0, |
|
| 821 |
.minimum_version_id = 0, |
|
| 822 |
.minimum_version_id_old = 0, |
|
| 823 |
.pre_save = menelaus_pre_save, |
|
| 824 |
.post_load = menelaus_post_load, |
|
| 825 |
.fields = (VMStateField []) {
|
|
| 826 |
VMSTATE_INT32(firstbyte, MenelausState), |
|
| 827 |
VMSTATE_UINT8(reg, MenelausState), |
|
| 828 |
VMSTATE_UINT8_ARRAY(vcore, MenelausState, 5), |
|
| 829 |
VMSTATE_UINT8_ARRAY(dcdc, MenelausState, 3), |
|
| 830 |
VMSTATE_UINT8_ARRAY(ldo, MenelausState, 8), |
|
| 831 |
VMSTATE_UINT8_ARRAY(sleep, MenelausState, 2), |
|
| 832 |
VMSTATE_UINT8(osc, MenelausState), |
|
| 833 |
VMSTATE_UINT8(detect, MenelausState), |
|
| 834 |
VMSTATE_UINT16(mask, MenelausState), |
|
| 835 |
VMSTATE_UINT16(status, MenelausState), |
|
| 836 |
VMSTATE_UINT8(dir, MenelausState), |
|
| 837 |
VMSTATE_UINT8(inputs, MenelausState), |
|
| 838 |
VMSTATE_UINT8(outputs, MenelausState), |
|
| 839 |
VMSTATE_UINT8(bbsms, MenelausState), |
|
| 840 |
VMSTATE_UINT8_ARRAY(pull, MenelausState, 4), |
|
| 841 |
VMSTATE_UINT8_ARRAY(mmc_ctrl, MenelausState, 3), |
|
| 842 |
VMSTATE_UINT8(mmc_debounce, MenelausState), |
|
| 843 |
VMSTATE_UINT8(rtc.ctrl, MenelausState), |
|
| 844 |
VMSTATE_UINT16(rtc.comp, MenelausState), |
|
| 845 |
VMSTATE_UINT16(rtc_next_vmstate, MenelausState), |
|
| 846 |
VMSTATE_STRUCT(rtc.new, MenelausState, 0, vmstate_menelaus_tm, |
|
| 847 |
struct tm), |
|
| 848 |
VMSTATE_STRUCT(rtc.alm, MenelausState, 0, vmstate_menelaus_tm, |
|
| 849 |
struct tm), |
|
| 850 |
VMSTATE_UINT8(pwrbtn_state, MenelausState), |
|
| 851 |
VMSTATE_I2C_SLAVE(i2c, MenelausState), |
|
| 852 |
VMSTATE_END_OF_LIST() |
|
| 853 |
} |
|
| 854 |
}; |
|
| 855 |
|
|
| 878 | 856 |
static int twl92230_init(i2c_slave *i2c) |
| 879 | 857 |
{
|
| 880 | 858 |
MenelausState *s = FROM_I2C_SLAVE(MenelausState, i2c); |
| ... | ... | |
| 887 | 865 |
|
| 888 | 866 |
menelaus_reset(&s->i2c); |
| 889 | 867 |
|
| 890 |
register_savevm("menelaus", -1, 0, menelaus_save, menelaus_load, s);
|
|
| 868 |
vmstate_register(-1, &vmstate_menelaus, s);
|
|
| 891 | 869 |
return 0; |
| 892 | 870 |
} |
| 893 | 871 |
|
Also available in: Unified diff