]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * PCA9552 I2C LED blinker | |
3 | * | |
4 | * https://www.nxp.com/docs/en/application-note/AN264.pdf | |
5 | * | |
6 | * Copyright (c) 2017-2018, IBM Corporation. | |
7 | * Copyright (c) 2020 Philippe Mathieu-Daudé | |
8 | * | |
9 | * This work is licensed under the terms of the GNU GPL, version 2 or | |
10 | * later. See the COPYING file in the top-level directory. | |
11 | */ | |
12 | ||
13 | #include "qemu/osdep.h" | |
14 | #include "qemu/log.h" | |
15 | #include "qemu/module.h" | |
16 | #include "qemu/bitops.h" | |
17 | #include "hw/qdev-properties.h" | |
18 | #include "hw/misc/pca9552.h" | |
19 | #include "hw/misc/pca9552_regs.h" | |
20 | #include "hw/irq.h" | |
21 | #include "migration/vmstate.h" | |
22 | #include "qapi/error.h" | |
23 | #include "qapi/visitor.h" | |
24 | #include "trace.h" | |
25 | #include "qom/object.h" | |
26 | ||
27 | struct PCA955xClass { | |
28 | /*< private >*/ | |
29 | I2CSlaveClass parent_class; | |
30 | /*< public >*/ | |
31 | ||
32 | uint8_t pin_count; | |
33 | uint8_t max_reg; | |
34 | }; | |
35 | typedef struct PCA955xClass PCA955xClass; | |
36 | ||
37 | DECLARE_CLASS_CHECKERS(PCA955xClass, PCA955X, | |
38 | TYPE_PCA955X) | |
39 | ||
40 | #define PCA9552_LED_ON 0x0 | |
41 | #define PCA9552_LED_OFF 0x1 | |
42 | #define PCA9552_LED_PWM0 0x2 | |
43 | #define PCA9552_LED_PWM1 0x3 | |
44 | ||
45 | static const char *led_state[] = {"on", "off", "pwm0", "pwm1"}; | |
46 | ||
47 | static uint8_t pca955x_pin_get_config(PCA955xState *s, int pin) | |
48 | { | |
49 | uint8_t reg = PCA9552_LS0 + (pin / 4); | |
50 | uint8_t shift = (pin % 4) << 1; | |
51 | ||
52 | return extract32(s->regs[reg], shift, 2); | |
53 | } | |
54 | ||
55 | /* Return INPUT status (bit #N belongs to GPIO #N) */ | |
56 | static uint16_t pca955x_pins_get_status(PCA955xState *s) | |
57 | { | |
58 | return (s->regs[PCA9552_INPUT1] << 8) | s->regs[PCA9552_INPUT0]; | |
59 | } | |
60 | ||
61 | static void pca955x_display_pins_status(PCA955xState *s, | |
62 | uint16_t previous_pins_status) | |
63 | { | |
64 | PCA955xClass *k = PCA955X_GET_CLASS(s); | |
65 | uint16_t pins_status, pins_changed; | |
66 | int i; | |
67 | ||
68 | pins_status = pca955x_pins_get_status(s); | |
69 | pins_changed = previous_pins_status ^ pins_status; | |
70 | if (!pins_changed) { | |
71 | return; | |
72 | } | |
73 | if (trace_event_get_state_backends(TRACE_PCA955X_GPIO_STATUS)) { | |
74 | char *buf = g_newa(char, k->pin_count + 1); | |
75 | ||
76 | for (i = 0; i < k->pin_count; i++) { | |
77 | if (extract32(pins_status, i, 1)) { | |
78 | buf[i] = '*'; | |
79 | } else { | |
80 | buf[i] = '.'; | |
81 | } | |
82 | } | |
83 | buf[i] = '\0'; | |
84 | trace_pca955x_gpio_status(s->description, buf); | |
85 | } | |
86 | if (trace_event_get_state_backends(TRACE_PCA955X_GPIO_CHANGE)) { | |
87 | for (i = 0; i < k->pin_count; i++) { | |
88 | if (extract32(pins_changed, i, 1)) { | |
89 | unsigned new_state = extract32(pins_status, i, 1); | |
90 | ||
91 | /* | |
92 | * We display the state using the PCA logic ("active-high"). | |
93 | * This is not the state of the LED, which signal might be | |
94 | * wired "active-low" on the board. | |
95 | */ | |
96 | trace_pca955x_gpio_change(s->description, i, | |
97 | !new_state, new_state); | |
98 | } | |
99 | } | |
100 | } | |
101 | } | |
102 | ||
103 | static void pca955x_update_pin_input(PCA955xState *s) | |
104 | { | |
105 | PCA955xClass *k = PCA955X_GET_CLASS(s); | |
106 | int i; | |
107 | ||
108 | for (i = 0; i < k->pin_count; i++) { | |
109 | uint8_t input_reg = PCA9552_INPUT0 + (i / 8); | |
110 | uint8_t input_shift = (i % 8); | |
111 | uint8_t config = pca955x_pin_get_config(s, i); | |
112 | ||
113 | switch (config) { | |
114 | case PCA9552_LED_ON: | |
115 | qemu_set_irq(s->gpio[i], 1); | |
116 | s->regs[input_reg] |= 1 << input_shift; | |
117 | break; | |
118 | case PCA9552_LED_OFF: | |
119 | qemu_set_irq(s->gpio[i], 0); | |
120 | s->regs[input_reg] &= ~(1 << input_shift); | |
121 | break; | |
122 | case PCA9552_LED_PWM0: | |
123 | case PCA9552_LED_PWM1: | |
124 | /* TODO */ | |
125 | default: | |
126 | break; | |
127 | } | |
128 | } | |
129 | } | |
130 | ||
131 | static uint8_t pca955x_read(PCA955xState *s, uint8_t reg) | |
132 | { | |
133 | switch (reg) { | |
134 | case PCA9552_INPUT0: | |
135 | case PCA9552_INPUT1: | |
136 | case PCA9552_PSC0: | |
137 | case PCA9552_PWM0: | |
138 | case PCA9552_PSC1: | |
139 | case PCA9552_PWM1: | |
140 | case PCA9552_LS0: | |
141 | case PCA9552_LS1: | |
142 | case PCA9552_LS2: | |
143 | case PCA9552_LS3: | |
144 | return s->regs[reg]; | |
145 | default: | |
146 | qemu_log_mask(LOG_GUEST_ERROR, "%s: unexpected read to register %d\n", | |
147 | __func__, reg); | |
148 | return 0xFF; | |
149 | } | |
150 | } | |
151 | ||
152 | static void pca955x_write(PCA955xState *s, uint8_t reg, uint8_t data) | |
153 | { | |
154 | uint16_t pins_status; | |
155 | ||
156 | switch (reg) { | |
157 | case PCA9552_PSC0: | |
158 | case PCA9552_PWM0: | |
159 | case PCA9552_PSC1: | |
160 | case PCA9552_PWM1: | |
161 | s->regs[reg] = data; | |
162 | break; | |
163 | ||
164 | case PCA9552_LS0: | |
165 | case PCA9552_LS1: | |
166 | case PCA9552_LS2: | |
167 | case PCA9552_LS3: | |
168 | pins_status = pca955x_pins_get_status(s); | |
169 | s->regs[reg] = data; | |
170 | pca955x_update_pin_input(s); | |
171 | pca955x_display_pins_status(s, pins_status); | |
172 | break; | |
173 | ||
174 | case PCA9552_INPUT0: | |
175 | case PCA9552_INPUT1: | |
176 | default: | |
177 | qemu_log_mask(LOG_GUEST_ERROR, "%s: unexpected write to register %d\n", | |
178 | __func__, reg); | |
179 | } | |
180 | } | |
181 | ||
182 | /* | |
183 | * When Auto-Increment is on, the register address is incremented | |
184 | * after each byte is sent to or received by the device. The index | |
185 | * rollovers to 0 when the maximum register address is reached. | |
186 | */ | |
187 | static void pca955x_autoinc(PCA955xState *s) | |
188 | { | |
189 | PCA955xClass *k = PCA955X_GET_CLASS(s); | |
190 | ||
191 | if (s->pointer != 0xFF && s->pointer & PCA9552_AUTOINC) { | |
192 | uint8_t reg = s->pointer & 0xf; | |
193 | ||
194 | reg = (reg + 1) % (k->max_reg + 1); | |
195 | s->pointer = reg | PCA9552_AUTOINC; | |
196 | } | |
197 | } | |
198 | ||
199 | static uint8_t pca955x_recv(I2CSlave *i2c) | |
200 | { | |
201 | PCA955xState *s = PCA955X(i2c); | |
202 | uint8_t ret; | |
203 | ||
204 | ret = pca955x_read(s, s->pointer & 0xf); | |
205 | ||
206 | /* | |
207 | * From the Specs: | |
208 | * | |
209 | * Important Note: When a Read sequence is initiated and the | |
210 | * AI bit is set to Logic Level 1, the Read Sequence MUST | |
211 | * start by a register different from 0. | |
212 | * | |
213 | * I don't know what should be done in this case, so throw an | |
214 | * error. | |
215 | */ | |
216 | if (s->pointer == PCA9552_AUTOINC) { | |
217 | qemu_log_mask(LOG_GUEST_ERROR, | |
218 | "%s: Autoincrement read starting with register 0\n", | |
219 | __func__); | |
220 | } | |
221 | ||
222 | pca955x_autoinc(s); | |
223 | ||
224 | return ret; | |
225 | } | |
226 | ||
227 | static int pca955x_send(I2CSlave *i2c, uint8_t data) | |
228 | { | |
229 | PCA955xState *s = PCA955X(i2c); | |
230 | ||
231 | /* First byte sent by is the register address */ | |
232 | if (s->len == 0) { | |
233 | s->pointer = data; | |
234 | s->len++; | |
235 | } else { | |
236 | pca955x_write(s, s->pointer & 0xf, data); | |
237 | ||
238 | pca955x_autoinc(s); | |
239 | } | |
240 | ||
241 | return 0; | |
242 | } | |
243 | ||
244 | static int pca955x_event(I2CSlave *i2c, enum i2c_event event) | |
245 | { | |
246 | PCA955xState *s = PCA955X(i2c); | |
247 | ||
248 | s->len = 0; | |
249 | return 0; | |
250 | } | |
251 | ||
252 | static void pca955x_get_led(Object *obj, Visitor *v, const char *name, | |
253 | void *opaque, Error **errp) | |
254 | { | |
255 | PCA955xClass *k = PCA955X_GET_CLASS(obj); | |
256 | PCA955xState *s = PCA955X(obj); | |
257 | int led, rc, reg; | |
258 | uint8_t state; | |
259 | ||
260 | rc = sscanf(name, "led%2d", &led); | |
261 | if (rc != 1) { | |
262 | error_setg(errp, "%s: error reading %s", __func__, name); | |
263 | return; | |
264 | } | |
265 | if (led < 0 || led > k->pin_count) { | |
266 | error_setg(errp, "%s invalid led %s", __func__, name); | |
267 | return; | |
268 | } | |
269 | /* | |
270 | * Get the LSx register as the qom interface should expose the device | |
271 | * state, not the modeled 'input line' behaviour which would come from | |
272 | * reading the INPUTx reg | |
273 | */ | |
274 | reg = PCA9552_LS0 + led / 4; | |
275 | state = (pca955x_read(s, reg) >> ((led % 4) * 2)) & 0x3; | |
276 | visit_type_str(v, name, (char **)&led_state[state], errp); | |
277 | } | |
278 | ||
279 | /* | |
280 | * Return an LED selector register value based on an existing one, with | |
281 | * the appropriate 2-bit state value set for the given LED number (0-3). | |
282 | */ | |
283 | static inline uint8_t pca955x_ledsel(uint8_t oldval, int led_num, int state) | |
284 | { | |
285 | return (oldval & (~(0x3 << (led_num << 1)))) | | |
286 | ((state & 0x3) << (led_num << 1)); | |
287 | } | |
288 | ||
289 | static void pca955x_set_led(Object *obj, Visitor *v, const char *name, | |
290 | void *opaque, Error **errp) | |
291 | { | |
292 | PCA955xClass *k = PCA955X_GET_CLASS(obj); | |
293 | PCA955xState *s = PCA955X(obj); | |
294 | int led, rc, reg, val; | |
295 | uint8_t state; | |
296 | char *state_str; | |
297 | ||
298 | if (!visit_type_str(v, name, &state_str, errp)) { | |
299 | return; | |
300 | } | |
301 | rc = sscanf(name, "led%2d", &led); | |
302 | if (rc != 1) { | |
303 | error_setg(errp, "%s: error reading %s", __func__, name); | |
304 | return; | |
305 | } | |
306 | if (led < 0 || led > k->pin_count) { | |
307 | error_setg(errp, "%s invalid led %s", __func__, name); | |
308 | return; | |
309 | } | |
310 | ||
311 | for (state = 0; state < ARRAY_SIZE(led_state); state++) { | |
312 | if (!strcmp(state_str, led_state[state])) { | |
313 | break; | |
314 | } | |
315 | } | |
316 | if (state >= ARRAY_SIZE(led_state)) { | |
317 | error_setg(errp, "%s invalid led state %s", __func__, state_str); | |
318 | return; | |
319 | } | |
320 | ||
321 | reg = PCA9552_LS0 + led / 4; | |
322 | val = pca955x_read(s, reg); | |
323 | val = pca955x_ledsel(val, led % 4, state); | |
324 | pca955x_write(s, reg, val); | |
325 | } | |
326 | ||
327 | static const VMStateDescription pca9552_vmstate = { | |
328 | .name = "PCA9552", | |
329 | .version_id = 0, | |
330 | .minimum_version_id = 0, | |
331 | .fields = (VMStateField[]) { | |
332 | VMSTATE_UINT8(len, PCA955xState), | |
333 | VMSTATE_UINT8(pointer, PCA955xState), | |
334 | VMSTATE_UINT8_ARRAY(regs, PCA955xState, PCA955X_NR_REGS), | |
335 | VMSTATE_I2C_SLAVE(i2c, PCA955xState), | |
336 | VMSTATE_END_OF_LIST() | |
337 | } | |
338 | }; | |
339 | ||
340 | static void pca9552_reset(DeviceState *dev) | |
341 | { | |
342 | PCA955xState *s = PCA955X(dev); | |
343 | ||
344 | s->regs[PCA9552_PSC0] = 0xFF; | |
345 | s->regs[PCA9552_PWM0] = 0x80; | |
346 | s->regs[PCA9552_PSC1] = 0xFF; | |
347 | s->regs[PCA9552_PWM1] = 0x80; | |
348 | s->regs[PCA9552_LS0] = 0x55; /* all OFF */ | |
349 | s->regs[PCA9552_LS1] = 0x55; | |
350 | s->regs[PCA9552_LS2] = 0x55; | |
351 | s->regs[PCA9552_LS3] = 0x55; | |
352 | ||
353 | pca955x_update_pin_input(s); | |
354 | ||
355 | s->pointer = 0xFF; | |
356 | s->len = 0; | |
357 | } | |
358 | ||
359 | static void pca955x_initfn(Object *obj) | |
360 | { | |
361 | PCA955xClass *k = PCA955X_GET_CLASS(obj); | |
362 | int led; | |
363 | ||
364 | assert(k->pin_count <= PCA955X_PIN_COUNT_MAX); | |
365 | for (led = 0; led < k->pin_count; led++) { | |
366 | char *name; | |
367 | ||
368 | name = g_strdup_printf("led%d", led); | |
369 | object_property_add(obj, name, "bool", pca955x_get_led, pca955x_set_led, | |
370 | NULL, NULL); | |
371 | g_free(name); | |
372 | } | |
373 | } | |
374 | ||
375 | static void pca955x_realize(DeviceState *dev, Error **errp) | |
376 | { | |
377 | PCA955xClass *k = PCA955X_GET_CLASS(dev); | |
378 | PCA955xState *s = PCA955X(dev); | |
379 | ||
380 | if (!s->description) { | |
381 | s->description = g_strdup("pca-unspecified"); | |
382 | } | |
383 | ||
384 | qdev_init_gpio_out(dev, s->gpio, k->pin_count); | |
385 | } | |
386 | ||
387 | static Property pca955x_properties[] = { | |
388 | DEFINE_PROP_STRING("description", PCA955xState, description), | |
389 | DEFINE_PROP_END_OF_LIST(), | |
390 | }; | |
391 | ||
392 | static void pca955x_class_init(ObjectClass *klass, void *data) | |
393 | { | |
394 | DeviceClass *dc = DEVICE_CLASS(klass); | |
395 | I2CSlaveClass *k = I2C_SLAVE_CLASS(klass); | |
396 | ||
397 | k->event = pca955x_event; | |
398 | k->recv = pca955x_recv; | |
399 | k->send = pca955x_send; | |
400 | dc->realize = pca955x_realize; | |
401 | device_class_set_props(dc, pca955x_properties); | |
402 | } | |
403 | ||
404 | static const TypeInfo pca955x_info = { | |
405 | .name = TYPE_PCA955X, | |
406 | .parent = TYPE_I2C_SLAVE, | |
407 | .instance_init = pca955x_initfn, | |
408 | .instance_size = sizeof(PCA955xState), | |
409 | .class_init = pca955x_class_init, | |
410 | .class_size = sizeof(PCA955xClass), | |
411 | .abstract = true, | |
412 | }; | |
413 | ||
414 | static void pca9552_class_init(ObjectClass *oc, void *data) | |
415 | { | |
416 | DeviceClass *dc = DEVICE_CLASS(oc); | |
417 | PCA955xClass *pc = PCA955X_CLASS(oc); | |
418 | ||
419 | dc->reset = pca9552_reset; | |
420 | dc->vmsd = &pca9552_vmstate; | |
421 | pc->max_reg = PCA9552_LS3; | |
422 | pc->pin_count = 16; | |
423 | } | |
424 | ||
425 | static const TypeInfo pca9552_info = { | |
426 | .name = TYPE_PCA9552, | |
427 | .parent = TYPE_PCA955X, | |
428 | .class_init = pca9552_class_init, | |
429 | }; | |
430 | ||
431 | static void pca955x_register_types(void) | |
432 | { | |
433 | type_register_static(&pca955x_info); | |
434 | type_register_static(&pca9552_info); | |
435 | } | |
436 | ||
437 | type_init(pca955x_register_types) |