of_batterydata: Add snapshot of of_batterydata library (1b073790) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/of/Kconfig

+5 −0

Original line number	Diff line number	Diff line
		@@ -109,4 +109,9 @@ config OF_OVERLAY
		config OF_NUMA
		bool

		config OF_BATTERYDATA
		def_bool y
		help
		OpenFirmware BatteryData accessors

		endif # OF

drivers/of/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -14,5 +14,6 @@ obj-$(CONFIG_OF_RESERVED_MEM) += of_reserved_mem.o
		obj-$(CONFIG_OF_RESOLVE) += resolver.o
		obj-$(CONFIG_OF_OVERLAY) += overlay.o
		obj-$(CONFIG_OF_NUMA) += of_numa.o
		obj-$(CONFIG_OF_BATTERYDATA) += of_batterydata.o

		obj-$(CONFIG_OF_UNITTEST) += unittest-data/

drivers/of/of_batterydata.c

0 → 100644

+450 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		/*
		* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved.
		*/

		#define pr_fmt(fmt) "%s: " fmt, __func__

		#include <linux/err.h>
		#include <linux/of.h>
		#include <linux/slab.h>
		#include <linux/module.h>
		#include <linux/types.h>
		#include <linux/batterydata-lib.h>
		#include <linux/power_supply.h>

		static int of_batterydata_read_lut(const struct device_node *np,
		int max_cols, int max_rows, int ncols, int nrows,
		int col_legend_data, int row_legend_data,
		int *lut_data)
		{
		struct property *prop;
		const __be32 *data;
		int cols, rows, size, i, j, *out_values;

		prop = of_find_property(np, "qcom,lut-col-legend", NULL);
		if (!prop) {
		pr_err("%s: No col legend found\n", np->name);
		return -EINVAL;
		} else if (!prop->value) {
		pr_err("%s: No col legend value found, np->name\n", np->name);
		return -ENODATA;
		} else if (prop->length > max_cols * sizeof(int)) {
		pr_err("%s: Too many columns\n", np->name);
		return -EINVAL;
		}

		cols = prop->length/sizeof(int);
		*ncols = cols;
		data = prop->value;
		for (i = 0; i < cols; i++)
		*col_legend_data++ = be32_to_cpup(data++);

		rows = 0;

		prop = of_find_property(np, "qcom,lut-row-legend", NULL);
		if (!prop \|\| row_legend_data == NULL) {
		/* single row lut */
		rows = 1;
		} else if (!prop->value) {
		pr_err("%s: No row legend value found\n", np->name);
		return -ENODATA;
		} else if (prop->length > max_rows * sizeof(int)) {
		pr_err("%s: Too many rows\n", np->name);
		return -EINVAL;
		}

		if (rows != 1) {
		rows = prop->length/sizeof(int);
		*nrows = rows;
		data = prop->value;
		for (i = 0; i < rows; i++)
		*row_legend_data++ = be32_to_cpup(data++);
		}

		prop = of_find_property(np, "qcom,lut-data", NULL);
		if (!prop) {
		pr_err("prop 'qcom,lut-data' not found\n");
		return -EINVAL;
		}
		data = prop->value;
		size = prop->length/sizeof(int);
		if (size != cols * rows) {
		pr_err("%s: data size mismatch, %dx%d != %d\n",
		np->name, cols, rows, size);
		return -EINVAL;
		}
		for (i = 0; i < rows; i++) {
		out_values = lut_data + (max_cols * i);
		for (j = 0; j < cols; j++) {
		*out_values++ = be32_to_cpup(data++);
		pr_debug("Value = %d\n", *(out_values-1));
		}
		}

		return 0;
		}

		static int of_batterydata_read_sf_lut(struct device_node *data_node,
		const char name, struct sf_lut lut)
		{
		struct device_node *node = of_find_node_by_name(data_node, name);
		int rc;

		if (!lut) {
		pr_debug("No lut provided, skipping\n");
		return 0;
		} else if (!node) {
		pr_err("Couldn't find %s node.\n", name);
		return -EINVAL;
		}

		rc = of_batterydata_read_lut(node, PC_CC_COLS, PC_CC_ROWS,
		&lut->cols, &lut->rows, lut->row_entries,
		lut->percent, *lut->sf);
		if (rc) {
		pr_err("Failed to read %s node.\n", name);
		return rc;
		}

		return 0;
		}

		static int of_batterydata_read_pc_temp_ocv_lut(struct device_node *data_node,
		const char name, struct pc_temp_ocv_lut lut)
		{
		struct device_node *node = of_find_node_by_name(data_node, name);
		int rc;

		if (!lut) {
		pr_debug("No lut provided, skipping\n");
		return 0;
		} else if (!node) {
		pr_err("Couldn't find %s node.\n", name);
		return -EINVAL;
		}
		rc = of_batterydata_read_lut(node, PC_TEMP_COLS, PC_TEMP_ROWS,
		&lut->cols, &lut->rows, lut->temp, lut->percent,
		*lut->ocv);
		if (rc) {
		pr_err("Failed to read %s node.\n", name);
		return rc;
		}

		return 0;
		}

		static int of_batterydata_read_ibat_temp_acc_lut(struct device_node *data_node,
		const char name, struct ibat_temp_acc_lut lut)
		{
		struct device_node *node = of_find_node_by_name(data_node, name);
		int rc;

		if (!lut) {
		pr_debug("No lut provided, skipping\n");
		return 0;
		} else if (!node) {
		pr_debug("Couldn't find %s node.\n", name);
		return 0;
		}
		rc = of_batterydata_read_lut(node, ACC_TEMP_COLS, ACC_IBAT_ROWS,
		&lut->cols, &lut->rows, lut->temp, lut->ibat,
		*lut->acc);
		if (rc) {
		pr_err("Failed to read %s node.\n", name);
		return rc;
		}

		return 0;
		}

		static int of_batterydata_read_single_row_lut(struct device_node *data_node,
		const char name, struct single_row_lut lut)
		{
		struct device_node *node = of_find_node_by_name(data_node, name);
		int rc;

		if (!lut) {
		pr_debug("No lut provided, skipping\n");
		return 0;
		} else if (!node) {
		pr_err("Couldn't find %s node.\n", name);
		return -EINVAL;
		}

		rc = of_batterydata_read_lut(node, MAX_SINGLE_LUT_COLS, 1,
		&lut->cols, NULL, lut->x, NULL, lut->y);
		if (rc) {
		pr_err("Failed to read %s node.\n", name);
		return rc;
		}

		return 0;
		}

		static int of_batterydata_read_batt_id_kohm(const struct device_node *np,
		const char propname, struct batt_ids batt_ids)
		{
		struct property *prop;
		const __be32 *data;
		int num, i, *id_kohm = batt_ids->kohm;

		prop = of_find_property(np, "qcom,batt-id-kohm", NULL);
		if (!prop) {
		pr_err("%s: No battery id resistor found\n", np->name);
		return -EINVAL;
		} else if (!prop->value) {
		pr_err("%s: No battery id resistor value found, np->name\n",
		np->name);
		return -ENODATA;
		} else if (prop->length > MAX_BATT_ID_NUM * sizeof(__be32)) {
		pr_err("%s: Too many battery id resistors\n", np->name);
		return -EINVAL;
		}

		num = prop->length/sizeof(__be32);
		batt_ids->num = num;
		data = prop->value;
		for (i = 0; i < num; i++)
		*id_kohm++ = be32_to_cpup(data++);

		return 0;
		}

		#define OF_PROP_READ(property, qpnp_dt_property, node, rc, optional) \
		do { \
		if (rc) \
		break; \
		rc = of_property_read_u32(node, "qcom," qpnp_dt_property, \
		&property); \
		\
		if ((rc == -EINVAL) && optional) { \
		property = -EINVAL; \
		rc = 0; \
		} else if (rc) { \
		pr_err("Error reading " #qpnp_dt_property \
		" property rc = %d\n", rc); \
		} \
		} while (0)

		static int of_batterydata_load_battery_data(struct device_node *node,
		int best_id_kohm,
		struct bms_battery_data *batt_data)
		{
		int rc;

		rc = of_batterydata_read_single_row_lut(node, "qcom,fcc-temp-lut",
		batt_data->fcc_temp_lut);
		if (rc)
		return rc;

		rc = of_batterydata_read_pc_temp_ocv_lut(node,
		"qcom,pc-temp-ocv-lut",
		batt_data->pc_temp_ocv_lut);
		if (rc)
		return rc;

		rc = of_batterydata_read_sf_lut(node, "qcom,rbatt-sf-lut",
		batt_data->rbatt_sf_lut);
		if (rc)
		return rc;

		rc = of_batterydata_read_ibat_temp_acc_lut(node, "qcom,ibat-acc-lut",
		batt_data->ibat_acc_lut);
		if (rc)
		return rc;

		rc = of_property_read_string(node, "qcom,battery-type",
		&batt_data->battery_type);
		if (rc) {
		pr_err("Error reading qcom,battery-type property rc=%d\n", rc);
		batt_data->battery_type = NULL;
		return rc;
		}

		OF_PROP_READ(batt_data->fcc, "fcc-mah", node, rc, false);
		OF_PROP_READ(batt_data->default_rbatt_mohm,
		"default-rbatt-mohm", node, rc, false);
		OF_PROP_READ(batt_data->rbatt_capacitive_mohm,
		"rbatt-capacitive-mohm", node, rc, false);
		OF_PROP_READ(batt_data->flat_ocv_threshold_uv,
		"flat-ocv-threshold-uv", node, rc, true);
		OF_PROP_READ(batt_data->max_voltage_uv,
		"max-voltage-uv", node, rc, true);
		OF_PROP_READ(batt_data->cutoff_uv, "v-cutoff-uv", node, rc, true);
		OF_PROP_READ(batt_data->iterm_ua, "chg-term-ua", node, rc, true);
		OF_PROP_READ(batt_data->fastchg_current_ma,
		"fastchg-current-ma", node, rc, true);
		OF_PROP_READ(batt_data->fg_cc_cv_threshold_mv,
		"fg-cc-cv-threshold-mv", node, rc, true);

		batt_data->batt_id_kohm = best_id_kohm;

		return rc;
		}

		static int64_t of_batterydata_convert_battery_id_kohm(int batt_id_uv,
		int rpull_up, int vadc_vdd)
		{
		int64_t resistor_value_kohm, denom;

		if (batt_id_uv == 0) {
		/* vadc not correct or batt id line grounded, report 0 kohms */
		return 0;
		}
		/* calculate the battery id resistance reported via ADC */
		denom = div64_s64(vadc_vdd * 1000000LL, batt_id_uv) - 1000000LL;

		if (denom == 0) {
		/* batt id connector might be open, return 0 kohms */
		return 0;
		}
		resistor_value_kohm = div64_s64(rpull_up * 1000000LL + denom/2, denom);

		pr_debug("batt id voltage = %d, resistor value = %lld\n",
		batt_id_uv, resistor_value_kohm);

		return resistor_value_kohm;
		}

		struct device_node *of_batterydata_get_best_profile(
		const struct device_node *batterydata_container_node,
		int batt_id_kohm, const char *batt_type)
		{
		struct batt_ids batt_ids;
		struct device_node node, best_node = NULL;
		const char *battery_type = NULL;
		int delta = 0, best_delta = 0, best_id_kohm = 0, id_range_pct,
		i = 0, rc = 0, limit = 0;
		bool in_range = false;

		/* read battery id range percentage for best profile */
		rc = of_property_read_u32(batterydata_container_node,
		"qcom,batt-id-range-pct", &id_range_pct);

		if (rc) {
		if (rc == -EINVAL) {
		id_range_pct = 0;
		} else {
		pr_err("failed to read battery id range\n");
		return ERR_PTR(-ENXIO);
		}
		}

		/*
		* Find the battery data with a battery id resistor closest to this one
		*/
		for_each_child_of_node(batterydata_container_node, node) {
		if (batt_type != NULL) {
		rc = of_property_read_string(node, "qcom,battery-type",
		&battery_type);
		if (!rc && strcmp(battery_type, batt_type) == 0) {
		best_node = node;
		best_id_kohm = batt_id_kohm;
		break;
		}
		} else {
		rc = of_batterydata_read_batt_id_kohm(node,
		"qcom,batt-id-kohm",
		&batt_ids);
		if (rc)
		continue;
		for (i = 0; i < batt_ids.num; i++) {
		delta = abs(batt_ids.kohm[i] - batt_id_kohm);
		limit = (batt_ids.kohm[i] * id_range_pct) / 100;
		in_range = (delta <= limit);
		/*
		* Check if the delta is the lowest one
		* and also if the limits are in range
		* before selecting the best node.
		*/
		if ((delta < best_delta \|\| !best_node)
		&& in_range) {
		best_node = node;
		best_delta = delta;
		best_id_kohm = batt_ids.kohm[i];
		}
		}
		}
		}

		if (best_node == NULL) {
		pr_err("No battery data found\n");
		return best_node;
		}

		/* check that profile id is in range of the measured batt_id */
		if (abs(best_id_kohm - batt_id_kohm) >
		((best_id_kohm * id_range_pct) / 100)) {
		pr_err("out of range: profile id %d batt id %d pct %d\n",
		best_id_kohm, batt_id_kohm, id_range_pct);
		return NULL;
		}

		rc = of_property_read_string(best_node, "qcom,battery-type",
		&battery_type);
		if (!rc)
		pr_info("%s found\n", battery_type);
		else
		pr_info("%s found\n", best_node->name);

		return best_node;
		}

		int of_batterydata_read_data(struct device_node *batterydata_container_node,
		struct bms_battery_data *batt_data,
		int batt_id_uv)
		{
		struct device_node node, best_node;
		struct batt_ids batt_ids;
		const char *battery_type = NULL;
		int delta, best_delta, batt_id_kohm, rpull_up_kohm,
		vadc_vdd_uv, best_id_kohm, i, rc = 0;

		node = batterydata_container_node;
		OF_PROP_READ(rpull_up_kohm, "rpull-up-kohm", node, rc, false);
		OF_PROP_READ(vadc_vdd_uv, "vref-batt-therm", node, rc, false);
		if (rc)
		return rc;

		batt_id_kohm = of_batterydata_convert_battery_id_kohm(batt_id_uv,
		rpull_up_kohm, vadc_vdd_uv);
		best_node = NULL;
		best_delta = 0;
		best_id_kohm = 0;

		/*
		* Find the battery data with a battery id resistor closest to this one
		*/
		for_each_child_of_node(batterydata_container_node, node) {
		rc = of_batterydata_read_batt_id_kohm(node,
		"qcom,batt-id-kohm",
		&batt_ids);
		if (rc)
		continue;
		for (i = 0; i < batt_ids.num; i++) {
		delta = abs(batt_ids.kohm[i] - batt_id_kohm);
		if (delta < best_delta \|\| !best_node) {
		best_node = node;
		best_delta = delta;
		best_id_kohm = batt_ids.kohm[i];
		}
		}
		}

		if (best_node == NULL) {
		pr_err("No battery data found\n");
		return -ENODATA;
		}
		rc = of_property_read_string(best_node, "qcom,battery-type",
		&battery_type);
		if (!rc)
		pr_info("%s loaded\n", battery_type);
		else
		pr_info("%s loaded\n", best_node->name);

		return of_batterydata_load_battery_data(best_node,
		best_id_kohm, batt_data);
		}

		MODULE_LICENSE("GPL v2");

