write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/drivers/regulator/s5m8767.c
..
..
@@ -115,7 +115,7 @@
115
115
 	[S5M8767_BUCK9] = &buck_voltage_val3,
116
116
 };
117
117
 
118
-static unsigned int s5m8767_opmode_reg[][4] = {
118
+static const unsigned int s5m8767_opmode_reg[][4] = {
119
119
 	/* {OFF, ON, LOWPOWER, SUSPEND} */
120
120
 	/* LDO1 ... LDO28 */
121
121
 	{0x0, 0x3, 0x2, 0x1}, /* LDO1 */
..
..
@@ -339,13 +339,9 @@
339
339
 					     unsigned int new_sel)
340
340
 {
341
341
 	struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
342
-	const struct sec_voltage_desc *desc;
343
-	int reg_id = rdev_get_id(rdev);
344
-
345
-	desc = reg_voltage_map[reg_id];
346
342
 
347
343
 	if ((old_sel < new_sel) && s5m8767->ramp_delay)
348
-		return DIV_ROUND_UP(desc->step * (new_sel - old_sel),
344
+		return DIV_ROUND_UP(rdev->desc->uV_step * (new_sel - old_sel),
349
345
 					s5m8767->ramp_delay * 1000);
350
346
 	return 0;
351
347
 }
..
..
@@ -447,15 +443,15 @@
447
443
 	}
448
444
 	if (mode != S5M8767_ENCTRL_USE_GPIO) {
449
445
 		dev_warn(s5m8767->dev,
450
-				"ext-control for %s: mismatched op_mode (%x), ignoring\n",
451
-				rdata->reg_node->name, mode);
446
+				"ext-control for %pOFn: mismatched op_mode (%x), ignoring\n",
447
+				rdata->reg_node, mode);
452
448
 		return;
453
449
 	}
454
450
 
455
451
 	if (!rdata->ext_control_gpiod) {
456
452
 		dev_warn(s5m8767->dev,
457
-				"ext-control for %s: GPIO not valid, ignoring\n",
458
-			 rdata->reg_node->name);
453
+				"ext-control for %pOFn: GPIO not valid, ignoring\n",
454
+			 rdata->reg_node);
459
455
 		return;
460
456
 	}
461
457
 
..
..
@@ -565,24 +561,29 @@
565
561
 	pdata->opmode = rmode;
566
562
 	for_each_child_of_node(regulators_np, reg_np) {
567
563
 		for (i = 0; i < ARRAY_SIZE(regulators); i++)
568
-			if (!of_node_cmp(reg_np->name, regulators[i].name))
564
+			if (of_node_name_eq(reg_np, regulators[i].name))
569
565
 				break;
570
566
 
571
567
 		if (i == ARRAY_SIZE(regulators)) {
572
568
 			dev_warn(iodev->dev,
573
-			"don't know how to configure regulator %s\n",
574
-			reg_np->name);
569
+			"don't know how to configure regulator %pOFn\n",
570
+			reg_np);
575
571
 			continue;
576
572
 		}
577
573
 
578
-		rdata->ext_control_gpiod = devm_gpiod_get_from_of_node(&pdev->dev,
579
-								       reg_np,
580
-								       "s5m8767,pmic-ext-control-gpios",
581
-								       0,
582
-								       GPIOD_OUT_HIGH,
583
-								       "s5m8767");
584
-		if (IS_ERR(rdata->ext_control_gpiod))
574
+		rdata->ext_control_gpiod = devm_fwnode_gpiod_get(
575
+			&pdev->dev,
576
+			of_fwnode_handle(reg_np),
577
+			"s5m8767,pmic-ext-control",
578
+			GPIOD_OUT_HIGH | GPIOD_FLAGS_BIT_NONEXCLUSIVE,
579
+			"s5m8767");
580
+		if (PTR_ERR(rdata->ext_control_gpiod) == -ENOENT) {
581
+			rdata->ext_control_gpiod = NULL;
582
+		} else if (IS_ERR(rdata->ext_control_gpiod)) {
583
+			of_node_put(reg_np);
584
+			of_node_put(regulators_np);
585
585
 			return PTR_ERR(rdata->ext_control_gpiod);
586
+		}
586
587
 
587
588
 		rdata->id = i;
588
589
 		rdata->initdata = of_get_regulator_init_data(
..
..
@@ -594,7 +595,7 @@
594
595
 		if (of_property_read_u32(reg_np, "op_mode",
595
596
 				&rmode->mode)) {
596
597
 			dev_warn(iodev->dev,
597
-				"no op_mode property property at %pOF\n",
598
+				"no op_mode property at %pOF\n",
598
599
 				reg_np);
599
600
 
600
601
 			rmode->mode = S5M8767_OPMODE_NORMAL_MODE;
..
..
@@ -922,9 +923,13 @@
922
923
 
923
924
 	for (i = 0; i < pdata->num_regulators; i++) {
924
925
 		const struct sec_voltage_desc *desc;
925
-		int id = pdata->regulators[i].id;
926
+		unsigned int id = pdata->regulators[i].id;
926
927
 		int enable_reg, enable_val;
927
928
 		struct regulator_dev *rdev;
929
+
930
+		BUILD_BUG_ON(ARRAY_SIZE(regulators) != ARRAY_SIZE(reg_voltage_map));
931
+		if (WARN_ON_ONCE(id >= ARRAY_SIZE(regulators)))
932
+			continue;
928
933
 
929
934
 		desc = reg_voltage_map[id];
930
935
 		if (desc) {
..
..
@@ -956,10 +961,17 @@
956
961
 		config.regmap = iodev->regmap_pmic;
957
962
 		config.of_node = pdata->regulators[i].reg_node;
958
963
 		config.ena_gpiod = NULL;
959
-		if (pdata->regulators[i].ext_control_gpiod)
964
+		if (pdata->regulators[i].ext_control_gpiod) {
965
+			/* Assigns config.ena_gpiod */
960
966
 			s5m8767_regulator_config_ext_control(s5m8767,
961
967
 					&pdata->regulators[i], &config);
962
968
 
969
+			/*
970
+			 * Hand the GPIO descriptor management over to the
971
+			 * regulator core, remove it from devres management.
972
+			 */
973
+			devm_gpiod_unhinge(s5m8767->dev, config.ena_gpiod);
974
+		}
963
975
 		rdev = devm_regulator_register(&pdev->dev, &regulators[id],
964
976
 						  &config);
965
977
 		if (IS_ERR(rdev)) {
..
..
@@ -996,20 +1008,9 @@
996
1008
 	.probe = s5m8767_pmic_probe,
997
1009
 	.id_table = s5m8767_pmic_id,
998
1010
 };
999
-
1000
-static int __init s5m8767_pmic_init(void)
1001
-{
1002
-	return platform_driver_register(&s5m8767_pmic_driver);
1003
-}
1004
-subsys_initcall(s5m8767_pmic_init);
1005
-
1006
-static void __exit s5m8767_pmic_exit(void)
1007
-{
1008
-	platform_driver_unregister(&s5m8767_pmic_driver);
1009
-}
1010
-module_exit(s5m8767_pmic_exit);
1011
+module_platform_driver(s5m8767_pmic_driver);
1011
1012
 
1012
1013
 /* Module information */
1013
1014
 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
1014
-MODULE_DESCRIPTION("SAMSUNG S5M8767 Regulator Driver");
1015
+MODULE_DESCRIPTION("Samsung S5M8767 Regulator Driver");
1015
1016
 MODULE_LICENSE("GPL");