1 #ifndef _LINUX_RESET_H_ 2 #define _LINUX_RESET_H_ 3 4 #include <linux/device.h> 5 6 struct reset_control; 7 8 #ifdef CONFIG_RESET_CONTROLLER 9 10 int reset_control_reset(struct reset_control *rstc); 11 int reset_control_assert(struct reset_control *rstc); 12 int reset_control_deassert(struct reset_control *rstc); 13 int reset_control_status(struct reset_control *rstc); 14 15 struct reset_control *__of_reset_control_get(struct device_node *node, 16 const char *id, int index, int shared); 17 void reset_control_put(struct reset_control *rstc); 18 struct reset_control *__devm_reset_control_get(struct device *dev, 19 const char *id, int index, int shared); 20 21 int __must_check device_reset(struct device *dev); 22 23 static inline int device_reset_optional(struct device *dev) 24 { 25 return device_reset(dev); 26 } 27 28 #else 29 30 static inline int reset_control_reset(struct reset_control *rstc) 31 { 32 WARN_ON(1); 33 return 0; 34 } 35 36 static inline int reset_control_assert(struct reset_control *rstc) 37 { 38 WARN_ON(1); 39 return 0; 40 } 41 42 static inline int reset_control_deassert(struct reset_control *rstc) 43 { 44 WARN_ON(1); 45 return 0; 46 } 47 48 static inline int reset_control_status(struct reset_control *rstc) 49 { 50 WARN_ON(1); 51 return 0; 52 } 53 54 static inline void reset_control_put(struct reset_control *rstc) 55 { 56 WARN_ON(1); 57 } 58 59 static inline int __must_check device_reset(struct device *dev) 60 { 61 WARN_ON(1); 62 return -ENOTSUPP; 63 } 64 65 static inline int device_reset_optional(struct device *dev) 66 { 67 return -ENOTSUPP; 68 } 69 70 static inline struct reset_control *__of_reset_control_get( 71 struct device_node *node, 72 const char *id, int index, int shared) 73 { 74 return ERR_PTR(-EINVAL); 75 } 76 77 static inline struct reset_control *__devm_reset_control_get( 78 struct device *dev, 79 const char *id, int index, int shared) 80 { 81 return ERR_PTR(-EINVAL); 82 } 83 84 #endif /* CONFIG_RESET_CONTROLLER */ 85 86 /** 87 * reset_control_get - Lookup and obtain an exclusive reference to a 88 * reset controller. 89 * @dev: device to be reset by the controller 90 * @id: reset line name 91 * 92 * Returns a struct reset_control or IS_ERR() condition containing errno. 93 * If this function is called more then once for the same reset_control it will 94 * return -EBUSY. 95 * 96 * See reset_control_get_shared for details on shared references to 97 * reset-controls. 98 * 99 * Use of id names is optional. 100 */ 101 static inline struct reset_control *__must_check reset_control_get( 102 struct device *dev, const char *id) 103 { 104 #ifndef CONFIG_RESET_CONTROLLER 105 WARN_ON(1); 106 #endif 107 return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, 0); 108 } 109 110 static inline struct reset_control *reset_control_get_optional( 111 struct device *dev, const char *id) 112 { 113 return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, 0); 114 } 115 116 /** 117 * reset_control_get_shared - Lookup and obtain a shared reference to a 118 * reset controller. 119 * @dev: device to be reset by the controller 120 * @id: reset line name 121 * 122 * Returns a struct reset_control or IS_ERR() condition containing errno. 123 * This function is intended for use with reset-controls which are shared 124 * between hardware-blocks. 125 * 126 * When a reset-control is shared, the behavior of reset_control_assert / 127 * deassert is changed, the reset-core will keep track of a deassert_count 128 * and only (re-)assert the reset after reset_control_assert has been called 129 * as many times as reset_control_deassert was called. Also see the remark 130 * about shared reset-controls in the reset_control_assert docs. 131 * 132 * Calling reset_control_assert without first calling reset_control_deassert 133 * is not allowed on a shared reset control. Calling reset_control_reset is 134 * also not allowed on a shared reset control. 135 * 136 * Use of id names is optional. 137 */ 138 static inline struct reset_control *reset_control_get_shared( 139 struct device *dev, const char *id) 140 { 141 return __of_reset_control_get(dev ? dev->of_node : NULL, id, 0, 1); 142 } 143 144 /** 145 * of_reset_control_get - Lookup and obtain an exclusive reference to a 146 * reset controller. 147 * @node: device to be reset by the controller 148 * @id: reset line name 149 * 150 * Returns a struct reset_control or IS_ERR() condition containing errno. 151 * 152 * Use of id names is optional. 153 */ 154 static inline struct reset_control *of_reset_control_get( 155 struct device_node *node, const char *id) 156 { 157 return __of_reset_control_get(node, id, 0, 0); 158 } 159 160 /** 161 * of_reset_control_get_by_index - Lookup and obtain an exclusive reference to 162 * a reset controller by index. 163 * @node: device to be reset by the controller 164 * @index: index of the reset controller 165 * 166 * This is to be used to perform a list of resets for a device or power domain 167 * in whatever order. Returns a struct reset_control or IS_ERR() condition 168 * containing errno. 169 */ 170 static inline struct reset_control *of_reset_control_get_by_index( 171 struct device_node *node, int index) 172 { 173 return __of_reset_control_get(node, NULL, index, 0); 174 } 175 176 /** 177 * devm_reset_control_get - resource managed reset_control_get() 178 * @dev: device to be reset by the controller 179 * @id: reset line name 180 * 181 * Managed reset_control_get(). For reset controllers returned from this 182 * function, reset_control_put() is called automatically on driver detach. 183 * See reset_control_get() for more information. 184 */ 185 static inline struct reset_control *__must_check devm_reset_control_get( 186 struct device *dev, const char *id) 187 { 188 #ifndef CONFIG_RESET_CONTROLLER 189 WARN_ON(1); 190 #endif 191 return __devm_reset_control_get(dev, id, 0, 0); 192 } 193 194 static inline struct reset_control *devm_reset_control_get_optional( 195 struct device *dev, const char *id) 196 { 197 return __devm_reset_control_get(dev, id, 0, 0); 198 } 199 200 /** 201 * devm_reset_control_get_by_index - resource managed reset_control_get 202 * @dev: device to be reset by the controller 203 * @index: index of the reset controller 204 * 205 * Managed reset_control_get(). For reset controllers returned from this 206 * function, reset_control_put() is called automatically on driver detach. 207 * See reset_control_get() for more information. 208 */ 209 static inline struct reset_control *devm_reset_control_get_by_index( 210 struct device *dev, int index) 211 { 212 return __devm_reset_control_get(dev, NULL, index, 0); 213 } 214 215 /** 216 * devm_reset_control_get_shared - resource managed reset_control_get_shared() 217 * @dev: device to be reset by the controller 218 * @id: reset line name 219 * 220 * Managed reset_control_get_shared(). For reset controllers returned from 221 * this function, reset_control_put() is called automatically on driver detach. 222 * See reset_control_get_shared() for more information. 223 */ 224 static inline struct reset_control *devm_reset_control_get_shared( 225 struct device *dev, const char *id) 226 { 227 return __devm_reset_control_get(dev, id, 0, 1); 228 } 229 230 /** 231 * devm_reset_control_get_shared_by_index - resource managed 232 * reset_control_get_shared 233 * @dev: device to be reset by the controller 234 * @index: index of the reset controller 235 * 236 * Managed reset_control_get_shared(). For reset controllers returned from 237 * this function, reset_control_put() is called automatically on driver detach. 238 * See reset_control_get_shared() for more information. 239 */ 240 static inline struct reset_control *devm_reset_control_get_shared_by_index( 241 struct device *dev, int index) 242 { 243 return __devm_reset_control_get(dev, NULL, index, 1); 244 } 245 246 #endif 247