507 lines
10 KiB
C
507 lines
10 KiB
C
/*
|
|
* Copyright (C) All rights reserved.
|
|
* Allwinner Technology Co., Ltd. <www.allwinnertech.com>
|
|
* Author: z.q <zengqi@allwinnertech.com>
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
/*
|
|
* This file contains clk functions, adapt for clk operation in boot.
|
|
*/
|
|
|
|
#include<clk/clk.h>
|
|
#include <fdt_support.h>
|
|
|
|
__attribute__((section(".data")))
|
|
static HLIST_HEAD(clk_list);
|
|
|
|
struct clk *__clk_lookup(const char *name)
|
|
{
|
|
struct clk *root_clk;
|
|
struct hlist_node *tmp;
|
|
int test_count = 0;
|
|
|
|
if (!name)
|
|
return NULL;
|
|
|
|
/* search the 'proper' clk tree first */
|
|
hlist_for_each_entry(root_clk, tmp, &clk_list, child_node) {
|
|
test_count++;
|
|
if (!strcmp(root_clk->name, name))
|
|
return root_clk;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void __clk_disable(struct clk *clk)
|
|
{
|
|
if (!clk)
|
|
return;
|
|
|
|
if (clk->enable_count == 0)
|
|
return;
|
|
|
|
if (--clk->enable_count > 0)
|
|
return;
|
|
|
|
if (clk->ops->disable)
|
|
clk->ops->disable(clk->hw);
|
|
|
|
__clk_disable(clk->parent);
|
|
}
|
|
|
|
unsigned long __clk_get_rate(struct clk *clk)
|
|
{
|
|
unsigned long ret;
|
|
|
|
if (!clk) {
|
|
ret = 0;
|
|
goto out;
|
|
}
|
|
ret = clk->rate;
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
static int __clk_enable(struct clk *clk)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (!clk) {
|
|
|
|
printf("%s: clk is null.\n", __func__);
|
|
return -1;
|
|
}
|
|
if (clk->flags & CLK_IS_ROOT) {
|
|
/* printf("%s: clk is root.\n",__func__); */
|
|
return 0;
|
|
}
|
|
|
|
if (clk->enable_count == 0) {
|
|
ret = __clk_enable(clk->parent);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (clk->ops->enable) {
|
|
ret = clk->ops->enable(clk->hw);
|
|
if (ret) {
|
|
__clk_disable(clk->parent);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
clk->enable_count++;
|
|
return 0;
|
|
}
|
|
|
|
static int __clk_set_parent(struct clk *clk, struct clk *parent)
|
|
{
|
|
struct clk *old_parent;
|
|
int ret = -1;
|
|
u8 i;
|
|
|
|
old_parent = clk->parent;
|
|
|
|
if (!clk->parents) {
|
|
clk->parents = malloc(sizeof(struct clk *) * clk->num_parents);
|
|
if (clk->parents)
|
|
memset(clk->parents, 0,
|
|
sizeof(struct clk *) * clk->num_parents);
|
|
}
|
|
|
|
/*
|
|
* find index of new parent clock using cached parent ptrs,
|
|
* or if not yet cached, use string name comparison and cache
|
|
* them now to avoid future calls to __clk_lookup.
|
|
*/
|
|
for (i = 0; i < clk->num_parents; i++) {
|
|
if (clk->parents && clk->parents[i] == parent) {
|
|
break;
|
|
} else if (!strcmp(clk->parent_names[i], parent->name)) {
|
|
if (clk->parents)
|
|
clk->parents[i] = __clk_lookup(parent->name);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == clk->num_parents) {
|
|
printf("%s: clock %s is not a possible parent of clock %s\n",
|
|
__func__, parent->name, clk->name);
|
|
goto out;
|
|
}
|
|
|
|
/* FIXME replace with clk_is_enabled(clk) someday */
|
|
if (clk->enable_count)
|
|
__clk_enable(parent);
|
|
|
|
/* change clock input source */
|
|
ret = clk->ops->set_parent(clk->hw, i);
|
|
clk->parent = clk->parents[i];
|
|
/* clean up old prepare and enable */
|
|
if (clk->enable_count)
|
|
__clk_disable(old_parent);
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
static void __clk_recalc_rates(struct clk *clk)
|
|
{
|
|
unsigned long parent_rate = 0;
|
|
|
|
if (clk->parent)
|
|
parent_rate = clk->parent->rate;
|
|
|
|
if (clk->ops->recalc_rate)
|
|
clk->rate = clk->ops->recalc_rate(clk->hw, parent_rate);
|
|
else
|
|
clk->rate = parent_rate;
|
|
}
|
|
|
|
static struct clk *__clk_init_parent(struct clk *clk)
|
|
{
|
|
struct clk *ret = NULL;
|
|
u8 index;
|
|
|
|
/* handle the trivial cases */
|
|
if (!clk->num_parents)
|
|
goto out;
|
|
|
|
if (clk->num_parents == 1) {
|
|
if (!clk->parent)
|
|
ret = clk->parent = __clk_lookup(clk->parent_names[0]);
|
|
ret = clk->parent;
|
|
goto out;
|
|
}
|
|
|
|
if (!clk->ops->get_parent) {
|
|
printf("%s:multi-parent clocks %s must implement .get_parent\n",
|
|
__func__, clk->name);
|
|
goto out;
|
|
};
|
|
|
|
/*
|
|
* Do our best to cache parent clocks in clk->parents. This prevents
|
|
* unnecessary and expensive calls to __clk_lookup. We don't set
|
|
* clk->parent here; that is done by the calling function
|
|
*/
|
|
|
|
index = clk->ops->get_parent(clk->hw);
|
|
|
|
if (!clk->parents) {
|
|
clk->parents =
|
|
malloc(sizeof(struct clk *) * clk->num_parents);
|
|
if (clk->parents)
|
|
memset(clk->parents, 0,
|
|
sizeof(struct clk *) * clk->num_parents);
|
|
}
|
|
if (!clk->parents)
|
|
ret = __clk_lookup(clk->parent_names[index]);
|
|
else if (!clk->parents[index])
|
|
ret = clk->parents[index] =
|
|
__clk_lookup(clk->parent_names[index]);
|
|
else
|
|
ret = clk->parents[index];
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
int __clk_init(struct clk *clk)
|
|
{
|
|
int i, ret = 0;
|
|
/* struct clk *orphan; */
|
|
/* struct hlist_node *tmp, *tmp2; */
|
|
|
|
if (!clk) {
|
|
printf("%s: this is a null clk!\n", __func__);
|
|
return -1;
|
|
}
|
|
/* check to see if a clock with this name is already registered */
|
|
if (__clk_lookup(clk->name)) {
|
|
printf("%s: clk %s already initialized\n",
|
|
__func__, clk->name);
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
/* check that clk_ops are sane. See Documentation/clk.txt */
|
|
if (clk->ops->set_rate &&
|
|
!(clk->ops->round_rate && clk->ops->recalc_rate)) {
|
|
printf("%s: %s must implement .round_rate & .recalc_rate\n",
|
|
__func__, clk->name);
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
if (clk->ops->set_parent && !clk->ops->get_parent) {
|
|
printf("%s: %s must implement .get_parent & .set_parent\n",
|
|
__func__, clk->name);
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
/* throw a WARN if any entries in parent_names are NULL */
|
|
for (i = 0; i < clk->num_parents; i++)
|
|
if (!clk->parent_names[i])
|
|
printf("%s: invalid NULL in %s's .parent_names\n",
|
|
__func__, clk->name);
|
|
/*
|
|
* Allocate an array of struct clk *'s to avoid unnecessary string
|
|
* look-ups of clk's possible parents. This can fail for clocks passed
|
|
* in to clk_init during early boot; thus any access to clk->parents[]
|
|
* must always check for a NULL pointer and try to populate it if
|
|
* necessary.
|
|
*
|
|
* If clk->parents is not NULL we skip this entire block. This allows
|
|
* for clock drivers to statically initialize clk->parents.
|
|
*/
|
|
|
|
if (clk->num_parents > 1 && !clk->parents) {
|
|
clk->parents = malloc((sizeof(struct clk *) *
|
|
clk->num_parents));
|
|
if (clk->parents)
|
|
memset(clk->parents, 0,
|
|
sizeof(struct clk *) * clk->num_parents);
|
|
/*
|
|
* __clk_lookup returns NULL for parents that have not been
|
|
* clk_init'd; thus any access to clk->parents[] must check
|
|
* for a NULL pointer. We can always perform lazy lookups for
|
|
* missing parents later on.
|
|
*/
|
|
if (clk->parents)
|
|
for (i = 0; i < clk->num_parents; i++)
|
|
clk->parents[i] =
|
|
__clk_lookup(clk->parent_names[i]);
|
|
}
|
|
clk->parent = __clk_init_parent(clk);
|
|
|
|
/*
|
|
* optional platform-specific magic
|
|
*
|
|
* The .init callback is not used by any of the basic clock types, but
|
|
* exists for weird hardware that must perform initialization magic.
|
|
* Please consider other ways of solving initialization problems before
|
|
* using this callback, as it's use is discouraged.
|
|
*/
|
|
|
|
|
|
hlist_add_head(&clk->child_node,
|
|
&clk_list);
|
|
|
|
if (clk->ops->recalc_rate)
|
|
clk->rate = clk->ops->recalc_rate(clk->hw,
|
|
__clk_get_rate(clk->parent));
|
|
else if (clk->parent)
|
|
clk->rate = clk->parent->rate;
|
|
else
|
|
clk->rate = 0;
|
|
|
|
if (clk->ops->init)
|
|
clk->ops->init(clk->hw);
|
|
out:
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
int clk_disable(struct clk *clk)
|
|
{
|
|
if (!clk)
|
|
return -1;
|
|
|
|
__clk_disable(clk);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int clk_prepare_enable(struct clk *clk)
|
|
{
|
|
int ret;
|
|
|
|
if (!clk)
|
|
return -1;
|
|
|
|
ret = __clk_enable(clk);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* clk_round_rate - round the given rate for a clk
|
|
* @clk: the clk for which we are rounding a rate
|
|
* @rate: the rate which is to be rounded
|
|
*
|
|
* Takes in a rate as input and rounds it to a rate that the clk can actually
|
|
* use which is then returned. If clk doesn't support round_rate operation
|
|
* then the parent rate is returned.
|
|
*/
|
|
long clk_round_rate(struct clk *clk, unsigned long rate)
|
|
{
|
|
unsigned long parent_rate = 0;
|
|
|
|
if (!clk)
|
|
return 0;
|
|
|
|
if (!clk->ops->round_rate) {
|
|
return clk->rate;
|
|
}
|
|
|
|
if (clk->parent)
|
|
parent_rate = clk->parent->rate;
|
|
|
|
return clk->ops->round_rate(clk->hw, rate, &parent_rate);
|
|
|
|
}
|
|
|
|
struct clk *clk_get_parent(struct clk *clk)
|
|
{
|
|
return !clk ? NULL : clk->parent;
|
|
}
|
|
|
|
int clk_set_parent(struct clk *clk, struct clk *parent)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (!clk || !clk->ops)
|
|
return -1;
|
|
|
|
if (!clk->ops->set_parent)
|
|
return -1;
|
|
|
|
/* prevent racing with updates to the clock topology */
|
|
|
|
if (clk->parent == parent)
|
|
goto out;
|
|
|
|
/* only re-parent if the clock is not in use */
|
|
if ((clk->flags & CLK_SET_PARENT_GATE) && clk->prepare_count) {
|
|
|
|
printf("%s: clk->enable_count = %d\n", __func__,
|
|
clk->enable_count);
|
|
ret = -1;
|
|
} else
|
|
ret = __clk_set_parent(clk, parent);
|
|
|
|
/* propagate ABORT_RATE_CHANGE if .set_parent failed */
|
|
if (ret) {
|
|
__clk_recalc_rates(clk);
|
|
goto out;
|
|
}
|
|
|
|
out:
|
|
|
|
return ret;
|
|
}
|
|
|
|
unsigned long clk_get_rate(struct clk *clk)
|
|
{
|
|
unsigned long rate;
|
|
|
|
rate = __clk_get_rate(clk);
|
|
|
|
return rate;
|
|
}
|
|
|
|
int clk_set_rate(struct clk *clk, unsigned long rate)
|
|
{
|
|
unsigned long best_parent_rate = 0;
|
|
int ret = 0;
|
|
unsigned long new_rate;
|
|
|
|
/* bail early if nothing to do */
|
|
if (rate == clk->rate && !(clk->flags & CLK_GET_RATE_NOCACHE)) {
|
|
goto out;
|
|
}
|
|
|
|
/* calculate new rates and get the topmost changed clock */
|
|
if (clk->parent)
|
|
best_parent_rate = clk->parent->rate;
|
|
|
|
if (!clk->parent) {
|
|
printf("%s: %s has NULL parent\n", __func__, clk->name);
|
|
ret = -1;
|
|
|
|
goto out;
|
|
}
|
|
|
|
if (!clk->ops->round_rate)
|
|
new_rate = clk->parent->new_rate;
|
|
else
|
|
new_rate = clk->ops->round_rate(clk->hw, rate,
|
|
&best_parent_rate);
|
|
clk->new_rate = new_rate;
|
|
|
|
/* change the rates */
|
|
if (clk->ops->set_rate)
|
|
clk->ops->set_rate(clk->hw, clk->new_rate, best_parent_rate);
|
|
|
|
if (clk->ops->recalc_rate)
|
|
clk->rate = clk->ops->recalc_rate(clk->hw, best_parent_rate);
|
|
else
|
|
clk->rate = best_parent_rate;
|
|
|
|
return 0;
|
|
out:
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
struct clk *clk_get(void *dev, const char *con_id)
|
|
{
|
|
struct clk *clk;
|
|
|
|
clk = __clk_lookup(con_id);
|
|
|
|
return clk ? clk : NULL;
|
|
}
|
|
|
|
void clk_put(struct clk *clk)
|
|
{
|
|
}
|
|
|
|
void clk_init(void)
|
|
{
|
|
init_clocks();
|
|
}
|
|
|
|
struct clk *clk_register(struct clk_hw *hw)
|
|
{
|
|
int ret;
|
|
struct clk *clk;
|
|
|
|
clk = malloc(sizeof(*clk));
|
|
if (clk)
|
|
memset(clk, 0, sizeof(*clk));
|
|
if (!clk) {
|
|
printf("%s: could not allocate clk\n", __func__);
|
|
ret = -1;
|
|
goto fail_out;
|
|
}
|
|
clk->name = hw->init->name;
|
|
clk->ops = hw->init->ops;
|
|
clk->hw = hw;
|
|
clk->flags = hw->init->flags;
|
|
clk->parent_names = hw->init->parent_names;
|
|
clk->num_parents = hw->init->num_parents;
|
|
hw->clk = clk;
|
|
|
|
ret = __clk_init(clk);
|
|
if (!ret)
|
|
return clk;
|
|
|
|
free(clk);
|
|
fail_out:
|
|
return NULL;
|
|
}
|
|
|