[deliverable/linux.git] / drivers / clk / at91 / clk-system.c

/*
 *  Copyright (C) 2013 Boris BREZILLON <b.brezillon@overkiz.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.
 *
 */

#include <linux/clk-provider.h>
#include <linux/clkdev.h>
#include <linux/clk/at91_pmc.h>
#include <linux/of.h>
#include <linux/mfd/syscon.h>
#include <linux/regmap.h>

#include "pmc.h"

#define SYSTEM_MAX_ID		31

#define SYSTEM_MAX_NAME_SZ	32

#define to_clk_system(hw) container_of(hw, struct clk_system, hw)
struct clk_system {
	struct clk_hw hw;
	struct regmap *regmap;
	u8 id;
};

static inline int is_pck(int id)
{
	return (id >= 8) && (id <= 15);
}

static inline bool clk_system_ready(struct regmap *regmap, int id)
{
	unsigned int status;

	regmap_read(regmap, AT91_PMC_SR, &status);

	return status & (1 << id) ? 1 : 0;
}

static int clk_system_prepare(struct clk_hw *hw)
{
	struct clk_system *sys = to_clk_system(hw);

	regmap_write(sys->regmap, AT91_PMC_SCER, 1 << sys->id);

	if (!is_pck(sys->id))
		return 0;

	while (!clk_system_ready(sys->regmap, sys->id))
		cpu_relax();

	return 0;
}

static void clk_system_unprepare(struct clk_hw *hw)
{
	struct clk_system *sys = to_clk_system(hw);

	regmap_write(sys->regmap, AT91_PMC_SCDR, 1 << sys->id);
}

static int clk_system_is_prepared(struct clk_hw *hw)
{
	struct clk_system *sys = to_clk_system(hw);
	unsigned int status;

	regmap_read(sys->regmap, AT91_PMC_SCSR, &status);

	if (!(status & (1 << sys->id)))
		return 0;

	if (!is_pck(sys->id))
		return 1;

	regmap_read(sys->regmap, AT91_PMC_SR, &status);

	return status & (1 << sys->id) ? 1 : 0;
}

static const struct clk_ops system_ops = {
	.prepare = clk_system_prepare,
	.unprepare = clk_system_unprepare,
	.is_prepared = clk_system_is_prepared,
};

static struct clk * __init
at91_clk_register_system(struct regmap *regmap, const char *name,
			 const char *parent_name, u8 id)
{
	struct clk_system *sys;
	struct clk *clk = NULL;
	struct clk_init_data init;

	if (!parent_name || id > SYSTEM_MAX_ID)
		return ERR_PTR(-EINVAL);

	sys = kzalloc(sizeof(*sys), GFP_KERNEL);
	if (!sys)
		return ERR_PTR(-ENOMEM);

	init.name = name;
	init.ops = &system_ops;
	init.parent_names = &parent_name;
	init.num_parents = 1;
	init.flags = CLK_SET_RATE_PARENT;

	sys->id = id;
	sys->hw.init = &init;
	sys->regmap = regmap;

	clk = clk_register(NULL, &sys->hw);
	if (IS_ERR(clk))
		kfree(sys);

	return clk;
}

static void __init of_at91rm9200_clk_sys_setup(struct device_node *np)
{
	int num;
	u32 id;
	struct clk *clk;
	const char *name;
	struct device_node *sysclknp;
	const char *parent_name;
	struct regmap *regmap;

	num = of_get_child_count(np);
	if (num > (SYSTEM_MAX_ID + 1))
		return;

	regmap = syscon_node_to_regmap(of_get_parent(np));
	if (IS_ERR(regmap))
		return;

	for_each_child_of_node(np, sysclknp) {
		if (of_property_read_u32(sysclknp, "reg", &id))
			continue;

		if (of_property_read_string(np, "clock-output-names", &name))
			name = sysclknp->name;

		parent_name = of_clk_get_parent_name(sysclknp, 0);

		clk = at91_clk_register_system(regmap, name, parent_name, id);
		if (IS_ERR(clk))
			continue;

		of_clk_add_provider(sysclknp, of_clk_src_simple_get, clk);
	}
}
CLK_OF_DECLARE(at91rm9200_clk_sys, "atmel,at91rm9200-clk-system",
	       of_at91rm9200_clk_sys_setup);
Commit	Line	Data
5fba62ea BB	1	/*
	2	* Copyright (C) 2013 Boris BREZILLON <b.brezillon@overkiz.com>
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; either version 2 of the License, or
	7	* (at your option) any later version.
	8	*
	9	*/
	10
	11	#include <linux/clk-provider.h>
	12	#include <linux/clkdev.h>
	13	#include <linux/clk/at91_pmc.h>
	14	#include <linux/of.h>
1bdf0232 BB	15	#include <linux/mfd/syscon.h>
1bdf0232 BB	16	#include <linux/regmap.h>
5fba62ea BB	17
	18	#include "pmc.h"
	19
	20	#define SYSTEM_MAX_ID 31
	21
	22	#define SYSTEM_MAX_NAME_SZ 32
	23
	24	#define to_clk_system(hw) container_of(hw, struct clk_system, hw)
	25	struct clk_system {
	26	struct clk_hw hw;
1bdf0232	27	struct regmap *regmap;
5fba62ea BB	28	u8 id;
	29	};
	30
