write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/drivers/regulator/xz3216.c
..
..
@@ -66,19 +66,15 @@
66
66
 	struct i2c_client *i2c;
67
67
 	int num_regulators;
68
68
 	struct regulator_dev *rdev;
69
-	struct regulator_desc desc;
70
69
 	struct regulator_init_data *regulator;
71
70
 	struct regmap *regmap;
72
71
 	/* Voltage setting register */
73
72
 	unsigned int vol_reg;
74
73
 	unsigned int sleep_reg;
75
-	unsigned int en_reg;
76
-	unsigned int sleep_en_reg;
77
74
 	/* Voltage range and step(linear) */
78
75
 	unsigned int vsel_min;
79
76
 	unsigned int vsel_step;
80
77
 	unsigned int sleep_vol_cache;
81
-	unsigned int sleep_vsel_id;
82
78
 };
83
79
 
84
80
 struct xz3216_regulator {
..
..
@@ -90,14 +86,7 @@
90
86
 struct xz3216_board {
91
87
 	struct regulator_init_data *xz3216_init_data;
92
88
 	struct device_node *of_node;
93
-	unsigned int sleep_vsel_id;
94
89
 };
95
-
96
-static unsigned int xz3216_map_mode(unsigned int mode)
97
-{
98
-	return mode == REGULATOR_MODE_FAST ?
99
-		REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
100
-}
101
90
 
102
91
 static unsigned int xz3216_dcdc_get_mode(struct regulator_dev *dev)
103
92
 {
..
..
@@ -131,51 +120,19 @@
131
120
 	}
132
121
 }
133
122
 
134
-static int xz3216_dcdc_is_enable(struct regulator_dev *dev)
135
-{
136
-	struct xz3216 *xz3216 = rdev_get_drvdata(dev);
137
-	int ret = 0;
138
-	unsigned int val;
139
-
140
-	ret = regmap_read(xz3216->regmap, xz3216->en_reg, &val);
141
-	if (ret < 0)
142
-		return ret;
143
-	if (val & VSEL_BUCK_EN)
144
-		return 1;
145
-	else
146
-		return 0;
147
-}
148
-
149
-static int xz3216_dcdc_enable(struct regulator_dev *dev)
150
-{
151
-	struct xz3216 *xz3216 = rdev_get_drvdata(dev);
152
-
153
-	return regmap_update_bits(xz3216->regmap, xz3216->en_reg,
154
-				VSEL_BUCK_EN, VSEL_BUCK_EN);
155
-}
156
-
157
-static int xz3216_dcdc_disable(struct regulator_dev *dev)
158
-{
159
-	struct xz3216 *xz3216 = rdev_get_drvdata(dev);
160
-
161
-	return regmap_update_bits(xz3216->regmap, xz3216->en_reg,
162
-				VSEL_BUCK_EN, 0);
163
-}
164
-
165
123
 static int xz3216_dcdc_suspend_enable(struct regulator_dev *dev)
166
124
 {
167
125
 	struct xz3216 *xz3216 = rdev_get_drvdata(dev);
168
-
169
-	return regmap_update_bits(xz3216->regmap, xz3216->sleep_en_reg,
170
-				VSEL_BUCK_EN, VSEL_BUCK_EN);
126
+	return regmap_update_bits(xz3216->regmap, XZ3216_BUCK1_SLP_VOL_BASE,
127
+				  VSEL_BUCK_EN, VSEL_BUCK_EN);
171
128
 }
172
129
 
173
130
 static int xz3216_dcdc_suspend_disable(struct regulator_dev *dev)
174
131
 {
175
132
 	struct xz3216 *xz3216 = rdev_get_drvdata(dev);
133
+	return regmap_update_bits(xz3216->regmap, XZ3216_BUCK1_SLP_VOL_BASE,
134
+				  VSEL_BUCK_EN, 0);
176
135
 
177
-	return regmap_update_bits(xz3216->regmap, xz3216->sleep_en_reg,
178
-				VSEL_BUCK_EN, 0);
179
136
 }
180
137
 
