drivers/i2c/muxes/i2c-mux-pca954x.c

   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 and PCA954x series of I2C multiplexer/switch
   8  * chips made by NXP Semiconductors.
   9  * This includes the:
  10  *       PCA9540, PCA9542, PCA9543, PCA9544, PCA9545, PCA9546, PCA9547,
  11  *       PCA9548, PCA9846, PCA9847, PCA9848 and PCA9849.
  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/delay.h>
  40 #include <linux/gpio/consumer.h>
  41 #include <linux/i2c.h>
  42 #include <linux/i2c-mux.h>
  43 #include <linux/interrupt.h>
  44 #include <linux/irq.h>
  45 #include <linux/module.h>
  46 #include <linux/of.h>
  47 #include <linux/of_device.h>
  48 #include <linux/of_irq.h>
  49 #include <linux/pm.h>
  50 #include <linux/slab.h>
  51 #include <linux/spinlock.h>
  52 #include <dt-bindings/mux/mux.h>
  53
  54 #define PCA954X_MAX_NCHANS 8
  55
  56 #define PCA954X_IRQ_OFFSET 4
  57
  58 enum pca_type {
  59         pca_9540,
  60         pca_9542,
  61         pca_9543,
  62         pca_9544,
  63         pca_9545,
  64         pca_9546,
  65         pca_9547,
  66         pca_9548,
  67         pca_9846,
  68         pca_9847,
  69         pca_9848,
  70         pca_9849,
  71 };
  72
  73 struct chip_desc {
  74         u8 nchans;
  75         u8 enable;      /* used for muxes only */
  76         u8 has_irq;
  77         enum muxtype {
  78                 pca954x_ismux = 0,
  79                 pca954x_isswi
  80         } muxtype;
  81         struct i2c_device_identity id;
  82 };
  83
  84 struct pca954x {
  85         const struct chip_desc *chip;
  86
  87         u8 last_chan;           /* last register value */
  88         /* MUX_IDLE_AS_IS, MUX_IDLE_DISCONNECT or >= 0 for channel */
  89         s8 idle_state;
  90
  91         struct i2c_client *client;
  92
  93         struct irq_domain *irq;
  94         unsigned int irq_mask;
  95         raw_spinlock_t lock;
  96 };
  97
  98 /* Provide specs for the PCA954x types we know about */
  99 static const struct chip_desc chips[] = {
 100         [pca_9540] = {
 101                 .nchans = 2,
 102                 .enable = 0x4,
 103                 .muxtype = pca954x_ismux,
 104                 .id = { .manufacturer_id = I2C_DEVICE_ID_NONE },
 105         },
 106         [pca_9542] = {
 107                 .nchans = 2,
 108                 .enable = 0x4,
 109                 .has_irq = 1,
 110                 .muxtype = pca954x_ismux,
 111                 .id = { .manufacturer_id = I2C_DEVICE_ID_NONE },
 112         },
 113         [pca_9543] = {
 114                 .nchans = 2,
 115                 .has_irq = 1,
 116                 .muxtype = pca954x_isswi,
 117                 .id = { .manufacturer_id = I2C_DEVICE_ID_NONE },
 118         },
 119         [pca_9544] = {
 120                 .nchans = 4,
 121                 .enable = 0x4,
 122                 .has_irq = 1,
 123                 .muxtype = pca954x_ismux,
 124                 .id = { .manufacturer_id = I2C_DEVICE_ID_NONE },
 125         },
 126         [pca_9545] = {
 127                 .nchans = 4,
 128                 .has_irq = 1,
 129                 .muxtype = pca954x_isswi,
 130                 .id = { .manufacturer_id = I2C_DEVICE_ID_NONE },
 131         },
 132         [pca_9546] = {
 133                 .nchans = 4,
 134                 .muxtype = pca954x_isswi,
 135                 .id = { .manufacturer_id = I2C_DEVICE_ID_NONE },
 136         },
 137         [pca_9547] = {
 138                 .nchans = 8,
 139                 .enable = 0x8,
 140                 .muxtype = pca954x_ismux,
 141                 .id = { .manufacturer_id = I2C_DEVICE_ID_NONE },
 142         },
 143         [pca_9548] = {
 144                 .nchans = 8,
 145                 .muxtype = pca954x_isswi,
 146                 .id = { .manufacturer_id = I2C_DEVICE_ID_NONE },
 147         },
 148         [pca_9846] = {
 149                 .nchans = 4,
 150                 .muxtype = pca954x_isswi,
 151                 .id = {
 152                         .manufacturer_id = I2C_DEVICE_ID_NXP_SEMICONDUCTORS,
 153                         .part_id = 0x10b,
 154                 },
 155         },
 156         [pca_9847] = {
 157                 .nchans = 8,
 158                 .enable = 0x8,
 159                 .muxtype = pca954x_ismux,
 160                 .id = {
 161                         .manufacturer_id = I2C_DEVICE_ID_NXP_SEMICONDUCTORS,
 162                         .part_id = 0x108,
 163                 },
 164         },
 165         [pca_9848] = {
 166                 .nchans = 8,
 167                 .muxtype = pca954x_isswi,
 168                 .id = {
 169                         .manufacturer_id = I2C_DEVICE_ID_NXP_SEMICONDUCTORS,
 170                         .part_id = 0x10a,
 171                 },
 172         },
 173         [pca_9849] = {
 174                 .nchans = 4,
 175                 .enable = 0x4,
 176                 .muxtype = pca954x_ismux,
 177                 .id = {
 178                         .manufacturer_id = I2C_DEVICE_ID_NXP_SEMICONDUCTORS,
 179                         .part_id = 0x109,
 180                 },
 181         },
 182 };
 183
 184 static const struct i2c_device_id pca954x_id[] = {
 185         { "pca9540", pca_9540 },
 186         { "pca9542", pca_9542 },
 187         { "pca9543", pca_9543 },
 188         { "pca9544", pca_9544 },
 189         { "pca9545", pca_9545 },
 190         { "pca9546", pca_9546 },
 191         { "pca9547", pca_9547 },
 192         { "pca9548", pca_9548 },
 193         { "pca9846", pca_9846 },
 194         { "pca9847", pca_9847 },
 195         { "pca9848", pca_9848 },
 196         { "pca9849", pca_9849 },
 197         { }
 198 };
 199 MODULE_DEVICE_TABLE(i2c, pca954x_id);
 200
 201 #ifdef CONFIG_OF
 202 static const struct of_device_id pca954x_of_match[] = {
 203         { .compatible = "nxp,pca9540", .data = &chips[pca_9540] },
 204         { .compatible = "nxp,pca9542", .data = &chips[pca_9542] },
 205         { .compatible = "nxp,pca9543", .data = &chips[pca_9543] },
 206         { .compatible = "nxp,pca9544", .data = &chips[pca_9544] },
 207         { .compatible = "nxp,pca9545", .data = &chips[pca_9545] },
 208         { .compatible = "nxp,pca9546", .data = &chips[pca_9546] },
 209         { .compatible = "nxp,pca9547", .data = &chips[pca_9547] },
 210         { .compatible = "nxp,pca9548", .data = &chips[pca_9548] },
 211         { .compatible = "nxp,pca9846", .data = &chips[pca_9846] },
 212         { .compatible = "nxp,pca9847", .data = &chips[pca_9847] },
 213         { .compatible = "nxp,pca9848", .data = &chips[pca_9848] },
 214         { .compatible = "nxp,pca9849", .data = &chips[pca_9849] },
 215         {}
 216 };
 217 MODULE_DEVICE_TABLE(of, pca954x_of_match);
 218 #endif
 219
 220 /* Write to mux register. Don't use i2c_transfer()/i2c_smbus_xfer()
 221    for this as they will try to lock adapter a second time */
 222 static int pca954x_reg_write(struct i2c_adapter *adap,
 223                              struct i2c_client *client, u8 val)
 224 {
 225         union i2c_smbus_data dummy;
 226
 227         return __i2c_smbus_xfer(adap, client->addr, client->flags,
 228                                 I2C_SMBUS_WRITE, val,
 229                                 I2C_SMBUS_BYTE, &dummy);
 230 }
 231
 232 static int pca954x_select_chan(struct i2c_mux_core *muxc, u32 chan)
 233 {
 234         struct pca954x *data = i2c_mux_priv(muxc);
 235         struct i2c_client *client = data->client;
 236         const struct chip_desc *chip = data->chip;
 237         u8 regval;
 238         int ret = 0;
 239
 240         /* we make switches look like muxes, not sure how to be smarter */
 241         if (chip->muxtype == pca954x_ismux)
 242                 regval = chan | chip->enable;
 243         else
 244                 regval = 1 << chan;
 245
 246         /* Only select the channel if its different from the last channel */
 247         if (data->last_chan != regval) {
 248                 ret = pca954x_reg_write(muxc->parent, client, regval);
 249                 data->last_chan = ret < 0 ? 0 : regval;
 250         }
 251
 252         return ret;
 253 }
 254
 255 static int pca954x_deselect_mux(struct i2c_mux_core *muxc, u32 chan)
 256 {
 257         struct pca954x *data = i2c_mux_priv(muxc);
 258         struct i2c_client *client = data->client;
 259         s8 idle_state;
 260
 261         idle_state = READ_ONCE(data->idle_state);
 262         if (idle_state >= 0)
 263                 /* Set the mux back to a predetermined channel */
 264                 return pca954x_select_chan(muxc, idle_state);
 265
 266         if (idle_state == MUX_IDLE_DISCONNECT) {
 267                 /* Deselect active channel */
 268                 data->last_chan = 0;
 269                 return pca954x_reg_write(muxc->parent, client,
 270                                          data->last_chan);
 271         }
 272
 273         /* otherwise leave as-is */
 274
 275         return 0;
 276 }
 277
 278 static ssize_t idle_state_show(struct device *dev,
 279                                     struct device_attribute *attr,
 280                                     char *buf)
 281 {
 282         struct i2c_client *client = to_i2c_client(dev);
 283         struct i2c_mux_core *muxc = i2c_get_clientdata(client);
 284         struct pca954x *data = i2c_mux_priv(muxc);
 285
 286         return sprintf(buf, "%d\n", READ_ONCE(data->idle_state));
 287 }
 288
 289 static ssize_t idle_state_store(struct device *dev,
 290                                 struct device_attribute *attr,
 291                                 const char *buf, size_t count)
 292 {
 293         struct i2c_client *client = to_i2c_client(dev);
 294         struct i2c_mux_core *muxc = i2c_get_clientdata(client);
 295         struct pca954x *data = i2c_mux_priv(muxc);
 296         int val;
 297         int ret;
 298
 299         ret = kstrtoint(buf, 0, &val);
 300         if (ret < 0)
 301                 return ret;
 302
 303         if (val != MUX_IDLE_AS_IS && val != MUX_IDLE_DISCONNECT &&
 304             (val < 0 || val >= data->chip->nchans))
 305                 return -EINVAL;
 306
 307         i2c_lock_bus(muxc->parent, I2C_LOCK_SEGMENT);
 308
 309         WRITE_ONCE(data->idle_state, val);
 310         /*
 311          * Set the mux into a state consistent with the new
 312          * idle_state.
 313          */
 314         if (data->last_chan || val != MUX_IDLE_DISCONNECT)
 315                 ret = pca954x_deselect_mux(muxc, 0);
 316
 317         i2c_unlock_bus(muxc->parent, I2C_LOCK_SEGMENT);
 318
 319         return ret < 0 ? ret : count;
 320 }
 321
 322 static DEVICE_ATTR_RW(idle_state);
 323
 324 static irqreturn_t pca954x_irq_handler(int irq, void *dev_id)
 325 {
 326         struct pca954x *data = dev_id;
 327         unsigned int child_irq;
 328         int ret, i, handled = 0;
 329
 330         ret = i2c_smbus_read_byte(data->client);
 331         if (ret < 0)
 332                 return IRQ_NONE;
 333
 334         for (i = 0; i < data->chip->nchans; i++) {
 335                 if (ret & BIT(PCA954X_IRQ_OFFSET + i)) {
 336                         child_irq = irq_linear_revmap(data->irq, i);
 337                         handle_nested_irq(child_irq);
 338                         handled++;
 339                 }
 340         }
 341         return handled ? IRQ_HANDLED : IRQ_NONE;
 342 }
 343
 344 static int pca954x_irq_set_type(struct irq_data *idata, unsigned int type)
 345 {
 346         if ((type & IRQ_TYPE_SENSE_MASK) != IRQ_TYPE_LEVEL_LOW)
 347                 return -EINVAL;
 348         return 0;
 349 }
 350
 351 static struct irq_chip pca954x_irq_chip = {
 352         .name = "i2c-mux-pca954x",
 353         .irq_set_type = pca954x_irq_set_type,
 354 };
 355
 356 static int pca954x_irq_setup(struct i2c_mux_core *muxc)
 357 {
 358         struct pca954x *data = i2c_mux_priv(muxc);
 359         struct i2c_client *client = data->client;
 360         int c, irq;
 361
 362         if (!data->chip->has_irq || client->irq <= 0)
 363                 return 0;
 364
 365         raw_spin_lock_init(&data->lock);
 366
 367         data->irq = irq_domain_add_linear(client->dev.of_node,
 368                                           data->chip->nchans,
 369                                           &irq_domain_simple_ops, data);
 370         if (!data->irq)
 371                 return -ENODEV;
 372
 373         for (c = 0; c < data->chip->nchans; c++) {
 374                 irq = irq_create_mapping(data->irq, c);
 375                 if (!irq) {
 376                         dev_err(&client->dev, "failed irq create map\n");
 377                         return -EINVAL;
 378                 }
 379                 irq_set_chip_data(irq, data);
 380                 irq_set_chip_and_handler(irq, &pca954x_irq_chip,
 381                         handle_simple_irq);
 382         }
 383
 384         return 0;
 385 }
 386
 387 static void pca954x_cleanup(struct i2c_mux_core *muxc)
 388 {
 389         struct pca954x *data = i2c_mux_priv(muxc);
 390         struct i2c_client *client = data->client;
 391         int c, irq;
 392
 393         device_remove_file(&client->dev, &dev_attr_idle_state);
 394
 395         if (data->irq) {
 396                 for (c = 0; c < data->chip->nchans; c++) {
 397                         irq = irq_find_mapping(data->irq, c);
 398                         irq_dispose_mapping(irq);
 399                 }
 400                 irq_domain_remove(data->irq);
 401         }
 402         i2c_mux_del_adapters(muxc);
 403 }
 404
 405 /*
 406  * I2C init/probing/exit functions
 407  */
 408 static int pca954x_probe(struct i2c_client *client,
 409                          const struct i2c_device_id *id)
 410 {
 411         struct i2c_adapter *adap = client->adapter;
 412         struct device *dev = &client->dev;
 413         struct device_node *np = dev->of_node;
 414         bool idle_disconnect_dt;
 415         struct gpio_desc *gpio;
 416         struct i2c_mux_core *muxc;
 417         struct pca954x *data;
 418         int num;
 419         int ret;
 420
 421         if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_BYTE))
 422                 return -ENODEV;
 423
 424         muxc = i2c_mux_alloc(adap, dev, PCA954X_MAX_NCHANS, sizeof(*data), 0,
 425                              pca954x_select_chan, pca954x_deselect_mux);
 426         if (!muxc)
 427                 return -ENOMEM;
 428         data = i2c_mux_priv(muxc);
 429
 430         i2c_set_clientdata(client, muxc);
 431         data->client = client;
 432
 433         /* Reset the mux if a reset GPIO is specified. */
 434         gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
 435         if (IS_ERR(gpio))
 436                 return PTR_ERR(gpio);
 437         if (gpio) {
 438                 udelay(1);
 439                 gpiod_set_value_cansleep(gpio, 0);
 440                 /* Give the chip some time to recover. */
 441                 udelay(1);
 442         }
 443
 444         data->chip = of_device_get_match_data(dev);
 445         if (!data->chip)
 446                 data->chip = &chips[id->driver_data];
 447
 448         if (data->chip->id.manufacturer_id != I2C_DEVICE_ID_NONE) {
 449                 struct i2c_device_identity id;
 450
 451                 ret = i2c_get_device_id(client, &id);
 452                 if (ret && ret != -EOPNOTSUPP)
 453                         return ret;
 454
 455                 if (!ret &&
 456                     (id.manufacturer_id != data->chip->id.manufacturer_id ||
 457                      id.part_id != data->chip->id.part_id)) {
 458                         dev_warn(dev, "unexpected device id %03x-%03x-%x\n",
 459                                  id.manufacturer_id, id.part_id,
 460                                  id.die_revision);
 461                         return -ENODEV;
 462                 }
 463         }
 464
 465         /* Write the mux register at addr to verify
 466          * that the mux is in fact present. This also
 467          * initializes the mux to disconnected state.
 468          */
 469         if (i2c_smbus_write_byte(client, 0) < 0) {
 470                 dev_warn(dev, "probe failed\n");
 471                 return -ENODEV;
 472         }
 473
 474         data->last_chan = 0;               /* force the first selection */
 475         data->idle_state = MUX_IDLE_AS_IS;
 476
 477         idle_disconnect_dt = np &&
 478                 of_property_read_bool(np, "i2c-mux-idle-disconnect");
 479         if (idle_disconnect_dt)
 480                 data->idle_state = MUX_IDLE_DISCONNECT;
 481
 482         ret = pca954x_irq_setup(muxc);
 483         if (ret)
 484                 goto fail_cleanup;
 485
 486         /* Now create an adapter for each channel */
 487         for (num = 0; num < data->chip->nchans; num++) {
 488                 ret = i2c_mux_add_adapter(muxc, 0, num, 0);
 489                 if (ret)
 490                         goto fail_cleanup;
 491         }
 492
 493         if (data->irq) {
 494                 ret = devm_request_threaded_irq(dev, data->client->irq,
 495                                                 NULL, pca954x_irq_handler,
 496                                                 IRQF_ONESHOT | IRQF_SHARED,
 497                                                 "pca954x", data);
 498                 if (ret)
 499                         goto fail_cleanup;
 500         }
 501
 502         /*
 503          * The attr probably isn't going to be needed in most cases,
 504          * so don't fail completely on error.
 505          */
 506         device_create_file(dev, &dev_attr_idle_state);
 507
 508         dev_info(dev, "registered %d multiplexed busses for I2C %s %s\n",
 509                  num, data->chip->muxtype == pca954x_ismux
 510                                 ? "mux" : "switch", client->name);
 511
 512         return 0;
 513
 514 fail_cleanup:
 515         pca954x_cleanup(muxc);
 516         return ret;
 517 }
 518
 519 static int pca954x_remove(struct i2c_client *client)
 520 {
 521         struct i2c_mux_core *muxc = i2c_get_clientdata(client);
 522
 523         pca954x_cleanup(muxc);
 524         return 0;
 525 }
 526
 527 #ifdef CONFIG_PM_SLEEP
 528 static int pca954x_resume(struct device *dev)
 529 {
 530         struct i2c_client *client = to_i2c_client(dev);
 531         struct i2c_mux_core *muxc = i2c_get_clientdata(client);
 532         struct pca954x *data = i2c_mux_priv(muxc);
 533
 534         data->last_chan = 0;
 535         return i2c_smbus_write_byte(client, 0);
 536 }
 537 #endif
 538
 539 static SIMPLE_DEV_PM_OPS(pca954x_pm, NULL, pca954x_resume);
 540
 541 static struct i2c_driver pca954x_driver = {
 542         .driver         = {
 543                 .name   = "pca954x",
 544                 .pm     = &pca954x_pm,
 545                 .of_match_table = of_match_ptr(pca954x_of_match),
 546         },
 547         .probe          = pca954x_probe,
 548         .remove         = pca954x_remove,
 549         .id_table       = pca954x_id,
 550 };
 551
 552 module_i2c_driver(pca954x_driver);
 553
 554 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
 555 MODULE_DESCRIPTION("PCA954x I2C mux/switch driver");
 556 MODULE_LICENSE("GPL v2");