#define pr_fmt(fmt) "clk-eyeq: " fmt
#include <linux/array_size.h>
#include <linux/auxiliary_bus.h>
#include <linux/bitfield.h>
#include <linux/bits.h>
#include <linux/clk-provider.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/io-64-nonatomic-hi-lo.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/overflow.h>
#include <linux/platform_device.h>
#include <linux/printk.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/types.h>
#include <dt-bindings/clock/mobileye,eyeq5-clk.h>
#include <dt-bindings/clock/mobileye,eyeq6lplus-clk.h>
#include <dt-bindings/clock/mobileye,eyeq7h-clk.h>
#define FRACG_PCSR0_DAC_EN BIT(0)
#define FRACG_PCSR0_DSM_EN BIT(1)
#define FRACG_PCSR0_PLL_EN BIT(2)
#define FRACG_PCSR0_FOUTPOSTDIV_EN BIT(3)
#define FRACG_PCSR0_POST_DIV1 GENMASK(6, 4)
#define FRACG_PCSR0_POST_DIV2 GENMASK(9, 7)
#define FRACG_PCSR0_REF_DIV GENMASK(15, 10)
#define FRACG_PCSR0_INTIN GENMASK(27, 16)
#define FRACG_PCSR0_BYPASS BIT(28)
#define FRACG_PCSR0_PLL_LOCKED BIT(31)
#define FRACG_PCSR1_RESET BIT(0)
#define FRACG_PCSR1_SSGC_DIV GENMASK(4, 1)
#define FRACG_PCSR1_SPREAD GENMASK(9, 5)
#define FRACG_PCSR1_DIS_SSCG BIT(10)
#define FRACG_PCSR1_DOWN_SPREAD BIT(11)
#define FRACG_PCSR1_FRAC_IN GENMASK(31, 12)
#define JFRACR_PCSR0_BYPASS BIT(0)
#define JFRACR_PCSR0_PLL_EN BIT(1)
#define JFRACR_PCSR0_FOUTVCO_EN BIT(2)
#define JFRACR_PCSR0_FOUTPOSTDIV_EN BIT(3)
#define JFRACR_PCSR0_POST_DIV1 GENMASK(6, 4)
#define JFRACR_PCSR0_POST_DIV2 GENMASK(9, 7)
#define JFRACR_PCSR0_REF_DIV GENMASK(15, 10)
#define JFRACR_PCSR0_FB_DIV GENMASK(27, 16)
#define JFRACR_PCSR0_VCO_SEL GENMASK(29, 28)
#define JFRACR_PCSR0_PLL_LOCKED GENMASK(31, 30)
#define JFRACR_PCSR1_FRAC_IN GENMASK(23, 0)
#define JFRACR_PCSR1_FOUT4PHASE_EN BIT(24)
#define JFRACR_PCSR1_DAC_EN BIT(25)
#define JFRACR_PCSR1_DSM_EN BIT(26)
#define JFRACR_PCSR2_RESET BIT(0)
#define JFRACR_PCSR2_DIS_SSCG BIT(1)
#define JFRACR_PCSR2_DOWN_SPREAD BIT(2)
#define JFRACR_PCSR2_SSGC_DIV GENMASK(7, 4)
#define JFRACR_PCSR2_SPREAD GENMASK(12, 8)
#define AINTP_PCSR_BYPASS BIT(0)
#define AINTP_PCSR_PLL_EN BIT(1)
#define AINTP_PCSR_FOUTVCO_EN BIT(2)
#define AINTP_PCSR_FOUTPOSTDIV_EN BIT(3)
#define AINTP_PCSR_POST_DIV1 GENMASK(6, 4)
#define AINTP_PCSR_POST_DIV2 GENMASK(9, 7)
#define AINTP_PCSR_REF_DIV GENMASK(15, 10)
#define AINTP_PCSR_FB_DIV GENMASK(27, 16)
#define AINTP_PCSR_VCO_SEL GENMASK(29, 28)
#define AINTP_PCSR_PLL_LOCKED BIT(31)
#define PARENT_BY_FWNAME (-1)
#define PARENT_BY_NAME (-2)
struct eqc_clock {
int index;
int parent_idx;
const char *name;
const char *parent_name;
int (*probe)(struct device *dev, struct device_node *np,
const struct eqc_clock *clk, void __iomem *base,
struct clk_hw_onecell_data *cells);
void (*unregister)(struct clk_hw *hw);
union {
struct {
unsigned int reg;
u8 shift;
u8 width;
unsigned long flags;
const struct clk_div_table *table;
} div;
struct {
unsigned int mult;
unsigned int div;
} ff;
struct {
unsigned int reg;
} pll;
};
};
struct eqc_match_data {
unsigned int clk_count;
const struct eqc_clock *clks;
const char *reset_auxdev_name;
const char *pinctrl_auxdev_name;
const char *eth_phy_auxdev_name;
unsigned int early_clk_count;
};
struct eqc_early_match_data {
unsigned int early_clk_count;
const struct eqc_clock *early_clks;
unsigned int late_clk_count;
};
static void eqc_pll_downshift_factors(unsigned long *mult, unsigned long *div)
{
unsigned long biggest;
unsigned int shift;
static_assert(sizeof_field(struct clk_fixed_factor, mult) == sizeof(unsigned int));
static_assert(sizeof_field(struct clk_fixed_factor, div) == sizeof(unsigned int));
if (*mult <= UINT_MAX && *div <= UINT_MAX)
return;
biggest = max(*mult, *div);
shift = __fls(biggest) - (BITS_PER_BYTE * sizeof(unsigned int)) + 1;
*mult >>= shift;
*div >>= shift;
}
static int eqc_pll_parse_aintp(void __iomem *base, unsigned long *mult, unsigned long *div)
{
u32 r0;
r0 = readl(base);
if (r0 & AINTP_PCSR_BYPASS) {
*mult = 1;
*div = 1;
return 0;
}
if (!(r0 & AINTP_PCSR_PLL_LOCKED))
return -EINVAL;
*mult = FIELD_GET(AINTP_PCSR_FB_DIV, r0);
*div = FIELD_GET(AINTP_PCSR_REF_DIV, r0);
if (!*mult || !*div)
return -EINVAL;
return 0;
}
static int eqc_pll_parse_fracg(void __iomem *base, unsigned long *mult,
unsigned long *div, unsigned long *acc)
{
unsigned long spread;
u32 r0, r1;
u64 val;
val = readq(base);
r0 = val;
r1 = val >> 32;
if (r0 & FRACG_PCSR0_BYPASS) {
*mult = 1;
*div = 1;
*acc = 0;
return 0;
}
if (!(r0 & FRACG_PCSR0_PLL_LOCKED))
return -EINVAL;
*mult = FIELD_GET(FRACG_PCSR0_INTIN, r0);
*div = FIELD_GET(FRACG_PCSR0_REF_DIV, r0);
if (r0 & FRACG_PCSR0_DSM_EN) {
*div *= (1ULL << 20);
*mult = *mult * (1ULL << 20) + FIELD_GET(FRACG_PCSR1_FRAC_IN, r1);
}
if (!*mult || !*div)
return -EINVAL;
if (r1 & (FRACG_PCSR1_RESET | FRACG_PCSR1_DIS_SSCG)) {
*acc = 0;
return 0;
}
spread = FIELD_GET(FRACG_PCSR1_SPREAD, r1);
*acc = DIV_ROUND_CLOSEST(spread * 1000000000, 1024 * 2);
if (r1 & FRACG_PCSR1_DOWN_SPREAD) {
*mult *= 2048 - spread;
*div *= 2048;
eqc_pll_downshift_factors(mult, div);
}
return 0;
}
static int eqc_pll_parse_jfracr(void __iomem *base, unsigned long *mult,
unsigned long *div, unsigned long *acc)
{
unsigned long spread;
u32 r0, r1, r2;
u64 val;
val = readq(base);
r0 = val;
r1 = val >> 32;
r2 = readl(base + 8);
if (r0 & JFRACR_PCSR0_BYPASS) {
*mult = 1;
*div = 1;
*acc = 0;
return 0;
}
if (!(r0 & JFRACR_PCSR0_PLL_LOCKED))
return -EINVAL;
*mult = FIELD_GET(JFRACR_PCSR0_FB_DIV, r0);
*div = FIELD_GET(JFRACR_PCSR0_REF_DIV, r0);
if (r1 & JFRACR_PCSR1_DSM_EN) {
*div *= (1ULL << 24);
*mult = *mult * (1ULL << 24) + FIELD_GET(JFRACR_PCSR1_FRAC_IN, r1);
}
if (!*mult || !*div)
return -EINVAL;
if (r2 & (JFRACR_PCSR2_RESET | JFRACR_PCSR2_DIS_SSCG)) {
*acc = 0;
} else {
spread = FIELD_GET(JFRACR_PCSR2_SPREAD, r2);
*acc = DIV_ROUND_CLOSEST(spread * 1000000000, 1024 * 2);
if (r2 & JFRACR_PCSR2_DOWN_SPREAD) {
*mult *= 2048 - spread;
*div *= 2048;
}
}
eqc_pll_downshift_factors(mult, div);
return 0;
}
static void eqc_auxdev_create_optional(struct device *dev, void __iomem *base,
const char *name)
{
struct auxiliary_device *adev;
if (name) {
adev = devm_auxiliary_device_create(dev, name,
(void __force *)base);
if (!adev)
dev_warn(dev, "failed creating auxiliary device %s.%s\n",
KBUILD_MODNAME, name);
}
}
static int eqc_fill_parent_data(const struct eqc_clock *clk,
struct clk_hw_onecell_data *cells,
struct clk_parent_data *parent_data)
{
int pidx = clk->parent_idx;
memset(parent_data, 0, sizeof(struct clk_parent_data));
if (pidx == PARENT_BY_FWNAME) {
parent_data->index = -1;
parent_data->fw_name = clk->parent_name;
} else if (pidx == PARENT_BY_NAME) {
parent_data->index = -1;
parent_data->name = clk->parent_name;
} else if (pidx >= 0 && pidx < cells->num && !IS_ERR(cells->hws[pidx])) {
parent_data->hw = cells->hws[pidx];
} else {
return -EINVAL;
}
return 0;
}
static int eqc_probe_divider(struct device *dev, struct device_node *np,
const struct eqc_clock *clk, void __iomem *base,
struct clk_hw_onecell_data *cells)
{
struct clk_parent_data parent_data;
struct clk_hw *hw;
int ret;
ret = eqc_fill_parent_data(clk, cells, &parent_data);
if (ret)
return ret;
hw = clk_hw_register_divider_table_parent_data(dev, clk->name,
&parent_data, 0, base + clk->div.reg, clk->div.shift,
clk->div.width, clk->div.flags, clk->div.table, NULL);
if (IS_ERR(hw))
return PTR_ERR(hw);
cells->hws[clk->index] = hw;
return 0;
}
static int eqc_probe_fixed_factor(struct device *dev, struct device_node *np,
const struct eqc_clock *clk, void __iomem *base,
struct clk_hw_onecell_data *cells)
{
struct clk_parent_data parent_data;
struct clk_hw *hw;
int ret;
ret = eqc_fill_parent_data(clk, cells, &parent_data);
if (ret)
return ret;
hw = clk_hw_register_fixed_factor_pdata(dev, np, clk->name, &parent_data, 0,
clk->ff.mult, clk->ff.div, 0, 0);
if (IS_ERR(hw))
return PTR_ERR(hw);
cells->hws[clk->index] = hw;
return 0;
}
static int eqc_probe_pll_aintp(struct device *dev, struct device_node *np,
const struct eqc_clock *clk, void __iomem *base,
struct clk_hw_onecell_data *cells)
{
struct clk_parent_data parent_data = { };
unsigned long mult, div;
struct clk_hw *hw;
int ret;
ret = eqc_pll_parse_aintp(base + clk->pll.reg, &mult, &div);
if (ret)
return ret;
ret = eqc_fill_parent_data(clk, cells, &parent_data);
if (ret)
return ret;
hw = clk_hw_register_fixed_factor_pdata(dev, np, clk->name, &parent_data,
0, mult, div, 0, 0);
if (IS_ERR(hw))
return PTR_ERR(hw);
cells->hws[clk->index] = hw;
return 0;
}
static int eqc_probe_pll_fracg(struct device *dev, struct device_node *np,
const struct eqc_clock *clk, void __iomem *base,
struct clk_hw_onecell_data *cells)
{
struct clk_parent_data parent_data;
unsigned long mult, div, acc;
struct clk_hw *hw;
int ret;
ret = eqc_pll_parse_fracg(base + clk->pll.reg, &mult, &div, &acc);
if (ret)
return ret;
ret = eqc_fill_parent_data(clk, cells, &parent_data);
if (ret)
return ret;
hw = clk_hw_register_fixed_factor_pdata(dev, np, clk->name, &parent_data, 0, mult,
div, acc, CLK_FIXED_FACTOR_FIXED_ACCURACY);
if (IS_ERR(hw))
return PTR_ERR(hw);
cells->hws[clk->index] = hw;
return 0;
}
static int eqc_probe_pll_jfracr(struct device *dev, struct device_node *np,
const struct eqc_clock *clk, void __iomem *base,
struct clk_hw_onecell_data *cells)
{
struct clk_parent_data parent_data = { };
unsigned long mult, div, acc;
struct clk_hw *hw;
int ret;
ret = eqc_pll_parse_jfracr(base + clk->pll.reg, &mult, &div, &acc);
if (ret)
return ret;
ret = eqc_fill_parent_data(clk, cells, &parent_data);
if (ret)
return ret;
hw = clk_hw_register_fixed_factor_pdata(dev, np, clk->name, &parent_data, 0, mult,
div, acc, CLK_FIXED_FACTOR_FIXED_ACCURACY);
if (IS_ERR(hw))
return PTR_ERR(hw);
cells->hws[clk->index] = hw;
return 0;
}
static int eqc_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *np = dev->of_node;
const struct eqc_match_data *data;
struct clk_hw_onecell_data *cells;
unsigned int i, clk_count;
void __iomem *base;
int ret;
base = devm_platform_ioremap_resource(pdev, 0);
if (IS_ERR(base))
return PTR_ERR(base);
data = device_get_match_data(dev);
if (!data)
return 0;
eqc_auxdev_create_optional(dev, base, data->reset_auxdev_name);
eqc_auxdev_create_optional(dev, base, data->pinctrl_auxdev_name);
eqc_auxdev_create_optional(dev, base, data->eth_phy_auxdev_name);
if (data->clk_count == 0)
return 0;
clk_count = data->clk_count + data->early_clk_count;
cells = kzalloc_flex(*cells, hws, clk_count);
if (!cells)
return -ENOMEM;
cells->num = clk_count;
for (i = 0; i < clk_count; i++)
cells->hws[i] = ERR_PTR(-EINVAL);
for (i = 0; i < data->clk_count; i++) {
const struct eqc_clock *clk = &data->clks[i];
if (clk->probe)
ret = clk->probe(dev, NULL, clk, base, cells);
else
ret = -EINVAL;
if (ret)
dev_warn(dev, "failed probing clock %s: %d\n", clk->name, ret);
}
ret = of_clk_add_hw_provider(np, of_clk_hw_onecell_get, cells);
if (ret) {
for (i = 0; i < data->clk_count; i++) {
const struct eqc_clock *clk = &data->clks[i];
struct clk_hw *hw = cells->hws[clk->index];
if (!IS_ERR_OR_NULL(hw) && clk->unregister)
clk->unregister(hw);
}
kfree(cells);
}
return ret;
}
#define DIV(_index, _parent_idx, _name, _parent_name, \
_reg, _shift, _width) \
{ \
.index = _index, \
.parent_idx = _parent_idx, \
.name = _name, \
.parent_name = _parent_name, \
.probe = eqc_probe_divider, \
.unregister = clk_hw_unregister_divider, \
.div.reg = _reg, \
.div.shift = _shift, \
.div.width = _width, \
.div.flags = CLK_DIVIDER_EVEN_INTEGERS, \
.div.table = NULL, \
}
#define DIV_TABLE_RO(_index, _parent_idx, _name, _parent_name, \
_reg, _shift, _width, _table) \
{ \
.index = _index, \
.parent_idx = _parent_idx, \
.name = _name, \
.parent_name = _parent_name, \
.probe = eqc_probe_divider, \
.unregister = clk_hw_unregister_divider, \
.div.reg = _reg, \
.div.shift = _shift, \
.div.width = _width, \
.div.flags = CLK_DIVIDER_READ_ONLY, \
.div.table = _table, \
}
#define FF(_index, _parent_idx, _name, _parent_name, _mult, _div) \
{ \
.index = _index, \
.parent_idx = _parent_idx, \
.name = _name, \
.parent_name = _parent_name, \
.probe = eqc_probe_fixed_factor, \
.unregister = clk_hw_unregister_fixed_factor, \
.ff.mult = _mult, \
.ff.div = _div, \
}
#define PLL_AINTP(_index, _parent_idx, _name, _parent_name, _reg) \
{ \
.index = _index, \
.parent_idx = _parent_idx, \
.name = _name, \
.parent_name = _parent_name, \
.probe = eqc_probe_pll_aintp, \
.unregister = clk_hw_unregister_fixed_factor, \
.pll.reg = _reg, \
}
#define PLL_FRACG(_index, _parent_idx, _name, _parent_name, _reg) \
{ \
.index = _index, \
.parent_idx = _parent_idx, \
.name = _name, \
.parent_name = _parent_name, \
.probe = eqc_probe_pll_fracg, \
.unregister = clk_hw_unregister_fixed_factor, \
.pll.reg = _reg, \
}
#define PLL_JFRACR(_index, _parent_idx, _name, _parent_name, _reg) \
{ \
.index = _index, \
.parent_idx = _parent_idx, \
.name = _name, \
.parent_name = _parent_name, \
.probe = eqc_probe_pll_jfracr, \
.unregister = clk_hw_unregister_fixed_factor, \
.pll.reg = _reg, \
}
enum {
EQ5C_CPU_OCC = EQ5C_PER_OCC_PCI + 1,
EQ5C_CPU_SI_CSS0,
EQ5C_CPU_CPC,
EQ5C_CPU_CM,
EQ5C_CPU_MEM,
EQ5C_CPU_OCC_ISRAM,
EQ5C_CPU_ISRAM,
EQ5C_CPU_OCC_DBU,
EQ5C_CPU_SI_DBU_TP,
EQ5C_VDI_OCC_VDI,
EQ5C_VDI_VDI,
EQ5C_VDI_OCC_CAN_SER,
EQ5C_VDI_CAN_SER,
EQ5C_VDI_I2C_SER,
EQ5C_PER_PERIPH,
EQ5C_PER_CAN,
EQ5C_PER_TIMER,
EQ5C_PER_CCF,
EQ5C_PER_OCC_MJPEG,
EQ5C_PER_HSM,
EQ5C_PER_MJPEG,
EQ5C_PER_FCMU_A,
};
static const struct eqc_clock eqc_eyeq5_early_clks[] = {
PLL_FRACG(EQ5C_PLL_CPU, PARENT_BY_FWNAME, "pll-cpu", "ref", 0x02C),
PLL_FRACG(EQ5C_PLL_PER, PARENT_BY_FWNAME, "pll-per", "ref", 0x05C),
FF(EQ5C_CPU_OCC, EQ5C_PLL_CPU, "occ-cpu", NULL, 1, 1),
FF(EQ5C_CPU_SI_CSS0, EQ5C_CPU_OCC, "si-css0", NULL, 1, 1),
FF(EQ5C_CPU_CORE0, EQ5C_CPU_SI_CSS0, "core0", NULL, 1, 1),
FF(EQ5C_CPU_CORE1, EQ5C_CPU_SI_CSS0, "core1", NULL, 1, 1),
FF(EQ5C_CPU_CORE2, EQ5C_CPU_SI_CSS0, "core2", NULL, 1, 1),
FF(EQ5C_CPU_CORE3, EQ5C_CPU_SI_CSS0, "core3", NULL, 1, 1),
FF(EQ5C_PER_OCC, EQ5C_PLL_PER, "occ-periph", NULL, 1, 16),
FF(EQ5C_PER_UART, EQ5C_PER_OCC, "uart", NULL, 1, 1),
};
static const struct eqc_clock eqc_eyeq5_clks[] = {
PLL_FRACG(EQ5C_PLL_VMP, PARENT_BY_FWNAME, "pll-vmp", "ref", 0x034),
PLL_FRACG(EQ5C_PLL_PMA, PARENT_BY_FWNAME, "pll-pma", "ref", 0x03C),
PLL_FRACG(EQ5C_PLL_VDI, PARENT_BY_FWNAME, "pll-vdi", "ref", 0x044),
PLL_FRACG(EQ5C_PLL_DDR0, PARENT_BY_FWNAME, "pll-ddr0", "ref", 0x04C),
PLL_FRACG(EQ5C_PLL_PCI, PARENT_BY_FWNAME, "pll-pci", "ref", 0x054),
PLL_FRACG(EQ5C_PLL_PMAC, PARENT_BY_FWNAME, "pll-pmac", "ref", 0x064),
PLL_FRACG(EQ5C_PLL_MPC, PARENT_BY_FWNAME, "pll-mpc", "ref", 0x06C),
PLL_FRACG(EQ5C_PLL_DDR1, PARENT_BY_FWNAME, "pll-ddr1", "ref", 0x074),
DIV(EQ5C_DIV_OSPI, PARENT_BY_NAME, "div-ospi", "pll-per", 0x11C, 0, 4),
FF(EQ5C_CPU_CPC, PARENT_BY_NAME, "cpc", "si-css0", 1, 1),
FF(EQ5C_CPU_CM, PARENT_BY_NAME, "cm", "si-css0", 1, 1),
FF(EQ5C_CPU_MEM, PARENT_BY_NAME, "mem", "si-css0", 1, 1),
FF(EQ5C_CPU_OCC_ISRAM, PARENT_BY_NAME, "occ-isram", "pll-cpu", 1, 2),
FF(EQ5C_CPU_ISRAM, EQ5C_CPU_OCC_ISRAM, "isram", NULL, 1, 1),
FF(EQ5C_CPU_OCC_DBU, PARENT_BY_NAME, "occ-dbu", "pll-cpu", 1, 10),
FF(EQ5C_CPU_SI_DBU_TP, EQ5C_CPU_OCC_DBU, "si-dbu-tp", NULL, 1, 1),
FF(EQ5C_VDI_OCC_VDI, PARENT_BY_NAME, "occ-vdi", "pll-vdi", 1, 2),
FF(EQ5C_VDI_VDI, EQ5C_VDI_OCC_VDI, "vdi", NULL, 1, 1),
FF(EQ5C_VDI_OCC_CAN_SER, PARENT_BY_NAME, "occ-can-ser", "pll-vdi", 1, 16),
FF(EQ5C_VDI_CAN_SER, EQ5C_VDI_OCC_CAN_SER, "can-ser", NULL, 1, 1),
FF(EQ5C_VDI_I2C_SER, PARENT_BY_NAME, "i2c-ser", "pll-vdi", 1, 20),
FF(EQ5C_PER_PERIPH, PARENT_BY_NAME, "periph", "occ-periph", 1, 1),
FF(EQ5C_PER_CAN, PARENT_BY_NAME, "can", "occ-periph", 1, 1),
FF(EQ5C_PER_SPI, PARENT_BY_NAME, "spi", "occ-periph", 1, 1),
FF(EQ5C_PER_I2C, PARENT_BY_NAME, "i2c", "occ-periph", 1, 1),
FF(EQ5C_PER_TIMER, PARENT_BY_NAME, "timer", "occ-periph", 1, 1),
FF(EQ5C_PER_GPIO, PARENT_BY_NAME, "gpio", "occ-periph", 1, 1),
FF(EQ5C_PER_EMMC, PARENT_BY_NAME, "emmc-sys", "pll-per", 1, 10),
FF(EQ5C_PER_CCF, PARENT_BY_NAME, "ccf-ctrl", "pll-per", 1, 4),
FF(EQ5C_PER_OCC_MJPEG, PARENT_BY_NAME, "occ-mjpeg", "pll-per", 1, 2),
FF(EQ5C_PER_HSM, EQ5C_PER_OCC_MJPEG, "hsm", NULL, 1, 1),
FF(EQ5C_PER_MJPEG, EQ5C_PER_OCC_MJPEG, "mjpeg", NULL, 1, 1),
FF(EQ5C_PER_FCMU_A, PARENT_BY_NAME, "fcmu-a", "pll-per", 1, 20),
FF(EQ5C_PER_OCC_PCI, PARENT_BY_NAME, "occ-pci-sys", "pll-per", 1, 8),
};
static const struct eqc_early_match_data eqc_eyeq5_early_match_data __initconst = {
.early_clk_count = ARRAY_SIZE(eqc_eyeq5_early_clks),
.early_clks = eqc_eyeq5_early_clks,
.late_clk_count = ARRAY_SIZE(eqc_eyeq5_clks),
};
static const struct eqc_match_data eqc_eyeq5_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq5_clks),
.clks = eqc_eyeq5_clks,
.reset_auxdev_name = "reset",
.pinctrl_auxdev_name = "pinctrl",
.eth_phy_auxdev_name = "phy",
.early_clk_count = ARRAY_SIZE(eqc_eyeq5_early_clks),
};
static const struct eqc_clock eqc_eyeq6l_clks[] = {
PLL_FRACG(EQ6LC_PLL_DDR, PARENT_BY_FWNAME, "pll-ddr", "ref", 0x02C),
PLL_FRACG(EQ6LC_PLL_CPU, PARENT_BY_FWNAME, "pll-cpu", "ref", 0x034),
PLL_FRACG(EQ6LC_PLL_PER, PARENT_BY_FWNAME, "pll-per", "ref", 0x03C),
PLL_FRACG(EQ6LC_PLL_VDI, PARENT_BY_FWNAME, "pll-vdi", "ref", 0x044),
};
static const struct eqc_match_data eqc_eyeq6l_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq6l_clks),
.clks = eqc_eyeq6l_clks,
.reset_auxdev_name = "reset",
};
static const struct eqc_clock eqc_eyeq6lplus_early_clks[] = {
PLL_FRACG(EQ6LPC_PLL_CPU, PARENT_BY_FWNAME, "pll-cpu", "ref", 0x058),
FF(EQ6LPC_CPU_OCC, EQ6LPC_PLL_CPU, "occ-cpu", NULL, 1, 1),
};
static const struct eqc_clock eqc_eyeq6lplus_clks[] = {
PLL_FRACG(EQ6LPC_PLL_DDR, PARENT_BY_FWNAME, "pll-ddr", "ref", 0x02C),
PLL_FRACG(EQ6LPC_PLL_ACC, PARENT_BY_FWNAME, "pll-acc", "ref", 0x034),
PLL_FRACG(EQ6LPC_PLL_PER, PARENT_BY_FWNAME, "pll-per", "ref", 0x03C),
PLL_FRACG(EQ6LPC_PLL_VDI, PARENT_BY_FWNAME, "pll-vdi", "ref", 0x044),
FF(EQ6LPC_DDR_OCC, EQ6LPC_PLL_DDR, "occ-ddr", NULL, 1, 1),
FF(EQ6LPC_ACC_VDI, EQ6LPC_PLL_ACC, "vdi-div", NULL, 1, 10),
FF(EQ6LPC_ACC_OCC, EQ6LPC_PLL_ACC, "occ-acc", NULL, 1, 1),
FF(EQ6LPC_ACC_FCMU, EQ6LPC_ACC_OCC, "fcmu-a-clk", NULL, 1, 10),
FF(EQ6LPC_PER_OCC, EQ6LPC_PLL_PER, "occ-per", NULL, 1, 1),
FF(EQ6LPC_PER_I2C_SER, EQ6LPC_PER_OCC, "i2c-ser-clk", NULL, 1, 10),
FF(EQ6LPC_PER_PCLK, EQ6LPC_PER_OCC, "pclk", NULL, 1, 4),
FF(EQ6LPC_PER_TSU, EQ6LPC_PER_OCC, "tsu-clk", NULL, 1, 8),
FF(EQ6LPC_PER_OSPI, EQ6LPC_PER_OCC, "ospi-ref-clk", NULL, 1, 10),
FF(EQ6LPC_PER_GPIO, EQ6LPC_PER_OCC, "gpio-clk", NULL, 1, 4),
FF(EQ6LPC_PER_TIMER, EQ6LPC_PER_OCC, "timer-clk", NULL, 1, 4),
FF(EQ6LPC_PER_I2C, EQ6LPC_PER_OCC, "i2c-clk", NULL, 1, 4),
FF(EQ6LPC_PER_UART, EQ6LPC_PER_OCC, "uart-clk", NULL, 1, 4),
FF(EQ6LPC_PER_SPI, EQ6LPC_PER_OCC, "spi-clk", NULL, 1, 4),
FF(EQ6LPC_PER_PERIPH, EQ6LPC_PER_OCC, "periph-clk", NULL, 1, 1),
FF(EQ6LPC_VDI_OCC, EQ6LPC_PLL_VDI, "occ-vdi", NULL, 1, 1),
};
static const struct eqc_early_match_data eqc_eyeq6lplus_early_match_data __initconst = {
.early_clk_count = ARRAY_SIZE(eqc_eyeq6lplus_early_clks),
.early_clks = eqc_eyeq6lplus_early_clks,
.late_clk_count = ARRAY_SIZE(eqc_eyeq6lplus_clks),
};
static const struct eqc_match_data eqc_eyeq6lplus_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq6lplus_clks),
.clks = eqc_eyeq6lplus_clks,
.reset_auxdev_name = "reset",
.pinctrl_auxdev_name = "pinctrl",
.early_clk_count = ARRAY_SIZE(eqc_eyeq6lplus_early_clks),
};
static const struct eqc_match_data eqc_eyeq6h_west_match_data = {
.reset_auxdev_name = "reset_west",
};
static const struct eqc_clock eqc_eyeq6h_east_clks[] = {
PLL_FRACG(0, PARENT_BY_FWNAME, "pll-east", "ref", 0x074),
};
static const struct eqc_match_data eqc_eyeq6h_east_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq6h_east_clks),
.clks = eqc_eyeq6h_east_clks,
.reset_auxdev_name = "reset_east",
};
static const struct eqc_clock eqc_eyeq6h_south_clks[] = {
PLL_FRACG(EQ6HC_SOUTH_PLL_VDI, PARENT_BY_FWNAME, "pll-vdi", "ref", 0x000),
PLL_FRACG(EQ6HC_SOUTH_PLL_PCIE, PARENT_BY_FWNAME, "pll-pcie", "ref", 0x008),
PLL_FRACG(EQ6HC_SOUTH_PLL_PER, PARENT_BY_FWNAME, "pll-per", "ref", 0x010),
PLL_FRACG(EQ6HC_SOUTH_PLL_ISP, PARENT_BY_FWNAME, "pll-isp", "ref", 0x018),
DIV(EQ6HC_SOUTH_DIV_EMMC, EQ6HC_SOUTH_PLL_PER, "div-emmc", NULL, 0x070, 4, 4),
DIV(EQ6HC_SOUTH_DIV_OSPI_REF, EQ6HC_SOUTH_PLL_PER, "div-ospi-ref", NULL, 0x090, 4, 4),
DIV(EQ6HC_SOUTH_DIV_OSPI_SYS, EQ6HC_SOUTH_PLL_PER, "div-ospi-sys", NULL, 0x090, 8, 1),
DIV(EQ6HC_SOUTH_DIV_TSU, EQ6HC_SOUTH_PLL_PCIE, "div-tsu", NULL, 0x098, 4, 8),
};
static const struct eqc_match_data eqc_eyeq6h_south_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq6h_south_clks),
.clks = eqc_eyeq6h_south_clks,
};
static const struct eqc_clock eqc_eyeq6h_ddr0_clks[] = {
PLL_FRACG(0, PARENT_BY_FWNAME, "pll-ddr0", "ref", 0x074),
};
static const struct eqc_match_data eqc_eyeq6h_ddr0_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq6h_ddr0_clks),
.clks = eqc_eyeq6h_ddr0_clks,
};
static const struct eqc_clock eqc_eyeq6h_ddr1_clks[] = {
PLL_FRACG(0, PARENT_BY_FWNAME, "pll-ddr1", "ref", 0x074),
};
static const struct eqc_match_data eqc_eyeq6h_ddr1_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq6h_ddr1_clks),
.clks = eqc_eyeq6h_ddr1_clks,
};
static const struct eqc_clock eqc_eyeq6h_acc_clks[] = {
PLL_FRACG(EQ6HC_ACC_PLL_XNN, PARENT_BY_FWNAME, "pll-xnn", "ref", 0x040),
PLL_FRACG(EQ6HC_ACC_PLL_VMP, PARENT_BY_FWNAME, "pll-vmp", "ref", 0x050),
PLL_FRACG(EQ6HC_ACC_PLL_PMA, PARENT_BY_FWNAME, "pll-pma", "ref", 0x05C),
PLL_FRACG(EQ6HC_ACC_PLL_MPC, PARENT_BY_FWNAME, "pll-mpc", "ref", 0x068),
PLL_FRACG(EQ6HC_ACC_PLL_NOC, PARENT_BY_FWNAME, "pll-noc", "ref", 0x070),
};
static const struct eqc_match_data eqc_eyeq6h_acc_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq6h_acc_clks),
.clks = eqc_eyeq6h_acc_clks,
.reset_auxdev_name = "reset_acc",
};
static const struct eqc_clock eqc_eyeq7h_acc0_clks[] = {
PLL_AINTP(EQ7HC_ACC_PLL_VMP, PARENT_BY_FWNAME, "pll-acc0-vmp", "ref_100p0", 0x400),
PLL_AINTP(EQ7HC_ACC_PLL_MPC, PARENT_BY_FWNAME, "pll-acc0-mpc", "ref_100p0", 0x404),
PLL_AINTP(EQ7HC_ACC_PLL_PMA, PARENT_BY_FWNAME, "pll-acc0-pma", "ref_100p0", 0x408),
PLL_AINTP(EQ7HC_ACC_PLL_NOC, PARENT_BY_FWNAME, "pll-acc0-noc-acc", "ref_106p6", 0x40c),
FF(EQ7HC_ACC_DIV_PMA, EQ7HC_ACC_PLL_PMA, "acc0_pma", NULL, 1, 2),
FF(EQ7HC_ACC_DIV_NCORE, EQ7HC_ACC_PLL_NOC, "acc0_ncore", NULL, 1, 2),
FF(EQ7HC_ACC_DIV_CFG, EQ7HC_ACC_PLL_NOC, "acc0_cfg", NULL, 1, 8),
};
static const struct eqc_match_data eqc_eyeq7h_acc0_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_acc0_clks),
.clks = eqc_eyeq7h_acc0_clks,
.reset_auxdev_name = "reset_acc0",
};
static const struct eqc_clock eqc_eyeq7h_acc1_clks[] = {
PLL_AINTP(EQ7HC_ACC_PLL_VMP, PARENT_BY_FWNAME, "pll-acc1-vmp", "ref_100p0", 0x400),
PLL_AINTP(EQ7HC_ACC_PLL_MPC, PARENT_BY_FWNAME, "pll-acc1-mpc", "ref_100p0", 0x404),
PLL_AINTP(EQ7HC_ACC_PLL_PMA, PARENT_BY_FWNAME, "pll-acc1-pma", "ref_100p0", 0x408),
PLL_AINTP(EQ7HC_ACC_PLL_NOC, PARENT_BY_FWNAME, "pll-acc1-noc-acc", "ref_106p6", 0x40c),
};
static const struct eqc_match_data eqc_eyeq7h_acc1_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_acc1_clks),
.clks = eqc_eyeq7h_acc1_clks,
.reset_auxdev_name = "reset_acc1",
};
static const struct clk_div_table eqc_eyeq7h_ddr_apb_div_table[] = {
{ .val = 0, .div = 8 },
{ .val = 1, .div = 128 },
{ .val = 0, .div = 0 },
};
static const struct clk_div_table eqc_eyeq7h_ddr_ref_div_table[] = {
{ .val = 0, .div = 2 },
{ .val = 1, .div = 8 },
{ .val = 0, .div = 0 },
};
static const struct clk_div_table eqc_eyeq7h_ddr_dfi_div_table[] = {
{ .val = 0, .div = 2 },
{ .val = 1, .div = 32 },
{ .val = 0, .div = 0 },
};
static const struct eqc_clock eqc_eyeq7h_ddr0_clks[] = {
PLL_AINTP(EQ7HC_DDR_PLL, PARENT_BY_FWNAME, "pll-ddr0", "ref", 0x0),
DIV_TABLE_RO(EQ7HC_DDR_DIV_APB, EQ7HC_DDR_PLL, "div-ddr0_apb", NULL,
0x08, 10, 1, eqc_eyeq7h_ddr_apb_div_table),
DIV_TABLE_RO(EQ7HC_DDR_DIV_PLLREF, EQ7HC_DDR_PLL, "div-ddr0_pllref", NULL,
0x08, 10, 1, eqc_eyeq7h_ddr_ref_div_table),
DIV_TABLE_RO(EQ7HC_DDR_DIV_DFI, EQ7HC_DDR_PLL, "div-ddr0-dfi", NULL,
0x08, 10, 1, eqc_eyeq7h_ddr_dfi_div_table),
};
static const struct eqc_match_data eqc_eyeq7h_ddr0_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_ddr0_clks),
.clks = eqc_eyeq7h_ddr0_clks,
.reset_auxdev_name = "reset_ddr0",
};
static const struct eqc_clock eqc_eyeq7h_ddr1_clks[] = {
PLL_AINTP(EQ7HC_DDR_PLL, PARENT_BY_FWNAME, "pll-ddr1", "ref", 0x0),
DIV_TABLE_RO(EQ7HC_DDR_DIV_APB, EQ7HC_DDR_PLL, "div-ddr1_apb", NULL,
0x08, 10, 1, eqc_eyeq7h_ddr_apb_div_table),
DIV_TABLE_RO(EQ7HC_DDR_DIV_PLLREF, EQ7HC_DDR_PLL, "div-ddr1_pllref", NULL,
0x08, 10, 1, eqc_eyeq7h_ddr_ref_div_table),
DIV_TABLE_RO(EQ7HC_DDR_DIV_DFI, EQ7HC_DDR_PLL, "div-ddr1-dfi", NULL,
0x08, 10, 1, eqc_eyeq7h_ddr_dfi_div_table),
};
static const struct eqc_match_data eqc_eyeq7h_ddr1_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_ddr1_clks),
.clks = eqc_eyeq7h_ddr1_clks,
.reset_auxdev_name = "reset_ddr1",
};
static const struct eqc_clock eqc_eyeq7h_east_clocks[] = {
PLL_JFRACR(EQ7HC_EAST_PLL_106P6, PARENT_BY_FWNAME, "pll-106p6-e", "ref", 0x00),
FF(EQ7HC_EAST_DIV_REF_106P6, EQ7HC_EAST_PLL_106P6, "ref_106p6_e", NULL, 1, 40),
PLL_AINTP(EQ7HC_EAST_PLL_NOC, EQ7HC_EAST_DIV_REF_106P6, "pll-noc-e", NULL, 0x30),
PLL_AINTP(EQ7HC_EAST_PLL_ISP, PARENT_BY_FWNAME, "pll-isp", "ref_100p0", 0x38),
PLL_AINTP(EQ7HC_EAST_PLL_VEU, PARENT_BY_FWNAME, "pll-veu", "ref_100p0", 0x40),
FF(EQ7HC_EAST_DIV_REF_DDR_PHY, EQ7HC_EAST_PLL_106P6, "ref_ddr_phy_e", NULL, 1, 2),
FF(EQ7HC_EAST_DIV_CORE, EQ7HC_EAST_PLL_NOC, "core_e", NULL, 1, 2),
FF(EQ7HC_EAST_DIV_CORE_MBIST, EQ7HC_EAST_PLL_NOC, "core_mbist_e", NULL, 1, 2),
FF(EQ7HC_EAST_DIV_ISRAM_MBIST, EQ7HC_EAST_PLL_NOC, "isram_mbist_e", NULL, 1, 2),
FF(EQ7HC_EAST_DIV_CFG, EQ7HC_EAST_PLL_NOC, "cfg_e", NULL, 1, 4),
FF(EQ7HC_EAST_DIV_VEU_CORE, EQ7HC_EAST_PLL_VEU, "veu_core", NULL, 1, 4),
FF(EQ7HC_EAST_DIV_VEU_MBIST, EQ7HC_EAST_PLL_VEU, "veu_mbist", NULL, 1, 4),
FF(EQ7HC_EAST_DIV_VEU_OCP, EQ7HC_EAST_PLL_VEU, "veu_ocp", NULL, 1, 16),
FF(EQ7HC_EAST_DIV_LBITS, EQ7HC_EAST_PLL_ISP, "lbits_e", NULL, 1, 48),
FF(EQ7HC_EAST_DIV_ISP0_CORE, EQ7HC_EAST_PLL_ISP, "isp0_core", NULL, 1, 2),
};
static const struct eqc_match_data eqc_eyeq7h_east_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_east_clocks),
.clks = eqc_eyeq7h_east_clocks,
.reset_auxdev_name = "reset_east",
};
static const struct eqc_clock eqc_eyeq7h_mips0_clks[] = {
PLL_AINTP(EQ7HC_MIPS_PLL_CPU, PARENT_BY_FWNAME, "pll-cpu0", "ref", 0x0),
FF(EQ7HC_MIPS_DIV_CM, EQ7HC_MIPS_PLL_CPU, "mips0_cm", NULL, 1, 2),
};
static const struct eqc_match_data eqc_eyeq7h_mips0_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_mips0_clks),
.clks = eqc_eyeq7h_mips0_clks,
};
static const struct eqc_clock eqc_eyeq7h_mips1_clks[] = {
PLL_AINTP(EQ7HC_MIPS_PLL_CPU, PARENT_BY_FWNAME, "pll-cpu1", "ref", 0x0),
FF(EQ7HC_MIPS_DIV_CM, EQ7HC_MIPS_PLL_CPU, "mips1_cm", NULL, 1, 2),
};
static const struct eqc_match_data eqc_eyeq7h_mips1_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_mips1_clks),
.clks = eqc_eyeq7h_mips1_clks,
};
static const struct eqc_clock eqc_eyeq7h_mips2_clks[] = {
PLL_AINTP(EQ7HC_MIPS_PLL_CPU, PARENT_BY_FWNAME, "pll-cpu2", "ref", 0x0),
FF(EQ7HC_MIPS_DIV_CM, EQ7HC_MIPS_PLL_CPU, "mips2_cm", NULL, 1, 2),
};
static const struct eqc_match_data eqc_eyeq7h_mips2_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_mips2_clks),
.clks = eqc_eyeq7h_mips2_clks,
};
static const struct eqc_clock eqc_eyeq7h_periph_east_clks[] = {
PLL_AINTP(EQ7HC_PERIPH_EAST_PLL_PER, PARENT_BY_FWNAME, "pll-periph_east_per", "ref", 0x0),
FF(EQ7HC_PERIPH_EAST_DIV_PER, EQ7HC_PERIPH_EAST_PLL_PER, "periph_e", NULL, 1, 10),
};
static const struct eqc_match_data eqc_eyeq7h_periph_east_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_periph_east_clks),
.clks = eqc_eyeq7h_periph_east_clks,
.reset_auxdev_name = "reset_periph_east",
};
static const struct eqc_clock eqc_eyeq7h_periph_west_clks[] = {
PLL_AINTP(EQ7HC_PERIPH_WEST_PLL_PER, PARENT_BY_FWNAME,
"pll-periph_west_per", "ref_100p0", 0x0),
PLL_AINTP(EQ7HC_PERIPH_WEST_PLL_I2S, PARENT_BY_FWNAME,
"pll-periph_west_i2s", "ref_106p6", 0x4),
FF(EQ7HC_PERIPH_WEST_DIV_PER, EQ7HC_PERIPH_WEST_PLL_PER, "periph_w", NULL, 1, 10),
FF(EQ7HC_PERIPH_WEST_DIV_I2S, EQ7HC_PERIPH_WEST_PLL_I2S, "periph_i2s_ser_w", NULL, 1, 100),
};
static const struct eqc_match_data eqc_eyeq7h_periph_west_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_periph_west_clks),
.clks = eqc_eyeq7h_periph_west_clks,
.reset_auxdev_name = "reset_periph_west",
};
static const struct eqc_clock eqc_eyeq7h_south_clks[] = {
PLL_JFRACR(EQ7HC_SOUTH_PLL_100P0, PARENT_BY_FWNAME, "pll-100p0", "ref", 0x40),
FF(EQ7HC_SOUTH_DIV_REF_100P0, EQ7HC_SOUTH_PLL_100P0, "ref_100p0", NULL, 1, 48),
PLL_AINTP(EQ7HC_SOUTH_PLL_XSPI, EQ7HC_SOUTH_DIV_REF_100P0, "pll-xspi", NULL, 0x10),
PLL_AINTP(EQ7HC_SOUTH_PLL_VDIO, EQ7HC_SOUTH_DIV_REF_100P0, "pll-vdio", NULL, 0x18),
PLL_AINTP(EQ7HC_SOUTH_PLL_PER, EQ7HC_SOUTH_DIV_REF_100P0, "pll-per-s", NULL, 0x20),
FF(EQ7HC_SOUTH_DIV_VDO_DSI_SYS, EQ7HC_SOUTH_PLL_100P0, "vdo_dsi_sys", NULL, 1, 9),
FF(EQ7HC_SOUTH_DIV_PMA_CMN_REF, EQ7HC_SOUTH_PLL_100P0, "pma_cmn_ref", NULL, 1, 48),
FF(EQ7HC_SOUTH_DIV_REF_UFS, EQ7HC_SOUTH_PLL_100P0, "ref_ufs", NULL, 1, 250),
FF(EQ7HC_SOUTH_DIV_XSPI_SYS, EQ7HC_SOUTH_PLL_XSPI, "xspi_sys", NULL, 1, 8),
FF(EQ7HC_SOUTH_DIV_XSPI_MBIST, EQ7HC_SOUTH_PLL_XSPI, "xspi_mbist", NULL, 1, 8),
FF(EQ7HC_SOUTH_DIV_NOC_S, EQ7HC_SOUTH_PLL_PER, "noc_s", NULL, 1, 2),
FF(EQ7HC_SOUTH_DIV_PCIE_SYS, EQ7HC_SOUTH_PLL_PER, "pcie_sys", NULL, 1, 4),
FF(EQ7HC_SOUTH_DIV_PCIE_SYS_MBIST, EQ7HC_SOUTH_PLL_PER, "pcie_sys_mbist", NULL, 1, 4),
FF(EQ7HC_SOUTH_DIV_PCIE_GBE_PHY, EQ7HC_SOUTH_PLL_PER, "pcie_gbe_phy_apb", NULL, 1, 16),
FF(EQ7HC_SOUTH_DIV_UFS_CORE, EQ7HC_SOUTH_PLL_PER, "ufs_core", NULL, 1, 8),
FF(EQ7HC_SOUTH_DIV_UFS_SMS, EQ7HC_SOUTH_PLL_PER, "ufs_sms", NULL, 1, 5),
FF(EQ7HC_SOUTH_DIV_UFS_ROM_SMS, EQ7HC_SOUTH_PLL_PER, "ufs_rom_sms", NULL, 1, 5),
FF(EQ7HC_SOUTH_DIV_ETH_SYS, EQ7HC_SOUTH_PLL_PER, "eth_sys", NULL, 1, 8),
FF(EQ7HC_SOUTH_DIV_ETH_MBIST, EQ7HC_SOUTH_PLL_PER, "eth_mbist", NULL, 1, 8),
FF(EQ7HC_SOUTH_DIV_CFG_S, EQ7HC_SOUTH_PLL_PER, "cfg_s", NULL, 1, 8),
FF(EQ7HC_SOUTH_DIV_TSU, EQ7HC_SOUTH_PLL_PER, "tsu", NULL, 1, 64),
FF(EQ7HC_SOUTH_DIV_VDIO, EQ7HC_SOUTH_PLL_VDIO, "vdio", NULL, 1, 4),
FF(EQ7HC_SOUTH_DIV_VDIO_CORE, EQ7HC_SOUTH_PLL_VDIO, "vdio_core", NULL, 1, 4),
FF(EQ7HC_SOUTH_DIV_VDIO_CORE_MBIST, EQ7HC_SOUTH_PLL_VDIO, "vdio_core_mbist", NULL, 1, 4),
FF(EQ7HC_SOUTH_DIV_VDO_CORE_MBIST, EQ7HC_SOUTH_PLL_VDIO, "vdo_core_mbist", NULL, 1, 4),
FF(EQ7HC_SOUTH_DIV_VDO_P, EQ7HC_SOUTH_PLL_VDIO, "vdo_p", NULL, 1, 40),
FF(EQ7HC_SOUTH_DIV_VDIO_CFG, EQ7HC_SOUTH_PLL_VDIO, "vdio_cfg", NULL, 1, 150),
FF(EQ7HC_SOUTH_DIV_VDIO_TXCLKESC, EQ7HC_SOUTH_PLL_VDIO, "vdio_txclkesc", NULL, 1, 8),
};
static const struct eqc_match_data eqc_eyeq7h_south_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_south_clks),
.clks = eqc_eyeq7h_south_clks,
.reset_auxdev_name = "reset_south",
};
static const struct eqc_clock eqc_eyeq7h_west_clks[] = {
PLL_JFRACR(EQ7HC_WEST_PLL_106P6, PARENT_BY_FWNAME, "pll-106p6-w", "ref", 0x0),
FF(EQ7HC_WEST_DIV_REF_106P6, EQ7HC_WEST_PLL_106P6, "ref_106p6_w", NULL, 1, 40),
PLL_AINTP(EQ7HC_WEST_PLL_NOC, EQ7HC_WEST_DIV_REF_106P6, "pll-noc-w", NULL, 0x30),
PLL_AINTP(EQ7HC_WEST_PLL_GPU, PARENT_BY_FWNAME, "pll-gpu", "ref_100p0", 0x38),
PLL_AINTP(EQ7HC_WEST_PLL_SSI, PARENT_BY_FWNAME, "pll-ssi", "ref_100p0", 0x40),
FF(EQ7HC_WEST_DIV_GPU, EQ7HC_WEST_PLL_GPU, "gpu", NULL, 1, 2),
FF(EQ7HC_WEST_DIV_GPU_MBIST, EQ7HC_WEST_PLL_GPU, "gpu_mbist", NULL, 1, 2),
FF(EQ7HC_WEST_DIV_LBITS, EQ7HC_WEST_PLL_GPU, "lbits_w", NULL, 1, 40),
FF(EQ7HC_WEST_DIV_MIPS_TIMER, EQ7HC_WEST_PLL_SSI, "mips_timer", NULL, 1, 24),
FF(EQ7HC_WEST_DIV_SSI_CORE, EQ7HC_WEST_PLL_SSI, "ssi_core", NULL, 1, 2),
FF(EQ7HC_WEST_DIV_SSI_CORE_MBIST, EQ7HC_WEST_PLL_SSI, "ssi_core_mbist", NULL, 1, 2),
FF(EQ7HC_WEST_DIV_SSI_ROM, EQ7HC_WEST_PLL_SSI, "ssi_rom", NULL, 1, 8),
FF(EQ7HC_WEST_DIV_SSI_ROM_MBIST, EQ7HC_WEST_PLL_SSI, "ssi_rom_mbist", NULL, 1, 8),
FF(EQ7HC_WEST_DIV_REF_DDR_PHY, EQ7HC_WEST_PLL_106P6, "ref_ddr_phy_w", NULL, 1, 2),
FF(EQ7HC_WEST_DIV_CORE, EQ7HC_WEST_PLL_NOC, "core_w", NULL, 1, 2),
FF(EQ7HC_WEST_DIV_CORE_MBIST, EQ7HC_WEST_PLL_NOC, "core_mbist_w", NULL, 1, 2),
FF(EQ7HC_WEST_DIV_CFG, EQ7HC_WEST_PLL_NOC, "cfg_w", NULL, 1, 4),
FF(EQ7HC_WEST_DIV_CAU, EQ7HC_WEST_PLL_NOC, "cau_w", NULL, 1, 8),
FF(EQ7HC_WEST_DIV_CAU_MBIST, EQ7HC_WEST_PLL_NOC, "cau_mbist_w", NULL, 1, 8),
};
static const struct eqc_match_data eqc_eyeq7h_west_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_west_clks),
.clks = eqc_eyeq7h_west_clks,
.reset_auxdev_name = "reset_west",
};
static const struct eqc_clock eqc_eyeq7h_xnn0_clks[] = {
PLL_AINTP(EQ7HC_XNN_PLL_XNN0, PARENT_BY_FWNAME, "pll-xnn0-0", "ref_100p0", 0x400),
PLL_AINTP(EQ7HC_XNN_PLL_XNN1, PARENT_BY_FWNAME, "pll-xnn0-1", "ref_100p0", 0x404),
PLL_AINTP(EQ7HC_XNN_PLL_XNN2, PARENT_BY_FWNAME, "pll-xnn0-2", "ref_100p0", 0x408),
PLL_AINTP(EQ7HC_XNN_PLL_CLSTR, PARENT_BY_FWNAME, "pll-xnn0-clstr", "ref_106p6", 0x410),
FF(EQ7HC_XNN_DIV_XNN0, EQ7HC_XNN_PLL_XNN0, "xnn0", NULL, 1, 2),
FF(EQ7HC_XNN_DIV_XNN1, EQ7HC_XNN_PLL_XNN1, "xnn1", NULL, 1, 2),
FF(EQ7HC_XNN_DIV_XNN2, EQ7HC_XNN_PLL_XNN2, "xnn2", NULL, 1, 2),
FF(EQ7HC_XNN_DIV_CLSTR, EQ7HC_XNN_PLL_CLSTR, "xnn0_clstr", NULL, 1, 2),
FF(EQ7HC_XNN_DIV_I2, EQ7HC_XNN_PLL_CLSTR, "xnn0_i2", NULL, 1, 4),
FF(EQ7HC_XNN_DIV_I2_SMS, EQ7HC_XNN_PLL_CLSTR, "xnn0_i2_sms", NULL, 1, 4),
FF(EQ7HC_XNN_DIV_CFG, EQ7HC_XNN_PLL_CLSTR, "xnn0_cfg", NULL, 1, 8),
};
static const struct eqc_match_data eqc_eyeq7h_xnn0_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_xnn0_clks),
.clks = eqc_eyeq7h_xnn0_clks,
.reset_auxdev_name = "reset_xnn0",
};
static const struct eqc_clock eqc_eyeq7h_xnn1_clks[] = {
PLL_AINTP(EQ7HC_XNN_PLL_XNN0, PARENT_BY_FWNAME, "pll-xnn1-0", "ref_100p0", 0x400),
PLL_AINTP(EQ7HC_XNN_PLL_XNN1, PARENT_BY_FWNAME, "pll-xnn1-1", "ref_100p0", 0x404),
PLL_AINTP(EQ7HC_XNN_PLL_XNN2, PARENT_BY_FWNAME, "pll-xnn1-2", "ref_100p0", 0x408),
PLL_AINTP(EQ7HC_XNN_PLL_CLSTR, PARENT_BY_FWNAME, "pll-xnn1-clstr", "ref_106p6", 0x410),
};
static const struct eqc_match_data eqc_eyeq7h_xnn1_match_data = {
.clk_count = ARRAY_SIZE(eqc_eyeq7h_xnn1_clks),
.clks = eqc_eyeq7h_xnn1_clks,
.reset_auxdev_name = "reset_xnn1",
};
static const struct of_device_id eqc_match_table[] = {
{ .compatible = "mobileye,eyeq5-olb", .data = &eqc_eyeq5_match_data },
{ .compatible = "mobileye,eyeq6l-olb", .data = &eqc_eyeq6l_match_data },
{ .compatible = "mobileye,eyeq6lplus-olb", .data = &eqc_eyeq6lplus_match_data },
{ .compatible = "mobileye,eyeq6h-central-olb" },
{ .compatible = "mobileye,eyeq6h-west-olb", .data = &eqc_eyeq6h_west_match_data },
{ .compatible = "mobileye,eyeq6h-east-olb", .data = &eqc_eyeq6h_east_match_data },
{ .compatible = "mobileye,eyeq6h-south-olb", .data = &eqc_eyeq6h_south_match_data },
{ .compatible = "mobileye,eyeq6h-ddr0-olb", .data = &eqc_eyeq6h_ddr0_match_data },
{ .compatible = "mobileye,eyeq6h-ddr1-olb", .data = &eqc_eyeq6h_ddr1_match_data },
{ .compatible = "mobileye,eyeq6h-acc-olb", .data = &eqc_eyeq6h_acc_match_data },
{ .compatible = "mobileye,eyeq7h-acc0-olb", .data = &eqc_eyeq7h_acc0_match_data },
{ .compatible = "mobileye,eyeq7h-acc1-olb", .data = &eqc_eyeq7h_acc1_match_data },
{ .compatible = "mobileye,eyeq7h-ddr0-olb", .data = &eqc_eyeq7h_ddr0_match_data },
{ .compatible = "mobileye,eyeq7h-ddr1-olb", .data = &eqc_eyeq7h_ddr1_match_data },
{ .compatible = "mobileye,eyeq7h-east-olb", .data = &eqc_eyeq7h_east_match_data },
{ .compatible = "mobileye,eyeq7h-mips0-olb", .data = &eqc_eyeq7h_mips0_match_data },
{ .compatible = "mobileye,eyeq7h-mips1-olb", .data = &eqc_eyeq7h_mips1_match_data },
{ .compatible = "mobileye,eyeq7h-mips2-olb", .data = &eqc_eyeq7h_mips2_match_data },
{ .compatible = "mobileye,eyeq7h-periph-east-olb",
.data = &eqc_eyeq7h_periph_east_match_data },
{ .compatible = "mobileye,eyeq7h-periph-west-olb",
.data = &eqc_eyeq7h_periph_west_match_data },
{ .compatible = "mobileye,eyeq7h-south-olb", .data = &eqc_eyeq7h_south_match_data },
{ .compatible = "mobileye,eyeq7h-west-olb", .data = &eqc_eyeq7h_west_match_data },
{ .compatible = "mobileye,eyeq7h-xnn0-olb", .data = &eqc_eyeq7h_xnn0_match_data },
{ .compatible = "mobileye,eyeq7h-xnn1-olb", .data = &eqc_eyeq7h_xnn1_match_data },
{}
};
static struct platform_driver eqc_driver = {
.probe = eqc_probe,
.driver = {
.name = "clk-eyeq",
.of_match_table = eqc_match_table,
.suppress_bind_attrs = true,
},
};
builtin_platform_driver(eqc_driver);
static const struct eqc_clock eqc_eyeq6h_central_early_clks[] = {
PLL_FRACG(EQ6HC_CENTRAL_PLL_CPU, PARENT_BY_FWNAME, "pll-cpu", "ref", 0x02C),
FF(EQ6HC_CENTRAL_CPU_OCC, EQ6HC_CENTRAL_PLL_CPU, "occ-cpu", NULL, 1, 1),
};
static const struct eqc_early_match_data eqc_eyeq6h_central_early_match_data __initconst = {
.early_clk_count = ARRAY_SIZE(eqc_eyeq6h_central_early_clks),
.early_clks = eqc_eyeq6h_central_early_clks,
};
static const struct eqc_clock eqc_eyeq6h_west_early_clks[] = {
PLL_FRACG(EQ6HC_WEST_PLL_PER, PARENT_BY_FWNAME, "pll-west", "ref", 0x074),
FF(EQ6HC_WEST_PER_OCC, EQ6HC_WEST_PLL_PER, "west-per-occ", NULL, 1, 10),
FF(EQ6HC_WEST_PER_UART, EQ6HC_WEST_PER_OCC, "west-per-uart", NULL, 1, 1),
};
static const struct eqc_early_match_data eqc_eyeq6h_west_early_match_data __initconst = {
.early_clk_count = ARRAY_SIZE(eqc_eyeq6h_west_early_clks),
.early_clks = eqc_eyeq6h_west_early_clks,
};
static void __init eqc_early_init(struct device_node *np,
const struct eqc_early_match_data *early_data)
{
struct clk_hw_onecell_data *cells;
unsigned int i, clk_count;
void __iomem *base;
int ret;
clk_count = early_data->early_clk_count + early_data->late_clk_count;
cells = kzalloc_flex(*cells, hws, clk_count);
if (!cells) {
ret = -ENOMEM;
goto err;
}
cells->num = clk_count;
for (i = 0; i < clk_count; i++)
cells->hws[i] = ERR_PTR(-EPROBE_DEFER);
base = of_iomap(np, 0);
if (!base) {
ret = -ENODEV;
goto err;
}
for (i = 0; i < early_data->early_clk_count; i++) {
const struct eqc_clock *clk = &early_data->early_clks[i];
if (clk->probe)
ret = clk->probe(NULL, np, clk, base, cells);
else
ret = -EINVAL;
if (ret) {
pr_err("failed registering %s\n", clk->name);
goto err;
}
}
ret = of_clk_add_hw_provider(np, of_clk_hw_onecell_get, cells);
if (ret) {
pr_err("failed registering clk provider: %d\n", ret);
goto err;
}
return;
err:
pr_err("failed clk init: %d\n", ret);
if (cells) {
of_clk_del_provider(np);
for (i = 0; i < early_data->early_clk_count; i++) {
const struct eqc_clock *clk = &early_data->early_clks[i];
struct clk_hw *hw = cells->hws[clk->index];
if (!IS_ERR_OR_NULL(hw) && clk->unregister)
clk->unregister(hw);
}
kfree(cells);
}
}
static void __init eqc_eyeq5_early_init(struct device_node *np)
{
eqc_early_init(np, &eqc_eyeq5_early_match_data);
}
CLK_OF_DECLARE_DRIVER(eqc_eyeq5, "mobileye,eyeq5-olb", eqc_eyeq5_early_init);
static void __init eqc_eyeq6h_central_early_init(struct device_node *np)
{
eqc_early_init(np, &eqc_eyeq6h_central_early_match_data);
}
CLK_OF_DECLARE_DRIVER(eqc_eyeq6h_central, "mobileye,eyeq6h-central-olb",
eqc_eyeq6h_central_early_init);
static void __init eqc_eyeq6h_west_early_init(struct device_node *np)
{
eqc_early_init(np, &eqc_eyeq6h_west_early_match_data);
}
CLK_OF_DECLARE_DRIVER(eqc_eyeq6h_west, "mobileye,eyeq6h-west-olb",
eqc_eyeq6h_west_early_init);
static void __init eqc_eyeq6lplus_early_init(struct device_node *np)
{
eqc_early_init(np, &eqc_eyeq6lplus_early_match_data);
}
CLK_OF_DECLARE_DRIVER(eqc_eyeq6lplus, "mobileye,eyeq6lplus-olb"