drivers/mux/adg792a.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Multiplexer driver for Analog Devices ADG792A/G Triple 4:1 mux
0004  *
0005  * Copyright (C) 2017 Axentia Technologies AB
0006  *
0007  * Author: Peter Rosin <peda@axentia.se>
0008  */
0009
0010 #include <linux/err.h>
0011 #include <linux/i2c.h>
0012 #include <linux/module.h>
0013 #include <linux/mux/driver.h>
0014 #include <linux/property.h>
0015
0016 #define ADG792A_LDSW        BIT(0)
0017 #define ADG792A_RESETB      BIT(1)
0018 #define ADG792A_DISABLE(mux)    (0x50 | (mux))
0019 #define ADG792A_DISABLE_ALL (0x5f)
0020 #define ADG792A_MUX(mux, state) (0xc0 | (((mux) + 1) << 2) | (state))
0021 #define ADG792A_MUX_ALL(state)  (0xc0 | (state))
0022
0023 static int adg792a_write_cmd(struct i2c_client *i2c, u8 cmd, int reset)
0024 {
0025     u8 data = ADG792A_RESETB | ADG792A_LDSW;
0026
0027     /* ADG792A_RESETB is active low, the chip resets when it is zero. */
0028     if (reset)
0029         data &= ~ADG792A_RESETB;
0030
0031     return i2c_smbus_write_byte_data(i2c, cmd, data);
0032 }
0033
0034 static int adg792a_set(struct mux_control *mux, int state)
0035 {
0036     struct i2c_client *i2c = to_i2c_client(mux->chip->dev.parent);
0037     u8 cmd;
0038
0039     if (mux->chip->controllers == 1) {
0040         /* parallel mux controller operation */
0041         if (state == MUX_IDLE_DISCONNECT)
0042             cmd = ADG792A_DISABLE_ALL;
0043         else
0044             cmd = ADG792A_MUX_ALL(state);
0045     } else {
0046         unsigned int controller = mux_control_get_index(mux);
0047
0048         if (state == MUX_IDLE_DISCONNECT)
0049             cmd = ADG792A_DISABLE(controller);
0050         else
0051             cmd = ADG792A_MUX(controller, state);
0052     }
0053
0054     return adg792a_write_cmd(i2c, cmd, 0);
0055 }
0056
0057 static const struct mux_control_ops adg792a_ops = {
0058     .set = adg792a_set,
0059 };
0060
0061 static int adg792a_probe(struct i2c_client *i2c)
0062 {
0063     struct device *dev = &i2c->dev;
0064     struct mux_chip *mux_chip;
0065     s32 idle_state[3];
0066     u32 cells;
0067     int ret;
0068     int i;
0069
0070     if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
0071         return -ENODEV;
0072
0073     ret = device_property_read_u32(dev, "#mux-control-cells", &cells);
0074     if (ret < 0)
0075         return ret;
0076     if (cells >= 2)
0077         return -EINVAL;
0078
0079     mux_chip = devm_mux_chip_alloc(dev, cells ? 3 : 1, 0);
0080     if (IS_ERR(mux_chip))
0081         return PTR_ERR(mux_chip);
0082
0083     mux_chip->ops = &adg792a_ops;
0084
0085     ret = adg792a_write_cmd(i2c, ADG792A_DISABLE_ALL, 1);
0086     if (ret < 0)
0087         return ret;
0088
0089     ret = device_property_read_u32_array(dev, "idle-state",
0090                          (u32 *)idle_state,
0091                          mux_chip->controllers);
0092     if (ret < 0) {
0093         idle_state[0] = MUX_IDLE_AS_IS;
0094         idle_state[1] = MUX_IDLE_AS_IS;
0095         idle_state[2] = MUX_IDLE_AS_IS;
0096     }
0097
0098     for (i = 0; i < mux_chip->controllers; ++i) {
0099         struct mux_control *mux = &mux_chip->mux[i];
0100
0101         mux->states = 4;
0102
0103         switch (idle_state[i]) {
0104         case MUX_IDLE_DISCONNECT:
0105         case MUX_IDLE_AS_IS:
0106         case 0 ... 4:
0107             mux->idle_state = idle_state[i];
0108             break;
0109         default:
0110             dev_err(dev, "invalid idle-state %d\n", idle_state[i]);
0111             return -EINVAL;
0112         }
0113     }
0114
0115     ret = devm_mux_chip_register(dev, mux_chip);
0116     if (ret < 0)
0117         return ret;
0118
0119     if (cells)
0120         dev_info(dev, "3x single pole quadruple throw muxes registered\n");
0121     else
0122         dev_info(dev, "triple pole quadruple throw mux registered\n");
0123
0124     return 0;
0125 }
0126
0127 static const struct i2c_device_id adg792a_id[] = {
0128     { .name = "adg792a", },
0129     { .name = "adg792g", },
0130     { }
0131 };
0132 MODULE_DEVICE_TABLE(i2c, adg792a_id);
0133
0134 static const struct of_device_id adg792a_of_match[] = {
0135     { .compatible = "adi,adg792a", },
0136     { .compatible = "adi,adg792g", },
0137     { }
0138 };
0139 MODULE_DEVICE_TABLE(of, adg792a_of_match);
0140
0141 static struct i2c_driver adg792a_driver = {
0142     .driver     = {
0143         .name       = "adg792a",
0144         .of_match_table = of_match_ptr(adg792a_of_match),
0145     },
0146     .probe_new  = adg792a_probe,
0147     .id_table   = adg792a_id,
0148 };
0149 module_i2c_driver(adg792a_driver);
0150
0151 MODULE_DESCRIPTION("Analog Devices ADG792A/G Triple 4:1 mux driver");
0152 MODULE_AUTHOR("Peter Rosin <peda@axentia.se>");
0153 MODULE_LICENSE("GPL v2");