1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Linear Technology LTC4306 and LTC4305 I2C multiplexer/switch 4 * 5 * Copyright (C) 2017 Analog Devices Inc. 6 * 7 * Based on: i2c-mux-pca954x.c 8 * 9 * Datasheet: http://cds.linear.com/docs/en/datasheet/4306.pdf 10 */ 11 12 #include <linux/gpio/consumer.h> 13 #include <linux/gpio/driver.h> 14 #include <linux/i2c-mux.h> 15 #include <linux/i2c.h> 16 #include <linux/module.h> 17 #include <linux/of.h> 18 #include <linux/of_device.h> 19 #include <linux/property.h> 20 #include <linux/regmap.h> 21 #include <linux/slab.h> 22 23 #define LTC4305_MAX_NCHANS 2 24 #define LTC4306_MAX_NCHANS 4 25 26 #define LTC_REG_STATUS 0x0 27 #define LTC_REG_CONFIG 0x1 28 #define LTC_REG_MODE 0x2 29 #define LTC_REG_SWITCH 0x3 30 31 #define LTC_DOWNSTREAM_ACCL_EN BIT(6) 32 #define LTC_UPSTREAM_ACCL_EN BIT(7) 33 34 #define LTC_GPIO_ALL_INPUT 0xC0 35 #define LTC_SWITCH_MASK 0xF0 36 37 enum ltc_type { 38 ltc_4305, 39 ltc_4306, 40 }; 41 42 struct chip_desc { 43 u8 nchans; 44 u8 num_gpios; 45 }; 46 47 struct ltc4306 { 48 struct regmap *regmap; 49 struct gpio_chip gpiochip; 50 const struct chip_desc *chip; 51 }; 52 53 static const struct chip_desc chips[] = { 54 [ltc_4305] = { 55 .nchans = LTC4305_MAX_NCHANS, 56 }, 57 [ltc_4306] = { 58 .nchans = LTC4306_MAX_NCHANS, 59 .num_gpios = 2, 60 }, 61 }; 62 63 static bool ltc4306_is_volatile_reg(struct device *dev, unsigned int reg) 64 { 65 return (reg == LTC_REG_CONFIG) ? true : false; 66 } 67 68 static const struct regmap_config ltc4306_regmap_config = { 69 .reg_bits = 8, 70 .val_bits = 8, 71 .max_register = LTC_REG_SWITCH, 72 .volatile_reg = ltc4306_is_volatile_reg, 73 .cache_type = REGCACHE_FLAT, 74 }; 75 76 static int ltc4306_gpio_get(struct gpio_chip *chip, unsigned int offset) 77 { 78 struct ltc4306 *data = gpiochip_get_data(chip); 79 unsigned int val; 80 int ret; 81 82 ret = regmap_read(data->regmap, LTC_REG_CONFIG, &val); 83 if (ret < 0) 84 return ret; 85 86 return !!(val & BIT(1 - offset)); 87 } 88 89 static void ltc4306_gpio_set(struct gpio_chip *chip, unsigned int offset, 90 int value) 91 { 92 struct ltc4306 *data = gpiochip_get_data(chip); 93 94 regmap_update_bits(data->regmap, LTC_REG_CONFIG, BIT(5 - offset), 95 value ? BIT(5 - offset) : 0); 96 } 97 98 static int ltc4306_gpio_get_direction(struct gpio_chip *chip, 99 unsigned int offset) 100 { 101 struct ltc4306 *data = gpiochip_get_data(chip); 102 unsigned int val; 103 int ret; 104 105 ret = regmap_read(data->regmap, LTC_REG_MODE, &val); 106 if (ret < 0) 107 return ret; 108 109 return !!(val & BIT(7 - offset)); 110 } 111 112 static int ltc4306_gpio_direction_input(struct gpio_chip *chip, 113 unsigned int offset) 114 { 115 struct ltc4306 *data = gpiochip_get_data(chip); 116 117 return regmap_update_bits(data->regmap, LTC_REG_MODE, 118 BIT(7 - offset), BIT(7 - offset)); 119 } 120 121 static int ltc4306_gpio_direction_output(struct gpio_chip *chip, 122 unsigned int offset, int value) 123 { 124 struct ltc4306 *data = gpiochip_get_data(chip); 125 126 ltc4306_gpio_set(chip, offset, value); 127 return regmap_update_bits(data->regmap, LTC_REG_MODE, 128 BIT(7 - offset), 0); 129 } 130 131 static int ltc4306_gpio_set_config(struct gpio_chip *chip, 132 unsigned int offset, unsigned long config) 133 { 134 struct ltc4306 *data = gpiochip_get_data(chip); 135 unsigned int val; 136 137 switch (pinconf_to_config_param(config)) { 138 case PIN_CONFIG_DRIVE_OPEN_DRAIN: 139 val = 0; 140 break; 141 case PIN_CONFIG_DRIVE_PUSH_PULL: 142 val = BIT(4 - offset); 143 break; 144 default: 145 return -ENOTSUPP; 146 } 147 148 return regmap_update_bits(data->regmap, LTC_REG_MODE, 149 BIT(4 - offset), val); 150 } 151 152 static int ltc4306_gpio_init(struct ltc4306 *data) 153 { 154 struct device *dev = regmap_get_device(data->regmap); 155 156 if (!data->chip->num_gpios) 157 return 0; 158 159 data->gpiochip.label = dev_name(dev); 160 data->gpiochip.base = -1; 161 data->gpiochip.ngpio = data->chip->num_gpios; 162 data->gpiochip.parent = dev; 163 data->gpiochip.can_sleep = true; 164 data->gpiochip.get_direction = ltc4306_gpio_get_direction; 165 data->gpiochip.direction_input = ltc4306_gpio_direction_input; 166 data->gpiochip.direction_output = ltc4306_gpio_direction_output; 167 data->gpiochip.get = ltc4306_gpio_get; 168 data->gpiochip.set = ltc4306_gpio_set; 169 data->gpiochip.set_config = ltc4306_gpio_set_config; 170 data->gpiochip.owner = THIS_MODULE; 171 172 /* gpiolib assumes all GPIOs default input */ 173 regmap_write(data->regmap, LTC_REG_MODE, LTC_GPIO_ALL_INPUT); 174 175 return devm_gpiochip_add_data(dev, &data->gpiochip, data); 176 } 177 178 static int ltc4306_select_mux(struct i2c_mux_core *muxc, u32 chan) 179 { 180 struct ltc4306 *data = i2c_mux_priv(muxc); 181 182 return regmap_update_bits(data->regmap, LTC_REG_SWITCH, 183 LTC_SWITCH_MASK, BIT(7 - chan)); 184 } 185 186 static int ltc4306_deselect_mux(struct i2c_mux_core *muxc, u32 chan) 187 { 188 struct ltc4306 *data = i2c_mux_priv(muxc); 189 190 return regmap_update_bits(data->regmap, LTC_REG_SWITCH, 191 LTC_SWITCH_MASK, 0); 192 } 193 194 static const struct i2c_device_id ltc4306_id[] = { 195 { "ltc4305", ltc_4305 }, 196 { "ltc4306", ltc_4306 }, 197 { } 198 }; 199 MODULE_DEVICE_TABLE(i2c, ltc4306_id); 200 201 static const struct of_device_id ltc4306_of_match[] = { 202 { .compatible = "lltc,ltc4305", .data = &chips[ltc_4305] }, 203 { .compatible = "lltc,ltc4306", .data = &chips[ltc_4306] }, 204 { } 205 }; 206 MODULE_DEVICE_TABLE(of, ltc4306_of_match); 207 208 static int ltc4306_probe(struct i2c_client *client) 209 { 210 struct i2c_adapter *adap = client->adapter; 211 const struct chip_desc *chip; 212 struct i2c_mux_core *muxc; 213 struct ltc4306 *data; 214 struct gpio_desc *gpio; 215 bool idle_disc; 216 unsigned int val = 0; 217 int num, ret; 218 219 chip = of_device_get_match_data(&client->dev); 220 221 if (!chip) 222 chip = &chips[i2c_match_id(ltc4306_id, client)->driver_data]; 223 224 idle_disc = device_property_read_bool(&client->dev, 225 "i2c-mux-idle-disconnect"); 226 227 muxc = i2c_mux_alloc(adap, &client->dev, 228 chip->nchans, sizeof(*data), 229 I2C_MUX_LOCKED, ltc4306_select_mux, 230 idle_disc ? ltc4306_deselect_mux : NULL); 231 if (!muxc) 232 return -ENOMEM; 233 data = i2c_mux_priv(muxc); 234 data->chip = chip; 235 236 i2c_set_clientdata(client, muxc); 237 238 data->regmap = devm_regmap_init_i2c(client, <c4306_regmap_config); 239 if (IS_ERR(data->regmap)) { 240 ret = PTR_ERR(data->regmap); 241 dev_err(&client->dev, "Failed to allocate register map: %d\n", 242 ret); 243 return ret; 244 } 245 246 /* Reset and enable the mux if an enable GPIO is specified. */ 247 gpio = devm_gpiod_get_optional(&client->dev, "enable", GPIOD_OUT_LOW); 248 if (IS_ERR(gpio)) 249 return PTR_ERR(gpio); 250 251 if (gpio) { 252 udelay(1); 253 gpiod_set_value(gpio, 1); 254 } 255 256 /* 257 * Write the mux register at addr to verify 258 * that the mux is in fact present. This also 259 * initializes the mux to disconnected state. 260 */ 261 if (regmap_write(data->regmap, LTC_REG_SWITCH, 0) < 0) { 262 dev_warn(&client->dev, "probe failed\n"); 263 return -ENODEV; 264 } 265 266 if (device_property_read_bool(&client->dev, 267 "ltc,downstream-accelerators-enable")) 268 val |= LTC_DOWNSTREAM_ACCL_EN; 269 270 if (device_property_read_bool(&client->dev, 271 "ltc,upstream-accelerators-enable")) 272 val |= LTC_UPSTREAM_ACCL_EN; 273 274 if (regmap_write(data->regmap, LTC_REG_CONFIG, val) < 0) 275 return -ENODEV; 276 277 ret = ltc4306_gpio_init(data); 278 if (ret < 0) 279 return ret; 280 281 /* Now create an adapter for each channel */ 282 for (num = 0; num < chip->nchans; num++) { 283 ret = i2c_mux_add_adapter(muxc, 0, num, 0); 284 if (ret) { 285 i2c_mux_del_adapters(muxc); 286 return ret; 287 } 288 } 289 290 dev_info(&client->dev, 291 "registered %d multiplexed busses for I2C switch %s\n", 292 num, client->name); 293 294 return 0; 295 } 296 297 static void ltc4306_remove(struct i2c_client *client) 298 { 299 struct i2c_mux_core *muxc = i2c_get_clientdata(client); 300 301 i2c_mux_del_adapters(muxc); 302 } 303 304 static struct i2c_driver ltc4306_driver = { 305 .driver = { 306 .name = "ltc4306", 307 .of_match_table = of_match_ptr(ltc4306_of_match), 308 }, 309 .probe_new = ltc4306_probe, 310 .remove = ltc4306_remove, 311 .id_table = ltc4306_id, 312 }; 313 314 module_i2c_driver(ltc4306_driver); 315 316 MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>"); 317 MODULE_DESCRIPTION("Linear Technology LTC4306, LTC4305 I2C mux/switch driver"); 318 MODULE_LICENSE("GPL v2"); 319