+ /* A held output may be undergoing a firmware rate transition. */
+ if (values[1] & (PLL_CHANNEL_HOLD << shift))
+ return -EBUSY;
+ return regmap_update_bits(clock->regmap, regs[1],
+ PLL_CHANNEL_DISABLE << shift, 0);
+ }
+ case PMB_XTAL:
+ return regmap_update_bits(clock->regmap, reg, XTAL_DRIVER_POWER_DOWN, 0);
+ case PMB_PVTMON:
+ ret = regmap_read(clock->regmap, reg, &value);
+ if (ret)
+ return ret;
+ /* Preserve the divider when firmware already enabled acquisition. */
+ if (value & PVTMON_CLOCK_ENABLE)
+ return 0;
+ return regmap_update_bits(clock->regmap, reg,
+ PVTMON_CLOCK_ENABLE | PVTMON_CLOCK_DIVIDER,
+ PVTMON_CLOCK_ENABLE |
+ FIELD_PREP(PVTMON_CLOCK_DIVIDER, 5));
+ case PMB_ZONE:
+ ret = regmap_read(clock->regmap, reg, &value);
+ if (ret)
+ return ret;
+ /* Power and isolation belong to the power-domain sequencer. */
+ if (!(value & ZONE_POWER_ON) || value & ZONE_POWER_DOWN_REQUEST)
+ return -EHOSTDOWN;
+ if (!(value & ZONE_MANUAL_CONTROL))
+ return 0;
+ return regmap_update_bits(clock->regmap, reg, ZONE_CLOCK_ENABLE,
+ ZONE_CLOCK_ENABLE);
+ case PMB_RUNNER:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static int bcmbca_pmb_clock_is_prepared(struct clk_hw *hw)
+{
+ struct bcmbca_pmb_clock *clock = to_pmb_clock(hw);
+ const struct bcmbca_pmb_clock_desc *desc = clock->desc;
+ unsigned int shift = (desc->channel % 2) * 16;
+ u32 value;
+ int ret;
+
+ if (desc->type == PMB_PLL_CHANNEL) {
+ unsigned int regs[] = {
+ BCMBCA_PMB_REG(desc->bus, desc->device, desc->pll->status),
+ BCMBCA_PMB_REG(desc->bus, desc->device,
+ desc->pll->ch01 + desc->channel / 2),
+ };
+ u32 values[ARRAY_SIZE(regs)];
+
+ ret = regmap_multi_reg_read(clock->regmap, regs, values, ARRAY_SIZE(regs));
+ if (ret || !(values[0] & PLL_LOCK))
+ return 0;
+ return !(values[1] & ((PLL_CHANNEL_DISABLE | PLL_CHANNEL_HOLD) << shift));
+ }
+
+ ret = regmap_read(clock->regmap,
+ BCMBCA_PMB_REG(desc->bus, desc->device, desc->reg), &value);
+ if (ret)
+ return 0;
+
+ switch (desc->type) {
+ case PMB_XTAL:
+ return !(value & XTAL_DRIVER_POWER_DOWN);
+ case PMB_PVTMON:
+ return !!(value & PVTMON_CLOCK_ENABLE);
+ case PMB_ZONE:
+ return (value & ZONE_POWER_ON) && !(value & ZONE_POWER_DOWN_REQUEST) &&
+ (!(value & ZONE_MANUAL_CONTROL) || (value & ZONE_CLOCK_ENABLE));
+ default:
+ return 0;
+ }
+}
+
+static unsigned long bcmbca_pmb_clock_recalc_rate(struct clk_hw *hw,
+ unsigned long parent_rate)
+{
+ struct bcmbca_pmb_clock *clock = to_pmb_clock(hw);
+ const struct bcmbca_pmb_clock_desc *desc = clock->desc;
+ unsigned int regs[4], count = 3;
+ u32 values[4], ndiv, pdiv, channel, mdiv;
+ unsigned int shift = (desc->channel % 2) * 16;
+ u64 multiplier, rate;
+ int ret;
+
+ if (desc->type == PMB_XTAL)
+ return parent_rate;
+ /* The vendor sources do not identify these clocks' parent rates. */
+ if (desc->type != PMB_PLL_CHANNEL)
+ return 0;
+
+ regs[0] = BCMBCA_PMB_REG(desc->bus, desc->device, desc->pll->ndiv);
+ regs[1] = BCMBCA_PMB_REG(desc->bus, desc->device, desc->pll->pdiv);
+ regs[2] = BCMBCA_PMB_REG(desc->bus, desc->device,
+ desc->pll->ch01 + desc->channel / 2);
+ if (desc->channel >= 2)
+ regs[count++] = BCMBCA_PMB_REG(desc->bus, desc->device, desc->pll->ch25);
+
+ ret = regmap_multi_reg_read(clock->regmap, regs, values, count);
+ if (ret) {
+ dev_err_ratelimited(clock->dev, "cannot read %s rate: %d\n", desc->name, ret);
+ return 0;
+ }
+ ndiv = values[0];
+ pdiv = values[1];
+ channel = values[2];
+ if (channel & (PLL_MDIV_OVERRIDE << shift))
+ mdiv = (channel >> shift) & 0xff;
+ else if (desc->channel < 2)
+ mdiv = (pdiv >> (16 + desc->channel * 8)) & 0xff;
+ else
+ mdiv = (values[3] >> ((desc->channel - 2) * 8)) & 0xff;
+
+ pdiv = FIELD_GET(PLL_PDIV, pdiv);
+ /* No rate can be determined from a zero divider. */
+ if (!pdiv || !mdiv)
+ return 0;
+ multiplier = ((u64)FIELD_GET(PLL_NDIV_INT, ndiv) << 20) |
+ FIELD_GET(PLL_NDIV_FRAC, ndiv);
+ rate = div64_u64((u64)parent_rate * multiplier,
+ ((u64)pdiv * mdiv) << 20);
+
+ return rate > ULONG_MAX ? 0 : rate;
+}
+
+static const struct clk_ops bcmbca_pmb_clock_ops = {
+ .prepare = bcmbca_pmb_clock_prepare,
+ .is_prepared = bcmbca_pmb_clock_is_prepared,
+ .recalc_rate = bcmbca_pmb_clock_recalc_rate,
+ /* No unprepare: these clocks can remain in use by PMC firmware. */
+};
+
+static const struct bcmbca_pmb_pll_layout bcm6846_rdppll = {
+ .ch01 = 16,
+ .status = 19,
+ .ndiv = 21,
+ .pdiv = 22,
+ .ch25 = 23,
+};
+
+/* The BIU PLL uses the classic BPCM register layout. */
+static const struct bcmbca_pmb_pll_layout bcm6846_biupll = {
+ .ch01 = 11,
+ .status = 15,
+ .ndiv = 17,
+ .pdiv = 18,
+ .ch25 = 19,
+};
+
+#define PMB_PLL(_id, _name, _device, _channel, _pll) \
+ [_id] = { .name = _name, .type = PMB_PLL_CHANNEL, .bus = 1, \
+ .device = _device, .channel = _channel, \
+ .pll = _pll }
+#define PMB_GATE(_id, _name, _type, _bus, _device, _reg) \
+ [_id] = { .name = _name, .type = _type, .bus = _bus, \
+ .device = _device, .reg = _reg }
+#define PMB_ZONE_CLK(_id, _name, _bus, _device, _zone) \
+ PMB_GATE(_id, _name, PMB_ZONE, _bus, _device, 32 + (_zone) * 8)
+
+static const struct bcmbca_pmb_clock_desc bcm6846_clocks[] = {
+ PMB_PLL(BCM6846_CLK_RDPPLL_CH0, "rdppll-ch0", 3, 0, &bcm6846_rdppll),
+ PMB_PLL(BCM6846_CLK_RDPPLL_CH1, "rdppll-ch1", 3, 1, &bcm6846_rdppll),
+ PMB_PLL(BCM6846_CLK_RDPPLL_CH2, "rdppll-ch2", 3, 2, &bcm6846_rdppll),
+ PMB_PLL(BCM6846_CLK_RDPPLL_CH3, "rdppll-ch3", 3, 3, &bcm6846_rdppll),
+ PMB_PLL(BCM6846_CLK_RDPPLL_CH4, "rdppll-ch4", 3, 4, &bcm6846_rdppll),
+ PMB_PLL(BCM6846_CLK_RDPPLL_CH5, "rdppll-ch5", 3, 5, &bcm6846_rdppll),
+ PMB_PLL(BCM6846_CLK_BIUPLL_CH0, "biupll-ch0", 38, 0, &bcm6846_biupll),
+ PMB_PLL(BCM6846_CLK_BIUPLL_CH1, "biupll-ch1", 38, 1, &bcm6846_biupll),
+ PMB_PLL(BCM6846_CLK_BIUPLL_CH2, "biupll-ch2", 38, 2, &bcm6846_biupll),
+ PMB_PLL(BCM6846_CLK_BIUPLL_CH3, "biupll-ch3", 38, 3, &bcm6846_biupll),
+ PMB_PLL(BCM6846_CLK_BIUPLL_CH4, "biupll-ch4", 38, 4, &bcm6846_biupll),
+ PMB_PLL(BCM6846_CLK_BIUPLL_CH5, "biupll-ch5", 38, 5, &bcm6846_biupll),
+ [BCM6846_CLK_RUNNER] = { .name = "runner", .type = PMB_RUNNER },
+ PMB_GATE(BCM6846_CLK_XTAL_OUT, "xtal-out", PMB_XTAL, 1, 1, XTAL_CONTROL),
+ PMB_GATE(BCM6846_CLK_PVTMON, "pvtmon", PMB_PVTMON, 1, 6, PVTMON_CONFIG),
+ PMB_ZONE_CLK(BCM6846_CLK_PERIPH_ZONE0, "periph-zone0", 0, 0, 0),
+ PMB_ZONE_CLK(BCM6846_CLK_PERIPH_ZONE1, "periph-zone1", 0, 0, 1),
+ PMB_ZONE_CLK(BCM6846_CLK_PERIPH_ZONE2, "periph-zone2", 0, 0, 2),
+ PMB_ZONE_CLK(BCM6846_CLK_PERIPH_ZONE3, "periph-zone3", 0, 0, 3),
+ PMB_ZONE_CLK(BCM6846_CLK_MEMC, "memc", 1, 8, 0),
+ PMB_ZONE_CLK(BCM6846_CLK_USB_ZONE0, "usb-zone0", 1, 10, 0),
+ PMB_ZONE_CLK(BCM6846_CLK_USB_ZONE1, "usb-zone1", 1, 10, 1),
+ PMB_ZONE_CLK(BCM6846_CLK_USB_ZONE2, "usb-zone2", 1, 10, 2),
+ PMB_ZONE_CLK(BCM6846_CLK_USB_ZONE3, "usb-zone3", 1, 10, 3),
+ PMB_ZONE_CLK(BCM6846_CLK_WAN_ZONE0, "wan-zone0", 1, 11, 0),
+ PMB_ZONE_CLK(BCM6846_CLK_WAN_ZONE1, "wan-zone1", 1, 11, 1),
+ PMB_ZONE_CLK(BCM6846_CLK_WAN_ZONE2, "wan-zone2", 1, 11, 2),
+ PMB_ZONE_CLK(BCM6846_CLK_XRDP_ZONE0, "xrdp-zone0", 1, 12, 0),
+ PMB_ZONE_CLK(BCM6846_CLK_XRDP_ZONE1, "xrdp-zone1", 1, 12, 1),
+ PMB_ZONE_CLK(BCM6846_CLK_XRDP_ZONE2, "xrdp-zone2", 1, 12, 2),
+ PMB_ZONE_CLK(BCM6846_CLK_RUNNER0, "runner0", 1, 14, 0),
+ PMB_ZONE_CLK(BCM6846_CLK_RUNNER1, "runner1", 1, 15, 0),
+ PMB_ZONE_CLK(BCM6846_CLK_RUNNER2, "runner2", 1, 16, 0),
+ PMB_ZONE_CLK(BCM6846_CLK_PCIE0, "pcie0", 0, 18, 0),
+ PMB_ZONE_CLK(BCM6846_CLK_PCIE1, "pcie1", 0, 19, 0),
+ /* BIU uses the classic BPCM layout, with its zone at word 16. */
+ PMB_GATE(BCM6846_CLK_BIU, "biu", PMB_ZONE, 1, 39, 16),
+};
+
+static int bcmbca_pmb_clock_probe(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct regmap *regmap = dev_get_regmap(dev->parent, NULL);
+ struct clk_hw_onecell_data *data;
+ struct bcmbca_pmb_clock *clocks;
+ struct clk *ref;
+ unsigned int i;
+ int ret;
+
+ if (!regmap)
+ return -ENODEV;
+
+ ref = devm_clk_get(dev, "ref");