LWIS: Use IS_ERR_OR_NULL instead of IS_ERRandroid-u-beta-2_r0.4android-u-beta-2_r0.3android-u-beta-2_r0.2

In most cases, we don't expect to get a NULL return. So, when we
check if the return pointer is an error or not, we should check if
it is NULL or not, too.

Bug: 277152200
Test: GCA, CTS
Change-Id: I138503873e35a46ed48aded41354d132fe9111b1
Signed-off-by: Holmes Chou <holmeschou@google.com>

12 files changed, 33 insertions, 33 deletions

diff --git a/lwis_clock.c b/lwis_clock.c
index 4a9dc18..e03fe9d 100644
--- a/lwis_clock.c
+++ b/lwis_clock.c
@@ -82,7 +82,7 @@ int lwis_clock_get(struct lwis_clock_list *list, char *name, struct device *dev,
 
 	/* Make sure clock exists */
 	clk = devm_clk_get(dev, name);
-	if (IS_ERR(clk)) {
+	if (IS_ERR_OR_NULL(clk)) {
 		pr_err("Clock %s not found\n", name);
 		return PTR_ERR(clk);
 	}
diff --git a/lwis_device.c b/lwis_device.c
index d2963aa..b4c8a44 100644
--- a/lwis_device.c
+++ b/lwis_device.c
@@ -617,7 +617,7 @@ int lwis_dev_process_power_sequence(struct lwis_device *lwis_dev,
 
 			gpios_info = lwis_gpios_get_info_by_name(lwis_dev->gpios_list,
 								 list->seq_info[i].name);
-			if (IS_ERR(gpios_info)) {
+			if (IS_ERR_OR_NULL(gpios_info)) {
 				dev_err(lwis_dev->dev, "Get %s gpios info failed\n",
 					list->seq_info[i].name);
 				ret = PTR_ERR(gpios_info);
@@ -693,7 +693,7 @@ int lwis_dev_process_power_sequence(struct lwis_device *lwis_dev,
 						gpios_info_it = lwis_gpios_get_info_by_name(
 							lwis_dev_it->gpios_list,
 							list->seq_info[i].name);
-						if (IS_ERR(gpios_info_it)) {
+						if (IS_ERR_OR_NULL(gpios_info_it)) {
 							continue;
 						}
 						if (gpios_info_it->id == gpios_info->id &&
@@ -752,7 +752,7 @@ int lwis_dev_process_power_sequence(struct lwis_device *lwis_dev,
 
 			if (set_active) {
 				lwis_dev->mclk_ctrl = devm_pinctrl_get(&lwis_dev->plat_dev->dev);
-				if (IS_ERR(lwis_dev->mclk_ctrl)) {
+				if (IS_ERR_OR_NULL(lwis_dev->mclk_ctrl)) {
 					dev_err(lwis_dev->dev, "Failed to get mclk\n");
 					ret = PTR_ERR(lwis_dev->mclk_ctrl);
 					lwis_dev->mclk_ctrl = NULL;
@@ -923,7 +923,7 @@ static int lwis_dev_power_up_by_default(struct lwis_device *lwis_dev)
 		bool activate_mclk = true;
 
 		lwis_dev->mclk_ctrl = devm_pinctrl_get(&lwis_dev->plat_dev->dev);
-		if (IS_ERR(lwis_dev->mclk_ctrl)) {
+		if (IS_ERR_OR_NULL(lwis_dev->mclk_ctrl)) {
 			dev_err(lwis_dev->dev, "Failed to get mclk\n");
 			ret = PTR_ERR(lwis_dev->mclk_ctrl);
 			lwis_dev->mclk_ctrl = NULL;
@@ -1516,7 +1516,7 @@ int lwis_base_probe(struct lwis_device *lwis_dev, struct platform_device *plat_d
 	/* Upon success initialization, create device for this instance */
 	lwis_dev->dev = device_create(core.dev_class, NULL, MKDEV(core.device_major, lwis_dev->id),
 				      lwis_dev, LWIS_DEVICE_NAME "-%s", lwis_dev->name);
-	if (IS_ERR(lwis_dev->dev)) {
+	if (IS_ERR_OR_NULL(lwis_dev->dev)) {
 		pr_err("Failed to create device\n");
 		ret = PTR_ERR(lwis_dev->dev);
 		goto error_init;
@@ -1602,7 +1602,7 @@ void lwis_base_unprobe(struct lwis_device *unprobe_lwis_dev)
 				lwis_dev->irq_gpios_info.gpios = NULL;
 			}
 			/* Destroy device */
-			if (!IS_ERR(lwis_dev->dev)) {
+			if (!IS_ERR_OR_NULL(lwis_dev->dev)) {
 				device_destroy(core.dev_class,
 					       MKDEV(core.device_major, lwis_dev->id));
 			}
@@ -1648,7 +1648,7 @@ static int __init lwis_register_base_device(void)
 
 	/* Create a device class*/
 	core.dev_class = class_create(THIS_MODULE, LWIS_CLASS_NAME);
-	if (IS_ERR(core.dev_class)) {
+	if (IS_ERR_OR_NULL(core.dev_class)) {
 		pr_err("Failed to create device class\n");
 		ret = PTR_ERR(core.dev_class);
 		goto error_class_create;
diff --git a/lwis_device_dpm.c b/lwis_device_dpm.c
index 0adda1f..deaaca3 100644
--- a/lwis_device_dpm.c
+++ b/lwis_device_dpm.c
@@ -167,7 +167,7 @@ int lwis_dpm_update_clock(struct lwis_device *lwis_dev, struct lwis_clk_setting
 			goto out;
 		}
 
-		if (IS_ERR(lwis_dev->clocks->clk[clk_index].clk)) {
+		if (IS_ERR_OR_NULL(lwis_dev->clocks->clk[clk_index].clk)) {
 			dev_err(lwis_dev->dev, "%s clk is invalid\n", lwis_dev->name);
 			ret = -EINVAL;
 			goto out;
diff --git a/lwis_device_i2c.c b/lwis_device_i2c.c
index 548a8d2..0135b05 100644
--- a/lwis_device_i2c.c
+++ b/lwis_device_i2c.c
@@ -213,7 +213,7 @@ static int lwis_i2c_device_setup(struct lwis_i2c_device *i2c_dev)
 	   pinctrl's are defined */
 	/* TODO: Need to figure out why this is parent's parent */
 	pinctrl = devm_pinctrl_get(dev->parent->parent);
-	if (IS_ERR(pinctrl)) {
+	if (IS_ERR_OR_NULL(pinctrl)) {
 		dev_err(i2c_dev->base_dev.dev, "Cannot instantiate pinctrl instance (%lu)\n",
 			PTR_ERR(pinctrl));
 		i2c_dev->state_pinctrl = NULL;
@@ -222,11 +222,11 @@ static int lwis_i2c_device_setup(struct lwis_i2c_device *i2c_dev)
 
 	/* Verify that on_i2c or off_i2c strings are present */
 	i2c_dev->pinctrl_default_state_only = false;
-	if (IS_ERR(pinctrl_lookup_state(pinctrl, I2C_OFF_STRING)) ||
-	    IS_ERR(pinctrl_lookup_state(pinctrl, I2C_ON_STRING))) {
+	if (IS_ERR_OR_NULL(pinctrl_lookup_state(pinctrl, I2C_OFF_STRING)) ||
+	    IS_ERR_OR_NULL(pinctrl_lookup_state(pinctrl, I2C_ON_STRING))) {
 		state = pinctrl_lookup_state(pinctrl, I2C_DEFAULT_STATE_STRING);
 		/* Default option also missing, return error */
-		if (IS_ERR(state)) {
+		if (IS_ERR_OR_NULL(state)) {
 			dev_err(i2c_dev->base_dev.dev,
 				"Pinctrl states {%s, %s, %s} not found (%lu)\n", I2C_OFF_STRING,
 				I2C_ON_STRING, I2C_DEFAULT_STATE_STRING, PTR_ERR(state));
diff --git a/lwis_device_slc.c b/lwis_device_slc.c
index 5b0dd53..5debf65 100644
--- a/lwis_device_slc.c
+++ b/lwis_device_slc.c
@@ -93,7 +93,7 @@ static int lwis_slc_enable(struct lwis_device *lwis_dev)
 
 	/* Initialize SLC partitions and get a handle */
 	slc_dev->partition_handle = pt_client_register(node, NULL, NULL);
-	if (IS_ERR(slc_dev->partition_handle)) {
+	if (IS_ERR_OR_NULL(slc_dev->partition_handle)) {
 		ret = PTR_ERR(slc_dev->partition_handle);
 		dev_err(lwis_dev->dev, "Failed to register PT client (%d)\n", ret);
 		slc_dev->partition_handle = NULL;
diff --git a/lwis_device_top.c b/lwis_device_top.c
index c1966b4..3a3b0c3 100644
--- a/lwis_device_top.c
+++ b/lwis_device_top.c
@@ -514,7 +514,7 @@ static int lwis_top_device_probe(struct platform_device *plat_dev)
 	kthread_init_worker(&top_dev->subscribe_worker);
 	top_dev->subscribe_worker_thread = kthread_run(
 		kthread_worker_fn, &top_dev->subscribe_worker, LWIS_SUBSCRIBER_THREAD_NAME);
-	if (IS_ERR(top_dev->subscribe_worker_thread)) {
+	if (IS_ERR_OR_NULL(top_dev->subscribe_worker_thread)) {
 		dev_err(top_dev->base_dev.dev, "subscribe kthread_run failed\n");
 		goto error_probe;
 	}
diff --git a/lwis_dt.c b/lwis_dt.c
index f3236f8..d6c4559 100644
--- a/lwis_dt.c
+++ b/lwis_dt.c
@@ -50,7 +50,7 @@ static int parse_gpios(struct lwis_device *lwis_dev, char *name, bool *is_presen
 	}
 
 	list = lwis_gpio_list_get(dev, name);
-	if (IS_ERR(list)) {
+	if (IS_ERR_OR_NULL(list)) {
 		pr_err("Error parsing GPIO list %s (%ld)\n", name, PTR_ERR(list));
 		return PTR_ERR(list);
 	}
@@ -103,14 +103,14 @@ static int parse_irq_gpios(struct lwis_device *lwis_dev)
 	}
 
 	gpios = lwis_gpio_list_get(dev, "irq");
-	if (IS_ERR(gpios)) {
+	if (IS_ERR_OR_NULL(gpios)) {
 		pr_err("Error parsing irq GPIO list (%ld)\n", PTR_ERR(gpios));
 		return PTR_ERR(gpios);
 	}
 	lwis_dev->irq_gpios_info.gpios = gpios;
 
 	lwis_dev->irq_gpios_info.irq_list = lwis_interrupt_list_alloc(lwis_dev, gpios->ndescs);
-	if (IS_ERR(lwis_dev->irq_gpios_info.irq_list)) {
+	if (IS_ERR_OR_NULL(lwis_dev->irq_gpios_info.irq_list)) {
 		ret = -ENOMEM;
 		lwis_dev->irq_gpios_info.irq_list = NULL;
 		pr_err("Failed to allocate irq list\n");
@@ -252,7 +252,7 @@ static int parse_regulators(struct lwis_device *lwis_dev)
 		of_property_count_elems_of_size(dev_node, "regulator-voltages", sizeof(u32));
 
 	lwis_dev->regulators = lwis_regulator_list_alloc(count);
-	if (IS_ERR(lwis_dev->regulators)) {
+	if (IS_ERR_OR_NULL(lwis_dev->regulators)) {
 		pr_err("Cannot allocate regulator list\n");
 		ret = PTR_ERR(lwis_dev->regulators);
 		lwis_dev->regulators = NULL;
@@ -312,7 +312,7 @@ static int parse_clocks(struct lwis_device *lwis_dev)
 	}
 
 	lwis_dev->clocks = lwis_clock_list_alloc(count);
-	if (IS_ERR(lwis_dev->clocks)) {
+	if (IS_ERR_OR_NULL(lwis_dev->clocks)) {
 		pr_err("Cannot allocate clocks list\n");
 		ret = PTR_ERR(lwis_dev->clocks);
 		lwis_dev->clocks = NULL;
@@ -393,13 +393,13 @@ static int parse_pinctrls(struct lwis_device *lwis_dev, char *expected_state)
 
 	/* Set up pinctrl */
 	pc = devm_pinctrl_get(dev);
-	if (IS_ERR(pc)) {
+	if (IS_ERR_OR_NULL(pc)) {
 		pr_err("Cannot allocate pinctrl\n");
 		return PTR_ERR(pc);
 	}
 
 	pinctrl_state = pinctrl_lookup_state(pc, expected_state);
-	if (IS_ERR(pinctrl_state)) {
+	if (IS_ERR_OR_NULL(pinctrl_state)) {
 		pr_err("Cannot find pinctrl state %s\n", expected_state);
 		devm_pinctrl_put(pc);
 		return PTR_ERR(pinctrl_state);
@@ -653,7 +653,7 @@ static int parse_interrupts(struct lwis_device *lwis_dev)
 	}
 
 	lwis_dev->irqs = lwis_interrupt_list_alloc(lwis_dev, count);
-	if (IS_ERR(lwis_dev->irqs)) {
+	if (IS_ERR_OR_NULL(lwis_dev->irqs)) {
 		if (lwis_dev->type == DEVICE_TYPE_TEST) {
 			pr_err("Failed to allocate injection\n");
 		} else {
@@ -848,7 +848,7 @@ static int parse_phys(struct lwis_device *lwis_dev)
 	}
 
 	lwis_dev->phys = lwis_phy_list_alloc(count);
-	if (IS_ERR(lwis_dev->phys)) {
+	if (IS_ERR_OR_NULL(lwis_dev->phys)) {
 		pr_err("Failed to allocate PHY list\n");
 		ret = PTR_ERR(lwis_dev->phys);
 		lwis_dev->phys = NULL;
@@ -949,7 +949,7 @@ static int parse_power_seqs(struct lwis_device *lwis_dev, const char *seq_name,
 	}
 
 	*list = lwis_dev_power_seq_list_alloc(power_seq_count);
-	if (IS_ERR(*list)) {
+	if (IS_ERR_OR_NULL(*list)) {
 		pr_err("Failed to allocate power sequence list\n");
 		ret = PTR_ERR(*list);
 		*list = NULL;
@@ -990,7 +990,7 @@ static int parse_power_seqs(struct lwis_device *lwis_dev, const char *seq_name,
 
 	if (type_gpio_count > 0 && lwis_dev->gpios_list == NULL) {
 		lwis_dev->gpios_list = lwis_gpios_list_alloc(type_gpio_count);
-		if (IS_ERR(lwis_dev->gpios_list)) {
+		if (IS_ERR_OR_NULL(lwis_dev->gpios_list)) {
 			pr_err("Failed to allocate gpios list\n");
 			ret = PTR_ERR(lwis_dev->gpios_list);
 			goto error_parse_power_seqs;
@@ -1011,7 +1011,7 @@ static int parse_power_seqs(struct lwis_device *lwis_dev, const char *seq_name,
 			seq_item_name = (*list)->seq_info[i].name;
 			dev = &lwis_dev->plat_dev->dev;
 			descs = lwis_gpio_list_get(dev, seq_item_name);
-			if (IS_ERR(descs)) {
+			if (IS_ERR_OR_NULL(descs)) {
 				pr_err("Error parsing GPIO list %s (%ld)\n", seq_item_name,
 				       PTR_ERR(descs));
 				ret = PTR_ERR(descs);
@@ -1045,7 +1045,7 @@ static int parse_power_seqs(struct lwis_device *lwis_dev, const char *seq_name,
 
 	if (type_regulator_count > 0 && lwis_dev->regulators == NULL) {
 		lwis_dev->regulators = lwis_regulator_list_alloc(type_regulator_count);
-		if (IS_ERR(lwis_dev->regulators)) {
+		if (IS_ERR_OR_NULL(lwis_dev->regulators)) {
 			pr_err("Failed to allocate regulator list\n");
 			ret = PTR_ERR(lwis_dev->regulators);
 			goto error_parse_power_seqs;
diff --git a/lwis_i2c.c b/lwis_i2c.c
index aa8fb87..a3e3386 100644
--- a/lwis_i2c.c
+++ b/lwis_i2c.c
@@ -130,7 +130,7 @@ int lwis_i2c_set_state(struct lwis_i2c_device *i2c, const char *state_str)
 	state_to_set = i2c->pinctrl_default_state_only ? "default" : state_str;
 
 	state = pinctrl_lookup_state(i2c->state_pinctrl, state_to_set);
-	if (IS_ERR(state)) {
+	if (IS_ERR_OR_NULL(state)) {
 		dev_err(i2c->base_dev.dev, "State %s not found (%ld)\n", state_str, PTR_ERR(state));
 		return PTR_ERR(state);
 	}
diff --git a/lwis_phy.c b/lwis_phy.c
index 6e4830a..7f2b8be 100644
--- a/lwis_phy.c
+++ b/lwis_phy.c
@@ -83,7 +83,7 @@ int lwis_phy_get(struct lwis_phy_list *list, char *name, struct device *dev)
 
 	/* Make sure PHY exists */
 	phy = devm_phy_get(dev, name);
-	if (IS_ERR(phy)) {
+	if (IS_ERR_OR_NULL(phy)) {
 		pr_err("PHY %s not found\n", name);
 		return PTR_ERR(phy);
 	}
diff --git a/lwis_pinctrl.c b/lwis_pinctrl.c
index f8e758d..170912e 100644
--- a/lwis_pinctrl.c
+++ b/lwis_pinctrl.c
@@ -25,7 +25,7 @@ int lwis_pinctrl_set_state(struct pinctrl *pc, char *state_str)
 	}
 
 	state = pinctrl_lookup_state(pc, state_str);
-	if (IS_ERR(state)) {
+	if (IS_ERR_OR_NULL(state)) {
 		pr_err("Cannot find mclk state %s\n", state_str);
 		return PTR_ERR(state);
 	}
diff --git a/lwis_regulator.c b/lwis_regulator.c
index 9f3b6fc..56d9d92 100644
--- a/lwis_regulator.c
+++ b/lwis_regulator.c
@@ -81,7 +81,7 @@ int lwis_regulator_get(struct lwis_regulator_list *list, char *name, int voltage
 
 	/* Make sure regulator exists */
 	reg = devm_regulator_get(dev, name);
-	if (IS_ERR(reg)) {
+	if (IS_ERR_OR_NULL(reg)) {
 		return PTR_ERR(reg);
 	}
 
diff --git a/lwis_util.c b/lwis_util.c
index 26e8163..bb6e211 100644
--- a/lwis_util.c
+++ b/lwis_util.c
@@ -125,7 +125,7 @@ int lwis_create_kthread_workers(struct lwis_device *lwis_dev)
 	kthread_init_worker(&lwis_dev->transaction_worker);
 	lwis_dev->transaction_worker_thread =
 		kthread_run(kthread_worker_fn, &lwis_dev->transaction_worker, t_name);
-	if (IS_ERR(lwis_dev->transaction_worker_thread)) {
+	if (IS_ERR_OR_NULL(lwis_dev->transaction_worker_thread)) {
 		dev_err(lwis_dev->dev, "transaction kthread_run failed\n");
 		return -EINVAL;
 	}