1 /* 2 * Reset Controller framework 3 * 4 * Copyright 2013 Philipp Zabel, Pengutronix 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 */ 11 #include <linux/device.h> 12 #include <linux/err.h> 13 #include <linux/export.h> 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/of.h> 17 #include <linux/reset.h> 18 #include <linux/reset-controller.h> 19 #include <linux/slab.h> 20 21 static DEFINE_MUTEX(reset_controller_list_mutex); 22 static LIST_HEAD(reset_controller_list); 23 24 /** 25 * struct reset_control - a reset control 26 * @rcdev: a pointer to the reset controller device 27 * this reset control belongs to 28 * @id: ID of the reset controller in the reset 29 * controller device 30 */ 31 struct reset_control { 32 struct reset_controller_dev *rcdev; 33 unsigned int id; 34 }; 35 36 /** 37 * of_reset_simple_xlate - translate reset_spec to the reset line number 38 * @rcdev: a pointer to the reset controller device 39 * @reset_spec: reset line specifier as found in the device tree 40 * @flags: a flags pointer to fill in (optional) 41 * 42 * This simple translation function should be used for reset controllers 43 * with 1:1 mapping, where reset lines can be indexed by number without gaps. 44 */ 45 static int of_reset_simple_xlate(struct reset_controller_dev *rcdev, 46 const struct of_phandle_args *reset_spec) 47 { 48 if (reset_spec->args[0] >= rcdev->nr_resets) 49 return -EINVAL; 50 51 return reset_spec->args[0]; 52 } 53 54 /** 55 * reset_controller_register - register a reset controller device 56 * @rcdev: a pointer to the initialized reset controller device 57 */ 58 int reset_controller_register(struct reset_controller_dev *rcdev) 59 { 60 if (!rcdev->of_xlate) { 61 rcdev->of_reset_n_cells = 1; 62 rcdev->of_xlate = of_reset_simple_xlate; 63 } 64 65 mutex_lock(&reset_controller_list_mutex); 66 list_add(&rcdev->list, &reset_controller_list); 67 mutex_unlock(&reset_controller_list_mutex); 68 69 return 0; 70 } 71 EXPORT_SYMBOL_GPL(reset_controller_register); 72 73 /** 74 * reset_controller_unregister - unregister a reset controller device 75 * @rcdev: a pointer to the reset controller device 76 */ 77 void reset_controller_unregister(struct reset_controller_dev *rcdev) 78 { 79 mutex_lock(&reset_controller_list_mutex); 80 list_del(&rcdev->list); 81 mutex_unlock(&reset_controller_list_mutex); 82 } 83 EXPORT_SYMBOL_GPL(reset_controller_unregister); 84 85 /** 86 * reset_control_reset - reset the controlled device 87 * @rstc: reset controller 88 */ 89 int reset_control_reset(struct reset_control *rstc) 90 { 91 if (rstc->rcdev->ops->reset) 92 return rstc->rcdev->ops->reset(rstc->rcdev, rstc->id); 93 94 return -ENOTSUPP; 95 } 96 EXPORT_SYMBOL_GPL(reset_control_reset); 97 98 /** 99 * reset_control_assert - asserts the reset line 100 * @rstc: reset controller 101 */ 102 int reset_control_assert(struct reset_control *rstc) 103 { 104 if (rstc->rcdev->ops->assert) 105 return rstc->rcdev->ops->assert(rstc->rcdev, rstc->id); 106 107 return -ENOTSUPP; 108 } 109 EXPORT_SYMBOL_GPL(reset_control_assert); 110 111 /** 112 * reset_control_deassert - deasserts the reset line 113 * @rstc: reset controller 114 */ 115 int reset_control_deassert(struct reset_control *rstc) 116 { 117 if (rstc->rcdev->ops->deassert) 118 return rstc->rcdev->ops->deassert(rstc->rcdev, rstc->id); 119 120 return -ENOTSUPP; 121 } 122 EXPORT_SYMBOL_GPL(reset_control_deassert); 123 124 /** 125 * reset_control_status - returns a negative errno if not supported, a 126 * positive value if the reset line is asserted, or zero if the reset 127 * line is not asserted. 128 * @rstc: reset controller 129 */ 130 int reset_control_status(struct reset_control *rstc) 131 { 132 if (rstc->rcdev->ops->status) 133 return rstc->rcdev->ops->status(rstc->rcdev, rstc->id); 134 135 return -ENOTSUPP; 136 } 137 EXPORT_SYMBOL_GPL(reset_control_status); 138 139 /** 140 * of_reset_control_get_by_index - Lookup and obtain a reference to a reset 141 * controller by index. 142 * @node: device to be reset by the controller 143 * @index: index of the reset controller 144 * 145 * This is to be used to perform a list of resets for a device or power domain 146 * in whatever order. Returns a struct reset_control or IS_ERR() condition 147 * containing errno. 148 */ 149 struct reset_control *of_reset_control_get_by_index(struct device_node *node, 150 int index) 151 { 152 struct reset_control *rstc; 153 struct reset_controller_dev *r, *rcdev; 154 struct of_phandle_args args; 155 int rstc_id; 156 int ret; 157 158 ret = of_parse_phandle_with_args(node, "resets", "#reset-cells", 159 index, &args); 160 if (ret) 161 return ERR_PTR(ret); 162 163 mutex_lock(&reset_controller_list_mutex); 164 rcdev = NULL; 165 list_for_each_entry(r, &reset_controller_list, list) { 166 if (args.np == r->of_node) { 167 rcdev = r; 168 break; 169 } 170 } 171 of_node_put(args.np); 172 173 if (!rcdev) { 174 mutex_unlock(&reset_controller_list_mutex); 175 return ERR_PTR(-EPROBE_DEFER); 176 } 177 178 if (WARN_ON(args.args_count != rcdev->of_reset_n_cells)) { 179 mutex_unlock(&reset_controller_list_mutex); 180 return ERR_PTR(-EINVAL); 181 } 182 183 rstc_id = rcdev->of_xlate(rcdev, &args); 184 if (rstc_id < 0) { 185 mutex_unlock(&reset_controller_list_mutex); 186 return ERR_PTR(rstc_id); 187 } 188 189 try_module_get(rcdev->owner); 190 mutex_unlock(&reset_controller_list_mutex); 191 192 rstc = kzalloc(sizeof(*rstc), GFP_KERNEL); 193 if (!rstc) { 194 module_put(rcdev->owner); 195 return ERR_PTR(-ENOMEM); 196 } 197 198 rstc->rcdev = rcdev; 199 rstc->id = rstc_id; 200 201 return rstc; 202 } 203 EXPORT_SYMBOL_GPL(of_reset_control_get_by_index); 204 205 /** 206 * of_reset_control_get - Lookup and obtain a reference to a reset controller. 207 * @node: device to be reset by the controller 208 * @id: reset line name 209 * 210 * Returns a struct reset_control or IS_ERR() condition containing errno. 211 * 212 * Use of id names is optional. 213 */ 214 struct reset_control *of_reset_control_get(struct device_node *node, 215 const char *id) 216 { 217 int index = 0; 218 219 if (id) { 220 index = of_property_match_string(node, 221 "reset-names", id); 222 if (index < 0) 223 return ERR_PTR(-ENOENT); 224 } 225 return of_reset_control_get_by_index(node, index); 226 } 227 EXPORT_SYMBOL_GPL(of_reset_control_get); 228 229 /** 230 * reset_control_get - Lookup and obtain a reference to a reset controller. 231 * @dev: device to be reset by the controller 232 * @id: reset line name 233 * 234 * Returns a struct reset_control or IS_ERR() condition containing errno. 235 * 236 * Use of id names is optional. 237 */ 238 struct reset_control *reset_control_get(struct device *dev, const char *id) 239 { 240 if (!dev) 241 return ERR_PTR(-EINVAL); 242 243 return of_reset_control_get(dev->of_node, id); 244 } 245 EXPORT_SYMBOL_GPL(reset_control_get); 246 247 /** 248 * reset_control_put - free the reset controller 249 * @rstc: reset controller 250 */ 251 252 void reset_control_put(struct reset_control *rstc) 253 { 254 if (IS_ERR(rstc)) 255 return; 256 257 module_put(rstc->rcdev->owner); 258 kfree(rstc); 259 } 260 EXPORT_SYMBOL_GPL(reset_control_put); 261 262 static void devm_reset_control_release(struct device *dev, void *res) 263 { 264 reset_control_put(*(struct reset_control **)res); 265 } 266 267 /** 268 * devm_reset_control_get - resource managed reset_control_get() 269 * @dev: device to be reset by the controller 270 * @id: reset line name 271 * 272 * Managed reset_control_get(). For reset controllers returned from this 273 * function, reset_control_put() is called automatically on driver detach. 274 * See reset_control_get() for more information. 275 */ 276 struct reset_control *devm_reset_control_get(struct device *dev, const char *id) 277 { 278 struct reset_control **ptr, *rstc; 279 280 ptr = devres_alloc(devm_reset_control_release, sizeof(*ptr), 281 GFP_KERNEL); 282 if (!ptr) 283 return ERR_PTR(-ENOMEM); 284 285 rstc = reset_control_get(dev, id); 286 if (!IS_ERR(rstc)) { 287 *ptr = rstc; 288 devres_add(dev, ptr); 289 } else { 290 devres_free(ptr); 291 } 292 293 return rstc; 294 } 295 EXPORT_SYMBOL_GPL(devm_reset_control_get); 296 297 /** 298 * device_reset - find reset controller associated with the device 299 * and perform reset 300 * @dev: device to be reset by the controller 301 * 302 * Convenience wrapper for reset_control_get() and reset_control_reset(). 303 * This is useful for the common case of devices with single, dedicated reset 304 * lines. 305 */ 306 int device_reset(struct device *dev) 307 { 308 struct reset_control *rstc; 309 int ret; 310 311 rstc = reset_control_get(dev, NULL); 312 if (IS_ERR(rstc)) 313 return PTR_ERR(rstc); 314 315 ret = reset_control_reset(rstc); 316 317 reset_control_put(rstc); 318 319 return ret; 320 } 321 EXPORT_SYMBOL_GPL(device_reset); 322