1// SPDX-License-Identifier: GPL-2.0 2/* 3 * R-Car Gen3 Clock Pulse Generator Library 4 * 5 * Copyright (C) 2015-2018 Glider bvba 6 * Copyright (C) 2019 Renesas Electronics Corp. 7 * 8 * Based on clk-rcar-gen3.c 9 * 10 * Copyright (C) 2015 Renesas Electronics Corp. 11 */ 12 13#include <linux/clk.h> 14#include <linux/clk-provider.h> 15#include <linux/device.h> 16#include <linux/err.h> 17#include <linux/init.h> 18#include <linux/io.h> 19#include <linux/pm.h> 20#include <linux/slab.h> 21#include <linux/sys_soc.h> 22 23#include "rcar-cpg-lib.h" 24 25spinlock_t cpg_lock; 26 27void cpg_reg_modify(void __iomem *reg, u32 clear, u32 set) 28{ 29 unsigned long flags; 30 u32 val; 31 32 spin_lock_irqsave(&cpg_lock, flags); 33 val = readl(reg); 34 val &= ~clear; 35 val |= set; 36 writel(val, reg); 37 spin_unlock_irqrestore(&cpg_lock, flags); 38}; 39 40static int cpg_simple_notifier_call(struct notifier_block *nb, 41 unsigned long action, void *data) 42{ 43 struct cpg_simple_notifier *csn = 44 container_of(nb, struct cpg_simple_notifier, nb); 45 46 switch (action) { 47 case PM_EVENT_SUSPEND: 48 csn->saved = readl(csn->reg); 49 return NOTIFY_OK; 50 51 case PM_EVENT_RESUME: 52 writel(csn->saved, csn->reg); 53 return NOTIFY_OK; 54 } 55 return NOTIFY_DONE; 56} 57 58void cpg_simple_notifier_register(struct raw_notifier_head *notifiers, 59 struct cpg_simple_notifier *csn) 60{ 61 csn->nb.notifier_call = cpg_simple_notifier_call; 62 raw_notifier_chain_register(notifiers, &csn->nb); 63} 64 65/* 66 * SDn Clock 67 */ 68 69#define SDnSRCFC_SHIFT 2 70#define STPnHCK BIT(9 - SDnSRCFC_SHIFT) 71 72static const struct clk_div_table cpg_sdh_div_table[] = { 73 /* 74 * These values are recommended by the datasheet. Because they come 75 * first, Linux will only use these. 76 */ 77 { 0, 1 }, { 1, 2 }, { STPnHCK | 2, 4 }, { STPnHCK | 3, 8 }, 78 { STPnHCK | 4, 16 }, 79 /* 80 * These values are not recommended because STPnHCK is wrong. But they 81 * have been seen because of broken firmware. So, we support reading 82 * them but Linux will sanitize them when initializing through 83 * recalc_rate. 84 */ 85 { STPnHCK | 0, 1 }, { STPnHCK | 1, 2 }, { 2, 4 }, { 3, 8 }, { 4, 16 }, 86 /* Sentinel */ 87 { 0, 0 } 88}; 89 90struct clk * __init cpg_sdh_clk_register(const char *name, 91 void __iomem *sdnckcr, const char *parent_name, 92 struct raw_notifier_head *notifiers) 93{ 94 struct cpg_simple_notifier *csn; 95 struct clk *clk; 96 97 csn = kzalloc(sizeof(*csn), GFP_KERNEL); 98 if (!csn) 99 return ERR_PTR(-ENOMEM); 100 101 csn->reg = sdnckcr; 102 103 clk = clk_register_divider_table(NULL, name, parent_name, 0, sdnckcr, 104 SDnSRCFC_SHIFT, 8, 0, cpg_sdh_div_table, 105 &cpg_lock); 106 if (IS_ERR(clk)) { 107 kfree(csn); 108 return clk; 109 } 110 111 cpg_simple_notifier_register(notifiers, csn); 112 return clk; 113} 114 115static const struct clk_div_table cpg_sd_div_table[] = { 116 { 0, 2 }, { 1, 4 }, { 0, 0 }, 117}; 118 119struct clk * __init cpg_sd_clk_register(const char *name, 120 void __iomem *sdnckcr, const char *parent_name) 121{ 122 return clk_register_divider_table(NULL, name, parent_name, 0, sdnckcr, 123 0, 2, 0, cpg_sd_div_table, &cpg_lock); 124} 125 126struct rpc_clock { 127 struct clk_divider div; 128 struct clk_gate gate; 129 /* 130 * One notifier covers both RPC and RPCD2 clocks as they are both 131 * controlled by the same RPCCKCR register... 132 */ 133 struct cpg_simple_notifier csn; 134}; 135 136static const struct clk_div_table cpg_rpc_div_table[] = { 137 { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 }, { 0, 0 }, 138}; 139 140struct clk * __init cpg_rpc_clk_register(const char *name, 141 void __iomem *rpcckcr, const char *parent_name, 142 struct raw_notifier_head *notifiers) 143{ 144 struct rpc_clock *rpc; 145 struct clk *clk; 146 147 rpc = kzalloc(sizeof(*rpc), GFP_KERNEL); 148 if (!rpc) 149 return ERR_PTR(-ENOMEM); 150 151 rpc->div.reg = rpcckcr; 152 rpc->div.width = 3; 153 rpc->div.table = cpg_rpc_div_table; 154 rpc->div.lock = &cpg_lock; 155 156 rpc->gate.reg = rpcckcr; 157 rpc->gate.bit_idx = 8; 158 rpc->gate.flags = CLK_GATE_SET_TO_DISABLE; 159 rpc->gate.lock = &cpg_lock; 160 161 rpc->csn.reg = rpcckcr; 162 163 clk = clk_register_composite(NULL, name, &parent_name, 1, NULL, NULL, 164 &rpc->div.hw, &clk_divider_ops, 165 &rpc->gate.hw, &clk_gate_ops, 166 CLK_SET_RATE_PARENT); 167 if (IS_ERR(clk)) { 168 kfree(rpc); 169 return clk; 170 } 171 172 cpg_simple_notifier_register(notifiers, &rpc->csn); 173 return clk; 174} 175 176struct rpcd2_clock { 177 struct clk_fixed_factor fixed; 178 struct clk_gate gate; 179}; 180 181struct clk * __init cpg_rpcd2_clk_register(const char *name, 182 void __iomem *rpcckcr, 183 const char *parent_name) 184{ 185 struct rpcd2_clock *rpcd2; 186 struct clk *clk; 187 188 rpcd2 = kzalloc(sizeof(*rpcd2), GFP_KERNEL); 189 if (!rpcd2) 190 return ERR_PTR(-ENOMEM); 191 192 rpcd2->fixed.mult = 1; 193 rpcd2->fixed.div = 2; 194 195 rpcd2->gate.reg = rpcckcr; 196 rpcd2->gate.bit_idx = 9; 197 rpcd2->gate.flags = CLK_GATE_SET_TO_DISABLE; 198 rpcd2->gate.lock = &cpg_lock; 199 200 clk = clk_register_composite(NULL, name, &parent_name, 1, NULL, NULL, 201 &rpcd2->fixed.hw, &clk_fixed_factor_ops, 202 &rpcd2->gate.hw, &clk_gate_ops, 203 CLK_SET_RATE_PARENT); 204 if (IS_ERR(clk)) 205 kfree(rpcd2); 206 207 return clk; 208} 209 210