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 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/i2c/pca954x.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
  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         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_9547] = {
 120                 .nchans = 8,
 121                 .enable = 0x8,
 122                 .muxtype = pca954x_ismux,
 123         },
 124         [pca_9548] = {
 125                 .nchans = 8,
 126                 .muxtype = pca954x_isswi,
 127         },
 128 };
 129
 130 static const struct i2c_device_id pca954x_id[] = {
 131         { "pca9540", pca_9540 },
 132         { "pca9542", pca_9542 },
 133         { "pca9543", pca_9543 },
 134         { "pca9544", pca_9544 },
 135         { "pca9545", pca_9545 },
 136         { "pca9546", pca_9545 },
 137         { "pca9547", pca_9547 },
 138         { "pca9548", pca_9548 },
 139         { }
 140 };
 141 MODULE_DEVICE_TABLE(i2c, pca954x_id);
 142
 143 #ifdef CONFIG_OF
 144 static const struct of_device_id pca954x_of_match[] = {
 145         { .compatible = "nxp,pca9540", .data = &chips[pca_9540] },
 146         { .compatible = "nxp,pca9542", .data = &chips[pca_9542] },
 147         { .compatible = "nxp,pca9543", .data = &chips[pca_9543] },
 148         { .compatible = "nxp,pca9544", .data = &chips[pca_9544] },
 149         { .compatible = "nxp,pca9545", .data = &chips[pca_9545] },
 150         { .compatible = "nxp,pca9546", .data = &chips[pca_9546] },
 151         { .compatible = "nxp,pca9547", .data = &chips[pca_9547] },
 152         { .compatible = "nxp,pca9548", .data = &chips[pca_9548] },
 153         {}
 154 };
 155 MODULE_DEVICE_TABLE(of, pca954x_of_match);
 156 #endif
 157
 158 /* Write to mux register. Don't use i2c_transfer()/i2c_smbus_xfer()
 159    for this as they will try to lock adapter a second time */
 160 static int pca954x_reg_write(struct i2c_adapter *adap,
 161                              struct i2c_client *client, u8 val)
 162 {
 163         int ret = -ENODEV;
 164
 165         if (adap->algo->master_xfer) {
 166                 struct i2c_msg msg;
 167                 char buf[1];
 168
 169                 msg.addr = client->addr;
 170                 msg.flags = 0;
 171                 msg.len = 1;
 172                 buf[0] = val;
 173                 msg.buf = buf;
 174                 ret = __i2c_transfer(adap, &msg, 1);
 175
 176                 if (ret >= 0 && ret != 1)
 177                         ret = -EREMOTEIO;
 178         } else {
 179                 union i2c_smbus_data data;
 180                 ret = adap->algo->smbus_xfer(adap, client->addr,
 181                                              client->flags,
 182                                              I2C_SMBUS_WRITE,
 183                                              val, I2C_SMBUS_BYTE, &data);
 184         }
 185
 186         return ret;
 187 }
 188
 189 static int pca954x_select_chan(struct i2c_mux_core *muxc, u32 chan)
 190 {
 191         struct pca954x *data = i2c_mux_priv(muxc);
 192         struct i2c_client *client = data->client;
 193         const struct chip_desc *chip = data->chip;
 194         u8 regval;
 195         int ret = 0;
 196
 197         /* we make switches look like muxes, not sure how to be smarter */
 198         if (chip->muxtype == pca954x_ismux)
 199                 regval = chan | chip->enable;
 200         else
 201                 regval = 1 << chan;
 202
 203         /* Only select the channel if its different from the last channel */
 204         if (data->last_chan != regval) {
 205                 ret = pca954x_reg_write(muxc->parent, client, regval);
 206                 data->last_chan = ret < 0 ? 0 : regval;
 207         }
 208
 209         return ret;
 210 }
 211
 212 static int pca954x_deselect_mux(struct i2c_mux_core *muxc, u32 chan)
 213 {
 214         struct pca954x *data = i2c_mux_priv(muxc);
 215         struct i2c_client *client = data->client;
 216
 217         if (!(data->deselect & (1 << chan)))
 218                 return 0;
 219
 220         /* Deselect active channel */
 221         data->last_chan = 0;
 222         return pca954x_reg_write(muxc->parent, client, data->last_chan);
 223 }
 224
 225 static irqreturn_t pca954x_irq_handler(int irq, void *dev_id)
 226 {
 227         struct pca954x *data = dev_id;
 228         unsigned int child_irq;
 229         int ret, i, handled = 0;
 230
 231         ret = i2c_smbus_read_byte(data->client);
 232         if (ret < 0)
 233                 return IRQ_NONE;
 234
 235         for (i = 0; i < data->chip->nchans; i++) {
 236                 if (ret & BIT(PCA954X_IRQ_OFFSET + i)) {
 237                         child_irq = irq_linear_revmap(data->irq, i);
 238                         handle_nested_irq(child_irq);
 239                         handled++;
 240                 }
 241         }
 242         return handled ? IRQ_HANDLED : IRQ_NONE;
 243 }
 244
 245 static void pca954x_irq_mask(struct irq_data *idata)
 246 {
 247         struct pca954x *data = irq_data_get_irq_chip_data(idata);
 248         unsigned int pos = idata->hwirq;
 249         unsigned long flags;
 250
 251         spin_lock_irqsave(&data->lock, flags);
 252
 253         data->irq_mask &= ~BIT(pos);
 254         if (!data->irq_mask)
 255                 disable_irq(data->client->irq);
 256
 257         spin_unlock_irqrestore(&data->lock, flags);
 258 }
 259
 260 static void pca954x_irq_unmask(struct irq_data *idata)
 261 {
 262         struct pca954x *data = irq_data_get_irq_chip_data(idata);
 263         unsigned int pos = idata->hwirq;
 264         unsigned long flags;
 265
 266         spin_lock_irqsave(&data->lock, flags);
 267
 268         if (!data->irq_mask)
 269                 enable_irq(data->client->irq);
 270         data->irq_mask |= BIT(pos);
 271
 272         spin_unlock_irqrestore(&data->lock, flags);
 273 }
 274
 275 static int pca954x_irq_set_type(struct irq_data *idata, unsigned int type)
 276 {
 277         if ((type & IRQ_TYPE_SENSE_MASK) != IRQ_TYPE_LEVEL_LOW)
 278                 return -EINVAL;
 279         return 0;
 280 }
 281
 282 static struct irq_chip pca954x_irq_chip = {
 283         .name = "i2c-mux-pca954x",
 284         .irq_mask = pca954x_irq_mask,
 285         .irq_unmask = pca954x_irq_unmask,
 286         .irq_set_type = pca954x_irq_set_type,
 287 };
 288
 289 static int pca954x_irq_setup(struct i2c_mux_core *muxc)
 290 {
 291         struct pca954x *data = i2c_mux_priv(muxc);
 292         struct i2c_client *client = data->client;
 293         int c, err, irq;
 294
 295         if (!data->chip->has_irq || client->irq <= 0)
 296                 return 0;
 297
 298         spin_lock_init(&data->lock);
 299
 300         data->irq = irq_domain_add_linear(client->dev.of_node,
 301                                           data->chip->nchans,
 302                                           &irq_domain_simple_ops, data);
 303         if (!data->irq)
 304                 return -ENODEV;
 305
 306         for (c = 0; c < data->chip->nchans; c++) {
 307                 irq = irq_create_mapping(data->irq, c);
 308                 irq_set_chip_data(irq, data);
 309                 irq_set_chip_and_handler(irq, &pca954x_irq_chip,
 310                         handle_simple_irq);
 311         }
 312
 313         err = devm_request_threaded_irq(&client->dev, data->client->irq, NULL,
 314                                         pca954x_irq_handler,
 315                                         IRQF_ONESHOT | IRQF_SHARED,
 316                                         "pca954x", data);
 317         if (err)
 318                 goto err_req_irq;
 319
 320         disable_irq(data->client->irq);
 321
 322         return 0;
 323 err_req_irq:
 324         for (c = 0; c < data->chip->nchans; c++) {
 325                 irq = irq_find_mapping(data->irq, c);
 326                 irq_dispose_mapping(irq);
 327         }
 328         irq_domain_remove(data->irq);
 329
 330         return err;
 331 }
 332
 333 /*
 334  * I2C init/probing/exit functions
 335  */
 336 static int pca954x_probe(struct i2c_client *client,
 337                          const struct i2c_device_id *id)
 338 {
 339         struct i2c_adapter *adap = to_i2c_adapter(client->dev.parent);
 340         struct pca954x_platform_data *pdata = dev_get_platdata(&client->dev);
 341         struct device_node *of_node = client->dev.of_node;
 342         bool idle_disconnect_dt;
 343         struct gpio_desc *gpio;
 344         int num, force, class;
 345         struct i2c_mux_core *muxc;
 346         struct pca954x *data;
 347         const struct of_device_id *match;
 348         int ret;
 349
 350         if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_BYTE))
 351                 return -ENODEV;
 352
 353         muxc = i2c_mux_alloc(adap, &client->dev,
 354                              PCA954X_MAX_NCHANS, sizeof(*data), 0,
 355                              pca954x_select_chan, pca954x_deselect_mux);
 356         if (!muxc)
 357                 return -ENOMEM;
 358         data = i2c_mux_priv(muxc);
 359
 360         i2c_set_clientdata(client, muxc);
 361         data->client = client;
 362
 363         /* Get the mux out of reset if a reset GPIO is specified. */
 364         gpio = devm_gpiod_get_optional(&client->dev, "reset", GPIOD_OUT_LOW);
 365         if (IS_ERR(gpio))
 366                 return PTR_ERR(gpio);
 367
 368         /* Write the mux register at addr to verify
 369          * that the mux is in fact present. This also
 370          * initializes the mux to disconnected state.
 371          */
 372         if (i2c_smbus_write_byte(client, 0) < 0) {
 373                 dev_warn(&client->dev, "probe failed\n");
 374                 return -ENODEV;
 375         }
 376
 377         match = of_match_device(of_match_ptr(pca954x_of_match), &client->dev);
 378         if (match)
 379                 data->chip = of_device_get_match_data(&client->dev);
 380         else
 381                 data->chip = &chips[id->driver_data];
 382
 383         data->last_chan = 0;               /* force the first selection */
 384
 385         idle_disconnect_dt = of_node &&
 386                 of_property_read_bool(of_node, "i2c-mux-idle-disconnect");
 387
 388         ret = pca954x_irq_setup(muxc);
 389         if (ret)
 390                 goto fail_del_adapters;
 391
 392         /* Now create an adapter for each channel */
 393         for (num = 0; num < data->chip->nchans; num++) {
 394                 bool idle_disconnect_pd = false;
 395
 396                 force = 0;                        /* dynamic adap number */
 397                 class = 0;                        /* no class by default */
 398                 if (pdata) {
 399                         if (num < pdata->num_modes) {
 400                                 /* force static number */
 401                                 force = pdata->modes[num].adap_id;
 402                                 class = pdata->modes[num].class;
 403                         } else
 404                                 /* discard unconfigured channels */
 405                                 break;
 406                         idle_disconnect_pd = pdata->modes[num].deselect_on_exit;
 407                 }
 408                 data->deselect |= (idle_disconnect_pd ||
 409                                    idle_disconnect_dt) << num;
 410
 411                 ret = i2c_mux_add_adapter(muxc, force, num, class);
 412
 413                 if (ret) {
 414                         dev_err(&client->dev,
 415                                 "failed to register multiplexed adapter"
 416                                 " %d as bus %d\n", num, force);
 417                         goto fail_del_adapters;
 418                 }
 419         }
 420
 421         dev_info(&client->dev,
 422                  "registered %d multiplexed busses for I2C %s %s\n",
 423                  num, data->chip->muxtype == pca954x_ismux
 424                                 ? "mux" : "switch", client->name);
 425
 426         return 0;
 427
 428 fail_del_adapters:
 429         i2c_mux_del_adapters(muxc);
 430         return ret;
 431 }
 432
 433 static int pca954x_remove(struct i2c_client *client)
 434 {
 435         struct i2c_mux_core *muxc = i2c_get_clientdata(client);
 436         struct pca954x *data = i2c_mux_priv(muxc);
 437         int c, irq;
 438
 439         if (data->irq) {
 440                 for (c = 0; c < data->chip->nchans; c++) {
 441                         irq = irq_find_mapping(data->irq, c);
 442                         irq_dispose_mapping(irq);
 443                 }
 444                 irq_domain_remove(data->irq);
 445         }
 446
 447         i2c_mux_del_adapters(muxc);
 448         return 0;
 449 }
 450
 451 #ifdef CONFIG_PM_SLEEP
 452 static int pca954x_resume(struct device *dev)
 453 {
 454         struct i2c_client *client = to_i2c_client(dev);
 455         struct i2c_mux_core *muxc = i2c_get_clientdata(client);
 456         struct pca954x *data = i2c_mux_priv(muxc);
 457
 458         data->last_chan = 0;
 459         return i2c_smbus_write_byte(client, 0);
 460 }
 461 #endif
 462
 463 static SIMPLE_DEV_PM_OPS(pca954x_pm, NULL, pca954x_resume);
 464
 465 static struct i2c_driver pca954x_driver = {
 466         .driver         = {
 467                 .name   = "pca954x",
 468                 .pm     = &pca954x_pm,
 469                 .of_match_table = of_match_ptr(pca954x_of_match),
 470         },
 471         .probe          = pca954x_probe,
 472         .remove         = pca954x_remove,
 473         .id_table       = pca954x_id,
 474 };
 475
 476 module_i2c_driver(pca954x_driver);
 477
 478 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
 479 MODULE_DESCRIPTION("PCA954x I2C mux/switch driver");
 480 MODULE_LICENSE("GPL v2");