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");