Lines Matching refs:core
54 struct clk_core *core;
103 struct clk_core *core;
114 static int clk_pm_runtime_get(struct clk_core *core)
118 if (!core->rpm_enabled)
121 ret = pm_runtime_get_sync(core->dev);
123 pm_runtime_put_noidle(core->dev);
129 static void clk_pm_runtime_put(struct clk_core *core)
131 if (!core->rpm_enabled)
134 pm_runtime_put_sync(core->dev);
155 struct clk_core *core, *failed;
168 hlist_for_each_entry(core, &clk_rpm_list, rpm_node) {
169 ret = clk_pm_runtime_get(core);
171 failed = core;
181 hlist_for_each_entry(core, &clk_rpm_list, rpm_node) {
182 if (core == failed)
185 clk_pm_runtime_put(core);
200 struct clk_core *core;
202 hlist_for_each_entry(core, &clk_rpm_list, rpm_node)
203 clk_pm_runtime_put(core);
207 static void clk_pm_runtime_init(struct clk_core *core)
209 struct device *dev = core->dev;
212 core->rpm_enabled = true;
215 hlist_add_head(&core->rpm_node, &clk_rpm_list);
289 static bool clk_core_rate_is_protected(struct clk_core *core)
291 return core->protect_count;
294 static bool clk_core_is_prepared(struct clk_core *core)
302 if (!core->ops->is_prepared)
303 return core->prepare_count;
305 if (!clk_pm_runtime_get(core)) {
306 ret = core->ops->is_prepared(core->hw);
307 clk_pm_runtime_put(core);
313 static bool clk_core_is_enabled(struct clk_core *core)
321 if (!core->ops->is_enabled)
322 return core->enable_count;
334 if (core->rpm_enabled) {
335 pm_runtime_get_noresume(core->dev);
336 if (!pm_runtime_active(core->dev)) {
347 if ((core->flags & CLK_OPS_PARENT_ENABLE) && core->parent)
348 if (!clk_core_is_enabled(core->parent)) {
353 ret = core->ops->is_enabled(core->hw);
355 if (core->rpm_enabled)
356 pm_runtime_put(core->dev);
365 return !clk ? NULL : clk->core->name;
371 return hw->core->name;
377 return !clk ? NULL : clk->core->hw;
383 return hw->core->num_parents;
389 return hw->core->parent ? hw->core->parent->hw : NULL;
394 struct clk_core *core)
399 if (!strcmp(core->name, name))
400 return core;
402 hlist_for_each_entry(child, &core->children, child_node) {
457 * @core: clk to find parent of
491 static struct clk_core *clk_core_get(struct clk_core *core, u8 p_index)
493 const char *name = core->parents[p_index].fw_name;
494 int index = core->parents[p_index].index;
496 struct device *dev = core->dev;
498 struct device_node *np = core->of_node;
519 return hw->core;
522 static void clk_core_fill_parent_index(struct clk_core *core, u8 index)
524 struct clk_parent_map *entry = &core->parents[index];
528 parent = entry->hw->core;
537 parent = clk_core_get(core, index);
544 entry->core = parent;
547 static struct clk_core *clk_core_get_parent_by_index(struct clk_core *core,
550 if (!core || index >= core->num_parents || !core->parents)
553 if (!core->parents[index].core)
554 clk_core_fill_parent_index(core, index);
556 return core->parents[index].core;
564 parent = clk_core_get_parent_by_index(hw->core, index);
572 return !clk ? 0 : clk->core->enable_count;
575 static unsigned long clk_core_get_rate_nolock(struct clk_core *core)
577 if (!core)
580 if (!core->num_parents || core->parent)
581 return core->rate;
593 return clk_core_get_rate_nolock(hw->core);
597 static unsigned long clk_core_get_accuracy_no_lock(struct clk_core *core)
599 if (!core)
602 return core->accuracy;
607 return hw->core->flags;
613 return clk_core_is_prepared(hw->core);
619 return clk_core_rate_is_protected(hw->core);
625 return clk_core_is_enabled(hw->core);
634 return clk_core_is_enabled(clk->core);
651 struct clk_core *core = hw->core, *parent, *best_parent = NULL;
657 if (core->flags & CLK_SET_RATE_NO_REPARENT) {
658 parent = core->parent;
659 if (core->flags & CLK_SET_RATE_PARENT) {
669 best = clk_core_get_rate_nolock(core);
676 num_parents = core->num_parents;
678 parent = clk_core_get_parent_by_index(core, i);
682 if (core->flags & CLK_SET_RATE_PARENT) {
713 struct clk_core *core = clk_core_lookup(name);
715 return !core ? NULL : core->hw->clk;
718 static void clk_core_get_boundaries(struct clk_core *core,
726 *min_rate = core->min_rate;
727 *max_rate = core->max_rate;
729 hlist_for_each_entry(clk_user, &core->clks, clks_node)
732 hlist_for_each_entry(clk_user, &core->clks, clks_node)
736 static bool clk_core_check_boundaries(struct clk_core *core,
744 if (min_rate > core->max_rate || max_rate < core->min_rate)
747 hlist_for_each_entry(user, &core->clks, clks_node)
757 hw->core->min_rate = min_rate;
758 hw->core->max_rate = max_rate;
789 static void clk_core_rate_unprotect(struct clk_core *core)
793 if (!core)
796 if (WARN(core->protect_count == 0,
797 "%s already unprotected\n", core->name))
800 if (--core->protect_count > 0)
803 clk_core_rate_unprotect(core->parent);
806 static int clk_core_rate_nuke_protect(struct clk_core *core)
812 if (!core)
815 if (core->protect_count == 0)
818 ret = core->protect_count;
819 core->protect_count = 1;
820 clk_core_rate_unprotect(core);
857 clk_core_rate_unprotect(clk->core);
864 static void clk_core_rate_protect(struct clk_core *core)
868 if (!core)
871 if (core->protect_count == 0)
872 clk_core_rate_protect(core->parent);
874 core->protect_count++;
877 static void clk_core_rate_restore_protect(struct clk_core *core, int count)
881 if (!core)
887 clk_core_rate_protect(core);
888 core->protect_count = count;
915 clk_core_rate_protect(clk->core);
923 static void clk_core_unprepare(struct clk_core *core)
927 if (!core)
930 if (WARN(core->prepare_count == 0,
931 "%s already unprepared\n", core->name))
934 if (WARN(core->prepare_count == 1 && core->flags & CLK_IS_CRITICAL,
935 "Unpreparing critical %s\n", core->name))
938 if (core->flags & CLK_SET_RATE_GATE)
939 clk_core_rate_unprotect(core);
941 if (--core->prepare_count > 0)
944 WARN(core->enable_count > 0, "Unpreparing enabled %s\n", core->name);
946 trace_clk_unprepare(core);
948 if (core->ops->unprepare)
949 core->ops->unprepare(core->hw);
951 trace_clk_unprepare_complete(core);
952 clk_core_unprepare(core->parent);
953 clk_pm_runtime_put(core);
956 static void clk_core_unprepare_lock(struct clk_core *core)
959 clk_core_unprepare(core);
979 clk_core_unprepare_lock(clk->core);
983 static int clk_core_prepare(struct clk_core *core)
989 if (!core)
992 if (core->prepare_count == 0) {
993 ret = clk_pm_runtime_get(core);
997 ret = clk_core_prepare(core->parent);
1001 trace_clk_prepare(core);
1003 if (core->ops->prepare)
1004 ret = core->ops->prepare(core->hw);
1006 trace_clk_prepare_complete(core);
1012 core->prepare_count++;
1021 if (core->flags & CLK_SET_RATE_GATE)
1022 clk_core_rate_protect(core);
1026 clk_core_unprepare(core->parent);
1028 clk_pm_runtime_put(core);
1032 static int clk_core_prepare_lock(struct clk_core *core)
1037 ret = clk_core_prepare(core);
1060 return clk_core_prepare_lock(clk->core);
1064 static void clk_core_disable(struct clk_core *core)
1068 if (!core)
1071 if (WARN(core->enable_count == 0, "%s already disabled\n", core->name))
1074 if (WARN(core->enable_count == 1 && core->flags & CLK_IS_CRITICAL,
1075 "Disabling critical %s\n", core->name))
1078 if (--core->enable_count > 0)
1081 trace_clk_disable_rcuidle(core);
1083 if (core->ops->disable)
1084 core->ops->disable(core->hw);
1086 trace_clk_disable_complete_rcuidle(core);
1088 clk_core_disable(core->parent);
1091 static void clk_core_disable_lock(struct clk_core *core)
1096 clk_core_disable(core);
1117 clk_core_disable_lock(clk->core);
1121 static int clk_core_enable(struct clk_core *core)
1127 if (!core)
1130 if (WARN(core->prepare_count == 0,
1131 "Enabling unprepared %s\n", core->name))
1134 if (core->enable_count == 0) {
1135 ret = clk_core_enable(core->parent);
1140 trace_clk_enable_rcuidle(core);
1142 if (core->ops->enable)
1143 ret = core->ops->enable(core->hw);
1145 trace_clk_enable_complete_rcuidle(core);
1148 clk_core_disable(core->parent);
1153 core->enable_count++;
1157 static int clk_core_enable_lock(struct clk_core *core)
1163 ret = clk_core_enable(core);
1181 struct clk_core *core = hw->core;
1183 if (core->enable_count)
1184 core->ops->enable(hw);
1186 core->ops->disable(hw);
1190 static int clk_core_save_context(struct clk_core *core)
1195 hlist_for_each_entry(child, &core->children, child_node) {
1201 if (core->ops && core->ops->save_context)
1202 ret = core->ops->save_context(core->hw);
1207 static void clk_core_restore_context(struct clk_core *core)
1211 if (core->ops && core->ops->restore_context)
1212 core->ops->restore_context(core->hw);
1214 hlist_for_each_entry(child, &core->children, child_node)
1254 struct clk_core *core;
1256 hlist_for_each_entry(core, &clk_root_list, child_node)
1257 clk_core_restore_context(core);
1259 hlist_for_each_entry(core, &clk_orphan_list, child_node)
1260 clk_core_restore_context(core);
1282 return clk_core_enable_lock(clk->core);
1286 static int clk_core_prepare_enable(struct clk_core *core)
1290 ret = clk_core_prepare_lock(core);
1294 ret = clk_core_enable_lock(core);
1296 clk_core_unprepare_lock(core);
1301 static void clk_core_disable_unprepare(struct clk_core *core)
1303 clk_core_disable_lock(core);
1304 clk_core_unprepare_lock(core);
1307 static void __init clk_unprepare_unused_subtree(struct clk_core *core)
1313 hlist_for_each_entry(child, &core->children, child_node)
1316 if (core->prepare_count)
1319 if (core->flags & CLK_IGNORE_UNUSED)
1322 if (clk_core_is_prepared(core)) {
1323 trace_clk_unprepare(core);
1324 if (core->ops->unprepare_unused)
1325 core->ops->unprepare_unused(core->hw);
1326 else if (core->ops->unprepare)
1327 core->ops->unprepare(core->hw);
1328 trace_clk_unprepare_complete(core);
1332 static void __init clk_disable_unused_subtree(struct clk_core *core)
1339 hlist_for_each_entry(child, &core->children, child_node)
1342 if (core->flags & CLK_OPS_PARENT_ENABLE)
1343 clk_core_prepare_enable(core->parent);
1347 if (core->enable_count)
1350 if (core->flags & CLK_IGNORE_UNUSED)
1358 if (clk_core_is_enabled(core)) {
1359 trace_clk_disable(core);
1360 if (core->ops->disable_unused)
1361 core->ops->disable_unused(core->hw);
1362 else if (core->ops->disable)
1363 core->ops->disable(core->hw);
1364 trace_clk_disable_complete(core);
1369 if (core->flags & CLK_OPS_PARENT_ENABLE)
1370 clk_core_disable_unprepare(core->parent);
1383 struct clk_core *core;
1402 hlist_for_each_entry(core, &clk_root_list, child_node)
1403 clk_disable_unused_subtree(core);
1405 hlist_for_each_entry(core, &clk_orphan_list, child_node)
1406 clk_disable_unused_subtree(core);
1408 hlist_for_each_entry(core, &clk_root_list, child_node)
1409 clk_unprepare_unused_subtree(core);
1411 hlist_for_each_entry(core, &clk_orphan_list, child_node)
1412 clk_unprepare_unused_subtree(core);
1422 static int clk_core_determine_round_nolock(struct clk_core *core,
1429 if (!core)
1433 * At this point, core protection will be disabled if
1438 if (clk_core_rate_is_protected(core)) {
1439 req->rate = core->rate;
1440 } else if (core->ops->determine_rate) {
1441 return core->ops->determine_rate(core->hw, req);
1442 } else if (core->ops->round_rate) {
1443 rate = core->ops->round_rate(core->hw, req->rate,
1456 static void clk_core_init_rate_req(struct clk_core * const core,
1461 if (WARN_ON(!core || !req))
1464 parent = core->parent;
1474 static bool clk_core_can_round(struct clk_core * const core)
1476 return core->ops->determine_rate || core->ops->round_rate;
1479 static int clk_core_round_rate_nolock(struct clk_core *core,
1484 if (!core) {
1489 clk_core_init_rate_req(core, req);
1491 if (clk_core_can_round(core))
1492 return clk_core_determine_round_nolock(core, req);
1493 else if (core->flags & CLK_SET_RATE_PARENT)
1494 return clk_core_round_rate_nolock(core->parent, req);
1496 req->rate = core->rate;
1514 return clk_core_round_rate_nolock(hw->core, req);
1538 clk_core_get_boundaries(hw->core, &req.min_rate, &req.max_rate);
1541 ret = clk_core_round_rate_nolock(hw->core, &req);
1569 clk_core_rate_unprotect(clk->core);
1571 clk_core_get_boundaries(clk->core, &req.min_rate, &req.max_rate);
1574 ret = clk_core_round_rate_nolock(clk->core, &req);
1577 clk_core_rate_protect(clk->core);
1590 * @core: clk that is changing rate
1602 static int __clk_notify(struct clk_core *core, unsigned long msg,
1613 if (cn->clk->core == core) {
1627 * @core: first clk in the subtree
1634 static void __clk_recalc_accuracies(struct clk_core *core)
1641 if (core->parent)
1642 parent_accuracy = core->parent->accuracy;
1644 if (core->ops->recalc_accuracy)
1645 core->accuracy = core->ops->recalc_accuracy(core->hw,
1648 core->accuracy = parent_accuracy;
1650 hlist_for_each_entry(child, &core->children, child_node)
1654 static long clk_core_get_accuracy_recalc(struct clk_core *core)
1656 if (core && (core->flags & CLK_GET_ACCURACY_NOCACHE))
1657 __clk_recalc_accuracies(core);
1659 return clk_core_get_accuracy_no_lock(core);
1679 accuracy = clk_core_get_accuracy_recalc(clk->core);
1686 static unsigned long clk_recalc(struct clk_core *core,
1691 if (core->ops->recalc_rate && !clk_pm_runtime_get(core)) {
1692 rate = core->ops->recalc_rate(core->hw, parent_rate);
1693 clk_pm_runtime_put(core);
1700 * @core: first clk in the subtree
1710 static void __clk_recalc_rates(struct clk_core *core, unsigned long msg)
1718 old_rate = core->rate;
1720 if (core->parent)
1721 parent_rate = core->parent->rate;
1723 core->rate = clk_recalc(core, parent_rate);
1729 if (core->notifier_count && msg)
1730 __clk_notify(core, msg, old_rate, core->rate);
1732 hlist_for_each_entry(child, &core->children, child_node)
1736 static unsigned long clk_core_get_rate_recalc(struct clk_core *core)
1738 if (core && (core->flags & CLK_GET_RATE_NOCACHE))
1739 __clk_recalc_rates(core, 0);
1741 return clk_core_get_rate_nolock(core);
1760 rate = clk_core_get_rate_recalc(clk->core);
1767 static int clk_fetch_parent_index(struct clk_core *core,
1775 for (i = 0; i < core->num_parents; i++) {
1777 if (core->parents[i].core == parent)
1781 if (core->parents[i].core)
1784 /* Maybe core hasn't been cached but the hw is all we know? */
1785 if (core->parents[i].hw) {
1786 if (core->parents[i].hw == parent->hw)
1794 if (parent == clk_core_get(core, i))
1798 if (core->parents[i].name &&
1799 !strcmp(parent->name, core->parents[i].name))
1803 if (i == core->num_parents)
1806 core->parents[i].core = parent;
1824 return clk_fetch_parent_index(hw->core, parent->core);
1829 * Update the orphan status of @core and all its children.
1831 static void clk_core_update_orphan_status(struct clk_core *core, bool is_orphan)
1835 core->orphan = is_orphan;
1837 hlist_for_each_entry(child, &core->children, child_node)
1841 static void clk_reparent(struct clk_core *core, struct clk_core *new_parent)
1843 bool was_orphan = core->orphan;
1845 hlist_del(&core->child_node);
1851 if (new_parent->new_child == core)
1854 hlist_add_head(&core->child_node, &new_parent->children);
1857 clk_core_update_orphan_status(core, becomes_orphan);
1859 hlist_add_head(&core->child_node, &clk_orphan_list);
1861 clk_core_update_orphan_status(core, true);
1864 core->parent = new_parent;
1867 static struct clk_core *__clk_set_parent_before(struct clk_core *core,
1871 struct clk_core *old_parent = core->parent;
1894 if (core->flags & CLK_OPS_PARENT_ENABLE) {
1900 if (core->prepare_count) {
1902 clk_core_enable_lock(core);
1907 clk_reparent(core, parent);
1913 static void __clk_set_parent_after(struct clk_core *core,
1921 if (core->prepare_count) {
1922 clk_core_disable_lock(core);
1927 if (core->flags & CLK_OPS_PARENT_ENABLE) {
1933 static int __clk_set_parent(struct clk_core *core, struct clk_core *parent,
1940 old_parent = __clk_set_parent_before(core, parent);
1942 trace_clk_set_parent(core, parent);
1945 if (parent && core->ops->set_parent)
1946 ret = core->ops->set_parent(core->hw, p_index);
1948 trace_clk_set_parent_complete(core, parent);
1952 clk_reparent(core, old_parent);
1954 __clk_set_parent_after(core, old_parent, parent);
1959 __clk_set_parent_after(core, parent, old_parent);
1966 * @core: first clk in the subtree
1978 static int __clk_speculate_rates(struct clk_core *core,
1987 new_rate = clk_recalc(core, parent_rate);
1990 if (core->notifier_count)
1991 ret = __clk_notify(core, PRE_RATE_CHANGE, core->rate, new_rate);
1995 __func__, core->name, ret);
1999 hlist_for_each_entry(child, &core->children, child_node) {
2009 static void clk_calc_subtree(struct clk_core *core, unsigned long new_rate,
2014 core->new_rate = new_rate;
2015 core->new_parent = new_parent;
2016 core->new_parent_index = p_index;
2018 core->new_child = NULL;
2019 if (new_parent && new_parent != core->parent)
2020 new_parent->new_child = core;
2022 hlist_for_each_entry(child, &core->children, child_node) {
2032 static struct clk_core *clk_calc_new_rates(struct clk_core *core,
2035 struct clk_core *top = core;
2045 if (IS_ERR_OR_NULL(core))
2049 parent = old_parent = core->parent;
2053 clk_core_get_boundaries(core, &min_rate, &max_rate);
2056 if (clk_core_can_round(core)) {
2063 clk_core_init_rate_req(core, &req);
2065 ret = clk_core_determine_round_nolock(core, &req);
2071 parent = req.best_parent_hw ? req.best_parent_hw->core : NULL;
2075 } else if (!parent || !(core->flags & CLK_SET_RATE_PARENT)) {
2077 core->new_rate = core->rate;
2088 (core->flags & CLK_SET_PARENT_GATE) && core->prepare_count) {
2090 __func__, core->name);
2095 if (parent && core->num_parents > 1) {
2096 p_index = clk_fetch_parent_index(core, parent);
2099 __func__, parent->name, core->name);
2104 if ((core->flags & CLK_SET_RATE_PARENT) && parent &&
2109 clk_calc_subtree(core, new_rate, parent, p_index);
2119 static struct clk_core *clk_propagate_rate_change(struct clk_core *core,
2125 if (core->rate == core->new_rate)
2128 if (core->notifier_count) {
2129 ret = __clk_notify(core, event, core->rate, core->new_rate);
2131 fail_clk = core;
2134 hlist_for_each_entry(child, &core->children, child_node) {
2136 if (child->new_parent && child->new_parent != core)
2143 /* handle the new child who might not be in core->children yet */
2144 if (core->new_child) {
2145 tmp_clk = clk_propagate_rate_change(core->new_child, event);
2157 static void clk_change_rate(struct clk_core *core)
2167 old_rate = core->rate;
2169 if (core->new_parent) {
2170 parent = core->new_parent;
2171 best_parent_rate = core->new_parent->rate;
2172 } else if (core->parent) {
2173 parent = core->parent;
2174 best_parent_rate = core->parent->rate;
2177 if (clk_pm_runtime_get(core))
2180 if (core->flags & CLK_SET_RATE_UNGATE) {
2183 clk_core_prepare(core);
2185 clk_core_enable(core);
2189 if (core->new_parent && core->new_parent != core->parent) {
2190 old_parent = __clk_set_parent_before(core, core->new_parent);
2191 trace_clk_set_parent(core, core->new_parent);
2193 if (core->ops->set_rate_and_parent) {
2195 core->ops->set_rate_and_parent(core->hw, core->new_rate,
2197 core->new_parent_index);
2198 } else if (core->ops->set_parent) {
2199 core->ops->set_parent(core->hw, core->new_parent_index);
2202 trace_clk_set_parent_complete(core, core->new_parent);
2203 __clk_set_parent_after(core, core->new_parent, old_parent);
2206 if (core->flags & CLK_OPS_PARENT_ENABLE)
2209 trace_clk_set_rate(core, core->new_rate);
2211 if (!skip_set_rate && core->ops->set_rate)
2212 core->ops->set_rate(core->hw, core->new_rate, best_parent_rate);
2214 trace_clk_set_rate_complete(core, core->new_rate);
2216 core->rate = clk_recalc(core, best_parent_rate);
2218 if (core->flags & CLK_SET_RATE_UNGATE) {
2222 clk_core_disable(core);
2224 clk_core_unprepare(core);
2227 if (core->flags & CLK_OPS_PARENT_ENABLE)
2230 if (core->notifier_count && old_rate != core->rate)
2231 __clk_notify(core, POST_RATE_CHANGE, old_rate, core->rate);
2233 if (core->flags & CLK_RECALC_NEW_RATES)
2234 (void)clk_calc_new_rates(core, core->new_rate);
2240 hlist_for_each_entry_safe(child, tmp, &core->children, child_node) {
2242 if (child->new_parent && child->new_parent != core)
2247 /* handle the new child who might not be in core->children yet */
2248 if (core->new_child)
2249 clk_change_rate(core->new_child);
2251 clk_pm_runtime_put(core);
2254 static unsigned long clk_core_req_round_rate_nolock(struct clk_core *core,
2262 if (!core)
2266 cnt = clk_core_rate_nuke_protect(core);
2270 clk_core_get_boundaries(core, &req.min_rate, &req.max_rate);
2273 ret = clk_core_round_rate_nolock(core, &req);
2276 clk_core_rate_restore_protect(core, cnt);
2281 static int clk_core_set_rate_nolock(struct clk_core *core,
2288 if (!core)
2291 rate = clk_core_req_round_rate_nolock(core, req_rate);
2294 if (rate == clk_core_get_rate_nolock(core))
2298 if (clk_core_rate_is_protected(core))
2302 top = clk_calc_new_rates(core, req_rate);
2306 ret = clk_pm_runtime_get(core);
2323 core->req_rate = req_rate;
2325 clk_pm_runtime_put(core);
2362 clk_core_rate_unprotect(clk->core);
2364 ret = clk_core_set_rate_nolock(clk->core, rate);
2367 clk_core_rate_protect(clk->core);
2410 ret = clk_core_set_rate_nolock(clk->core, rate);
2412 clk_core_rate_protect(clk->core);
2440 __func__, clk->core->name, clk->dev_id, clk->con_id,
2448 clk_core_rate_unprotect(clk->core);
2456 if (!clk_core_check_boundaries(clk->core, min, max)) {
2461 rate = clk_core_get_rate_nolock(clk->core);
2481 ret = clk_core_set_rate_nolock(clk->core, rate);
2491 clk_core_rate_protect(clk->core);
2546 parent = !clk->core->parent ? NULL : clk->core->parent->hw->clk;
2553 static struct clk_core *__clk_init_parent(struct clk_core *core)
2557 if (core->num_parents > 1 && core->ops->get_parent)
2558 index = core->ops->get_parent(core->hw);
2560 return clk_core_get_parent_by_index(core, index);
2563 static void clk_core_reparent(struct clk_core *core,
2566 clk_reparent(core, new_parent);
2567 __clk_recalc_accuracies(core);
2568 __clk_recalc_rates(core, POST_RATE_CHANGE);
2576 clk_core_reparent(hw->core, !new_parent ? NULL : new_parent->core);
2591 struct clk_core *core, *parent_core;
2598 core = clk->core;
2599 parent_core = parent->core;
2602 if (core->parent == parent_core)
2605 for (i = 0; i < core->num_parents; i++)
2606 if (!strcmp(core->parents[i].name, parent_core->name))
2613 static int clk_core_set_parent_nolock(struct clk_core *core,
2622 if (!core)
2625 if (core->parent == parent)
2629 if (core->num_parents > 1 && !core->ops->set_parent)
2633 if ((core->flags & CLK_SET_PARENT_GATE) && core->prepare_count)
2636 if (clk_core_rate_is_protected(core))
2641 p_index = clk_fetch_parent_index(core, parent);
2644 __func__, parent->name, core->name);
2650 ret = clk_pm_runtime_get(core);
2655 ret = __clk_speculate_rates(core, p_rate);
2662 ret = __clk_set_parent(core, parent, p_index);
2666 __clk_recalc_rates(core, ABORT_RATE_CHANGE);
2668 __clk_recalc_rates(core, POST_RATE_CHANGE);
2669 __clk_recalc_accuracies(core);
2673 clk_pm_runtime_put(core);
2680 return clk_core_set_parent_nolock(hw->core, parent->core);
2711 clk_core_rate_unprotect(clk->core);
2713 ret = clk_core_set_parent_nolock(clk->core,
2714 parent ? parent->core : NULL);
2717 clk_core_rate_protect(clk->core);
2725 static int clk_core_set_phase_nolock(struct clk_core *core, int degrees)
2731 if (!core)
2734 if (clk_core_rate_is_protected(core))
2737 trace_clk_set_phase(core, degrees);
2739 if (core->ops->set_phase) {
2740 ret = core->ops->set_phase(core->hw, degrees);
2742 core->phase = degrees;
2745 trace_clk_set_phase_complete(core, degrees);
2785 clk_core_rate_unprotect(clk->core);
2787 ret = clk_core_set_phase_nolock(clk->core, degrees);
2790 clk_core_rate_protect(clk->core);
2798 static int clk_core_get_phase(struct clk_core *core)
2803 if (!core->ops->get_phase)
2807 ret = core->ops->get_phase(core->hw);
2809 core->phase = ret;
2829 ret = clk_core_get_phase(clk->core);
2836 static void clk_core_reset_duty_cycle_nolock(struct clk_core *core)
2839 core->duty.num = 1;
2840 core->duty.den = 2;
2843 static int clk_core_update_duty_cycle_parent_nolock(struct clk_core *core);
2845 static int clk_core_update_duty_cycle_nolock(struct clk_core *core)
2847 struct clk_duty *duty = &core->duty;
2850 if (!core->ops->get_duty_cycle)
2851 return clk_core_update_duty_cycle_parent_nolock(core);
2853 ret = core->ops->get_duty_cycle(core->hw, duty);
2866 clk_core_reset_duty_cycle_nolock(core);
2870 static int clk_core_update_duty_cycle_parent_nolock(struct clk_core *core)
2874 if (core->parent &&
2875 core->flags & CLK_DUTY_CYCLE_PARENT) {
2876 ret = clk_core_update_duty_cycle_nolock(core->parent);
2877 memcpy(&core->duty, &core->parent->duty, sizeof(core->duty));
2879 clk_core_reset_duty_cycle_nolock(core);
2885 static int clk_core_set_duty_cycle_parent_nolock(struct clk_core *core,
2888 static int clk_core_set_duty_cycle_nolock(struct clk_core *core,
2895 if (clk_core_rate_is_protected(core))
2898 trace_clk_set_duty_cycle(core, duty);
2900 if (!core->ops->set_duty_cycle)
2901 return clk_core_set_duty_cycle_parent_nolock(core, duty);
2903 ret = core->ops->set_duty_cycle(core->hw, duty);
2905 memcpy(&core->duty, duty, sizeof(*duty));
2907 trace_clk_set_duty_cycle_complete(core, duty);
2912 static int clk_core_set_duty_cycle_parent_nolock(struct clk_core *core,
2917 if (core->parent &&
2918 core->flags & (CLK_DUTY_CYCLE_PARENT | CLK_SET_RATE_PARENT)) {
2919 ret = clk_core_set_duty_cycle_nolock(core->parent, duty);
2920 memcpy(&core->duty, &core->parent->duty, sizeof(core->duty));
2955 clk_core_rate_unprotect(clk->core);
2957 ret = clk_core_set_duty_cycle_nolock(clk->core, &duty);
2960 clk_core_rate_protect(clk->core);
2968 static int clk_core_get_scaled_duty_cycle(struct clk_core *core,
2971 struct clk_duty *duty = &core->duty;
2976 ret = clk_core_update_duty_cycle_nolock(core);
2998 return clk_core_get_scaled_duty_cycle(clk->core, scale);
3019 /* true if clk->core pointers match. Avoid dereferencing garbage */
3021 if (p->core == q->core)
3167 struct clk_core *core = data;
3171 ret = clk_core_set_rate_nolock(core, val);
3181 struct clk_core *core = data;
3185 ret = clk_prepare_enable(core->hw->clk);
3187 clk_disable_unprepare(core->hw->clk);
3194 struct clk_core *core = data;
3196 *val = core->enable_count && core->prepare_count;
3210 struct clk_core *core = data;
3212 *val = core->rate;
3240 struct clk_core *core = s->private;
3241 unsigned long flags = core->flags;
3259 static void possible_parent_show(struct seq_file *s, struct clk_core *core,
3277 parent = clk_core_get_parent_by_index(core, i);
3280 } else if (core->parents[i].name) {
3281 seq_puts(s, core->parents[i].name);
3282 } else if (core->parents[i].fw_name) {
3283 seq_printf(s, "<%s>(fw)", core->parents[i].fw_name);
3285 if (core->parents[i].index >= 0)
3286 name = of_clk_get_parent_name(core->of_node, core->parents[i].index);
3298 struct clk_core *core = s->private;
3301 for (i = 0; i < core->num_parents - 1; i++)
3302 possible_parent_show(s, core, i, ' ');
3304 possible_parent_show(s, core, i, '\n');
3312 struct clk_core *core = s->private;
3314 if (core->parent)
3315 seq_printf(s, "%s\n", core->parent->name);
3323 struct clk_core *core = s->private;
3324 struct clk_duty *duty = &core->duty;
3334 struct clk_core *core = s->private;
3338 clk_core_get_boundaries(core, &min_rate, &max_rate);
3348 struct clk_core *core = s->private;
3352 clk_core_get_boundaries(core, &min_rate, &max_rate);
3360 static void clk_debug_create_one(struct clk_core *core, struct dentry *pdentry)
3364 if (!core || !pdentry)
3367 root = debugfs_create_dir(core->name, pdentry);
3368 core->dentry = root;
3370 debugfs_create_file("clk_rate", clk_rate_mode, root, core,
3372 debugfs_create_file("clk_min_rate", 0444, root, core, &clk_min_rate_fops);
3373 debugfs_create_file("clk_max_rate", 0444, root, core, &clk_max_rate_fops);
3374 debugfs_create_ulong("clk_accuracy", 0444, root, &core->accuracy);
3375 debugfs_create_u32("clk_phase", 0444, root, &core->phase);
3376 debugfs_create_file("clk_flags", 0444, root, core, &clk_flags_fops);
3377 debugfs_create_u32("clk_prepare_count", 0444, root, &core->prepare_count);
3378 debugfs_create_u32("clk_enable_count", 0444, root, &core->enable_count);
3379 debugfs_create_u32("clk_protect_count", 0444, root, &core->protect_count);
3380 debugfs_create_u32("clk_notifier_count", 0444, root, &core->notifier_count);
3381 debugfs_create_file("clk_duty_cycle", 0444, root, core,
3384 debugfs_create_file("clk_prepare_enable", 0644, root, core,
3388 if (core->num_parents > 0)
3389 debugfs_create_file("clk_parent", 0444, root, core,
3392 if (core->num_parents > 1)
3393 debugfs_create_file("clk_possible_parents", 0444, root, core,
3396 if (core->ops->debug_init)
3397 core->ops->debug_init(core->hw, core->dentry);
3402 * @core: the clk being added to the debugfs clk directory
3408 static void clk_debug_register(struct clk_core *core)
3411 hlist_add_head(&core->debug_node, &clk_debug_list);
3413 clk_debug_create_one(core, rootdir);
3419 * @core: the clk being removed from the debugfs clk directory
3425 static void clk_debug_unregister(struct clk_core *core)
3428 hlist_del_init(&core->debug_node);
3429 debugfs_remove_recursive(core->dentry);
3430 core->dentry = NULL;
3445 struct clk_core *core;
3477 hlist_for_each_entry(core, &clk_debug_list, debug_node)
3478 clk_debug_create_one(core, rootdir);
3487 static inline void clk_debug_register(struct clk_core *core) { }
3488 static inline void clk_debug_unregister(struct clk_core *core)
3536 * @core: clk_core being initialized
3541 static int __clk_core_init(struct clk_core *core)
3548 if (!core)
3554 * Set hw->core after grabbing the prepare_lock to synchronize with
3555 * callers of clk_core_fill_parent_index() where we treat hw->core
3559 core->hw->core = core;
3561 ret = clk_pm_runtime_get(core);
3566 if (clk_core_lookup(core->name)) {
3568 __func__, core->name);
3574 if (core->ops->set_rate &&
3575 !((core->ops->round_rate || core->ops->determine_rate) &&
3576 core->ops->recalc_rate)) {
3578 __func__, core->name);
3583 if (core->ops->set_parent && !core->ops->get_parent) {
3585 __func__, core->name);
3590 if (core->num_parents > 1 && !core->ops->get_parent) {
3592 __func__, core->name);
3597 if (core->ops->set_rate_and_parent &&
3598 !(core->ops->set_parent && core->ops->set_rate)) {
3600 __func__, core->name);
3619 if (core->ops->init) {
3620 ret = core->ops->init(core->hw);
3625 parent = core->parent = __clk_init_parent(core);
3628 * Populate core->parent if parent has already been clk_core_init'd. If
3638 hlist_add_head(&core->child_node, &parent->children);
3639 core->orphan = parent->orphan;
3640 } else if (!core->num_parents) {
3641 hlist_add_head(&core->child_node, &clk_root_list);
3642 core->orphan = false;
3644 hlist_add_head(&core->child_node, &clk_orphan_list);
3645 core->orphan = true;
3655 if (core->ops->recalc_accuracy)
3656 core->accuracy = core->ops->recalc_accuracy(core->hw,
3659 core->accuracy = parent->accuracy;
3661 core->accuracy = 0;
3668 phase = clk_core_get_phase(core);
3672 core->name);
3679 clk_core_update_duty_cycle_nolock(core);
3687 if (core->ops->recalc_rate)
3688 rate = core->ops->recalc_rate(core->hw,
3694 core->rate = core->req_rate = rate;
3701 if (core->flags & CLK_IS_CRITICAL) {
3704 ret = clk_core_prepare(core);
3707 __func__, core->name);
3712 ret = clk_core_enable(core);
3716 __func__, core->name);
3717 clk_core_unprepare(core);
3724 clk_pm_runtime_put(core);
3727 hlist_del_init(&core->child_node);
3728 core->hw->core = NULL;
3734 clk_debug_register(core);
3741 * @core: clk to add consumer to
3744 static void clk_core_link_consumer(struct clk_core *core, struct clk *clk)
3747 hlist_add_head(&clk->clks_node, &core->clks);
3763 * @core: clk to allocate a consumer for
3769 static struct clk *alloc_clk(struct clk_core *core, const char *dev_id,
3778 clk->core = core;
3815 struct clk_core *core;
3821 core = hw->core;
3822 clk = alloc_clk(core, dev_id, con_id);
3827 if (!try_module_get(core->owner)) {
3832 kref_get(&core->ref);
3833 clk_core_link_consumer(core, clk);
3855 static int clk_core_populate_parent_map(struct clk_core *core,
3873 core->parents = parents;
3884 __func__, core->name);
3917 static void clk_core_free_parent_map(struct clk_core *core)
3919 int i = core->num_parents;
3921 if (!core->num_parents)
3925 kfree_const(core->parents[i].name);
3926 kfree_const(core->parents[i].fw_name);
3929 kfree(core->parents);
3935 struct clk_core *core = container_of(ref, struct clk_core, ref);
3937 if (core->rpm_enabled) {
3939 hlist_del(&core->rpm_node);
3943 clk_core_free_parent_map(core);
3944 kfree_const(core->name);
3945 kfree(core);
3952 struct clk_core *core;
3958 * we catch use of hw->init early on in the core.
3962 core = kzalloc(sizeof(*core), GFP_KERNEL);
3963 if (!core) {
3968 kref_init(&core->ref);
3970 core->name = kstrdup_const(init->name, GFP_KERNEL);
3971 if (!core->name) {
3980 core->ops = init->ops;
3982 core->dev = dev;
3983 clk_pm_runtime_init(core);
3984 core->of_node = np;
3986 core->owner = dev->driver->owner;
3987 core->hw = hw;
3988 core->flags = init->flags;
3989 core->num_parents = init->num_parents;
3990 core->min_rate = 0;
3991 core->max_rate = ULONG_MAX;
3993 ret = clk_core_populate_parent_map(core, init);
3997 INIT_HLIST_HEAD(&core->clks);
4003 hw->clk = alloc_clk(core, NULL, NULL);
4009 clk_core_link_consumer(core, hw->clk);
4011 ret = __clk_core_init(core);
4026 kref_put(&core->ref, __clk_release);
4148 if (root->parents[i].core == target)
4149 root->parents[i].core = NULL;
4156 static void clk_core_evict_parent_cache(struct clk_core *core)
4165 clk_core_evict_parent_cache_subtree(root, core);
4181 clk_debug_unregister(clk->core);
4185 ops = clk->core->ops;
4188 clk->core->name);
4196 clk->core->ops = &clk_nodrv_ops;
4200 ops->terminate(clk->core->hw);
4202 if (!hlist_empty(&clk->core->children)) {
4207 hlist_for_each_entry_safe(child, t, &clk->core->children,
4212 clk_core_evict_parent_cache(clk->core);
4214 hlist_del_init(&clk->core->child_node);
4216 if (clk->core->prepare_count)
4218 __func__, clk->core->name);
4220 if (clk->core->protect_count)
4222 __func__, clk->core->name);
4224 kref_put(&clk->core->ref, __clk_release);
4380 clk->core->protect_count -= (clk->exclusive_count - 1);
4381 clk_core_rate_unprotect(clk->core);
4386 if (clk->min_rate > clk->core->req_rate ||
4387 clk->max_rate < clk->core->req_rate)
4388 clk_core_set_rate_nolock(clk->core, clk->core->req_rate);
4390 owner = clk->core->owner;
4391 kref_put(&clk->core->ref, __clk_release);
4450 clk->core->notifier_count++;
4484 clk->core->notifier_count--;