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/acpi.h> 39 #include <linux/device.h> 40 #include <linux/gpio/consumer.h> 41 #include <linux/i2c.h> 42 #include <linux/i2c-mux.h> 43 #include <linux/i2c/pca954x.h> 44 #include <linux/module.h> 45 #include <linux/of.h> 46 #include <linux/of_device.h> 47 #include <linux/pm.h> 48 #include <linux/slab.h> 49 50 #define PCA954X_MAX_NCHANS 8 51 52 enum pca_type { 53 pca_9540, 54 pca_9542, 55 pca_9543, 56 pca_9544, 57 pca_9545, 58 pca_9546, 59 pca_9547, 60 pca_9548, 61 }; 62 63 struct chip_desc { 64 u8 nchans; 65 u8 enable; /* used for muxes only */ 66 enum muxtype { 67 pca954x_ismux = 0, 68 pca954x_isswi 69 } muxtype; 70 }; 71 72 struct pca954x { 73 const struct chip_desc *chip; 74 75 u8 last_chan; /* last register value */ 76 u8 deselect; 77 struct i2c_client *client; 78 }; 79 80 /* Provide specs for the PCA954x types we know about */ 81 static const struct chip_desc chips[] = { 82 [pca_9540] = { 83 .nchans = 2, 84 .enable = 0x4, 85 .muxtype = pca954x_ismux, 86 }, 87 [pca_9543] = { 88 .nchans = 2, 89 .muxtype = pca954x_isswi, 90 }, 91 [pca_9544] = { 92 .nchans = 4, 93 .enable = 0x4, 94 .muxtype = pca954x_ismux, 95 }, 96 [pca_9545] = { 97 .nchans = 4, 98 .muxtype = pca954x_isswi, 99 }, 100 [pca_9547] = { 101 .nchans = 8, 102 .enable = 0x8, 103 .muxtype = pca954x_ismux, 104 }, 105 [pca_9548] = { 106 .nchans = 8, 107 .muxtype = pca954x_isswi, 108 }, 109 }; 110 111 static const struct i2c_device_id pca954x_id[] = { 112 { "pca9540", pca_9540 }, 113 { "pca9542", pca_9540 }, 114 { "pca9543", pca_9543 }, 115 { "pca9544", pca_9544 }, 116 { "pca9545", pca_9545 }, 117 { "pca9546", pca_9545 }, 118 { "pca9547", pca_9547 }, 119 { "pca9548", pca_9548 }, 120 { } 121 }; 122 MODULE_DEVICE_TABLE(i2c, pca954x_id); 123 124 #ifdef CONFIG_ACPI 125 static const struct acpi_device_id pca954x_acpi_ids[] = { 126 { .id = "PCA9540", .driver_data = pca_9540 }, 127 { .id = "PCA9542", .driver_data = pca_9540 }, 128 { .id = "PCA9543", .driver_data = pca_9543 }, 129 { .id = "PCA9544", .driver_data = pca_9544 }, 130 { .id = "PCA9545", .driver_data = pca_9545 }, 131 { .id = "PCA9546", .driver_data = pca_9545 }, 132 { .id = "PCA9547", .driver_data = pca_9547 }, 133 { .id = "PCA9548", .driver_data = pca_9548 }, 134 { } 135 }; 136 MODULE_DEVICE_TABLE(acpi, pca954x_acpi_ids); 137 #endif 138 139 #ifdef CONFIG_OF 140 static const struct of_device_id pca954x_of_match[] = { 141 { .compatible = "nxp,pca9540", .data = &chips[pca_9540] }, 142 { .compatible = "nxp,pca9542", .data = &chips[pca_9542] }, 143 { .compatible = "nxp,pca9543", .data = &chips[pca_9543] }, 144 { .compatible = "nxp,pca9544", .data = &chips[pca_9544] }, 145 { .compatible = "nxp,pca9545", .data = &chips[pca_9545] }, 146 { .compatible = "nxp,pca9546", .data = &chips[pca_9546] }, 147 { .compatible = "nxp,pca9547", .data = &chips[pca_9547] }, 148 { .compatible = "nxp,pca9548", .data = &chips[pca_9548] }, 149 {} 150 }; 151 #endif 152 153 /* Write to mux register. Don't use i2c_transfer()/i2c_smbus_xfer() 154 for this as they will try to lock adapter a second time */ 155 static int pca954x_reg_write(struct i2c_adapter *adap, 156 struct i2c_client *client, u8 val) 157 { 158 int ret = -ENODEV; 159 160 if (adap->algo->master_xfer) { 161 struct i2c_msg msg; 162 char buf[1]; 163 164 msg.addr = client->addr; 165 msg.flags = 0; 166 msg.len = 1; 167 buf[0] = val; 168 msg.buf = buf; 169 ret = __i2c_transfer(adap, &msg, 1); 170 } else { 171 union i2c_smbus_data data; 172 ret = adap->algo->smbus_xfer(adap, client->addr, 173 client->flags, 174 I2C_SMBUS_WRITE, 175 val, I2C_SMBUS_BYTE, &data); 176 } 177 178 return ret; 179 } 180 181 static int pca954x_select_chan(struct i2c_mux_core *muxc, u32 chan) 182 { 183 struct pca954x *data = i2c_mux_priv(muxc); 184 struct i2c_client *client = data->client; 185 const struct chip_desc *chip = data->chip; 186 u8 regval; 187 int ret = 0; 188 189 /* we make switches look like muxes, not sure how to be smarter */ 190 if (chip->muxtype == pca954x_ismux) 191 regval = chan | chip->enable; 192 else 193 regval = 1 << chan; 194 195 /* Only select the channel if its different from the last channel */ 196 if (data->last_chan != regval) { 197 ret = pca954x_reg_write(muxc->parent, client, regval); 198 data->last_chan = ret ? 0 : regval; 199 } 200 201 return ret; 202 } 203 204 static int pca954x_deselect_mux(struct i2c_mux_core *muxc, u32 chan) 205 { 206 struct pca954x *data = i2c_mux_priv(muxc); 207 struct i2c_client *client = data->client; 208 209 if (!(data->deselect & (1 << chan))) 210 return 0; 211 212 /* Deselect active channel */ 213 data->last_chan = 0; 214 return pca954x_reg_write(muxc->parent, client, data->last_chan); 215 } 216 217 /* 218 * I2C init/probing/exit functions 219 */ 220 static int pca954x_probe(struct i2c_client *client, 221 const struct i2c_device_id *id) 222 { 223 struct i2c_adapter *adap = to_i2c_adapter(client->dev.parent); 224 struct pca954x_platform_data *pdata = dev_get_platdata(&client->dev); 225 struct device_node *of_node = client->dev.of_node; 226 bool idle_disconnect_dt; 227 struct gpio_desc *gpio; 228 int num, force, class; 229 struct i2c_mux_core *muxc; 230 struct pca954x *data; 231 const struct of_device_id *match; 232 int ret; 233 234 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_BYTE)) 235 return -ENODEV; 236 237 muxc = i2c_mux_alloc(adap, &client->dev, 238 PCA954X_MAX_NCHANS, sizeof(*data), 0, 239 pca954x_select_chan, pca954x_deselect_mux); 240 if (!muxc) 241 return -ENOMEM; 242 data = i2c_mux_priv(muxc); 243 244 i2c_set_clientdata(client, muxc); 245 data->client = client; 246 247 /* Get the mux out of reset if a reset GPIO is specified. */ 248 gpio = devm_gpiod_get_optional(&client->dev, "reset", GPIOD_OUT_LOW); 249 if (IS_ERR(gpio)) 250 return PTR_ERR(gpio); 251 252 /* Write the mux register at addr to verify 253 * that the mux is in fact present. This also 254 * initializes the mux to disconnected state. 255 */ 256 if (i2c_smbus_write_byte(client, 0) < 0) { 257 dev_warn(&client->dev, "probe failed\n"); 258 return -ENODEV; 259 } 260 261 match = of_match_device(of_match_ptr(pca954x_of_match), &client->dev); 262 if (match) 263 data->chip = of_device_get_match_data(&client->dev); 264 else if (id) 265 data->chip = &chips[id->driver_data]; 266 else { 267 const struct acpi_device_id *acpi_id; 268 269 acpi_id = acpi_match_device(ACPI_PTR(pca954x_acpi_ids), 270 &client->dev); 271 if (!acpi_id) 272 return -ENODEV; 273 data->chip = &chips[acpi_id->driver_data]; 274 } 275 276 data->last_chan = 0; /* force the first selection */ 277 278 idle_disconnect_dt = of_node && 279 of_property_read_bool(of_node, "i2c-mux-idle-disconnect"); 280 281 /* Now create an adapter for each channel */ 282 for (num = 0; num < data->chip->nchans; num++) { 283 bool idle_disconnect_pd = false; 284 285 force = 0; /* dynamic adap number */ 286 class = 0; /* no class by default */ 287 if (pdata) { 288 if (num < pdata->num_modes) { 289 /* force static number */ 290 force = pdata->modes[num].adap_id; 291 class = pdata->modes[num].class; 292 } else 293 /* discard unconfigured channels */ 294 break; 295 idle_disconnect_pd = pdata->modes[num].deselect_on_exit; 296 } 297 data->deselect |= (idle_disconnect_pd || 298 idle_disconnect_dt) << num; 299 300 ret = i2c_mux_add_adapter(muxc, force, num, class); 301 302 if (ret) { 303 dev_err(&client->dev, 304 "failed to register multiplexed adapter" 305 " %d as bus %d\n", num, force); 306 goto virt_reg_failed; 307 } 308 } 309 310 dev_info(&client->dev, 311 "registered %d multiplexed busses for I2C %s %s\n", 312 num, data->chip->muxtype == pca954x_ismux 313 ? "mux" : "switch", client->name); 314 315 return 0; 316 317 virt_reg_failed: 318 i2c_mux_del_adapters(muxc); 319 return ret; 320 } 321 322 static int pca954x_remove(struct i2c_client *client) 323 { 324 struct i2c_mux_core *muxc = i2c_get_clientdata(client); 325 326 i2c_mux_del_adapters(muxc); 327 return 0; 328 } 329 330 #ifdef CONFIG_PM_SLEEP 331 static int pca954x_resume(struct device *dev) 332 { 333 struct i2c_client *client = to_i2c_client(dev); 334 struct i2c_mux_core *muxc = i2c_get_clientdata(client); 335 struct pca954x *data = i2c_mux_priv(muxc); 336 337 data->last_chan = 0; 338 return i2c_smbus_write_byte(client, 0); 339 } 340 #endif 341 342 static SIMPLE_DEV_PM_OPS(pca954x_pm, NULL, pca954x_resume); 343 344 static struct i2c_driver pca954x_driver = { 345 .driver = { 346 .name = "pca954x", 347 .pm = &pca954x_pm, 348 .of_match_table = of_match_ptr(pca954x_of_match), 349 .acpi_match_table = ACPI_PTR(pca954x_acpi_ids), 350 }, 351 .probe = pca954x_probe, 352 .remove = pca954x_remove, 353 .id_table = pca954x_id, 354 }; 355 356 module_i2c_driver(pca954x_driver); 357 358 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); 359 MODULE_DESCRIPTION("PCA954x I2C mux/switch driver"); 360 MODULE_LICENSE("GPL v2"); 361