[mirror_ubuntu-jammy-kernel.git] / drivers / clk / sirf / clk-atlas6.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Clock tree for CSR SiRFatlasVI
 *
 * Copyright (c) 2011 - 2014 Cambridge Silicon Radio Limited, a CSR plc group
 * company.
 */

#include <linux/module.h>
#include <linux/bitops.h>
#include <linux/io.h>
#include <linux/clkdev.h>
#include <linux/clk-provider.h>
#include <linux/of_address.h>
#include <linux/syscore_ops.h>

#include "atlas6.h"
#include "clk-common.c"

static struct clk_dmn clk_mmc01 = {
	.regofs = SIRFSOC_CLKC_MMC01_CFG,
	.enable_bit = 59,
	.hw = {
		.init = &clk_mmc01_init,
	},
};

static struct clk_dmn clk_mmc23 = {
	.regofs = SIRFSOC_CLKC_MMC23_CFG,
	.enable_bit = 60,
	.hw = {
		.init = &clk_mmc23_init,
	},
};

static struct clk_dmn clk_mmc45 = {
	.regofs = SIRFSOC_CLKC_MMC45_CFG,
	.enable_bit = 61,
	.hw = {
		.init = &clk_mmc45_init,
	},
};

static const struct clk_init_data clk_nand_init = {
	.name = "nand",
	.ops = &dmn_ops,
	.parent_names = dmn_clk_parents,
	.num_parents = ARRAY_SIZE(dmn_clk_parents),
};

static struct clk_dmn clk_nand = {
	.regofs = SIRFSOC_CLKC_NAND_CFG,
	.enable_bit = 34,
	.hw = {
		.init = &clk_nand_init,
	},
};

enum atlas6_clk_index {
	/* 0    1     2      3      4      5      6       7         8      9 */
	rtc,    osc,   pll1,  pll2,  pll3,  mem,   sys,   security, dsp,   gps,
	mf,     io,    cpu,   uart0, uart1, uart2, tsc,   i2c0,     i2c1,  spi0,
	spi1,   pwmc,  efuse, pulse, dmac0, dmac1, nand,  audio,    usp0,  usp1,
	usp2,   vip,   gfx,   gfx2d,    lcd,   vpp,   mmc01, mmc23,    mmc45, usbpll,
	usb0,  usb1,   cphif, maxclk,
};

static __initdata struct clk_hw *atlas6_clk_hw_array[maxclk] = {
	NULL, /* dummy */
	NULL,
	&clk_pll1.hw,
	&clk_pll2.hw,
	&clk_pll3.hw,
	&clk_mem.hw,
	&clk_sys.hw,
	&clk_security.hw,
	&clk_dsp.hw,
	&clk_gps.hw,
	&clk_mf.hw,
	&clk_io.hw,
	&clk_cpu.hw,
	&clk_uart0.hw,
	&clk_uart1.hw,
	&clk_uart2.hw,
	&clk_tsc.hw,
	&clk_i2c0.hw,
	&clk_i2c1.hw,
	&clk_spi0.hw,
	&clk_spi1.hw,
	&clk_pwmc.hw,
	&clk_efuse.hw,
	&clk_pulse.hw,
	&clk_dmac0.hw,
	&clk_dmac1.hw,
	&clk_nand.hw,
	&clk_audio.hw,
	&clk_usp0.hw,
	&clk_usp1.hw,
	&clk_usp2.hw,
	&clk_vip.hw,
	&clk_gfx.hw,
	&clk_gfx2d.hw,
	&clk_lcd.hw,
	&clk_vpp.hw,
	&clk_mmc01.hw,
	&clk_mmc23.hw,
	&clk_mmc45.hw,
	&usb_pll_clk_hw,
	&clk_usb0.hw,
	&clk_usb1.hw,
	&clk_cphif.hw,
};

static struct clk *atlas6_clks[maxclk];

