1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Maxim MAX96745 MFD driver
4 *
5 * Copyright (C) 2022 Rockchip Electronics Co. Ltd.
6 */
7
8 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/i2c.h>
11 #include <linux/i2c-mux.h>
12 #include <linux/extcon-provider.h>
13 #include <linux/gpio/consumer.h>
14 #include <linux/regmap.h>
15 #include <linux/mfd/core.h>
16 #include <linux/mfd/max96745.h>
17
18 static const struct mfd_cell max96745_devs[] = {
19 {
20 .name = "max96745-pinctrl",
21 .of_compatible = "maxim,max96745-pinctrl",
22 }, {
23 .name = "max96745-bridge",
24 .of_compatible = "maxim,max96745-bridge",
25 },
26 };
27
28 static const unsigned int max96745_cable[] = {
29 EXTCON_JACK_VIDEO_OUT,
30 EXTCON_NONE,
31 };
32
max96745_vid_tx_active(struct max96745 * max96745)33 static bool max96745_vid_tx_active(struct max96745 *max96745)
34 {
35 u32 val;
36
37 if (regmap_read(max96745->regmap, 0x0107, &val))
38 return false;
39
40 if (!FIELD_GET(VID_TX_ACTIVE_A | VID_TX_ACTIVE_B, val))
41 return false;
42
43 return true;
44 }
45
max96745_volatile_reg(struct device * dev,unsigned int reg)46 static bool max96745_volatile_reg(struct device *dev, unsigned int reg)
47 {
48 switch (reg) {
49 case 0x0076:
50 case 0x0086:
51 case 0x0100:
52 case 0x0200 ... 0x02ce:
53 case 0x7000:
54 case 0x7070:
55 case 0x7074:
56 return false;
57 default:
58 return true;
59 }
60 }
61
62 static const struct regmap_config max96745_regmap_config = {
63 .name = "max96745",
64 .reg_bits = 16,
65 .val_bits = 8,
66 .max_register = 0x8000,
67 .volatile_reg = max96745_volatile_reg,
68 .cache_type = REGCACHE_RBTREE,
69 };
70
max96745_select(struct i2c_mux_core * muxc,u32 chan)71 static int max96745_select(struct i2c_mux_core *muxc, u32 chan)
72 {
73 struct max96745 *max96745 = dev_get_drvdata(muxc->dev);
74
75 if (!max96745->idle_disc)
76 return 0;
77
78 if (chan == 1)
79 regmap_update_bits(max96745->regmap, 0x0086, DIS_REM_CC,
80 FIELD_PREP(DIS_REM_CC, 0));
81 else
82 regmap_update_bits(max96745->regmap, 0x0076, DIS_REM_CC,
83 FIELD_PREP(DIS_REM_CC, 0));
84
85 return 0;
86 }
87
max96745_deselect(struct i2c_mux_core * muxc,u32 chan)88 static int max96745_deselect(struct i2c_mux_core *muxc, u32 chan)
89 {
90 struct max96745 *max96745 = dev_get_drvdata(muxc->dev);
91
92 if (!max96745->idle_disc)
93 return 0;
94
95 if (chan == 1)
96 regmap_update_bits(max96745->regmap, 0x0086, DIS_REM_CC,
97 FIELD_PREP(DIS_REM_CC, 1));
98 else
99 regmap_update_bits(max96745->regmap, 0x0076, DIS_REM_CC,
100 FIELD_PREP(DIS_REM_CC, 1));
101
102 return 0;
103 }
104
max96745_power_off(void * data)105 static void max96745_power_off(void *data)
106 {
107 struct max96745 *max96745 = data;
108
109 if (max96745->pwdnb_gpio)
110 gpiod_direction_output(max96745->pwdnb_gpio, 1);
111
112 if (max96745->enable_gpio)
113 gpiod_direction_output(max96745->enable_gpio, 0);
114 }
115
max96745_power_on(struct max96745 * max96745)116 static void max96745_power_on(struct max96745 *max96745)
117 {
118 if (max96745_vid_tx_active(max96745)) {
119 extcon_set_state(max96745->extcon, EXTCON_JACK_VIDEO_OUT, true);
120 return;
121 }
122
123 if (max96745->enable_gpio) {
124 gpiod_direction_output(max96745->enable_gpio, 1);
125 msleep(200);
126 }
127
128 if (max96745->pwdnb_gpio) {
129 gpiod_direction_output(max96745->pwdnb_gpio, 0);
130 msleep(30);
131 }
132
133 /* Set for I2C Fast-mode speed */
134 regmap_write(max96745->regmap, 0x0070, 0x16);
135
136 if (max96745->idle_disc) {
137 regmap_update_bits(max96745->regmap, 0x0076, DIS_REM_CC,
138 FIELD_PREP(DIS_REM_CC, 1));
139 regmap_update_bits(max96745->regmap, 0x0086, DIS_REM_CC,
140 FIELD_PREP(DIS_REM_CC, 1));
141 }
142 }
143
line_fault_monitor_show(struct device * device,struct device_attribute * attr,char * buf)144 static ssize_t line_fault_monitor_show(struct device *device,
145 struct device_attribute *attr,
146 char *buf)
147 {
148 struct max96745 *max96745 = dev_get_drvdata(device);
149 u32 pu_lf, lf, status;
150
151 regmap_read(max96745->regmap, 0x0005, &pu_lf);
152
153 /*
154 * Line-fault status of wire connected to LMN0/1/2/3 pin
155 *
156 * 0b000: Short to battery
157 * 0b001: Short to GND
158 * 0b010: Normal operation
159 * 0b011: Line open
160 * 0b1XX: Line-to-line short
161 */
162 regmap_read(max96745->regmap, 0x0026, &lf);
163
164 if (FIELD_GET(PU_LF0, pu_lf)) {
165 status = (lf & LF_0);
166 return sprintf(buf, "%d\n", status);
167 }
168
169 if (FIELD_GET(PU_LF1, pu_lf)) {
170 status = (lf & LF_1) >> 4;
171 return sprintf(buf, "%d\n", status);
172 }
173
174 regmap_read(max96745->regmap, 0x0027, &lf);
175
176 if (FIELD_GET(PU_LF2, pu_lf)) {
177 status = (lf & LF_2);
178 return sprintf(buf, "%d\n", status);
179 }
180
181 if (FIELD_GET(PU_LF3, pu_lf)) {
182 status = (lf & LF_3) >> 4;
183 return sprintf(buf, "%d\n", status);
184 }
185
186
187 return sprintf(buf, "%d\n", -EINVAL);
188 }
189
190 static DEVICE_ATTR_RO(line_fault_monitor);
191
192 static struct attribute *max96745_attrs[] = {
193 &dev_attr_line_fault_monitor.attr,
194 NULL
195 };
196
197 static const struct attribute_group max96745_attr_group = {
198 .attrs = max96745_attrs,
199 };
200
max96745_sysfs_add(struct max96745 * max96745)201 static int max96745_sysfs_add(struct max96745 *max96745)
202 {
203 struct device *dev = max96745->dev;
204 int ret;
205 u32 ch;
206
207 ret = of_property_read_u32(dev->of_node, "line-fault-monitor", &ch);
208 if (!ret)
209 regmap_update_bits(max96745->regmap, 0x0005,
210 PU_LF0 << ch, PU_LF0 << ch);
211
212 ret = devm_device_add_group(dev, &max96745_attr_group);
213 if (ret) {
214 dev_err(dev, "failed to register sysfs. err: %d\n", ret);
215 return ret;
216 };
217
218 return 0;
219 }
220
max96745_i2c_probe(struct i2c_client * client)221 static int max96745_i2c_probe(struct i2c_client *client)
222 {
223 struct device *dev = &client->dev;
224 struct device_node *child;
225 struct max96745 *max96745;
226 unsigned int nr = 0;
227 int ret;
228
229 for_each_available_child_of_node(dev->of_node, child) {
230 if (!of_find_property(child, "reg", NULL))
231 continue;
232
233 nr++;
234 }
235
236 max96745 = devm_kzalloc(dev, sizeof(*max96745), GFP_KERNEL);
237 if (!max96745)
238 return -ENOMEM;
239
240 max96745->idle_disc = device_property_read_bool(dev, "i2c-mux-idle-disconnect");
241
242 max96745->muxc = i2c_mux_alloc(client->adapter, dev, nr,
243 0, I2C_MUX_LOCKED, max96745_select,
244 max96745_deselect);
245 if (!max96745->muxc)
246 return -ENOMEM;
247
248 max96745->dev = dev;
249 i2c_set_clientdata(client, max96745);
250
251 max96745->regmap = devm_regmap_init_i2c(client, &max96745_regmap_config);
252 if (IS_ERR(max96745->regmap))
253 return dev_err_probe(dev, PTR_ERR(max96745->regmap),
254 "failed to initialize regmap");
255
256 max96745->enable_gpio = devm_gpiod_get_optional(dev, "enable",
257 GPIOD_ASIS);
258 if (IS_ERR(max96745->enable_gpio))
259 return dev_err_probe(dev, PTR_ERR(max96745->enable_gpio),
260 "failed to get enable GPIO\n");
261
262 max96745->pwdnb_gpio = devm_gpiod_get_optional(dev, "pwdnb",
263 GPIOD_ASIS);
264 if (IS_ERR(max96745->pwdnb_gpio))
265 return dev_err_probe(dev, PTR_ERR(max96745->pwdnb_gpio),
266 "failed to get pwdnb GPIO\n");
267
268 max96745->extcon = devm_extcon_dev_allocate(dev, max96745_cable);
269 if (IS_ERR(max96745->extcon))
270 return dev_err_probe(dev, PTR_ERR(max96745->extcon),
271 "failed to allocate extcon device\n");
272
273 ret = devm_extcon_dev_register(dev, max96745->extcon);
274 if (ret)
275 return dev_err_probe(dev, ret,
276 "failed to register extcon device\n");
277
278 max96745_power_on(max96745);
279
280 ret = devm_add_action_or_reset(dev, max96745_power_off, max96745);
281 if (ret)
282 return ret;
283
284 ret = devm_mfd_add_devices(dev, PLATFORM_DEVID_AUTO, max96745_devs,
285 ARRAY_SIZE(max96745_devs), NULL, 0, NULL);
286 if (ret)
287 return ret;
288
289 for_each_available_child_of_node(dev->of_node, child) {
290 if (of_property_read_u32(child, "reg", &nr))
291 continue;
292
293 ret = i2c_mux_add_adapter(max96745->muxc, 0, nr, 0);
294 if (ret) {
295 i2c_mux_del_adapters(max96745->muxc);
296 return ret;
297 }
298 }
299
300 ret = max96745_sysfs_add(max96745);
301 if (ret)
302 return dev_err_probe(dev, ret, "failed to registers sysfs\n");
303
304 return 0;
305 }
306
max96745_i2c_remove(struct i2c_client * client)307 static int max96745_i2c_remove(struct i2c_client *client)
308 {
309 struct max96745 *max96745 = i2c_get_clientdata(client);
310
311 i2c_mux_del_adapters(max96745->muxc);
312
313 return 0;
314 }
315
max96745_i2c_shutdown(struct i2c_client * client)316 static void max96745_i2c_shutdown(struct i2c_client *client)
317 {
318 struct max96745 *max96745 = i2c_get_clientdata(client);
319
320 max96745_power_off(max96745);
321 }
322
max96745_suspend(struct device * dev)323 static int __maybe_unused max96745_suspend(struct device *dev)
324 {
325 struct max96745 *max96745 = dev_get_drvdata(dev);
326
327 regcache_mark_dirty(max96745->regmap);
328 regcache_cache_only(max96745->regmap, true);
329
330 return 0;
331 }
332
max96745_resume(struct device * dev)333 static int __maybe_unused max96745_resume(struct device *dev)
334 {
335 struct max96745 *max96745 = dev_get_drvdata(dev);
336
337 regcache_cache_only(max96745->regmap, false);
338 regcache_sync(max96745->regmap);
339
340 return 0;
341 }
342
343 static SIMPLE_DEV_PM_OPS(max96745_pm_ops, max96745_suspend, max96745_resume);
344
345 static const struct of_device_id max96745_of_match[] = {
346 { .compatible = "maxim,max96745", },
347 {}
348 };
349 MODULE_DEVICE_TABLE(of, max96745_of_match);
350
351 static struct i2c_driver max96745_i2c_driver = {
352 .driver = {
353 .name = "max96745",
354 .of_match_table = max96745_of_match,
355 .pm = &max96745_pm_ops,
356 },
357 .probe_new = max96745_i2c_probe,
358 .remove = max96745_i2c_remove,
359 .shutdown = max96745_i2c_shutdown,
360 };
361
362 module_i2c_driver(max96745_i2c_driver);
363
364 MODULE_AUTHOR("Wyon Bi <bivvy.bi@rock-chips.com>");
365 MODULE_DESCRIPTION("Maxim MAX96745 MFD driver");
366 MODULE_LICENSE("GPL");
367