hw/misc/pca9552.c

   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  *
   8  * This work is licensed under the terms of the GNU GPL, version 2 or
   9  * later. See the COPYING file in the top-level directory.
  10  */
  11
  12 #include "qemu/osdep.h"
  13 #include "qemu/log.h"
  14 #include "qemu/module.h"
  15 #include "hw/misc/pca9552.h"
  16 #include "hw/misc/pca9552_regs.h"
  17 #include "migration/vmstate.h"
  18
  19 #define PCA9552_LED_ON   0x0
  20 #define PCA9552_LED_OFF  0x1
  21 #define PCA9552_LED_PWM0 0x2
  22 #define PCA9552_LED_PWM1 0x3
  23
  24 static uint8_t pca9552_pin_get_config(PCA9552State *s, int pin)
  25 {
  26     uint8_t reg   = PCA9552_LS0 + (pin / 4);
  27     uint8_t shift = (pin % 4) << 1;
  28
  29     return extract32(s->regs[reg], shift, 2);
  30 }
  31
  32 static void pca9552_update_pin_input(PCA9552State *s)
  33 {
  34     int i;
  35
  36     for (i = 0; i < s->nr_leds; i++) {
  37         uint8_t input_reg = PCA9552_INPUT0 + (i / 8);
  38         uint8_t input_shift = (i % 8);
  39         uint8_t config = pca9552_pin_get_config(s, i);
  40
  41         switch (config) {
  42         case PCA9552_LED_ON:
  43             s->regs[input_reg] |= 1 << input_shift;
  44             break;
  45         case PCA9552_LED_OFF:
  46             s->regs[input_reg] &= ~(1 << input_shift);
  47             break;
  48         case PCA9552_LED_PWM0:
  49         case PCA9552_LED_PWM1:
  50             /* TODO */
  51         default:
  52             break;
  53         }
  54     }
  55 }
  56
  57 static uint8_t pca9552_read(PCA9552State *s, uint8_t reg)
  58 {
  59     switch (reg) {
  60     case PCA9552_INPUT0:
  61     case PCA9552_INPUT1:
  62     case PCA9552_PSC0:
  63     case PCA9552_PWM0:
  64     case PCA9552_PSC1:
  65     case PCA9552_PWM1:
  66     case PCA9552_LS0:
  67     case PCA9552_LS1:
  68     case PCA9552_LS2:
  69     case PCA9552_LS3:
  70         return s->regs[reg];
  71     default:
  72         qemu_log_mask(LOG_GUEST_ERROR, "%s: unexpected read to register %d\n",
  73                       __func__, reg);
  74         return 0xFF;
  75     }
  76 }
  77
  78 static void pca9552_write(PCA9552State *s, uint8_t reg, uint8_t data)
  79 {
  80     switch (reg) {
  81     case PCA9552_PSC0:
  82     case PCA9552_PWM0:
  83     case PCA9552_PSC1:
  84     case PCA9552_PWM1:
  85         s->regs[reg] = data;
  86         break;
  87
  88     case PCA9552_LS0:
  89     case PCA9552_LS1:
  90     case PCA9552_LS2:
  91     case PCA9552_LS3:
  92         s->regs[reg] = data;
  93         pca9552_update_pin_input(s);
  94         break;
  95
  96     case PCA9552_INPUT0:
  97     case PCA9552_INPUT1:
  98     default:
  99         qemu_log_mask(LOG_GUEST_ERROR, "%s: unexpected write to register %d\n",
 100                       __func__, reg);
 101     }
 102 }
 103
 104 /*
 105  * When Auto-Increment is on, the register address is incremented
 106  * after each byte is sent to or received by the device. The index
 107  * rollovers to 0 when the maximum register address is reached.
 108  */
 109 static void pca9552_autoinc(PCA9552State *s)
 110 {
 111     if (s->pointer != 0xFF && s->pointer & PCA9552_AUTOINC) {
 112         uint8_t reg = s->pointer & 0xf;
 113
 114         reg = (reg + 1) % (s->max_reg + 1);
 115         s->pointer = reg | PCA9552_AUTOINC;
 116     }
 117 }
 118
 119 static uint8_t pca9552_recv(I2CSlave *i2c)
 120 {
 121     PCA9552State *s = PCA9552(i2c);
 122     uint8_t ret;
 123
 124     ret = pca9552_read(s, s->pointer & 0xf);
 125
 126     /*
 127      * From the Specs:
 128      *
 129      *     Important Note: When a Read sequence is initiated and the
 130      *     AI bit is set to Logic Level 1, the Read Sequence MUST
 131      *     start by a register different from 0.
 132      *
 133      * I don't know what should be done in this case, so throw an
 134      * error.
 135      */
 136     if (s->pointer == PCA9552_AUTOINC) {
 137         qemu_log_mask(LOG_GUEST_ERROR,
 138                       "%s: Autoincrement read starting with register 0\n",
 139                       __func__);
 140     }
 141
 142     pca9552_autoinc(s);
 143
 144     return ret;
 145 }
 146
 147 static int pca9552_send(I2CSlave *i2c, uint8_t data)
 148 {
 149     PCA9552State *s = PCA9552(i2c);
 150
 151     /* First byte sent by is the register address */
 152     if (s->len == 0) {
 153         s->pointer = data;
 154         s->len++;
 155     } else {
 156         pca9552_write(s, s->pointer & 0xf, data);
 157
 158         pca9552_autoinc(s);
 159     }
 160
 161     return 0;
 162 }
 163
 164 static int pca9552_event(I2CSlave *i2c, enum i2c_event event)
 165 {
 166     PCA9552State *s = PCA9552(i2c);
 167
 168     s->len = 0;
 169     return 0;
 170 }
 171
 172 static const VMStateDescription pca9552_vmstate = {
 173     .name = "PCA9552",
 174     .version_id = 0,
 175     .minimum_version_id = 0,
 176     .fields = (VMStateField[]) {
 177         VMSTATE_UINT8(len, PCA9552State),
 178         VMSTATE_UINT8(pointer, PCA9552State),
 179         VMSTATE_UINT8_ARRAY(regs, PCA9552State, PCA9552_NR_REGS),
 180         VMSTATE_I2C_SLAVE(i2c, PCA9552State),
 181         VMSTATE_END_OF_LIST()
 182     }
 183 };
 184
 185 static void pca9552_reset(DeviceState *dev)
 186 {
 187     PCA9552State *s = PCA9552(dev);
 188
 189     s->regs[PCA9552_PSC0] = 0xFF;
 190     s->regs[PCA9552_PWM0] = 0x80;
 191     s->regs[PCA9552_PSC1] = 0xFF;
 192     s->regs[PCA9552_PWM1] = 0x80;
 193     s->regs[PCA9552_LS0] = 0x55; /* all OFF */
 194     s->regs[PCA9552_LS1] = 0x55;
 195     s->regs[PCA9552_LS2] = 0x55;
 196     s->regs[PCA9552_LS3] = 0x55;
 197
 198     pca9552_update_pin_input(s);
 199
 200     s->pointer = 0xFF;
 201     s->len = 0;
 202 }
 203
 204 static void pca9552_initfn(Object *obj)
 205 {
 206     PCA9552State *s = PCA9552(obj);
 207
 208     /* If support for the other PCA955X devices are implemented, these
 209      * constant values might be part of class structure describing the
 210      * PCA955X device
 211      */
 212     s->max_reg = PCA9552_LS3;
 213     s->nr_leds = 16;
 214 }
 215
 216 static void pca9552_class_init(ObjectClass *klass, void *data)
 217 {
 218     DeviceClass *dc = DEVICE_CLASS(klass);
 219     I2CSlaveClass *k = I2C_SLAVE_CLASS(klass);
 220
 221     k->event = pca9552_event;
 222     k->recv = pca9552_recv;
 223     k->send = pca9552_send;
 224     dc->reset = pca9552_reset;
 225     dc->vmsd = &pca9552_vmstate;
 226 }
 227
 228 static const TypeInfo pca9552_info = {
 229     .name          = TYPE_PCA9552,
 230     .parent        = TYPE_I2C_SLAVE,
 231     .instance_init = pca9552_initfn,
 232     .instance_size = sizeof(PCA9552State),
 233     .class_init    = pca9552_class_init,
 234 };
 235
 236 static void pca9552_register_types(void)
 237 {
 238     type_register_static(&pca9552_info);
 239 }
 240
 241 type_init(pca9552_register_types)