static void __init atlas6_clk_init(struct device_node *np)
{
	struct device_node *rscnp;
	int i;

	rscnp = of_find_compatible_node(NULL, NULL, "sirf,prima2-rsc");
	sirfsoc_rsc_vbase = of_iomap(rscnp, 0);
	if (!sirfsoc_rsc_vbase)
		panic("unable to map rsc registers\n");
	of_node_put(rscnp);

	sirfsoc_clk_vbase = of_iomap(np, 0);
	if (!sirfsoc_clk_vbase)
		panic("unable to map clkc registers\n");

	/* These are always available (RTC and 26MHz OSC)*/
	atlas6_clks[rtc] = clk_register_fixed_rate(NULL, "rtc", NULL, 0, 32768);
	atlas6_clks[osc] = clk_register_fixed_rate(NULL, "osc", NULL, 0,
						   26000000);

	for (i = pll1; i < maxclk; i++) {
		atlas6_clks[i] = clk_register(NULL, atlas6_clk_hw_array[i]);
		BUG_ON(IS_ERR(atlas6_clks[i]));
	}
	clk_register_clkdev(atlas6_clks[cpu], NULL, "cpu");
	clk_register_clkdev(atlas6_clks[io],  NULL, "io");
	clk_register_clkdev(atlas6_clks[mem],  NULL, "mem");
	clk_register_clkdev(atlas6_clks[mem],  NULL, "osc");

	clk_data.clks = atlas6_clks;
	clk_data.clk_num = maxclk;

	of_clk_add_provider(np, of_clk_src_onecell_get, &clk_data);
}
CLK_OF_DECLARE(atlas6_clk, "sirf,atlas6-clkc", atlas6_clk_init);
Commit	Line	Data
a636cd6c	1	// SPDX-License-Identifier: GPL-2.0-or-later
7bf21bc8 BS	2	/*
	3	* Clock tree for CSR SiRFatlasVI
	4	*
77366929 BS	5	* Copyright (c) 2011 - 2014 Cambridge Silicon Radio Limited, a CSR plc group
77366929 BS	6	* company.
7bf21bc8 BS	7	*/
	8
	9	#include <linux/module.h>
	10	#include <linux/bitops.h>
	11	#include <linux/io.h>
7bf21bc8 BS	12	#include <linux/clkdev.h>
	13	#include <linux/clk-provider.h>
	14	#include <linux/of_address.h>
	15	#include <linux/syscore_ops.h>
	16
	17	#include "atlas6.h"
	18	#include "clk-common.c"
	19
	20	static struct clk_dmn clk_mmc01 = {
	21	.regofs = SIRFSOC_CLKC_MMC01_CFG,
	22	.enable_bit = 59,
	23	.hw = {
	24	.init = &clk_mmc01_init,
	25	},
	26	};
	27
	28	static struct clk_dmn clk_mmc23 = {
	29	.regofs = SIRFSOC_CLKC_MMC23_CFG,
	30	.enable_bit = 60,
	31	.hw = {
	32	.init = &clk_mmc23_init,
	33	},
	34	};
	35
	36	static struct clk_dmn clk_mmc45 = {
	37	.regofs = SIRFSOC_CLKC_MMC45_CFG,
	38	.enable_bit = 61,
	39	.hw = {
	40	.init = &clk_mmc45_init,
	41	},
	42	};
	43
