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/acpi.h>
39 #include <linux/device.h>
40 #include <linux/gpio/consumer.h>
41 #include <linux/i2c.h>
42 #include <linux/i2c-mux.h>
43 #include <linux/i2c/pca954x.h>
44 #include <linux/interrupt.h>
45 #include <linux/irq.h>
46 #include <linux/module.h>
48 #include <linux/of_device.h>
49 #include <linux/of_irq.h>
51 #include <linux/slab.h>
52 #include <linux/spinlock.h>
54 #define PCA954X_MAX_NCHANS 8
56 #define PCA954X_IRQ_OFFSET 4
71 u8 enable
; /* used for muxes only */
80 const struct chip_desc
*chip
;
82 u8 last_chan
; /* last register value */
84 struct i2c_client
*client
;
86 struct irq_domain
*irq
;
87 unsigned int irq_mask
;
91 /* Provide specs for the PCA954x types we know about */
92 static const struct chip_desc chips
[] = {
96 .muxtype
= pca954x_ismux
,
102 .muxtype
= pca954x_ismux
,
107 .muxtype
= pca954x_isswi
,
113 .muxtype
= pca954x_ismux
,
118 .muxtype
= pca954x_isswi
,
123 .muxtype
= pca954x_ismux
,
127 .muxtype
= pca954x_isswi
,
131 static const struct i2c_device_id pca954x_id
[] = {
132 { "pca9540", pca_9540
},
133 { "pca9542", pca_9542
},
134 { "pca9543", pca_9543
},
135 { "pca9544", pca_9544
},
136 { "pca9545", pca_9545
},
137 { "pca9546", pca_9545
},
138 { "pca9547", pca_9547
},
139 { "pca9548", pca_9548
},
142 MODULE_DEVICE_TABLE(i2c
, pca954x_id
);
145 static const struct acpi_device_id pca954x_acpi_ids
[] = {
146 { .id
= "PCA9540", .driver_data
= pca_9540
},
147 { .id
= "PCA9542", .driver_data
= pca_9542
},
148 { .id
= "PCA9543", .driver_data
= pca_9543
},
149 { .id
= "PCA9544", .driver_data
= pca_9544
},
150 { .id
= "PCA9545", .driver_data
= pca_9545
},
151 { .id
= "PCA9546", .driver_data
= pca_9545
},
152 { .id
= "PCA9547", .driver_data
= pca_9547
},
153 { .id
= "PCA9548", .driver_data
= pca_9548
},
156 MODULE_DEVICE_TABLE(acpi
, pca954x_acpi_ids
);
160 static const struct of_device_id pca954x_of_match
[] = {
161 { .compatible
= "nxp,pca9540", .data
= &chips
[pca_9540
] },
162 { .compatible
= "nxp,pca9542", .data
= &chips
[pca_9542
] },
163 { .compatible
= "nxp,pca9543", .data
= &chips
[pca_9543
] },
164 { .compatible
= "nxp,pca9544", .data
= &chips
[pca_9544
] },
165 { .compatible
= "nxp,pca9545", .data
= &chips
[pca_9545
] },
166 { .compatible
= "nxp,pca9546", .data
= &chips
[pca_9546
] },
167 { .compatible
= "nxp,pca9547", .data
= &chips
[pca_9547
] },
168 { .compatible
= "nxp,pca9548", .data
= &chips
[pca_9548
] },
171 MODULE_DEVICE_TABLE(of
, pca954x_of_match
);
174 /* Write to mux register. Don't use i2c_transfer()/i2c_smbus_xfer()
175 for this as they will try to lock adapter a second time */
176 static int pca954x_reg_write(struct i2c_adapter
*adap
,
177 struct i2c_client
*client
, u8 val
)
181 if (adap
->algo
->master_xfer
) {
185 msg
.addr
= client
->addr
;
190 ret
= __i2c_transfer(adap
, &msg
, 1);
192 if (ret
>= 0 && ret
!= 1)
195 union i2c_smbus_data data
;
196 ret
= adap
->algo
->smbus_xfer(adap
, client
->addr
,
199 val
, I2C_SMBUS_BYTE
, &data
);
205 static int pca954x_select_chan(struct i2c_mux_core
*muxc
, u32 chan
)
207 struct pca954x
*data
= i2c_mux_priv(muxc
);
208 struct i2c_client
*client
= data
->client
;
209 const struct chip_desc
*chip
= data
->chip
;
213 /* we make switches look like muxes, not sure how to be smarter */
214 if (chip
->muxtype
== pca954x_ismux
)
215 regval
= chan
| chip
->enable
;
219 /* Only select the channel if its different from the last channel */
220 if (data
->last_chan
!= regval
) {
221 ret
= pca954x_reg_write(muxc
->parent
, client
, regval
);
222 data
->last_chan
= ret
< 0 ? 0 : regval
;
228 static int pca954x_deselect_mux(struct i2c_mux_core
*muxc
, u32 chan
)
230 struct pca954x
*data
= i2c_mux_priv(muxc
);
231 struct i2c_client
*client
= data
->client
;
233 if (!(data
->deselect
& (1 << chan
)))
236 /* Deselect active channel */
238 return pca954x_reg_write(muxc
->parent
, client
, data
->last_chan
);
241 static irqreturn_t
pca954x_irq_handler(int irq
, void *dev_id
)
243 struct pca954x
*data
= dev_id
;
244 unsigned int child_irq
;
245 int ret
, i
, handled
= 0;
247 ret
= i2c_smbus_read_byte(data
->client
);
251 for (i
= 0; i
< data
->chip
->nchans
; i
++) {
252 if (ret
& BIT(PCA954X_IRQ_OFFSET
+ i
)) {
253 child_irq
= irq_linear_revmap(data
->irq
, i
);
254 handle_nested_irq(child_irq
);
258 return handled
? IRQ_HANDLED
: IRQ_NONE
;
261 static void pca954x_irq_mask(struct irq_data
*idata
)
263 struct pca954x
*data
= irq_data_get_irq_chip_data(idata
);
264 unsigned int pos
= idata
->hwirq
;
267 spin_lock_irqsave(&data
->lock
, flags
);
269 data
->irq_mask
&= ~BIT(pos
);
271 disable_irq(data
->client
->irq
);
273 spin_unlock_irqrestore(&data
->lock
, flags
);
276 static void pca954x_irq_unmask(struct irq_data
*idata
)
278 struct pca954x
*data
= irq_data_get_irq_chip_data(idata
);
279 unsigned int pos
= idata
->hwirq
;
282 spin_lock_irqsave(&data
->lock
, flags
);
285 enable_irq(data
->client
->irq
);
286 data
->irq_mask
|= BIT(pos
);
288 spin_unlock_irqrestore(&data
->lock
, flags
);
291 static int pca954x_irq_set_type(struct irq_data
*idata
, unsigned int type
)
293 if ((type
& IRQ_TYPE_SENSE_MASK
) != IRQ_TYPE_LEVEL_LOW
)
298 static struct irq_chip pca954x_irq_chip
= {
299 .name
= "i2c-mux-pca954x",
300 .irq_mask
= pca954x_irq_mask
,
301 .irq_unmask
= pca954x_irq_unmask
,
302 .irq_set_type
= pca954x_irq_set_type
,
305 static int pca954x_irq_setup(struct i2c_mux_core
*muxc
)
307 struct pca954x
*data
= i2c_mux_priv(muxc
);
308 struct i2c_client
*client
= data
->client
;
311 if (!data
->chip
->has_irq
|| client
->irq
<= 0)
314 spin_lock_init(&data
->lock
);
316 data
->irq
= irq_domain_add_linear(client
->dev
.of_node
,
318 &irq_domain_simple_ops
, data
);
322 for (c
= 0; c
< data
->chip
->nchans
; c
++) {
323 irq
= irq_create_mapping(data
->irq
, c
);
324 irq_set_chip_data(irq
, data
);
325 irq_set_chip_and_handler(irq
, &pca954x_irq_chip
,
329 err
= devm_request_threaded_irq(&client
->dev
, data
->client
->irq
, NULL
,
331 IRQF_ONESHOT
| IRQF_SHARED
,
336 disable_irq(data
->client
->irq
);
340 for (c
= 0; c
< data
->chip
->nchans
; c
++) {
341 irq
= irq_find_mapping(data
->irq
, c
);
342 irq_dispose_mapping(irq
);
344 irq_domain_remove(data
->irq
);
350 * I2C init/probing/exit functions
352 static int pca954x_probe(struct i2c_client
*client
,
353 const struct i2c_device_id
*id
)
355 struct i2c_adapter
*adap
= to_i2c_adapter(client
->dev
.parent
);
356 struct pca954x_platform_data
*pdata
= dev_get_platdata(&client
->dev
);
357 struct device_node
*of_node
= client
->dev
.of_node
;
358 bool idle_disconnect_dt
;
359 struct gpio_desc
*gpio
;
360 int num
, force
, class;
361 struct i2c_mux_core
*muxc
;
362 struct pca954x
*data
;
363 const struct of_device_id
*match
;
366 if (!i2c_check_functionality(adap
, I2C_FUNC_SMBUS_BYTE
))
369 muxc
= i2c_mux_alloc(adap
, &client
->dev
,
370 PCA954X_MAX_NCHANS
, sizeof(*data
), 0,
371 pca954x_select_chan
, pca954x_deselect_mux
);
374 data
= i2c_mux_priv(muxc
);
376 i2c_set_clientdata(client
, muxc
);
377 data
->client
= client
;
379 /* Get the mux out of reset if a reset GPIO is specified. */
380 gpio
= devm_gpiod_get_optional(&client
->dev
, "reset", GPIOD_OUT_LOW
);
382 return PTR_ERR(gpio
);
384 /* Write the mux register at addr to verify
385 * that the mux is in fact present. This also
386 * initializes the mux to disconnected state.
388 if (i2c_smbus_write_byte(client
, 0) < 0) {
389 dev_warn(&client
->dev
, "probe failed\n");
393 match
= of_match_device(of_match_ptr(pca954x_of_match
), &client
->dev
);
395 data
->chip
= of_device_get_match_data(&client
->dev
);
397 data
->chip
= &chips
[id
->driver_data
];
399 const struct acpi_device_id
*acpi_id
;
401 acpi_id
= acpi_match_device(ACPI_PTR(pca954x_acpi_ids
),
405 data
->chip
= &chips
[acpi_id
->driver_data
];
408 data
->last_chan
= 0; /* force the first selection */
410 idle_disconnect_dt
= of_node
&&
411 of_property_read_bool(of_node
, "i2c-mux-idle-disconnect");
413 ret
= pca954x_irq_setup(muxc
);
415 goto fail_del_adapters
;
417 /* Now create an adapter for each channel */
418 for (num
= 0; num
< data
->chip
->nchans
; num
++) {
419 bool idle_disconnect_pd
= false;
421 force
= 0; /* dynamic adap number */
422 class = 0; /* no class by default */
424 if (num
< pdata
->num_modes
) {
425 /* force static number */
426 force
= pdata
->modes
[num
].adap_id
;
427 class = pdata
->modes
[num
].class;
429 /* discard unconfigured channels */
431 idle_disconnect_pd
= pdata
->modes
[num
].deselect_on_exit
;
433 data
->deselect
|= (idle_disconnect_pd
||
434 idle_disconnect_dt
) << num
;
436 ret
= i2c_mux_add_adapter(muxc
, force
, num
, class);
439 dev_err(&client
->dev
,
440 "failed to register multiplexed adapter"
441 " %d as bus %d\n", num
, force
);
442 goto fail_del_adapters
;
446 dev_info(&client
->dev
,
447 "registered %d multiplexed busses for I2C %s %s\n",
448 num
, data
->chip
->muxtype
== pca954x_ismux
449 ? "mux" : "switch", client
->name
);
454 i2c_mux_del_adapters(muxc
);
458 static int pca954x_remove(struct i2c_client
*client
)
460 struct i2c_mux_core
*muxc
= i2c_get_clientdata(client
);
461 struct pca954x
*data
= i2c_mux_priv(muxc
);
465 for (c
= 0; c
< data
->chip
->nchans
; c
++) {
466 irq
= irq_find_mapping(data
->irq
, c
);
467 irq_dispose_mapping(irq
);
469 irq_domain_remove(data
->irq
);
472 i2c_mux_del_adapters(muxc
);
476 #ifdef CONFIG_PM_SLEEP
477 static int pca954x_resume(struct device
*dev
)
479 struct i2c_client
*client
= to_i2c_client(dev
);
480 struct i2c_mux_core
*muxc
= i2c_get_clientdata(client
);
481 struct pca954x
*data
= i2c_mux_priv(muxc
);
484 return i2c_smbus_write_byte(client
, 0);
488 static SIMPLE_DEV_PM_OPS(pca954x_pm
, NULL
, pca954x_resume
);
490 static struct i2c_driver pca954x_driver
= {
494 .of_match_table
= of_match_ptr(pca954x_of_match
),
495 .acpi_match_table
= ACPI_PTR(pca954x_acpi_ids
),
497 .probe
= pca954x_probe
,
498 .remove
= pca954x_remove
,
499 .id_table
= pca954x_id
,
502 module_i2c_driver(pca954x_driver
);
504 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
505 MODULE_DESCRIPTION("PCA954x I2C mux/switch driver");
506 MODULE_LICENSE("GPL v2");