2 * Copyright 2016 Michal Meloun <mmel@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
30 #include "opt_platform.h"
31 #include <sys/param.h>
34 #include <sys/kernel.h>
35 #include <sys/queue.h>
37 #include <sys/malloc.h>
38 #include <sys/mutex.h>
39 #include <sys/limits.h>
42 #include <sys/sysctl.h>
43 #include <sys/systm.h>
47 #include <dev/fdt/fdt_common.h>
48 #include <dev/ofw/ofw_bus.h>
49 #include <dev/ofw/ofw_bus_subr.h>
51 #include <dev/extres/clk/clk.h>
53 SYSCTL_NODE(_hw, OID_AUTO, clock, CTLFLAG_RD, NULL, "Clocks");
55 MALLOC_DEFINE(M_CLOCK, "clocks", "Clock framework");
57 /* Forward declarations. */
62 typedef TAILQ_HEAD(clknode_list, clknode) clknode_list_t;
63 typedef TAILQ_HEAD(clkdom_list, clkdom) clkdom_list_t;
65 /* Default clock methods. */
66 static int clknode_method_init(struct clknode *clk, device_t dev);
67 static int clknode_method_recalc_freq(struct clknode *clk, uint64_t *freq);
68 static int clknode_method_set_freq(struct clknode *clk, uint64_t fin,
69 uint64_t *fout, int flags, int *stop);
70 static int clknode_method_set_gate(struct clknode *clk, bool enable);
71 static int clknode_method_set_mux(struct clknode *clk, int idx);
74 * Clock controller methods.
76 static clknode_method_t clknode_methods[] = {
77 CLKNODEMETHOD(clknode_init, clknode_method_init),
78 CLKNODEMETHOD(clknode_recalc_freq, clknode_method_recalc_freq),
79 CLKNODEMETHOD(clknode_set_freq, clknode_method_set_freq),
80 CLKNODEMETHOD(clknode_set_gate, clknode_method_set_gate),
81 CLKNODEMETHOD(clknode_set_mux, clknode_method_set_mux),
85 DEFINE_CLASS_0(clknode, clknode_class, clknode_methods, 0);
88 * Clock node - basic element for modeling SOC clock graph. It holds the clock
89 * provider's data about the clock, and the links for the clock's membership in
95 /* Clock nodes topology. */
96 struct clkdom *clkdom; /* Owning clock domain */
97 TAILQ_ENTRY(clknode) clkdom_link; /* Domain list entry */
98 TAILQ_ENTRY(clknode) clklist_link; /* Global list entry */
100 /* String based parent list. */
101 const char **parent_names; /* Array of parent names */
102 int parent_cnt; /* Number of parents */
103 int parent_idx; /* Parent index or -1 */
105 /* Cache for already resolved names. */
106 struct clknode **parents; /* Array of potential parents */
107 struct clknode *parent; /* Current parent */
109 /* Parent/child relationship links. */
110 clknode_list_t children; /* List of our children */
111 TAILQ_ENTRY(clknode) sibling_link; /* Our entry in parent's list */
113 /* Details of this device. */
114 void *softc; /* Instance softc */
115 const char *name; /* Globally unique name */
116 intptr_t id; /* Per domain unique id */
117 int flags; /* CLK_FLAG_* */
118 struct sx lock; /* Lock for this clock */
119 int ref_cnt; /* Reference counter */
120 int enable_cnt; /* Enabled counter */
123 uint64_t freq; /* Actual frequency */
125 struct sysctl_ctx_list sysctl_ctx;
129 * Per consumer data, information about how a consumer is using a clock node.
130 * A pointer to this structure is used as a handle in the consumer interface.
134 struct clknode *clknode;
139 * Clock domain - a group of clocks provided by one clock device.
142 device_t dev; /* Link to provider device */
143 TAILQ_ENTRY(clkdom) link; /* Global domain list entry */
144 clknode_list_t clknode_list; /* All clocks in the domain */
147 clknode_ofw_mapper_func *ofw_mapper; /* Find clock using FDT xref */
152 * The system-wide list of clock domains.
154 static clkdom_list_t clkdom_list = TAILQ_HEAD_INITIALIZER(clkdom_list);
157 * Each clock node is linked on a system-wide list and can be searched by name.
159 static clknode_list_t clknode_list = TAILQ_HEAD_INITIALIZER(clknode_list);
162 * Locking - we use three levels of locking:
163 * - First, topology lock is taken. This one protect all lists.
164 * - Second level is per clknode lock. It protects clknode data.
165 * - Third level is outside of this file, it protect clock device registers.
166 * First two levels use sleepable locks; clock device can use mutex or sx lock.
168 static struct sx clk_topo_lock;
169 SX_SYSINIT(clock_topology, &clk_topo_lock, "Clock topology lock");
171 #define CLK_TOPO_SLOCK() sx_slock(&clk_topo_lock)
172 #define CLK_TOPO_XLOCK() sx_xlock(&clk_topo_lock)
173 #define CLK_TOPO_UNLOCK() sx_unlock(&clk_topo_lock)
174 #define CLK_TOPO_ASSERT() sx_assert(&clk_topo_lock, SA_LOCKED)
175 #define CLK_TOPO_XASSERT() sx_assert(&clk_topo_lock, SA_XLOCKED)
177 #define CLKNODE_SLOCK(_sc) sx_slock(&((_sc)->lock))
178 #define CLKNODE_XLOCK(_sc) sx_xlock(&((_sc)->lock))
179 #define CLKNODE_UNLOCK(_sc) sx_unlock(&((_sc)->lock))
181 static void clknode_adjust_parent(struct clknode *clknode, int idx);
183 enum clknode_sysctl_type {
184 CLKNODE_SYSCTL_PARENT,
185 CLKNODE_SYSCTL_PARENTS_LIST,
186 CLKNODE_SYSCTL_CHILDREN_LIST,
189 static int clknode_sysctl(SYSCTL_HANDLER_ARGS);
190 static int clkdom_sysctl(SYSCTL_HANDLER_ARGS);
193 * Default clock methods for base class.
196 clknode_method_init(struct clknode *clknode, device_t dev)
203 clknode_method_recalc_freq(struct clknode *clknode, uint64_t *freq)
210 clknode_method_set_freq(struct clknode *clknode, uint64_t fin, uint64_t *fout,
211 int flags, int *stop)
219 clknode_method_set_gate(struct clknode *clk, bool enable)
226 clknode_method_set_mux(struct clknode *clk, int idx)
233 * Internal functions.
237 * Duplicate an array of parent names.
239 * Compute total size and allocate a single block which holds both the array of
240 * pointers to strings and the copied strings themselves. Returns a pointer to
241 * the start of the block where the array of copied string pointers lives.
243 * XXX Revisit this, no need for the DECONST stuff.
246 strdup_list(const char **names, int num)
249 const char **outptr, *ptr;
252 len = sizeof(char *) * num;
253 for (i = 0; i < num; i++) {
254 if (names[i] == NULL)
256 slen = strlen(names[i]);
258 panic("Clock parent names array have empty string");
261 outptr = malloc(len, M_CLOCK, M_WAITOK | M_ZERO);
262 ptr = (char *)(outptr + num);
263 for (i = 0; i < num; i++) {
264 if (names[i] == NULL)
267 slen = strlen(names[i]) + 1;
268 bcopy(names[i], __DECONST(void *, outptr[i]), slen);
275 * Recompute the cached frequency for this node and all its children.
278 clknode_refresh_cache(struct clknode *clknode, uint64_t freq)
281 struct clknode *entry;
285 /* Compute generated frequency. */
286 rv = CLKNODE_RECALC_FREQ(clknode, &freq);
288 /* XXX If an error happens while refreshing children
289 * this leaves the world in a partially-updated state.
292 panic("clknode_refresh_cache failed for '%s'\n",
296 /* Refresh cache for this node. */
297 clknode->freq = freq;
299 /* Refresh cache for all children. */
300 TAILQ_FOREACH(entry, &(clknode->children), sibling_link) {
301 rv = clknode_refresh_cache(entry, freq);
313 clknode_find_by_name(const char *name)
315 struct clknode *entry;
319 TAILQ_FOREACH(entry, &clknode_list, clklist_link) {
320 if (strcmp(entry->name, name) == 0)
327 clknode_find_by_id(struct clkdom *clkdom, intptr_t id)
329 struct clknode *entry;
333 TAILQ_FOREACH(entry, &clkdom->clknode_list, clkdom_link) {
341 /* -------------------------------------------------------------------------- */
343 * Clock domain functions
346 /* Find clock domain associated to device in global list. */
348 clkdom_get_by_dev(const device_t dev)
350 struct clkdom *entry;
354 TAILQ_FOREACH(entry, &clkdom_list, link) {
355 if (entry->dev == dev)
363 /* Default DT mapper. */
365 clknode_default_ofw_map(struct clkdom *clkdom, uint32_t ncells,
366 phandle_t *cells, struct clknode **clk)
372 *clk = clknode_find_by_id(clkdom, 1);
373 else if (ncells == 1)
374 *clk = clknode_find_by_id(clkdom, cells[0]);
385 * Create a clock domain. Returns with the topo lock held.
388 clkdom_create(device_t dev)
390 struct clkdom *clkdom;
392 clkdom = malloc(sizeof(struct clkdom), M_CLOCK, M_WAITOK | M_ZERO);
394 TAILQ_INIT(&clkdom->clknode_list);
396 clkdom->ofw_mapper = clknode_default_ofw_map;
399 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
400 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
402 CTLTYPE_STRING | CTLFLAG_RD,
403 clkdom, 0, clkdom_sysctl,
405 "Clock list for the domain");
411 clkdom_unlock(struct clkdom *clkdom)
418 clkdom_xlock(struct clkdom *clkdom)
425 * Finalize initialization of clock domain. Releases topo lock.
427 * XXX Revisit failure handling.
430 clkdom_finit(struct clkdom *clkdom)
432 struct clknode *clknode;
438 if ((node = ofw_bus_get_node(clkdom->dev)) == -1) {
439 device_printf(clkdom->dev,
440 "%s called on not ofw based device\n", __func__);
446 /* Make clock domain globally visible. */
448 TAILQ_INSERT_TAIL(&clkdom_list, clkdom, link);
450 OF_device_register_xref(OF_xref_from_node(node), clkdom->dev);
453 /* Register all clock names into global list. */
454 TAILQ_FOREACH(clknode, &clkdom->clknode_list, clkdom_link) {
455 TAILQ_INSERT_TAIL(&clknode_list, clknode, clklist_link);
458 * At this point all domain nodes must be registered and all
459 * parents must be valid.
461 TAILQ_FOREACH(clknode, &clkdom->clknode_list, clkdom_link) {
462 if (clknode->parent_cnt == 0)
464 for (i = 0; i < clknode->parent_cnt; i++) {
465 if (clknode->parents[i] != NULL)
467 if (clknode->parent_names[i] == NULL)
469 clknode->parents[i] = clknode_find_by_name(
470 clknode->parent_names[i]);
471 if (clknode->parents[i] == NULL) {
472 device_printf(clkdom->dev,
473 "Clock %s have unknown parent: %s\n",
474 clknode->name, clknode->parent_names[i]);
479 /* If parent index is not set yet... */
480 if (clknode->parent_idx == CLKNODE_IDX_NONE) {
481 device_printf(clkdom->dev,
482 "Clock %s have not set parent idx\n",
487 if (clknode->parents[clknode->parent_idx] == NULL) {
488 device_printf(clkdom->dev,
489 "Clock %s have unknown parent(idx %d): %s\n",
490 clknode->name, clknode->parent_idx,
491 clknode->parent_names[clknode->parent_idx]);
495 clknode_adjust_parent(clknode, clknode->parent_idx);
501 /* Dump clock domain. */
503 clkdom_dump(struct clkdom * clkdom)
505 struct clknode *clknode;
510 TAILQ_FOREACH(clknode, &clkdom->clknode_list, clkdom_link) {
511 rv = clknode_get_freq(clknode, &freq);
512 printf("Clock: %s, parent: %s(%d), freq: %ju\n", clknode->name,
513 clknode->parent == NULL ? "(NULL)" : clknode->parent->name,
515 (uintmax_t)((rv == 0) ? freq: rv));
521 * Create and initialize clock object, but do not register it.
524 clknode_create(struct clkdom * clkdom, clknode_class_t clknode_class,
525 const struct clknode_init_def *def)
527 struct clknode *clknode;
528 struct sysctl_oid *clknode_oid;
530 KASSERT(def->name != NULL, ("clock name is NULL"));
531 KASSERT(def->name[0] != '\0', ("clock name is empty"));
534 if (clknode_find_by_name(def->name) != NULL)
535 panic("Duplicated clock registration: %s\n", def->name);
539 /* Create object and initialize it. */
540 clknode = malloc(sizeof(struct clknode), M_CLOCK, M_WAITOK | M_ZERO);
541 kobj_init((kobj_t)clknode, (kobj_class_t)clknode_class);
542 sx_init(&clknode->lock, "Clocknode lock");
544 /* Allocate softc if required. */
545 if (clknode_class->size > 0) {
546 clknode->softc = malloc(clknode_class->size,
547 M_CLOCK, M_WAITOK | M_ZERO);
550 /* Prepare array for ptrs to parent clocks. */
551 clknode->parents = malloc(sizeof(struct clknode *) * def->parent_cnt,
552 M_CLOCK, M_WAITOK | M_ZERO);
554 /* Copy all strings unless they're flagged as static. */
555 if (def->flags & CLK_NODE_STATIC_STRINGS) {
556 clknode->name = def->name;
557 clknode->parent_names = def->parent_names;
559 clknode->name = strdup(def->name, M_CLOCK);
560 clknode->parent_names =
561 strdup_list(def->parent_names, def->parent_cnt);
565 clknode->id = def->id;
566 clknode->clkdom = clkdom;
567 clknode->flags = def->flags;
568 clknode->parent_cnt = def->parent_cnt;
569 clknode->parent = NULL;
570 clknode->parent_idx = CLKNODE_IDX_NONE;
571 TAILQ_INIT(&clknode->children);
573 sysctl_ctx_init(&clknode->sysctl_ctx);
574 clknode_oid = SYSCTL_ADD_NODE(&clknode->sysctl_ctx,
575 SYSCTL_STATIC_CHILDREN(_hw_clock),
576 OID_AUTO, clknode->name,
577 CTLFLAG_RD, 0, "A clock node");
579 SYSCTL_ADD_U64(&clknode->sysctl_ctx,
580 SYSCTL_CHILDREN(clknode_oid),
581 OID_AUTO, "frequency",
582 CTLFLAG_RD, &clknode->freq, 0, "The clock frequency");
583 SYSCTL_ADD_PROC(&clknode->sysctl_ctx,
584 SYSCTL_CHILDREN(clknode_oid),
586 CTLTYPE_STRING | CTLFLAG_RD,
587 clknode, CLKNODE_SYSCTL_PARENT, clknode_sysctl,
590 SYSCTL_ADD_PROC(&clknode->sysctl_ctx,
591 SYSCTL_CHILDREN(clknode_oid),
593 CTLTYPE_STRING | CTLFLAG_RD,
594 clknode, CLKNODE_SYSCTL_PARENTS_LIST, clknode_sysctl,
596 "The clock parents list");
597 SYSCTL_ADD_PROC(&clknode->sysctl_ctx,
598 SYSCTL_CHILDREN(clknode_oid),
599 OID_AUTO, "childrens",
600 CTLTYPE_STRING | CTLFLAG_RD,
601 clknode, CLKNODE_SYSCTL_CHILDREN_LIST, clknode_sysctl,
603 "The clock childrens list");
604 SYSCTL_ADD_INT(&clknode->sysctl_ctx,
605 SYSCTL_CHILDREN(clknode_oid),
606 OID_AUTO, "enable_cnt",
607 CTLFLAG_RD, &clknode->enable_cnt, 0, "The clock enable counter");
613 * Register clock object into clock domain hierarchy.
616 clknode_register(struct clkdom * clkdom, struct clknode *clknode)
620 rv = CLKNODE_INIT(clknode, clknode_get_device(clknode));
622 printf(" CLKNODE_INIT failed: %d\n", rv);
626 TAILQ_INSERT_TAIL(&clkdom->clknode_list, clknode, clkdom_link);
632 * Clock providers interface.
636 * Reparent clock node.
639 clknode_adjust_parent(struct clknode *clknode, int idx)
644 if (clknode->parent_cnt == 0)
646 if ((idx == CLKNODE_IDX_NONE) || (idx >= clknode->parent_cnt))
647 panic("%s: Invalid parent index %d for clock %s",
648 __func__, idx, clknode->name);
650 if (clknode->parents[idx] == NULL)
651 panic("%s: Invalid parent index %d for clock %s",
652 __func__, idx, clknode->name);
654 /* Remove me from old children list. */
655 if (clknode->parent != NULL) {
656 TAILQ_REMOVE(&clknode->parent->children, clknode, sibling_link);
659 /* Insert into children list of new parent. */
660 clknode->parent_idx = idx;
661 clknode->parent = clknode->parents[idx];
662 TAILQ_INSERT_TAIL(&clknode->parent->children, clknode, sibling_link);
666 * Set parent index - init function.
669 clknode_init_parent_idx(struct clknode *clknode, int idx)
672 if (clknode->parent_cnt == 0) {
673 clknode->parent_idx = CLKNODE_IDX_NONE;
674 clknode->parent = NULL;
677 if ((idx == CLKNODE_IDX_NONE) ||
678 (idx >= clknode->parent_cnt) ||
679 (clknode->parent_names[idx] == NULL))
680 panic("%s: Invalid parent index %d for clock %s",
681 __func__, idx, clknode->name);
682 clknode->parent_idx = idx;
686 clknode_set_parent_by_idx(struct clknode *clknode, int idx)
692 /* We have exclusive topology lock, node lock is not needed. */
695 if (clknode->parent_cnt == 0)
698 if (clknode->parent_idx == idx)
701 oldidx = clknode->parent_idx;
702 clknode_adjust_parent(clknode, idx);
703 rv = CLKNODE_SET_MUX(clknode, idx);
705 clknode_adjust_parent(clknode, oldidx);
708 rv = clknode_get_freq(clknode->parent, &freq);
711 rv = clknode_refresh_cache(clknode, freq);
716 clknode_set_parent_by_name(struct clknode *clknode, const char *name)
722 /* We have exclusive topology lock, node lock is not needed. */
725 if (clknode->parent_cnt == 0)
729 * If this node doesnt have mux, then passthrough request to parent.
730 * This feature is used in clock domain initialization and allows us to
731 * set clock source and target frequency on the tail node of the clock
734 if (clknode->parent_cnt == 1) {
735 rv = clknode_set_parent_by_name(clknode->parent, name);
739 for (idx = 0; idx < clknode->parent_cnt; idx++) {
740 if (clknode->parent_names[idx] == NULL)
742 if (strcmp(clknode->parent_names[idx], name) == 0)
745 if (idx >= clknode->parent_cnt) {
748 if (clknode->parent_idx == idx)
751 oldidx = clknode->parent_idx;
752 clknode_adjust_parent(clknode, idx);
753 rv = CLKNODE_SET_MUX(clknode, idx);
755 clknode_adjust_parent(clknode, oldidx);
756 CLKNODE_UNLOCK(clknode);
759 rv = clknode_get_freq(clknode->parent, &freq);
762 rv = clknode_refresh_cache(clknode, freq);
767 clknode_get_parent(struct clknode *clknode)
770 return (clknode->parent);
774 clknode_get_name(struct clknode *clknode)
777 return (clknode->name);
781 clknode_get_parent_names(struct clknode *clknode)
784 return (clknode->parent_names);
788 clknode_get_parents_num(struct clknode *clknode)
791 return (clknode->parent_cnt);
795 clknode_get_parent_idx(struct clknode *clknode)
798 return (clknode->parent_idx);
802 clknode_get_flags(struct clknode *clknode)
805 return (clknode->flags);
810 clknode_get_softc(struct clknode *clknode)
813 return (clknode->softc);
817 clknode_get_device(struct clknode *clknode)
820 return (clknode->clkdom->dev);
825 clkdom_set_ofw_mapper(struct clkdom * clkdom, clknode_ofw_mapper_func *map)
828 clkdom->ofw_mapper = map;
833 * Real consumers executive
836 clknode_get_freq(struct clknode *clknode, uint64_t *freq)
842 /* Use cached value, if it exists. */
843 *freq = clknode->freq;
847 /* Get frequency from parent, if the clock has a parent. */
848 if (clknode->parent_cnt > 0) {
849 rv = clknode_get_freq(clknode->parent, freq);
855 /* And recalculate my output frequency. */
856 CLKNODE_XLOCK(clknode);
857 rv = CLKNODE_RECALC_FREQ(clknode, freq);
859 CLKNODE_UNLOCK(clknode);
860 printf("Cannot get frequency for clk: %s, error: %d\n",
865 /* Save new frequency to cache. */
866 clknode->freq = *freq;
867 CLKNODE_UNLOCK(clknode);
872 clknode_set_freq(struct clknode *clknode, uint64_t freq, int flags,
876 uint64_t parent_freq;
878 /* We have exclusive topology lock, node lock is not needed. */
881 /* Check for no change */
882 if (clknode->freq == freq)
888 * We can set frequency only if
891 * clock is glitch free and is enabled by calling consumer only
893 if ((flags & CLK_SET_DRYRUN) == 0 &&
894 clknode->enable_cnt > 1 &&
895 clknode->enable_cnt > enablecnt &&
896 (clknode->flags & CLK_NODE_GLITCH_FREE) == 0) {
900 /* Get frequency from parent, if the clock has a parent. */
901 if (clknode->parent_cnt > 0) {
902 rv = clknode_get_freq(clknode->parent, &parent_freq);
908 /* Set frequency for this clock. */
909 rv = CLKNODE_SET_FREQ(clknode, parent_freq, &freq, flags, &done);
911 printf("Cannot set frequency for clk: %s, error: %d\n",
913 if ((flags & CLK_SET_DRYRUN) == 0)
914 clknode_refresh_cache(clknode, parent_freq);
919 /* Success - invalidate frequency cache for all children. */
920 if ((flags & CLK_SET_DRYRUN) == 0) {
921 clknode->freq = freq;
922 /* Clock might have reparent during set_freq */
923 if (clknode->parent_cnt > 0) {
924 rv = clknode_get_freq(clknode->parent,
930 clknode_refresh_cache(clknode, parent_freq);
932 } else if (clknode->parent != NULL) {
933 /* Nothing changed, pass request to parent. */
934 rv = clknode_set_freq(clknode->parent, freq, flags, enablecnt);
936 /* End of chain without action. */
937 printf("Cannot set frequency for clk: %s, end of chain\n",
946 clknode_enable(struct clknode *clknode)
952 /* Enable clock for each node in chain, starting from source. */
953 if (clknode->parent_cnt > 0) {
954 rv = clknode_enable(clknode->parent);
960 /* Handle this node */
961 CLKNODE_XLOCK(clknode);
962 if (clknode->enable_cnt == 0) {
963 rv = CLKNODE_SET_GATE(clknode, 1);
965 CLKNODE_UNLOCK(clknode);
969 clknode->enable_cnt++;
970 CLKNODE_UNLOCK(clknode);
975 clknode_disable(struct clknode *clknode)
982 CLKNODE_XLOCK(clknode);
983 /* Disable clock for each node in chain, starting from consumer. */
984 if ((clknode->enable_cnt == 1) &&
985 ((clknode->flags & CLK_NODE_CANNOT_STOP) == 0)) {
986 rv = CLKNODE_SET_GATE(clknode, 0);
988 CLKNODE_UNLOCK(clknode);
992 clknode->enable_cnt--;
993 CLKNODE_UNLOCK(clknode);
995 if (clknode->parent_cnt > 0) {
996 rv = clknode_disable(clknode->parent);
1002 clknode_stop(struct clknode *clknode, int depth)
1009 CLKNODE_XLOCK(clknode);
1010 /* The first node cannot be enabled. */
1011 if ((clknode->enable_cnt != 0) && (depth == 0)) {
1012 CLKNODE_UNLOCK(clknode);
1015 /* Stop clock for each node in chain, starting from consumer. */
1016 if ((clknode->enable_cnt == 0) &&
1017 ((clknode->flags & CLK_NODE_CANNOT_STOP) == 0)) {
1018 rv = CLKNODE_SET_GATE(clknode, 0);
1020 CLKNODE_UNLOCK(clknode);
1024 CLKNODE_UNLOCK(clknode);
1026 if (clknode->parent_cnt > 0)
1027 rv = clknode_stop(clknode->parent, depth + 1);
1031 /* --------------------------------------------------------------------------
1033 * Clock consumers interface.
1036 /* Helper function for clk_get*() */
1038 clk_create(struct clknode *clknode, device_t dev)
1044 clk = malloc(sizeof(struct clk), M_CLOCK, M_WAITOK);
1046 clk->clknode = clknode;
1047 clk->enable_cnt = 0;
1054 clk_get_freq(clk_t clk, uint64_t *freq)
1057 struct clknode *clknode;
1059 clknode = clk->clknode;
1060 KASSERT(clknode->ref_cnt > 0,
1061 ("Attempt to access unreferenced clock: %s\n", clknode->name));
1064 rv = clknode_get_freq(clknode, freq);
1070 clk_set_freq(clk_t clk, uint64_t freq, int flags)
1073 struct clknode *clknode;
1075 flags &= CLK_SET_USER_MASK;
1076 clknode = clk->clknode;
1077 KASSERT(clknode->ref_cnt > 0,
1078 ("Attempt to access unreferenced clock: %s\n", clknode->name));
1081 rv = clknode_set_freq(clknode, freq, flags, clk->enable_cnt);
1087 clk_test_freq(clk_t clk, uint64_t freq, int flags)
1090 struct clknode *clknode;
1092 flags &= CLK_SET_USER_MASK;
1093 clknode = clk->clknode;
1094 KASSERT(clknode->ref_cnt > 0,
1095 ("Attempt to access unreferenced clock: %s\n", clknode->name));
1098 rv = clknode_set_freq(clknode, freq, flags | CLK_SET_DRYRUN, 0);
1104 clk_get_parent(clk_t clk, clk_t *parent)
1106 struct clknode *clknode;
1107 struct clknode *parentnode;
1109 clknode = clk->clknode;
1110 KASSERT(clknode->ref_cnt > 0,
1111 ("Attempt to access unreferenced clock: %s\n", clknode->name));
1114 parentnode = clknode_get_parent(clknode);
1115 if (parentnode == NULL) {
1119 *parent = clk_create(parentnode, clk->dev);
1125 clk_set_parent_by_clk(clk_t clk, clk_t parent)
1128 struct clknode *clknode;
1129 struct clknode *parentnode;
1131 clknode = clk->clknode;
1132 parentnode = parent->clknode;
1133 KASSERT(clknode->ref_cnt > 0,
1134 ("Attempt to access unreferenced clock: %s\n", clknode->name));
1135 KASSERT(parentnode->ref_cnt > 0,
1136 ("Attempt to access unreferenced clock: %s\n", clknode->name));
1138 rv = clknode_set_parent_by_name(clknode, parentnode->name);
1144 clk_enable(clk_t clk)
1147 struct clknode *clknode;
1149 clknode = clk->clknode;
1150 KASSERT(clknode->ref_cnt > 0,
1151 ("Attempt to access unreferenced clock: %s\n", clknode->name));
1153 rv = clknode_enable(clknode);
1161 clk_disable(clk_t clk)
1164 struct clknode *clknode;
1166 clknode = clk->clknode;
1167 KASSERT(clknode->ref_cnt > 0,
1168 ("Attempt to access unreferenced clock: %s\n", clknode->name));
1169 KASSERT(clk->enable_cnt > 0,
1170 ("Attempt to disable already disabled clock: %s\n", clknode->name));
1172 rv = clknode_disable(clknode);
1183 struct clknode *clknode;
1185 clknode = clk->clknode;
1186 KASSERT(clknode->ref_cnt > 0,
1187 ("Attempt to access unreferenced clock: %s\n", clknode->name));
1188 KASSERT(clk->enable_cnt == 0,
1189 ("Attempt to stop already enabled clock: %s\n", clknode->name));
1192 rv = clknode_stop(clknode, 0);
1198 clk_release(clk_t clk)
1200 struct clknode *clknode;
1202 clknode = clk->clknode;
1203 KASSERT(clknode->ref_cnt > 0,
1204 ("Attempt to access unreferenced clock: %s\n", clknode->name));
1206 while (clk->enable_cnt > 0) {
1207 clknode_disable(clknode);
1210 CLKNODE_XLOCK(clknode);
1212 CLKNODE_UNLOCK(clknode);
1220 clk_get_name(clk_t clk)
1223 struct clknode *clknode;
1225 clknode = clk->clknode;
1226 KASSERT(clknode->ref_cnt > 0,
1227 ("Attempt to access unreferenced clock: %s\n", clknode->name));
1228 name = clknode_get_name(clknode);
1233 clk_get_by_name(device_t dev, const char *name, clk_t *clk)
1235 struct clknode *clknode;
1238 clknode = clknode_find_by_name(name);
1239 if (clknode == NULL) {
1243 *clk = clk_create(clknode, dev);
1249 clk_get_by_id(device_t dev, struct clkdom *clkdom, intptr_t id, clk_t *clk)
1251 struct clknode *clknode;
1255 clknode = clknode_find_by_id(clkdom, id);
1256 if (clknode == NULL) {
1260 *clk = clk_create(clknode, dev);
1269 clk_set_assigned_parent(device_t dev, clk_t clk, int idx)
1275 rv = clk_get_by_ofw_index_prop(dev, 0,
1276 "assigned-clock-parents", idx, &parent);
1279 "cannot get parent at idx %d\n", idx);
1283 pname = clk_get_name(parent);
1284 rv = clk_set_parent_by_clk(clk, parent);
1287 "Cannot set parent %s for clock %s\n",
1288 pname, clk_get_name(clk));
1289 else if (bootverbose)
1290 device_printf(dev, "Set %s as the parent of %s\n",
1291 pname, clk_get_name(clk));
1292 clk_release(parent);
1296 clk_set_assigned_rates(device_t dev, clk_t clk, uint32_t freq)
1300 rv = clk_set_freq(clk, freq, 0);
1302 device_printf(dev, "Failed to set %s to a frequency of %u\n",
1303 clk_get_name(clk), freq);
1307 device_printf(dev, "Set %s to %u\n",
1308 clk_get_name(clk), freq);
1312 clk_set_assigned(device_t dev, phandle_t node)
1316 int rv, nclocks, nrates, nparents, i;
1318 rv = ofw_bus_parse_xref_list_get_length(node,
1319 "assigned-clocks", "#clock-cells", &nclocks);
1324 "cannot parse assigned-clock property\n");
1328 nrates = OF_getencprop_alloc_multi(node, "assigned-clock-rates",
1329 sizeof(*rates), (void **)&rates);
1333 nparents = ofw_bus_parse_xref_list_get_length(node,
1334 "assigned-clock-parents", "#clock-cells", &nparents);
1336 for (i = 0; i < nclocks; i++) {
1337 /* First get the clock we are supposed to modify */
1338 rv = clk_get_by_ofw_index_prop(dev, 0, "assigned-clocks",
1343 "cannot get assigned clock at idx %d\n",
1348 /* First set it's parent if needed */
1350 clk_set_assigned_parent(dev, clk, i);
1352 /* Then set a new frequency */
1353 if (i <= nrates && rates[i] != 0)
1354 clk_set_assigned_rates(dev, clk, rates[i]);
1363 clk_get_by_ofw_index_prop(device_t dev, phandle_t cnode, const char *prop, int idx, clk_t *clk)
1365 phandle_t parent, *cells;
1368 struct clkdom *clkdom;
1369 struct clknode *clknode;
1373 cnode = ofw_bus_get_node(dev);
1375 device_printf(dev, "%s called on not ofw based device\n",
1381 rv = ofw_bus_parse_xref_list_alloc(cnode, prop, "#clock-cells", idx,
1382 &parent, &ncells, &cells);
1387 clockdev = OF_device_from_xref(parent);
1388 if (clockdev == NULL) {
1394 clkdom = clkdom_get_by_dev(clockdev);
1395 if (clkdom == NULL){
1401 rv = clkdom->ofw_mapper(clkdom, ncells, cells, &clknode);
1403 *clk = clk_create(clknode, dev);
1409 OF_prop_free(cells);
1414 clk_get_by_ofw_index(device_t dev, phandle_t cnode, int idx, clk_t *clk)
1416 return (clk_get_by_ofw_index_prop(dev, cnode, "clocks", idx, clk));
1420 clk_get_by_ofw_name(device_t dev, phandle_t cnode, const char *name, clk_t *clk)
1425 cnode = ofw_bus_get_node(dev);
1427 device_printf(dev, "%s called on not ofw based device\n",
1431 rv = ofw_bus_find_string_index(cnode, "clock-names", name, &idx);
1434 return (clk_get_by_ofw_index(dev, cnode, idx, clk));
1437 /* --------------------------------------------------------------------------
1439 * Support functions for parsing various clock related OFW things.
1443 * Get "clock-output-names" and (optional) "clock-indices" lists.
1444 * Both lists are alocated using M_OFWPROP specifier.
1446 * Returns number of items or 0.
1449 clk_parse_ofw_out_names(device_t dev, phandle_t node, const char ***out_names,
1456 if (!OF_hasprop(node, "clock-output-names"))
1458 rv = ofw_bus_string_list_to_array(node, "clock-output-names",
1464 if (!OF_hasprop(node, "clock-indices"))
1465 return (name_items);
1466 rv = OF_getencprop_alloc_multi(node, "clock-indices", sizeof (uint32_t),
1468 if (rv != name_items) {
1469 device_printf(dev, " Size of 'clock-output-names' and "
1470 "'clock-indices' differs\n");
1471 OF_prop_free(*out_names);
1472 OF_prop_free(*indices);
1475 return (name_items);
1479 * Get output clock name for single output clock node.
1482 clk_parse_ofw_clk_name(device_t dev, phandle_t node, const char **name)
1484 const char **out_names;
1485 const char *tmp_name;
1489 if (!OF_hasprop(node, "clock-output-names")) {
1490 tmp_name = ofw_bus_get_name(dev);
1491 if (tmp_name == NULL)
1493 *name = strdup(tmp_name, M_OFWPROP);
1496 rv = ofw_bus_string_list_to_array(node, "clock-output-names",
1499 OF_prop_free(out_names);
1500 device_printf(dev, "Malformed 'clock-output-names' property\n");
1503 *name = strdup(out_names[0], M_OFWPROP);
1504 OF_prop_free(out_names);
1510 clkdom_sysctl(SYSCTL_HANDLER_ARGS)
1512 struct clkdom *clkdom = arg1;
1513 struct clknode *clknode;
1517 sb = sbuf_new_for_sysctl(NULL, NULL, 4096, req);
1522 TAILQ_FOREACH(clknode, &clkdom->clknode_list, clkdom_link) {
1523 sbuf_printf(sb, "%s ", clknode->name);
1527 ret = sbuf_finish(sb);
1533 clknode_sysctl(SYSCTL_HANDLER_ARGS)
1535 struct clknode *clknode, *children;
1536 enum clknode_sysctl_type type = arg2;
1538 const char **parent_names;
1542 sb = sbuf_new_for_sysctl(NULL, NULL, 512, req);
1548 case CLKNODE_SYSCTL_PARENT:
1549 if (clknode->parent)
1550 sbuf_printf(sb, "%s", clknode->parent->name);
1552 case CLKNODE_SYSCTL_PARENTS_LIST:
1553 parent_names = clknode_get_parent_names(clknode);
1554 for (i = 0; i < clknode->parent_cnt; i++)
1555 sbuf_printf(sb, "%s ", parent_names[i]);
1557 case CLKNODE_SYSCTL_CHILDREN_LIST:
1558 TAILQ_FOREACH(children, &(clknode->children), sibling_link) {
1559 sbuf_printf(sb, "%s ", children->name);
1565 ret = sbuf_finish(sb);