Merge android13-gs-pixel-5.10-24Q2 into android13-gs-pixel-5.10

SBMerger: 571992243
Change-Id: I690023d7d20afbe9f5f75380cf572565d8847d31
Signed-off-by: SecurityBot <android-nexus-securitybot@system.gserviceaccount.com>

4 files changed, 126 insertions, 67 deletions

diff --git a/max1720x_battery.c b/max1720x_battery.c
index 2916c8a..dc03d2b 100644
--- a/max1720x_battery.c
+++ b/max1720x_battery.c
@@ -3850,6 +3850,52 @@ static ssize_t max1720x_set_custom_model(struct file *filp,
 BATTERY_DEBUG_ATTRIBUTE(debug_m5_custom_model_fops, max1720x_show_custom_model,
 			max1720x_set_custom_model);
 
+static ssize_t max1720x_show_model_reg(struct file *filp, char __user *buf,
+				       size_t count, loff_t *ppos)
+{
+	struct max1720x_chip *chip = (struct max1720x_chip *)filp->private_data;
+	const struct max17x0x_regmap *map = &chip->regmap;
+	u32 reg_address;
+	unsigned int data;
+	char *tmp;
+	int len = 0, ret, rc;
+
+	if (!map->regmap) {
+		pr_err("Failed to read, no regmap\n");
+		return -EIO;
+	}
+
+	tmp = kmalloc(PAGE_SIZE, GFP_KERNEL);
+	if (!tmp)
+		return -ENOMEM;
+
+	rc = max_m5_model_lock(map->regmap, false);
+	if (rc < 0)
+		pr_warn("unlock fail, rc=%d\n", rc);
+
+	for (reg_address = MAX_M5_FG_MODEL_START;
+	     reg_address < MAX_M5_FG_MODEL_START + MAX_M5_FG_MODEL_SIZE ; reg_address++) {
+		ret = regmap_read(map->regmap, reg_address, &data);
+		if (ret < 0)
+			continue;
+
+		len += scnprintf(tmp + len, PAGE_SIZE - len, "%02x: %04x\n", reg_address, data);
+	}
+
+	rc = max_m5_model_lock(map->regmap, true);
+	if (rc < 0)
+		pr_warn("lock fail, rc=%d\n", rc);
+
+	if (len > 0)
+		len = simple_read_from_buffer(buf, count, ppos, tmp, len);
+
+	kfree(tmp);
+
+	return len;
+}
+
+BATTERY_DEBUG_ATTRIBUTE(debug_model_reg_fops, max1720x_show_model_reg, NULL);
+
 
 static int debug_sync_model(void *data, u64 val)
 {
@@ -4115,9 +4161,12 @@ static int max17x0x_init_sysfs(struct max1720x_chip *chip)
 					chip->regmap_nvram.reglog,
 					&debug_reglog_writes_fops);
 
-	if (chip->gauge_type == MAX_M5_GAUGE_TYPE)
+	if (chip->gauge_type == MAX_M5_GAUGE_TYPE) {
 		debugfs_create_file("fg_model", 0444, de, chip,
 				    &debug_m5_custom_model_fops);
+		debugfs_create_file("model_registers", 0444, de, chip,
+				    &debug_model_reg_fops);
+	}
 	debugfs_create_bool("model_ok", 0444, de, &chip->model_ok);
 	debugfs_create_file("sync_model", 0400, de, chip,
 			    &debug_sync_model_fops);
diff --git a/max_m5.c b/max_m5.c
index 2f1ee9d..f86abb0 100644
--- a/max_m5.c
+++ b/max_m5.c
@@ -146,7 +146,7 @@ static int max_m5_write_custom_model(struct regmap *regmap, u16 *model_data,
 				count * 2);
 }
 
