1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /*
3  * Mellanox i2c mux driver
4  *
5  * Copyright (C) 2016-2020 Mellanox Technologies
6  */
7 
8 #include <linux/device.h>
9 #include <linux/i2c.h>
10 #include <linux/i2c-mux.h>
11 #include <linux/io.h>
12 #include <linux/init.h>
13 #include <linux/module.h>
14 #include <linux/platform_data/mlxcpld.h>
15 #include <linux/platform_device.h>
16 #include <linux/slab.h>
17 
18 /* mlxcpld_mux - mux control structure:
19  * @last_val - last selected register value or -1 if mux deselected
20  * @client - I2C device client
21  * @pdata: platform data
22  */
23 struct mlxcpld_mux {
24 	int last_val;
25 	struct i2c_client *client;
26 	struct mlxcpld_mux_plat_data pdata;
27 };
28 
29 /* MUX logic description.
30  * Driver can support different mux control logic, according to CPLD
31  * implementation.
32  *
33  * Connectivity schema.
34  *
35  * i2c-mlxcpld                                 Digital               Analog
36  * driver
37  * *--------*                                 * -> mux1 (virt bus2) -> mux -> |
38  * | I2CLPC | i2c physical                    * -> mux2 (virt bus3) -> mux -> |
39  * | bridge | bus 1                 *---------*                               |
40  * | logic  |---------------------> * mux reg *                               |
41  * | in CPLD|                       *---------*                               |
42  * *--------*   i2c-mux-mlxpcld          ^    * -> muxn (virt busn) -> mux -> |
43  *     |        driver                   |                                    |
44  *     |        *---------------*        |                              Devices
45  *     |        * CPLD (i2c bus)* select |
46  *     |        * registers for *--------*
47  *     |        * mux selection * deselect
48  *     |        *---------------*
49  *     |                 |
50  * <-------->     <----------->
51  * i2c cntrl      Board cntrl reg
52  * reg space      space (mux select,
53  *                IO, LED, WD, info)
54  *
55  */
56 
57 /* Write to mux register. Don't use i2c_transfer() and i2c_smbus_xfer()
58  * for this as they will try to lock adapter a second time.
59  */
60 static int mlxcpld_mux_reg_write(struct i2c_adapter *adap,
61 				 struct mlxcpld_mux *mux, u32 val)
62 {
63 	struct i2c_client *client = mux->client;
64 	union i2c_smbus_data data;
65 	struct i2c_msg msg;
66 	u8 buf[3];
67 
68 	switch (mux->pdata.reg_size) {
69 	case 1:
70 		data.byte = val;
71 		return __i2c_smbus_xfer(adap, client->addr, client->flags,
72 					I2C_SMBUS_WRITE, mux->pdata.sel_reg_addr,
73 					I2C_SMBUS_BYTE_DATA, &data);
74 	case 2:
75 		buf[0] = mux->pdata.sel_reg_addr >> 8;
76 		buf[1] = mux->pdata.sel_reg_addr;
77 		buf[2] = val;
78 		msg.addr = client->addr;
79 		msg.buf = buf;
80 		msg.len = mux->pdata.reg_size + 1;
81 		msg.flags = 0;
82 		return __i2c_transfer(adap, &msg, 1);
83 	default:
84 		return -EINVAL;
85 	}
86 }
87 
88 static int mlxcpld_mux_select_chan(struct i2c_mux_core *muxc, u32 chan)
89 {
90 	struct mlxcpld_mux *mux = i2c_mux_priv(muxc);
91 	u32 regval = chan;
92 	int err = 0;
93 
94 	if (mux->pdata.reg_size == 1)
95 		regval += 1;
96 
97 	/* Only select the channel if its different from the last channel */
98 	if (mux->last_val != regval) {
99 		err = mlxcpld_mux_reg_write(muxc->parent, mux, regval);
100 		mux->last_val = err < 0 ? -1 : regval;
101 	}
102 
103 	return err;
104 }
105 
106 static int mlxcpld_mux_deselect(struct i2c_mux_core *muxc, u32 chan)
107 {
108 	struct mlxcpld_mux *mux = i2c_mux_priv(muxc);
109 
110 	/* Deselect active channel */
111 	mux->last_val = -1;
112 
113 	return mlxcpld_mux_reg_write(muxc->parent, mux, 0);
114 }
115 
116 /* Probe/reomove functions */
117 static int mlxcpld_mux_probe(struct platform_device *pdev)
118 {
119 	struct mlxcpld_mux_plat_data *pdata = dev_get_platdata(&pdev->dev);
120 	struct i2c_client *client = to_i2c_client(pdev->dev.parent);
121 	struct i2c_mux_core *muxc;
122 	struct mlxcpld_mux *data;
123 	int num, err;
124 	u32 func;
125 
126 	if (!pdata)
127 		return -EINVAL;
128 
129 	switch (pdata->reg_size) {
130 	case 1:
131 		func = I2C_FUNC_SMBUS_WRITE_BYTE_DATA;
132 		break;
133 	case 2:
134 		func = I2C_FUNC_I2C;
135 		break;
136 	default:
137 		return -EINVAL;
138 	}
139 
140 	if (!i2c_check_functionality(client->adapter, func))
141 		return -ENODEV;
142 
143 	muxc = i2c_mux_alloc(client->adapter, &pdev->dev, pdata->num_adaps,
144 			     sizeof(*data), 0, mlxcpld_mux_select_chan,
145 			     mlxcpld_mux_deselect);
146 	if (!muxc)
147 		return -ENOMEM;
148 
149 	platform_set_drvdata(pdev, muxc);
150 	data = i2c_mux_priv(muxc);
151 	data->client = client;
152 	memcpy(&data->pdata, pdata, sizeof(*pdata));
153 	data->last_val = -1; /* force the first selection */
154 
155 	/* Create an adapter for each channel. */
156 	for (num = 0; num < pdata->num_adaps; num++) {
157 		err = i2c_mux_add_adapter(muxc, 0, pdata->chan_ids[num], 0);
158 		if (err)
159 			goto virt_reg_failed;
160 	}
161 
162 	/* Notify caller when all channels' adapters are created. */
163 	if (pdata->completion_notify)
164 		pdata->completion_notify(pdata->handle, muxc->parent, muxc->adapter);
165 
166 	return 0;
167 
168 virt_reg_failed:
169 	i2c_mux_del_adapters(muxc);
170 	return err;
171 }
172 
173 static void mlxcpld_mux_remove(struct platform_device *pdev)
174 {
175 	struct i2c_mux_core *muxc = platform_get_drvdata(pdev);
176 
177 	i2c_mux_del_adapters(muxc);
178 }
179 
180 static struct platform_driver mlxcpld_mux_driver = {
181 	.driver = {
182 		.name = "i2c-mux-mlxcpld",
183 	},
184 	.probe = mlxcpld_mux_probe,
185 	.remove_new = mlxcpld_mux_remove,
186 };
187 
188 module_platform_driver(mlxcpld_mux_driver);
189 
190 MODULE_AUTHOR("Michael Shych (michaels@mellanox.com)");
191 MODULE_DESCRIPTION("Mellanox I2C-CPLD-MUX driver");
192 MODULE_LICENSE("Dual BSD/GPL");
193 MODULE_ALIAS("platform:i2c-mux-mlxcpld");
194