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 25 spinlock_t cpg_lock; 26 27 void 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 40 static 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 58 void 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 72 static const struct clk_div_table cpg_sdh_div_table[] = { 73 { 0, 1 }, { 1, 2 }, { STPnHCK | 2, 4 }, { STPnHCK | 3, 8 }, 74 { STPnHCK | 4, 16 }, { 0, 0 }, 75 }; 76 77 struct clk * __init cpg_sdh_clk_register(const char *name, 78 void __iomem *sdnckcr, const char *parent_name, 79 struct raw_notifier_head *notifiers) 80 { 81 struct cpg_simple_notifier *csn; 82 struct clk *clk; 83 84 csn = kzalloc(sizeof(*csn), GFP_KERNEL); 85 if (!csn) 86 return ERR_PTR(-ENOMEM); 87 88 csn->reg = sdnckcr; 89 90 clk = clk_register_divider_table(NULL, name, parent_name, 0, sdnckcr, 91 SDnSRCFC_SHIFT, 8, 0, cpg_sdh_div_table, 92 &cpg_lock); 93 if (IS_ERR(clk)) { 94 kfree(csn); 95 return clk; 96 } 97 98 cpg_simple_notifier_register(notifiers, csn); 99 return clk; 100 } 101 102 static const struct clk_div_table cpg_sd_div_table[] = { 103 { 0, 2 }, { 1, 4 }, { 0, 0 }, 104 }; 105 106 struct clk * __init cpg_sd_clk_register(const char *name, 107 void __iomem *sdnckcr, const char *parent_name) 108 { 109 return clk_register_divider_table(NULL, name, parent_name, 0, sdnckcr, 110 0, 2, 0, cpg_sd_div_table, &cpg_lock); 111 } 112 113 struct rpc_clock { 114 struct clk_divider div; 115 struct clk_gate gate; 116 /* 117 * One notifier covers both RPC and RPCD2 clocks as they are both 118 * controlled by the same RPCCKCR register... 119 */ 120 struct cpg_simple_notifier csn; 121 }; 122 123 static const struct clk_div_table cpg_rpc_div_table[] = { 124 { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 }, { 0, 0 }, 125 }; 126 127 struct clk * __init cpg_rpc_clk_register(const char *name, 128 void __iomem *rpcckcr, const char *parent_name, 129 struct raw_notifier_head *notifiers) 130 { 131 struct rpc_clock *rpc; 132 struct clk *clk; 133 134 rpc = kzalloc(sizeof(*rpc), GFP_KERNEL); 135 if (!rpc) 136 return ERR_PTR(-ENOMEM); 137 138 rpc->div.reg = rpcckcr; 139 rpc->div.width = 3; 140 rpc->div.table = cpg_rpc_div_table; 141 rpc->div.lock = &cpg_lock; 142 143 rpc->gate.reg = rpcckcr; 144 rpc->gate.bit_idx = 8; 145 rpc->gate.flags = CLK_GATE_SET_TO_DISABLE; 146 rpc->gate.lock = &cpg_lock; 147 148 rpc->csn.reg = rpcckcr; 149 150 clk = clk_register_composite(NULL, name, &parent_name, 1, NULL, NULL, 151 &rpc->div.hw, &clk_divider_ops, 152 &rpc->gate.hw, &clk_gate_ops, 153 CLK_SET_RATE_PARENT); 154 if (IS_ERR(clk)) { 155 kfree(rpc); 156 return clk; 157 } 158 159 cpg_simple_notifier_register(notifiers, &rpc->csn); 160 return clk; 161 } 162 163 struct rpcd2_clock { 164 struct clk_fixed_factor fixed; 165 struct clk_gate gate; 166 }; 167 168 struct clk * __init cpg_rpcd2_clk_register(const char *name, 169 void __iomem *rpcckcr, 170 const char *parent_name) 171 { 172 struct rpcd2_clock *rpcd2; 173 struct clk *clk; 174 175 rpcd2 = kzalloc(sizeof(*rpcd2), GFP_KERNEL); 176 if (!rpcd2) 177 return ERR_PTR(-ENOMEM); 178 179 rpcd2->fixed.mult = 1; 180 rpcd2->fixed.div = 2; 181 182 rpcd2->gate.reg = rpcckcr; 183 rpcd2->gate.bit_idx = 9; 184 rpcd2->gate.flags = CLK_GATE_SET_TO_DISABLE; 185 rpcd2->gate.lock = &cpg_lock; 186 187 clk = clk_register_composite(NULL, name, &parent_name, 1, NULL, NULL, 188 &rpcd2->fixed.hw, &clk_fixed_factor_ops, 189 &rpcd2->gate.hw, &clk_gate_ops, 190 CLK_SET_RATE_PARENT); 191 if (IS_ERR(clk)) 192 kfree(rpcd2); 193 194 return clk; 195 } 196 197