0777066d	44	static const struct clk_init_data clk_nand_init = {
7bf21bc8 BS	45	.name = "nand",
	46	.ops = &dmn_ops,
	47	.parent_names = dmn_clk_parents,
	48	.num_parents = ARRAY_SIZE(dmn_clk_parents),
	49	};
	50
	51	static struct clk_dmn clk_nand = {
	52	.regofs = SIRFSOC_CLKC_NAND_CFG,
	53	.enable_bit = 34,
	54	.hw = {
	55	.init = &clk_nand_init,
	56	},
	57	};
	58
	59	enum atlas6_clk_index {
	60	/* 0 1 2 3 4 5 6 7 8 9 */
	61	rtc, osc, pll1, pll2, pll3, mem, sys, security, dsp, gps,
	62	mf, io, cpu, uart0, uart1, uart2, tsc, i2c0, i2c1, spi0,
	63	spi1, pwmc, efuse, pulse, dmac0, dmac1, nand, audio, usp0, usp1,
	64	usp2, vip, gfx, gfx2d, lcd, vpp, mmc01, mmc23, mmc45, usbpll,
	65	usb0, usb1, cphif, maxclk,
	66	};
	67
	68	static __initdata struct clk_hw *atlas6_clk_hw_array[maxclk] = {
	69	NULL, /* dummy */
	70	NULL,
	71	&clk_pll1.hw,
	72	&clk_pll2.hw,
	73	&clk_pll3.hw,
	74	&clk_mem.hw,
	75	&clk_sys.hw,
	76	&clk_security.hw,
	77	&clk_dsp.hw,
	78	&clk_gps.hw,
	79	&clk_mf.hw,
	80	&clk_io.hw,
	81	&clk_cpu.hw,
	82	&clk_uart0.hw,
	83	&clk_uart1.hw,
	84	&clk_uart2.hw,
	85	&clk_tsc.hw,
	86	&clk_i2c0.hw,
	87	&clk_i2c1.hw,
	88	&clk_spi0.hw,
	89	&clk_spi1.hw,
	90	&clk_pwmc.hw,
	91	&clk_efuse.hw,
	92	&clk_pulse.hw,
	93	&clk_dmac0.hw,
	94	&clk_dmac1.hw,
	95	&clk_nand.hw,
	96	&clk_audio.hw,
	97	&clk_usp0.hw,
	98	&clk_usp1.hw,
	99	&clk_usp2.hw,
	100	&clk_vip.hw,
	101	&clk_gfx.hw,
	102	&clk_gfx2d.hw,
	103	&clk_lcd.hw,
	104	&clk_vpp.hw,
	105	&clk_mmc01.hw,
	106	&clk_mmc23.hw,
	107	&clk_mmc45.hw,
	108	&usb_pll_clk_hw,
109	&clk_usb0.hw,
110	&clk_usb1.hw,
111	&clk_cphif.hw,
112	};
113
114	static struct clk *atlas6_clks[maxclk];
115
116	static void __init atlas6_clk_init(struct device_node *np)
117	{
118	struct device_node *rscnp;
119	int i;
120
121	rscnp = of_find_compatible_node(NULL, NULL, "sirf,prima2-rsc");
122	sirfsoc_rsc_vbase = of_iomap(rscnp, 0);
123	if (!sirfsoc_rsc_vbase)
124	panic("unable to map rsc registers\n");
125	of_node_put(rscnp);
126
127	sirfsoc_clk_vbase = of_iomap(np, 0);
128	if (!sirfsoc_clk_vbase)
129	panic("unable to map clkc registers\n");
130
131	/* These are always available (RTC and 26MHz OSC)*/
23ced271 SB	132	atlas6_clks[rtc] = clk_register_fixed_rate(NULL, "rtc", NULL, 0, 32768);
	133	atlas6_clks[osc] = clk_register_fixed_rate(NULL, "osc", NULL, 0,
	134	26000000);
7bf21bc8 BS	135
	136	for (i = pll1; i < maxclk; i++) {
	137	atlas6_clks[i] = clk_register(NULL, atlas6_clk_hw_array[i]);
12b90b40	138	BUG_ON(IS_ERR(atlas6_clks[i]));
7bf21bc8 BS	139	}
	140	clk_register_clkdev(atlas6_clks[cpu], NULL, "cpu");
	141	clk_register_clkdev(atlas6_clks[io], NULL, "io");
	142	clk_register_clkdev(atlas6_clks[mem], NULL, "mem");
	143	clk_register_clkdev(atlas6_clks[mem], NULL, "osc");
	144
	145	clk_data.clks = atlas6_clks;
	146	clk_data.clk_num = maxclk;
	147
	148	of_clk_add_provider(np, of_clk_src_onecell_get, &clk_data);
	149	}
	150	CLK_OF_DECLARE(atlas6_clk, "sirf,atlas6-clkc", atlas6_clk_init);