Commit b09d6d99 authored by Michael Turquette's avatar Michael Turquette
Browse files

clk: remove clk-private.h 



Private clock framework data structures should be private, surprisingly.

Now that all platforms and drivers have been updated to remove static
initializations of struct clk and struct clk_core objects and all
references to clk-private.h have been removed we can move the
definitions of these structures into drivers/clk/clk.c and delete the
header.

Additionally the ugly DEFINE_CLK macros have been removed. Those were
used for static definitions of struct clk objects. That practice is no
longer allowed.

Finally __clk_init is staticized as it is no longer declared in any
header.

Reviewed-by: default avatarStephen Boyd <sboyd@codeaurora.org>
Signed-off-by: default avatarMichael Turquette <mturquette@linaro.org>
parent c87ea8a8

drivers/clk/clk.c

+39 −2
Original line number Diff line number Diff line
@@ -9,7 +9,7 @@ 
 * Standard functionality for the common clock API.  See Documentation/clk.txt

 */



#include <linux/clk-private.h>

#include <linux/clk-provider.h>

#include <linux/clk/clk-conf.h>

#include <linux/module.h>

#include <linux/mutex.h>
@@ -46,6 +46,43 @@ static unsigned long clk_core_round_rate_nolock(struct clk_core *clk, 
						unsigned long rate);

static struct clk_core *clk_core_lookup(const char *name);



/***    private data structures    ***/



struct clk_core {

	const char		*name;

	const struct clk_ops	*ops;

	struct clk_hw		*hw;

	struct module		*owner;

	struct clk_core		*parent;

	const char		**parent_names;

	struct clk_core		**parents;

	u8			num_parents;

	u8			new_parent_index;

	unsigned long		rate;

	unsigned long		new_rate;

	struct clk_core		*new_parent;

	struct clk_core		*new_child;

	unsigned long		flags;

	unsigned int		enable_count;

	unsigned int		prepare_count;

	unsigned long		accuracy;

	int			phase;

	struct hlist_head	children;

	struct hlist_node	child_node;

	struct hlist_node	debug_node;

	unsigned int		notifier_count;

#ifdef CONFIG_DEBUG_FS

	struct dentry		*dentry;

#endif

	struct kref		ref;

};



struct clk {

	struct clk_core	*core;

	const char *dev_id;

	const char *con_id;

};



/***           locking             ***/

static void clk_prepare_lock(void)

{
@@ -1995,7 +2032,7 @@ int clk_get_phase(struct clk *clk) 
 * Initializes the lists in struct clk_core, queries the hardware for the

 * parent and rate and sets them both.

 */

int __clk_init(struct device *dev, struct clk *clk_user)

static int __clk_init(struct device *dev, struct clk *clk_user)

{

	int i, ret = 0;

	struct clk_core *orphan;

include/linux/clk-private.h

deleted100644 → 0
+0 −237
Original line number Diff line number Diff line 
/*

 *  linux/include/linux/clk-private.h

 *

 *  Copyright (c) 2010-2011 Jeremy Kerr <jeremy.kerr@canonical.com>

 *  Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */

#ifndef __LINUX_CLK_PRIVATE_H

#define __LINUX_CLK_PRIVATE_H



#include <linux/clk-provider.h>

#include <linux/kref.h>

#include <linux/list.h>



/*

 * WARNING: Do not include clk-private.h from any file that implements struct

 * clk_ops.  Doing so is a layering violation!

 *

 * This header exists only to allow for statically initialized clock data.  Any

 * static clock data must be defined in a separate file from the logic that

 * implements the clock operations for that same data.

 */



#ifdef CONFIG_COMMON_CLK



struct module;



struct clk_core {

	const char		*name;

	const struct clk_ops	*ops;

	struct clk_hw		*hw;

	struct module		*owner;

	struct clk_core		*parent;

	const char		**parent_names;

	struct clk_core		**parents;

	u8			num_parents;

	u8			new_parent_index;

	unsigned long		rate;

	unsigned long		new_rate;

	struct clk_core		*new_parent;

	struct clk_core		*new_child;

	unsigned long		flags;

	unsigned int		enable_count;

	unsigned int		prepare_count;

	unsigned long		accuracy;

	int			phase;

	struct hlist_head	children;

	struct hlist_node	child_node;

	struct hlist_node	debug_node;

	unsigned int		notifier_count;

#ifdef CONFIG_DEBUG_FS

	struct dentry		*dentry;

#endif

	struct kref		ref;

};



struct clk {

	struct clk_core	*core;

	const char *dev_id;

	const char *con_id;

};



/*

 * DOC: Basic clock implementations common to many platforms

 *

 * Each basic clock hardware type is comprised of a structure describing the

 * clock hardware, implementations of the relevant callbacks in struct clk_ops,

 * unique flags for that hardware type, a registration function and an

 * alternative macro for static initialization

 */



#define DEFINE_CLK(_name, _ops, _flags, _parent_names,		\

		_parents)					\

	static struct clk _name = {				\

		.core = &_name##_core				\

	};							\

	static struct clk_core _name##_core = {			\

		.name = #_name,					\

		.ops = &_ops,					\

		.hw = &_name##_hw.hw,				\

		.parent_names = _parent_names,			\

		.num_parents = ARRAY_SIZE(_parent_names),	\

		.parents = _parents,				\

		.flags = _flags | CLK_IS_BASIC,			\

	}



