Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
torvalds
GitHub Repository: torvalds/linux
 Path: blob/master/drivers/clk/at91/clk-system.c
26288 views
1
// SPDX-License-Identifier: GPL-2.0-or-later

2
/*

3
 *  Copyright (C) 2013 Boris BREZILLON <[email protected]>

4
 */

5


6
#include <linux/clk-provider.h>

7
#include <linux/clkdev.h>

8
#include <linux/clk/at91_pmc.h>

9
#include <linux/of.h>

10
#include <linux/mfd/syscon.h>

11
#include <linux/regmap.h>

12


13
#include "pmc.h"

14


15
#define SYSTEM_MAX_ID		31

16


17
#define SYSTEM_MAX_NAME_SZ	32

18


19
#define to_clk_system(hw) container_of(hw, struct clk_system, hw)

20
struct clk_system {

21
	struct clk_hw hw;

22
	struct regmap *regmap;

23
	struct at91_clk_pms pms;

24
	u8 id;

25
};

26


27
static inline int is_pck(int id)

28
{

29
	return (id >= 8) && (id <= 15);

30
}

31


32
static inline bool clk_system_ready(struct regmap *regmap, int id)

33
{

34
	unsigned int status;

35


36
	regmap_read(regmap, AT91_PMC_SR, &status);

37


38
	return !!(status & (1 << id));

39
}

40


41
static int clk_system_prepare(struct clk_hw *hw)

42
{

43
	struct clk_system *sys = to_clk_system(hw);

44


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

46


47
	if (!is_pck(sys->id))

48
		return 0;

49


50
	while (!clk_system_ready(sys->regmap, sys->id))

51
		cpu_relax();

52


53
	return 0;

54
}

55


56
static void clk_system_unprepare(struct clk_hw *hw)

57
{

58
	struct clk_system *sys = to_clk_system(hw);

59


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

61
}

62


63
static int clk_system_is_prepared(struct clk_hw *hw)

64
{

65
	struct clk_system *sys = to_clk_system(hw);

66
	unsigned int status;

67


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

69


70
	if (!(status & (1 << sys->id)))

71
		return 0;

72


73
	if (!is_pck(sys->id))

74
		return 1;

75


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

77


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

79
}

80


81
static int clk_system_save_context(struct clk_hw *hw)

82
{

83
	struct clk_system *sys = to_clk_system(hw);

84


85
	sys->pms.status = clk_system_is_prepared(hw);

86


87
	return 0;

88
}

89


90
static void clk_system_restore_context(struct clk_hw *hw)

91
{

92
	struct clk_system *sys = to_clk_system(hw);

93


94
	if (sys->pms.status)

95
		clk_system_prepare(&sys->hw);

96
}

97


98
static const struct clk_ops system_ops = {

99
	.prepare = clk_system_prepare,

100
	.unprepare = clk_system_unprepare,

101
	.is_prepared = clk_system_is_prepared,

102
	.save_context = clk_system_save_context,

103
	.restore_context = clk_system_restore_context,

104
};

105


106
struct clk_hw * __init

107
at91_clk_register_system(struct regmap *regmap, const char *name,

108
			 const char *parent_name, struct clk_hw *parent_hw, u8 id,

109
			 unsigned long flags)

110
{

111
	struct clk_system *sys;

112
	struct clk_hw *hw;

113
	struct clk_init_data init = {};

114
	int ret;

115


116
	if (!(parent_name || parent_hw) || id > SYSTEM_MAX_ID)

117
		return ERR_PTR(-EINVAL);

118


119
	sys = kzalloc(sizeof(*sys), GFP_KERNEL);

120
	if (!sys)

121
		return ERR_PTR(-ENOMEM);

122


123
	init.name = name;

124
	init.ops = &system_ops;

125
	if (parent_hw)

126
		init.parent_hws = (const struct clk_hw **)&parent_hw;

127
	else

128
		init.parent_names = &parent_name;

129
	init.num_parents = 1;

130
	init.flags = CLK_SET_RATE_PARENT | flags;

131


132
	sys->id = id;

133
	sys->hw.init = &init;

134
	sys->regmap = regmap;

135


136
	hw = &sys->hw;

137
	ret = clk_hw_register(NULL, &sys->hw);

138
	if (ret) {

139
		kfree(sys);

140
		hw = ERR_PTR(ret);

141
	}

142


143
	return hw;

144
}

145


146