reset: make optional functions really optional

RamiroOliveira · pH5 · commit bb475230b8e5 · 2017-01-20T10:36:15.000+01:00
The *_get_optional_* functions weren't really optional so this patch
makes them really optional.

These *_get_optional_* functions will now return NULL instead of an error
if no matching reset phandle is found in the DT, and all the
reset_control_* functions now accept NULL rstc pointers.

Signed-off-by: Ramiro Oliveira &lt;Ramiro.Oliveira@synopsys.com&gt;
Signed-off-by: Philipp Zabel &lt;p.zabel@pengutronix.de&gt;
diff --git a/drivers/reset/core.c b/drivers/reset/core.c
@@ -143,12 +143,18 @@ EXPORT_SYMBOL_GPL(devm_reset_controller_register);
  * a no-op.
  * Consumers must not use reset_control_(de)assert on shared reset lines when
  * reset_control_reset has been used.
+ *
+ * If rstc is NULL it is an optional reset and the function will just
+ * return 0.
  */
 int reset_control_reset(struct reset_control *rstc)
 {
 	int ret;
 
-	if (WARN_ON(IS_ERR_OR_NULL(rstc)))
+	if (!rstc)
+		return 0;
+
+	if (WARN_ON(IS_ERR(rstc)))
 		return -EINVAL;
 
 	if (!rstc->rcdev->ops->reset)
@@ -182,10 +188,17 @@ EXPORT_SYMBOL_GPL(reset_control_reset);
  * internal state to be reset, but must be prepared for this to happen.
  * Consumers must not use reset_control_reset on shared reset lines when
  * reset_control_(de)assert has been used.
+ * return 0.
+ *
+ * If rstc is NULL it is an optional reset and the function will just
+ * return 0.
  */
 int reset_control_assert(struct reset_control *rstc)
 {
-	if (WARN_ON(IS_ERR_OR_NULL(rstc)))
+	if (!rstc)
+		return 0;
+
+	if (WARN_ON(IS_ERR(rstc)))
 		return -EINVAL;
 
 	if (!rstc->rcdev->ops->assert)
@@ -213,10 +226,17 @@ EXPORT_SYMBOL_GPL(reset_control_assert);
  * After calling this function, the reset is guaranteed to be deasserted.
  * Consumers must not use reset_control_reset on shared reset lines when
  * reset_control_(de)assert has been used.
+ * return 0.
+ *
+ * If rstc is NULL it is an optional reset and the function will just
+ * return 0.
  */
 int reset_control_deassert(struct reset_control *rstc)
 {
-	if (WARN_ON(IS_ERR_OR_NULL(rstc)))
+	if (!rstc)
+		return 0;
+
+	if (WARN_ON(IS_ERR(rstc)))
 		return -EINVAL;
 
 	if (!rstc->rcdev->ops->deassert)
@@ -237,12 +257,15 @@ EXPORT_SYMBOL_GPL(reset_control_deassert);
 /**
  * reset_control_status - returns a negative errno if not supported, a
  * positive value if the reset line is asserted, or zero if the reset
- * line is not asserted.
+ * line is not asserted or if the desc is NULL (optional reset).
  * @rstc: reset controller
  */
 int reset_control_status(struct reset_control *rstc)
 {
-	if (WARN_ON(IS_ERR_OR_NULL(rstc)))
+	if (!rstc)
+		return 0;
+
+	if (WARN_ON(IS_ERR(rstc)))
 		return -EINVAL;
 
 	if (rstc->rcdev->ops->status)
@@ -299,7 +322,8 @@ static void __reset_control_put(struct reset_control *rstc)
 }
 
 struct reset_control *__of_reset_control_get(struct device_node *node,
-				     const char *id, int index, bool shared)
+				     const char *id, int index, bool shared,
+				     bool optional)
 {
 	struct reset_control *rstc;
 	struct reset_controller_dev *r, *rcdev;
@@ -313,14 +337,18 @@ struct reset_control *__of_reset_control_get(struct device_node *node,
 	if (id) {
 		index = of_property_match_string(node,
 						 "reset-names", id);
+		if (index == -EILSEQ)
+			return ERR_PTR(index);
 		if (index < 0)
-			return ERR_PTR(-ENOENT);
+			return optional ? NULL : ERR_PTR(-ENOENT);
 	}
 
 	ret = of_parse_phandle_with_args(node, "resets", "#reset-cells",
 					 index, &args);
-	if (ret)
+	if (ret == -EINVAL)
 		return ERR_PTR(ret);
+	if (ret)
+		return optional ? NULL : ERR_PTR(ret);
 
 	mutex_lock(&reset_list_mutex);
 	rcdev = NULL;
@@ -379,7 +407,8 @@ static void devm_reset_control_release(struct device *dev, void *res)
 }
 
 struct reset_control *__devm_reset_control_get(struct device *dev,
-				     const char *id, int index, bool shared)
+				     const char *id, int index, bool shared,
+				     bool optional)
 {
 	struct reset_control **ptr, *rstc;
 
@@ -389,7 +418,7 @@ struct reset_control *__devm_reset_control_get(struct device *dev,
 		return ERR_PTR(-ENOMEM);
 
 	rstc = __of_reset_control_get(dev ? dev->of_node : NULL,
-				      id, index, shared);
+				      id, index, shared, optional);
 	if (!IS_ERR(rstc)) {
 		*ptr = rstc;
 		devres_add(dev, ptr);
diff --git a/include/linux/reset.h b/include/linux/reset.h
@@ -13,10 +13,12 @@ int reset_control_deassert(struct reset_control *rstc);
 int reset_control_status(struct reset_control *rstc);
 
 struct reset_control *__of_reset_control_get(struct device_node *node,
-				     const char *id, int index, bool shared);
+				     const char *id, int index, bool shared,
+				     bool optional);
 void reset_control_put(struct reset_control *rstc);
 struct reset_control *__devm_reset_control_get(struct device *dev,
-				     const char *id, int index, bool shared);
+				     const char *id, int index, bool shared,
+				     bool optional);
 
 int __must_check device_reset(struct device *dev);
 
@@ -69,14 +71,15 @@ static inline int device_reset_optional(struct device *dev)
 
 static inline struct reset_control *__of_reset_control_get(
 					struct device_node *node,
-					const char *id, int index, bool shared)
+					const char *id, int index, bool shared,
+					bool optional)
 {
 	return ERR_PTR(-ENOTSUPP);
 }
 
 static inline struct reset_control *__devm_reset_control_get(
-					struct device *dev,
-					const char *id, int index, bool shared)
+					struct device *dev, const char *id,
+					int index, bool shared, bool optional)
 {
 	return ERR_PTR(-ENOTSUPP);
 }
