misc/max111x: QOM casting sweep
[qemu.git] / hw / misc / max111x.c
1 /*
2 * Maxim MAX1110/1111 ADC chip emulation.
3 *
4 * Copyright (c) 2006 Openedhand Ltd.
5 * Written by Andrzej Zaborowski <balrog@zabor.org>
6 *
7 * This code is licensed under the GNU GPLv2.
8 *
9 * Contributions after 2012-01-13 are licensed under the terms of the
10 * GNU GPL, version 2 or (at your option) any later version.
11 */
12
13 #include "hw/ssi.h"
14
15 typedef struct {
16 SSISlave parent_obj;
17
18 qemu_irq interrupt;
19 uint8_t tb1, rb2, rb3;
20 int cycle;
21
22 uint8_t input[8];
23 int inputs, com;
24 } MAX111xState;
25
26 #define TYPE_MAX_111X "max111x"
27
28 #define MAX_111X(obj) \
29 OBJECT_CHECK(MAX111xState, (obj), TYPE_MAX_111X)
30
31 #define TYPE_MAX_1110 "max1110"
32 #define TYPE_MAX_1111 "max1111"
33
34 /* Control-byte bitfields */
35 #define CB_PD0 (1 << 0)
36 #define CB_PD1 (1 << 1)
37 #define CB_SGL (1 << 2)
38 #define CB_UNI (1 << 3)
39 #define CB_SEL0 (1 << 4)
40 #define CB_SEL1 (1 << 5)
41 #define CB_SEL2 (1 << 6)
42 #define CB_START (1 << 7)
43
44 #define CHANNEL_NUM(v, b0, b1, b2) \
45 ((((v) >> (2 + (b0))) & 4) | \
46 (((v) >> (3 + (b1))) & 2) | \
47 (((v) >> (4 + (b2))) & 1))
48
49 static uint32_t max111x_read(MAX111xState *s)
50 {
51 if (!s->tb1)
52 return 0;
53
54 switch (s->cycle ++) {
55 case 1:
56 return s->rb2;
57 case 2:
58 return s->rb3;
59 }
60
61 return 0;
62 }
63
64 /* Interpret a control-byte */
65 static void max111x_write(MAX111xState *s, uint32_t value)
66 {
67 int measure, chan;
68
69 /* Ignore the value if START bit is zero */
70 if (!(value & CB_START))
71 return;
72
73 s->cycle = 0;
74
75 if (!(value & CB_PD1)) {
76 s->tb1 = 0;
77 return;
78 }
79
80 s->tb1 = value;
81
82 if (s->inputs == 8)
83 chan = CHANNEL_NUM(value, 1, 0, 2);
84 else
85 chan = CHANNEL_NUM(value & ~CB_SEL0, 0, 1, 2);
86
87 if (value & CB_SGL)
88 measure = s->input[chan] - s->com;
89 else
90 measure = s->input[chan] - s->input[chan ^ 1];
91
92 if (!(value & CB_UNI))
93 measure ^= 0x80;
94
95 s->rb2 = (measure >> 2) & 0x3f;
96 s->rb3 = (measure << 6) & 0xc0;
97
98 /* FIXME: When should the IRQ be lowered? */
99 qemu_irq_raise(s->interrupt);
100 }
101
102 static uint32_t max111x_transfer(SSISlave *dev, uint32_t value)
103 {
104 MAX111xState *s = MAX_111X(dev);
105 max111x_write(s, value);
106 return max111x_read(s);
107 }
108
109 static const VMStateDescription vmstate_max111x = {
110 .name = "max111x",
111 .version_id = 1,
112 .minimum_version_id = 1,
113 .minimum_version_id_old = 1,
114 .fields = (VMStateField[]) {
115 VMSTATE_SSI_SLAVE(parent_obj, MAX111xState),
116 VMSTATE_UINT8(tb1, MAX111xState),
117 VMSTATE_UINT8(rb2, MAX111xState),
118 VMSTATE_UINT8(rb3, MAX111xState),
119 VMSTATE_INT32_EQUAL(inputs, MAX111xState),
120 VMSTATE_INT32(com, MAX111xState),
121 VMSTATE_ARRAY_INT32_UNSAFE(input, MAX111xState, inputs,
122 vmstate_info_uint8, uint8_t),
123 VMSTATE_END_OF_LIST()
124 }
125 };
126
127 static int max111x_init(SSISlave *d, int inputs)
128 {
129 DeviceState *dev = DEVICE(d);
130 MAX111xState *s = MAX_111X(dev);
131
132 qdev_init_gpio_out(dev, &s->interrupt, 1);
133
134 s->inputs = inputs;
135 /* TODO: add a user interface for setting these */
136 s->input[0] = 0xf0;
137 s->input[1] = 0xe0;
138 s->input[2] = 0xd0;
139 s->input[3] = 0xc0;
140 s->input[4] = 0xb0;
141 s->input[5] = 0xa0;
142 s->input[6] = 0x90;
143 s->input[7] = 0x80;
144 s->com = 0;
145
146 vmstate_register(dev, -1, &vmstate_max111x, s);
147 return 0;
148 }
149
150 static int max1110_init(SSISlave *dev)
151 {
152 return max111x_init(dev, 8);
153 }
154
155 static int max1111_init(SSISlave *dev)
156 {
157 return max111x_init(dev, 4);
158 }
159
160 void max111x_set_input(DeviceState *dev, int line, uint8_t value)
161 {
162 MAX111xState *s = MAX_111X(dev);
163 assert(line >= 0 && line < s->inputs);
164 s->input[line] = value;
165 }
166
167 static void max111x_class_init(ObjectClass *klass, void *data)
168 {
169 SSISlaveClass *k = SSI_SLAVE_CLASS(klass);
170
171 k->transfer = max111x_transfer;
172 }
173
174 static const TypeInfo max111x_info = {
175 .name = TYPE_MAX_111X,
176 .parent = TYPE_SSI_SLAVE,
177 .instance_size = sizeof(MAX111xState),
178 .class_init = max111x_class_init,
179 .abstract = true,
180 };
181
182 static void max1110_class_init(ObjectClass *klass, void *data)
183 {
184 SSISlaveClass *k = SSI_SLAVE_CLASS(klass);
185
186 k->init = max1110_init;
187 }
188
189 static const TypeInfo max1110_info = {
190 .name = TYPE_MAX_1110,
191 .parent = TYPE_MAX_111X,
192 .class_init = max1110_class_init,
193 };
194
195 static void max1111_class_init(ObjectClass *klass, void *data)
196 {
197 SSISlaveClass *k = SSI_SLAVE_CLASS(klass);
198
199 k->init = max1111_init;
200 }
201
202 static const TypeInfo max1111_info = {
203 .name = TYPE_MAX_1111,
204 .parent = TYPE_MAX_111X,
205 .class_init = max1111_class_init,
206 };
207
208 static void max111x_register_types(void)
209 {
210 type_register_static(&max111x_info);
211 type_register_static(&max1110_info);
212 type_register_static(&max1111_info);
213 }
214
215 type_init(max111x_register_types)