include/linux/reset.h

   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