#define DEFINE_CLK_FIXED_RATE(_name, _flags, _rate,		\

				_fixed_rate_flags)		\

	static struct clk _name;				\

	static struct clk_core _name##_core;			\

	static const char *_name##_parent_names[] = {};		\

	static struct clk_fixed_rate _name##_hw = {		\

		.hw = {						\

			.core = &_name##_core,			\

			.clk = &_name,				\

		},						\

		.fixed_rate = _rate,				\

		.flags = _fixed_rate_flags,			\

	};							\

	DEFINE_CLK(_name, clk_fixed_rate_ops, _flags,		\

			_name##_parent_names, NULL);



#define DEFINE_CLK_GATE(_name, _parent_name, _parent_ptr,	\

				_flags, _reg, _bit_idx,		\

				_gate_flags, _lock)		\

	static struct clk _name;				\

	static struct clk_core _name##_core;			\

	static const char *_name##_parent_names[] = {		\

		_parent_name,					\

	};							\

	static struct clk_core *_name##_parents[] = {		\

		_parent_ptr,					\

	};							\

	static struct clk_gate _name##_hw = {			\

		.hw = {						\

			.core = &_name##_core,			\

			.clk = &_name,				\

		},						\

		.reg = _reg,					\

		.bit_idx = _bit_idx,				\

		.flags = _gate_flags,				\

		.lock = _lock,					\

	};							\

	DEFINE_CLK(_name, clk_gate_ops, _flags,			\

			_name##_parent_names, _name##_parents);



#define _DEFINE_CLK_DIVIDER(_name, _parent_name, _parent_ptr,	\

				_flags, _reg, _shift, _width,	\

				_divider_flags, _table, _lock)	\

	static struct clk _name;				\

	static struct clk_core _name##_core;			\

	static const char *_name##_parent_names[] = {		\

		_parent_name,					\

	};							\

	static struct clk_core *_name##_parents[] = {		\

		_parent_ptr,					\

	};							\

	static struct clk_divider _name##_hw = {		\

		.hw = {						\

			.core = &_name##_core,			\

			.clk = &_name,				\

		},						\

		.reg = _reg,					\

		.shift = _shift,				\

		.width = _width,				\

		.flags = _divider_flags,			\

		.table = _table,				\

		.lock = _lock,					\

	};							\

	DEFINE_CLK(_name, clk_divider_ops, _flags,		\

			_name##_parent_names, _name##_parents);



#define DEFINE_CLK_DIVIDER(_name, _parent_name, _parent_ptr,	\

				_flags, _reg, _shift, _width,	\

				_divider_flags, _lock)		\

	_DEFINE_CLK_DIVIDER(_name, _parent_name, _parent_ptr,	\

				_flags, _reg, _shift, _width,	\

				_divider_flags, NULL, _lock)



#define DEFINE_CLK_DIVIDER_TABLE(_name, _parent_name,		\

				_parent_ptr, _flags, _reg,	\

				_shift, _width, _divider_flags,	\

				_table, _lock)			\

	_DEFINE_CLK_DIVIDER(_name, _parent_name, _parent_ptr,	\

				_flags, _reg, _shift, _width,	\

				_divider_flags, _table, _lock)	\



#define DEFINE_CLK_MUX(_name, _parent_names, _parents, _flags,	\

				_reg, _shift, _width,		\

				_mux_flags, _lock)		\

	static struct clk _name;				\

	static struct clk_core _name##_core;			\

	static struct clk_mux _name##_hw = {			\

		.hw = {						\

			.core = &_name##_core,			\

			.clk = &_name,				\

		},						\

		.reg = _reg,					\

		.shift = _shift,				\

		.mask = BIT(_width) - 1,			\

		.flags = _mux_flags,				\

		.lock = _lock,					\

	};							\

	DEFINE_CLK(_name, clk_mux_ops, _flags, _parent_names,	\

			_parents);



#define DEFINE_CLK_FIXED_FACTOR(_name, _parent_name,		\

				_parent_ptr, _flags,		\

				_mult, _div)			\

	static struct clk _name;				\

	static struct clk_core _name##_core;			\

	static const char *_name##_parent_names[] = {		\

		_parent_name,					\

	};							\

	static struct clk_core *_name##_parents[] = {		\

		_parent_ptr,					\

	};							\

	static struct clk_fixed_factor _name##_hw = {		\

		.hw = {						\

			.core = &_name##_core,			\

			.clk = &_name,				\

		},						\

		.mult = _mult,					\

		.div = _div,					\

	};							\

	DEFINE_CLK(_name, clk_fixed_factor_ops, _flags,		\

			_name##_parent_names, _name##_parents);



/**

 * __clk_init - initialize the data structures in a struct clk

 * @dev:	device initializing this clk, placeholder for now

 * @clk:	clk being initialized

 *

 * Initializes the lists in struct clk, queries the hardware for the

 * parent and rate and sets them both.

 *

 * Any struct clk passed into __clk_init must have the following members

 * populated:

 * 	.name

 * 	.ops

 * 	.hw

 * 	.parent_names

 * 	.num_parents

 * 	.flags

 *

 * It is not necessary to call clk_register if __clk_init is used directly with

 * statically initialized clock data.

 *

 * Returns 0 on success, otherwise an error code.

 */

int __clk_init(struct device *dev, struct clk *clk);



#endif /* CONFIG_COMMON_CLK */

#endif /* CLK_PRIVATE_H */

CRA Git | Maintained and supported by SUSTech CRA and CCSE