1 /* 2 * I2C multiplexer 3 * 4 * Copyright (c) 2008-2009 Rodolfo Giometti <giometti@linux.it> 5 * Copyright (c) 2008-2009 Eurotech S.p.A. <info@eurotech.it> 6 * 7 * This module supports the PCA954x series of I2C multiplexer/switch chips 8 * made by Philips Semiconductors. 9 * This includes the: 10 * PCA9540, PCA9542, PCA9543, PCA9544, PCA9545, PCA9546, PCA9547 11 * and PCA9548. 12 * 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. 19 * 20 * Based on: 21 * pca954x.c from Kumar Gala <galak@kernel.crashing.org> 22 * Copyright (C) 2006 23 * 24 * Based on: 25 * pca954x.c from Ken Harrenstien 26 * Copyright (C) 2004 Google, Inc. (Ken Harrenstien) 27 * 28 * Based on: 29 * i2c-virtual_cb.c from Brian Kuschak <bkuschak@yahoo.com> 30 * and 31 * pca9540.c from Jean Delvare <jdelvare@suse.de>. 32 * 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. 36 */ 37 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/interrupt.h> 43 #include <linux/irq.h> 44 #include <linux/module.h> 45 #include <linux/of.h> 46 #include <linux/of_device.h> 47 #include <linux/of_irq.h> 48 #include <linux/platform_data/pca954x.h> 49 #include <linux/pm.h> 50 #include <linux/slab.h> 51 #include <linux/spinlock.h> 52 53 #define PCA954X_MAX_NCHANS 8 54 55 #define PCA954X_IRQ_OFFSET 4 56 57 enum pca_type { 58 pca_9540, 59 pca_9542, 60 pca_9543, 61 pca_9544, 62 pca_9545, 63 pca_9546, 64 pca_9547, 65 pca_9548, 66 }; 67 68 struct chip_desc { 69 u8 nchans; 70 u8 enable; /* used for muxes only */ 71 u8 has_irq; 72 enum muxtype { 73 pca954x_ismux = 0, 74 pca954x_isswi 75 } muxtype; 76 }; 77 78 struct pca954x { 79 const struct chip_desc *chip; 80 81 u8 last_chan; /* last register value */ 82 u8 deselect; 83 struct i2c_client *client; 84 85 struct irq_domain *irq; 86 unsigned int irq_mask; 87 raw_spinlock_t lock; 88 }; 89 90 /* Provide specs for the PCA954x types we know about */ 91 static const struct chip_desc chips[] = { 92 [pca_9540] = { 93 .nchans = 2, 94 .enable = 0x4, 95 .muxtype = pca954x_ismux, 96 }, 97 [pca_9542] = { 98 .nchans = 2, 99 .enable = 0x4, 100 .has_irq = 1, 101 .muxtype = pca954x_ismux, 102 }, 103 [pca_9543] = { 104 .nchans = 2, 105 .has_irq = 1, 106 .muxtype = pca954x_isswi, 107 }, 108 [pca_9544] = { 109 .nchans = 4, 110 .enable = 0x4, 111 .has_irq = 1, 112 .muxtype = pca954x_ismux, 113 }, 114 [pca_9545] = { 115 .nchans = 4, 116 .has_irq = 1, 117 .muxtype = pca954x_isswi, 118 }, 119 [pca_9546] = { 120 .nchans = 4, 121 .muxtype = pca954x_isswi, 122 }, 123 [pca_9547] = { 124 .nchans = 8, 125 .enable = 0x8, 126 .muxtype = pca954x_ismux, 127 }, 128 [pca_9548] = { 129 .nchans = 8, 130 .muxtype = pca954x_isswi, 131 }, 132 }; 133 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 }, 143 { } 144 }; 145 MODULE_DEVICE_TABLE(i2c, pca954x_id); 146 147 #ifdef CONFIG_OF 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] }, 157 {} 158 }; 159 MODULE_DEVICE_TABLE(of, pca954x_of_match); 160 #endif 161 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) 166 { 167 int ret = -ENODEV; 168 169 if (adap->algo->master_xfer) { 170 struct i2c_msg msg; 171 char buf[1]; 172 173 msg.addr = client->addr; 174 msg.flags = 0; 175 msg.len = 1; 176 buf[0] = val; 177 msg.buf = buf; 178 ret = __i2c_transfer(adap, &msg, 1); 179 180 if (ret >= 0 && ret != 1) 181 ret = -EREMOTEIO; 182 } else { 183 union i2c_smbus_data data; 184 ret = adap->algo->smbus_xfer(adap, client->addr, 185 client->flags, 186 I2C_SMBUS_WRITE, 187 val, I2C_SMBUS_BYTE, &data); 188 } 189 190 return ret; 191 } 192 193 static int pca954x_select_chan(struct i2c_mux_core *muxc, u32 chan) 194 { 195 struct pca954x *data = i2c_mux_priv(muxc); 196 struct i2c_client *client = data->client; 197 const struct chip_desc *chip = data->chip; 198 u8 regval; 199 int ret = 0; 200 201 /* we make switches look like muxes, not sure how to be smarter */ 202 if (chip->muxtype == pca954x_ismux) 203 regval = chan | chip->enable; 204 else 205 regval = 1 << chan; 206 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; 211 } 212 213 return ret; 214 } 215 216 static int pca954x_deselect_mux(struct i2c_mux_core *muxc, u32 chan) 217 { 218 struct pca954x *data = i2c_mux_priv(muxc); 219 struct i2c_client *client = data->client; 220 221 if (!(data->deselect & (1 << chan))) 222 return 0; 223 224 /* Deselect active channel */ 225 data->last_chan = 0; 226 return pca954x_reg_write(muxc->parent, client, data->last_chan); 227 } 228 229 static irqreturn_t pca954x_irq_handler(int irq, void *dev_id) 230 { 231 struct pca954x *data = dev_id; 232 unsigned int child_irq; 233 int ret, i, handled = 0; 234 235 ret = i2c_smbus_read_byte(data->client); 236 if (ret < 0) 237 return IRQ_NONE; 238 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); 243 handled++; 244 } 245 } 246 return handled ? IRQ_HANDLED : IRQ_NONE; 247 } 248 249 static int pca954x_irq_set_type(struct irq_data *idata, unsigned int type) 250 { 251 if ((type & IRQ_TYPE_SENSE_MASK) != IRQ_TYPE_LEVEL_LOW) 252 return -EINVAL; 253 return 0; 254 } 255 256 static struct irq_chip pca954x_irq_chip = { 257 .name = "i2c-mux-pca954x", 258 .irq_set_type = pca954x_irq_set_type, 259 }; 260 261 static int pca954x_irq_setup(struct i2c_mux_core *muxc) 262 { 263 struct pca954x *data = i2c_mux_priv(muxc); 264 struct i2c_client *client = data->client; 265 int c, irq; 266 267 if (!data->chip->has_irq || client->irq <= 0) 268 return 0; 269 270 raw_spin_lock_init(&data->lock); 271 272 data->irq = irq_domain_add_linear(client->dev.of_node, 273 data->chip->nchans, 274 &irq_domain_simple_ops, data); 275 if (!data->irq) 276 return -ENODEV; 277 278 for (c = 0; c < data->chip->nchans; c++) { 279 irq = irq_create_mapping(data->irq, c); 280 if (!irq) { 281 dev_err(&client->dev, "failed irq create map\n"); 282 return -EINVAL; 283 } 284 irq_set_chip_data(irq, data); 285 irq_set_chip_and_handler(irq, &pca954x_irq_chip, 286 handle_simple_irq); 287 } 288 289 return 0; 290 } 291 292 static void pca954x_cleanup(struct i2c_mux_core *muxc) 293 { 294 struct pca954x *data = i2c_mux_priv(muxc); 295 int c, irq; 296 297 if (data->irq) { 298 for (c = 0; c < data->chip->nchans; c++) { 299 irq = irq_find_mapping(data->irq, c); 300 irq_dispose_mapping(irq); 301 } 302 irq_domain_remove(data->irq); 303 } 304 i2c_mux_del_adapters(muxc); 305 } 306 307 /* 308 * I2C init/probing/exit functions 309 */ 310 static int pca954x_probe(struct i2c_client *client, 311 const struct i2c_device_id *id) 312 { 313 struct i2c_adapter *adap = to_i2c_adapter(client->dev.parent); 314 struct pca954x_platform_data *pdata = dev_get_platdata(&client->dev); 315 struct device_node *of_node = client->dev.of_node; 316 bool idle_disconnect_dt; 317 struct gpio_desc *gpio; 318 int num, force, class; 319 struct i2c_mux_core *muxc; 320 struct pca954x *data; 321 const struct of_device_id *match; 322 int ret; 323 324 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_BYTE)) 325 return -ENODEV; 326 327 muxc = i2c_mux_alloc(adap, &client->dev, 328 PCA954X_MAX_NCHANS, sizeof(*data), 0, 329 pca954x_select_chan, pca954x_deselect_mux); 330 if (!muxc) 331 return -ENOMEM; 332 data = i2c_mux_priv(muxc); 333 334 i2c_set_clientdata(client, muxc); 335 data->client = client; 336 337 /* Get the mux out of reset if a reset GPIO is specified. */ 338 gpio = devm_gpiod_get_optional(&client->dev, "reset", GPIOD_OUT_LOW); 339 if (IS_ERR(gpio)) 340 return PTR_ERR(gpio); 341 342 /* Write the mux register at addr to verify 343 * that the mux is in fact present. This also 344 * initializes the mux to disconnected state. 345 */ 346 if (i2c_smbus_write_byte(client, 0) < 0) { 347 dev_warn(&client->dev, "probe failed\n"); 348 return -ENODEV; 349 } 350 351 match = of_match_device(of_match_ptr(pca954x_of_match), &client->dev); 352 if (match) 353 data->chip = of_device_get_match_data(&client->dev); 354 else 355 data->chip = &chips[id->driver_data]; 356 357 data->last_chan = 0; /* force the first selection */ 358 359 idle_disconnect_dt = of_node && 360 of_property_read_bool(of_node, "i2c-mux-idle-disconnect"); 361 362 ret = pca954x_irq_setup(muxc); 363 if (ret) 364 goto fail_cleanup; 365 366 /* Now create an adapter for each channel */ 367 for (num = 0; num < data->chip->nchans; num++) { 368 bool idle_disconnect_pd = false; 369 370 force = 0; /* dynamic adap number */ 371 class = 0; /* no class by default */ 372 if (pdata) { 373 if (num < pdata->num_modes) { 374 /* force static number */ 375 force = pdata->modes[num].adap_id; 376 class = pdata->modes[num].class; 377 } else 378 /* discard unconfigured channels */ 379 break; 380 idle_disconnect_pd = pdata->modes[num].deselect_on_exit; 381 } 382 data->deselect |= (idle_disconnect_pd || 383 idle_disconnect_dt) << num; 384 385 ret = i2c_mux_add_adapter(muxc, force, num, class); 386 if (ret) 387 goto fail_cleanup; 388 } 389 390 if (data->irq) { 391 ret = devm_request_threaded_irq(&client->dev, data->client->irq, 392 NULL, pca954x_irq_handler, 393 IRQF_ONESHOT | IRQF_SHARED, 394 "pca954x", data); 395 if (ret) 396 goto fail_cleanup; 397 } 398 399 dev_info(&client->dev, 400 "registered %d multiplexed busses for I2C %s %s\n", 401 num, data->chip->muxtype == pca954x_ismux 402 ? "mux" : "switch", client->name); 403 404 return 0; 405 406 fail_cleanup: 407 pca954x_cleanup(muxc); 408 return ret; 409 } 410 411 static int pca954x_remove(struct i2c_client *client) 412 { 413 struct i2c_mux_core *muxc = i2c_get_clientdata(client); 414 415 pca954x_cleanup(muxc); 416 return 0; 417 } 418 419 #ifdef CONFIG_PM_SLEEP 420 static int pca954x_resume(struct device *dev) 421 { 422 struct i2c_client *client = to_i2c_client(dev); 423 struct i2c_mux_core *muxc = i2c_get_clientdata(client); 424 struct pca954x *data = i2c_mux_priv(muxc); 425 426 data->last_chan = 0; 427 return i2c_smbus_write_byte(client, 0); 428 } 429 #endif 430 431 static SIMPLE_DEV_PM_OPS(pca954x_pm, NULL, pca954x_resume); 432 433 static struct i2c_driver pca954x_driver = { 434 .driver = { 435 .name = "pca954x", 436 .pm = &pca954x_pm, 437 .of_match_table = of_match_ptr(pca954x_of_match), 438 }, 439 .probe = pca954x_probe, 440 .remove = pca954x_remove, 441 .id_table = pca954x_id, 442 }; 443 444 module_i2c_driver(pca954x_driver); 445 446 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); 447 MODULE_DESCRIPTION("PCA954x I2C mux/switch driver"); 448 MODULE_LICENSE("GPL v2"); 449