drivers/i2c/muxes/pca954x.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015 - 2016 Xilinx, Inc.
   4  * Copyright (C) 2017 National Instruments Corp
   5  * Written by Michal Simek
   6  */
   7
   8 #include <common.h>
   9 #include <dm.h>
  10 #include <errno.h>
  11 #include <i2c.h>
  12
  13 #include <asm-generic/gpio.h>
  14
  15 DECLARE_GLOBAL_DATA_PTR;
  16
  17 enum pca_type {
  18         PCA9543,
  19         PCA9544,
  20         PCA9547,
  21         PCA9548,
  22         PCA9646
  23 };
  24
  25 struct chip_desc {
  26         u8 enable; /* Enable mask in ctl register (used for muxes only) */
  27         enum muxtype {
  28                 pca954x_ismux = 0,
  29                 pca954x_isswi,
  30         } muxtype;
  31         u32 width;
  32 };
  33
  34 struct pca954x_priv {
  35         u32 addr; /* I2C mux address */
  36         u32 width; /* I2C mux width - number of busses */
  37         struct gpio_desc gpio_mux_reset;
  38 };
  39
  40 static const struct chip_desc chips[] = {
  41         [PCA9543] = {
  42                 .muxtype = pca954x_isswi,
  43                 .width = 2,
  44         },
  45         [PCA9544] = {
  46                 .enable = 0x4,
  47                 .muxtype = pca954x_ismux,
  48                 .width = 4,
  49         },
  50         [PCA9547] = {
  51                 .enable = 0x8,
  52                 .muxtype = pca954x_ismux,
  53                 .width = 8,
  54         },
  55         [PCA9548] = {
  56                 .muxtype = pca954x_isswi,
  57                 .width = 8,
  58         },
  59         [PCA9646] = {
  60                 .muxtype = pca954x_isswi,
  61                 .width = 4,
  62         },
  63 };
  64
  65 static int pca954x_deselect(struct udevice *mux, struct udevice *bus,
  66                             uint channel)
  67 {
  68         struct pca954x_priv *priv = dev_get_priv(mux);
  69         uchar byte = 0;
  70
  71         return dm_i2c_write(mux, priv->addr, &byte, 1);
  72 }
  73
  74 static int pca954x_select(struct udevice *mux, struct udevice *bus,
  75                           uint channel)
  76 {
  77         struct pca954x_priv *priv = dev_get_priv(mux);
  78         const struct chip_desc *chip = &chips[dev_get_driver_data(mux)];
  79         uchar byte;
  80
  81         if (chip->muxtype == pca954x_ismux)
  82                 byte = channel | chip->enable;
  83         else
  84                 byte = 1 << channel;
  85
  86         return dm_i2c_write(mux, priv->addr, &byte, 1);
  87 }
  88
  89 static const struct i2c_mux_ops pca954x_ops = {
  90         .select = pca954x_select,
  91         .deselect = pca954x_deselect,
  92 };
  93
  94 static const struct udevice_id pca954x_ids[] = {
  95         { .compatible = "nxp,pca9543", .data = PCA9543 },
  96         { .compatible = "nxp,pca9544", .data = PCA9544 },
  97         { .compatible = "nxp,pca9547", .data = PCA9547 },
  98         { .compatible = "nxp,pca9548", .data = PCA9548 },
  99         { .compatible = "nxp,pca9646", .data = PCA9646 },
 100         { }
 101 };
 102
 103 static int pca954x_ofdata_to_platdata(struct udevice *dev)
 104 {
 105         struct pca954x_priv *priv = dev_get_priv(dev);
 106         const struct chip_desc *chip = &chips[dev_get_driver_data(dev)];
 107
 108         priv->addr = dev_read_u32_default(dev, "reg", 0);
 109         if (!priv->addr) {
 110                 debug("MUX not found\n");
 111                 return -ENODEV;
 112         }
 113         priv->width = chip->width;
 114
 115         if (!priv->width) {
 116                 debug("No I2C MUX width specified\n");
 117                 return -EINVAL;
 118         }
 119
 120         debug("Device %s at 0x%x with width %d\n",
 121               dev->name, priv->addr, priv->width);
 122
 123         return 0;
 124 }
 125
 126 static int pca954x_probe(struct udevice *dev)
 127 {
 128         if (IS_ENABLED(CONFIG_DM_GPIO)) {
 129                 struct pca954x_priv *priv = dev_get_priv(dev);
 130                 int err;
 131
 132                 err = gpio_request_by_name(dev, "reset-gpios", 0,
 133                                 &priv->gpio_mux_reset, GPIOD_IS_OUT);
 134
 135                 /* it's optional so only bail if we get a real error */
 136                 if (err && (err != -ENOENT))
 137                         return err;
 138
 139                 /* dm will take care of polarity */
 140                 if (dm_gpio_is_valid(&priv->gpio_mux_reset))
 141                         dm_gpio_set_value(&priv->gpio_mux_reset, 0);
 142         }
 143
 144         return 0;
 145 }
 146
 147 static int pca954x_remove(struct udevice *dev)
 148 {
 149         if (IS_ENABLED(CONFIG_DM_GPIO)) {
 150                 struct pca954x_priv *priv = dev_get_priv(dev);
 151
 152                 if (dm_gpio_is_valid(&priv->gpio_mux_reset))
 153                         dm_gpio_free(dev, &priv->gpio_mux_reset);
 154         }
 155
 156         return 0;
 157 }
 158
 159 U_BOOT_DRIVER(pca954x) = {
 160         .name = "pca954x",
 161         .id = UCLASS_I2C_MUX,
 162         .of_match = pca954x_ids,
 163         .probe = pca954x_probe,
 164         .remove = pca954x_remove,
 165         .ops = &pca954x_ops,
 166         .ofdata_to_platdata = pca954x_ofdata_to_platdata,
 167         .priv_auto_alloc_size = sizeof(struct pca954x_priv),
 168 };