1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Marvell Armada CP110 System Controller 4 * 5 * Copyright (C) 2016 Marvell 6 * 7 * Thomas Petazzoni <thomas.petazzoni@free-electrons.com> 8 * 9 */ 10 11 /* 12 * CP110 has 6 core clocks: 13 * 14 * - PLL0 (1 Ghz) 15 * - PPv2 core (1/3 PLL0) 16 * - x2 Core (1/2 PLL0) 17 * - Core (1/2 x2 Core) 18 * - SDIO (2/5 PLL0) 19 * 20 * - NAND clock, which is either: 21 * - Equal to SDIO clock 22 * - 2/5 PLL0 23 * 24 * CP110 has 32 gateable clocks, for the various peripherals in the IP. 25 */ 26 27 #define pr_fmt(fmt) "cp110-system-controller: " fmt 28 29 #include "armada_ap_cp_helper.h" 30 #include <linux/clk-provider.h> 31 #include <linux/mfd/syscon.h> 32 #include <linux/init.h> 33 #include <linux/of.h> 34 #include <linux/platform_device.h> 35 #include <linux/regmap.h> 36 #include <linux/slab.h> 37 38 #define CP110_PM_CLOCK_GATING_REG 0x220 39 #define CP110_NAND_FLASH_CLK_CTRL_REG 0x700 40 #define NF_CLOCK_SEL_400_MASK BIT(0) 41 42 enum { 43 CP110_CLK_TYPE_CORE, 44 CP110_CLK_TYPE_GATABLE, 45 }; 46 47 #define CP110_MAX_CORE_CLOCKS 6 48 #define CP110_MAX_GATABLE_CLOCKS 32 49 50 #define CP110_CLK_NUM \ 51 (CP110_MAX_CORE_CLOCKS + CP110_MAX_GATABLE_CLOCKS) 52 53 #define CP110_CORE_PLL0 0 54 #define CP110_CORE_PPV2 1 55 #define CP110_CORE_X2CORE 2 56 #define CP110_CORE_CORE 3 57 #define CP110_CORE_NAND 4 58 #define CP110_CORE_SDIO 5 59 60 /* A number of gateable clocks need special handling */ 61 #define CP110_GATE_AUDIO 0 62 #define CP110_GATE_COMM_UNIT 1 63 #define CP110_GATE_NAND 2 64 #define CP110_GATE_PPV2 3 65 #define CP110_GATE_SDIO 4 66 #define CP110_GATE_MG 5 67 #define CP110_GATE_MG_CORE 6 68 #define CP110_GATE_XOR1 7 69 #define CP110_GATE_XOR0 8 70 #define CP110_GATE_GOP_DP 9 71 #define CP110_GATE_PCIE_X1_0 11 72 #define CP110_GATE_PCIE_X1_1 12 73 #define CP110_GATE_PCIE_X4 13 74 #define CP110_GATE_PCIE_XOR 14 75 #define CP110_GATE_SATA 15 76 #define CP110_GATE_SATA_USB 16 77 #define CP110_GATE_MAIN 17 78 #define CP110_GATE_SDMMC_GOP 18 79 #define CP110_GATE_SLOW_IO 21 80 #define CP110_GATE_USB3H0 22 81 #define CP110_GATE_USB3H1 23 82 #define CP110_GATE_USB3DEV 24 83 #define CP110_GATE_EIP150 25 84 #define CP110_GATE_EIP197 26 85 86 static const char * const gate_base_names[] = { 87 [CP110_GATE_AUDIO] = "audio", 88 [CP110_GATE_COMM_UNIT] = "communit", 89 [CP110_GATE_NAND] = "nand", 90 [CP110_GATE_PPV2] = "ppv2", 91 [CP110_GATE_SDIO] = "sdio", 92 [CP110_GATE_MG] = "mg-domain", 93 [CP110_GATE_MG_CORE] = "mg-core", 94 [CP110_GATE_XOR1] = "xor1", 95 [CP110_GATE_XOR0] = "xor0", 96 [CP110_GATE_GOP_DP] = "gop-dp", 97 [CP110_GATE_PCIE_X1_0] = "pcie_x10", 98 [CP110_GATE_PCIE_X1_1] = "pcie_x11", 99 [CP110_GATE_PCIE_X4] = "pcie_x4", 100 [CP110_GATE_PCIE_XOR] = "pcie-xor", 101 [CP110_GATE_SATA] = "sata", 102 [CP110_GATE_SATA_USB] = "sata-usb", 103 [CP110_GATE_MAIN] = "main", 104 [CP110_GATE_SDMMC_GOP] = "sd-mmc-gop", 105 [CP110_GATE_SLOW_IO] = "slow-io", 106 [CP110_GATE_USB3H0] = "usb3h0", 107 [CP110_GATE_USB3H1] = "usb3h1", 108 [CP110_GATE_USB3DEV] = "usb3dev", 109 [CP110_GATE_EIP150] = "eip150", 110 [CP110_GATE_EIP197] = "eip197" 111 }; 112 113 struct cp110_gate_clk { 114 struct clk_hw hw; 115 struct regmap *regmap; 116 u8 bit_idx; 117 }; 118 119 #define to_cp110_gate_clk(hw) container_of(hw, struct cp110_gate_clk, hw) 120 121 static int cp110_gate_enable(struct clk_hw *hw) 122 { 123 struct cp110_gate_clk *gate = to_cp110_gate_clk(hw); 124 125 regmap_update_bits(gate->regmap, CP110_PM_CLOCK_GATING_REG, 126 BIT(gate->bit_idx), BIT(gate->bit_idx)); 127 128 return 0; 129 } 130 131 static void cp110_gate_disable(struct clk_hw *hw) 132 { 133 struct cp110_gate_clk *gate = to_cp110_gate_clk(hw); 134 135 regmap_update_bits(gate->regmap, CP110_PM_CLOCK_GATING_REG, 136 BIT(gate->bit_idx), 0); 137 } 138 139 static int cp110_gate_is_enabled(struct clk_hw *hw) 140 { 141 struct cp110_gate_clk *gate = to_cp110_gate_clk(hw); 142 u32 val; 143 144 regmap_read(gate->regmap, CP110_PM_CLOCK_GATING_REG, &val); 145 146 return val & BIT(gate->bit_idx); 147 } 148 149 static const struct clk_ops cp110_gate_ops = { 150 .enable = cp110_gate_enable, 151 .disable = cp110_gate_disable, 152 .is_enabled = cp110_gate_is_enabled, 153 }; 154 155 static struct clk_hw *cp110_register_gate(const char *name, 156 const char *parent_name, 157 struct regmap *regmap, u8 bit_idx) 158 { 159 struct cp110_gate_clk *gate; 160 struct clk_hw *hw; 161 struct clk_init_data init; 162 int ret; 163 164 gate = kzalloc(sizeof(*gate), GFP_KERNEL); 165 if (!gate) 166 return ERR_PTR(-ENOMEM); 167 168 memset(&init, 0, sizeof(init)); 169 170 init.name = name; 171 init.ops = &cp110_gate_ops; 172 init.parent_names = &parent_name; 173 init.num_parents = 1; 174 175 gate->regmap = regmap; 176 gate->bit_idx = bit_idx; 177 gate->hw.init = &init; 178 179 hw = &gate->hw; 180 ret = clk_hw_register(NULL, hw); 181 if (ret) { 182 kfree(gate); 183 hw = ERR_PTR(ret); 184 } 185 186 return hw; 187 } 188 189 static void cp110_unregister_gate(struct clk_hw *hw) 190 { 191 clk_hw_unregister(hw); 192 kfree(to_cp110_gate_clk(hw)); 193 } 194 195 static struct clk_hw *cp110_of_clk_get(struct of_phandle_args *clkspec, 196 void *data) 197 { 198 struct clk_hw_onecell_data *clk_data = data; 199 unsigned int type = clkspec->args[0]; 200 unsigned int idx = clkspec->args[1]; 201 202 if (type == CP110_CLK_TYPE_CORE) { 203 if (idx >= CP110_MAX_CORE_CLOCKS) 204 return ERR_PTR(-EINVAL); 205 return clk_data->hws[idx]; 206 } else if (type == CP110_CLK_TYPE_GATABLE) { 207 if (idx >= CP110_MAX_GATABLE_CLOCKS) 208 return ERR_PTR(-EINVAL); 209 return clk_data->hws[CP110_MAX_CORE_CLOCKS + idx]; 210 } 211 212 return ERR_PTR(-EINVAL); 213 } 214 215 static int cp110_syscon_common_probe(struct platform_device *pdev, 216 struct device_node *syscon_node) 217 { 218 struct regmap *regmap; 219 struct device *dev = &pdev->dev; 220 struct device_node *np = dev->of_node; 221 const char *ppv2_name, *pll0_name, *core_name, *x2core_name, *nand_name, 222 *sdio_name; 223 struct clk_hw_onecell_data *cp110_clk_data; 224 struct clk_hw *hw, **cp110_clks; 225 u32 nand_clk_ctrl; 226 int i, ret; 227 char *gate_name[ARRAY_SIZE(gate_base_names)]; 228 229 regmap = syscon_node_to_regmap(syscon_node); 230 if (IS_ERR(regmap)) 231 return PTR_ERR(regmap); 232 233 ret = regmap_read(regmap, CP110_NAND_FLASH_CLK_CTRL_REG, 234 &nand_clk_ctrl); 235 if (ret) 236 return ret; 237 238 cp110_clk_data = devm_kzalloc(dev, sizeof(*cp110_clk_data) + 239 sizeof(struct clk_hw *) * CP110_CLK_NUM, 240 GFP_KERNEL); 241 if (!cp110_clk_data) 242 return -ENOMEM; 243 244 cp110_clks = cp110_clk_data->hws; 245 cp110_clk_data->num = CP110_CLK_NUM; 246 247 /* Register the PLL0 which is the root of the hw tree */ 248 pll0_name = ap_cp_unique_name(dev, syscon_node, "pll0"); 249 hw = clk_hw_register_fixed_rate(NULL, pll0_name, NULL, 0, 250 1000 * 1000 * 1000); 251 if (IS_ERR(hw)) { 252 ret = PTR_ERR(hw); 253 goto fail_pll0; 254 } 255 256 cp110_clks[CP110_CORE_PLL0] = hw; 257 258 /* PPv2 is PLL0/3 */ 259 ppv2_name = ap_cp_unique_name(dev, syscon_node, "ppv2-core"); 260 hw = clk_hw_register_fixed_factor(NULL, ppv2_name, pll0_name, 0, 1, 3); 261 if (IS_ERR(hw)) { 262 ret = PTR_ERR(hw); 263 goto fail_ppv2; 264 } 265 266 cp110_clks[CP110_CORE_PPV2] = hw; 267 268 /* X2CORE clock is PLL0/2 */ 269 x2core_name = ap_cp_unique_name(dev, syscon_node, "x2core"); 270 hw = clk_hw_register_fixed_factor(NULL, x2core_name, pll0_name, 271 0, 1, 2); 272 if (IS_ERR(hw)) { 273 ret = PTR_ERR(hw); 274 goto fail_eip; 275 } 276 277 cp110_clks[CP110_CORE_X2CORE] = hw; 278 279 /* Core clock is X2CORE/2 */ 280 core_name = ap_cp_unique_name(dev, syscon_node, "core"); 281 hw = clk_hw_register_fixed_factor(NULL, core_name, x2core_name, 282 0, 1, 2); 283 if (IS_ERR(hw)) { 284 ret = PTR_ERR(hw); 285 goto fail_core; 286 } 287 288 cp110_clks[CP110_CORE_CORE] = hw; 289 /* NAND can be either PLL0/2.5 or core clock */ 290 nand_name = ap_cp_unique_name(dev, syscon_node, "nand-core"); 291 if (nand_clk_ctrl & NF_CLOCK_SEL_400_MASK) 292 hw = clk_hw_register_fixed_factor(NULL, nand_name, 293 pll0_name, 0, 2, 5); 294 else 295 hw = clk_hw_register_fixed_factor(NULL, nand_name, 296 core_name, 0, 1, 1); 297 if (IS_ERR(hw)) { 298 ret = PTR_ERR(hw); 299 goto fail_nand; 300 } 301 302 cp110_clks[CP110_CORE_NAND] = hw; 303 304 /* SDIO clock is PLL0/2.5 */ 305 sdio_name = ap_cp_unique_name(dev, syscon_node, "sdio-core"); 306 hw = clk_hw_register_fixed_factor(NULL, sdio_name, 307 pll0_name, 0, 2, 5); 308 if (IS_ERR(hw)) { 309 ret = PTR_ERR(hw); 310 goto fail_sdio; 311 } 312 313 cp110_clks[CP110_CORE_SDIO] = hw; 314 315 /* create the unique name for all the gate clocks */ 316 for (i = 0; i < ARRAY_SIZE(gate_base_names); i++) 317 gate_name[i] = ap_cp_unique_name(dev, syscon_node, 318 gate_base_names[i]); 319 320 for (i = 0; i < ARRAY_SIZE(gate_base_names); i++) { 321 const char *parent; 322 323 if (gate_name[i] == NULL) 324 continue; 325 326 switch (i) { 327 case CP110_GATE_NAND: 328 parent = nand_name; 329 break; 330 case CP110_GATE_MG: 331 case CP110_GATE_GOP_DP: 332 case CP110_GATE_PPV2: 333 parent = ppv2_name; 334 break; 335 case CP110_GATE_SDIO: 336 parent = sdio_name; 337 break; 338 case CP110_GATE_MAIN: 339 case CP110_GATE_PCIE_XOR: 340 case CP110_GATE_PCIE_X4: 341 case CP110_GATE_EIP150: 342 case CP110_GATE_EIP197: 343 parent = x2core_name; 344 break; 345 default: 346 parent = core_name; 347 break; 348 } 349 hw = cp110_register_gate(gate_name[i], parent, regmap, i); 350 351 if (IS_ERR(hw)) { 352 ret = PTR_ERR(hw); 353 goto fail_gate; 354 } 355 356 cp110_clks[CP110_MAX_CORE_CLOCKS + i] = hw; 357 } 358 359 ret = of_clk_add_hw_provider(np, cp110_of_clk_get, cp110_clk_data); 360 if (ret) 361 goto fail_clk_add; 362 363 platform_set_drvdata(pdev, cp110_clks); 364 365 return 0; 366 367 fail_clk_add: 368 fail_gate: 369 for (i = 0; i < CP110_MAX_GATABLE_CLOCKS; i++) { 370 hw = cp110_clks[CP110_MAX_CORE_CLOCKS + i]; 371 372 if (hw) 373 cp110_unregister_gate(hw); 374 } 375 376 clk_hw_unregister_fixed_factor(cp110_clks[CP110_CORE_SDIO]); 377 fail_sdio: 378 clk_hw_unregister_fixed_factor(cp110_clks[CP110_CORE_NAND]); 379 fail_nand: 380 clk_hw_unregister_fixed_factor(cp110_clks[CP110_CORE_CORE]); 381 fail_core: 382 clk_hw_unregister_fixed_factor(cp110_clks[CP110_CORE_X2CORE]); 383 fail_eip: 384 clk_hw_unregister_fixed_factor(cp110_clks[CP110_CORE_PPV2]); 385 fail_ppv2: 386 clk_hw_unregister_fixed_rate(cp110_clks[CP110_CORE_PLL0]); 387 fail_pll0: 388 return ret; 389 } 390 391 static int cp110_syscon_legacy_clk_probe(struct platform_device *pdev) 392 { 393 dev_warn(&pdev->dev, FW_WARN "Using legacy device tree binding\n"); 394 dev_warn(&pdev->dev, FW_WARN "Update your device tree:\n"); 395 dev_warn(&pdev->dev, FW_WARN 396 "This binding won't be supported in future kernels\n"); 397 398 return cp110_syscon_common_probe(pdev, pdev->dev.of_node); 399 } 400 401 static int cp110_clk_probe(struct platform_device *pdev) 402 { 403 return cp110_syscon_common_probe(pdev, pdev->dev.of_node->parent); 404 } 405 406 static const struct of_device_id cp110_syscon_legacy_of_match[] = { 407 { .compatible = "marvell,cp110-system-controller0", }, 408 { } 409 }; 410 411 static struct platform_driver cp110_syscon_legacy_driver = { 412 .probe = cp110_syscon_legacy_clk_probe, 413 .driver = { 414 .name = "marvell-cp110-system-controller0", 415 .of_match_table = cp110_syscon_legacy_of_match, 416 .suppress_bind_attrs = true, 417 }, 418 }; 419 builtin_platform_driver(cp110_syscon_legacy_driver); 420 421 static const struct of_device_id cp110_clock_of_match[] = { 422 { .compatible = "marvell,cp110-clock", }, 423 { } 424 }; 425 426 static struct platform_driver cp110_clock_driver = { 427 .probe = cp110_clk_probe, 428 .driver = { 429 .name = "marvell-cp110-clock", 430 .of_match_table = cp110_clock_of_match, 431 .suppress_bind_attrs = true, 432 }, 433 }; 434 builtin_platform_driver(cp110_clock_driver); 435