4 * Copyright (c) 2008-2009 Rodolfo Giometti <giometti@linux.it>
5 * Copyright (c) 2008-2009 Eurotech S.p.A. <info@eurotech.it>
7 * This module supports the PCA954x series of I2C multiplexer/switch chips
8 * made by Philips Semiconductors.
10 * PCA9540, PCA9542, PCA9543, PCA9544, PCA9545, PCA9546, PCA9547
13 * These chips are all controlled via the I2C bus itself, and all have a
14 * single 8-bit register. The upstream "parent" bus fans out to two,
15 * four, or eight downstream busses or channels; which of these
16 * are selected is determined by the chip type and register contents. A
17 * mux can select only one sub-bus at a time; a switch can select any
18 * combination simultaneously.
21 * pca954x.c from Kumar Gala <galak@kernel.crashing.org>
25 * pca954x.c from Ken Harrenstien
26 * Copyright (C) 2004 Google, Inc. (Ken Harrenstien)
29 * i2c-virtual_cb.c from Brian Kuschak <bkuschak@yahoo.com>
31 * pca9540.c from Jean Delvare <jdelvare@suse.de>.
33 * This file is licensed under the terms of the GNU General Public
34 * License version 2. This program is licensed "as is" without any
35 * warranty of any kind, whether express or implied.
38 #include <linux/device.h>
39 #include <linux/gpio/consumer.h>
40 #include <linux/i2c.h>
41 #include <linux/i2c-mux.h>
42 #include <linux/i2c/pca954x.h>
43 #include <linux/interrupt.h>
44 #include <linux/irq.h>
45 #include <linux/module.h>
47 #include <linux/of_device.h>
48 #include <linux/of_irq.h>
50 #include <linux/slab.h>
51 #include <linux/spinlock.h>
53 #define PCA954X_MAX_NCHANS 8
55 #define PCA954X_IRQ_OFFSET 4
70 u8 enable
; /* used for muxes only */
79 const struct chip_desc
*chip
;
81 u8 last_chan
; /* last register value */
83 struct i2c_client
*client
;
85 struct irq_domain
*irq
;
86 unsigned int irq_mask
;
90 /* Provide specs for the PCA954x types we know about */
91 static const struct chip_desc chips
[] = {
95 .muxtype
= pca954x_ismux
,
101 .muxtype
= pca954x_ismux
,
106 .muxtype
= pca954x_isswi
,
112 .muxtype
= pca954x_ismux
,
117 .muxtype
= pca954x_isswi
,
121 .muxtype
= pca954x_isswi
,
126 .muxtype
= pca954x_ismux
,
130 .muxtype
= pca954x_isswi
,
134 static const struct i2c_device_id pca954x_id
[] = {
135 { "pca9540", pca_9540
},
136 { "pca9542", pca_9542
},
137 { "pca9543", pca_9543
},
138 { "pca9544", pca_9544
},
139 { "pca9545", pca_9545
},
140 { "pca9546", pca_9546
},
141 { "pca9547", pca_9547
},
142 { "pca9548", pca_9548
},
145 MODULE_DEVICE_TABLE(i2c
, pca954x_id
);
148 static const struct of_device_id pca954x_of_match
[] = {
149 { .compatible
= "nxp,pca9540", .data
= &chips
[pca_9540
] },
150 { .compatible
= "nxp,pca9542", .data
= &chips
[pca_9542
] },
151 { .compatible
= "nxp,pca9543", .data
= &chips
[pca_9543
] },
152 { .compatible
= "nxp,pca9544", .data
= &chips
[pca_9544
] },
153 { .compatible
= "nxp,pca9545", .data
= &chips
[pca_9545
] },
154 { .compatible
= "nxp,pca9546", .data
= &chips
[pca_9546
] },
155 { .compatible
= "nxp,pca9547", .data
= &chips
[pca_9547
] },
156 { .compatible
= "nxp,pca9548", .data
= &chips
[pca_9548
] },
159 MODULE_DEVICE_TABLE(of
, pca954x_of_match
);
162 /* Write to mux register. Don't use i2c_transfer()/i2c_smbus_xfer()
163 for this as they will try to lock adapter a second time */
164 static int pca954x_reg_write(struct i2c_adapter
*adap
,
165 struct i2c_client
*client
, u8 val
)
169 if (adap
->algo
->master_xfer
) {
173 msg
.addr
= client
->addr
;
178 ret
= __i2c_transfer(adap
, &msg
, 1);
180 if (ret
>= 0 && ret
!= 1)
183 union i2c_smbus_data data
;
184 ret
= adap
->algo
->smbus_xfer(adap
, client
->addr
,
187 val
, I2C_SMBUS_BYTE
, &data
);
193 static int pca954x_select_chan(struct i2c_mux_core
*muxc
, u32 chan
)
195 struct pca954x
*data
= i2c_mux_priv(muxc
);
196 struct i2c_client
*client
= data
->client
;
197 const struct chip_desc
*chip
= data
->chip
;
201 /* we make switches look like muxes, not sure how to be smarter */
202 if (chip
->muxtype
== pca954x_ismux
)
203 regval
= chan
| chip
->enable
;
207 /* Only select the channel if its different from the last channel */
208 if (data
->last_chan
!= regval
) {
209 ret
= pca954x_reg_write(muxc
->parent
, client
, regval
);
210 data
->last_chan
= ret
< 0 ? 0 : regval
;
216 static int pca954x_deselect_mux(struct i2c_mux_core
*muxc
, u32 chan
)
218 struct pca954x
*data
= i2c_mux_priv(muxc
);
219 struct i2c_client
*client
= data
->client
;
221 if (!(data
->deselect
& (1 << chan
)))
224 /* Deselect active channel */
226 return pca954x_reg_write(muxc
->parent
, client
, data
->last_chan
);
229 static irqreturn_t
pca954x_irq_handler(int irq
, void *dev_id
)
231 struct pca954x
*data
= dev_id
;
232 unsigned int child_irq
;
233 int ret
, i
, handled
= 0;
235 ret
= i2c_smbus_read_byte(data
->client
);
239 for (i
= 0; i
< data
->chip
->nchans
; i
++) {
240 if (ret
& BIT(PCA954X_IRQ_OFFSET
+ i
)) {
241 child_irq
= irq_linear_revmap(data
->irq
, i
);
242 handle_nested_irq(child_irq
);
246 return handled
? IRQ_HANDLED
: IRQ_NONE
;
249 static void pca954x_irq_mask(struct irq_data
*idata
)
251 struct pca954x
*data
= irq_data_get_irq_chip_data(idata
);
252 unsigned int pos
= idata
->hwirq
;
255 raw_spin_lock_irqsave(&data
->lock
, flags
);
257 data
->irq_mask
&= ~BIT(pos
);
259 disable_irq(data
->client
->irq
);
261 raw_spin_unlock_irqrestore(&data
->lock
, flags
);
264 static void pca954x_irq_unmask(struct irq_data
*idata
)
266 struct pca954x
*data
= irq_data_get_irq_chip_data(idata
);
267 unsigned int pos
= idata
->hwirq
;
270 raw_spin_lock_irqsave(&data
->lock
, flags
);
273 enable_irq(data
->client
->irq
);
274 data
->irq_mask
|= BIT(pos
);
276 raw_spin_unlock_irqrestore(&data
->lock
, flags
);
279 static int pca954x_irq_set_type(struct irq_data
*idata
, unsigned int type
)
281 if ((type
& IRQ_TYPE_SENSE_MASK
) != IRQ_TYPE_LEVEL_LOW
)
286 static struct irq_chip pca954x_irq_chip
= {
287 .name
= "i2c-mux-pca954x",
288 .irq_mask
= pca954x_irq_mask
,
289 .irq_unmask
= pca954x_irq_unmask
,
290 .irq_set_type
= pca954x_irq_set_type
,
293 static int pca954x_irq_setup(struct i2c_mux_core
*muxc
)
295 struct pca954x
*data
= i2c_mux_priv(muxc
);
296 struct i2c_client
*client
= data
->client
;
299 if (!data
->chip
->has_irq
|| client
->irq
<= 0)
302 raw_spin_lock_init(&data
->lock
);
304 data
->irq
= irq_domain_add_linear(client
->dev
.of_node
,
306 &irq_domain_simple_ops
, data
);
310 for (c
= 0; c
< data
->chip
->nchans
; c
++) {
311 irq
= irq_create_mapping(data
->irq
, c
);
312 irq_set_chip_data(irq
, data
);
313 irq_set_chip_and_handler(irq
, &pca954x_irq_chip
,
317 err
= devm_request_threaded_irq(&client
->dev
, data
->client
->irq
, NULL
,
319 IRQF_ONESHOT
| IRQF_SHARED
,
324 disable_irq(data
->client
->irq
);
328 for (c
= 0; c
< data
->chip
->nchans
; c
++) {
329 irq
= irq_find_mapping(data
->irq
, c
);
330 irq_dispose_mapping(irq
);
332 irq_domain_remove(data
->irq
);
338 * I2C init/probing/exit functions
340 static int pca954x_probe(struct i2c_client
*client
,
341 const struct i2c_device_id
*id
)
343 struct i2c_adapter
*adap
= to_i2c_adapter(client
->dev
.parent
);
344 struct pca954x_platform_data
*pdata
= dev_get_platdata(&client
->dev
);
345 struct device_node
*of_node
= client
->dev
.of_node
;
346 bool idle_disconnect_dt
;
347 struct gpio_desc
*gpio
;
348 int num
, force
, class;
349 struct i2c_mux_core
*muxc
;
350 struct pca954x
*data
;
351 const struct of_device_id
*match
;
354 if (!i2c_check_functionality(adap
, I2C_FUNC_SMBUS_BYTE
))
357 muxc
= i2c_mux_alloc(adap
, &client
->dev
,
358 PCA954X_MAX_NCHANS
, sizeof(*data
), 0,
359 pca954x_select_chan
, pca954x_deselect_mux
);
362 data
= i2c_mux_priv(muxc
);
364 i2c_set_clientdata(client
, muxc
);
365 data
->client
= client
;
367 /* Get the mux out of reset if a reset GPIO is specified. */
368 gpio
= devm_gpiod_get_optional(&client
->dev
, "reset", GPIOD_OUT_LOW
);
370 return PTR_ERR(gpio
);
372 /* Write the mux register at addr to verify
373 * that the mux is in fact present. This also
374 * initializes the mux to disconnected state.
376 if (i2c_smbus_write_byte(client
, 0) < 0) {
377 dev_warn(&client
->dev
, "probe failed\n");
381 match
= of_match_device(of_match_ptr(pca954x_of_match
), &client
->dev
);
383 data
->chip
= of_device_get_match_data(&client
->dev
);
385 data
->chip
= &chips
[id
->driver_data
];
387 data
->last_chan
= 0; /* force the first selection */
389 idle_disconnect_dt
= of_node
&&
390 of_property_read_bool(of_node
, "i2c-mux-idle-disconnect");
392 ret
= pca954x_irq_setup(muxc
);
394 goto fail_del_adapters
;
396 /* Now create an adapter for each channel */
397 for (num
= 0; num
< data
->chip
->nchans
; num
++) {
398 bool idle_disconnect_pd
= false;
400 force
= 0; /* dynamic adap number */
401 class = 0; /* no class by default */
403 if (num
< pdata
->num_modes
) {
404 /* force static number */
405 force
= pdata
->modes
[num
].adap_id
;
406 class = pdata
->modes
[num
].class;
408 /* discard unconfigured channels */
410 idle_disconnect_pd
= pdata
->modes
[num
].deselect_on_exit
;
412 data
->deselect
|= (idle_disconnect_pd
||
413 idle_disconnect_dt
) << num
;
415 ret
= i2c_mux_add_adapter(muxc
, force
, num
, class);
417 goto fail_del_adapters
;
420 dev_info(&client
->dev
,
421 "registered %d multiplexed busses for I2C %s %s\n",
422 num
, data
->chip
->muxtype
== pca954x_ismux
423 ? "mux" : "switch", client
->name
);
428 i2c_mux_del_adapters(muxc
);
432 static int pca954x_remove(struct i2c_client
*client
)
434 struct i2c_mux_core
*muxc
= i2c_get_clientdata(client
);
435 struct pca954x
*data
= i2c_mux_priv(muxc
);
439 for (c
= 0; c
< data
->chip
->nchans
; c
++) {
440 irq
= irq_find_mapping(data
->irq
, c
);
441 irq_dispose_mapping(irq
);
443 irq_domain_remove(data
->irq
);
446 i2c_mux_del_adapters(muxc
);
450 #ifdef CONFIG_PM_SLEEP
451 static int pca954x_resume(struct device
*dev
)
453 struct i2c_client
*client
= to_i2c_client(dev
);
454 struct i2c_mux_core
*muxc
= i2c_get_clientdata(client
);
455 struct pca954x
*data
= i2c_mux_priv(muxc
);
458 return i2c_smbus_write_byte(client
, 0);
462 static SIMPLE_DEV_PM_OPS(pca954x_pm
, NULL
, pca954x_resume
);
464 static struct i2c_driver pca954x_driver
= {
468 .of_match_table
= of_match_ptr(pca954x_of_match
),
470 .probe
= pca954x_probe
,
471 .remove
= pca954x_remove
,
472 .id_table
= pca954x_id
,
475 module_i2c_driver(pca954x_driver
);
477 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
478 MODULE_DESCRIPTION("PCA954x I2C mux/switch driver");
479 MODULE_LICENSE("GPL v2");