1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * I2C multiplexer |
4 | * |
5 | * Copyright (c) 2008-2009 Rodolfo Giometti <giometti@linux.it> |
6 | * Copyright (c) 2008-2009 Eurotech S.p.A. <info@eurotech.it> |
7 | * |
8 | * This module supports the PCA954x and PCA984x series of I2C multiplexer/switch |
9 | * chips made by NXP Semiconductors. |
10 | * This includes the: |
11 | * PCA9540, PCA9542, PCA9543, PCA9544, PCA9545, PCA9546, PCA9547, |
12 | * PCA9548, PCA9846, PCA9847, PCA9848 and PCA9849. |
13 | * |
14 | * It's also compatible to Maxims MAX735x I2C switch chips, which are controlled |
15 | * as the NXP PCA9548 and the MAX736x chips that act like the PCA9544. |
16 | * |
17 | * This includes the: |
18 | * MAX7356, MAX7357, MAX7358, MAX7367, MAX7368 and MAX7369 |
19 | * |
20 | * These chips are all controlled via the I2C bus itself, and all have a |
21 | * single 8-bit register. The upstream "parent" bus fans out to two, |
22 | * four, or eight downstream busses or channels; which of these |
23 | * are selected is determined by the chip type and register contents. A |
24 | * mux can select only one sub-bus at a time; a switch can select any |
25 | * combination simultaneously. |
26 | * |
27 | * Based on: |
28 | * pca954x.c from Kumar Gala <galak@kernel.crashing.org> |
29 | * Copyright (C) 2006 |
30 | * |
31 | * Based on: |
32 | * pca954x.c from Ken Harrenstien |
33 | * Copyright (C) 2004 Google, Inc. (Ken Harrenstien) |
34 | * |
35 | * Based on: |
36 | * i2c-virtual_cb.c from Brian Kuschak <bkuschak@yahoo.com> |
37 | * and |
38 | * pca9540.c from Jean Delvare <jdelvare@suse.de>. |
39 | */ |
40 | |
41 | #include <linux/device.h> |
42 | #include <linux/delay.h> |
43 | #include <linux/gpio/consumer.h> |
44 | #include <linux/i2c.h> |
45 | #include <linux/i2c-mux.h> |
46 | #include <linux/interrupt.h> |
47 | #include <linux/irq.h> |
48 | #include <linux/module.h> |
49 | #include <linux/pm.h> |
50 | #include <linux/property.h> |
51 | #include <linux/regulator/consumer.h> |
52 | #include <linux/reset.h> |
53 | #include <linux/slab.h> |
54 | #include <linux/spinlock.h> |
55 | #include <dt-bindings/mux/mux.h> |
56 | |
57 | #define PCA954X_MAX_NCHANS 8 |
58 | |
59 | #define PCA954X_IRQ_OFFSET 4 |
60 | |
61 | /* |
62 | * MAX7357's configuration register is writeable after POR, but |
63 | * can be locked by setting the basic mode bit. MAX7358 configuration |
64 | * register is locked by default and needs to be unlocked first. |
65 | * The configuration register holds the following settings: |
66 | */ |
67 | #define MAX7357_CONF_INT_ENABLE BIT(0) |
68 | #define MAX7357_CONF_FLUSH_OUT BIT(1) |
69 | #define MAX7357_CONF_RELEASE_INT BIT(2) |
70 | #define MAX7357_CONF_DISCON_SINGLE_CHAN BIT(4) |
71 | #define MAX7357_CONF_PRECONNECT_TEST BIT(7) |
72 | |
73 | #define MAX7357_POR_DEFAULT_CONF MAX7357_CONF_INT_ENABLE |
74 | |
75 | enum pca_type { |
76 | max_7356, |
77 | max_7357, |
78 | max_7358, |
79 | max_7367, |
80 | max_7368, |
81 | max_7369, |
82 | pca_9540, |
83 | pca_9542, |
84 | pca_9543, |
85 | pca_9544, |
86 | pca_9545, |
87 | pca_9546, |
88 | pca_9547, |
89 | pca_9548, |
90 | pca_9846, |
91 | pca_9847, |
92 | pca_9848, |
93 | pca_9849, |
94 | }; |
95 | |
96 | struct chip_desc { |
97 | u8 nchans; |
98 | u8 enable; /* used for muxes only */ |
99 | u8 has_irq; |
100 | enum muxtype { |
101 | pca954x_ismux = 0, |
102 | pca954x_isswi |
103 | } muxtype; |
104 | struct i2c_device_identity id; |
105 | }; |
106 | |
107 | struct pca954x { |
108 | const struct chip_desc *chip; |
109 | |
110 | u8 last_chan; /* last register value */ |
111 | /* MUX_IDLE_AS_IS, MUX_IDLE_DISCONNECT or >= 0 for channel */ |
112 | s32 idle_state; |
113 | |
114 | struct i2c_client *client; |
115 | |
116 | struct irq_domain *irq; |
117 | unsigned int irq_mask; |
118 | raw_spinlock_t lock; |
119 | struct regulator *supply; |
120 | |
121 | struct gpio_desc *reset_gpio; |
122 | struct reset_control *reset_cont; |
123 | }; |
124 | |
125 | /* Provide specs for the MAX735x, PCA954x and PCA984x types we know about */ |
126 | static const struct chip_desc chips[] = { |
127 | [max_7356] = { |
128 | .nchans = 8, |
129 | .muxtype = pca954x_isswi, |
130 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
131 | }, |
132 | [max_7357] = { |
133 | .nchans = 8, |
134 | .muxtype = pca954x_isswi, |
135 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
136 | /* |
137 | * No interrupt controller support. The interrupt |
138 | * provides information about stuck channels. |
139 | */ |
140 | }, |
141 | [max_7358] = { |
142 | .nchans = 8, |
143 | .muxtype = pca954x_isswi, |
144 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
145 | /* |
146 | * No interrupt controller support. The interrupt |
147 | * provides information about stuck channels. |
148 | */ |
149 | }, |
150 | [max_7367] = { |
151 | .nchans = 4, |
152 | .muxtype = pca954x_isswi, |
153 | .has_irq = 1, |
154 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
155 | }, |
156 | [max_7368] = { |
157 | .nchans = 4, |
158 | .muxtype = pca954x_isswi, |
159 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
160 | }, |
161 | [max_7369] = { |
162 | .nchans = 4, |
163 | .enable = 0x4, |
164 | .muxtype = pca954x_ismux, |
165 | .has_irq = 1, |
166 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
167 | }, |
168 | [pca_9540] = { |
169 | .nchans = 2, |
170 | .enable = 0x4, |
171 | .muxtype = pca954x_ismux, |
172 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
173 | }, |
174 | [pca_9542] = { |
175 | .nchans = 2, |
176 | .enable = 0x4, |
177 | .has_irq = 1, |
178 | .muxtype = pca954x_ismux, |
179 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
180 | }, |
181 | [pca_9543] = { |
182 | .nchans = 2, |
183 | .has_irq = 1, |
184 | .muxtype = pca954x_isswi, |
185 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
186 | }, |
187 | [pca_9544] = { |
188 | .nchans = 4, |
189 | .enable = 0x4, |
190 | .has_irq = 1, |
191 | .muxtype = pca954x_ismux, |
192 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
193 | }, |
194 | [pca_9545] = { |
195 | .nchans = 4, |
196 | .has_irq = 1, |
197 | .muxtype = pca954x_isswi, |
198 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
199 | }, |
200 | [pca_9546] = { |
201 | .nchans = 4, |
202 | .muxtype = pca954x_isswi, |
203 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
204 | }, |
205 | [pca_9547] = { |
206 | .nchans = 8, |
207 | .enable = 0x8, |
208 | .muxtype = pca954x_ismux, |
209 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
210 | }, |
211 | [pca_9548] = { |
212 | .nchans = 8, |
213 | .muxtype = pca954x_isswi, |
214 | .id = { .manufacturer_id = I2C_DEVICE_ID_NONE }, |
215 | }, |
216 | [pca_9846] = { |
217 | .nchans = 4, |
218 | .muxtype = pca954x_isswi, |
219 | .id = { |
220 | .manufacturer_id = I2C_DEVICE_ID_NXP_SEMICONDUCTORS, |
221 | .part_id = 0x10b, |
222 | }, |
223 | }, |
224 | [pca_9847] = { |
225 | .nchans = 8, |
226 | .enable = 0x8, |
227 | .muxtype = pca954x_ismux, |
228 | .id = { |
229 | .manufacturer_id = I2C_DEVICE_ID_NXP_SEMICONDUCTORS, |
230 | .part_id = 0x108, |
231 | }, |
232 | }, |
233 | [pca_9848] = { |
234 | .nchans = 8, |
235 | .muxtype = pca954x_isswi, |
236 | .id = { |
237 | .manufacturer_id = I2C_DEVICE_ID_NXP_SEMICONDUCTORS, |
238 | .part_id = 0x10a, |
239 | }, |
240 | }, |
241 | [pca_9849] = { |
242 | .nchans = 4, |
243 | .enable = 0x4, |
244 | .muxtype = pca954x_ismux, |
245 | .id = { |
246 | .manufacturer_id = I2C_DEVICE_ID_NXP_SEMICONDUCTORS, |
247 | .part_id = 0x109, |
248 | }, |
249 | }, |
250 | }; |
251 | |
252 | static const struct i2c_device_id pca954x_id[] = { |
253 | { "max7356" , max_7356 }, |
254 | { "max7357" , max_7357 }, |
255 | { "max7358" , max_7358 }, |
256 | { "max7367" , max_7367 }, |
257 | { "max7368" , max_7368 }, |
258 | { "max7369" , max_7369 }, |
259 | { "pca9540" , pca_9540 }, |
260 | { "pca9542" , pca_9542 }, |
261 | { "pca9543" , pca_9543 }, |
262 | { "pca9544" , pca_9544 }, |
263 | { "pca9545" , pca_9545 }, |
264 | { "pca9546" , pca_9546 }, |
265 | { "pca9547" , pca_9547 }, |
266 | { "pca9548" , pca_9548 }, |
267 | { "pca9846" , pca_9846 }, |
268 | { "pca9847" , pca_9847 }, |
269 | { "pca9848" , pca_9848 }, |
270 | { "pca9849" , pca_9849 }, |
271 | { } |
272 | }; |
273 | MODULE_DEVICE_TABLE(i2c, pca954x_id); |
274 | |
275 | static const struct of_device_id pca954x_of_match[] = { |
276 | { .compatible = "maxim,max7356" , .data = &chips[max_7356] }, |
277 | { .compatible = "maxim,max7357" , .data = &chips[max_7357] }, |
278 | { .compatible = "maxim,max7358" , .data = &chips[max_7358] }, |
279 | { .compatible = "maxim,max7367" , .data = &chips[max_7367] }, |
280 | { .compatible = "maxim,max7368" , .data = &chips[max_7368] }, |
281 | { .compatible = "maxim,max7369" , .data = &chips[max_7369] }, |
282 | { .compatible = "nxp,pca9540" , .data = &chips[pca_9540] }, |
283 | { .compatible = "nxp,pca9542" , .data = &chips[pca_9542] }, |
284 | { .compatible = "nxp,pca9543" , .data = &chips[pca_9543] }, |
285 | { .compatible = "nxp,pca9544" , .data = &chips[pca_9544] }, |
286 | { .compatible = "nxp,pca9545" , .data = &chips[pca_9545] }, |
287 | { .compatible = "nxp,pca9546" , .data = &chips[pca_9546] }, |
288 | { .compatible = "nxp,pca9547" , .data = &chips[pca_9547] }, |
289 | { .compatible = "nxp,pca9548" , .data = &chips[pca_9548] }, |
290 | { .compatible = "nxp,pca9846" , .data = &chips[pca_9846] }, |
291 | { .compatible = "nxp,pca9847" , .data = &chips[pca_9847] }, |
292 | { .compatible = "nxp,pca9848" , .data = &chips[pca_9848] }, |
293 | { .compatible = "nxp,pca9849" , .data = &chips[pca_9849] }, |
294 | {} |
295 | }; |
296 | MODULE_DEVICE_TABLE(of, pca954x_of_match); |
297 | |
298 | /* Write to mux register. Don't use i2c_transfer()/i2c_smbus_xfer() |
299 | for this as they will try to lock adapter a second time */ |
300 | static int pca954x_reg_write(struct i2c_adapter *adap, |
301 | struct i2c_client *client, u8 val) |
302 | { |
303 | union i2c_smbus_data dummy; |
304 | |
305 | return __i2c_smbus_xfer(adapter: adap, addr: client->addr, flags: client->flags, |
306 | I2C_SMBUS_WRITE, command: val, |
307 | I2C_SMBUS_BYTE, data: &dummy); |
308 | } |
309 | |
310 | static u8 pca954x_regval(struct pca954x *data, u8 chan) |
311 | { |
312 | /* We make switches look like muxes, not sure how to be smarter. */ |
313 | if (data->chip->muxtype == pca954x_ismux) |
314 | return chan | data->chip->enable; |
315 | else |
316 | return 1 << chan; |
317 | } |
318 | |
319 | static int pca954x_select_chan(struct i2c_mux_core *muxc, u32 chan) |
320 | { |
321 | struct pca954x *data = i2c_mux_priv(muxc); |
322 | struct i2c_client *client = data->client; |
323 | u8 regval; |
324 | int ret = 0; |
325 | |
326 | regval = pca954x_regval(data, chan); |
327 | /* Only select the channel if its different from the last channel */ |
328 | if (data->last_chan != regval) { |
329 | ret = pca954x_reg_write(adap: muxc->parent, client, val: regval); |
330 | data->last_chan = ret < 0 ? 0 : regval; |
331 | } |
332 | |
333 | return ret; |
334 | } |
335 | |
336 | static int pca954x_deselect_mux(struct i2c_mux_core *muxc, u32 chan) |
337 | { |
338 | struct pca954x *data = i2c_mux_priv(muxc); |
339 | struct i2c_client *client = data->client; |
340 | s32 idle_state; |
341 | |
342 | idle_state = READ_ONCE(data->idle_state); |
343 | if (idle_state >= 0) |
344 | /* Set the mux back to a predetermined channel */ |
345 | return pca954x_select_chan(muxc, chan: idle_state); |
346 | |
347 | if (idle_state == MUX_IDLE_DISCONNECT) { |
348 | /* Deselect active channel */ |
349 | data->last_chan = 0; |
350 | return pca954x_reg_write(adap: muxc->parent, client, |
351 | val: data->last_chan); |
352 | } |
353 | |
354 | /* otherwise leave as-is */ |
355 | |
356 | return 0; |
357 | } |
358 | |
359 | static ssize_t idle_state_show(struct device *dev, |
360 | struct device_attribute *attr, |
361 | char *buf) |
362 | { |
363 | struct i2c_client *client = to_i2c_client(dev); |
364 | struct i2c_mux_core *muxc = i2c_get_clientdata(client); |
365 | struct pca954x *data = i2c_mux_priv(muxc); |
366 | |
367 | return sprintf(buf, fmt: "%d\n" , READ_ONCE(data->idle_state)); |
368 | } |
369 | |
370 | static ssize_t idle_state_store(struct device *dev, |
371 | struct device_attribute *attr, |
372 | const char *buf, size_t count) |
373 | { |
374 | struct i2c_client *client = to_i2c_client(dev); |
375 | struct i2c_mux_core *muxc = i2c_get_clientdata(client); |
376 | struct pca954x *data = i2c_mux_priv(muxc); |
377 | int val; |
378 | int ret; |
379 | |
380 | ret = kstrtoint(s: buf, base: 0, res: &val); |
381 | if (ret < 0) |
382 | return ret; |
383 | |
384 | if (val != MUX_IDLE_AS_IS && val != MUX_IDLE_DISCONNECT && |
385 | (val < 0 || val >= data->chip->nchans)) |
386 | return -EINVAL; |
387 | |
388 | i2c_lock_bus(adapter: muxc->parent, I2C_LOCK_SEGMENT); |
389 | |
390 | WRITE_ONCE(data->idle_state, val); |
391 | /* |
392 | * Set the mux into a state consistent with the new |
393 | * idle_state. |
394 | */ |
395 | if (data->last_chan || val != MUX_IDLE_DISCONNECT) |
396 | ret = pca954x_deselect_mux(muxc, chan: 0); |
397 | |
398 | i2c_unlock_bus(adapter: muxc->parent, I2C_LOCK_SEGMENT); |
399 | |
400 | return ret < 0 ? ret : count; |
401 | } |
402 | |
403 | static DEVICE_ATTR_RW(idle_state); |
404 | |
405 | static irqreturn_t pca954x_irq_handler(int irq, void *dev_id) |
406 | { |
407 | struct pca954x *data = dev_id; |
408 | unsigned long pending; |
409 | int ret, i; |
410 | |
411 | ret = i2c_smbus_read_byte(client: data->client); |
412 | if (ret < 0) |
413 | return IRQ_NONE; |
414 | |
415 | pending = (ret >> PCA954X_IRQ_OFFSET) & (BIT(data->chip->nchans) - 1); |
416 | for_each_set_bit(i, &pending, data->chip->nchans) |
417 | handle_nested_irq(irq: irq_linear_revmap(domain: data->irq, hwirq: i)); |
418 | |
419 | return IRQ_RETVAL(pending); |
420 | } |
421 | |
422 | static int pca954x_irq_set_type(struct irq_data *idata, unsigned int type) |
423 | { |
424 | if ((type & IRQ_TYPE_SENSE_MASK) != IRQ_TYPE_LEVEL_LOW) |
425 | return -EINVAL; |
426 | return 0; |
427 | } |
428 | |
429 | static struct irq_chip pca954x_irq_chip = { |
430 | .name = "i2c-mux-pca954x" , |
431 | .irq_set_type = pca954x_irq_set_type, |
432 | }; |
433 | |
434 | static int pca954x_irq_setup(struct i2c_mux_core *muxc) |
435 | { |
436 | struct pca954x *data = i2c_mux_priv(muxc); |
437 | struct i2c_client *client = data->client; |
438 | int c, irq; |
439 | |
440 | if (!data->chip->has_irq || client->irq <= 0) |
441 | return 0; |
442 | |
443 | raw_spin_lock_init(&data->lock); |
444 | |
445 | data->irq = irq_domain_add_linear(of_node: client->dev.of_node, |
446 | size: data->chip->nchans, |
447 | ops: &irq_domain_simple_ops, host_data: data); |
448 | if (!data->irq) |
449 | return -ENODEV; |
450 | |
451 | for (c = 0; c < data->chip->nchans; c++) { |
452 | irq = irq_create_mapping(host: data->irq, hwirq: c); |
453 | if (!irq) { |
454 | dev_err(&client->dev, "failed irq create map\n" ); |
455 | return -EINVAL; |
456 | } |
457 | irq_set_chip_data(irq, data); |
458 | irq_set_chip_and_handler(irq, chip: &pca954x_irq_chip, |
459 | handle: handle_simple_irq); |
460 | } |
461 | |
462 | return 0; |
463 | } |
464 | |
465 | static void pca954x_cleanup(struct i2c_mux_core *muxc) |
466 | { |
467 | struct pca954x *data = i2c_mux_priv(muxc); |
468 | int c, irq; |
469 | |
470 | regulator_disable(regulator: data->supply); |
471 | |
472 | if (data->irq) { |
473 | for (c = 0; c < data->chip->nchans; c++) { |
474 | irq = irq_find_mapping(domain: data->irq, hwirq: c); |
475 | irq_dispose_mapping(virq: irq); |
476 | } |
477 | irq_domain_remove(host: data->irq); |
478 | } |
479 | i2c_mux_del_adapters(muxc); |
480 | } |
481 | |
482 | static int pca954x_init(struct i2c_client *client, struct pca954x *data) |
483 | { |
484 | int ret; |
485 | |
486 | if (data->idle_state >= 0) |
487 | data->last_chan = pca954x_regval(data, chan: data->idle_state); |
488 | else |
489 | data->last_chan = 0; /* Disconnect multiplexer */ |
490 | |
491 | if (device_is_compatible(dev: &client->dev, compat: "maxim,max7357" )) { |
492 | if (i2c_check_functionality(adap: client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) { |
493 | u8 conf = MAX7357_POR_DEFAULT_CONF; |
494 | /* |
495 | * The interrupt signal is shared with the reset pin. Release the |
496 | * interrupt after 1.6 seconds to allow using the pin as reset. |
497 | */ |
498 | conf |= MAX7357_CONF_RELEASE_INT; |
499 | |
500 | if (device_property_read_bool(dev: &client->dev, propname: "maxim,isolate-stuck-channel" )) |
501 | conf |= MAX7357_CONF_DISCON_SINGLE_CHAN; |
502 | if (device_property_read_bool(dev: &client->dev, |
503 | propname: "maxim,send-flush-out-sequence" )) |
504 | conf |= MAX7357_CONF_FLUSH_OUT; |
505 | if (device_property_read_bool(dev: &client->dev, |
506 | propname: "maxim,preconnection-wiggle-test-enable" )) |
507 | conf |= MAX7357_CONF_PRECONNECT_TEST; |
508 | |
509 | ret = i2c_smbus_write_byte_data(client, command: data->last_chan, value: conf); |
510 | } else { |
511 | dev_warn(&client->dev, "Write byte data not supported." |
512 | "Cannot enable enhanced mode features\n" ); |
513 | ret = i2c_smbus_write_byte(client, value: data->last_chan); |
514 | } |
515 | } else { |
516 | ret = i2c_smbus_write_byte(client, value: data->last_chan); |
517 | } |
518 | |
519 | if (ret < 0) |
520 | data->last_chan = 0; |
521 | |
522 | return ret; |
523 | } |
524 | |
525 | static int pca954x_get_reset(struct device *dev, struct pca954x *data) |
526 | { |
527 | data->reset_cont = devm_reset_control_get_optional_shared(dev, NULL); |
528 | if (IS_ERR(ptr: data->reset_cont)) |
529 | return dev_err_probe(dev, err: PTR_ERR(ptr: data->reset_cont), |
530 | fmt: "Failed to get reset\n" ); |
531 | else if (data->reset_cont) |
532 | return 0; |
533 | |
534 | /* |
535 | * fallback to legacy reset-gpios |
536 | */ |
537 | data->reset_gpio = devm_gpiod_get_optional(dev, con_id: "reset" , flags: GPIOD_OUT_HIGH); |
538 | if (IS_ERR(ptr: data->reset_gpio)) { |
539 | return dev_err_probe(dev, err: PTR_ERR(ptr: data->reset_gpio), |
540 | fmt: "Failed to get reset gpio" ); |
541 | } |
542 | |
543 | return 0; |
544 | } |
545 | |
546 | static void pca954x_reset_deassert(struct pca954x *data) |
547 | { |
548 | if (data->reset_cont) |
549 | reset_control_deassert(rstc: data->reset_cont); |
550 | else |
551 | gpiod_set_value_cansleep(desc: data->reset_gpio, value: 0); |
552 | } |
553 | |
554 | /* |
555 | * I2C init/probing/exit functions |
556 | */ |
557 | static int pca954x_probe(struct i2c_client *client) |
558 | { |
559 | const struct i2c_device_id *id = i2c_client_get_device_id(client); |
560 | struct i2c_adapter *adap = client->adapter; |
561 | struct device *dev = &client->dev; |
562 | struct i2c_mux_core *muxc; |
563 | struct pca954x *data; |
564 | int num; |
565 | int ret; |
566 | |
567 | if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_BYTE)) |
568 | return -ENODEV; |
569 | |
570 | muxc = i2c_mux_alloc(parent: adap, dev, PCA954X_MAX_NCHANS, sizeof_priv: sizeof(*data), flags: 0, |
571 | select: pca954x_select_chan, deselect: pca954x_deselect_mux); |
572 | if (!muxc) |
573 | return -ENOMEM; |
574 | data = i2c_mux_priv(muxc); |
575 | |
576 | i2c_set_clientdata(client, data: muxc); |
577 | data->client = client; |
578 | |
579 | data->supply = devm_regulator_get(dev, id: "vdd" ); |
580 | if (IS_ERR(ptr: data->supply)) |
581 | return dev_err_probe(dev, err: PTR_ERR(ptr: data->supply), |
582 | fmt: "Failed to request regulator\n" ); |
583 | |
584 | ret = regulator_enable(regulator: data->supply); |
585 | if (ret) |
586 | return dev_err_probe(dev, err: ret, |
587 | fmt: "Failed to enable vdd supply\n" ); |
588 | |
589 | ret = pca954x_get_reset(dev, data); |
590 | if (ret) |
591 | goto fail_cleanup; |
592 | |
593 | if (data->reset_cont || data->reset_gpio) { |
594 | udelay(1); |
595 | pca954x_reset_deassert(data); |
596 | /* Give the chip some time to recover. */ |
597 | udelay(1); |
598 | } |
599 | |
600 | data->chip = device_get_match_data(dev); |
601 | if (!data->chip) |
602 | data->chip = &chips[id->driver_data]; |
603 | |
604 | if (data->chip->id.manufacturer_id != I2C_DEVICE_ID_NONE) { |
605 | struct i2c_device_identity id; |
606 | |
607 | ret = i2c_get_device_id(client, id: &id); |
608 | if (ret && ret != -EOPNOTSUPP) |
609 | goto fail_cleanup; |
610 | |
611 | if (!ret && |
612 | (id.manufacturer_id != data->chip->id.manufacturer_id || |
613 | id.part_id != data->chip->id.part_id)) { |
614 | dev_warn(dev, "unexpected device id %03x-%03x-%x\n" , |
615 | id.manufacturer_id, id.part_id, |
616 | id.die_revision); |
617 | ret = -ENODEV; |
618 | goto fail_cleanup; |
619 | } |
620 | } |
621 | |
622 | data->idle_state = MUX_IDLE_AS_IS; |
623 | if (device_property_read_u32(dev, propname: "idle-state" , val: &data->idle_state)) { |
624 | if (device_property_read_bool(dev, propname: "i2c-mux-idle-disconnect" )) |
625 | data->idle_state = MUX_IDLE_DISCONNECT; |
626 | } |
627 | |
628 | /* |
629 | * Write the mux register at addr to verify |
630 | * that the mux is in fact present. This also |
631 | * initializes the mux to a channel |
632 | * or disconnected state. |
633 | */ |
634 | ret = pca954x_init(client, data); |
635 | if (ret < 0) { |
636 | dev_warn(dev, "probe failed\n" ); |
637 | ret = -ENODEV; |
638 | goto fail_cleanup; |
639 | } |
640 | |
641 | ret = pca954x_irq_setup(muxc); |
642 | if (ret) |
643 | goto fail_cleanup; |
644 | |
645 | /* Now create an adapter for each channel */ |
646 | for (num = 0; num < data->chip->nchans; num++) { |
647 | ret = i2c_mux_add_adapter(muxc, force_nr: 0, chan_id: num, class: 0); |
648 | if (ret) |
649 | goto fail_cleanup; |
650 | } |
651 | |
652 | if (data->irq) { |
653 | ret = devm_request_threaded_irq(dev, irq: data->client->irq, |
654 | NULL, thread_fn: pca954x_irq_handler, |
655 | IRQF_ONESHOT | IRQF_SHARED, |
656 | devname: "pca954x" , dev_id: data); |
657 | if (ret) |
658 | goto fail_cleanup; |
659 | } |
660 | |
661 | /* |
662 | * The attr probably isn't going to be needed in most cases, |
663 | * so don't fail completely on error. |
664 | */ |
665 | device_create_file(device: dev, entry: &dev_attr_idle_state); |
666 | |
667 | dev_info(dev, "registered %d multiplexed busses for I2C %s %s\n" , |
668 | num, data->chip->muxtype == pca954x_ismux |
669 | ? "mux" : "switch" , client->name); |
670 | |
671 | return 0; |
672 | |
673 | fail_cleanup: |
674 | pca954x_cleanup(muxc); |
675 | return ret; |
676 | } |
677 | |
678 | static void pca954x_remove(struct i2c_client *client) |
679 | { |
680 | struct i2c_mux_core *muxc = i2c_get_clientdata(client); |
681 | |
682 | device_remove_file(dev: &client->dev, attr: &dev_attr_idle_state); |
683 | |
684 | pca954x_cleanup(muxc); |
685 | } |
686 | |
687 | static int pca954x_resume(struct device *dev) |
688 | { |
689 | struct i2c_client *client = to_i2c_client(dev); |
690 | struct i2c_mux_core *muxc = i2c_get_clientdata(client); |
691 | struct pca954x *data = i2c_mux_priv(muxc); |
692 | int ret; |
693 | |
694 | ret = pca954x_init(client, data); |
695 | if (ret < 0) |
696 | dev_err(&client->dev, "failed to verify mux presence\n" ); |
697 | |
698 | return ret; |
699 | } |
700 | |
701 | static DEFINE_SIMPLE_DEV_PM_OPS(pca954x_pm, NULL, pca954x_resume); |
702 | |
703 | static struct i2c_driver pca954x_driver = { |
704 | .driver = { |
705 | .name = "pca954x" , |
706 | .pm = pm_sleep_ptr(&pca954x_pm), |
707 | .of_match_table = pca954x_of_match, |
708 | }, |
709 | .probe = pca954x_probe, |
710 | .remove = pca954x_remove, |
711 | .id_table = pca954x_id, |
712 | }; |
713 | |
714 | module_i2c_driver(pca954x_driver); |
715 | |
716 | MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>" ); |
717 | MODULE_DESCRIPTION("PCA954x I2C mux/switch driver" ); |
718 | MODULE_LICENSE("GPL v2" ); |
719 | |