cce6db80 JJH	31	static inline int is_pck(int id)
	32	{
	33	return (id >= 8) && (id <= 15);
	34	}
cce6db80	35
1bdf0232 BB	36	static inline bool clk_system_ready(struct regmap *regmap, int id)
	37	{
	38	unsigned int status;
	39
	40	regmap_read(regmap, AT91_PMC_SR, &status);
	41
	42	return status & (1 << id) ? 1 : 0;
	43	}
	44
cce6db80	45	static int clk_system_prepare(struct clk_hw *hw)
5fba62ea BB	46	{
5fba62ea BB	47	struct clk_system *sys = to_clk_system(hw);
5fba62ea	48
1bdf0232	49	regmap_write(sys->regmap, AT91_PMC_SCER, 1 << sys->id);
cce6db80 JJH	50
	51	if (!is_pck(sys->id))
	52	return 0;
	53
99a81706 AB	54	while (!clk_system_ready(sys->regmap, sys->id))
	55	cpu_relax();
	56
5fba62ea BB	57	return 0;
	58	}
	59
cce6db80	60	static void clk_system_unprepare(struct clk_hw *hw)
5fba62ea BB	61	{
5fba62ea BB	62	struct clk_system *sys = to_clk_system(hw);
5fba62ea	63
1bdf0232	64	regmap_write(sys->regmap, AT91_PMC_SCDR, 1 << sys->id);
5fba62ea BB	65	}
5fba62ea BB	66
cce6db80	67	static int clk_system_is_prepared(struct clk_hw *hw)
5fba62ea BB	68	{
5fba62ea BB	69	struct clk_system *sys = to_clk_system(hw);
1bdf0232 BB	70	unsigned int status;
	71
	72	regmap_read(sys->regmap, AT91_PMC_SCSR, &status);
5fba62ea	73
1bdf0232	74	if (!(status & (1 << sys->id)))
cce6db80 JJH	75	return 0;
	76
	77	if (!is_pck(sys->id))
	78	return 1;
	79
1bdf0232 BB	80	regmap_read(sys->regmap, AT91_PMC_SR, &status);
	81
	82	return status & (1 << sys->id) ? 1 : 0;
5fba62ea BB	83	}
	84
	85	static const struct clk_ops system_ops = {
cce6db80 JJH	86	.prepare = clk_system_prepare,
	87	.unprepare = clk_system_unprepare,
	88	.is_prepared = clk_system_is_prepared,
5fba62ea BB	89	};
	90
	91	static struct clk * __init
1bdf0232	92	at91_clk_register_system(struct regmap regmap, const char name,
99a81706	93	const char *parent_name, u8 id)
5fba62ea BB	94	{
	95	struct clk_system *sys;
	96	struct clk *clk = NULL;
	97	struct clk_init_data init;
	98
	99	if (!parent_name \|\| id > SYSTEM_MAX_ID)
	100	return ERR_PTR(-EINVAL);
	101
	102	sys = kzalloc(sizeof(*sys), GFP_KERNEL);
	103	if (!sys)
	104	return ERR_PTR(-ENOMEM);
	105
	106	init.name = name;
	107	init.ops = &system_ops;
	108	init.parent_names = &parent_name;
	109	init.num_parents = 1;
b736bcb3	110	init.flags = CLK_SET_RATE_PARENT;
5fba62ea BB	111
	112	sys->id = id;
	113	sys->hw.init = &init;
1bdf0232	114	sys->regmap = regmap;
5fba62ea BB	115
5fba62ea BB	116	clk = clk_register(NULL, &sys->hw);
99a81706	117	if (IS_ERR(clk))
5fba62ea BB	118	kfree(sys);
	119
	120	return clk;
	121	}
	122
1bdf0232	123	static void __init of_at91rm9200_clk_sys_setup(struct device_node *np)
5fba62ea BB	124	{
	125	int num;
	126	u32 id;
	127	struct clk *clk;
	128	const char *name;
	129	struct device_node *sysclknp;
	130	const char *parent_name;
1bdf0232	131	struct regmap *regmap;
5fba62ea BB	132
	133	num = of_get_child_count(np);
	134	if (num > (SYSTEM_MAX_ID + 1))
	135	return;
	136
1bdf0232 BB	137	regmap = syscon_node_to_regmap(of_get_parent(np));
	138	if (IS_ERR(regmap))
	139	return;
	140
5fba62ea BB	141	for_each_child_of_node(np, sysclknp) {
	142	if (of_property_read_u32(sysclknp, "reg", &id))
	143	continue;
	144
	145	if (of_property_read_string(np, "clock-output-names", &name))
	146	name = sysclknp->name;
	147
	148	parent_name = of_clk_get_parent_name(sysclknp, 0);
	149
99a81706	150	clk = at91_clk_register_system(regmap, name, parent_name, id);
5fba62ea BB	151	if (IS_ERR(clk))
	152	continue;
	153
	154	of_clk_add_provider(sysclknp, of_clk_src_simple_get, clk);
	155	}
	156	}
1bdf0232 BB	157	CLK_OF_DECLARE(at91rm9200_clk_sys, "atmel,at91rm9200-clk-system",
1bdf0232 BB	158	of_at91rm9200_clk_sys_setup);