write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/drivers/mfd/display-serdes/serdes-i2c.c
..
..
@@ -9,6 +9,8 @@
9
9
 
10
10
 #include "core.h"
11
11
 
12
+static struct serdes *g_serdes_ser_split[MAX_NUM_SERDES_SPLIT];
13
+
12
14
 int serdes_i2c_set_sequence(struct serdes *serdes)
13
15
 {
14
16
 	struct device *dev = serdes->dev;
..
..
@@ -52,6 +54,42 @@
52
54
 	return ret;
53
55
 }
54
56
 EXPORT_SYMBOL_GPL(serdes_i2c_set_sequence);
57
+
58
+static int serdes_set_i2c_address(struct serdes *serdes, u32 reg_hw, u32 reg_use, int link)
59
+{
60
+	int ret = 0;
61
+	struct i2c_client *client_split;
62
+	struct serdes *serdes_split = serdes->g_serdes_bridge_split;
63
+
64
+	if (!serdes_split) {
65
+		pr_info("%s: serdes_split is null\n", __func__);
66
+		return -1;
67
+	}
68
+
69
+	client_split = to_i2c_client(serdes->regmap->dev);
70
+	SERDES_DBG_MFD("%s: %s-%s addr=0x%x reg_hw=0x%x, reg_use=0x%x serdes_split=0x%p\n",
71
+		       __func__, dev_name(serdes_split->dev), client_split->name,
72
+		       client_split->addr, serdes->reg_hw, serdes->reg_use, serdes_split);
73
+
74
+	client_split->addr = serdes->reg_hw;
75
+
76
+	if (serdes_split && serdes_split->chip_data->split_ops &&
77
+	    serdes_split->chip_data->split_ops->select)
78
+		ret = serdes_split->chip_data->split_ops->select(serdes_split, link);
79
+
80
+	if (serdes->chip_data->split_ops && serdes->chip_data->split_ops->set_i2c_addr)
81
+		serdes->chip_data->split_ops->set_i2c_addr(serdes, reg_use, link);
82
+
83
+	if (serdes_split && serdes_split->chip_data->split_ops &&
84
+	    serdes_split->chip_data->split_ops->select)
85
+		ret = serdes_split->chip_data->split_ops->select(serdes_split, SER_SPLITTER_MODE);
86
+
87
+	client_split->addr = serdes->reg_use;
88
+
89
+	serdes_i2c_set_sequence(serdes);
90
+
91
+	return ret;
92
+}
55
93
 
56
94
 static void serdes_mfd_work(struct work_struct *work)
57
95
 {
..
..
@@ -125,8 +163,11 @@
125
163
 
126
164
 	/* init ser register(not des register) more early if uboot logo disabled */
127
165
 	serdes->route_enable = of_property_read_bool(dev->of_node, "route-enable");
128
-	if ((!serdes->route_enable) && (serdes->chip_data->serdes_type == TYPE_SER))
166
+	if ((!serdes->route_enable) && (serdes->chip_data->serdes_type == TYPE_SER)) {
167
+		if (serdes->chip_data->chip_init)
168
+			serdes->chip_data->chip_init(serdes);
129
169
 		ret = serdes_i2c_set_sequence(serdes);
170
+	}
130
171
 
131
172
 	return ret;
132
173
 }
..
..
@@ -146,7 +187,8 @@
146
187
 	serdes->chip_data = (struct serdes_chip_data *)of_device_get_match_data(dev);
147
188
 	i2c_set_clientdata(client, serdes);
148
189
 
149
-	dev_info(dev, "serdes %s probe start\n", serdes->chip_data->name);
190
+	dev_info(dev, "serdes %s probe start, id=%d\n", serdes->chip_data->name,
191
+		 serdes->chip_data->serdes_id);
150
192
 
151
193
 	serdes->type = serdes->chip_data->serdes_type;
152
194
 	serdes->regmap = devm_regmap_init_i2c(client, serdes->chip_data->regmap_config);
..
..
@@ -171,7 +213,6 @@
171
213
 	if (IS_ERR(serdes->vpower)) {
172
214
 		if (PTR_ERR(serdes->vpower) != -ENODEV)
173
215
 			return PTR_ERR(serdes->vpower);
174
-		dev_info(dev, "no vpower regulator found\n");
175
216
 	}
176
217
 