181
138
 static int xz3216_dcdc_set_sleep_voltage(struct regulator_dev *dev,
..
..
@@ -189,13 +146,13 @@
189
146
 	ret = regulator_map_voltage_linear(dev, uV, uV);
190
147
 	if (ret < 0)
191
148
 		return ret;
192
-	ret = regmap_update_bits(xz3216->regmap, xz3216->sleep_reg,
149
+	ret = regmap_update_bits(xz3216->regmap, XZ3216_BUCK1_SLP_VOL_BASE,
193
150
 					VSEL_NSEL_MASK, ret);
194
151
 	if (ret < 0)
195
152
 		return ret;
196
153
 	xz3216->sleep_vol_cache = uV;
197
-
198
154
 	return 0;
155
+
199
156
 }
200
157
 
201
158
 static int xz3216_dcdc_set_suspend_mode(struct regulator_dev *dev,
..
..
@@ -205,29 +162,15 @@
205
162
 
206
163
 	switch (mode) {
207
164
 	case REGULATOR_MODE_FAST:
208
-		return regmap_update_bits(xz3216->regmap, xz3216->sleep_reg,
209
-						VSEL_MODE, VSEL_MODE);
165
+		return regmap_update_bits(xz3216->regmap, xz3216->vol_reg,
166
+					  VSEL_MODE, VSEL_MODE);
210
167
 	case REGULATOR_MODE_NORMAL:
211
-		return regmap_update_bits(xz3216->regmap, xz3216->sleep_reg,
212
-						VSEL_MODE, 0);
168
+		return regmap_update_bits(xz3216->regmap, xz3216->vol_reg,
169
+					  VSEL_MODE, 0);
213
170
 	default:
214
171
 		DBG_ERR("error:dcdc_xz3216 only auto and pwm mode\n");
215
172
 		return -EINVAL;
216
173
 	}
217
-}
218
-
219
-static int xz3216_resume(struct regulator_dev *rdev)
220
-{
221
-	int ret;
222
-
223
-	if (!rdev->constraints->state_mem.changeable)
224
-		return 0;
225
-
226
-	ret = xz3216_dcdc_suspend_enable(rdev);
227
-	if (ret)
228
-		return ret;
229
-
230
-	return regulator_suspend_enable(rdev, PM_SUSPEND_MEM);
231
174
 }
232
175
 
233
176
 static const int slew_rates[] = {
..
..
@@ -266,9 +209,9 @@
266
209
 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
267
210
 	.list_voltage = regulator_list_voltage_linear,
268
211
 	.map_voltage = regulator_map_voltage_linear,
269
-	.is_enabled = xz3216_dcdc_is_enable,
270
-	.enable = xz3216_dcdc_enable,
271
-	.disable = xz3216_dcdc_disable,
212
+	.is_enabled = regulator_is_enabled_regmap,
213
+	.enable = regulator_enable_regmap,
214
+	.disable = regulator_disable_regmap,
272
215
 	.get_mode = xz3216_dcdc_get_mode,
273
216
 	.set_mode = xz3216_dcdc_set_mode,
274
217
 	.set_suspend_voltage = xz3216_dcdc_set_sleep_voltage,
..
..
@@ -277,47 +220,26 @@
277
220
 	.set_suspend_mode = xz3216_dcdc_set_suspend_mode,
278
221
 	.set_ramp_delay = xz3216_set_ramp,
279
222
 	.set_voltage_time_sel = regulator_set_voltage_time_sel,
280
-	.resume = xz3216_resume,
281
223
 };
282
224
 
283
-static int xz3216_regulator_register(struct xz3216 *xz3216, struct regulator_config *config)
284
-{
285
-	struct regulator_desc *rdesc = &xz3216->desc;
286
-
287
-	rdesc->name = "XZ_DCDC1";
288
-	rdesc->supply_name = "vin";
289
-	rdesc->id = 0;
290
-	rdesc->ops = &xz3216_dcdc_ops;
291
-	rdesc->type = REGULATOR_VOLTAGE;
292
-	rdesc->n_voltages = 64;
293
-	rdesc->enable_mask = VSEL_BUCK_EN;
294
-	rdesc->min_uV = 600000;
295
-	rdesc->uV_step = 12500;
296
-	rdesc->vsel_mask = VSEL_NSEL_MASK;
297
-	rdesc->owner = THIS_MODULE;
298
-	rdesc->enable_time = 400;
299
-
300
-	if (xz3216->sleep_vsel_id) {
301
-		rdesc->vsel_reg = XZ3216_BUCK1_SET_VOL_BASE;
302
-		rdesc->enable_reg = XZ3216_BUCK1_SET_VOL_BASE;
303
-
304
-		xz3216->vol_reg = rdesc->vsel_reg;
305
-		xz3216->en_reg = rdesc->vsel_reg;
306
-		xz3216->sleep_reg = XZ3216_BUCK1_SLP_VOL_BASE;
307
-		xz3216->sleep_en_reg = xz3216->sleep_reg;
308
-	} else {
309
-		rdesc->vsel_reg = XZ3216_BUCK1_SLP_VOL_BASE;
310
-		rdesc->enable_reg = XZ3216_BUCK1_SLP_VOL_BASE;
311
-
312
-		xz3216->vol_reg = rdesc->vsel_reg;
313
-		xz3216->en_reg = rdesc->vsel_reg;
314
-		xz3216->sleep_reg = XZ3216_BUCK1_SET_VOL_BASE;
315
-		xz3216->sleep_en_reg = xz3216->sleep_reg;
316
-	}
317
-	xz3216->rdev = devm_regulator_register(xz3216->dev, &xz3216->desc, config);
318
-
319
-	return PTR_ERR_OR_ZERO(xz3216->rdev);
320
-}
225
+static struct regulator_desc regulators[] = {
226
+	{
227
+		.name = "XZ_DCDC1",
228
+		.supply_name = "vin",
229
+		.id = 0,
230
+		.ops = &xz3216_dcdc_ops,
231
+		.n_voltages = 64,
232
+		.type = REGULATOR_VOLTAGE,
233
+		.enable_time = 400,
234
+		.enable_reg = XZ3216_BUCK1_SET_VOL_BASE,
235
+		.enable_mask = VSEL_BUCK_EN,
236
+		.min_uV = 600000,
237
+		.uV_step = 12500,
238
+		.vsel_reg = XZ3216_BUCK1_SET_VOL_BASE,
239
+		.vsel_mask = VSEL_NSEL_MASK,
240
+		.owner = THIS_MODULE,
241
+	},
242
+};
321
243
 
322
244
 static const struct regmap_config xz3216_regmap_config = {
323
245
 	.reg_bits = 8,
..
..
@@ -343,49 +265,26 @@
343
265
 	struct device_node *regs;
344
266
 	struct device_node *xz3216_np;
345
267
 	int count;
346
-	u32 tmp;
347
-
348
-	pdata = devm_kzalloc(xz3216->dev, sizeof(*pdata), GFP_KERNEL);
349
-	if (!pdata)
350
-		return NULL;
351
268
 
352
269
 	xz3216_np = of_node_get(xz3216->dev->of_node);
353
270
 	if (!xz3216_np) {
354
271
 		DBG_ERR("could not find pmic sub-node\n");
355
272
 		return NULL;
356
273
 	}
357
-
358
-	regs = of_find_node_by_name(xz3216_np, "regulator");
359
-	if (!regs) {
360
-		DBG_ERR("can not found regulator node\n");
361
-		return NULL;
362
-	}
363
-	count = of_property_read_u32(regs, "fcs,suspend-voltage-selector",
364
-				   &tmp);
365
-	if (!count) {
366
-		pdata->sleep_vsel_id = tmp;
367
-		pr_info("xz3216, suspend-voltage-selector = %d\n", pdata->sleep_vsel_id);
368
-	} else {
369
-		pdata->sleep_vsel_id = 0;
370
-		pr_info("xz3216, get suspend-voltage-selector failed, use default value\n");
371
-	}
372
-	of_node_put(regs);
373
-
374
274
 	regs = of_find_node_by_name(xz3216_np, "regulators");
375
275
 	if (!regs)
376
276
 		return NULL;
377
-
378
-	xz3216_reg_matches[0].desc = &xz3216->desc;
379
277
 	count = of_regulator_match(xz3216->dev, regs, xz3216_reg_matches,
380
278
 				   XZ3216_NUM_REGULATORS);
381
279
 	of_node_put(regs);
382
-	if (!count)
280
+	pdata = devm_kzalloc(xz3216->dev, sizeof(*pdata), GFP_KERNEL);
281
+	if (!pdata)
383
282
 		return NULL;
384
283
 	pdata->xz3216_init_data = xz3216_reg_matches[0].init_data;
385
284
 	pdata->of_node = xz3216_reg_matches[0].of_node;
386
-
387
285
 	return pdata;
388
286
 }
287
+
389
288
 #else
390
289
 static struct xz3216_board *xz3216_parse_dt(struct i2c_client *i2c)
391
290
 {
..
..
@@ -401,7 +300,7 @@
401
300
 	const struct of_device_id *match;
402
301
 	struct regulator_config config = { };
403
302
 	int ret;
404
-
303
+	DBG("%s, line=%d\n", __func__, __LINE__);
405
304
 	xz3216 = devm_kzalloc(&i2c->dev, sizeof(struct xz3216),
406
305
 						GFP_KERNEL);
407
306
 	if (!xz3216) {
..
..
@@ -417,7 +316,6 @@
417
316
 		}
418
317
 	}
419
318
 
420
-	xz3216->desc.of_map_mode = xz3216_map_mode;
421
319
 	xz3216->regmap = devm_regmap_init_i2c(i2c, &xz3216_regmap_config);
422
320
 	if (IS_ERR(xz3216->regmap)) {
423
321
 		dev_err(&i2c->dev, "Failed to allocate regmap!\n");
..
..
@@ -431,7 +329,6 @@
431
329
 	if (!pdev)
432
330
 		pdev = xz3216_parse_dt(xz3216);
433
331
 	if (pdev) {
434
-		xz3216->sleep_vsel_id = pdev->sleep_vsel_id;
435
332
 		xz3216->num_regulators = XZ3216_NUM_REGULATORS;
436
333
 		xz3216->rdev = kcalloc(XZ3216_NUM_REGULATORS,
437
334
 					sizeof(struct regulator_dev),
..
..
@@ -445,8 +342,9 @@
445
342
 		config.dev = xz3216->dev;
446
343
 		config.driver_data = xz3216;
447
344
 		config.init_data = xz3216->regulator;
448
-		config.regmap = xz3216->regmap;
449
-		ret = xz3216_regulator_register(xz3216, &config);
345
+		xz3216->rdev = devm_regulator_register(xz3216->dev,
346
+						&regulators[0], &config);
347
+		ret = PTR_ERR_OR_ZERO(xz3216->rdev);
450
348
 		if (ret < 0)
451
349
 			dev_err(&i2c->dev, "Failed to register regulator!\n");
452
350
 		return ret;