@@ -104,7 +107,8 @@ __must_check reset_control_get_exclusive(struct device *dev, const char *id)
 #ifndef CONFIG_RESET_CONTROLLER
 	WARN_ON(1);
 #endif
-	return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, 0);
+	return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, false,
+									false);
 }
 
 /**
@@ -132,19 +136,22 @@ __must_check reset_control_get_exclusive(struct device *dev, const char *id)
 static inline struct reset_control *reset_control_get_shared(
 					struct device *dev, const char *id)
 {
-	return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, true);
+	return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, true,
+									false);
 }
 
 static inline struct reset_control *reset_control_get_optional_exclusive(
 					struct device *dev, const char *id)
 {
-	return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, false);
+	return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, false,
+									true);
 }
 
 static inline struct reset_control *reset_control_get_optional_shared(
 					struct device *dev, const char *id)
 {
-	return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, true);
+	return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, true,
+									true);
 }
 
 /**
@@ -160,7 +167,7 @@ static inline struct reset_control *reset_control_get_optional_shared(
 static inline struct reset_control *of_reset_control_get_exclusive(
 				struct device_node *node, const char *id)
 {
-	return __of_reset_control_get(node, id, 0, 0);
+	return __of_reset_control_get(node, id, 0, false, false);
 }
 
 /**
@@ -185,7 +192,7 @@ static inline struct reset_control *of_reset_control_get_exclusive(
 static inline struct reset_control *of_reset_control_get_shared(
 				struct device_node *node, const char *id)
 {
-	return __of_reset_control_get(node, id, 0, true);
+	return __of_reset_control_get(node, id, 0, true, false);
 }
 
 /**
@@ -202,7 +209,7 @@ static inline struct reset_control *of_reset_control_get_shared(
 static inline struct reset_control *of_reset_control_get_exclusive_by_index(
 					struct device_node *node, int index)
 {
-	return __of_reset_control_get(node, NULL, index, false);
+	return __of_reset_control_get(node, NULL, index, false, false);
 }
 
 /**
@@ -230,7 +237,7 @@ static inline struct reset_control *of_reset_control_get_exclusive_by_index(
 static inline struct reset_control *of_reset_control_get_shared_by_index(
 					struct device_node *node, int index)
 {
-	return __of_reset_control_get(node, NULL, index, true);
+	return __of_reset_control_get(node, NULL, index, true, false);
 }
 
 /**
@@ -252,7 +259,7 @@ __must_check devm_reset_control_get_exclusive(struct device *dev,
 #ifndef CONFIG_RESET_CONTROLLER
 	WARN_ON(1);
 #endif
-	return __devm_reset_control_get(dev, id, 0, false);
+	return __devm_reset_control_get(dev, id, 0, false, false);
 }
 
 /**
@@ -267,19 +274,19 @@ __must_check devm_reset_control_get_exclusive(struct device *dev,
 static inline struct reset_control *devm_reset_control_get_shared(
 					struct device *dev, const char *id)
 {
-	return __devm_reset_control_get(dev, id, 0, true);
+	return __devm_reset_control_get(dev, id, 0, true, false);
 }
 
 static inline struct reset_control *devm_reset_control_get_optional_exclusive(
 					struct device *dev, const char *id)
 {
-	return __devm_reset_control_get(dev, id, 0, false);
+	return __devm_reset_control_get(dev, id, 0, false, true);
 }
 
 static inline struct reset_control *devm_reset_control_get_optional_shared(
 					struct device *dev, const char *id)
 {
-	return __devm_reset_control_get(dev, id, 0, true);
+	return __devm_reset_control_get(dev, id, 0, true, true);
 }
 
 /**
@@ -297,7 +304,7 @@ static inline struct reset_control *devm_reset_control_get_optional_shared(
 static inline struct reset_control *
 devm_reset_control_get_exclusive_by_index(struct device *dev, int index)
 {
-	return __devm_reset_control_get(dev, NULL, index, false);
+	return __devm_reset_control_get(dev, NULL, index, false, false);
 }
 
 /**
@@ -313,7 +320,7 @@ devm_reset_control_get_exclusive_by_index(struct device *dev, int index)
 static inline struct reset_control *
 devm_reset_control_get_shared_by_index(struct device *dev, int index)
 {
-	return __devm_reset_control_get(dev, NULL, index, true);
+	return __devm_reset_control_get(dev, NULL, index, true, false);
 }
 
 /*

Original file line number	Diff line number	Diff line change
`@@ -13,10 +13,12 @@ int reset_control_deassert(struct reset_control *rstc);`
`13`	`13`	`int reset_control_status(struct reset_control *rstc);`
`14`	`14`
`15`	`15`	`struct reset_control __of_reset_control_get(struct device_node node,`
`16`		`- const char *id, int index, bool shared);`
	`16`	`+ const char *id, int index, bool shared,`
	`17`	`+ bool optional);`
`17`	`18`	`void reset_control_put(struct reset_control *rstc);`
`18`	`19`	`struct reset_control __devm_reset_control_get(struct device dev,`
`19`		`- const char *id, int index, bool shared);`
	`20`	`+ const char *id, int index, bool shared,`
	`21`	`+ bool optional);`
`20`	`22`
`21`	`23`	`int __must_check device_reset(struct device *dev);`
`22`	`24`
`@@ -69,14 +71,15 @@ static inline int device_reset_optional(struct device *dev)`
`69`	`71`
`70`	`72`	`static inline struct reset_control *__of_reset_control_get(`
`71`	`73`	`struct device_node *node,`
`72`		`- const char *id, int index, bool shared)`
	`74`	`+ const char *id, int index, bool shared,`
	`75`	`+ bool optional)`
`73`	`76`	`{`
`74`	`77`	`return ERR_PTR(-ENOTSUPP);`
`75`	`78`	`}`
`76`	`79`
`77`	`80`	`static inline struct reset_control *__devm_reset_control_get(`
`78`		`- struct device *dev,`
`79`		`- const char *id, int index, bool shared)`
	`81`	`+ struct device dev, const char id,`
	`82`	`+ int index, bool shared, bool optional)`
`80`	`83`	`{`
`81`	`84`	`return ERR_PTR(-ENOTSUPP);`
`82`	`85`	`}`
`@@ -104,7 +107,8 @@ __must_check reset_control_get_exclusive(struct device dev, const char id)`
`104`	`107`	`#ifndef CONFIG_RESET_CONTROLLER`
`105`	`108`	`WARN_ON(1);`
`106`	`109`	`#endif`
`107`		`- return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, 0);`
	`110`	`+ return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, false,`
	`111`	`+ false);`
`108`	`112`	`}`
`109`	`113`
`110`	`114`	`/**`
`@@ -132,19 +136,22 @@ __must_check reset_control_get_exclusive(struct device dev, const char id)`
`132`	`136`	`static inline struct reset_control *reset_control_get_shared(`
`133`	`137`	`struct device dev, const char id)`
`134`	`138`	`{`
`135`		`- return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, true);`
	`139`	`+ return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, true,`
	`140`	`+ false);`
`136`	`141`	`}`
`137`	`142`
`138`	`143`	`static inline struct reset_control *reset_control_get_optional_exclusive(`
`139`	`144`	`struct device dev, const char id)`
`140`	`145`	`{`
`141`		`- return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, false);`
	`146`	`+ return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, false,`
	`147`	`+ true);`
`142`	`148`	`}`
`143`	`149`
`144`	`150`	`static inline struct reset_control *reset_control_get_optional_shared(`
`145`	`151`	`struct device dev, const char id)`
`146`	`152`	`{`
`147`		`- return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, true);`
	`153`	`+ return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, true,`
	`154`	`+ true);`
`148`	`155`	`}`
`149`	`156`
`150`	`157`	`/**`
`@@ -160,7 +167,7 @@ static inline struct reset_control *reset_control_get_optional_shared(`
`160`	`167`	`static inline struct reset_control *of_reset_control_get_exclusive(`
`161`	`168`	`struct device_node node, const char id)`
`162`	`169`	`{`
`163`		`- return __of_reset_control_get(node, id, 0, 0);`
	`170`	`+ return __of_reset_control_get(node, id, 0, false, false);`
`164`	`171`	`}`
`165`	`172`
`166`	`173`	`/**`
`@@ -185,7 +192,7 @@ static inline struct reset_control *of_reset_control_get_exclusive(`
`185`	`192`	`static inline struct reset_control *of_reset_control_get_shared(`
`186`	`193`	`struct device_node node, const char id)`
`187`	`194`	`{`
`188`		`- return __of_reset_control_get(node, id, 0, true);`
	`195`	`+ return __of_reset_control_get(node, id, 0, true, false);`
`189`	`196`	`}`
`190`	`197`
`191`	`198`	`/**`
`@@ -202,7 +209,7 @@ static inline struct reset_control *of_reset_control_get_shared(`
`202`	`209`	`static inline struct reset_control *of_reset_control_get_exclusive_by_index(`
`203`	`210`	`struct device_node *node, int index)`
`204`	`211`	`{`
`205`		`- return __of_reset_control_get(node, NULL, index, false);`
	`212`	`+ return __of_reset_control_get(node, NULL, index, false, false);`
`206`	`213`	`}`
`207`	`214`
`208`	`215`	`/**`
`@@ -230,7 +237,7 @@ static inline struct reset_control *of_reset_control_get_exclusive_by_index(`
`230`	`237`	`static inline struct reset_control *of_reset_control_get_shared_by_index(`
`231`	`238`	`struct device_node *node, int index)`
`232`	`239`	`{`
`233`		`- return __of_reset_control_get(node, NULL, index, true);`
	`240`	`+ return __of_reset_control_get(node, NULL, index, true, false);`
`234`	`241`	`}`
`235`	`242`
`236`	`243`	`/**`
`@@ -252,7 +259,7 @@ __must_check devm_reset_control_get_exclusive(struct device *dev,`
`252`	`259`	`#ifndef CONFIG_RESET_CONTROLLER`
`253`	`260`	`WARN_ON(1);`
`254`	`261`	`#endif`
`255`		`- return __devm_reset_control_get(dev, id, 0, false);`
	`262`	`+ return __devm_reset_control_get(dev, id, 0, false, false);`
`256`	`263`	`}`
`257`	`264`
`258`	`265`	`/**`
`@@ -267,19 +274,19 @@ __must_check devm_reset_control_get_exclusive(struct device *dev,`
`267`	`274`	`static inline struct reset_control *devm_reset_control_get_shared(`
`268`	`275`	`struct device dev, const char id)`
`269`	`276`	`{`
`270`		`- return __devm_reset_control_get(dev, id, 0, true);`
	`277`	`+ return __devm_reset_control_get(dev, id, 0, true, false);`
`271`	`278`	`}`
`272`	`279`
`273`	`280`	`static inline struct reset_control *devm_reset_control_get_optional_exclusive(`
`274`	`281`	`struct device dev, const char id)`
`275`	`282`	`{`
`276`		`- return __devm_reset_control_get(dev, id, 0, false);`
	`283`	`+ return __devm_reset_control_get(dev, id, 0, false, true);`
`277`	`284`	`}`
`278`	`285`
`279`	`286`	`static inline struct reset_control *devm_reset_control_get_optional_shared(`
`280`	`287`	`struct device dev, const char id)`
`281`	`288`	`{`
`282`		`- return __devm_reset_control_get(dev, id, 0, true);`
	`289`	`+ return __devm_reset_control_get(dev, id, 0, true, true);`
`283`	`290`	`}`
`284`	`291`
`285`	`292`	`/**`
`@@ -297,7 +304,7 @@ static inline struct reset_control *devm_reset_control_get_optional_shared(`
`297`	`304`	`static inline struct reset_control *`
`298`	`305`	`devm_reset_control_get_exclusive_by_index(struct device *dev, int index)`
`299`	`306`	`{`
`300`		`- return __devm_reset_control_get(dev, NULL, index, false);`
	`307`	`+ return __devm_reset_control_get(dev, NULL, index, false, false);`
`301`	`308`	`}`
`302`	`309`
`303`	`310`	`/**`
`@@ -313,7 +320,7 @@ devm_reset_control_get_exclusive_by_index(struct device *dev, int index)`
`313`	`320`	`static inline struct reset_control *`
`314`	`321`	`devm_reset_control_get_shared_by_index(struct device *dev, int index)`
`315`	`322`	`{`
`316`		`- return __devm_reset_control_get(dev, NULL, index, true);`
	`323`	`+ return __devm_reset_control_get(dev, NULL, index, true, false);`
`317`	`324`	`}`
`318`	`325`
`319`	`326`	`/*`