-static int max_m5_model_lock(struct regmap *regmap, bool enabled)
+int max_m5_model_lock(struct regmap *regmap, bool enabled)
 {
 	u16 code[2] = {0x59, 0xC4};
 
diff --git a/max_m5.h b/max_m5.h
index 9620cff..a7186d3 100644
--- a/max_m5.h
+++ b/max_m5.h
@@ -131,6 +131,7 @@ int max_m5_model_get_cap_lsb(const struct max_m5_data *m5_data);
 int max_m5_reset_state_data(struct max_m5_data *m5_data);
 int max_m5_needs_reset_model_data(const struct max_m5_data *m5_data);
 int max_m5_get_designcap(const struct max_m5_data *m5_data);
+int max_m5_model_lock(struct regmap *regmap, bool enabled);
 
 /*
  * max_m5 might use the low 8 bits of devname to keep the model version number
diff --git a/p9221_charger.c b/p9221_charger.c
index 802d475..72cee14 100644
--- a/p9221_charger.c
+++ b/p9221_charger.c
@@ -6180,6 +6180,30 @@ static void p9221_uevent_work(struct work_struct *work)
 	}
 }
 
+static int p9221_parse_gpios(struct device *dev, char *of_name_1, char *of_name_2,
+			     enum of_gpio_flags *flags)
+{
+	int ret_1, ret_2 = 0;
+	struct device_node *node = dev->of_node;
+
+	ret_1 = of_get_named_gpio_flags(node, of_name_1, 0, flags);
+	if (ret_1 < 0)
+		ret_2 = of_get_named_gpio_flags(node, of_name_2, 0, flags);
+
+	if (ret_1 == -EPROBE_DEFER || ret_2 == -EPROBE_DEFER)
+		return -EPROBE_DEFER;
+
+	if (ret_1 > 0)
+		return ret_1;
+	if (ret_2 > 0)
+		return ret_2;
+
+	dev_dbg(dev, "unable to read %s from dt: %d\n", of_name_1, ret_1);
+	dev_dbg(dev, "unable to read %s from dt: %d\n", of_name_2, ret_2);
+
+	return -EINVAL;
+}
+
 static int p9221_parse_dt(struct device *dev,
 			  struct p9221_charger_platform_data *pdata)
 {
@@ -6209,53 +6233,45 @@ static int p9221_parse_dt(struct device *dev,
 	}
 
 	/* QI_EN_L: enable/disable WLC chip */
-	ret = of_get_named_gpio(node, "idt,gpio_qien", 0);
-	pdata->qien_gpio = ret;
-	if (ret < 0)
-		dev_warn(dev, "unable to read idt,gpio_qien from dt: %d\n",
-			 ret);
-	else
+	pdata->qien_gpio = p9221_parse_gpios(dev, "idt,qien-gpio", "idt,gpio_qien", &flags);
+	if (pdata->qien_gpio == -EPROBE_DEFER)
+		return -EPROBE_DEFER;
+	if (pdata->qien_gpio > 0)
 		dev_info(dev, "enable gpio:%d", pdata->qien_gpio);
 
 	/*
 	 * QI_USB_VBUS_EN: control the priority of USB and WLC,
 	 *                 set to high after boot
 	 */
-	ret = of_get_named_gpio_flags(node, "idt,gpio_qi_vbus_en", 0, &flags);
-	pdata->qi_vbus_en = ret;
-	if (ret < 0) {
-		dev_warn(dev, "unable to read idt,gpio_qi_vbus_en from dt: %d\n",
-			 ret);
-	} else {
+	pdata->qi_vbus_en = p9221_parse_gpios(dev, "idt,qi_vbus_en-gpio", "idt,gpio_qi_vbus_en",
+					      &flags);
+	if (pdata->qi_vbus_en == -EPROBE_DEFER)
+		return -EPROBE_DEFER;
+	if (pdata->qi_vbus_en > 0) {
 		pdata->qi_vbus_en_act_low = (flags & OF_GPIO_ACTIVE_LOW) != 0;
 		dev_info(dev, "QI_USB_VBUS_EN gpio:%d(act_low=%d)",
 			 pdata->qi_vbus_en, pdata->qi_vbus_en_act_low);
 	}
 
 	/* Enable/Disable WLC chip(for P9XXX_GPIO_VBUS_EN) */
-	ret = of_get_named_gpio_flags(node, "idt,gpio_wlc_en", 0, &flags);
-	pdata->wlc_en = ret;
-	if (ret < 0) {
-		dev_warn(dev, "unable to read idt,gpio_wlc_en from dt: %d\n",
-			 ret);
-	} else {
+	pdata->wlc_en = p9221_parse_gpios(dev, "idt,wlc_en-gpio", "idt,gpio_wlc_en", &flags);
+	if (pdata->wlc_en == -EPROBE_DEFER)
+		return -EPROBE_DEFER;
+	if (pdata->wlc_en > 0) {
 		pdata->wlc_en_act_low = (flags & OF_GPIO_ACTIVE_LOW) != 0;
 		dev_info(dev, "WLC enable/disable pin:%d", pdata->wlc_en);
 	}
 
 	/* WLC_BPP_EPP_SLCT */
-	ret = of_get_named_gpio(node, "idt,gpio_slct", 0);
-	pdata->slct_gpio = ret;
-	if (ret < 0) {
-		dev_warn(dev, "unable to read idt,gpio_slct from dt: %d\n",
-			 ret);
-	} else {
+	pdata->slct_gpio = p9221_parse_gpios(dev, "idt,slct-gpio", "idt,gpio_slct", &flags);
+	if (pdata->slct_gpio == -EPROBE_DEFER)
+		return -EPROBE_DEFER;
+	if (pdata->slct_gpio > 0) {
 		ret = of_property_read_u32(node, "idt,gpio_slct_value", &data);
 		if (ret == 0)
 			pdata->slct_value = (data != 0);
-
 		dev_info(dev, "WLC_BPP_EPP_SLCT gpio:%d value=%d",
-					pdata->slct_gpio, pdata->slct_value);
+			 pdata->slct_gpio, pdata->slct_value);
 	}
 
 	/* RTx: idt,gpio_ben / idt,gpio_switch / idt,gpio_boost */
@@ -6269,46 +6285,42 @@ static int p9221_parse_dt(struct device *dev,
 	dev_info(dev, "has_rtx:%d\n", pdata->has_rtx);
 
 	/* boost enable, power WLC IC from device */
-	ret = of_get_named_gpio(node, "idt,gpio_ben", 0);
-	if (ret == -EPROBE_DEFER)
-		return ret;
-	pdata->ben_gpio = ret;
-	if (ret >= 0)
+	pdata->ben_gpio = p9221_parse_gpios(dev, "idt,gpio-ben", "idt,gpio_ben", &flags);
+	if (pdata->ben_gpio == -EPROBE_DEFER)
+		return -EPROBE_DEFER;
+	if (pdata->ben_gpio > 0)
 		dev_info(dev, "ben gpio:%d\n", pdata->ben_gpio);
 
-	ret = of_get_named_gpio(node, "idt,gpio_switch", 0);
-	if (ret == -EPROBE_DEFER)
-		return ret;
-	pdata->switch_gpio = ret;
-	if (ret >= 0)
+	pdata->switch_gpio = p9221_parse_gpios(dev, "idt,switch-gpio", "idt,gpio_switch", &flags);
+	if (pdata->switch_gpio == -EPROBE_DEFER)
+		return -EPROBE_DEFER;
+	if (pdata->switch_gpio > 0)
 		dev_info(dev, "switch gpio:%d\n", pdata->switch_gpio);
 
 	/* boost gpio sets rtx at charging voltage level */
-	ret = of_get_named_gpio(node, "idt,gpio_boost", 0);
-	if (ret == -EPROBE_DEFER)
-		return ret;
-	pdata->boost_gpio = ret;
-	if (ret >= 0)
+	pdata->boost_gpio = p9221_parse_gpios(dev, "idt,boost-gpio", "idt,gpio_boost", &flags);
+	if (pdata->boost_gpio == -EPROBE_DEFER)
+		return -EPROBE_DEFER;
+	if (pdata->boost_gpio > 0)
 		dev_info(dev, "boost gpio:%d\n", pdata->boost_gpio);
 
 	/* configure boost to 7V through wlc chip */
 	pdata->apbst_en = of_property_read_bool(node, "idt,apbst_en");
 
-	ret = of_get_named_gpio(node, "idt,gpio_extben", 0);
-	if (ret == -EPROBE_DEFER)
-		return ret;
-	pdata->ext_ben_gpio = ret;
-	if (ret >= 0) {
+	pdata->ext_ben_gpio = p9221_parse_gpios(dev, "idt,extben-gpio", "idt,gpio_extben", &flags);
+	if (pdata->ext_ben_gpio == -EPROBE_DEFER)
+		return -EPROBE_DEFER;
+	if (pdata->ext_ben_gpio > 0) {
 		ret = gpio_request(pdata->ext_ben_gpio, "wc_ref");
 		dev_info(dev, "ext ben gpio:%d, ret=%d\n", pdata->ext_ben_gpio, ret);
 	}
 
 	/* DC-PPS */
-	ret = of_get_named_gpio(node, "idt,gpio_dc_switch", 0);
-	if (ret == -EPROBE_DEFER)
-		return ret;
-	pdata->dc_switch_gpio = ret;
-	if (ret >= 0)
+	pdata->dc_switch_gpio = p9221_parse_gpios(dev, "idt,dc_switch-gpio", "idt,gpio_dc_switch",
+						  &flags);
+	if (pdata->dc_switch_gpio == -EPROBE_DEFER)
+		return -EPROBE_DEFER;
+	if (pdata->dc_switch_gpio > 0)
 		dev_info(dev, "dc_switch gpio:%d\n", pdata->dc_switch_gpio);
 
 	ret = of_property_read_u32(node, "idt,has_wlc_dc", &data);
@@ -6319,23 +6331,20 @@ static int p9221_parse_dt(struct device *dev,
 	dev_info(dev, "has_wlc_dc:%d\n", pdata->has_wlc_dc);
 
 	/* Main IRQ */
-	ret = of_get_named_gpio(node, "idt,irq_gpio", 0);
-	if (ret < 0) {
-		dev_err(dev, "unable to read idt,irq_gpio from dt: %d\n", ret);
-		return ret;
+	pdata->irq_gpio = p9221_parse_gpios(dev, "idt,irq-gpio", "idt,irq_gpio", &flags);
+	if (pdata->irq_gpio == -EPROBE_DEFER)
+		return -EPROBE_DEFER;
+	if (pdata->irq_gpio > 0) {
+		pdata->irq_int = gpio_to_irq(pdata->irq_gpio);
+		dev_info(dev, "gpio:%d, gpio_irq:%d\n", pdata->irq_gpio, pdata->irq_int);
 	}
-	pdata->irq_gpio = ret;
-	pdata->irq_int = gpio_to_irq(pdata->irq_gpio);
-	dev_info(dev, "gpio:%d, gpio_irq:%d\n", pdata->irq_gpio,
-		 pdata->irq_int);
 
 	/* Optional Detect IRQ */
-	ret = of_get_named_gpio(node, "idt,irq_det_gpio", 0);
-	pdata->irq_det_gpio = ret;
-	if (ret < 0) {
-		dev_warn(dev, "unable to read idt,irq_det_gpio from dt: %d\n",
-			 ret);
-	} else {
+	pdata->irq_det_gpio = p9221_parse_gpios(dev, "idt,irq_det-gpio", "idt,irq_det_gpio",
+						&flags);
+	if (pdata->irq_det_gpio == -EPROBE_DEFER)
+		return -EPROBE_DEFER;
+	if (pdata->irq_det_gpio > 0) {
 		pdata->irq_det_int = gpio_to_irq(pdata->irq_det_gpio);
 		dev_info(dev, "det gpio:%d, det gpio_irq:%d\n",
 			 pdata->irq_det_gpio, pdata->irq_det_int);