1 /*
2 * I2C multiplexer for PCA954x series of I2C multiplexer/switch chips.
3 *
4 * Copyright 2021 Google LLC
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * for more details.
15 */
16
17 #include "qemu/osdep.h"
18 #include "qapi/error.h"
19 #include "hw/i2c/i2c.h"
20 #include "hw/i2c/i2c_mux_pca954x.h"
21 #include "hw/i2c/smbus_slave.h"
22 #include "hw/qdev-core.h"
23 #include "hw/qdev-properties.h"
24 #include "hw/sysbus.h"
25 #include "qemu/log.h"
26 #include "qemu/module.h"
27 #include "qemu/queue.h"
28 #include "qom/object.h"
29 #include "trace.h"
30
31 #define PCA9548_CHANNEL_COUNT 8
32 #define PCA9546_CHANNEL_COUNT 4
33
34 /*
35 * struct Pca954xState - The pca954x state object.
36 * @control: The value written to the mux control.
37 * @channel: The set of i2c channel buses that act as channels which own the
38 * i2c children.
39 */
40 typedef struct Pca954xState {
41 SMBusDevice parent;
42
43 uint8_t control;
44
45 bool enabled[PCA9548_CHANNEL_COUNT];
46 I2CBus *bus[PCA9548_CHANNEL_COUNT];
47
48 char *name;
49 } Pca954xState;
50
51 /*
52 * struct Pca954xClass - The pca954x class object.
53 * @nchans: The number of i2c channels this device has.
54 */
55 typedef struct Pca954xClass {
56 SMBusDeviceClass parent;
57
58 uint8_t nchans;
59 } Pca954xClass;
60
61 #define TYPE_PCA954X "pca954x"
OBJECT_DECLARE_TYPE(Pca954xState,Pca954xClass,PCA954X)62 OBJECT_DECLARE_TYPE(Pca954xState, Pca954xClass, PCA954X)
63
64 /*
65 * For each channel, if it's enabled, recursively call match on those children.
66 */
67 static bool pca954x_match(I2CSlave *candidate, uint8_t address,
68 bool broadcast,
69 I2CNodeList *current_devs)
70 {
71 Pca954xState *mux = PCA954X(candidate);
72 Pca954xClass *mc = PCA954X_GET_CLASS(mux);
73 int i;
74
75 /* They are talking to the mux itself (or all devices enabled). */
76 if ((candidate->address == address) || broadcast) {
77 I2CNode *node = g_new(struct I2CNode, 1);
78 node->elt = candidate;
79 QLIST_INSERT_HEAD(current_devs, node, next);
80 if (!broadcast) {
81 return true;
82 }
83 }
84
85 for (i = 0; i < mc->nchans; i++) {
86 if (!mux->enabled[i]) {
87 continue;
88 }
89
90 if (i2c_scan_bus(mux->bus[i], address, broadcast,
91 current_devs)) {
92 if (!broadcast) {
93 return true;
94 }
95 }
96 }
97
98 /* If we arrived here we didn't find a match, return broadcast. */
99 return broadcast;
100 }
101
pca954x_enable_channel(Pca954xState * s,uint8_t enable_mask)102 static void pca954x_enable_channel(Pca954xState *s, uint8_t enable_mask)
103 {
104 Pca954xClass *mc = PCA954X_GET_CLASS(s);
105 int i;
106
107 /*
108 * For each channel, check if their bit is set in enable_mask and if yes,
109 * enable it, otherwise disable, hide it.
110 */
111 for (i = 0; i < mc->nchans; i++) {
112 if (enable_mask & (1 << i)) {
113 s->enabled[i] = true;
114 } else {
115 s->enabled[i] = false;
116 }
117 }
118 }
119
pca954x_write(Pca954xState * s,uint8_t data)120 static void pca954x_write(Pca954xState *s, uint8_t data)
121 {
122 s->control = data;
123 pca954x_enable_channel(s, data);
124
125 trace_pca954x_write_bytes(data);
126 }
127
pca954x_write_data(SMBusDevice * d,uint8_t * buf,uint8_t len)128 static int pca954x_write_data(SMBusDevice *d, uint8_t *buf, uint8_t len)
129 {
130 Pca954xState *s = PCA954X(d);
131
132 if (len == 0) {
133 qemu_log_mask(LOG_GUEST_ERROR, "%s: writing empty data\n", __func__);
134 return -1;
135 }
136
137 /*
138 * len should be 1, because they write one byte to enable/disable channels.
139 */
140 if (len > 1) {
141 qemu_log_mask(LOG_GUEST_ERROR,
142 "%s: extra data after channel selection mask\n",
143 __func__);
144 return -1;
145 }
146
147 pca954x_write(s, buf[0]);
148 return 0;
149 }
150
pca954x_read_byte(SMBusDevice * d)151 static uint8_t pca954x_read_byte(SMBusDevice *d)
152 {
153 Pca954xState *s = PCA954X(d);
154 uint8_t data = s->control;
155 trace_pca954x_read_data(data);
156 return data;
157 }
158
pca954x_enter_reset(Object * obj,ResetType type)159 static void pca954x_enter_reset(Object *obj, ResetType type)
160 {
161 Pca954xState *s = PCA954X(obj);
162 /* Reset will disable all channels. */
163 pca954x_write(s, 0);
164 }
165
pca954x_i2c_get_bus(I2CSlave * mux,uint8_t channel)166 I2CBus *pca954x_i2c_get_bus(I2CSlave *mux, uint8_t channel)
167 {
168 Pca954xClass *pc = PCA954X_GET_CLASS(mux);
169 Pca954xState *pca954x = PCA954X(mux);
170
171 g_assert(channel < pc->nchans);
172 return pca954x->bus[channel];
173 }
174
pca9546_class_init(ObjectClass * klass,void * data)175 static void pca9546_class_init(ObjectClass *klass, void *data)
176 {
177 Pca954xClass *s = PCA954X_CLASS(klass);
178 s->nchans = PCA9546_CHANNEL_COUNT;
179 }
180
pca9548_class_init(ObjectClass * klass,void * data)181 static void pca9548_class_init(ObjectClass *klass, void *data)
182 {
183 Pca954xClass *s = PCA954X_CLASS(klass);
184 s->nchans = PCA9548_CHANNEL_COUNT;
185 }
186
pca954x_realize(DeviceState * dev,Error ** errp)187 static void pca954x_realize(DeviceState *dev, Error **errp)
188 {
189 Pca954xState *s = PCA954X(dev);
190 DeviceState *d = DEVICE(s);
191 if (s->name) {
192 d->id = g_strdup(s->name);
193 } else {
194 d->id = g_strdup_printf("pca954x[%x]", s->parent.i2c.address);
195 }
196 }
197
pca954x_init(Object * obj)198 static void pca954x_init(Object *obj)
199 {
200 Pca954xState *s = PCA954X(obj);
201 Pca954xClass *c = PCA954X_GET_CLASS(obj);
202 int i;
203
204 /* SMBus modules. Cannot fail. */
205 for (i = 0; i < c->nchans; i++) {
206 g_autofree gchar *bus_name = g_strdup_printf("i2c.%d", i);
207
208 /* start all channels as disabled. */
209 s->enabled[i] = false;
210 s->bus[i] = i2c_init_bus(DEVICE(s), bus_name);
211 }
212 }
213
214 static Property pca954x_props[] = {
215 DEFINE_PROP_STRING("name", Pca954xState, name),
216 DEFINE_PROP_END_OF_LIST()
217 };
218
pca954x_class_init(ObjectClass * klass,void * data)219 static void pca954x_class_init(ObjectClass *klass, void *data)
220 {
221 I2CSlaveClass *sc = I2C_SLAVE_CLASS(klass);
222 ResettableClass *rc = RESETTABLE_CLASS(klass);
223 DeviceClass *dc = DEVICE_CLASS(klass);
224 SMBusDeviceClass *k = SMBUS_DEVICE_CLASS(klass);
225
226 sc->match_and_add = pca954x_match;
227
228 rc->phases.enter = pca954x_enter_reset;
229
230 dc->desc = "Pca954x i2c-mux";
231 dc->realize = pca954x_realize;
232
233 k->write_data = pca954x_write_data;
234 k->receive_byte = pca954x_read_byte;
235
236 device_class_set_props(dc, pca954x_props);
237 }
238
239 static const TypeInfo pca954x_info[] = {
240 {
241 .name = TYPE_PCA954X,
242 .parent = TYPE_SMBUS_DEVICE,
243 .instance_size = sizeof(Pca954xState),
244 .instance_init = pca954x_init,
245 .class_size = sizeof(Pca954xClass),
246 .class_init = pca954x_class_init,
247 .abstract = true,
248 },
249 {
250 .name = TYPE_PCA9546,
251 .parent = TYPE_PCA954X,
252 .class_init = pca9546_class_init,
253 },
254 {
255 .name = TYPE_PCA9548,
256 .parent = TYPE_PCA954X,
257 .class_init = pca9548_class_init,
258 },
259 };
260
261 DEFINE_TYPES(pca954x_info)
262