Skip to content
Navigation Menu
Toggle navigation
Sign in
In this repository
All GitHub Enterprise
↵
Jump to
↵
No suggested jump to results
In this repository
All GitHub Enterprise
↵
Jump to
↵
In this organization
All GitHub Enterprise
↵
Jump to
↵
In this repository
All GitHub Enterprise
↵
Jump to
↵
Sign in
Reseting focus
You signed in with another tab or window.
Reload
to refresh your session.
You signed out in another tab or window.
Reload
to refresh your session.
You switched accounts on another tab or window.
Reload
to refresh your session.
Dismiss alert
{{ message }}
mariux64
/
linux
Public
Notifications
You must be signed in to change notification settings
Fork
0
Star
0
Code
Issues
2
Pull requests
0
Actions
Projects
0
Wiki
Security
Insights
Additional navigation options
Code
Issues
Pull requests
Actions
Projects
Wiki
Security
Insights
Files
c15ddec
Documentation
arch
block
certs
crypto
drivers
accessibility
acpi
amba
android
ata
atm
auxdisplay
base
bcma
block
bluetooth
bus
cdrom
char
clk
clocksource
connector
cpufreq
cpuidle
crypto
dca
devfreq
dio
dma-buf
dma
edac
eisa
extcon
firewire
firmware
fmc
fpga
gpio
gpu
hid
hsi
hv
hwmon
hwspinlock
hwtracing
i2c
ide
idle
iio
infiniband
input
iommu
ipack
irqchip
isdn
leds
lguest
lightnvm
macintosh
mailbox
mcb
md
media
memory
memstick
message
mfd
misc
mmc
mtd
net
nfc
ntb
nubus
nvdimm
nvme
nvmem
of
oprofile
parisc
parport
pci
pcmcia
perf
phy
pinctrl
platform
pnp
power
powercap
pps
ps3
ptp
pwm
rapidio
ras
regulator
remoteproc
reset
hisilicon
sti
Kconfig
Makefile
core.c
reset-ath79.c
reset-berlin.c
reset-lpc18xx.c
reset-pistachio.c
reset-socfpga.c
reset-sunxi.c
reset-zynq.c
rpmsg
rtc
s390
sbus
scsi
sfi
sh
sn
soc
spi
spmi
ssb
staging
target
tc
thermal
thunderbolt
tty
uio
usb
uwb
vfio
vhost
video
virt
virtio
vlynq
vme
w1
watchdog
xen
zorro
Kconfig
Makefile
firmware
fs
include
init
ipc
kernel
lib
mm
net
samples
scripts
security
sound
tools
usr
virt
.get_maintainer.ignore
.gitignore
.mailmap
COPYING
CREDITS
Kbuild
Kconfig
MAINTAINERS
Makefile
README
REPORTING-BUGS
Breadcrumbs
linux
/
drivers
/
reset
/
core.c
Blame
Blame
Latest commit
History
History
313 lines (261 loc) · 7.28 KB
Breadcrumbs
linux
/
drivers
/
reset
/
core.c
Top
File metadata and controls
Code
Blame
313 lines (261 loc) · 7.28 KB
Raw
/* * Reset Controller framework * * Copyright 2013 Philipp Zabel, Pengutronix * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. */ #include <linux/device.h> #include <linux/err.h> #include <linux/export.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/of.h> #include <linux/reset.h> #include <linux/reset-controller.h> #include <linux/slab.h> static DEFINE_MUTEX(reset_list_mutex); static LIST_HEAD(reset_controller_list); /** * struct reset_control - a reset control * @rcdev: a pointer to the reset controller device * this reset control belongs to * @list: list entry for the rcdev's reset controller list * @id: ID of the reset controller in the reset * controller device * @refcnt: Number of gets of this reset_control */ struct reset_control { struct reset_controller_dev *rcdev; struct list_head list; unsigned int id; unsigned int refcnt; }; /** * of_reset_simple_xlate - translate reset_spec to the reset line number * @rcdev: a pointer to the reset controller device * @reset_spec: reset line specifier as found in the device tree * @flags: a flags pointer to fill in (optional) * * This simple translation function should be used for reset controllers * with 1:1 mapping, where reset lines can be indexed by number without gaps. */ static int of_reset_simple_xlate(struct reset_controller_dev *rcdev, const struct of_phandle_args *reset_spec) { if (reset_spec->args[0] >= rcdev->nr_resets) return -EINVAL; return reset_spec->args[0]; } /** * reset_controller_register - register a reset controller device * @rcdev: a pointer to the initialized reset controller device */ int reset_controller_register(struct reset_controller_dev *rcdev) { if (!rcdev->of_xlate) { rcdev->of_reset_n_cells = 1; rcdev->of_xlate = of_reset_simple_xlate; } INIT_LIST_HEAD(&rcdev->reset_control_head); mutex_lock(&reset_list_mutex); list_add(&rcdev->list, &reset_controller_list); mutex_unlock(&reset_list_mutex); return 0; } EXPORT_SYMBOL_GPL(reset_controller_register); /** * reset_controller_unregister - unregister a reset controller device * @rcdev: a pointer to the reset controller device */ void reset_controller_unregister(struct reset_controller_dev *rcdev) { mutex_lock(&reset_list_mutex); list_del(&rcdev->list); mutex_unlock(&reset_list_mutex); } EXPORT_SYMBOL_GPL(reset_controller_unregister); /** * reset_control_reset - reset the controlled device * @rstc: reset controller */ int reset_control_reset(struct reset_control *rstc) { if (rstc->rcdev->ops->reset) return rstc->rcdev->ops->reset(rstc->rcdev, rstc->id); return -ENOTSUPP; } EXPORT_SYMBOL_GPL(reset_control_reset); /** * reset_control_assert - asserts the reset line * @rstc: reset controller */ int reset_control_assert(struct reset_control *rstc) { if (rstc->rcdev->ops->assert) return rstc->rcdev->ops->assert(rstc->rcdev, rstc->id); return -ENOTSUPP; } EXPORT_SYMBOL_GPL(reset_control_assert); /** * reset_control_deassert - deasserts the reset line * @rstc: reset controller */ int reset_control_deassert(struct reset_control *rstc) { if (rstc->rcdev->ops->deassert) return rstc->rcdev->ops->deassert(rstc->rcdev, rstc->id); return -ENOTSUPP; } 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. * @rstc: reset controller */ int reset_control_status(struct reset_control *rstc) { if (rstc->rcdev->ops->status) return rstc->rcdev->ops->status(rstc->rcdev, rstc->id); return -ENOTSUPP; } EXPORT_SYMBOL_GPL(reset_control_status); static struct reset_control *__reset_control_get( struct reset_controller_dev *rcdev, unsigned int index) { struct reset_control *rstc; lockdep_assert_held(&reset_list_mutex); list_for_each_entry(rstc, &rcdev->reset_control_head, list) { if (rstc->id == index) { rstc->refcnt++; return rstc; } } rstc = kzalloc(sizeof(*rstc), GFP_KERNEL); if (!rstc) return ERR_PTR(-ENOMEM); try_module_get(rcdev->owner); rstc->rcdev = rcdev; list_add(&rstc->list, &rcdev->reset_control_head); rstc->id = index; rstc->refcnt = 1; return rstc; } static void __reset_control_put(struct reset_control *rstc) { lockdep_assert_held(&reset_list_mutex); if (--rstc->refcnt) return; module_put(rstc->rcdev->owner); list_del(&rstc->list); kfree(rstc); } struct reset_control *__of_reset_control_get(struct device_node *node, const char *id, int index) { struct reset_control *rstc; struct reset_controller_dev *r, *rcdev; struct of_phandle_args args; int rstc_id; int ret; if (!node) return ERR_PTR(-EINVAL); if (id) { index = of_property_match_string(node, "reset-names", id); if (index < 0) return ERR_PTR(-ENOENT); } ret = of_parse_phandle_with_args(node, "resets", "#reset-cells", index, &args); if (ret) return ERR_PTR(ret); mutex_lock(&reset_list_mutex); rcdev = NULL; list_for_each_entry(r, &reset_controller_list, list) { if (args.np == r->of_node) { rcdev = r; break; } } of_node_put(args.np); if (!rcdev) { mutex_unlock(&reset_list_mutex); return ERR_PTR(-EPROBE_DEFER); } if (WARN_ON(args.args_count != rcdev->of_reset_n_cells)) { mutex_unlock(&reset_list_mutex); return ERR_PTR(-EINVAL); } rstc_id = rcdev->of_xlate(rcdev, &args); if (rstc_id < 0) { mutex_unlock(&reset_list_mutex); return ERR_PTR(rstc_id); } /* reset_list_mutex also protects the rcdev's reset_control list */ rstc = __reset_control_get(rcdev, rstc_id); mutex_unlock(&reset_list_mutex); return rstc; } EXPORT_SYMBOL_GPL(__of_reset_control_get); /** * reset_control_put - free the reset controller * @rstc: reset controller */ void reset_control_put(struct reset_control *rstc) { if (IS_ERR(rstc)) return; mutex_lock(&reset_list_mutex); __reset_control_put(rstc); mutex_unlock(&reset_list_mutex); } EXPORT_SYMBOL_GPL(reset_control_put); static void devm_reset_control_release(struct device *dev, void *res) { reset_control_put(*(struct reset_control **)res); } struct reset_control *__devm_reset_control_get(struct device *dev, const char *id, int index) { struct reset_control **ptr, *rstc; ptr = devres_alloc(devm_reset_control_release, sizeof(*ptr), GFP_KERNEL); if (!ptr) return ERR_PTR(-ENOMEM); rstc = __of_reset_control_get(dev ? dev->of_node : NULL, id, index); if (!IS_ERR(rstc)) { *ptr = rstc; devres_add(dev, ptr); } else { devres_free(ptr); } return rstc; } EXPORT_SYMBOL_GPL(__devm_reset_control_get); /** * device_reset - find reset controller associated with the device * and perform reset * @dev: device to be reset by the controller * * Convenience wrapper for reset_control_get() and reset_control_reset(). * This is useful for the common case of devices with single, dedicated reset * lines. */ int device_reset(struct device *dev) { struct reset_control *rstc; int ret; rstc = reset_control_get(dev, NULL); if (IS_ERR(rstc)) return PTR_ERR(rstc); ret = reset_control_reset(rstc); reset_control_put(rstc); return ret; } EXPORT_SYMBOL_GPL(device_reset);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
You can’t perform that action at this time.