177
218
 	if (!IS_ERR(serdes->vpower)) {
..
..
@@ -194,8 +235,7 @@
194
235
 
195
236
 	ret = serdes_get_init_seq(serdes);
196
237
 	if (ret)
197
-		return dev_err_probe(dev, ret,
198
-				     "failed to write serdes register with i2c\n");
238
+		dev_err(dev, "failed to write serdes register with i2c\n");
199
239
 
200
240
 	mutex_init(&serdes->io_lock);
201
241
 	dev_set_drvdata(serdes->dev, serdes);
..
..
@@ -203,6 +243,31 @@
203
243
 	if (ret != 0) {
204
244
 		serdes_irq_exit(serdes);
205
245
 		return ret;
246
+	}
247
+
248
+	of_property_read_u32(dev->of_node, "id-serdes-bridge-split",
249
+			     &serdes->id_serdes_bridge_split);
250
+	if ((serdes->id_serdes_bridge_split < MAX_NUM_SERDES_SPLIT) && (serdes->type == TYPE_SER)) {
251
+		g_serdes_ser_split[serdes->id_serdes_bridge_split] = serdes;
252
+		SERDES_DBG_MFD("%s: %s-%s g_serdes_split[%d]=0x%p\n", __func__,
253
+			       dev_name(serdes->dev), serdes->chip_data->name,
254
+			       serdes->id_serdes_bridge_split, serdes);
255
+	}
256
+
257
+	of_property_read_u32(dev->of_node, "reg-hw", &serdes->reg_hw);
258
+	of_property_read_u32(dev->of_node, "reg", &serdes->reg_use);
259
+	of_property_read_u32(dev->of_node, "link", &serdes->link_use);
260
+	of_property_read_u32(dev->of_node, "id-serdes-panel-split", &serdes->id_serdes_panel_split);
261
+	if ((serdes->id_serdes_panel_split) && (serdes->type == TYPE_DES)) {
262
+		serdes->g_serdes_bridge_split = g_serdes_ser_split[serdes->id_serdes_panel_split];
263
+		SERDES_DBG_MFD("%s: id=%d p=0x%p\n", __func__,
264
+			       serdes->id_serdes_panel_split, serdes->g_serdes_bridge_split);
265
+	}
266
+
267
+	if (serdes->reg_hw) {
268
+		SERDES_DBG_MFD("%s: %s start change i2c address from 0x%x to 0x%x\n",
269
+			       __func__, dev->of_node->name, serdes->reg_hw, serdes->reg_use);
270
+		serdes_set_i2c_address(serdes, serdes->reg_hw, serdes->reg_use, serdes->link_use);
206
271
 	}
207
272
 
208
273
 	serdes->use_delay_work = of_property_read_bool(dev->of_node, "use-delay-work");
..
..
@@ -215,14 +280,22 @@
215
280
 		queue_delayed_work(serdes->mfd_wq, &serdes->mfd_delay_work, msecs_to_jiffies(300));
216
281
 		SERDES_DBG_MFD("%s: use_delay_work=%d\n", __func__, serdes->use_delay_work);
217
282
 	} else {
218
-		ret = serdes_device_init(serdes);
283
+		serdes_device_init(serdes);
219
284
 		SERDES_DBG_MFD("%s: use_delay_work=%d\n", __func__, serdes->use_delay_work);
220
285
 	}
221
286
 
222
287
 	dev_info(dev, "serdes %s serdes_i2c_probe successful version %s\n",
223
288
 		 serdes->chip_data->name, MFD_SERDES_DISPLAY_VERSION);
224
289
 
225
-	return ret;
290
+	return 0;
291
+}
292
+
293
+static void serdes_i2c_shutdown(struct i2c_client *client)
294
+{
295
+	struct device *dev = &client->dev;
296
+	struct serdes *serdes = dev_get_drvdata(dev);
297
+
298
+	serdes_device_shutdown(serdes);
226
299
 }
227
300
 
228
301
 static int serdes_i2c_prepare(struct device *dev)
..
..
@@ -266,7 +339,7 @@
266
339
 {
267
340
 	struct serdes *serdes = dev_get_drvdata(dev);
268
341
 
269
-	serdes_device_shutdown(serdes);
342
+	serdes_device_poweroff(serdes);
270
343
 
271
344
 	return 0;
272
345
 }
..
..
@@ -289,6 +362,9 @@
289
362
 #endif
290
363
 #if IS_ENABLED(CONFIG_SERDES_DISPLAY_CHIP_MAXIM_MAX96772)
291
364
 	{ .compatible = "maxim,max96772", .data = &serdes_max96772_data },
365
+#endif
366
+#if IS_ENABLED(CONFIG_SERDES_DISPLAY_CHIP_MAXIM_MAX96789)
367
+	{ .compatible = "maxim,max96789", .data = &serdes_max96789_data },
292
368
 #endif
293
369
 #if IS_ENABLED(CONFIG_SERDES_DISPLAY_CHIP_ROCKCHIP_RKX111)
294
370
 	{ .compatible = "rockchip,rkx111", .data = &serdes_rkx111_data },
..
..
@@ -317,6 +393,7 @@
317
393
 		.of_match_table = of_match_ptr(serdes_of_match),
318
394
 	},
319
395
 	.probe = serdes_i2c_probe,
396
+	.shutdown = serdes_i2c_shutdown,
320
397
 };
321
398
 
322
399
 static int __init serdes_i2c_init(void)