include/linux/batterydata-lib.h

0 → 100644

+211 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 */
		/*
		* Copyright (c) 2012-2015, 2017 The Linux Foundation. All rights reserved.
		*/

		#ifndef __BMS_BATTERYDATA_H
		#define __BMS_BATTERYDATA_H

		#include <linux/errno.h>

		#define FCC_CC_COLS 5
		#define FCC_TEMP_COLS 8

		#define PC_CC_ROWS 31
		#define PC_CC_COLS 13

		#define PC_TEMP_ROWS 31
		#define PC_TEMP_COLS 8

		#define ACC_IBAT_ROWS 4
		#define ACC_TEMP_COLS 3

		#define MAX_SINGLE_LUT_COLS 20

		#define MAX_BATT_ID_NUM 4
		#define DEGC_SCALE 10

		struct single_row_lut {
		int x[MAX_SINGLE_LUT_COLS];
		int y[MAX_SINGLE_LUT_COLS];
		int cols;
		};

		/**
		* struct sf_lut -
		* @rows: number of percent charge entries should be <= PC_CC_ROWS
		* @cols: number of charge cycle entries should be <= PC_CC_COLS
		* @row_entries: the charge cycles/temperature at which sf data
		* is available in the table.
		* The charge cycles must be in increasing order from 0 to rows.
		* @percent: the percent charge at which sf data is available in the table
		* The percentcharge must be in decreasing order from 0 to cols.
		* @sf: the scaling factor data
		*/
		struct sf_lut {
		int rows;
		int cols;
		int row_entries[PC_CC_COLS];
		int percent[PC_CC_ROWS];
		int sf[PC_CC_ROWS][PC_CC_COLS];
		};

		/**
		* struct pc_temp_ocv_lut -
		* @rows: number of percent charge entries should be <= PC_TEMP_ROWS
		* @cols: number of temperature entries should be <= PC_TEMP_COLS
		* @temp: the temperatures at which ocv data is available in the table
		* The temperatures must be in increasing order from 0 to rows.
		* @percent: the percent charge at which ocv data is available in the table
		* The percentcharge must be in decreasing order from 0 to cols.
		* @ocv: the open circuit voltage
		*/
		struct pc_temp_ocv_lut {
		int rows;
		int cols;
		int temp[PC_TEMP_COLS];
		int percent[PC_TEMP_ROWS];
		int ocv[PC_TEMP_ROWS][PC_TEMP_COLS];
		};

		struct ibat_temp_acc_lut {
		int rows;
		int cols;
		int temp[ACC_TEMP_COLS];
		int ibat[ACC_IBAT_ROWS];
		int acc[ACC_IBAT_ROWS][ACC_TEMP_COLS];
		};

		struct batt_ids {
		int kohm[MAX_BATT_ID_NUM];
		int num;
		};

		enum battery_type {
		BATT_UNKNOWN = 0,
		BATT_PALLADIUM,
		BATT_DESAY,
		BATT_OEM,
		BATT_QRD_4V35_2000MAH,
		BATT_QRD_4V2_1300MAH,
		};

		/**
		* struct bms_battery_data -
		* @fcc: full charge capacity (mAmpHour)
		* @fcc_temp_lut: table to get fcc at a given temp
		* @pc_temp_ocv_lut: table to get percent charge given batt temp and cycles
		* @pc_sf_lut: table to get percent charge scaling factor given cycles
		* and percent charge
		* @rbatt_sf_lut: table to get battery resistance scaling factor given
		* temperature and percent charge
		* @default_rbatt_mohm: the default value of battery resistance to use when
		* readings from bms are not available.
		* @delta_rbatt_mohm: the resistance to be added towards lower soc to
		* compensate for battery capacitance.
		* @rbatt_capacitve_mohm: the resistance to be added to compensate for
		* battery capacitance
		* @flat_ocv_threshold_uv: the voltage where the battery's discharge curve
		* starts flattening out.
		* @max_voltage_uv: max voltage of the battery
		* @cutoff_uv: cutoff voltage of the battery
		* @iterm_ua: termination current of the battery when charging
		* to 100%
		* @batt_id_kohm: the best matched battery id resistor value
		* @fastchg_current_ma: maximum fast charge current
		* @fg_cc_cv_threshold_mv: CC to CV threashold voltage
		*/

		struct bms_battery_data {
		unsigned int fcc;
		struct single_row_lut *fcc_temp_lut;
		struct single_row_lut *fcc_sf_lut;
		struct pc_temp_ocv_lut *pc_temp_ocv_lut;
		struct ibat_temp_acc_lut *ibat_acc_lut;
		struct sf_lut *pc_sf_lut;
		struct sf_lut *rbatt_sf_lut;
		int default_rbatt_mohm;
		int delta_rbatt_mohm;
		int rbatt_capacitive_mohm;
		int flat_ocv_threshold_uv;
		int max_voltage_uv;
		int cutoff_uv;
		int iterm_ua;
		int batt_id_kohm;
		int fastchg_current_ma;
		int fg_cc_cv_threshold_mv;
		const char *battery_type;
		};

		#define is_between(left, right, value) \
		(((left) >= (right) && (left) >= (value) \
		&& (value) >= (right)) \
		\|\| ((left) <= (right) && (left) <= (value) \
		&& (value) <= (right)))

		#if defined(CONFIG_PM8921_BMS) \|\| \
		defined(CONFIG_PM8921_BMS_MODULE) \|\| \
		defined(CONFIG_QPNP_BMS) \|\| \
		defined(CONFIG_QPNP_VM_BMS)
		extern struct bms_battery_data palladium_1500_data;
		extern struct bms_battery_data desay_5200_data;
		extern struct bms_battery_data oem_batt_data;
		extern struct bms_battery_data QRD_4v35_2000mAh_data;
		extern struct bms_battery_data qrd_4v2_1300mah_data;

		int interpolate_fcc(struct single_row_lut *fcc_temp_lut, int batt_temp);
		int interpolate_scalingfactor(struct sf_lut *sf_lut, int row_entry, int pc);
		int interpolate_scalingfactor_fcc(struct single_row_lut *fcc_sf_lut,
		int cycles);
		int interpolate_pc(struct pc_temp_ocv_lut *pc_temp_ocv,
		int batt_temp_degc, int ocv);
		int interpolate_ocv(struct pc_temp_ocv_lut *pc_temp_ocv,
		int batt_temp_degc, int pc);
		int interpolate_slope(struct pc_temp_ocv_lut *pc_temp_ocv,
		int batt_temp, int pc);
		int interpolate_acc(struct ibat_temp_acc_lut *ibat_acc_lut,
		int batt_temp, int ibat);
		int linear_interpolate(int y0, int x0, int y1, int x1, int x);
		#else
		static inline int interpolate_fcc(struct single_row_lut *fcc_temp_lut,
		int batt_temp)
		{
		return -EINVAL;
		}
		static inline int interpolate_scalingfactor(struct sf_lut *sf_lut,
		int row_entry, int pc)
		{
		return -EINVAL;
		}
		static inline int interpolate_scalingfactor_fcc(
		struct single_row_lut *fcc_sf_lut, int cycles)
		{
		return -EINVAL;
		}
		static inline int interpolate_pc(struct pc_temp_ocv_lut *pc_temp_ocv,
		int batt_temp_degc, int ocv)
		{
		return -EINVAL;
		}
		static inline int interpolate_ocv(struct pc_temp_ocv_lut *pc_temp_ocv,
		int batt_temp_degc, int pc)
		{
		return -EINVAL;
		}
		static inline int interpolate_slope(struct pc_temp_ocv_lut *pc_temp_ocv,
		int batt_temp, int pc)
		{
		return -EINVAL;
		}
		static inline int linear_interpolate(int y0, int x0, int y1, int x1, int x)
		{
		return -EINVAL;
		}
		static inline int interpolate_acc(struct ibat_temp_acc_lut *ibat_acc_lut,
		int batt_temp, int ibat)
		{
		return -EINVAL;
		}
		#endif

		#endif

