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

   1 /*
   2  * I2C multiplexer driver for PCA9541 bus master selector
   3  *
   4  * Copyright (c) 2010 Ericsson AB.
   5  *
   6  * Author: Guenter Roeck <linux@roeck-us.net>
   7  *
   8  * Derived from:
   9  *  pca954x.c
  10  *
  11  *  Copyright (c) 2008-2009 Rodolfo Giometti <giometti@linux.it>
  12  *  Copyright (c) 2008-2009 Eurotech S.p.A. <info@eurotech.it>
  13  *
  14  * This file is licensed under the terms of the GNU General Public
  15  * License version 2. This program is licensed "as is" without any
  16  * warranty of any kind, whether express or implied.
  17  */
  18
  19 #include <linux/bitops.h>
  20 #include <linux/delay.h>
  21 #include <linux/device.h>
  22 #include <linux/i2c.h>
  23 #include <linux/i2c-mux.h>
  24 #include <linux/jiffies.h>
  25 #include <linux/module.h>
  26 #include <linux/slab.h>
  27
  28 /*
  29  * The PCA9541 is a bus master selector. It supports two I2C masters connected
  30  * to a single slave bus.
  31  *
  32  * Before each bus transaction, a master has to acquire bus ownership. After the
  33  * transaction is complete, bus ownership has to be released. This fits well
  34  * into the I2C multiplexer framework, which provides select and release
  35  * functions for this purpose. For this reason, this driver is modeled as
  36  * single-channel I2C bus multiplexer.
  37  *
  38  * This driver assumes that the two bus masters are controlled by two different
  39  * hosts. If a single host controls both masters, platform code has to ensure
  40  * that only one of the masters is instantiated at any given time.
  41  */
  42
  43 #define PCA9541_CONTROL         0x01
  44 #define PCA9541_ISTAT           0x02
  45
  46 #define PCA9541_CTL_MYBUS       BIT(0)
  47 #define PCA9541_CTL_NMYBUS      BIT(1)
  48 #define PCA9541_CTL_BUSON       BIT(2)
  49 #define PCA9541_CTL_NBUSON      BIT(3)
  50 #define PCA9541_CTL_BUSINIT     BIT(4)
  51 #define PCA9541_CTL_TESTON      BIT(6)
  52 #define PCA9541_CTL_NTESTON     BIT(7)
  53
  54 #define PCA9541_ISTAT_INTIN     BIT(0)
  55 #define PCA9541_ISTAT_BUSINIT   BIT(1)
  56 #define PCA9541_ISTAT_BUSOK     BIT(2)
  57 #define PCA9541_ISTAT_BUSLOST   BIT(3)
  58 #define PCA9541_ISTAT_MYTEST    BIT(6)
  59 #define PCA9541_ISTAT_NMYTEST   BIT(7)
  60
  61 #define BUSON           (PCA9541_CTL_BUSON | PCA9541_CTL_NBUSON)
  62 #define MYBUS           (PCA9541_CTL_MYBUS | PCA9541_CTL_NMYBUS)
  63 #define mybus(x)        (!((x) & MYBUS) || ((x) & MYBUS) == MYBUS)
  64 #define busoff(x)       (!((x) & BUSON) || ((x) & BUSON) == BUSON)
  65
  66 /* arbitration timeouts, in jiffies */
  67 #define ARB_TIMEOUT     (HZ / 8)        /* 125 ms until forcing bus ownership */
  68 #define ARB2_TIMEOUT    (HZ / 4)        /* 250 ms until acquisition failure */
  69
  70 /* arbitration retry delays, in us */
  71 #define SELECT_DELAY_SHORT      50
  72 #define SELECT_DELAY_LONG       1000
  73
  74 struct pca9541 {
  75         struct i2c_client *client;
  76         unsigned long select_timeout;
  77         unsigned long arb_timeout;
  78 };
  79
  80 static const struct i2c_device_id pca9541_id[] = {
  81         {"pca9541", 0},
  82         {}
  83 };
  84
  85 MODULE_DEVICE_TABLE(i2c, pca9541_id);
  86
  87 #ifdef CONFIG_OF
  88 static const struct of_device_id pca9541_of_match[] = {
  89         { .compatible = "nxp,pca9541" },
  90         {}
  91 };
  92 MODULE_DEVICE_TABLE(of, pca9541_of_match);
  93 #endif
  94
  95 /*
  96  * Write to chip register. Don't use i2c_transfer()/i2c_smbus_xfer()
  97  * as they will try to lock the adapter a second time.
  98  */
  99 static int pca9541_reg_write(struct i2c_client *client, u8 command, u8 val)
 100 {
 101         struct i2c_adapter *adap = client->adapter;
 102         union i2c_smbus_data data = { .byte = val };
 103
 104         return __i2c_smbus_xfer(adap, client->addr, client->flags,
 105                                 I2C_SMBUS_WRITE, command,
 106                                 I2C_SMBUS_BYTE_DATA, &data);
 107 }
 108
 109 /*
 110  * Read from chip register. Don't use i2c_transfer()/i2c_smbus_xfer()
 111  * as they will try to lock adapter a second time.
 112  */
 113 static int pca9541_reg_read(struct i2c_client *client, u8 command)
 114 {
 115         struct i2c_adapter *adap = client->adapter;
 116         union i2c_smbus_data data;
 117         int ret;
 118
 119         ret = __i2c_smbus_xfer(adap, client->addr, client->flags,
 120                                I2C_SMBUS_READ, command,
 121                                I2C_SMBUS_BYTE_DATA, &data);
 122
 123         return ret ?: data.byte;
 124 }
 125
 126 /*
 127  * Arbitration management functions
 128  */
 129
 130 /* Release bus. Also reset NTESTON and BUSINIT if it was set. */
 131 static void pca9541_release_bus(struct i2c_client *client)
 132 {
 133         int reg;
 134
 135         reg = pca9541_reg_read(client, PCA9541_CONTROL);
 136         if (reg >= 0 && !busoff(reg) && mybus(reg))
 137                 pca9541_reg_write(client, PCA9541_CONTROL,
 138                                   (reg & PCA9541_CTL_NBUSON) >> 1);
 139 }
 140
 141 /*
 142  * Arbitration is defined as a two-step process. A bus master can only activate
 143  * the slave bus if it owns it; otherwise it has to request ownership first.
 144  * This multi-step process ensures that access contention is resolved
 145  * gracefully.
 146  *
 147  * Bus  Ownership       Other master    Action
 148  * state                requested access
 149  * ----------------------------------------------------
 150  * off  -               yes             wait for arbitration timeout or
 151  *                                      for other master to drop request
 152  * off  no              no              take ownership
 153  * off  yes             no              turn on bus
 154  * on   yes             -               done
 155  * on   no              -               wait for arbitration timeout or
 156  *                                      for other master to release bus
 157  *
 158  * The main contention point occurs if the slave bus is off and both masters
 159  * request ownership at the same time. In this case, one master will turn on
 160  * the slave bus, believing that it owns it. The other master will request
 161  * bus ownership. Result is that the bus is turned on, and master which did
 162  * _not_ own the slave bus before ends up owning it.
 163  */
 164
 165 /* Control commands per PCA9541 datasheet */
 166 static const u8 pca9541_control[16] = {
 167         4, 0, 1, 5, 4, 4, 5, 5, 0, 0, 1, 1, 0, 4, 5, 1
 168 };
 169
 170 /*
 171  * Channel arbitration
 172  *
 173  * Return values:
 174  *  <0: error
 175  *  0 : bus not acquired
 176  *  1 : bus acquired
 177  */
 178 static int pca9541_arbitrate(struct i2c_client *client)
 179 {
 180         struct i2c_mux_core *muxc = i2c_get_clientdata(client);
 181         struct pca9541 *data = i2c_mux_priv(muxc);
 182         int reg;
 183
 184         reg = pca9541_reg_read(client, PCA9541_CONTROL);
 185         if (reg < 0)
 186                 return reg;
 187
 188         if (busoff(reg)) {
 189                 int istat;
 190                 /*
 191                  * Bus is off. Request ownership or turn it on unless
 192                  * other master requested ownership.
 193                  */
 194                 istat = pca9541_reg_read(client, PCA9541_ISTAT);
 195                 if (!(istat & PCA9541_ISTAT_NMYTEST)
 196                     || time_is_before_eq_jiffies(data->arb_timeout)) {
 197                         /*
 198                          * Other master did not request ownership,
 199                          * or arbitration timeout expired. Take the bus.
 200                          */
 201                         pca9541_reg_write(client,
 202                                           PCA9541_CONTROL,
 203                                           pca9541_control[reg & 0x0f]
 204                                           | PCA9541_CTL_NTESTON);
 205                         data->select_timeout = SELECT_DELAY_SHORT;
 206                 } else {
 207                         /*
 208                          * Other master requested ownership.
 209                          * Set extra long timeout to give it time to acquire it.
 210                          */
 211                         data->select_timeout = SELECT_DELAY_LONG * 2;
 212                 }
 213         } else if (mybus(reg)) {
 214                 /*
 215                  * Bus is on, and we own it. We are done with acquisition.
 216                  * Reset NTESTON and BUSINIT, then return success.
 217                  */
 218                 if (reg & (PCA9541_CTL_NTESTON | PCA9541_CTL_BUSINIT))
 219                         pca9541_reg_write(client,
 220                                           PCA9541_CONTROL,
 221                                           reg & ~(PCA9541_CTL_NTESTON
 222                                                   | PCA9541_CTL_BUSINIT));
 223                 return 1;
 224         } else {
 225                 /*
 226                  * Other master owns the bus.
 227                  * If arbitration timeout has expired, force ownership.
 228                  * Otherwise request it.
 229                  */
 230                 data->select_timeout = SELECT_DELAY_LONG;
 231                 if (time_is_before_eq_jiffies(data->arb_timeout)) {
 232                         /* Time is up, take the bus and reset it. */
 233                         pca9541_reg_write(client,
 234                                           PCA9541_CONTROL,
 235                                           pca9541_control[reg & 0x0f]
 236                                           | PCA9541_CTL_BUSINIT
 237                                           | PCA9541_CTL_NTESTON);
 238                 } else {
 239                         /* Request bus ownership if needed */
 240                         if (!(reg & PCA9541_CTL_NTESTON))
 241                                 pca9541_reg_write(client,
 242                                                   PCA9541_CONTROL,
 243                                                   reg | PCA9541_CTL_NTESTON);
 244                 }
 245         }
 246         return 0;
 247 }
 248
 249 static int pca9541_select_chan(struct i2c_mux_core *muxc, u32 chan)
 250 {
 251         struct pca9541 *data = i2c_mux_priv(muxc);
 252         struct i2c_client *client = data->client;
 253         int ret;
 254         unsigned long timeout = jiffies + ARB2_TIMEOUT;
 255                 /* give up after this time */
 256
 257         data->arb_timeout = jiffies + ARB_TIMEOUT;
 258                 /* force bus ownership after this time */
 259
 260         do {
 261                 ret = pca9541_arbitrate(client);
 262                 if (ret)
 263                         return ret < 0 ? ret : 0;
 264
 265                 if (data->select_timeout == SELECT_DELAY_SHORT)
 266                         udelay(data->select_timeout);
 267                 else
 268                         msleep(data->select_timeout / 1000);
 269         } while (time_is_after_eq_jiffies(timeout));
 270
 271         return -ETIMEDOUT;
 272 }
 273
 274 static int pca9541_release_chan(struct i2c_mux_core *muxc, u32 chan)
 275 {
 276         struct pca9541 *data = i2c_mux_priv(muxc);
 277         struct i2c_client *client = data->client;
 278
 279         pca9541_release_bus(client);
 280         return 0;
 281 }
 282
 283 /*
 284  * I2C init/probing/exit functions
 285  */
 286 static int pca9541_probe(struct i2c_client *client,
 287                          const struct i2c_device_id *id)
 288 {
 289         struct i2c_adapter *adap = client->adapter;
 290         struct i2c_mux_core *muxc;
 291         struct pca9541 *data;
 292         int ret;
 293
 294         if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_BYTE_DATA))
 295                 return -ENODEV;
 296
 297         /*
 298          * I2C accesses are unprotected here.
 299          * We have to lock the I2C segment before releasing the bus.
 300          */
 301         i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
 302         pca9541_release_bus(client);
 303         i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
 304
 305         /* Create mux adapter */
 306
 307         muxc = i2c_mux_alloc(adap, &client->dev, 1, sizeof(*data),
 308                              I2C_MUX_ARBITRATOR,
 309                              pca9541_select_chan, pca9541_release_chan);
 310         if (!muxc)
 311                 return -ENOMEM;
 312
 313         data = i2c_mux_priv(muxc);
 314         data->client = client;
 315
 316         i2c_set_clientdata(client, muxc);
 317
 318         ret = i2c_mux_add_adapter(muxc, 0, 0, 0);
 319         if (ret)
 320                 return ret;
 321
 322         dev_info(&client->dev, "registered master selector for I2C %s\n",
 323                  client->name);
 324
 325         return 0;
 326 }
 327
 328 static int pca9541_remove(struct i2c_client *client)
 329 {
 330         struct i2c_mux_core *muxc = i2c_get_clientdata(client);
 331
 332         i2c_mux_del_adapters(muxc);
 333         return 0;
 334 }
 335
 336 static struct i2c_driver pca9541_driver = {
 337         .driver = {
 338                    .name = "pca9541",
 339                    .of_match_table = of_match_ptr(pca9541_of_match),
 340                    },
 341         .probe = pca9541_probe,
 342         .remove = pca9541_remove,
 343         .id_table = pca9541_id,
 344 };
 345
 346 module_i2c_driver(pca9541_driver);
 347
 348 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
 349 MODULE_DESCRIPTION("PCA9541 I2C master selector driver");
 350 MODULE_LICENSE("GPL v2");