phy/broadcom/phy-bcm-ns-usb2.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Broadcom Northstar USB 2.0 PHY Driver
0004  *
0005  * Copyright (C) 2016 Rafał Miłecki <zajec5@gmail.com>
0006  */
0007
0008 #include <linux/bcma/bcma.h>
0009 #include <linux/clk.h>
0010 #include <linux/delay.h>
0011 #include <linux/err.h>
0012 #include <linux/mfd/syscon.h>
0013 #include <linux/module.h>
0014 #include <linux/of_address.h>
0015 #include <linux/of_platform.h>
0016 #include <linux/phy/phy.h>
0017 #include <linux/platform_device.h>
0018 #include <linux/regmap.h>
0019 #include <linux/slab.h>
0020
0021 struct bcm_ns_usb2 {
0022     struct device *dev;
0023     struct clk *ref_clk;
0024     struct phy *phy;
0025     struct regmap *clkset;
0026     void __iomem *base;
0027
0028     /* Deprecated binding */
0029     void __iomem *dmu;
0030 };
0031
0032 static int bcm_ns_usb2_phy_init(struct phy *phy)
0033 {
0034     struct bcm_ns_usb2 *usb2 = phy_get_drvdata(phy);
0035     struct device *dev = usb2->dev;
0036     u32 ref_clk_rate, usb2ctl, usb_pll_ndiv, usb_pll_pdiv;
0037     int err = 0;
0038
0039     err = clk_prepare_enable(usb2->ref_clk);
0040     if (err < 0) {
0041         dev_err(dev, "Failed to prepare ref clock: %d\n", err);
0042         goto err_out;
0043     }
0044
0045     ref_clk_rate = clk_get_rate(usb2->ref_clk);
0046     if (!ref_clk_rate) {
0047         dev_err(dev, "Failed to get ref clock rate\n");
0048         err = -EINVAL;
0049         goto err_clk_off;
0050     }
0051
0052     if (usb2->base)
0053         usb2ctl = readl(usb2->base);
0054     else
0055         usb2ctl = readl(usb2->dmu + BCMA_DMU_CRU_USB2_CONTROL);
0056
0057     if (usb2ctl & BCMA_DMU_CRU_USB2_CONTROL_USB_PLL_PDIV_MASK) {
0058         usb_pll_pdiv = usb2ctl;
0059         usb_pll_pdiv &= BCMA_DMU_CRU_USB2_CONTROL_USB_PLL_PDIV_MASK;
0060         usb_pll_pdiv >>= BCMA_DMU_CRU_USB2_CONTROL_USB_PLL_PDIV_SHIFT;
0061     } else {
0062         usb_pll_pdiv = 1 << 3;
0063     }
0064
0065     /* Calculate ndiv based on a solid 1920 MHz that is for USB2 PHY */
0066     usb_pll_ndiv = (1920000000 * usb_pll_pdiv) / ref_clk_rate;
0067
0068     /* Unlock DMU PLL settings with some magic value */
0069     if (usb2->clkset)
0070         regmap_write(usb2->clkset, 0, 0x0000ea68);
0071     else
0072         writel(0x0000ea68, usb2->dmu + BCMA_DMU_CRU_CLKSET_KEY);
0073
0074     /* Write USB 2.0 PLL control setting */
0075     usb2ctl &= ~BCMA_DMU_CRU_USB2_CONTROL_USB_PLL_NDIV_MASK;
0076     usb2ctl |= usb_pll_ndiv << BCMA_DMU_CRU_USB2_CONTROL_USB_PLL_NDIV_SHIFT;
0077     if (usb2->base)
0078         writel(usb2ctl, usb2->base);
0079     else
0080         writel(usb2ctl, usb2->dmu + BCMA_DMU_CRU_USB2_CONTROL);
0081
0082     /* Lock DMU PLL settings */
0083     if (usb2->clkset)
0084         regmap_write(usb2->clkset, 0, 0x00000000);
0085     else
0086         writel(0x00000000, usb2->dmu + BCMA_DMU_CRU_CLKSET_KEY);
0087
0088 err_clk_off:
0089     clk_disable_unprepare(usb2->ref_clk);
0090 err_out:
0091     return err;
0092 }
0093
0094 static const struct phy_ops ops = {
0095     .init       = bcm_ns_usb2_phy_init,
0096     .owner      = THIS_MODULE,
0097 };
0098
0099 static int bcm_ns_usb2_probe(struct platform_device *pdev)
0100 {
0101     struct device *dev = &pdev->dev;
0102     struct bcm_ns_usb2 *usb2;
0103     struct phy_provider *phy_provider;
0104
0105     usb2 = devm_kzalloc(&pdev->dev, sizeof(*usb2), GFP_KERNEL);
0106     if (!usb2)
0107         return -ENOMEM;
0108     usb2->dev = dev;
0109
0110     if (of_find_property(dev->of_node, "brcm,syscon-clkset", NULL)) {
0111         usb2->base = devm_platform_ioremap_resource(pdev, 0);
0112         if (IS_ERR(usb2->base)) {
0113             dev_err(dev, "Failed to map control reg\n");
0114             return PTR_ERR(usb2->base);
0115         }
0116
0117         usb2->clkset = syscon_regmap_lookup_by_phandle(dev->of_node,
0118                                    "brcm,syscon-clkset");
0119         if (IS_ERR(usb2->clkset)) {
0120             dev_err(dev, "Failed to lookup clkset regmap\n");
0121             return PTR_ERR(usb2->clkset);
0122         }
0123     } else {
0124         usb2->dmu = devm_platform_ioremap_resource_byname(pdev, "dmu");
0125         if (IS_ERR(usb2->dmu)) {
0126             dev_err(dev, "Failed to map DMU regs\n");
0127             return PTR_ERR(usb2->dmu);
0128         }
0129
0130         dev_warn(dev, "using deprecated DT binding\n");
0131     }
0132
0133     usb2->ref_clk = devm_clk_get(dev, "phy-ref-clk");
0134     if (IS_ERR(usb2->ref_clk)) {
0135         dev_err_probe(dev, PTR_ERR(usb2->ref_clk), "failed to get ref clk\n");
0136         return PTR_ERR(usb2->ref_clk);
0137     }
0138
0139     usb2->phy = devm_phy_create(dev, NULL, &ops);
0140     if (IS_ERR(usb2->phy))
0141         return PTR_ERR(usb2->phy);
0142
0143     phy_set_drvdata(usb2->phy, usb2);
0144     platform_set_drvdata(pdev, usb2);
0145
0146     phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate);
0147     return PTR_ERR_OR_ZERO(phy_provider);
0148 }
0149
0150 static const struct of_device_id bcm_ns_usb2_id_table[] = {
0151     { .compatible = "brcm,ns-usb2-phy", },
0152     {},
0153 };
0154 MODULE_DEVICE_TABLE(of, bcm_ns_usb2_id_table);
0155
0156 static struct platform_driver bcm_ns_usb2_driver = {
0157     .probe      = bcm_ns_usb2_probe,
0158     .driver = {
0159         .name = "bcm_ns_usb2",
0160         .of_match_table = bcm_ns_usb2_id_table,
0161     },
0162 };
0163 module_platform_driver(bcm_ns_usb2_driver);
0164
0165 MODULE_LICENSE("GPL v2");