include/linux/of_batterydata.h

0 → 100644

+57 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 */
		/*
		* Copyright (c) 2013-2014, 2016-2018 The Linux Foundation. All rights reserved.
		*/

		#include <linux/of.h>
		#include <linux/batterydata-lib.h>

		#ifdef CONFIG_OF_BATTERYDATA
		/**
		* of_batterydata_read_data() - Populate battery data from the device tree
		* @container_node: pointer to the battery-data container device node
		* containing the profile nodes.
		* @batt_data: pointer to an allocated bms_battery_data structure that the
		* loaded profile will be written to.
		* @batt_id_uv: ADC voltage of the battery id line used to differentiate
		* between different battery profiles. If there are multiple
		* battery data in the device tree, the one with the closest
		* battery id resistance will be automatically loaded.
		*
		* This routine loads the closest match battery data from device tree based on
		* the battery id reading. Then, it will try to load all the relevant data from
		* the device tree battery data profile.
		*
		* If any of the lookup table pointers are NULL, this routine will skip trying
		* to read them.
		*/
		int of_batterydata_read_data(struct device_node *container_node,
		struct bms_battery_data *batt_data,
		int batt_id_uv);
		/**
		* of_batterydata_get_best_profile() - Find matching battery data device node
		* @batterydata_container_node: pointer to the battery-data container device
		* node containing the profile nodes.
		* @batt_id_kohm: Battery ID in KOhms for which we want to find the profile.
		* @batt_type: Battery type which we want to force load the profile.
		*
		* This routine returns a device_node pointer to the closest match battery data
		* from device tree based on the battery id reading.
		*/
		struct device_node *of_batterydata_get_best_profile(
		struct device_node *batterydata_container_node,
		int batt_id_kohm, const char *batt_type);
		#else
		static inline int of_batterydata_read_data(struct device_node *container_node,
		struct bms_battery_data *batt_data,
		int batt_id_uv)
		{
		return -ENXIO;
		}
		static inline struct device_node *of_batterydata_get_best_profile(
		struct device_node *batterydata_container_node,
		int batt_id_kohm, const char *batt_type)
		{
		return NULL;
		}
		#endif /* CONFIG_OF_BATTERYDATA */