F: Documentation/devicetree/bindings/net/apm-xgene-enet.txt
F: Documentation/devicetree/bindings/net/apm-xgene-mdio.txt
F: drivers/net/ethernet/apm/xgene/
-F: drivers/net/phy/mdio-xgene.c
+F: drivers/net/mdio/mdio-xgene.c
APPLIED MICRO (APM) X-GENE SOC PMU
M: Khuong Dinh <khuong@os.amperecomputing.com>
F: Documentation/devicetree/bindings/net/mdio*
F: Documentation/devicetree/bindings/net/qca,ar803x.yaml
F: Documentation/networking/phy.rst
+F: drivers/net/mdio/
F: drivers/net/pcs/
F: drivers/net/phy/
F: drivers/of/of_mdio.c
F: drivers/of/of_net.c
F: include/dt-bindings/net/qca-ar803x.h
F: include/linux/*mdio*.h
+F: include/linux/mdio/*.h
F: include/linux/of_net.h
F: include/linux/phy.h
F: include/linux/phy_fixed.h
L: netdev@vger.kernel.org
S: Maintained
F: Documentation/devicetree/bindings/net/marvell,mvusb.yaml
-F: drivers/net/phy/mdio-mvusb.c
+F: drivers/net/mdio/mdio-mvusb.c
MARVELL XENON MMC/SD/SDIO HOST CONTROLLER DRIVER
M: Hu Ziji <huziji@marvell.com>
source "drivers/net/phy/Kconfig"
+source "drivers/net/mdio/Kconfig"
+
source "drivers/net/pcs/Kconfig"
source "drivers/net/plip/Kconfig"
obj-$(CONFIG_NET) += Space.o loopback.o
obj-$(CONFIG_NETCONSOLE) += netconsole.o
obj-y += phy/
+obj-y += mdio/
obj-y += pcs/
obj-$(CONFIG_RIONET) += rionet.o
obj-$(CONFIG_NET_TEAM) += team/
--- /dev/null
+# SPDX-License-Identifier: GPL-2.0-only
+#
+# MDIO Layer Configuration
+#
+
+menuconfig MDIO_DEVICE
+ tristate "MDIO bus device drivers"
+ help
+ MDIO devices and driver infrastructure code.
+
+if MDIO_DEVICE
+
+config MDIO_BUS
+ tristate
+ default m if PHYLIB=m
+ default MDIO_DEVICE
+ help
+ This internal symbol is used for link time dependencies and it
+ reflects whether the mdio_bus/mdio_device code is built as a
+ loadable module or built-in.
+
+if MDIO_BUS
+
+config MDIO_DEVRES
+ tristate
+
+config MDIO_SUN4I
+ tristate "Allwinner sun4i MDIO interface support"
+ depends on ARCH_SUNXI || COMPILE_TEST
+ help
+ This driver supports the MDIO interface found in the network
+ interface units of the Allwinner SoC that have an EMAC (A10,
+ A12, A10s, etc.)
+
+config MDIO_XGENE
+ tristate "APM X-Gene SoC MDIO bus controller"
+ depends on ARCH_XGENE || COMPILE_TEST
+ help
+ This module provides a driver for the MDIO busses found in the
+ APM X-Gene SoC's.
+
+config MDIO_ASPEED
+ tristate "ASPEED MDIO bus controller"
+ depends on ARCH_ASPEED || COMPILE_TEST
+ depends on OF_MDIO && HAS_IOMEM
+ help
+ This module provides a driver for the independent MDIO bus
+ controllers found in the ASPEED AST2600 SoC. This is a driver for the
+ third revision of the ASPEED MDIO register interface - the first two
+ revisions are the "old" and "new" interfaces found in the AST2400 and
+ AST2500, embedded in the MAC. For legacy reasons, FTGMAC100 driver
+ continues to drive the embedded MDIO controller for the AST2400 and
+ AST2500 SoCs, so say N if AST2600 support is not required.
+
+config MDIO_BITBANG
+ tristate "Bitbanged MDIO buses"
+ help
+ This module implements the MDIO bus protocol in software,
+ for use by low level drivers that export the ability to
+ drive the relevant pins.
+
+ If in doubt, say N.
+
+config MDIO_BCM_IPROC
+ tristate "Broadcom iProc MDIO bus controller"
+ depends on ARCH_BCM_IPROC || COMPILE_TEST
+ depends on HAS_IOMEM && OF_MDIO
+ default ARCH_BCM_IPROC
+ help
+ This module provides a driver for the MDIO busses found in the
+ Broadcom iProc SoC's.
+
+config MDIO_BCM_UNIMAC
+ tristate "Broadcom UniMAC MDIO bus controller"
+ depends on HAS_IOMEM
+ help
+ This module provides a driver for the Broadcom UniMAC MDIO busses.
+ This hardware can be found in the Broadcom GENET Ethernet MAC
+ controllers as well as some Broadcom Ethernet switches such as the
+ Starfighter 2 switches.
+
+config MDIO_CAVIUM
+ tristate
+
+config MDIO_GPIO
+ tristate "GPIO lib-based bitbanged MDIO buses"
+ depends on MDIO_BITBANG
+ depends on GPIOLIB || COMPILE_TEST
+ help
+ Supports GPIO lib-based MDIO busses.
+
+ To compile this driver as a module, choose M here: the module
+ will be called mdio-gpio.
+
+config MDIO_HISI_FEMAC
+ tristate "Hisilicon FEMAC MDIO bus controller"
+ depends on HAS_IOMEM && OF_MDIO
+ help
+ This module provides a driver for the MDIO busses found in the
+ Hisilicon SoC that have an Fast Ethernet MAC.
+
+config MDIO_I2C
+ tristate
+ depends on I2C
+ help
+ Support I2C based PHYs. This provides a MDIO bus bridged
+ to I2C to allow PHYs connected in I2C mode to be accessed
+ using the existing infrastructure.
+
+ This is library mode.
+
+config MDIO_MVUSB
+ tristate "Marvell USB to MDIO Adapter"
+ depends on USB
+ select MDIO_DEVRES
+ help
+ A USB to MDIO converter present on development boards for
+ Marvell's Link Street family of Ethernet switches.
+
+config MDIO_MSCC_MIIM
+ tristate "Microsemi MIIM interface support"
+ depends on HAS_IOMEM
+ select MDIO_DEVRES
+ help
+ This driver supports the MIIM (MDIO) interface found in the network
+ switches of the Microsemi SoCs; it is recommended to switch on
+ CONFIG_HIGH_RES_TIMERS
+
+config MDIO_MOXART
+ tristate "MOXA ART MDIO interface support"
+ depends on ARCH_MOXART || COMPILE_TEST
+ help
+ This driver supports the MDIO interface found in the network
+ interface units of the MOXA ART SoC
+
+config MDIO_OCTEON
+ tristate "Octeon and some ThunderX SOCs MDIO buses"
+ depends on (64BIT && OF_MDIO) || COMPILE_TEST
+ depends on HAS_IOMEM
+ select MDIO_CAVIUM
+ help
+ This module provides a driver for the Octeon and ThunderX MDIO
+ buses. It is required by the Octeon and ThunderX ethernet device
+ drivers on some systems.
+
+config MDIO_IPQ4019
+ tristate "Qualcomm IPQ4019 MDIO interface support"
+ depends on HAS_IOMEM && OF_MDIO
+ help
+ This driver supports the MDIO interface found in Qualcomm
+ IPQ40xx series Soc-s.
+
+config MDIO_IPQ8064
+ tristate "Qualcomm IPQ8064 MDIO interface support"
+ depends on HAS_IOMEM && OF_MDIO
+ depends on MFD_SYSCON
+ help
+ This driver supports the MDIO interface found in the network
+ interface units of the IPQ8064 SoC
+
+config MDIO_THUNDER
+ tristate "ThunderX SOCs MDIO buses"
+ depends on 64BIT
+ depends on PCI
+ select MDIO_CAVIUM
+ help
+ This driver supports the MDIO interfaces found on Cavium
+ ThunderX SoCs when the MDIO bus device appears as a PCI
+ device.
+
+comment "MDIO Multiplexers"
+
+config MDIO_BUS_MUX
+ tristate
+ depends on OF_MDIO
+ help
+ This module provides a driver framework for MDIO bus
+ multiplexers which connect one of several child MDIO busses
+ to a parent bus. Switching between child busses is done by
+ device specific drivers.
+
+config MDIO_BUS_MUX_MESON_G12A
+ tristate "Amlogic G12a based MDIO bus multiplexer"
+ depends on ARCH_MESON || COMPILE_TEST
+ depends on OF_MDIO && HAS_IOMEM && COMMON_CLK
+ select MDIO_BUS_MUX
+ default m if ARCH_MESON
+ help
+ This module provides a driver for the MDIO multiplexer/glue of
+ the amlogic g12a SoC. The multiplexers connects either the external
+ or the internal MDIO bus to the parent bus.
+
+config MDIO_BUS_MUX_BCM_IPROC
+ tristate "Broadcom iProc based MDIO bus multiplexers"
+ depends on OF && OF_MDIO && (ARCH_BCM_IPROC || COMPILE_TEST)
+ select MDIO_BUS_MUX
+ default ARCH_BCM_IPROC
+ help
+ This module provides a driver for MDIO bus multiplexers found in
+ iProc based Broadcom SoCs. This multiplexer connects one of several
+ child MDIO bus to a parent bus. Buses could be internal as well as
+ external and selection logic lies inside the same multiplexer.
+
+config MDIO_BUS_MUX_GPIO
+ tristate "GPIO controlled MDIO bus multiplexers"
+ depends on OF_GPIO && OF_MDIO
+ select MDIO_BUS_MUX
+ help
+ This module provides a driver for MDIO bus multiplexers that
+ are controlled via GPIO lines. The multiplexer connects one of
+ several child MDIO busses to a parent bus. Child bus
+ selection is under the control of GPIO lines.
+
+config MDIO_BUS_MUX_MULTIPLEXER
+ tristate "MDIO bus multiplexer using kernel multiplexer subsystem"
+ depends on OF_MDIO
+ select MULTIPLEXER
+ select MDIO_BUS_MUX
+ help
+ This module provides a driver for MDIO bus multiplexer
+ that is controlled via the kernel multiplexer subsystem. The
+ bus multiplexer connects one of several child MDIO busses to
+ a parent bus. Child bus selection is under the control of
+ the kernel multiplexer subsystem.
+
+config MDIO_BUS_MUX_MMIOREG
+ tristate "MMIO device-controlled MDIO bus multiplexers"
+ depends on OF_MDIO && HAS_IOMEM
+ select MDIO_BUS_MUX
+ help
+ This module provides a driver for MDIO bus multiplexers that
+ are controlled via a simple memory-mapped device, like an FPGA.
+ The multiplexer connects one of several child MDIO busses to a
+ parent bus. Child bus selection is under the control of one of
+ the FPGA's registers.
+
+ Currently, only 8/16/32 bits registers are supported.
+
+
+endif
+endif
--- /dev/null
+# SPDX-License-Identifier: GPL-2.0
+# Makefile for Linux MDIO bus drivers
+
+obj-$(CONFIG_MDIO_ASPEED) += mdio-aspeed.o
+obj-$(CONFIG_MDIO_BCM_IPROC) += mdio-bcm-iproc.o
+obj-$(CONFIG_MDIO_BCM_UNIMAC) += mdio-bcm-unimac.o
+obj-$(CONFIG_MDIO_BITBANG) += mdio-bitbang.o
+obj-$(CONFIG_MDIO_CAVIUM) += mdio-cavium.o
+obj-$(CONFIG_MDIO_GPIO) += mdio-gpio.o
+obj-$(CONFIG_MDIO_HISI_FEMAC) += mdio-hisi-femac.o
+obj-$(CONFIG_MDIO_I2C) += mdio-i2c.o
+obj-$(CONFIG_MDIO_IPQ4019) += mdio-ipq4019.o
+obj-$(CONFIG_MDIO_IPQ8064) += mdio-ipq8064.o
+obj-$(CONFIG_MDIO_MOXART) += mdio-moxart.o
+obj-$(CONFIG_MDIO_MSCC_MIIM) += mdio-mscc-miim.o
+obj-$(CONFIG_MDIO_MVUSB) += mdio-mvusb.o
+obj-$(CONFIG_MDIO_OCTEON) += mdio-octeon.o
+obj-$(CONFIG_MDIO_SUN4I) += mdio-sun4i.o
+obj-$(CONFIG_MDIO_THUNDER) += mdio-thunder.o
+obj-$(CONFIG_MDIO_XGENE) += mdio-xgene.o
+
+obj-$(CONFIG_MDIO_BUS_MUX) += mdio-mux.o
+obj-$(CONFIG_MDIO_BUS_MUX_BCM_IPROC) += mdio-mux-bcm-iproc.o
+obj-$(CONFIG_MDIO_BUS_MUX_GPIO) += mdio-mux-gpio.o
+obj-$(CONFIG_MDIO_BUS_MUX_MESON_G12A) += mdio-mux-meson-g12a.o
+obj-$(CONFIG_MDIO_BUS_MUX_MMIOREG) += mdio-mux-mmioreg.o
+obj-$(CONFIG_MDIO_BUS_MUX_MULTIPLEXER) += mdio-mux-multiplexer.o
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-or-later
+/* Copyright (C) 2019 IBM Corp. */
+
+#include <linux/bitfield.h>
+#include <linux/delay.h>
+#include <linux/iopoll.h>
+#include <linux/mdio.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_mdio.h>
+#include <linux/phy.h>
+#include <linux/platform_device.h>
+
+#define DRV_NAME "mdio-aspeed"
+
+#define ASPEED_MDIO_CTRL 0x0
+#define ASPEED_MDIO_CTRL_FIRE BIT(31)
+#define ASPEED_MDIO_CTRL_ST BIT(28)
+#define ASPEED_MDIO_CTRL_ST_C45 0
+#define ASPEED_MDIO_CTRL_ST_C22 1
+#define ASPEED_MDIO_CTRL_OP GENMASK(27, 26)
+#define MDIO_C22_OP_WRITE 0b01
+#define MDIO_C22_OP_READ 0b10
+#define ASPEED_MDIO_CTRL_PHYAD GENMASK(25, 21)
+#define ASPEED_MDIO_CTRL_REGAD GENMASK(20, 16)
+#define ASPEED_MDIO_CTRL_MIIWDATA GENMASK(15, 0)
+
+#define ASPEED_MDIO_DATA 0x4
+#define ASPEED_MDIO_DATA_MDC_THRES GENMASK(31, 24)
+#define ASPEED_MDIO_DATA_MDIO_EDGE BIT(23)
+#define ASPEED_MDIO_DATA_MDIO_LATCH GENMASK(22, 20)
+#define ASPEED_MDIO_DATA_IDLE BIT(16)
+#define ASPEED_MDIO_DATA_MIIRDATA GENMASK(15, 0)
+
+#define ASPEED_MDIO_INTERVAL_US 100
+#define ASPEED_MDIO_TIMEOUT_US (ASPEED_MDIO_INTERVAL_US * 10)
+
+struct aspeed_mdio {
+ void __iomem *base;
+};
+
+static int aspeed_mdio_read(struct mii_bus *bus, int addr, int regnum)
+{
+ struct aspeed_mdio *ctx = bus->priv;
+ u32 ctrl;
+ u32 data;
+ int rc;
+
+ dev_dbg(&bus->dev, "%s: addr: %d, regnum: %d\n", __func__, addr,
+ regnum);
+
+ /* Just clause 22 for the moment */
+ if (regnum & MII_ADDR_C45)
+ return -EOPNOTSUPP;
+
+ ctrl = ASPEED_MDIO_CTRL_FIRE
+ | FIELD_PREP(ASPEED_MDIO_CTRL_ST, ASPEED_MDIO_CTRL_ST_C22)
+ | FIELD_PREP(ASPEED_MDIO_CTRL_OP, MDIO_C22_OP_READ)
+ | FIELD_PREP(ASPEED_MDIO_CTRL_PHYAD, addr)
+ | FIELD_PREP(ASPEED_MDIO_CTRL_REGAD, regnum);
+
+ iowrite32(ctrl, ctx->base + ASPEED_MDIO_CTRL);
+
+ rc = readl_poll_timeout(ctx->base + ASPEED_MDIO_DATA, data,
+ data & ASPEED_MDIO_DATA_IDLE,
+ ASPEED_MDIO_INTERVAL_US,
+ ASPEED_MDIO_TIMEOUT_US);
+ if (rc < 0)
+ return rc;
+
+ return FIELD_GET(ASPEED_MDIO_DATA_MIIRDATA, data);
+}
+
+static int aspeed_mdio_write(struct mii_bus *bus, int addr, int regnum, u16 val)
+{
+ struct aspeed_mdio *ctx = bus->priv;
+ u32 ctrl;
+
+ dev_dbg(&bus->dev, "%s: addr: %d, regnum: %d, val: 0x%x\n",
+ __func__, addr, regnum, val);
+
+ /* Just clause 22 for the moment */
+ if (regnum & MII_ADDR_C45)
+ return -EOPNOTSUPP;
+
+ ctrl = ASPEED_MDIO_CTRL_FIRE
+ | FIELD_PREP(ASPEED_MDIO_CTRL_ST, ASPEED_MDIO_CTRL_ST_C22)
+ | FIELD_PREP(ASPEED_MDIO_CTRL_OP, MDIO_C22_OP_WRITE)
+ | FIELD_PREP(ASPEED_MDIO_CTRL_PHYAD, addr)
+ | FIELD_PREP(ASPEED_MDIO_CTRL_REGAD, regnum)
+ | FIELD_PREP(ASPEED_MDIO_CTRL_MIIWDATA, val);
+
+ iowrite32(ctrl, ctx->base + ASPEED_MDIO_CTRL);
+
+ return readl_poll_timeout(ctx->base + ASPEED_MDIO_CTRL, ctrl,
+ !(ctrl & ASPEED_MDIO_CTRL_FIRE),
+ ASPEED_MDIO_INTERVAL_US,
+ ASPEED_MDIO_TIMEOUT_US);
+}
+
+static int aspeed_mdio_probe(struct platform_device *pdev)
+{
+ struct aspeed_mdio *ctx;
+ struct mii_bus *bus;
+ int rc;
+
+ bus = devm_mdiobus_alloc_size(&pdev->dev, sizeof(*ctx));
+ if (!bus)
+ return -ENOMEM;
+
+ ctx = bus->priv;
+ ctx->base = devm_platform_ioremap_resource(pdev, 0);
+ if (IS_ERR(ctx->base))
+ return PTR_ERR(ctx->base);
+
+ bus->name = DRV_NAME;
+ snprintf(bus->id, MII_BUS_ID_SIZE, "%s%d", pdev->name, pdev->id);
+ bus->parent = &pdev->dev;
+ bus->read = aspeed_mdio_read;
+ bus->write = aspeed_mdio_write;
+
+ rc = of_mdiobus_register(bus, pdev->dev.of_node);
+ if (rc) {
+ dev_err(&pdev->dev, "Cannot register MDIO bus!\n");
+ return rc;
+ }
+
+ platform_set_drvdata(pdev, bus);
+
+ return 0;
+}
+
+static int aspeed_mdio_remove(struct platform_device *pdev)
+{
+ mdiobus_unregister(platform_get_drvdata(pdev));
+
+ return 0;
+}
+
+static const struct of_device_id aspeed_mdio_of_match[] = {
+ { .compatible = "aspeed,ast2600-mdio", },
+ { },
+};
+
+static struct platform_driver aspeed_mdio_driver = {
+ .driver = {
+ .name = DRV_NAME,
+ .of_match_table = aspeed_mdio_of_match,
+ },
+ .probe = aspeed_mdio_probe,
+ .remove = aspeed_mdio_remove,
+};
+
+module_platform_driver(aspeed_mdio_driver);
+
+MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
+MODULE_LICENSE("GPL");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2015 Broadcom Corporation
+ */
+
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/of_mdio.h>
+#include <linux/phy.h>
+#include <linux/platform_device.h>
+#include <linux/sched.h>
+
+#define IPROC_GPHY_MDCDIV 0x1a
+
+#define MII_CTRL_OFFSET 0x000
+
+#define MII_CTRL_DIV_SHIFT 0
+#define MII_CTRL_PRE_SHIFT 7
+#define MII_CTRL_BUSY_SHIFT 8
+
+#define MII_DATA_OFFSET 0x004
+#define MII_DATA_MASK 0xffff
+#define MII_DATA_TA_SHIFT 16
+#define MII_DATA_TA_VAL 2
+#define MII_DATA_RA_SHIFT 18
+#define MII_DATA_PA_SHIFT 23
+#define MII_DATA_OP_SHIFT 28
+#define MII_DATA_OP_WRITE 1
+#define MII_DATA_OP_READ 2
+#define MII_DATA_SB_SHIFT 30
+
+struct iproc_mdio_priv {
+ struct mii_bus *mii_bus;
+ void __iomem *base;
+};
+
+static inline int iproc_mdio_wait_for_idle(void __iomem *base)
+{
+ u32 val;
+ unsigned int timeout = 1000; /* loop for 1s */
+
+ do {
+ val = readl(base + MII_CTRL_OFFSET);
+ if ((val & BIT(MII_CTRL_BUSY_SHIFT)) == 0)
+ return 0;
+
+ usleep_range(1000, 2000);
+ } while (timeout--);
+
+ return -ETIMEDOUT;
+}
+
+static inline void iproc_mdio_config_clk(void __iomem *base)
+{
+ u32 val;
+
+ val = (IPROC_GPHY_MDCDIV << MII_CTRL_DIV_SHIFT) |
+ BIT(MII_CTRL_PRE_SHIFT);
+ writel(val, base + MII_CTRL_OFFSET);
+}
+
+static int iproc_mdio_read(struct mii_bus *bus, int phy_id, int reg)
+{
+ struct iproc_mdio_priv *priv = bus->priv;
+ u32 cmd;
+ int rc;
+
+ rc = iproc_mdio_wait_for_idle(priv->base);
+ if (rc)
+ return rc;
+
+ /* Prepare the read operation */
+ cmd = (MII_DATA_TA_VAL << MII_DATA_TA_SHIFT) |
+ (reg << MII_DATA_RA_SHIFT) |
+ (phy_id << MII_DATA_PA_SHIFT) |
+ BIT(MII_DATA_SB_SHIFT) |
+ (MII_DATA_OP_READ << MII_DATA_OP_SHIFT);
+
+ writel(cmd, priv->base + MII_DATA_OFFSET);
+
+ rc = iproc_mdio_wait_for_idle(priv->base);
+ if (rc)
+ return rc;
+
+ cmd = readl(priv->base + MII_DATA_OFFSET) & MII_DATA_MASK;
+
+ return cmd;
+}
+
+static int iproc_mdio_write(struct mii_bus *bus, int phy_id,
+ int reg, u16 val)
+{
+ struct iproc_mdio_priv *priv = bus->priv;
+ u32 cmd;
+ int rc;
+
+ rc = iproc_mdio_wait_for_idle(priv->base);
+ if (rc)
+ return rc;
+
+ /* Prepare the write operation */
+ cmd = (MII_DATA_TA_VAL << MII_DATA_TA_SHIFT) |
+ (reg << MII_DATA_RA_SHIFT) |
+ (phy_id << MII_DATA_PA_SHIFT) |
+ BIT(MII_DATA_SB_SHIFT) |
+ (MII_DATA_OP_WRITE << MII_DATA_OP_SHIFT) |
+ ((u32)(val) & MII_DATA_MASK);
+
+ writel(cmd, priv->base + MII_DATA_OFFSET);
+
+ rc = iproc_mdio_wait_for_idle(priv->base);
+ if (rc)
+ return rc;
+
+ return 0;
+}
+
+static int iproc_mdio_probe(struct platform_device *pdev)
+{
+ struct iproc_mdio_priv *priv;
+ struct mii_bus *bus;
+ int rc;
+
+ priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ priv->base = devm_platform_ioremap_resource(pdev, 0);
+ if (IS_ERR(priv->base)) {
+ dev_err(&pdev->dev, "failed to ioremap register\n");
+ return PTR_ERR(priv->base);
+ }
+
+ priv->mii_bus = mdiobus_alloc();
+ if (!priv->mii_bus) {
+ dev_err(&pdev->dev, "MDIO bus alloc failed\n");
+ return -ENOMEM;
+ }
+
+ bus = priv->mii_bus;
+ bus->priv = priv;
+ bus->name = "iProc MDIO bus";
+ snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d", pdev->name, pdev->id);
+ bus->parent = &pdev->dev;
+ bus->read = iproc_mdio_read;
+ bus->write = iproc_mdio_write;
+
+ iproc_mdio_config_clk(priv->base);
+
+ rc = of_mdiobus_register(bus, pdev->dev.of_node);
+ if (rc) {
+ dev_err(&pdev->dev, "MDIO bus registration failed\n");
+ goto err_iproc_mdio;
+ }
+
+ platform_set_drvdata(pdev, priv);
+
+ dev_info(&pdev->dev, "Broadcom iProc MDIO bus registered\n");
+
+ return 0;
+
+err_iproc_mdio:
+ mdiobus_free(bus);
+ return rc;
+}
+
+static int iproc_mdio_remove(struct platform_device *pdev)
+{
+ struct iproc_mdio_priv *priv = platform_get_drvdata(pdev);
+
+ mdiobus_unregister(priv->mii_bus);
+ mdiobus_free(priv->mii_bus);
+
+ return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int iproc_mdio_resume(struct device *dev)
+{
+ struct platform_device *pdev = to_platform_device(dev);
+ struct iproc_mdio_priv *priv = platform_get_drvdata(pdev);
+
+ /* restore the mii clock configuration */
+ iproc_mdio_config_clk(priv->base);
+
+ return 0;
+}
+
+static const struct dev_pm_ops iproc_mdio_pm_ops = {
+ .resume = iproc_mdio_resume
+};
+#endif /* CONFIG_PM_SLEEP */
+
+static const struct of_device_id iproc_mdio_of_match[] = {
+ { .compatible = "brcm,iproc-mdio", },
+ { /* sentinel */ },
+};
+MODULE_DEVICE_TABLE(of, iproc_mdio_of_match);
+
+static struct platform_driver iproc_mdio_driver = {
+ .driver = {
+ .name = "iproc-mdio",
+ .of_match_table = iproc_mdio_of_match,
+#ifdef CONFIG_PM_SLEEP
+ .pm = &iproc_mdio_pm_ops,
+#endif
+ },
+ .probe = iproc_mdio_probe,
+ .remove = iproc_mdio_remove,
+};
+
+module_platform_driver(iproc_mdio_driver);
+
+MODULE_AUTHOR("Broadcom Corporation");
+MODULE_DESCRIPTION("Broadcom iProc MDIO bus controller");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:iproc-mdio");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Broadcom UniMAC MDIO bus controller driver
+ *
+ * Copyright (C) 2014-2017 Broadcom
+ */
+
+#include <linux/kernel.h>
+#include <linux/phy.h>
+#include <linux/platform_device.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/delay.h>
+#include <linux/clk.h>
+
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/of_mdio.h>
+
+#include <linux/platform_data/mdio-bcm-unimac.h>
+
+#define MDIO_CMD 0x00
+#define MDIO_START_BUSY (1 << 29)
+#define MDIO_READ_FAIL (1 << 28)
+#define MDIO_RD (2 << 26)
+#define MDIO_WR (1 << 26)
+#define MDIO_PMD_SHIFT 21
+#define MDIO_PMD_MASK 0x1F
+#define MDIO_REG_SHIFT 16
+#define MDIO_REG_MASK 0x1F
+
+#define MDIO_CFG 0x04
+#define MDIO_C22 (1 << 0)
+#define MDIO_C45 0
+#define MDIO_CLK_DIV_SHIFT 4
+#define MDIO_CLK_DIV_MASK 0x3F
+#define MDIO_SUPP_PREAMBLE (1 << 12)
+
+struct unimac_mdio_priv {
+ struct mii_bus *mii_bus;
+ void __iomem *base;
+ int (*wait_func) (void *wait_func_data);
+ void *wait_func_data;
+ struct clk *clk;
+ u32 clk_freq;
+};
+
+static inline u32 unimac_mdio_readl(struct unimac_mdio_priv *priv, u32 offset)
+{
+ /* MIPS chips strapped for BE will automagically configure the
+ * peripheral registers for CPU-native byte order.
+ */
+ if (IS_ENABLED(CONFIG_MIPS) && IS_ENABLED(CONFIG_CPU_BIG_ENDIAN))
+ return __raw_readl(priv->base + offset);
+ else
+ return readl_relaxed(priv->base + offset);
+}
+
+static inline void unimac_mdio_writel(struct unimac_mdio_priv *priv, u32 val,
+ u32 offset)
+{
+ if (IS_ENABLED(CONFIG_MIPS) && IS_ENABLED(CONFIG_CPU_BIG_ENDIAN))
+ __raw_writel(val, priv->base + offset);
+ else
+ writel_relaxed(val, priv->base + offset);
+}
+
+static inline void unimac_mdio_start(struct unimac_mdio_priv *priv)
+{
+ u32 reg;
+
+ reg = unimac_mdio_readl(priv, MDIO_CMD);
+ reg |= MDIO_START_BUSY;
+ unimac_mdio_writel(priv, reg, MDIO_CMD);
+}
+
+static inline unsigned int unimac_mdio_busy(struct unimac_mdio_priv *priv)
+{
+ return unimac_mdio_readl(priv, MDIO_CMD) & MDIO_START_BUSY;
+}
+
+static int unimac_mdio_poll(void *wait_func_data)
+{
+ struct unimac_mdio_priv *priv = wait_func_data;
+ unsigned int timeout = 1000;
+
+ do {
+ if (!unimac_mdio_busy(priv))
+ return 0;
+
+ usleep_range(1000, 2000);
+ } while (--timeout);
+
+ return -ETIMEDOUT;
+}
+
+static int unimac_mdio_read(struct mii_bus *bus, int phy_id, int reg)
+{
+ struct unimac_mdio_priv *priv = bus->priv;
+ int ret;
+ u32 cmd;
+
+ /* Prepare the read operation */
+ cmd = MDIO_RD | (phy_id << MDIO_PMD_SHIFT) | (reg << MDIO_REG_SHIFT);
+ unimac_mdio_writel(priv, cmd, MDIO_CMD);
+
+ /* Start MDIO transaction */
+ unimac_mdio_start(priv);
+
+ ret = priv->wait_func(priv->wait_func_data);
+ if (ret)
+ return ret;
+
+ cmd = unimac_mdio_readl(priv, MDIO_CMD);
+
+ /* Some broken devices are known not to release the line during
+ * turn-around, e.g: Broadcom BCM53125 external switches, so check for
+ * that condition here and ignore the MDIO controller read failure
+ * indication.
+ */
+ if (!(bus->phy_ignore_ta_mask & 1 << phy_id) && (cmd & MDIO_READ_FAIL))
+ return -EIO;
+
+ return cmd & 0xffff;
+}
+
+static int unimac_mdio_write(struct mii_bus *bus, int phy_id,
+ int reg, u16 val)
+{
+ struct unimac_mdio_priv *priv = bus->priv;
+ u32 cmd;
+
+ /* Prepare the write operation */
+ cmd = MDIO_WR | (phy_id << MDIO_PMD_SHIFT) |
+ (reg << MDIO_REG_SHIFT) | (0xffff & val);
+ unimac_mdio_writel(priv, cmd, MDIO_CMD);
+
+ unimac_mdio_start(priv);
+
+ return priv->wait_func(priv->wait_func_data);
+}
+
+/* Workaround for integrated BCM7xxx Gigabit PHYs which have a problem with
+ * their internal MDIO management controller making them fail to successfully
+ * be read from or written to for the first transaction. We insert a dummy
+ * BMSR read here to make sure that phy_get_device() and get_phy_id() can
+ * correctly read the PHY MII_PHYSID1/2 registers and successfully register a
+ * PHY device for this peripheral.
+ *
+ * Once the PHY driver is registered, we can workaround subsequent reads from
+ * there (e.g: during system-wide power management).
+ *
+ * bus->reset is invoked before mdiobus_scan during mdiobus_register and is
+ * therefore the right location to stick that workaround. Since we do not want
+ * to read from non-existing PHYs, we either use bus->phy_mask or do a manual
+ * Device Tree scan to limit the search area.
+ */
+static int unimac_mdio_reset(struct mii_bus *bus)
+{
+ struct device_node *np = bus->dev.of_node;
+ struct device_node *child;
+ u32 read_mask = 0;
+ int addr;
+
+ if (!np) {
+ read_mask = ~bus->phy_mask;
+ } else {
+ for_each_available_child_of_node(np, child) {
+ addr = of_mdio_parse_addr(&bus->dev, child);
+ if (addr < 0)
+ continue;
+
+ read_mask |= 1 << addr;
+ }
+ }
+
+ for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
+ if (read_mask & 1 << addr) {
+ dev_dbg(&bus->dev, "Workaround for PHY @ %d\n", addr);
+ mdiobus_read(bus, addr, MII_BMSR);
+ }
+ }
+
+ return 0;
+}
+
+static void unimac_mdio_clk_set(struct unimac_mdio_priv *priv)
+{
+ unsigned long rate;
+ u32 reg, div;
+
+ /* Keep the hardware default values */
+ if (!priv->clk_freq)
+ return;
+
+ if (!priv->clk)
+ rate = 250000000;
+ else
+ rate = clk_get_rate(priv->clk);
+
+ div = (rate / (2 * priv->clk_freq)) - 1;
+ if (div & ~MDIO_CLK_DIV_MASK) {
+ pr_warn("Incorrect MDIO clock frequency, ignoring\n");
+ return;
+ }
+
+ /* The MDIO clock is the reference clock (typicaly 250Mhz) divided by
+ * 2 x (MDIO_CLK_DIV + 1)
+ */
+ reg = unimac_mdio_readl(priv, MDIO_CFG);
+ reg &= ~(MDIO_CLK_DIV_MASK << MDIO_CLK_DIV_SHIFT);
+ reg |= div << MDIO_CLK_DIV_SHIFT;
+ unimac_mdio_writel(priv, reg, MDIO_CFG);
+}
+
+static int unimac_mdio_probe(struct platform_device *pdev)
+{
+ struct unimac_mdio_pdata *pdata = pdev->dev.platform_data;
+ struct unimac_mdio_priv *priv;
+ struct device_node *np;
+ struct mii_bus *bus;
+ struct resource *r;
+ int ret;
+
+ np = pdev->dev.of_node;
+
+ priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (!r)
+ return -EINVAL;
+
+ /* Just ioremap, as this MDIO block is usually integrated into an
+ * Ethernet MAC controller register range
+ */
+ priv->base = devm_ioremap(&pdev->dev, r->start, resource_size(r));
+ if (!priv->base) {
+ dev_err(&pdev->dev, "failed to remap register\n");
+ return -ENOMEM;
+ }
+
+ priv->clk = devm_clk_get_optional(&pdev->dev, NULL);
+ if (IS_ERR(priv->clk))
+ return PTR_ERR(priv->clk);
+
+ ret = clk_prepare_enable(priv->clk);
+ if (ret)
+ return ret;
+
+ if (of_property_read_u32(np, "clock-frequency", &priv->clk_freq))
+ priv->clk_freq = 0;
+
+ unimac_mdio_clk_set(priv);
+
+ priv->mii_bus = mdiobus_alloc();
+ if (!priv->mii_bus) {
+ ret = -ENOMEM;
+ goto out_clk_disable;
+ }
+
+ bus = priv->mii_bus;
+ bus->priv = priv;
+ if (pdata) {
+ bus->name = pdata->bus_name;
+ priv->wait_func = pdata->wait_func;
+ priv->wait_func_data = pdata->wait_func_data;
+ bus->phy_mask = ~pdata->phy_mask;
+ } else {
+ bus->name = "unimac MII bus";
+ priv->wait_func_data = priv;
+ priv->wait_func = unimac_mdio_poll;
+ }
+ bus->parent = &pdev->dev;
+ bus->read = unimac_mdio_read;
+ bus->write = unimac_mdio_write;
+ bus->reset = unimac_mdio_reset;
+ snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d", pdev->name, pdev->id);
+
+ ret = of_mdiobus_register(bus, np);
+ if (ret) {
+ dev_err(&pdev->dev, "MDIO bus registration failed\n");
+ goto out_mdio_free;
+ }
+
+ platform_set_drvdata(pdev, priv);
+
+ dev_info(&pdev->dev, "Broadcom UniMAC MDIO bus\n");
+
+ return 0;
+
+out_mdio_free:
+ mdiobus_free(bus);
+out_clk_disable:
+ clk_disable_unprepare(priv->clk);
+ return ret;
+}
+
+static int unimac_mdio_remove(struct platform_device *pdev)
+{
+ struct unimac_mdio_priv *priv = platform_get_drvdata(pdev);
+
+ mdiobus_unregister(priv->mii_bus);
+ mdiobus_free(priv->mii_bus);
+ clk_disable_unprepare(priv->clk);
+
+ return 0;
+}
+
+static int __maybe_unused unimac_mdio_suspend(struct device *d)
+{
+ struct unimac_mdio_priv *priv = dev_get_drvdata(d);
+
+ clk_disable_unprepare(priv->clk);
+
+ return 0;
+}
+
+static int __maybe_unused unimac_mdio_resume(struct device *d)
+{
+ struct unimac_mdio_priv *priv = dev_get_drvdata(d);
+ int ret;
+
+ ret = clk_prepare_enable(priv->clk);
+ if (ret)
+ return ret;
+
+ unimac_mdio_clk_set(priv);
+
+ return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(unimac_mdio_pm_ops,
+ unimac_mdio_suspend, unimac_mdio_resume);
+
+static const struct of_device_id unimac_mdio_ids[] = {
+ { .compatible = "brcm,genet-mdio-v5", },
+ { .compatible = "brcm,genet-mdio-v4", },
+ { .compatible = "brcm,genet-mdio-v3", },
+ { .compatible = "brcm,genet-mdio-v2", },
+ { .compatible = "brcm,genet-mdio-v1", },
+ { .compatible = "brcm,unimac-mdio", },
+ { /* sentinel */ },
+};
+MODULE_DEVICE_TABLE(of, unimac_mdio_ids);
+
+static struct platform_driver unimac_mdio_driver = {
+ .driver = {
+ .name = UNIMAC_MDIO_DRV_NAME,
+ .of_match_table = unimac_mdio_ids,
+ .pm = &unimac_mdio_pm_ops,
+ },
+ .probe = unimac_mdio_probe,
+ .remove = unimac_mdio_remove,
+};
+module_platform_driver(unimac_mdio_driver);
+
+MODULE_AUTHOR("Broadcom Corporation");
+MODULE_DESCRIPTION("Broadcom UniMAC MDIO bus controller");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" UNIMAC_MDIO_DRV_NAME);
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Bitbanged MDIO support.
+ *
+ * Author: Scott Wood <scottwood@freescale.com>
+ * Copyright (c) 2007 Freescale Semiconductor
+ *
+ * Based on CPM2 MDIO code which is:
+ *
+ * Copyright (c) 2003 Intracom S.A.
+ * by Pantelis Antoniou <panto@intracom.gr>
+ *
+ * 2005 (c) MontaVista Software, Inc.
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ */
+
+#include <linux/module.h>
+#include <linux/mdio-bitbang.h>
+#include <linux/types.h>
+#include <linux/delay.h>
+
+#define MDIO_READ 2
+#define MDIO_WRITE 1
+
+#define MDIO_C45 (1<<15)
+#define MDIO_C45_ADDR (MDIO_C45 | 0)
+#define MDIO_C45_READ (MDIO_C45 | 3)
+#define MDIO_C45_WRITE (MDIO_C45 | 1)
+
+#define MDIO_SETUP_TIME 10
+#define MDIO_HOLD_TIME 10
+
+/* Minimum MDC period is 400 ns, plus some margin for error. MDIO_DELAY
+ * is done twice per period.
+ */
+#define MDIO_DELAY 250
+
+/* The PHY may take up to 300 ns to produce data, plus some margin
+ * for error.
+ */
+#define MDIO_READ_DELAY 350
+
+/* MDIO must already be configured as output. */
+static void mdiobb_send_bit(struct mdiobb_ctrl *ctrl, int val)
+{
+ const struct mdiobb_ops *ops = ctrl->ops;
+
+ ops->set_mdio_data(ctrl, val);
+ ndelay(MDIO_DELAY);
+ ops->set_mdc(ctrl, 1);
+ ndelay(MDIO_DELAY);
+ ops->set_mdc(ctrl, 0);
+}
+
+/* MDIO must already be configured as input. */
+static int mdiobb_get_bit(struct mdiobb_ctrl *ctrl)
+{
+ const struct mdiobb_ops *ops = ctrl->ops;
+
+ ndelay(MDIO_DELAY);
+ ops->set_mdc(ctrl, 1);
+ ndelay(MDIO_READ_DELAY);
+ ops->set_mdc(ctrl, 0);
+
+ return ops->get_mdio_data(ctrl);
+}
+
+/* MDIO must already be configured as output. */
+static void mdiobb_send_num(struct mdiobb_ctrl *ctrl, u16 val, int bits)
+{
+ int i;
+
+ for (i = bits - 1; i >= 0; i--)
+ mdiobb_send_bit(ctrl, (val >> i) & 1);
+}
+
+/* MDIO must already be configured as input. */
+static u16 mdiobb_get_num(struct mdiobb_ctrl *ctrl, int bits)
+{
+ int i;
+ u16 ret = 0;
+
+ for (i = bits - 1; i >= 0; i--) {
+ ret <<= 1;
+ ret |= mdiobb_get_bit(ctrl);
+ }
+
+ return ret;
+}
+
+/* Utility to send the preamble, address, and
+ * register (common to read and write).
+ */
+static void mdiobb_cmd(struct mdiobb_ctrl *ctrl, int op, u8 phy, u8 reg)
+{
+ const struct mdiobb_ops *ops = ctrl->ops;
+ int i;
+
+ ops->set_mdio_dir(ctrl, 1);
+
+ /*
+ * Send a 32 bit preamble ('1's) with an extra '1' bit for good
+ * measure. The IEEE spec says this is a PHY optional
+ * requirement. The AMD 79C874 requires one after power up and
+ * one after a MII communications error. This means that we are
+ * doing more preambles than we need, but it is safer and will be
+ * much more robust.
+ */
+
+ for (i = 0; i < 32; i++)
+ mdiobb_send_bit(ctrl, 1);
+
+ /* send the start bit (01) and the read opcode (10) or write (01).
+ Clause 45 operation uses 00 for the start and 11, 10 for
+ read/write */
+ mdiobb_send_bit(ctrl, 0);
+ if (op & MDIO_C45)
+ mdiobb_send_bit(ctrl, 0);
+ else
+ mdiobb_send_bit(ctrl, 1);
+ mdiobb_send_bit(ctrl, (op >> 1) & 1);
+ mdiobb_send_bit(ctrl, (op >> 0) & 1);
+
+ mdiobb_send_num(ctrl, phy, 5);
+ mdiobb_send_num(ctrl, reg, 5);
+}
+
+/* In clause 45 mode all commands are prefixed by MDIO_ADDR to specify the
+ lower 16 bits of the 21 bit address. This transfer is done identically to a
+ MDIO_WRITE except for a different code. To enable clause 45 mode or
+ MII_ADDR_C45 into the address. Theoretically clause 45 and normal devices
+ can exist on the same bus. Normal devices should ignore the MDIO_ADDR
+ phase. */
+static int mdiobb_cmd_addr(struct mdiobb_ctrl *ctrl, int phy, u32 addr)
+{
+ unsigned int dev_addr = (addr >> 16) & 0x1F;
+ unsigned int reg = addr & 0xFFFF;
+ mdiobb_cmd(ctrl, MDIO_C45_ADDR, phy, dev_addr);
+
+ /* send the turnaround (10) */
+ mdiobb_send_bit(ctrl, 1);
+ mdiobb_send_bit(ctrl, 0);
+
+ mdiobb_send_num(ctrl, reg, 16);
+
+ ctrl->ops->set_mdio_dir(ctrl, 0);
+ mdiobb_get_bit(ctrl);
+
+ return dev_addr;
+}
+
+static int mdiobb_read(struct mii_bus *bus, int phy, int reg)
+{
+ struct mdiobb_ctrl *ctrl = bus->priv;
+ int ret, i;
+
+ if (reg & MII_ADDR_C45) {
+ reg = mdiobb_cmd_addr(ctrl, phy, reg);
+ mdiobb_cmd(ctrl, MDIO_C45_READ, phy, reg);
+ } else
+ mdiobb_cmd(ctrl, MDIO_READ, phy, reg);
+
+ ctrl->ops->set_mdio_dir(ctrl, 0);
+
+ /* check the turnaround bit: the PHY should be driving it to zero, if this
+ * PHY is listed in phy_ignore_ta_mask as having broken TA, skip that
+ */
+ if (mdiobb_get_bit(ctrl) != 0 &&
+ !(bus->phy_ignore_ta_mask & (1 << phy))) {
+ /* PHY didn't drive TA low -- flush any bits it
+ * may be trying to send.
+ */
+ for (i = 0; i < 32; i++)
+ mdiobb_get_bit(ctrl);
+
+ return 0xffff;
+ }
+
+ ret = mdiobb_get_num(ctrl, 16);
+ mdiobb_get_bit(ctrl);
+ return ret;
+}
+
+static int mdiobb_write(struct mii_bus *bus, int phy, int reg, u16 val)
+{
+ struct mdiobb_ctrl *ctrl = bus->priv;
+
+ if (reg & MII_ADDR_C45) {
+ reg = mdiobb_cmd_addr(ctrl, phy, reg);
+ mdiobb_cmd(ctrl, MDIO_C45_WRITE, phy, reg);
+ } else
+ mdiobb_cmd(ctrl, MDIO_WRITE, phy, reg);
+
+ /* send the turnaround (10) */
+ mdiobb_send_bit(ctrl, 1);
+ mdiobb_send_bit(ctrl, 0);
+
+ mdiobb_send_num(ctrl, val, 16);
+
+ ctrl->ops->set_mdio_dir(ctrl, 0);
+ mdiobb_get_bit(ctrl);
+ return 0;
+}
+
+struct mii_bus *alloc_mdio_bitbang(struct mdiobb_ctrl *ctrl)
+{
+ struct mii_bus *bus;
+
+ bus = mdiobus_alloc();
+ if (!bus)
+ return NULL;
+
+ __module_get(ctrl->ops->owner);
+
+ bus->read = mdiobb_read;
+ bus->write = mdiobb_write;
+ bus->priv = ctrl;
+
+ return bus;
+}
+EXPORT_SYMBOL(alloc_mdio_bitbang);
+
+void free_mdio_bitbang(struct mii_bus *bus)
+{
+ struct mdiobb_ctrl *ctrl = bus->priv;
+
+ module_put(ctrl->ops->owner);
+ mdiobus_free(bus);
+}
+EXPORT_SYMBOL(free_mdio_bitbang);
+
+MODULE_LICENSE("GPL v2");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2009-2016 Cavium, Inc.
+ */
+
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <linux/phy.h>
+#include <linux/io.h>
+
+#include "mdio-cavium.h"
+
+static void cavium_mdiobus_set_mode(struct cavium_mdiobus *p,
+ enum cavium_mdiobus_mode m)
+{
+ union cvmx_smix_clk smi_clk;
+
+ if (m == p->mode)
+ return;
+
+ smi_clk.u64 = oct_mdio_readq(p->register_base + SMI_CLK);
+ smi_clk.s.mode = (m == C45) ? 1 : 0;
+ smi_clk.s.preamble = 1;
+ oct_mdio_writeq(smi_clk.u64, p->register_base + SMI_CLK);
+ p->mode = m;
+}
+
+static int cavium_mdiobus_c45_addr(struct cavium_mdiobus *p,
+ int phy_id, int regnum)
+{
+ union cvmx_smix_cmd smi_cmd;
+ union cvmx_smix_wr_dat smi_wr;
+ int timeout = 1000;
+
+ cavium_mdiobus_set_mode(p, C45);
+
+ smi_wr.u64 = 0;
+ smi_wr.s.dat = regnum & 0xffff;
+ oct_mdio_writeq(smi_wr.u64, p->register_base + SMI_WR_DAT);
+
+ regnum = (regnum >> 16) & 0x1f;
+
+ smi_cmd.u64 = 0;
+ smi_cmd.s.phy_op = 0; /* MDIO_CLAUSE_45_ADDRESS */
+ smi_cmd.s.phy_adr = phy_id;
+ smi_cmd.s.reg_adr = regnum;
+ oct_mdio_writeq(smi_cmd.u64, p->register_base + SMI_CMD);
+
+ do {
+ /* Wait 1000 clocks so we don't saturate the RSL bus
+ * doing reads.
+ */
+ __delay(1000);
+ smi_wr.u64 = oct_mdio_readq(p->register_base + SMI_WR_DAT);
+ } while (smi_wr.s.pending && --timeout);
+
+ if (timeout <= 0)
+ return -EIO;
+ return 0;
+}
+
+int cavium_mdiobus_read(struct mii_bus *bus, int phy_id, int regnum)
+{
+ struct cavium_mdiobus *p = bus->priv;
+ union cvmx_smix_cmd smi_cmd;
+ union cvmx_smix_rd_dat smi_rd;
+ unsigned int op = 1; /* MDIO_CLAUSE_22_READ */
+ int timeout = 1000;
+
+ if (regnum & MII_ADDR_C45) {
+ int r = cavium_mdiobus_c45_addr(p, phy_id, regnum);
+
+ if (r < 0)
+ return r;
+
+ regnum = (regnum >> 16) & 0x1f;
+ op = 3; /* MDIO_CLAUSE_45_READ */
+ } else {
+ cavium_mdiobus_set_mode(p, C22);
+ }
+
+ smi_cmd.u64 = 0;
+ smi_cmd.s.phy_op = op;
+ smi_cmd.s.phy_adr = phy_id;
+ smi_cmd.s.reg_adr = regnum;
+ oct_mdio_writeq(smi_cmd.u64, p->register_base + SMI_CMD);
+
+ do {
+ /* Wait 1000 clocks so we don't saturate the RSL bus
+ * doing reads.
+ */
+ __delay(1000);
+ smi_rd.u64 = oct_mdio_readq(p->register_base + SMI_RD_DAT);
+ } while (smi_rd.s.pending && --timeout);
+
+ if (smi_rd.s.val)
+ return smi_rd.s.dat;
+ else
+ return -EIO;
+}
+EXPORT_SYMBOL(cavium_mdiobus_read);
+
+int cavium_mdiobus_write(struct mii_bus *bus, int phy_id, int regnum, u16 val)
+{
+ struct cavium_mdiobus *p = bus->priv;
+ union cvmx_smix_cmd smi_cmd;
+ union cvmx_smix_wr_dat smi_wr;
+ unsigned int op = 0; /* MDIO_CLAUSE_22_WRITE */
+ int timeout = 1000;
+
+ if (regnum & MII_ADDR_C45) {
+ int r = cavium_mdiobus_c45_addr(p, phy_id, regnum);
+
+ if (r < 0)
+ return r;
+
+ regnum = (regnum >> 16) & 0x1f;
+ op = 1; /* MDIO_CLAUSE_45_WRITE */
+ } else {
+ cavium_mdiobus_set_mode(p, C22);
+ }
+
+ smi_wr.u64 = 0;
+ smi_wr.s.dat = val;
+ oct_mdio_writeq(smi_wr.u64, p->register_base + SMI_WR_DAT);
+
+ smi_cmd.u64 = 0;
+ smi_cmd.s.phy_op = op;
+ smi_cmd.s.phy_adr = phy_id;
+ smi_cmd.s.reg_adr = regnum;
+ oct_mdio_writeq(smi_cmd.u64, p->register_base + SMI_CMD);
+
+ do {
+ /* Wait 1000 clocks so we don't saturate the RSL bus
+ * doing reads.
+ */
+ __delay(1000);
+ smi_wr.u64 = oct_mdio_readq(p->register_base + SMI_WR_DAT);
+ } while (smi_wr.s.pending && --timeout);
+
+ if (timeout <= 0)
+ return -EIO;
+
+ return 0;
+}
+EXPORT_SYMBOL(cavium_mdiobus_write);
+
+MODULE_DESCRIPTION("Common code for OCTEON and Thunder MDIO bus drivers");
+MODULE_AUTHOR("David Daney");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2009-2016 Cavium, Inc.
+ */
+
+enum cavium_mdiobus_mode {
+ UNINIT = 0,
+ C22,
+ C45
+};
+
+#define SMI_CMD 0x0
+#define SMI_WR_DAT 0x8
+#define SMI_RD_DAT 0x10
+#define SMI_CLK 0x18
+#define SMI_EN 0x20
+
+#ifdef __BIG_ENDIAN_BITFIELD
+#define OCT_MDIO_BITFIELD_FIELD(field, more) \
+ field; \
+ more
+
+#else
+#define OCT_MDIO_BITFIELD_FIELD(field, more) \
+ more \
+ field;
+
+#endif
+
+union cvmx_smix_clk {
+ u64 u64;
+ struct cvmx_smix_clk_s {
+ OCT_MDIO_BITFIELD_FIELD(u64 reserved_25_63:39,
+ OCT_MDIO_BITFIELD_FIELD(u64 mode:1,
+ OCT_MDIO_BITFIELD_FIELD(u64 reserved_21_23:3,
+ OCT_MDIO_BITFIELD_FIELD(u64 sample_hi:5,
+ OCT_MDIO_BITFIELD_FIELD(u64 sample_mode:1,
+ OCT_MDIO_BITFIELD_FIELD(u64 reserved_14_14:1,
+ OCT_MDIO_BITFIELD_FIELD(u64 clk_idle:1,
+ OCT_MDIO_BITFIELD_FIELD(u64 preamble:1,
+ OCT_MDIO_BITFIELD_FIELD(u64 sample:4,
+ OCT_MDIO_BITFIELD_FIELD(u64 phase:8,
+ ;))))))))))
+ } s;
+};
+
+union cvmx_smix_cmd {
+ u64 u64;
+ struct cvmx_smix_cmd_s {
+ OCT_MDIO_BITFIELD_FIELD(u64 reserved_18_63:46,
+ OCT_MDIO_BITFIELD_FIELD(u64 phy_op:2,
+ OCT_MDIO_BITFIELD_FIELD(u64 reserved_13_15:3,
+ OCT_MDIO_BITFIELD_FIELD(u64 phy_adr:5,
+ OCT_MDIO_BITFIELD_FIELD(u64 reserved_5_7:3,
+ OCT_MDIO_BITFIELD_FIELD(u64 reg_adr:5,
+ ;))))))
+ } s;
+};
+
+union cvmx_smix_en {
+ u64 u64;
+ struct cvmx_smix_en_s {
+ OCT_MDIO_BITFIELD_FIELD(u64 reserved_1_63:63,
+ OCT_MDIO_BITFIELD_FIELD(u64 en:1,
+ ;))
+ } s;
+};
+
+union cvmx_smix_rd_dat {
+ u64 u64;
+ struct cvmx_smix_rd_dat_s {
+ OCT_MDIO_BITFIELD_FIELD(u64 reserved_18_63:46,
+ OCT_MDIO_BITFIELD_FIELD(u64 pending:1,
+ OCT_MDIO_BITFIELD_FIELD(u64 val:1,
+ OCT_MDIO_BITFIELD_FIELD(u64 dat:16,
+ ;))))
+ } s;
+};
+
+union cvmx_smix_wr_dat {
+ u64 u64;
+ struct cvmx_smix_wr_dat_s {
+ OCT_MDIO_BITFIELD_FIELD(u64 reserved_18_63:46,
+ OCT_MDIO_BITFIELD_FIELD(u64 pending:1,
+ OCT_MDIO_BITFIELD_FIELD(u64 val:1,
+ OCT_MDIO_BITFIELD_FIELD(u64 dat:16,
+ ;))))
+ } s;
+};
+
+struct cavium_mdiobus {
+ struct mii_bus *mii_bus;
+ void __iomem *register_base;
+ enum cavium_mdiobus_mode mode;
+};
+
+#ifdef CONFIG_CAVIUM_OCTEON_SOC
+
+#include <asm/octeon/octeon.h>
+
+static inline void oct_mdio_writeq(u64 val, void __iomem *addr)
+{
+ cvmx_write_csr((u64 __force)addr, val);
+}
+
+static inline u64 oct_mdio_readq(void __iomem *addr)
+{
+ return cvmx_read_csr((u64 __force)addr);
+}
+#else
+#include <linux/io-64-nonatomic-lo-hi.h>
+
+#define oct_mdio_writeq(val, addr) writeq(val, addr)
+#define oct_mdio_readq(addr) readq(addr)
+#endif
+
+int cavium_mdiobus_read(struct mii_bus *bus, int phy_id, int regnum);
+int cavium_mdiobus_write(struct mii_bus *bus, int phy_id, int regnum, u16 val);
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * GPIO based MDIO bitbang driver.
+ * Supports OpenFirmware.
+ *
+ * Copyright (c) 2008 CSE Semaphore Belgium.
+ * by Laurent Pinchart <laurentp@cse-semaphore.com>
+ *
+ * Copyright (C) 2008, Paulius Zaleckas <paulius.zaleckas@teltonika.lt>
+ *
+ * Based on earlier work by
+ *
+ * Copyright (c) 2003 Intracom S.A.
+ * by Pantelis Antoniou <panto@intracom.gr>
+ *
+ * 2005 (c) MontaVista Software, Inc.
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/platform_data/mdio-gpio.h>
+#include <linux/mdio-bitbang.h>
+#include <linux/mdio-gpio.h>
+#include <linux/gpio/consumer.h>
+#include <linux/of_mdio.h>
+
+struct mdio_gpio_info {
+ struct mdiobb_ctrl ctrl;
+ struct gpio_desc *mdc, *mdio, *mdo;
+};
+
+static int mdio_gpio_get_data(struct device *dev,
+ struct mdio_gpio_info *bitbang)
+{
+ bitbang->mdc = devm_gpiod_get_index(dev, NULL, MDIO_GPIO_MDC,
+ GPIOD_OUT_LOW);
+ if (IS_ERR(bitbang->mdc))
+ return PTR_ERR(bitbang->mdc);
+
+ bitbang->mdio = devm_gpiod_get_index(dev, NULL, MDIO_GPIO_MDIO,
+ GPIOD_IN);
+ if (IS_ERR(bitbang->mdio))
+ return PTR_ERR(bitbang->mdio);
+
+ bitbang->mdo = devm_gpiod_get_index_optional(dev, NULL, MDIO_GPIO_MDO,
+ GPIOD_OUT_LOW);
+ return PTR_ERR_OR_ZERO(bitbang->mdo);
+}
+
+static void mdio_dir(struct mdiobb_ctrl *ctrl, int dir)
+{
+ struct mdio_gpio_info *bitbang =
+ container_of(ctrl, struct mdio_gpio_info, ctrl);
+
+ if (bitbang->mdo) {
+ /* Separate output pin. Always set its value to high
+ * when changing direction. If direction is input,
+ * assume the pin serves as pull-up. If direction is
+ * output, the default value is high.
+ */
+ gpiod_set_value_cansleep(bitbang->mdo, 1);
+ return;
+ }
+
+ if (dir)
+ gpiod_direction_output(bitbang->mdio, 1);
+ else
+ gpiod_direction_input(bitbang->mdio);
+}
+
+static int mdio_get(struct mdiobb_ctrl *ctrl)
+{
+ struct mdio_gpio_info *bitbang =
+ container_of(ctrl, struct mdio_gpio_info, ctrl);
+
+ return gpiod_get_value_cansleep(bitbang->mdio);
+}
+
+static void mdio_set(struct mdiobb_ctrl *ctrl, int what)
+{
+ struct mdio_gpio_info *bitbang =
+ container_of(ctrl, struct mdio_gpio_info, ctrl);
+
+ if (bitbang->mdo)
+ gpiod_set_value_cansleep(bitbang->mdo, what);
+ else
+ gpiod_set_value_cansleep(bitbang->mdio, what);
+}
+
+static void mdc_set(struct mdiobb_ctrl *ctrl, int what)
+{
+ struct mdio_gpio_info *bitbang =
+ container_of(ctrl, struct mdio_gpio_info, ctrl);
+
+ gpiod_set_value_cansleep(bitbang->mdc, what);
+}
+
+static const struct mdiobb_ops mdio_gpio_ops = {
+ .owner = THIS_MODULE,
+ .set_mdc = mdc_set,
+ .set_mdio_dir = mdio_dir,
+ .set_mdio_data = mdio_set,
+ .get_mdio_data = mdio_get,
+};
+
+static struct mii_bus *mdio_gpio_bus_init(struct device *dev,
+ struct mdio_gpio_info *bitbang,
+ int bus_id)
+{
+ struct mdio_gpio_platform_data *pdata = dev_get_platdata(dev);
+ struct mii_bus *new_bus;
+
+ bitbang->ctrl.ops = &mdio_gpio_ops;
+
+ new_bus = alloc_mdio_bitbang(&bitbang->ctrl);
+ if (!new_bus)
+ return NULL;
+
+ new_bus->name = "GPIO Bitbanged MDIO";
+ new_bus->parent = dev;
+
+ if (bus_id != -1)
+ snprintf(new_bus->id, MII_BUS_ID_SIZE, "gpio-%x", bus_id);
+ else
+ strncpy(new_bus->id, "gpio", MII_BUS_ID_SIZE);
+
+ if (pdata) {
+ new_bus->phy_mask = pdata->phy_mask;
+ new_bus->phy_ignore_ta_mask = pdata->phy_ignore_ta_mask;
+ }
+
+ dev_set_drvdata(dev, new_bus);
+
+ return new_bus;
+}
+
+static void mdio_gpio_bus_deinit(struct device *dev)
+{
+ struct mii_bus *bus = dev_get_drvdata(dev);
+
+ free_mdio_bitbang(bus);
+}
+
+static void mdio_gpio_bus_destroy(struct device *dev)
+{
+ struct mii_bus *bus = dev_get_drvdata(dev);
+
+ mdiobus_unregister(bus);
+ mdio_gpio_bus_deinit(dev);
+}
+
+static int mdio_gpio_probe(struct platform_device *pdev)
+{
+ struct mdio_gpio_info *bitbang;
+ struct mii_bus *new_bus;
+ int ret, bus_id;
+
+ bitbang = devm_kzalloc(&pdev->dev, sizeof(*bitbang), GFP_KERNEL);
+ if (!bitbang)
+ return -ENOMEM;
+
+ ret = mdio_gpio_get_data(&pdev->dev, bitbang);
+ if (ret)
+ return ret;
+
+ if (pdev->dev.of_node) {
+ bus_id = of_alias_get_id(pdev->dev.of_node, "mdio-gpio");
+ if (bus_id < 0) {
+ dev_warn(&pdev->dev, "failed to get alias id\n");
+ bus_id = 0;
+ }
+ } else {
+ bus_id = pdev->id;
+ }
+
+ new_bus = mdio_gpio_bus_init(&pdev->dev, bitbang, bus_id);
+ if (!new_bus)
+ return -ENODEV;
+
+ ret = of_mdiobus_register(new_bus, pdev->dev.of_node);
+ if (ret)
+ mdio_gpio_bus_deinit(&pdev->dev);
+
+ return ret;
+}
+
+static int mdio_gpio_remove(struct platform_device *pdev)
+{
+ mdio_gpio_bus_destroy(&pdev->dev);
+
+ return 0;
+}
+
+static const struct of_device_id mdio_gpio_of_match[] = {
+ { .compatible = "virtual,mdio-gpio", },
+ { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, mdio_gpio_of_match);
+
+static struct platform_driver mdio_gpio_driver = {
+ .probe = mdio_gpio_probe,
+ .remove = mdio_gpio_remove,
+ .driver = {
+ .name = "mdio-gpio",
+ .of_match_table = mdio_gpio_of_match,
+ },
+};
+
+module_platform_driver(mdio_gpio_driver);
+
+MODULE_ALIAS("platform:mdio-gpio");
+MODULE_AUTHOR("Laurent Pinchart, Paulius Zaleckas");
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("Generic driver for MDIO bus emulation using GPIO");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Hisilicon Fast Ethernet MDIO Bus Driver
+ *
+ * Copyright (c) 2016 HiSilicon Technologies Co., Ltd.
+ */
+
+#include <linux/clk.h>
+#include <linux/iopoll.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of_address.h>
+#include <linux/of_mdio.h>
+#include <linux/platform_device.h>
+
+#define MDIO_RWCTRL 0x00
+#define MDIO_RO_DATA 0x04
+#define MDIO_WRITE BIT(13)
+#define MDIO_RW_FINISH BIT(15)
+#define BIT_PHY_ADDR_OFFSET 8
+#define BIT_WR_DATA_OFFSET 16
+
+struct hisi_femac_mdio_data {
+ struct clk *clk;
+ void __iomem *membase;
+};
+
+static int hisi_femac_mdio_wait_ready(struct hisi_femac_mdio_data *data)
+{
+ u32 val;
+
+ return readl_poll_timeout(data->membase + MDIO_RWCTRL,
+ val, val & MDIO_RW_FINISH, 20, 10000);
+}
+
+static int hisi_femac_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
+{
+ struct hisi_femac_mdio_data *data = bus->priv;
+ int ret;
+
+ ret = hisi_femac_mdio_wait_ready(data);
+ if (ret)
+ return ret;
+
+ writel((mii_id << BIT_PHY_ADDR_OFFSET) | regnum,
+ data->membase + MDIO_RWCTRL);
+
+ ret = hisi_femac_mdio_wait_ready(data);
+ if (ret)
+ return ret;
+
+ return readl(data->membase + MDIO_RO_DATA) & 0xFFFF;
+}
+
+static int hisi_femac_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
+ u16 value)
+{
+ struct hisi_femac_mdio_data *data = bus->priv;
+ int ret;
+
+ ret = hisi_femac_mdio_wait_ready(data);
+ if (ret)
+ return ret;
+
+ writel(MDIO_WRITE | (value << BIT_WR_DATA_OFFSET) |
+ (mii_id << BIT_PHY_ADDR_OFFSET) | regnum,
+ data->membase + MDIO_RWCTRL);
+
+ return hisi_femac_mdio_wait_ready(data);
+}
+
+static int hisi_femac_mdio_probe(struct platform_device *pdev)
+{
+ struct device_node *np = pdev->dev.of_node;
+ struct mii_bus *bus;
+ struct hisi_femac_mdio_data *data;
+ int ret;
+
+ bus = mdiobus_alloc_size(sizeof(*data));
+ if (!bus)
+ return -ENOMEM;
+
+ bus->name = "hisi_femac_mii_bus";
+ bus->read = &hisi_femac_mdio_read;
+ bus->write = &hisi_femac_mdio_write;
+ snprintf(bus->id, MII_BUS_ID_SIZE, "%s", pdev->name);
+ bus->parent = &pdev->dev;
+
+ data = bus->priv;
+ data->membase = devm_platform_ioremap_resource(pdev, 0);
+ if (IS_ERR(data->membase)) {
+ ret = PTR_ERR(data->membase);
+ goto err_out_free_mdiobus;
+ }
+
+ data->clk = devm_clk_get(&pdev->dev, NULL);
+ if (IS_ERR(data->clk)) {
+ ret = PTR_ERR(data->clk);
+ goto err_out_free_mdiobus;
+ }
+
+ ret = clk_prepare_enable(data->clk);
+ if (ret)
+ goto err_out_free_mdiobus;
+
+ ret = of_mdiobus_register(bus, np);
+ if (ret)
+ goto err_out_disable_clk;
+
+ platform_set_drvdata(pdev, bus);
+
+ return 0;
+
+err_out_disable_clk:
+ clk_disable_unprepare(data->clk);
+err_out_free_mdiobus:
+ mdiobus_free(bus);
+ return ret;
+}
+
+static int hisi_femac_mdio_remove(struct platform_device *pdev)
+{
+ struct mii_bus *bus = platform_get_drvdata(pdev);
+ struct hisi_femac_mdio_data *data = bus->priv;
+
+ mdiobus_unregister(bus);
+ clk_disable_unprepare(data->clk);
+ mdiobus_free(bus);
+
+ return 0;
+}
+
+static const struct of_device_id hisi_femac_mdio_dt_ids[] = {
+ { .compatible = "hisilicon,hisi-femac-mdio" },
+ { }
+};
+MODULE_DEVICE_TABLE(of, hisi_femac_mdio_dt_ids);
+
+static struct platform_driver hisi_femac_mdio_driver = {
+ .probe = hisi_femac_mdio_probe,
+ .remove = hisi_femac_mdio_remove,
+ .driver = {
+ .name = "hisi-femac-mdio",
+ .of_match_table = hisi_femac_mdio_dt_ids,
+ },
+};
+
+module_platform_driver(hisi_femac_mdio_driver);
+
+MODULE_DESCRIPTION("Hisilicon Fast Ethernet MAC MDIO interface driver");
+MODULE_AUTHOR("Dongpo Li <lidongpo@hisilicon.com>");
+MODULE_LICENSE("GPL");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * MDIO I2C bridge
+ *
+ * Copyright (C) 2015-2016 Russell King
+ *
+ * Network PHYs can appear on I2C buses when they are part of SFP module.
+ * This driver exposes these PHYs to the networking PHY code, allowing
+ * our PHY drivers access to these PHYs, and so allowing configuration
+ * of their settings.
+ */
+#include <linux/i2c.h>
+#include <linux/mdio/mdio-i2c.h>
+#include <linux/phy.h>
+
+/*
+ * I2C bus addresses 0x50 and 0x51 are normally an EEPROM, which is
+ * specified to be present in SFP modules. These correspond with PHY
+ * addresses 16 and 17. Disallow access to these "phy" addresses.
+ */
+static bool i2c_mii_valid_phy_id(int phy_id)
+{
+ return phy_id != 0x10 && phy_id != 0x11;
+}
+
+static unsigned int i2c_mii_phy_addr(int phy_id)
+{
+ return phy_id + 0x40;
+}
+
+static int i2c_mii_read(struct mii_bus *bus, int phy_id, int reg)
+{
+ struct i2c_adapter *i2c = bus->priv;
+ struct i2c_msg msgs[2];
+ u8 addr[3], data[2], *p;
+ int bus_addr, ret;
+
+ if (!i2c_mii_valid_phy_id(phy_id))
+ return 0xffff;
+
+ p = addr;
+ if (reg & MII_ADDR_C45) {
+ *p++ = 0x20 | ((reg >> 16) & 31);
+ *p++ = reg >> 8;
+ }
+ *p++ = reg;
+
+ bus_addr = i2c_mii_phy_addr(phy_id);
+ msgs[0].addr = bus_addr;
+ msgs[0].flags = 0;
+ msgs[0].len = p - addr;
+ msgs[0].buf = addr;
+ msgs[1].addr = bus_addr;
+ msgs[1].flags = I2C_M_RD;
+ msgs[1].len = sizeof(data);
+ msgs[1].buf = data;
+
+ ret = i2c_transfer(i2c, msgs, ARRAY_SIZE(msgs));
+ if (ret != ARRAY_SIZE(msgs))
+ return 0xffff;
+
+ return data[0] << 8 | data[1];
+}
+
+static int i2c_mii_write(struct mii_bus *bus, int phy_id, int reg, u16 val)
+{
+ struct i2c_adapter *i2c = bus->priv;
+ struct i2c_msg msg;
+ int ret;
+ u8 data[5], *p;
+
+ if (!i2c_mii_valid_phy_id(phy_id))
+ return 0;
+
+ p = data;
+ if (reg & MII_ADDR_C45) {
+ *p++ = (reg >> 16) & 31;
+ *p++ = reg >> 8;
+ }
+ *p++ = reg;
+ *p++ = val >> 8;
+ *p++ = val;
+
+ msg.addr = i2c_mii_phy_addr(phy_id);
+ msg.flags = 0;
+ msg.len = p - data;
+ msg.buf = data;
+
+ ret = i2c_transfer(i2c, &msg, 1);
+
+ return ret < 0 ? ret : 0;
+}
+
+struct mii_bus *mdio_i2c_alloc(struct device *parent, struct i2c_adapter *i2c)
+{
+ struct mii_bus *mii;
+
+ if (!i2c_check_functionality(i2c, I2C_FUNC_I2C))
+ return ERR_PTR(-EINVAL);
+
+ mii = mdiobus_alloc();
+ if (!mii)
+ return ERR_PTR(-ENOMEM);
+
+ snprintf(mii->id, MII_BUS_ID_SIZE, "i2c:%s", dev_name(parent));
+ mii->parent = parent;
+ mii->read = i2c_mii_read;
+ mii->write = i2c_mii_write;
+ mii->priv = i2c;
+
+ return mii;
+}
+EXPORT_SYMBOL_GPL(mdio_i2c_alloc);
+
+MODULE_AUTHOR("Russell King");
+MODULE_DESCRIPTION("MDIO I2C bridge library");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
+/* Copyright (c) 2015, The Linux Foundation. All rights reserved. */
+/* Copyright (c) 2020 Sartura Ltd. */
+
+#include <linux/delay.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/iopoll.h>
+#include <linux/of_address.h>
+#include <linux/of_mdio.h>
+#include <linux/phy.h>
+#include <linux/platform_device.h>
+
+#define MDIO_ADDR_REG 0x44
+#define MDIO_DATA_WRITE_REG 0x48
+#define MDIO_DATA_READ_REG 0x4c
+#define MDIO_CMD_REG 0x50
+#define MDIO_CMD_ACCESS_BUSY BIT(16)
+#define MDIO_CMD_ACCESS_START BIT(8)
+#define MDIO_CMD_ACCESS_CODE_READ 0
+#define MDIO_CMD_ACCESS_CODE_WRITE 1
+
+#define ipq4019_MDIO_TIMEOUT 10000
+#define ipq4019_MDIO_SLEEP 10
+
+struct ipq4019_mdio_data {
+ void __iomem *membase;
+};
+
+static int ipq4019_mdio_wait_busy(struct mii_bus *bus)
+{
+ struct ipq4019_mdio_data *priv = bus->priv;
+ unsigned int busy;
+
+ return readl_poll_timeout(priv->membase + MDIO_CMD_REG, busy,
+ (busy & MDIO_CMD_ACCESS_BUSY) == 0,
+ ipq4019_MDIO_SLEEP, ipq4019_MDIO_TIMEOUT);
+}
+
+static int ipq4019_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
+{
+ struct ipq4019_mdio_data *priv = bus->priv;
+ unsigned int cmd;
+
+ /* Reject clause 45 */
+ if (regnum & MII_ADDR_C45)
+ return -EOPNOTSUPP;
+
+ if (ipq4019_mdio_wait_busy(bus))
+ return -ETIMEDOUT;
+
+ /* issue the phy address and reg */
+ writel((mii_id << 8) | regnum, priv->membase + MDIO_ADDR_REG);
+
+ cmd = MDIO_CMD_ACCESS_START | MDIO_CMD_ACCESS_CODE_READ;
+
+ /* issue read command */
+ writel(cmd, priv->membase + MDIO_CMD_REG);
+
+ /* Wait read complete */
+ if (ipq4019_mdio_wait_busy(bus))
+ return -ETIMEDOUT;
+
+ /* Read and return data */
+ return readl(priv->membase + MDIO_DATA_READ_REG);
+}
+
+static int ipq4019_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
+ u16 value)
+{
+ struct ipq4019_mdio_data *priv = bus->priv;
+ unsigned int cmd;
+
+ /* Reject clause 45 */
+ if (regnum & MII_ADDR_C45)
+ return -EOPNOTSUPP;
+
+ if (ipq4019_mdio_wait_busy(bus))
+ return -ETIMEDOUT;
+
+ /* issue the phy address and reg */
+ writel((mii_id << 8) | regnum, priv->membase + MDIO_ADDR_REG);
+
+ /* issue write data */
+ writel(value, priv->membase + MDIO_DATA_WRITE_REG);
+
+ cmd = MDIO_CMD_ACCESS_START | MDIO_CMD_ACCESS_CODE_WRITE;
+ /* issue write command */
+ writel(cmd, priv->membase + MDIO_CMD_REG);
+
+ /* Wait write complete */
+ if (ipq4019_mdio_wait_busy(bus))
+ return -ETIMEDOUT;
+
+ return 0;
+}
+
+static int ipq4019_mdio_probe(struct platform_device *pdev)
+{
+ struct ipq4019_mdio_data *priv;
+ struct mii_bus *bus;
+ int ret;
+
+ bus = devm_mdiobus_alloc_size(&pdev->dev, sizeof(*priv));
+ if (!bus)
+ return -ENOMEM;
+
+ priv = bus->priv;
+
+ priv->membase = devm_platform_ioremap_resource(pdev, 0);
+ if (IS_ERR(priv->membase))
+ return PTR_ERR(priv->membase);
+
+ bus->name = "ipq4019_mdio";
+ bus->read = ipq4019_mdio_read;
+ bus->write = ipq4019_mdio_write;
+ bus->parent = &pdev->dev;
+ snprintf(bus->id, MII_BUS_ID_SIZE, "%s%d", pdev->name, pdev->id);
+
+ ret = of_mdiobus_register(bus, pdev->dev.of_node);
+ if (ret) {
+ dev_err(&pdev->dev, "Cannot register MDIO bus!\n");
+ return ret;
+ }
+
+ platform_set_drvdata(pdev, bus);
+
+ return 0;
+}
+
+static int ipq4019_mdio_remove(struct platform_device *pdev)
+{
+ struct mii_bus *bus = platform_get_drvdata(pdev);
+
+ mdiobus_unregister(bus);
+
+ return 0;
+}
+
+static const struct of_device_id ipq4019_mdio_dt_ids[] = {
+ { .compatible = "qcom,ipq4019-mdio" },
+ { }
+};
+MODULE_DEVICE_TABLE(of, ipq4019_mdio_dt_ids);
+
+static struct platform_driver ipq4019_mdio_driver = {
+ .probe = ipq4019_mdio_probe,
+ .remove = ipq4019_mdio_remove,
+ .driver = {
+ .name = "ipq4019-mdio",
+ .of_match_table = ipq4019_mdio_dt_ids,
+ },
+};
+
+module_platform_driver(ipq4019_mdio_driver);
+
+MODULE_DESCRIPTION("ipq4019 MDIO interface driver");
+MODULE_AUTHOR("Qualcomm Atheros");
+MODULE_LICENSE("Dual BSD/GPL");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/* Qualcomm IPQ8064 MDIO interface driver
+ *
+ * Copyright (C) 2019 Christian Lamparter <chunkeey@gmail.com>
+ * Copyright (C) 2020 Ansuel Smith <ansuelsmth@gmail.com>
+ */
+
+#include <linux/delay.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/regmap.h>
+#include <linux/of_mdio.h>
+#include <linux/phy.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/syscon.h>
+
+/* MII address register definitions */
+#define MII_ADDR_REG_ADDR 0x10
+#define MII_BUSY BIT(0)
+#define MII_WRITE BIT(1)
+#define MII_CLKRANGE_60_100M (0 << 2)
+#define MII_CLKRANGE_100_150M (1 << 2)
+#define MII_CLKRANGE_20_35M (2 << 2)
+#define MII_CLKRANGE_35_60M (3 << 2)
+#define MII_CLKRANGE_150_250M (4 << 2)
+#define MII_CLKRANGE_250_300M (5 << 2)
+#define MII_CLKRANGE_MASK GENMASK(4, 2)
+#define MII_REG_SHIFT 6
+#define MII_REG_MASK GENMASK(10, 6)
+#define MII_ADDR_SHIFT 11
+#define MII_ADDR_MASK GENMASK(15, 11)
+
+#define MII_DATA_REG_ADDR 0x14
+
+#define MII_MDIO_DELAY_USEC (1000)
+#define MII_MDIO_RETRY_MSEC (10)
+
+struct ipq8064_mdio {
+ struct regmap *base; /* NSS_GMAC0_BASE */
+};
+
+static int
+ipq8064_mdio_wait_busy(struct ipq8064_mdio *priv)
+{
+ u32 busy;
+
+ return regmap_read_poll_timeout(priv->base, MII_ADDR_REG_ADDR, busy,
+ !(busy & MII_BUSY), MII_MDIO_DELAY_USEC,
+ MII_MDIO_RETRY_MSEC * USEC_PER_MSEC);
+}
+
+static int
+ipq8064_mdio_read(struct mii_bus *bus, int phy_addr, int reg_offset)
+{
+ u32 miiaddr = MII_BUSY | MII_CLKRANGE_250_300M;
+ struct ipq8064_mdio *priv = bus->priv;
+ u32 ret_val;
+ int err;
+
+ /* Reject clause 45 */
+ if (reg_offset & MII_ADDR_C45)
+ return -EOPNOTSUPP;
+
+ miiaddr |= ((phy_addr << MII_ADDR_SHIFT) & MII_ADDR_MASK) |
+ ((reg_offset << MII_REG_SHIFT) & MII_REG_MASK);
+
+ regmap_write(priv->base, MII_ADDR_REG_ADDR, miiaddr);
+ usleep_range(8, 10);
+
+ err = ipq8064_mdio_wait_busy(priv);
+ if (err)
+ return err;
+
+ regmap_read(priv->base, MII_DATA_REG_ADDR, &ret_val);
+ return (int)ret_val;
+}
+
+static int
+ipq8064_mdio_write(struct mii_bus *bus, int phy_addr, int reg_offset, u16 data)
+{
+ u32 miiaddr = MII_WRITE | MII_BUSY | MII_CLKRANGE_250_300M;
+ struct ipq8064_mdio *priv = bus->priv;
+
+ /* Reject clause 45 */
+ if (reg_offset & MII_ADDR_C45)
+ return -EOPNOTSUPP;
+
+ regmap_write(priv->base, MII_DATA_REG_ADDR, data);
+
+ miiaddr |= ((phy_addr << MII_ADDR_SHIFT) & MII_ADDR_MASK) |
+ ((reg_offset << MII_REG_SHIFT) & MII_REG_MASK);
+
+ regmap_write(priv->base, MII_ADDR_REG_ADDR, miiaddr);
+ usleep_range(8, 10);
+
+ return ipq8064_mdio_wait_busy(priv);
+}
+
+static int
+ipq8064_mdio_probe(struct platform_device *pdev)
+{
+ struct device_node *np = pdev->dev.of_node;
+ struct ipq8064_mdio *priv;
+ struct mii_bus *bus;
+ int ret;
+
+ bus = devm_mdiobus_alloc_size(&pdev->dev, sizeof(*priv));
+ if (!bus)
+ return -ENOMEM;
+
+ bus->name = "ipq8064_mdio_bus";
+ bus->read = ipq8064_mdio_read;
+ bus->write = ipq8064_mdio_write;
+ snprintf(bus->id, MII_BUS_ID_SIZE, "%s-mii", dev_name(&pdev->dev));
+ bus->parent = &pdev->dev;
+
+ priv = bus->priv;
+ priv->base = device_node_to_regmap(np);
+ if (IS_ERR(priv->base)) {
+ if (priv->base == ERR_PTR(-EPROBE_DEFER))
+ return -EPROBE_DEFER;
+
+ dev_err(&pdev->dev, "error getting device regmap, error=%pe\n",
+ priv->base);
+ return PTR_ERR(priv->base);
+ }
+
+ ret = of_mdiobus_register(bus, np);
+ if (ret)
+ return ret;
+
+ platform_set_drvdata(pdev, bus);
+ return 0;
+}
+
+static int
+ipq8064_mdio_remove(struct platform_device *pdev)
+{
+ struct mii_bus *bus = platform_get_drvdata(pdev);
+
+ mdiobus_unregister(bus);
+
+ return 0;
+}
+
+static const struct of_device_id ipq8064_mdio_dt_ids[] = {
+ { .compatible = "qcom,ipq8064-mdio" },
+ { }
+};
+MODULE_DEVICE_TABLE(of, ipq8064_mdio_dt_ids);
+
+static struct platform_driver ipq8064_mdio_driver = {
+ .probe = ipq8064_mdio_probe,
+ .remove = ipq8064_mdio_remove,
+ .driver = {
+ .name = "ipq8064-mdio",
+ .of_match_table = ipq8064_mdio_dt_ids,
+ },
+};
+
+module_platform_driver(ipq8064_mdio_driver);
+
+MODULE_DESCRIPTION("Qualcomm IPQ8064 MDIO interface driver");
+MODULE_AUTHOR("Christian Lamparter <chunkeey@gmail.com>");
+MODULE_AUTHOR("Ansuel Smith <ansuelsmth@gmail.com>");
+MODULE_LICENSE("GPL");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/* MOXA ART Ethernet (RTL8201CP) MDIO interface driver
+ *
+ * Copyright (C) 2013 Jonas Jensen <jonas.jensen@gmail.com>
+ */
+
+#include <linux/delay.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of_address.h>
+#include <linux/of_mdio.h>
+#include <linux/phy.h>
+#include <linux/platform_device.h>
+
+#define REG_PHY_CTRL 0
+#define REG_PHY_WRITE_DATA 4
+
+/* REG_PHY_CTRL */
+#define MIIWR BIT(27) /* init write sequence (auto cleared)*/
+#define MIIRD BIT(26)
+#define REGAD_MASK 0x3e00000
+#define PHYAD_MASK 0x1f0000
+#define MIIRDATA_MASK 0xffff
+
+/* REG_PHY_WRITE_DATA */
+#define MIIWDATA_MASK 0xffff
+
+struct moxart_mdio_data {
+ void __iomem *base;
+};
+
+static int moxart_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
+{
+ struct moxart_mdio_data *data = bus->priv;
+ u32 ctrl = 0;
+ unsigned int count = 5;
+
+ dev_dbg(&bus->dev, "%s\n", __func__);
+
+ ctrl |= MIIRD | ((mii_id << 16) & PHYAD_MASK) |
+ ((regnum << 21) & REGAD_MASK);
+
+ writel(ctrl, data->base + REG_PHY_CTRL);
+
+ do {
+ ctrl = readl(data->base + REG_PHY_CTRL);
+
+ if (!(ctrl & MIIRD))
+ return ctrl & MIIRDATA_MASK;
+
+ mdelay(10);
+ count--;
+ } while (count > 0);
+
+ dev_dbg(&bus->dev, "%s timed out\n", __func__);
+
+ return -ETIMEDOUT;
+}
+
+static int moxart_mdio_write(struct mii_bus *bus, int mii_id,
+ int regnum, u16 value)
+{
+ struct moxart_mdio_data *data = bus->priv;
+ u32 ctrl = 0;
+ unsigned int count = 5;
+
+ dev_dbg(&bus->dev, "%s\n", __func__);
+
+ ctrl |= MIIWR | ((mii_id << 16) & PHYAD_MASK) |
+ ((regnum << 21) & REGAD_MASK);
+
+ value &= MIIWDATA_MASK;
+
+ writel(value, data->base + REG_PHY_WRITE_DATA);
+ writel(ctrl, data->base + REG_PHY_CTRL);
+
+ do {
+ ctrl = readl(data->base + REG_PHY_CTRL);
+
+ if (!(ctrl & MIIWR))
+ return 0;
+
+ mdelay(10);
+ count--;
+ } while (count > 0);
+
+ dev_dbg(&bus->dev, "%s timed out\n", __func__);
+
+ return -ETIMEDOUT;
+}
+
+static int moxart_mdio_reset(struct mii_bus *bus)
+{
+ int data, i;
+
+ for (i = 0; i < PHY_MAX_ADDR; i++) {
+ data = moxart_mdio_read(bus, i, MII_BMCR);
+ if (data < 0)
+ continue;
+
+ data |= BMCR_RESET;
+ if (moxart_mdio_write(bus, i, MII_BMCR, data) < 0)
+ continue;
+ }
+
+ return 0;
+}
+
+static int moxart_mdio_probe(struct platform_device *pdev)
+{
+ struct device_node *np = pdev->dev.of_node;
+ struct mii_bus *bus;
+ struct moxart_mdio_data *data;
+ int ret, i;
+
+ bus = mdiobus_alloc_size(sizeof(*data));
+ if (!bus)
+ return -ENOMEM;
+
+ bus->name = "MOXA ART Ethernet MII";
+ bus->read = &moxart_mdio_read;
+ bus->write = &moxart_mdio_write;
+ bus->reset = &moxart_mdio_reset;
+ snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d-mii", pdev->name, pdev->id);
+ bus->parent = &pdev->dev;
+
+ /* Setting PHY_IGNORE_INTERRUPT here even if it has no effect,
+ * of_mdiobus_register() sets these PHY_POLL.
+ * Ideally, the interrupt from MAC controller could be used to
+ * detect link state changes, not polling, i.e. if there was
+ * a way phy_driver could set PHY_HAS_INTERRUPT but have that
+ * interrupt handled in ethernet drivercode.
+ */
+ for (i = 0; i < PHY_MAX_ADDR; i++)
+ bus->irq[i] = PHY_IGNORE_INTERRUPT;
+
+ data = bus->priv;
+ data->base = devm_platform_ioremap_resource(pdev, 0);
+ if (IS_ERR(data->base)) {
+ ret = PTR_ERR(data->base);
+ goto err_out_free_mdiobus;
+ }
+
+ ret = of_mdiobus_register(bus, np);
+ if (ret < 0)
+ goto err_out_free_mdiobus;
+
+ platform_set_drvdata(pdev, bus);
+
+ return 0;
+
+err_out_free_mdiobus:
+ mdiobus_free(bus);
+ return ret;
+}
+
+static int moxart_mdio_remove(struct platform_device *pdev)
+{
+ struct mii_bus *bus = platform_get_drvdata(pdev);
+
+ mdiobus_unregister(bus);
+ mdiobus_free(bus);
+
+ return 0;
+}
+
+static const struct of_device_id moxart_mdio_dt_ids[] = {
+ { .compatible = "moxa,moxart-mdio" },
+ { }
+};
+MODULE_DEVICE_TABLE(of, moxart_mdio_dt_ids);
+
+static struct platform_driver moxart_mdio_driver = {
+ .probe = moxart_mdio_probe,
+ .remove = moxart_mdio_remove,
+ .driver = {
+ .name = "moxart-mdio",
+ .of_match_table = moxart_mdio_dt_ids,
+ },
+};
+
+module_platform_driver(moxart_mdio_driver);
+
+MODULE_DESCRIPTION("MOXA ART MDIO interface driver");
+MODULE_AUTHOR("Jonas Jensen <jonas.jensen@gmail.com>");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+// SPDX-License-Identifier: (GPL-2.0 OR MIT)
+/*
+ * Driver for the MDIO interface of Microsemi network switches.
+ *
+ * Author: Alexandre Belloni <alexandre.belloni@bootlin.com>
+ * Copyright (c) 2017 Microsemi Corporation
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/phy.h>
+#include <linux/platform_device.h>
+#include <linux/bitops.h>
+#include <linux/io.h>
+#include <linux/iopoll.h>
+#include <linux/of_mdio.h>
+
+#define MSCC_MIIM_REG_STATUS 0x0
+#define MSCC_MIIM_STATUS_STAT_PENDING BIT(2)
+#define MSCC_MIIM_STATUS_STAT_BUSY BIT(3)
+#define MSCC_MIIM_REG_CMD 0x8
+#define MSCC_MIIM_CMD_OPR_WRITE BIT(1)
+#define MSCC_MIIM_CMD_OPR_READ BIT(2)
+#define MSCC_MIIM_CMD_WRDATA_SHIFT 4
+#define MSCC_MIIM_CMD_REGAD_SHIFT 20
+#define MSCC_MIIM_CMD_PHYAD_SHIFT 25
+#define MSCC_MIIM_CMD_VLD BIT(31)
+#define MSCC_MIIM_REG_DATA 0xC
+#define MSCC_MIIM_DATA_ERROR (BIT(16) | BIT(17))
+
+#define MSCC_PHY_REG_PHY_CFG 0x0
+#define PHY_CFG_PHY_ENA (BIT(0) | BIT(1) | BIT(2) | BIT(3))
+#define PHY_CFG_PHY_COMMON_RESET BIT(4)
+#define PHY_CFG_PHY_RESET (BIT(5) | BIT(6) | BIT(7) | BIT(8))
+#define MSCC_PHY_REG_PHY_STATUS 0x4
+
+struct mscc_miim_dev {
+ void __iomem *regs;
+ void __iomem *phy_regs;
+};
+
+/* When high resolution timers aren't built-in: we can't use usleep_range() as
+ * we would sleep way too long. Use udelay() instead.
+ */
+#define mscc_readl_poll_timeout(addr, val, cond, delay_us, timeout_us) \
+({ \
+ if (!IS_ENABLED(CONFIG_HIGH_RES_TIMERS)) \
+ readl_poll_timeout_atomic(addr, val, cond, delay_us, \
+ timeout_us); \
+ readl_poll_timeout(addr, val, cond, delay_us, timeout_us); \
+})
+
+static int mscc_miim_wait_ready(struct mii_bus *bus)
+{
+ struct mscc_miim_dev *miim = bus->priv;
+ u32 val;
+
+ return mscc_readl_poll_timeout(miim->regs + MSCC_MIIM_REG_STATUS, val,
+ !(val & MSCC_MIIM_STATUS_STAT_BUSY), 50,
+ 10000);
+}
+
+static int mscc_miim_wait_pending(struct mii_bus *bus)
+{
+ struct mscc_miim_dev *miim = bus->priv;
+ u32 val;
+
+ return mscc_readl_poll_timeout(miim->regs + MSCC_MIIM_REG_STATUS, val,
+ !(val & MSCC_MIIM_STATUS_STAT_PENDING),
+ 50, 10000);
+}
+
+static int mscc_miim_read(struct mii_bus *bus, int mii_id, int regnum)
+{
+ struct mscc_miim_dev *miim = bus->priv;
+ u32 val;
+ int ret;
+
+ ret = mscc_miim_wait_pending(bus);
+ if (ret)
+ goto out;
+
+ writel(MSCC_MIIM_CMD_VLD | (mii_id << MSCC_MIIM_CMD_PHYAD_SHIFT) |
+ (regnum << MSCC_MIIM_CMD_REGAD_SHIFT) | MSCC_MIIM_CMD_OPR_READ,
+ miim->regs + MSCC_MIIM_REG_CMD);
+
+ ret = mscc_miim_wait_ready(bus);
+ if (ret)
+ goto out;
+
+ val = readl(miim->regs + MSCC_MIIM_REG_DATA);
+ if (val & MSCC_MIIM_DATA_ERROR) {
+ ret = -EIO;
+ goto out;
+ }
+
+ ret = val & 0xFFFF;
+out:
+ return ret;
+}
+
+static int mscc_miim_write(struct mii_bus *bus, int mii_id,
+ int regnum, u16 value)
+{
+ struct mscc_miim_dev *miim = bus->priv;
+ int ret;
+
+ ret = mscc_miim_wait_pending(bus);
+ if (ret < 0)
+ goto out;
+
+ writel(MSCC_MIIM_CMD_VLD | (mii_id << MSCC_MIIM_CMD_PHYAD_SHIFT) |
+ (regnum << MSCC_MIIM_CMD_REGAD_SHIFT) |
+ (value << MSCC_MIIM_CMD_WRDATA_SHIFT) |
+ MSCC_MIIM_CMD_OPR_WRITE,
+ miim->regs + MSCC_MIIM_REG_CMD);
+
+out:
+ return ret;
+}
+
+static int mscc_miim_reset(struct mii_bus *bus)
+{
+ struct mscc_miim_dev *miim = bus->priv;
+
+ if (miim->phy_regs) {
+ writel(0, miim->phy_regs + MSCC_PHY_REG_PHY_CFG);
+ writel(0x1ff, miim->phy_regs + MSCC_PHY_REG_PHY_CFG);
+ mdelay(500);
+ }
+
+ return 0;
+}
+
+static int mscc_miim_probe(struct platform_device *pdev)
+{
+ struct resource *res;
+ struct mii_bus *bus;
+ struct mscc_miim_dev *dev;
+ int ret;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (!res)
+ return -ENODEV;
+
+ bus = devm_mdiobus_alloc_size(&pdev->dev, sizeof(*dev));
+ if (!bus)
+ return -ENOMEM;
+
+ bus->name = "mscc_miim";
+ bus->read = mscc_miim_read;
+ bus->write = mscc_miim_write;
+ bus->reset = mscc_miim_reset;
+ snprintf(bus->id, MII_BUS_ID_SIZE, "%s-mii", dev_name(&pdev->dev));
+ bus->parent = &pdev->dev;
+
+ dev = bus->priv;
+ dev->regs = devm_ioremap_resource(&pdev->dev, res);
+ if (IS_ERR(dev->regs)) {
+ dev_err(&pdev->dev, "Unable to map MIIM registers\n");
+ return PTR_ERR(dev->regs);
+ }
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+ if (res) {
+ dev->phy_regs = devm_ioremap_resource(&pdev->dev, res);
+ if (IS_ERR(dev->phy_regs)) {
+ dev_err(&pdev->dev, "Unable to map internal phy registers\n");
+ return PTR_ERR(dev->phy_regs);
+ }
+ }
+
+ ret = of_mdiobus_register(bus, pdev->dev.of_node);
+ if (ret < 0) {
+ dev_err(&pdev->dev, "Cannot register MDIO bus (%d)\n", ret);
+ return ret;
+ }
+
+ platform_set_drvdata(pdev, bus);
+
+ return 0;
+}
+
+static int mscc_miim_remove(struct platform_device *pdev)
+{
+ struct mii_bus *bus = platform_get_drvdata(pdev);
+
+ mdiobus_unregister(bus);
+
+ return 0;
+}
+
+static const struct of_device_id mscc_miim_match[] = {
+ { .compatible = "mscc,ocelot-miim" },
+ { }
+};
+MODULE_DEVICE_TABLE(of, mscc_miim_match);
+
+static struct platform_driver mscc_miim_driver = {
+ .probe = mscc_miim_probe,
+ .remove = mscc_miim_remove,
+ .driver = {
+ .name = "mscc-miim",
+ .of_match_table = mscc_miim_match,
+ },
+};
+
+module_platform_driver(mscc_miim_driver);
+
+MODULE_DESCRIPTION("Microsemi MIIM driver");
+MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@bootlin.com>");
+MODULE_LICENSE("Dual MIT/GPL");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright 2016 Broadcom
+ */
+#include <linux/clk.h>
+#include <linux/platform_device.h>
+#include <linux/device.h>
+#include <linux/of_mdio.h>
+#include <linux/module.h>
+#include <linux/phy.h>
+#include <linux/mdio-mux.h>
+#include <linux/delay.h>
+#include <linux/iopoll.h>
+
+#define MDIO_RATE_ADJ_EXT_OFFSET 0x000
+#define MDIO_RATE_ADJ_INT_OFFSET 0x004
+#define MDIO_RATE_ADJ_DIVIDENT_SHIFT 16
+
+#define MDIO_SCAN_CTRL_OFFSET 0x008
+#define MDIO_SCAN_CTRL_OVRIDE_EXT_MSTR 28
+
+#define MDIO_PARAM_OFFSET 0x23c
+#define MDIO_PARAM_MIIM_CYCLE 29
+#define MDIO_PARAM_INTERNAL_SEL 25
+#define MDIO_PARAM_BUS_ID 22
+#define MDIO_PARAM_C45_SEL 21
+#define MDIO_PARAM_PHY_ID 16
+#define MDIO_PARAM_PHY_DATA 0
+
+#define MDIO_READ_OFFSET 0x240
+#define MDIO_READ_DATA_MASK 0xffff
+#define MDIO_ADDR_OFFSET 0x244
+
+#define MDIO_CTRL_OFFSET 0x248
+#define MDIO_CTRL_WRITE_OP 0x1
+#define MDIO_CTRL_READ_OP 0x2
+
+#define MDIO_STAT_OFFSET 0x24c
+#define MDIO_STAT_DONE 1
+
+#define BUS_MAX_ADDR 32
+#define EXT_BUS_START_ADDR 16
+
+#define MDIO_REG_ADDR_SPACE_SIZE 0x250
+
+#define MDIO_OPERATING_FREQUENCY 11000000
+#define MDIO_RATE_ADJ_DIVIDENT 1
+
+struct iproc_mdiomux_desc {
+ void *mux_handle;
+ void __iomem *base;
+ struct device *dev;
+ struct mii_bus *mii_bus;
+ struct clk *core_clk;
+};
+
+static void mdio_mux_iproc_config(struct iproc_mdiomux_desc *md)
+{
+ u32 divisor;
+ u32 val;
+
+ /* Disable external mdio master access */
+ val = readl(md->base + MDIO_SCAN_CTRL_OFFSET);
+ val |= BIT(MDIO_SCAN_CTRL_OVRIDE_EXT_MSTR);
+ writel(val, md->base + MDIO_SCAN_CTRL_OFFSET);
+
+ if (md->core_clk) {
+ /* use rate adjust regs to derrive the mdio's operating
+ * frequency from the specified core clock
+ */
+ divisor = clk_get_rate(md->core_clk) / MDIO_OPERATING_FREQUENCY;
+ divisor = divisor / (MDIO_RATE_ADJ_DIVIDENT + 1);
+ val = divisor;
+ val |= MDIO_RATE_ADJ_DIVIDENT << MDIO_RATE_ADJ_DIVIDENT_SHIFT;
+ writel(val, md->base + MDIO_RATE_ADJ_EXT_OFFSET);
+ writel(val, md->base + MDIO_RATE_ADJ_INT_OFFSET);
+ }
+}
+
+static int iproc_mdio_wait_for_idle(void __iomem *base, bool result)
+{
+ u32 val;
+
+ return readl_poll_timeout(base + MDIO_STAT_OFFSET, val,
+ (val & MDIO_STAT_DONE) == result,
+ 2000, 1000000);
+}
+
+/* start_miim_ops- Program and start MDIO transaction over mdio bus.
+ * @base: Base address
+ * @phyid: phyid of the selected bus.
+ * @reg: register offset to be read/written.
+ * @val :0 if read op else value to be written in @reg;
+ * @op: Operation that need to be carried out.
+ * MDIO_CTRL_READ_OP: Read transaction.
+ * MDIO_CTRL_WRITE_OP: Write transaction.
+ *
+ * Return value: Successful Read operation returns read reg values and write
+ * operation returns 0. Failure operation returns negative error code.
+ */
+static int start_miim_ops(void __iomem *base,
+ u16 phyid, u32 reg, u16 val, u32 op)
+{
+ u32 param;
+ int ret;
+
+ writel(0, base + MDIO_CTRL_OFFSET);
+ ret = iproc_mdio_wait_for_idle(base, 0);
+ if (ret)
+ goto err;
+
+ param = readl(base + MDIO_PARAM_OFFSET);
+ param |= phyid << MDIO_PARAM_PHY_ID;
+ param |= val << MDIO_PARAM_PHY_DATA;
+ if (reg & MII_ADDR_C45)
+ param |= BIT(MDIO_PARAM_C45_SEL);
+
+ writel(param, base + MDIO_PARAM_OFFSET);
+
+ writel(reg, base + MDIO_ADDR_OFFSET);
+
+ writel(op, base + MDIO_CTRL_OFFSET);
+
+ ret = iproc_mdio_wait_for_idle(base, 1);
+ if (ret)
+ goto err;
+
+ if (op == MDIO_CTRL_READ_OP)
+ ret = readl(base + MDIO_READ_OFFSET) & MDIO_READ_DATA_MASK;
+err:
+ return ret;
+}
+
+static int iproc_mdiomux_read(struct mii_bus *bus, int phyid, int reg)
+{
+ struct iproc_mdiomux_desc *md = bus->priv;
+ int ret;
+
+ ret = start_miim_ops(md->base, phyid, reg, 0, MDIO_CTRL_READ_OP);
+ if (ret < 0)
+ dev_err(&bus->dev, "mdiomux read operation failed!!!");
+
+ return ret;
+}
+
+static int iproc_mdiomux_write(struct mii_bus *bus,
+ int phyid, int reg, u16 val)
+{
+ struct iproc_mdiomux_desc *md = bus->priv;
+ int ret;
+
+ /* Write val at reg offset */
+ ret = start_miim_ops(md->base, phyid, reg, val, MDIO_CTRL_WRITE_OP);
+ if (ret < 0)
+ dev_err(&bus->dev, "mdiomux write operation failed!!!");
+
+ return ret;
+}
+
+static int mdio_mux_iproc_switch_fn(int current_child, int desired_child,
+ void *data)
+{
+ struct iproc_mdiomux_desc *md = data;
+ u32 param, bus_id;
+ bool bus_dir;
+
+ /* select bus and its properties */
+ bus_dir = (desired_child < EXT_BUS_START_ADDR);
+ bus_id = bus_dir ? desired_child : (desired_child - EXT_BUS_START_ADDR);
+
+ param = (bus_dir ? 1 : 0) << MDIO_PARAM_INTERNAL_SEL;
+ param |= (bus_id << MDIO_PARAM_BUS_ID);
+
+ writel(param, md->base + MDIO_PARAM_OFFSET);
+ return 0;
+}
+
+static int mdio_mux_iproc_probe(struct platform_device *pdev)
+{
+ struct iproc_mdiomux_desc *md;
+ struct mii_bus *bus;
+ struct resource *res;
+ int rc;
+
+ md = devm_kzalloc(&pdev->dev, sizeof(*md), GFP_KERNEL);
+ if (!md)
+ return -ENOMEM;
+ md->dev = &pdev->dev;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (res->start & 0xfff) {
+ /* For backward compatibility in case the
+ * base address is specified with an offset.
+ */
+ dev_info(&pdev->dev, "fix base address in dt-blob\n");
+ res->start &= ~0xfff;
+ res->end = res->start + MDIO_REG_ADDR_SPACE_SIZE - 1;
+ }
+ md->base = devm_ioremap_resource(&pdev->dev, res);
+ if (IS_ERR(md->base)) {
+ dev_err(&pdev->dev, "failed to ioremap register\n");
+ return PTR_ERR(md->base);
+ }
+
+ md->mii_bus = devm_mdiobus_alloc(&pdev->dev);
+ if (!md->mii_bus) {
+ dev_err(&pdev->dev, "mdiomux bus alloc failed\n");
+ return -ENOMEM;
+ }
+
+ md->core_clk = devm_clk_get(&pdev->dev, NULL);
+ if (md->core_clk == ERR_PTR(-ENOENT) ||
+ md->core_clk == ERR_PTR(-EINVAL))
+ md->core_clk = NULL;
+ else if (IS_ERR(md->core_clk))
+ return PTR_ERR(md->core_clk);
+
+ rc = clk_prepare_enable(md->core_clk);
+ if (rc) {
+ dev_err(&pdev->dev, "failed to enable core clk\n");
+ return rc;
+ }
+
+ bus = md->mii_bus;
+ bus->priv = md;
+ bus->name = "iProc MDIO mux bus";
+ snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d", pdev->name, pdev->id);
+ bus->parent = &pdev->dev;
+ bus->read = iproc_mdiomux_read;
+ bus->write = iproc_mdiomux_write;
+
+ bus->phy_mask = ~0;
+ bus->dev.of_node = pdev->dev.of_node;
+ rc = mdiobus_register(bus);
+ if (rc) {
+ dev_err(&pdev->dev, "mdiomux registration failed\n");
+ goto out_clk;
+ }
+
+ platform_set_drvdata(pdev, md);
+
+ rc = mdio_mux_init(md->dev, md->dev->of_node, mdio_mux_iproc_switch_fn,
+ &md->mux_handle, md, md->mii_bus);
+ if (rc) {
+ dev_info(md->dev, "mdiomux initialization failed\n");
+ goto out_register;
+ }
+
+ mdio_mux_iproc_config(md);
+
+ dev_info(md->dev, "iProc mdiomux registered\n");
+ return 0;
+
+out_register:
+ mdiobus_unregister(bus);
+out_clk:
+ clk_disable_unprepare(md->core_clk);
+ return rc;
+}
+
+static int mdio_mux_iproc_remove(struct platform_device *pdev)
+{
+ struct iproc_mdiomux_desc *md = platform_get_drvdata(pdev);
+
+ mdio_mux_uninit(md->mux_handle);
+ mdiobus_unregister(md->mii_bus);
+ clk_disable_unprepare(md->core_clk);
+
+ return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int mdio_mux_iproc_suspend(struct device *dev)
+{
+ struct iproc_mdiomux_desc *md = dev_get_drvdata(dev);
+
+ clk_disable_unprepare(md->core_clk);
+
+ return 0;
+}
+
+static int mdio_mux_iproc_resume(struct device *dev)
+{
+ struct iproc_mdiomux_desc *md = dev_get_drvdata(dev);
+ int rc;
+
+ rc = clk_prepare_enable(md->core_clk);
+ if (rc) {
+ dev_err(md->dev, "failed to enable core clk\n");
+ return rc;
+ }
+ mdio_mux_iproc_config(md);
+
+ return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(mdio_mux_iproc_pm_ops,
+ mdio_mux_iproc_suspend, mdio_mux_iproc_resume);
+
+static const struct of_device_id mdio_mux_iproc_match[] = {
+ {
+ .compatible = "brcm,mdio-mux-iproc",
+ },
+ {},
+};
+MODULE_DEVICE_TABLE(of, mdio_mux_iproc_match);
+
+static struct platform_driver mdiomux_iproc_driver = {
+ .driver = {
+ .name = "mdio-mux-iproc",
+ .of_match_table = mdio_mux_iproc_match,
+ .pm = &mdio_mux_iproc_pm_ops,
+ },
+ .probe = mdio_mux_iproc_probe,
+ .remove = mdio_mux_iproc_remove,
+};
+
+module_platform_driver(mdiomux_iproc_driver);
+
+MODULE_DESCRIPTION("iProc MDIO Mux Bus Driver");
+MODULE_AUTHOR("Pramod Kumar <pramod.kumar@broadcom.com>");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2011, 2012 Cavium, Inc.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/device.h>
+#include <linux/of_mdio.h>
+#include <linux/module.h>
+#include <linux/phy.h>
+#include <linux/mdio-mux.h>
+#include <linux/gpio/consumer.h>
+
+#define DRV_VERSION "1.1"
+#define DRV_DESCRIPTION "GPIO controlled MDIO bus multiplexer driver"
+
+struct mdio_mux_gpio_state {
+ struct gpio_descs *gpios;
+ void *mux_handle;
+};
+
+static int mdio_mux_gpio_switch_fn(int current_child, int desired_child,
+ void *data)
+{
+ struct mdio_mux_gpio_state *s = data;
+ DECLARE_BITMAP(values, BITS_PER_TYPE(desired_child));
+
+ if (current_child == desired_child)
+ return 0;
+
+ values[0] = desired_child;
+
+ gpiod_set_array_value_cansleep(s->gpios->ndescs, s->gpios->desc,
+ s->gpios->info, values);
+
+ return 0;
+}
+
+static int mdio_mux_gpio_probe(struct platform_device *pdev)
+{
+ struct mdio_mux_gpio_state *s;
+ struct gpio_descs *gpios;
+ int r;
+
+ gpios = devm_gpiod_get_array(&pdev->dev, NULL, GPIOD_OUT_LOW);
+ if (IS_ERR(gpios))
+ return PTR_ERR(gpios);
+
+ s = devm_kzalloc(&pdev->dev, sizeof(*s), GFP_KERNEL);
+ if (!s)
+ return -ENOMEM;
+
+ s->gpios = gpios;
+
+ r = mdio_mux_init(&pdev->dev, pdev->dev.of_node,
+ mdio_mux_gpio_switch_fn, &s->mux_handle, s, NULL);
+
+ if (r != 0)
+ return r;
+
+ pdev->dev.platform_data = s;
+ return 0;
+}
+
+static int mdio_mux_gpio_remove(struct platform_device *pdev)
+{
+ struct mdio_mux_gpio_state *s = dev_get_platdata(&pdev->dev);
+ mdio_mux_uninit(s->mux_handle);
+ return 0;
+}
+
+static const struct of_device_id mdio_mux_gpio_match[] = {
+ {
+ .compatible = "mdio-mux-gpio",
+ },
+ {
+ /* Legacy compatible property. */
+ .compatible = "cavium,mdio-mux-sn74cbtlv3253",
+ },
+ {},
+};
+MODULE_DEVICE_TABLE(of, mdio_mux_gpio_match);
+
+static struct platform_driver mdio_mux_gpio_driver = {
+ .driver = {
+ .name = "mdio-mux-gpio",
+ .of_match_table = mdio_mux_gpio_match,
+ },
+ .probe = mdio_mux_gpio_probe,
+ .remove = mdio_mux_gpio_remove,
+};
+
+module_platform_driver(mdio_mux_gpio_driver);
+
+MODULE_DESCRIPTION(DRV_DESCRIPTION);
+MODULE_VERSION(DRV_VERSION);
+MODULE_AUTHOR("David Daney");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2019 Baylibre, SAS.
+ * Author: Jerome Brunet <jbrunet@baylibre.com>
+ */
+
+#include <linux/bitfield.h>
+#include <linux/clk.h>
+#include <linux/clk-provider.h>
+#include <linux/device.h>
+#include <linux/io.h>
+#include <linux/iopoll.h>
+#include <linux/mdio-mux.h>
+#include <linux/module.h>
+#include <linux/phy.h>
+#include <linux/platform_device.h>
+
+#define ETH_PLL_STS 0x40
+#define ETH_PLL_CTL0 0x44
+#define PLL_CTL0_LOCK_DIG BIT(30)
+#define PLL_CTL0_RST BIT(29)
+#define PLL_CTL0_EN BIT(28)
+#define PLL_CTL0_SEL BIT(23)
+#define PLL_CTL0_N GENMASK(14, 10)
+#define PLL_CTL0_M GENMASK(8, 0)
+#define PLL_LOCK_TIMEOUT 1000000
+#define PLL_MUX_NUM_PARENT 2
+#define ETH_PLL_CTL1 0x48
+#define ETH_PLL_CTL2 0x4c
+#define ETH_PLL_CTL3 0x50
+#define ETH_PLL_CTL4 0x54
+#define ETH_PLL_CTL5 0x58
+#define ETH_PLL_CTL6 0x5c
+#define ETH_PLL_CTL7 0x60
+
+#define ETH_PHY_CNTL0 0x80
+#define EPHY_G12A_ID 0x33010180
+#define ETH_PHY_CNTL1 0x84
+#define PHY_CNTL1_ST_MODE GENMASK(2, 0)
+#define PHY_CNTL1_ST_PHYADD GENMASK(7, 3)
+#define EPHY_DFLT_ADD 8
+#define PHY_CNTL1_MII_MODE GENMASK(15, 14)
+#define EPHY_MODE_RMII 0x1
+#define PHY_CNTL1_CLK_EN BIT(16)
+#define PHY_CNTL1_CLKFREQ BIT(17)
+#define PHY_CNTL1_PHY_ENB BIT(18)
+#define ETH_PHY_CNTL2 0x88
+#define PHY_CNTL2_USE_INTERNAL BIT(5)
+#define PHY_CNTL2_SMI_SRC_MAC BIT(6)
+#define PHY_CNTL2_RX_CLK_EPHY BIT(9)
+
+#define MESON_G12A_MDIO_EXTERNAL_ID 0
+#define MESON_G12A_MDIO_INTERNAL_ID 1
+
+struct g12a_mdio_mux {
+ bool pll_is_enabled;
+ void __iomem *regs;
+ void *mux_handle;
+ struct clk *pclk;
+ struct clk *pll;
+};
+
+struct g12a_ephy_pll {
+ void __iomem *base;
+ struct clk_hw hw;
+};
+
+#define g12a_ephy_pll_to_dev(_hw) \
+ container_of(_hw, struct g12a_ephy_pll, hw)
+
+static unsigned long g12a_ephy_pll_recalc_rate(struct clk_hw *hw,
+ unsigned long parent_rate)
+{
+ struct g12a_ephy_pll *pll = g12a_ephy_pll_to_dev(hw);
+ u32 val, m, n;
+
+ val = readl(pll->base + ETH_PLL_CTL0);
+ m = FIELD_GET(PLL_CTL0_M, val);
+ n = FIELD_GET(PLL_CTL0_N, val);
+
+ return parent_rate * m / n;
+}
+
+static int g12a_ephy_pll_enable(struct clk_hw *hw)
+{
+ struct g12a_ephy_pll *pll = g12a_ephy_pll_to_dev(hw);
+ u32 val = readl(pll->base + ETH_PLL_CTL0);
+
+ /* Apply both enable an reset */
+ val |= PLL_CTL0_RST | PLL_CTL0_EN;
+ writel(val, pll->base + ETH_PLL_CTL0);
+
+ /* Clear the reset to let PLL lock */
+ val &= ~PLL_CTL0_RST;
+ writel(val, pll->base + ETH_PLL_CTL0);
+
+ /* Poll on the digital lock instead of the usual analog lock
+ * This is done because bit 31 is unreliable on some SoC. Bit
+ * 31 may indicate that the PLL is not lock eventhough the clock
+ * is actually running
+ */
+ return readl_poll_timeout(pll->base + ETH_PLL_CTL0, val,
+ val & PLL_CTL0_LOCK_DIG, 0, PLL_LOCK_TIMEOUT);
+}
+
+static void g12a_ephy_pll_disable(struct clk_hw *hw)
+{
+ struct g12a_ephy_pll *pll = g12a_ephy_pll_to_dev(hw);
+ u32 val;
+
+ val = readl(pll->base + ETH_PLL_CTL0);
+ val &= ~PLL_CTL0_EN;
+ val |= PLL_CTL0_RST;
+ writel(val, pll->base + ETH_PLL_CTL0);
+}
+
+static int g12a_ephy_pll_is_enabled(struct clk_hw *hw)
+{
+ struct g12a_ephy_pll *pll = g12a_ephy_pll_to_dev(hw);
+ unsigned int val;
+
+ val = readl(pll->base + ETH_PLL_CTL0);
+
+ return (val & PLL_CTL0_LOCK_DIG) ? 1 : 0;
+}
+
+static int g12a_ephy_pll_init(struct clk_hw *hw)
+{
+ struct g12a_ephy_pll *pll = g12a_ephy_pll_to_dev(hw);
+
+ /* Apply PLL HW settings */
+ writel(0x29c0040a, pll->base + ETH_PLL_CTL0);
+ writel(0x927e0000, pll->base + ETH_PLL_CTL1);
+ writel(0xac5f49e5, pll->base + ETH_PLL_CTL2);
+ writel(0x00000000, pll->base + ETH_PLL_CTL3);
+ writel(0x00000000, pll->base + ETH_PLL_CTL4);
+ writel(0x20200000, pll->base + ETH_PLL_CTL5);
+ writel(0x0000c002, pll->base + ETH_PLL_CTL6);
+ writel(0x00000023, pll->base + ETH_PLL_CTL7);
+
+ return 0;
+}
+
+static const struct clk_ops g12a_ephy_pll_ops = {
+ .recalc_rate = g12a_ephy_pll_recalc_rate,
+ .is_enabled = g12a_ephy_pll_is_enabled,
+ .enable = g12a_ephy_pll_enable,
+ .disable = g12a_ephy_pll_disable,
+ .init = g12a_ephy_pll_init,
+};
+
+static int g12a_enable_internal_mdio(struct g12a_mdio_mux *priv)
+{
+ int ret;
+
+ /* Enable the phy clock */
+ if (!priv->pll_is_enabled) {
+ ret = clk_prepare_enable(priv->pll);
+ if (ret)
+ return ret;
+ }
+
+ priv->pll_is_enabled = true;
+
+ /* Initialize ephy control */
+ writel(EPHY_G12A_ID, priv->regs + ETH_PHY_CNTL0);
+ writel(FIELD_PREP(PHY_CNTL1_ST_MODE, 3) |
+ FIELD_PREP(PHY_CNTL1_ST_PHYADD, EPHY_DFLT_ADD) |
+ FIELD_PREP(PHY_CNTL1_MII_MODE, EPHY_MODE_RMII) |
+ PHY_CNTL1_CLK_EN |
+ PHY_CNTL1_CLKFREQ |
+ PHY_CNTL1_PHY_ENB,
+ priv->regs + ETH_PHY_CNTL1);
+ writel(PHY_CNTL2_USE_INTERNAL |
+ PHY_CNTL2_SMI_SRC_MAC |
+ PHY_CNTL2_RX_CLK_EPHY,
+ priv->regs + ETH_PHY_CNTL2);
+
+ return 0;
+}
+
+static int g12a_enable_external_mdio(struct g12a_mdio_mux *priv)
+{
+ /* Reset the mdio bus mux */
+ writel_relaxed(0x0, priv->regs + ETH_PHY_CNTL2);
+
+ /* Disable the phy clock if enabled */
+ if (priv->pll_is_enabled) {
+ clk_disable_unprepare(priv->pll);
+ priv->pll_is_enabled = false;
+ }
+
+ return 0;
+}
+
+static int g12a_mdio_switch_fn(int current_child, int desired_child,
+ void *data)
+{
+ struct g12a_mdio_mux *priv = dev_get_drvdata(data);
+
+ if (current_child == desired_child)
+ return 0;
+
+ switch (desired_child) {
+ case MESON_G12A_MDIO_EXTERNAL_ID:
+ return g12a_enable_external_mdio(priv);
+ case MESON_G12A_MDIO_INTERNAL_ID:
+ return g12a_enable_internal_mdio(priv);
+ default:
+ return -EINVAL;
+ }
+}
+
+static const struct of_device_id g12a_mdio_mux_match[] = {
+ { .compatible = "amlogic,g12a-mdio-mux", },
+ {},
+};
+MODULE_DEVICE_TABLE(of, g12a_mdio_mux_match);
+
+static int g12a_ephy_glue_clk_register(struct device *dev)
+{
+ struct g12a_mdio_mux *priv = dev_get_drvdata(dev);
+ const char *parent_names[PLL_MUX_NUM_PARENT];
+ struct clk_init_data init;
+ struct g12a_ephy_pll *pll;
+ struct clk_mux *mux;
+ struct clk *clk;
+ char *name;
+ int i;
+
+ /* get the mux parents */
+ for (i = 0; i < PLL_MUX_NUM_PARENT; i++) {
+ char in_name[8];
+
+ snprintf(in_name, sizeof(in_name), "clkin%d", i);
+ clk = devm_clk_get(dev, in_name);
+ if (IS_ERR(clk)) {
+ if (PTR_ERR(clk) != -EPROBE_DEFER)
+ dev_err(dev, "Missing clock %s\n", in_name);
+ return PTR_ERR(clk);
+ }
+
+ parent_names[i] = __clk_get_name(clk);
+ }
+
+ /* create the input mux */
+ mux = devm_kzalloc(dev, sizeof(*mux), GFP_KERNEL);
+ if (!mux)
+ return -ENOMEM;
+
+ name = kasprintf(GFP_KERNEL, "%s#mux", dev_name(dev));
+ if (!name)
+ return -ENOMEM;
+
+ init.name = name;
+ init.ops = &clk_mux_ro_ops;
+ init.flags = 0;
+ init.parent_names = parent_names;
+ init.num_parents = PLL_MUX_NUM_PARENT;
+
+ mux->reg = priv->regs + ETH_PLL_CTL0;
+ mux->shift = __ffs(PLL_CTL0_SEL);
+ mux->mask = PLL_CTL0_SEL >> mux->shift;
+ mux->hw.init = &init;
+
+ clk = devm_clk_register(dev, &mux->hw);
+ kfree(name);
+ if (IS_ERR(clk)) {
+ dev_err(dev, "failed to register input mux\n");
+ return PTR_ERR(clk);
+ }
+
+ /* create the pll */
+ pll = devm_kzalloc(dev, sizeof(*pll), GFP_KERNEL);
+ if (!pll)
+ return -ENOMEM;
+
+ name = kasprintf(GFP_KERNEL, "%s#pll", dev_name(dev));
+ if (!name)
+ return -ENOMEM;
+
+ init.name = name;
+ init.ops = &g12a_ephy_pll_ops;
+ init.flags = 0;
+ parent_names[0] = __clk_get_name(clk);
+ init.parent_names = parent_names;
+ init.num_parents = 1;
+
+ pll->base = priv->regs;
+ pll->hw.init = &init;
+
+ clk = devm_clk_register(dev, &pll->hw);
+ kfree(name);
+ if (IS_ERR(clk)) {
+ dev_err(dev, "failed to register input mux\n");
+ return PTR_ERR(clk);
+ }
+
+ priv->pll = clk;
+
+ return 0;
+}
+
+static int g12a_mdio_mux_probe(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct g12a_mdio_mux *priv;
+ int ret;
+
+ priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ platform_set_drvdata(pdev, priv);
+
+ priv->regs = devm_platform_ioremap_resource(pdev, 0);
+ if (IS_ERR(priv->regs))
+ return PTR_ERR(priv->regs);
+
+ priv->pclk = devm_clk_get(dev, "pclk");
+ if (IS_ERR(priv->pclk)) {
+ ret = PTR_ERR(priv->pclk);
+ if (ret != -EPROBE_DEFER)
+ dev_err(dev, "failed to get peripheral clock\n");
+ return ret;
+ }
+
+ /* Make sure the device registers are clocked */
+ ret = clk_prepare_enable(priv->pclk);
+ if (ret) {
+ dev_err(dev, "failed to enable peripheral clock");
+ return ret;
+ }
+
+ /* Register PLL in CCF */
+ ret = g12a_ephy_glue_clk_register(dev);
+ if (ret)
+ goto err;
+
+ ret = mdio_mux_init(dev, dev->of_node, g12a_mdio_switch_fn,
+ &priv->mux_handle, dev, NULL);
+ if (ret) {
+ if (ret != -EPROBE_DEFER)
+ dev_err(dev, "mdio multiplexer init failed: %d", ret);
+ goto err;
+ }
+
+ return 0;
+
+err:
+ clk_disable_unprepare(priv->pclk);
+ return ret;
+}
+
+static int g12a_mdio_mux_remove(struct platform_device *pdev)
+{
+ struct g12a_mdio_mux *priv = platform_get_drvdata(pdev);
+
+ mdio_mux_uninit(priv->mux_handle);
+
+ if (priv->pll_is_enabled)
+ clk_disable_unprepare(priv->pll);
+
+ clk_disable_unprepare(priv->pclk);
+
+ return 0;
+}
+
+static struct platform_driver g12a_mdio_mux_driver = {
+ .probe = g12a_mdio_mux_probe,
+ .remove = g12a_mdio_mux_remove,
+ .driver = {
+ .name = "g12a-mdio_mux",
+ .of_match_table = g12a_mdio_mux_match,
+ },
+};
+module_platform_driver(g12a_mdio_mux_driver);
+
+MODULE_DESCRIPTION("Amlogic G12a MDIO multiplexer driver");
+MODULE_AUTHOR("Jerome Brunet <jbrunet@baylibre.com>");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Simple memory-mapped device MDIO MUX driver
+ *
+ * Author: Timur Tabi <timur@freescale.com>
+ *
+ * Copyright 2012 Freescale Semiconductor, Inc.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/device.h>
+#include <linux/of_address.h>
+#include <linux/of_mdio.h>
+#include <linux/module.h>
+#include <linux/phy.h>
+#include <linux/mdio-mux.h>
+
+struct mdio_mux_mmioreg_state {
+ void *mux_handle;
+ phys_addr_t phys;
+ unsigned int iosize;
+ unsigned int mask;
+};
+
+/*
+ * MDIO multiplexing switch function
+ *
+ * This function is called by the mdio-mux layer when it thinks the mdio bus
+ * multiplexer needs to switch.
+ *
+ * 'current_child' is the current value of the mux register (masked via
+ * s->mask).
+ *
+ * 'desired_child' is the value of the 'reg' property of the target child MDIO
+ * node.
+ *
+ * The first time this function is called, current_child == -1.
+ *
+ * If current_child == desired_child, then the mux is already set to the
+ * correct bus.
+ */
+static int mdio_mux_mmioreg_switch_fn(int current_child, int desired_child,
+ void *data)
+{
+ struct mdio_mux_mmioreg_state *s = data;
+
+ if (current_child ^ desired_child) {
+ void __iomem *p = ioremap(s->phys, s->iosize);
+ if (!p)
+ return -ENOMEM;
+
+ switch (s->iosize) {
+ case sizeof(uint8_t): {
+ uint8_t x, y;
+
+ x = ioread8(p);
+ y = (x & ~s->mask) | desired_child;
+ if (x != y) {
+ iowrite8((x & ~s->mask) | desired_child, p);
+ pr_debug("%s: %02x -> %02x\n", __func__, x, y);
+ }
+
+ break;
+ }
+ case sizeof(uint16_t): {
+ uint16_t x, y;
+
+ x = ioread16(p);
+ y = (x & ~s->mask) | desired_child;
+ if (x != y) {
+ iowrite16((x & ~s->mask) | desired_child, p);
+ pr_debug("%s: %04x -> %04x\n", __func__, x, y);
+ }
+
+ break;
+ }
+ case sizeof(uint32_t): {
+ uint32_t x, y;
+
+ x = ioread32(p);
+ y = (x & ~s->mask) | desired_child;
+ if (x != y) {
+ iowrite32((x & ~s->mask) | desired_child, p);
+ pr_debug("%s: %08x -> %08x\n", __func__, x, y);
+ }
+
+ break;
+ }
+ }
+
+ iounmap(p);
+ }
+
+ return 0;
+}
+
+static int mdio_mux_mmioreg_probe(struct platform_device *pdev)
+{
+ struct device_node *np2, *np = pdev->dev.of_node;
+ struct mdio_mux_mmioreg_state *s;
+ struct resource res;
+ const __be32 *iprop;
+ int len, ret;
+
+ dev_dbg(&pdev->dev, "probing node %pOF\n", np);
+
+ s = devm_kzalloc(&pdev->dev, sizeof(*s), GFP_KERNEL);
+ if (!s)
+ return -ENOMEM;
+
+ ret = of_address_to_resource(np, 0, &res);
+ if (ret) {
+ dev_err(&pdev->dev, "could not obtain memory map for node %pOF\n",
+ np);
+ return ret;
+ }
+ s->phys = res.start;
+
+ s->iosize = resource_size(&res);
+ if (s->iosize != sizeof(uint8_t) &&
+ s->iosize != sizeof(uint16_t) &&
+ s->iosize != sizeof(uint32_t)) {
+ dev_err(&pdev->dev, "only 8/16/32-bit registers are supported\n");
+ return -EINVAL;
+ }
+
+ iprop = of_get_property(np, "mux-mask", &len);
+ if (!iprop || len != sizeof(uint32_t)) {
+ dev_err(&pdev->dev, "missing or invalid mux-mask property\n");
+ return -ENODEV;
+ }
+ if (be32_to_cpup(iprop) >= BIT(s->iosize * 8)) {
+ dev_err(&pdev->dev, "only 8/16/32-bit registers are supported\n");
+ return -EINVAL;
+ }
+ s->mask = be32_to_cpup(iprop);
+
+ /*
+ * Verify that the 'reg' property of each child MDIO bus does not
+ * set any bits outside of the 'mask'.
+ */
+ for_each_available_child_of_node(np, np2) {
+ iprop = of_get_property(np2, "reg", &len);
+ if (!iprop || len != sizeof(uint32_t)) {
+ dev_err(&pdev->dev, "mdio-mux child node %pOF is "
+ "missing a 'reg' property\n", np2);
+ of_node_put(np2);
+ return -ENODEV;
+ }
+ if (be32_to_cpup(iprop) & ~s->mask) {
+ dev_err(&pdev->dev, "mdio-mux child node %pOF has "
+ "a 'reg' value with unmasked bits\n",
+ np2);
+ of_node_put(np2);
+ return -ENODEV;
+ }
+ }
+
+ ret = mdio_mux_init(&pdev->dev, pdev->dev.of_node,
+ mdio_mux_mmioreg_switch_fn,
+ &s->mux_handle, s, NULL);
+ if (ret) {
+ if (ret != -EPROBE_DEFER)
+ dev_err(&pdev->dev,
+ "failed to register mdio-mux bus %pOF\n", np);
+ return ret;
+ }
+
+ pdev->dev.platform_data = s;
+
+ return 0;
+}
+
+static int mdio_mux_mmioreg_remove(struct platform_device *pdev)
+{
+ struct mdio_mux_mmioreg_state *s = dev_get_platdata(&pdev->dev);
+
+ mdio_mux_uninit(s->mux_handle);
+
+ return 0;
+}
+
+static const struct of_device_id mdio_mux_mmioreg_match[] = {
+ {
+ .compatible = "mdio-mux-mmioreg",
+ },
+ {},
+};
+MODULE_DEVICE_TABLE(of, mdio_mux_mmioreg_match);
+
+static struct platform_driver mdio_mux_mmioreg_driver = {
+ .driver = {
+ .name = "mdio-mux-mmioreg",
+ .of_match_table = mdio_mux_mmioreg_match,
+ },
+ .probe = mdio_mux_mmioreg_probe,
+ .remove = mdio_mux_mmioreg_remove,
+};
+
+module_platform_driver(mdio_mux_mmioreg_driver);
+
+MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
+MODULE_DESCRIPTION("Memory-mapped device MDIO MUX driver");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0+
+/* MDIO bus multiplexer using kernel multiplexer subsystem
+ *
+ * Copyright 2019 NXP
+ */
+
+#include <linux/platform_device.h>
+#include <linux/mdio-mux.h>
+#include <linux/module.h>
+#include <linux/mux/consumer.h>
+
+struct mdio_mux_multiplexer_state {
+ struct mux_control *muxc;
+ bool do_deselect;
+ void *mux_handle;
+};
+
+/**
+ * mdio_mux_multiplexer_switch_fn - This function is called by the mdio-mux
+ * layer when it thinks the mdio bus
+ * multiplexer needs to switch.
+ * @current_child: current value of the mux register.
+ * @desired_child: value of the 'reg' property of the target child MDIO node.
+ * @data: Private data used by this switch_fn passed to mdio_mux_init function
+ * via mdio_mux_init(.., .., .., .., data, ..).
+ *
+ * The first time this function is called, current_child == -1.
+ * If current_child == desired_child, then the mux is already set to the
+ * correct bus.
+ */
+static int mdio_mux_multiplexer_switch_fn(int current_child, int desired_child,
+ void *data)
+{
+ struct platform_device *pdev;
+ struct mdio_mux_multiplexer_state *s;
+ int ret = 0;
+
+ pdev = (struct platform_device *)data;
+ s = platform_get_drvdata(pdev);
+
+ if (!(current_child ^ desired_child))
+ return 0;
+
+ if (s->do_deselect)
+ ret = mux_control_deselect(s->muxc);
+ if (ret) {
+ dev_err(&pdev->dev, "mux_control_deselect failed in %s: %d\n",
+ __func__, ret);
+ return ret;
+ }
+
+ ret = mux_control_select(s->muxc, desired_child);
+ if (!ret) {
+ dev_dbg(&pdev->dev, "%s %d -> %d\n", __func__, current_child,
+ desired_child);
+ s->do_deselect = true;
+ } else {
+ s->do_deselect = false;
+ }
+
+ return ret;
+}
+
+static int mdio_mux_multiplexer_probe(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct mdio_mux_multiplexer_state *s;
+ int ret = 0;
+
+ s = devm_kzalloc(&pdev->dev, sizeof(*s), GFP_KERNEL);
+ if (!s)
+ return -ENOMEM;
+
+ s->muxc = devm_mux_control_get(dev, NULL);
+ if (IS_ERR(s->muxc)) {
+ ret = PTR_ERR(s->muxc);
+ if (ret != -EPROBE_DEFER)
+ dev_err(&pdev->dev, "Failed to get mux: %d\n", ret);
+ return ret;
+ }
+
+ platform_set_drvdata(pdev, s);
+
+ ret = mdio_mux_init(&pdev->dev, pdev->dev.of_node,
+ mdio_mux_multiplexer_switch_fn, &s->mux_handle,
+ pdev, NULL);
+
+ return ret;
+}
+
+static int mdio_mux_multiplexer_remove(struct platform_device *pdev)
+{
+ struct mdio_mux_multiplexer_state *s = platform_get_drvdata(pdev);
+
+ mdio_mux_uninit(s->mux_handle);
+
+ if (s->do_deselect)
+ mux_control_deselect(s->muxc);
+
+ return 0;
+}
+
+static const struct of_device_id mdio_mux_multiplexer_match[] = {
+ { .compatible = "mdio-mux-multiplexer", },
+ {},
+};
+MODULE_DEVICE_TABLE(of, mdio_mux_multiplexer_match);
+
+static struct platform_driver mdio_mux_multiplexer_driver = {
+ .driver = {
+ .name = "mdio-mux-multiplexer",
+ .of_match_table = mdio_mux_multiplexer_match,
+ },
+ .probe = mdio_mux_multiplexer_probe,
+ .remove = mdio_mux_multiplexer_remove,
+};
+
+module_platform_driver(mdio_mux_multiplexer_driver);
+
+MODULE_DESCRIPTION("MDIO bus multiplexer using kernel multiplexer subsystem");
+MODULE_AUTHOR("Pankaj Bansal <pankaj.bansal@nxp.com>");
+MODULE_LICENSE("GPL");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2011, 2012 Cavium, Inc.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/mdio-mux.h>
+#include <linux/of_mdio.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/phy.h>
+
+#define DRV_DESCRIPTION "MDIO bus multiplexer driver"
+
+struct mdio_mux_child_bus;
+
+struct mdio_mux_parent_bus {
+ struct mii_bus *mii_bus;
+ int current_child;
+ int parent_id;
+ void *switch_data;
+ int (*switch_fn)(int current_child, int desired_child, void *data);
+
+ /* List of our children linked through their next fields. */
+ struct mdio_mux_child_bus *children;
+};
+
+struct mdio_mux_child_bus {
+ struct mii_bus *mii_bus;
+ struct mdio_mux_parent_bus *parent;
+ struct mdio_mux_child_bus *next;
+ int bus_number;
+};
+
+/*
+ * The parent bus' lock is used to order access to the switch_fn.
+ */
+static int mdio_mux_read(struct mii_bus *bus, int phy_id, int regnum)
+{
+ struct mdio_mux_child_bus *cb = bus->priv;
+ struct mdio_mux_parent_bus *pb = cb->parent;
+ int r;
+
+ mutex_lock_nested(&pb->mii_bus->mdio_lock, MDIO_MUTEX_MUX);
+ r = pb->switch_fn(pb->current_child, cb->bus_number, pb->switch_data);
+ if (r)
+ goto out;
+
+ pb->current_child = cb->bus_number;
+
+ r = pb->mii_bus->read(pb->mii_bus, phy_id, regnum);
+out:
+ mutex_unlock(&pb->mii_bus->mdio_lock);
+
+ return r;
+}
+
+/*
+ * The parent bus' lock is used to order access to the switch_fn.
+ */
+static int mdio_mux_write(struct mii_bus *bus, int phy_id,
+ int regnum, u16 val)
+{
+ struct mdio_mux_child_bus *cb = bus->priv;
+ struct mdio_mux_parent_bus *pb = cb->parent;
+
+ int r;
+
+ mutex_lock_nested(&pb->mii_bus->mdio_lock, MDIO_MUTEX_MUX);
+ r = pb->switch_fn(pb->current_child, cb->bus_number, pb->switch_data);
+ if (r)
+ goto out;
+
+ pb->current_child = cb->bus_number;
+
+ r = pb->mii_bus->write(pb->mii_bus, phy_id, regnum, val);
+out:
+ mutex_unlock(&pb->mii_bus->mdio_lock);
+
+ return r;
+}
+
+static int parent_count;
+
+int mdio_mux_init(struct device *dev,
+ struct device_node *mux_node,
+ int (*switch_fn)(int cur, int desired, void *data),
+ void **mux_handle,
+ void *data,
+ struct mii_bus *mux_bus)
+{
+ struct device_node *parent_bus_node;
+ struct device_node *child_bus_node;
+ int r, ret_val;
+ struct mii_bus *parent_bus;
+ struct mdio_mux_parent_bus *pb;
+ struct mdio_mux_child_bus *cb;
+
+ if (!mux_node)
+ return -ENODEV;
+
+ if (!mux_bus) {
+ parent_bus_node = of_parse_phandle(mux_node,
+ "mdio-parent-bus", 0);
+
+ if (!parent_bus_node)
+ return -ENODEV;
+
+ parent_bus = of_mdio_find_bus(parent_bus_node);
+ if (!parent_bus) {
+ ret_val = -EPROBE_DEFER;
+ goto err_parent_bus;
+ }
+ } else {
+ parent_bus_node = NULL;
+ parent_bus = mux_bus;
+ get_device(&parent_bus->dev);
+ }
+
+ pb = devm_kzalloc(dev, sizeof(*pb), GFP_KERNEL);
+ if (!pb) {
+ ret_val = -ENOMEM;
+ goto err_pb_kz;
+ }
+
+ pb->switch_data = data;
+ pb->switch_fn = switch_fn;
+ pb->current_child = -1;
+ pb->parent_id = parent_count++;
+ pb->mii_bus = parent_bus;
+
+ ret_val = -ENODEV;
+ for_each_available_child_of_node(mux_node, child_bus_node) {
+ int v;
+
+ r = of_property_read_u32(child_bus_node, "reg", &v);
+ if (r) {
+ dev_err(dev,
+ "Error: Failed to find reg for child %pOF\n",
+ child_bus_node);
+ continue;
+ }
+
+ cb = devm_kzalloc(dev, sizeof(*cb), GFP_KERNEL);
+ if (!cb) {
+ ret_val = -ENOMEM;
+ continue;
+ }
+ cb->bus_number = v;
+ cb->parent = pb;
+
+ cb->mii_bus = mdiobus_alloc();
+ if (!cb->mii_bus) {
+ ret_val = -ENOMEM;
+ devm_kfree(dev, cb);
+ continue;
+ }
+ cb->mii_bus->priv = cb;
+
+ cb->mii_bus->name = "mdio_mux";
+ snprintf(cb->mii_bus->id, MII_BUS_ID_SIZE, "%x.%x",
+ pb->parent_id, v);
+ cb->mii_bus->parent = dev;
+ cb->mii_bus->read = mdio_mux_read;
+ cb->mii_bus->write = mdio_mux_write;
+ r = of_mdiobus_register(cb->mii_bus, child_bus_node);
+ if (r) {
+ dev_err(dev,
+ "Error: Failed to register MDIO bus for child %pOF\n",
+ child_bus_node);
+ mdiobus_free(cb->mii_bus);
+ devm_kfree(dev, cb);
+ } else {
+ cb->next = pb->children;
+ pb->children = cb;
+ }
+ }
+ if (pb->children) {
+ *mux_handle = pb;
+ return 0;
+ }
+
+ dev_err(dev, "Error: No acceptable child buses found\n");
+ devm_kfree(dev, pb);
+err_pb_kz:
+ put_device(&parent_bus->dev);
+err_parent_bus:
+ of_node_put(parent_bus_node);
+ return ret_val;
+}
+EXPORT_SYMBOL_GPL(mdio_mux_init);
+
+void mdio_mux_uninit(void *mux_handle)
+{
+ struct mdio_mux_parent_bus *pb = mux_handle;
+ struct mdio_mux_child_bus *cb = pb->children;
+
+ while (cb) {
+ mdiobus_unregister(cb->mii_bus);
+ mdiobus_free(cb->mii_bus);
+ cb = cb->next;
+ }
+
+ put_device(&pb->mii_bus->dev);
+}
+EXPORT_SYMBOL_GPL(mdio_mux_uninit);
+
+MODULE_DESCRIPTION(DRV_DESCRIPTION);
+MODULE_AUTHOR("David Daney");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of_mdio.h>
+#include <linux/phy.h>
+#include <linux/usb.h>
+
+#define USB_MARVELL_VID 0x1286
+
+static const struct usb_device_id mvusb_mdio_table[] = {
+ { USB_DEVICE(USB_MARVELL_VID, 0x1fa4) },
+
+ {}
+};
+MODULE_DEVICE_TABLE(usb, mvusb_mdio_table);
+
+enum {
+ MVUSB_CMD_PREAMBLE0,
+ MVUSB_CMD_PREAMBLE1,
+ MVUSB_CMD_ADDR,
+ MVUSB_CMD_VAL,
+};
+
+struct mvusb_mdio {
+ struct usb_device *udev;
+ struct mii_bus *mdio;
+
+ __le16 buf[4];
+};
+
+static int mvusb_mdio_read(struct mii_bus *mdio, int dev, int reg)
+{
+ struct mvusb_mdio *mvusb = mdio->priv;
+ int err, alen;
+
+ if (dev & MII_ADDR_C45)
+ return -EOPNOTSUPP;
+
+ mvusb->buf[MVUSB_CMD_ADDR] = cpu_to_le16(0xa400 | (dev << 5) | reg);
+
+ err = usb_bulk_msg(mvusb->udev, usb_sndbulkpipe(mvusb->udev, 2),
+ mvusb->buf, 6, &alen, 100);
+ if (err)
+ return err;
+
+ err = usb_bulk_msg(mvusb->udev, usb_rcvbulkpipe(mvusb->udev, 6),
+ &mvusb->buf[MVUSB_CMD_VAL], 2, &alen, 100);
+ if (err)
+ return err;
+
+ return le16_to_cpu(mvusb->buf[MVUSB_CMD_VAL]);
+}
+
+static int mvusb_mdio_write(struct mii_bus *mdio, int dev, int reg, u16 val)
+{
+ struct mvusb_mdio *mvusb = mdio->priv;
+ int alen;
+
+ if (dev & MII_ADDR_C45)
+ return -EOPNOTSUPP;
+
+ mvusb->buf[MVUSB_CMD_ADDR] = cpu_to_le16(0x8000 | (dev << 5) | reg);
+ mvusb->buf[MVUSB_CMD_VAL] = cpu_to_le16(val);
+
+ return usb_bulk_msg(mvusb->udev, usb_sndbulkpipe(mvusb->udev, 2),
+ mvusb->buf, 8, &alen, 100);
+}
+
+static int mvusb_mdio_probe(struct usb_interface *interface,
+ const struct usb_device_id *id)
+{
+ struct device *dev = &interface->dev;
+ struct mvusb_mdio *mvusb;
+ struct mii_bus *mdio;
+
+ mdio = devm_mdiobus_alloc_size(dev, sizeof(*mvusb));
+ if (!mdio)
+ return -ENOMEM;
+
+ mvusb = mdio->priv;
+ mvusb->mdio = mdio;
+ mvusb->udev = usb_get_dev(interface_to_usbdev(interface));
+
+ /* Reversed from USB PCAPs, no idea what these mean. */
+ mvusb->buf[MVUSB_CMD_PREAMBLE0] = cpu_to_le16(0xe800);
+ mvusb->buf[MVUSB_CMD_PREAMBLE1] = cpu_to_le16(0x0001);
+
+ snprintf(mdio->id, MII_BUS_ID_SIZE, "mvusb-%s", dev_name(dev));
+ mdio->name = mdio->id;
+ mdio->parent = dev;
+ mdio->read = mvusb_mdio_read;
+ mdio->write = mvusb_mdio_write;
+
+ usb_set_intfdata(interface, mvusb);
+ return of_mdiobus_register(mdio, dev->of_node);
+}
+
+static void mvusb_mdio_disconnect(struct usb_interface *interface)
+{
+ struct mvusb_mdio *mvusb = usb_get_intfdata(interface);
+ struct usb_device *udev = mvusb->udev;
+
+ mdiobus_unregister(mvusb->mdio);
+ usb_set_intfdata(interface, NULL);
+ usb_put_dev(udev);
+}
+
+static struct usb_driver mvusb_mdio_driver = {
+ .name = "mvusb_mdio",
+ .id_table = mvusb_mdio_table,
+ .probe = mvusb_mdio_probe,
+ .disconnect = mvusb_mdio_disconnect,
+};
+
+module_usb_driver(mvusb_mdio_driver);
+
+MODULE_AUTHOR("Tobias Waldekranz <tobias@waldekranz.com>");
+MODULE_DESCRIPTION("Marvell USB MDIO Adapter");
+MODULE_LICENSE("GPL");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2009-2015 Cavium, Inc.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/of_address.h>
+#include <linux/of_mdio.h>
+#include <linux/module.h>
+#include <linux/gfp.h>
+#include <linux/phy.h>
+#include <linux/io.h>
+
+#include "mdio-cavium.h"
+
+static int octeon_mdiobus_probe(struct platform_device *pdev)
+{
+ struct cavium_mdiobus *bus;
+ struct mii_bus *mii_bus;
+ struct resource *res_mem;
+ resource_size_t mdio_phys;
+ resource_size_t regsize;
+ union cvmx_smix_en smi_en;
+ int err = -ENOENT;
+
+ mii_bus = devm_mdiobus_alloc_size(&pdev->dev, sizeof(*bus));
+ if (!mii_bus)
+ return -ENOMEM;
+
+ res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (res_mem == NULL) {
+ dev_err(&pdev->dev, "found no memory resource\n");
+ return -ENXIO;
+ }
+
+ bus = mii_bus->priv;
+ bus->mii_bus = mii_bus;
+ mdio_phys = res_mem->start;
+ regsize = resource_size(res_mem);
+
+ if (!devm_request_mem_region(&pdev->dev, mdio_phys, regsize,
+ res_mem->name)) {
+ dev_err(&pdev->dev, "request_mem_region failed\n");
+ return -ENXIO;
+ }
+
+ bus->register_base = devm_ioremap(&pdev->dev, mdio_phys, regsize);
+ if (!bus->register_base) {
+ dev_err(&pdev->dev, "dev_ioremap failed\n");
+ return -ENOMEM;
+ }
+
+ smi_en.u64 = 0;
+ smi_en.s.en = 1;
+ oct_mdio_writeq(smi_en.u64, bus->register_base + SMI_EN);
+
+ bus->mii_bus->name = KBUILD_MODNAME;
+ snprintf(bus->mii_bus->id, MII_BUS_ID_SIZE, "%px", bus->register_base);
+ bus->mii_bus->parent = &pdev->dev;
+
+ bus->mii_bus->read = cavium_mdiobus_read;
+ bus->mii_bus->write = cavium_mdiobus_write;
+
+ platform_set_drvdata(pdev, bus);
+
+ err = of_mdiobus_register(bus->mii_bus, pdev->dev.of_node);
+ if (err)
+ goto fail_register;
+
+ dev_info(&pdev->dev, "Probed\n");
+
+ return 0;
+fail_register:
+ mdiobus_free(bus->mii_bus);
+ smi_en.u64 = 0;
+ oct_mdio_writeq(smi_en.u64, bus->register_base + SMI_EN);
+ return err;
+}
+
+static int octeon_mdiobus_remove(struct platform_device *pdev)
+{
+ struct cavium_mdiobus *bus;
+ union cvmx_smix_en smi_en;
+
+ bus = platform_get_drvdata(pdev);
+
+ mdiobus_unregister(bus->mii_bus);
+ mdiobus_free(bus->mii_bus);
+ smi_en.u64 = 0;
+ oct_mdio_writeq(smi_en.u64, bus->register_base + SMI_EN);
+ return 0;
+}
+
+static const struct of_device_id octeon_mdiobus_match[] = {
+ {
+ .compatible = "cavium,octeon-3860-mdio",
+ },
+ {},
+};
+MODULE_DEVICE_TABLE(of, octeon_mdiobus_match);
+
+static struct platform_driver octeon_mdiobus_driver = {
+ .driver = {
+ .name = KBUILD_MODNAME,
+ .of_match_table = octeon_mdiobus_match,
+ },
+ .probe = octeon_mdiobus_probe,
+ .remove = octeon_mdiobus_remove,
+};
+
+module_platform_driver(octeon_mdiobus_driver);
+
+MODULE_DESCRIPTION("Cavium OCTEON MDIO bus driver");
+MODULE_AUTHOR("David Daney");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Allwinner EMAC MDIO interface driver
+ *
+ * Copyright 2012-2013 Stefan Roese <sr@denx.de>
+ * Copyright 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
+ *
+ * Based on the Linux driver provided by Allwinner:
+ * Copyright (C) 1997 Sten Wang
+ */
+
+#include <linux/delay.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of_address.h>
+#include <linux/of_mdio.h>
+#include <linux/phy.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+
+#define EMAC_MAC_MCMD_REG (0x00)
+#define EMAC_MAC_MADR_REG (0x04)
+#define EMAC_MAC_MWTD_REG (0x08)
+#define EMAC_MAC_MRDD_REG (0x0c)
+#define EMAC_MAC_MIND_REG (0x10)
+#define EMAC_MAC_SSRR_REG (0x14)
+
+#define MDIO_TIMEOUT (msecs_to_jiffies(100))
+
+struct sun4i_mdio_data {
+ void __iomem *membase;
+ struct regulator *regulator;
+};
+
+static int sun4i_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
+{
+ struct sun4i_mdio_data *data = bus->priv;
+ unsigned long timeout_jiffies;
+ int value;
+
+ /* issue the phy address and reg */
+ writel((mii_id << 8) | regnum, data->membase + EMAC_MAC_MADR_REG);
+ /* pull up the phy io line */
+ writel(0x1, data->membase + EMAC_MAC_MCMD_REG);
+
+ /* Wait read complete */
+ timeout_jiffies = jiffies + MDIO_TIMEOUT;
+ while (readl(data->membase + EMAC_MAC_MIND_REG) & 0x1) {
+ if (time_is_before_jiffies(timeout_jiffies))
+ return -ETIMEDOUT;
+ msleep(1);
+ }
+
+ /* push down the phy io line */
+ writel(0x0, data->membase + EMAC_MAC_MCMD_REG);
+ /* and read data */
+ value = readl(data->membase + EMAC_MAC_MRDD_REG);
+
+ return value;
+}
+
+static int sun4i_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
+ u16 value)
+{
+ struct sun4i_mdio_data *data = bus->priv;
+ unsigned long timeout_jiffies;
+
+ /* issue the phy address and reg */
+ writel((mii_id << 8) | regnum, data->membase + EMAC_MAC_MADR_REG);
+ /* pull up the phy io line */
+ writel(0x1, data->membase + EMAC_MAC_MCMD_REG);
+
+ /* Wait read complete */
+ timeout_jiffies = jiffies + MDIO_TIMEOUT;
+ while (readl(data->membase + EMAC_MAC_MIND_REG) & 0x1) {
+ if (time_is_before_jiffies(timeout_jiffies))
+ return -ETIMEDOUT;
+ msleep(1);
+ }
+
+ /* push down the phy io line */
+ writel(0x0, data->membase + EMAC_MAC_MCMD_REG);
+ /* and write data */
+ writel(value, data->membase + EMAC_MAC_MWTD_REG);
+
+ return 0;
+}
+
+static int sun4i_mdio_probe(struct platform_device *pdev)
+{
+ struct device_node *np = pdev->dev.of_node;
+ struct mii_bus *bus;
+ struct sun4i_mdio_data *data;
+ int ret;
+
+ bus = mdiobus_alloc_size(sizeof(*data));
+ if (!bus)
+ return -ENOMEM;
+
+ bus->name = "sun4i_mii_bus";
+ bus->read = &sun4i_mdio_read;
+ bus->write = &sun4i_mdio_write;
+ snprintf(bus->id, MII_BUS_ID_SIZE, "%s-mii", dev_name(&pdev->dev));
+ bus->parent = &pdev->dev;
+
+ data = bus->priv;
+ data->membase = devm_platform_ioremap_resource(pdev, 0);
+ if (IS_ERR(data->membase)) {
+ ret = PTR_ERR(data->membase);
+ goto err_out_free_mdiobus;
+ }
+
+ data->regulator = devm_regulator_get(&pdev->dev, "phy");
+ if (IS_ERR(data->regulator)) {
+ if (PTR_ERR(data->regulator) == -EPROBE_DEFER) {
+ ret = -EPROBE_DEFER;
+ goto err_out_free_mdiobus;
+ }
+
+ dev_info(&pdev->dev, "no regulator found\n");
+ data->regulator = NULL;
+ } else {
+ ret = regulator_enable(data->regulator);
+ if (ret)
+ goto err_out_free_mdiobus;
+ }
+
+ ret = of_mdiobus_register(bus, np);
+ if (ret < 0)
+ goto err_out_disable_regulator;
+
+ platform_set_drvdata(pdev, bus);
+
+ return 0;
+
+err_out_disable_regulator:
+ if (data->regulator)
+ regulator_disable(data->regulator);
+err_out_free_mdiobus:
+ mdiobus_free(bus);
+ return ret;
+}
+
+static int sun4i_mdio_remove(struct platform_device *pdev)
+{
+ struct mii_bus *bus = platform_get_drvdata(pdev);
+ struct sun4i_mdio_data *data = bus->priv;
+
+ mdiobus_unregister(bus);
+ if (data->regulator)
+ regulator_disable(data->regulator);
+ mdiobus_free(bus);
+
+ return 0;
+}
+
+static const struct of_device_id sun4i_mdio_dt_ids[] = {
+ { .compatible = "allwinner,sun4i-a10-mdio" },
+
+ /* Deprecated */
+ { .compatible = "allwinner,sun4i-mdio" },
+ { }
+};
+MODULE_DEVICE_TABLE(of, sun4i_mdio_dt_ids);
+
+static struct platform_driver sun4i_mdio_driver = {
+ .probe = sun4i_mdio_probe,
+ .remove = sun4i_mdio_remove,
+ .driver = {
+ .name = "sun4i-mdio",
+ .of_match_table = sun4i_mdio_dt_ids,
+ },
+};
+
+module_platform_driver(sun4i_mdio_driver);
+
+MODULE_DESCRIPTION("Allwinner EMAC MDIO interface driver");
+MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2009-2016 Cavium, Inc.
+ */
+
+#include <linux/of_address.h>
+#include <linux/of_mdio.h>
+#include <linux/module.h>
+#include <linux/gfp.h>
+#include <linux/phy.h>
+#include <linux/io.h>
+#include <linux/acpi.h>
+#include <linux/pci.h>
+
+#include "mdio-cavium.h"
+
+struct thunder_mdiobus_nexus {
+ void __iomem *bar0;
+ struct cavium_mdiobus *buses[4];
+};
+
+static int thunder_mdiobus_pci_probe(struct pci_dev *pdev,
+ const struct pci_device_id *ent)
+{
+ struct device_node *node;
+ struct fwnode_handle *fwn;
+ struct thunder_mdiobus_nexus *nexus;
+ int err;
+ int i;
+
+ nexus = devm_kzalloc(&pdev->dev, sizeof(*nexus), GFP_KERNEL);
+ if (!nexus)
+ return -ENOMEM;
+
+ pci_set_drvdata(pdev, nexus);
+
+ err = pcim_enable_device(pdev);
+ if (err) {
+ dev_err(&pdev->dev, "Failed to enable PCI device\n");
+ pci_set_drvdata(pdev, NULL);
+ return err;
+ }
+
+ err = pci_request_regions(pdev, KBUILD_MODNAME);
+ if (err) {
+ dev_err(&pdev->dev, "pci_request_regions failed\n");
+ goto err_disable_device;
+ }
+
+ nexus->bar0 = pcim_iomap(pdev, 0, pci_resource_len(pdev, 0));
+ if (!nexus->bar0) {
+ err = -ENOMEM;
+ goto err_release_regions;
+ }
+
+ i = 0;
+ device_for_each_child_node(&pdev->dev, fwn) {
+ struct resource r;
+ struct mii_bus *mii_bus;
+ struct cavium_mdiobus *bus;
+ union cvmx_smix_en smi_en;
+
+ /* If it is not an OF node we cannot handle it yet, so
+ * exit the loop.
+ */
+ node = to_of_node(fwn);
+ if (!node)
+ break;
+
+ err = of_address_to_resource(node, 0, &r);
+ if (err) {
+ dev_err(&pdev->dev,
+ "Couldn't translate address for \"%pOFn\"\n",
+ node);
+ break;
+ }
+
+ mii_bus = devm_mdiobus_alloc_size(&pdev->dev, sizeof(*bus));
+ if (!mii_bus)
+ break;
+ bus = mii_bus->priv;
+ bus->mii_bus = mii_bus;
+
+ nexus->buses[i] = bus;
+ i++;
+
+ bus->register_base = nexus->bar0 +
+ r.start - pci_resource_start(pdev, 0);
+
+ smi_en.u64 = 0;
+ smi_en.s.en = 1;
+ oct_mdio_writeq(smi_en.u64, bus->register_base + SMI_EN);
+ bus->mii_bus->name = KBUILD_MODNAME;
+ snprintf(bus->mii_bus->id, MII_BUS_ID_SIZE, "%llx", r.start);
+ bus->mii_bus->parent = &pdev->dev;
+ bus->mii_bus->read = cavium_mdiobus_read;
+ bus->mii_bus->write = cavium_mdiobus_write;
+
+ err = of_mdiobus_register(bus->mii_bus, node);
+ if (err)
+ dev_err(&pdev->dev, "of_mdiobus_register failed\n");
+
+ dev_info(&pdev->dev, "Added bus at %llx\n", r.start);
+ if (i >= ARRAY_SIZE(nexus->buses))
+ break;
+ }
+ return 0;
+
+err_release_regions:
+ pci_release_regions(pdev);
+
+err_disable_device:
+ pci_set_drvdata(pdev, NULL);
+ return err;
+}
+
+static void thunder_mdiobus_pci_remove(struct pci_dev *pdev)
+{
+ int i;
+ struct thunder_mdiobus_nexus *nexus = pci_get_drvdata(pdev);
+
+ for (i = 0; i < ARRAY_SIZE(nexus->buses); i++) {
+ struct cavium_mdiobus *bus = nexus->buses[i];
+
+ if (!bus)
+ continue;
+
+ mdiobus_unregister(bus->mii_bus);
+ mdiobus_free(bus->mii_bus);
+ oct_mdio_writeq(0, bus->register_base + SMI_EN);
+ }
+ pci_release_regions(pdev);
+ pci_set_drvdata(pdev, NULL);
+}
+
+static const struct pci_device_id thunder_mdiobus_id_table[] = {
+ { PCI_DEVICE(PCI_VENDOR_ID_CAVIUM, 0xa02b) },
+ { 0, } /* End of table. */
+};
+MODULE_DEVICE_TABLE(pci, thunder_mdiobus_id_table);
+
+static struct pci_driver thunder_mdiobus_driver = {
+ .name = KBUILD_MODNAME,
+ .id_table = thunder_mdiobus_id_table,
+ .probe = thunder_mdiobus_pci_probe,
+ .remove = thunder_mdiobus_pci_remove,
+};
+
+module_pci_driver(thunder_mdiobus_driver);
+
+MODULE_DESCRIPTION("Cavium ThunderX MDIO bus driver");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0+
+/* Applied Micro X-Gene SoC MDIO Driver
+ *
+ * Copyright (c) 2016, Applied Micro Circuits Corporation
+ * Author: Iyappan Subramanian <isubramanian@apm.com>
+ */
+
+#include <linux/acpi.h>
+#include <linux/clk.h>
+#include <linux/device.h>
+#include <linux/efi.h>
+#include <linux/if_vlan.h>
+#include <linux/io.h>
+#include <linux/mdio/mdio-xgene.h>
+#include <linux/module.h>
+#include <linux/of_platform.h>
+#include <linux/of_net.h>
+#include <linux/of_mdio.h>
+#include <linux/prefetch.h>
+#include <linux/phy.h>
+#include <net/ip.h>
+
+static bool xgene_mdio_status;
+
+u32 xgene_mdio_rd_mac(struct xgene_mdio_pdata *pdata, u32 rd_addr)
+{
+ void __iomem *addr, *rd, *cmd, *cmd_done;
+ u32 done, rd_data = BUSY_MASK;
+ u8 wait = 10;
+
+ addr = pdata->mac_csr_addr + MAC_ADDR_REG_OFFSET;
+ rd = pdata->mac_csr_addr + MAC_READ_REG_OFFSET;
+ cmd = pdata->mac_csr_addr + MAC_COMMAND_REG_OFFSET;
+ cmd_done = pdata->mac_csr_addr + MAC_COMMAND_DONE_REG_OFFSET;
+
+ spin_lock(&pdata->mac_lock);
+ iowrite32(rd_addr, addr);
+ iowrite32(XGENE_ENET_RD_CMD, cmd);
+
+ while (!(done = ioread32(cmd_done)) && wait--)
+ udelay(1);
+
+ if (done)
+ rd_data = ioread32(rd);
+
+ iowrite32(0, cmd);
+ spin_unlock(&pdata->mac_lock);
+
+ return rd_data;
+}
+EXPORT_SYMBOL(xgene_mdio_rd_mac);
+
+void xgene_mdio_wr_mac(struct xgene_mdio_pdata *pdata, u32 wr_addr, u32 data)
+{
+ void __iomem *addr, *wr, *cmd, *cmd_done;
+ u8 wait = 10;
+ u32 done;
+
+ addr = pdata->mac_csr_addr + MAC_ADDR_REG_OFFSET;
+ wr = pdata->mac_csr_addr + MAC_WRITE_REG_OFFSET;
+ cmd = pdata->mac_csr_addr + MAC_COMMAND_REG_OFFSET;
+ cmd_done = pdata->mac_csr_addr + MAC_COMMAND_DONE_REG_OFFSET;
+
+ spin_lock(&pdata->mac_lock);
+ iowrite32(wr_addr, addr);
+ iowrite32(data, wr);
+ iowrite32(XGENE_ENET_WR_CMD, cmd);
+
+ while (!(done = ioread32(cmd_done)) && wait--)
+ udelay(1);
+
+ if (!done)
+ pr_err("MCX mac write failed, addr: 0x%04x\n", wr_addr);
+
+ iowrite32(0, cmd);
+ spin_unlock(&pdata->mac_lock);
+}
+EXPORT_SYMBOL(xgene_mdio_wr_mac);
+
+int xgene_mdio_rgmii_read(struct mii_bus *bus, int phy_id, int reg)
+{
+ struct xgene_mdio_pdata *pdata = (struct xgene_mdio_pdata *)bus->priv;
+ u32 data, done;
+ u8 wait = 10;
+
+ data = SET_VAL(PHY_ADDR, phy_id) | SET_VAL(REG_ADDR, reg);
+ xgene_mdio_wr_mac(pdata, MII_MGMT_ADDRESS_ADDR, data);
+ xgene_mdio_wr_mac(pdata, MII_MGMT_COMMAND_ADDR, READ_CYCLE_MASK);
+ do {
+ usleep_range(5, 10);
+ done = xgene_mdio_rd_mac(pdata, MII_MGMT_INDICATORS_ADDR);
+ } while ((done & BUSY_MASK) && wait--);
+
+ if (done & BUSY_MASK) {
+ dev_err(&bus->dev, "MII_MGMT read failed\n");
+ return -EBUSY;
+ }
+
+ data = xgene_mdio_rd_mac(pdata, MII_MGMT_STATUS_ADDR);
+ xgene_mdio_wr_mac(pdata, MII_MGMT_COMMAND_ADDR, 0);
+
+ return data;
+}
+EXPORT_SYMBOL(xgene_mdio_rgmii_read);
+
+int xgene_mdio_rgmii_write(struct mii_bus *bus, int phy_id, int reg, u16 data)
+{
+ struct xgene_mdio_pdata *pdata = (struct xgene_mdio_pdata *)bus->priv;
+ u32 val, done;
+ u8 wait = 10;
+
+ val = SET_VAL(PHY_ADDR, phy_id) | SET_VAL(REG_ADDR, reg);
+ xgene_mdio_wr_mac(pdata, MII_MGMT_ADDRESS_ADDR, val);
+
+ xgene_mdio_wr_mac(pdata, MII_MGMT_CONTROL_ADDR, data);
+ do {
+ usleep_range(5, 10);
+ done = xgene_mdio_rd_mac(pdata, MII_MGMT_INDICATORS_ADDR);
+ } while ((done & BUSY_MASK) && wait--);
+
+ if (done & BUSY_MASK) {
+ dev_err(&bus->dev, "MII_MGMT write failed\n");
+ return -EBUSY;
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL(xgene_mdio_rgmii_write);
+
+static u32 xgene_menet_rd_diag_csr(struct xgene_mdio_pdata *pdata, u32 offset)
+{
+ return ioread32(pdata->diag_csr_addr + offset);
+}
+
+static void xgene_menet_wr_diag_csr(struct xgene_mdio_pdata *pdata,
+ u32 offset, u32 val)
+{
+ iowrite32(val, pdata->diag_csr_addr + offset);
+}
+
+static int xgene_enet_ecc_init(struct xgene_mdio_pdata *pdata)
+{
+ u32 data;
+ u8 wait = 10;
+
+ xgene_menet_wr_diag_csr(pdata, MENET_CFG_MEM_RAM_SHUTDOWN_ADDR, 0x0);
+ do {
+ usleep_range(100, 110);
+ data = xgene_menet_rd_diag_csr(pdata, MENET_BLOCK_MEM_RDY_ADDR);
+ } while ((data != 0xffffffff) && wait--);
+
+ if (data != 0xffffffff) {
+ dev_err(pdata->dev, "Failed to release memory from shutdown\n");
+ return -ENODEV;
+ }
+
+ return 0;
+}
+
+static void xgene_gmac_reset(struct xgene_mdio_pdata *pdata)
+{
+ xgene_mdio_wr_mac(pdata, MAC_CONFIG_1_ADDR, SOFT_RESET);
+ xgene_mdio_wr_mac(pdata, MAC_CONFIG_1_ADDR, 0);
+}
+
+static int xgene_mdio_reset(struct xgene_mdio_pdata *pdata)
+{
+ int ret;
+
+ if (pdata->dev->of_node) {
+ clk_prepare_enable(pdata->clk);
+ udelay(5);
+ clk_disable_unprepare(pdata->clk);
+ udelay(5);
+ clk_prepare_enable(pdata->clk);
+ udelay(5);
+ } else {
+#ifdef CONFIG_ACPI
+ acpi_evaluate_object(ACPI_HANDLE(pdata->dev),
+ "_RST", NULL, NULL);
+#endif
+ }
+
+ ret = xgene_enet_ecc_init(pdata);
+ if (ret) {
+ if (pdata->dev->of_node)
+ clk_disable_unprepare(pdata->clk);
+ return ret;
+ }
+ xgene_gmac_reset(pdata);
+
+ return 0;
+}
+
+static void xgene_enet_rd_mdio_csr(void __iomem *base_addr,
+ u32 offset, u32 *val)
+{
+ void __iomem *addr = base_addr + offset;
+
+ *val = ioread32(addr);
+}
+
+static void xgene_enet_wr_mdio_csr(void __iomem *base_addr,
+ u32 offset, u32 val)
+{
+ void __iomem *addr = base_addr + offset;
+
+ iowrite32(val, addr);
+}
+
+static int xgene_xfi_mdio_write(struct mii_bus *bus, int phy_id,
+ int reg, u16 data)
+{
+ void __iomem *addr = (void __iomem *)bus->priv;
+ int timeout = 100;
+ u32 status, val;
+
+ val = SET_VAL(HSTPHYADX, phy_id) | SET_VAL(HSTREGADX, reg) |
+ SET_VAL(HSTMIIMWRDAT, data);
+ xgene_enet_wr_mdio_csr(addr, MIIM_FIELD_ADDR, val);
+
+ val = HSTLDCMD | SET_VAL(HSTMIIMCMD, MIIM_CMD_LEGACY_WRITE);
+ xgene_enet_wr_mdio_csr(addr, MIIM_COMMAND_ADDR, val);
+
+ do {
+ usleep_range(5, 10);
+ xgene_enet_rd_mdio_csr(addr, MIIM_INDICATOR_ADDR, &status);
+ } while ((status & BUSY_MASK) && timeout--);
+
+ xgene_enet_wr_mdio_csr(addr, MIIM_COMMAND_ADDR, 0);
+
+ return 0;
+}
+
+static int xgene_xfi_mdio_read(struct mii_bus *bus, int phy_id, int reg)
+{
+ void __iomem *addr = (void __iomem *)bus->priv;
+ u32 data, status, val;
+ int timeout = 100;
+
+ val = SET_VAL(HSTPHYADX, phy_id) | SET_VAL(HSTREGADX, reg);
+ xgene_enet_wr_mdio_csr(addr, MIIM_FIELD_ADDR, val);
+
+ val = HSTLDCMD | SET_VAL(HSTMIIMCMD, MIIM_CMD_LEGACY_READ);
+ xgene_enet_wr_mdio_csr(addr, MIIM_COMMAND_ADDR, val);
+
+ do {
+ usleep_range(5, 10);
+ xgene_enet_rd_mdio_csr(addr, MIIM_INDICATOR_ADDR, &status);
+ } while ((status & BUSY_MASK) && timeout--);
+
+ if (status & BUSY_MASK) {
+ pr_err("XGENET_MII_MGMT write failed\n");
+ return -EBUSY;
+ }
+
+ xgene_enet_rd_mdio_csr(addr, MIIMRD_FIELD_ADDR, &data);
+ xgene_enet_wr_mdio_csr(addr, MIIM_COMMAND_ADDR, 0);
+
+ return data;
+}
+
+struct phy_device *xgene_enet_phy_register(struct mii_bus *bus, int phy_addr)
+{
+ struct phy_device *phy_dev;
+
+ phy_dev = get_phy_device(bus, phy_addr, false);
+ if (!phy_dev || IS_ERR(phy_dev))
+ return NULL;
+
+ if (phy_device_register(phy_dev))
+ phy_device_free(phy_dev);
+
+ return phy_dev;
+}
+EXPORT_SYMBOL(xgene_enet_phy_register);
+
+#ifdef CONFIG_ACPI
+static acpi_status acpi_register_phy(acpi_handle handle, u32 lvl,
+ void *context, void **ret)
+{
+ struct mii_bus *mdio = context;
+ struct acpi_device *adev;
+ struct phy_device *phy_dev;
+ const union acpi_object *obj;
+ u32 phy_addr;
+
+ if (acpi_bus_get_device(handle, &adev))
+ return AE_OK;
+
+ if (acpi_dev_get_property(adev, "phy-channel", ACPI_TYPE_INTEGER, &obj))
+ return AE_OK;
+ phy_addr = obj->integer.value;
+
+ phy_dev = xgene_enet_phy_register(mdio, phy_addr);
+ adev->driver_data = phy_dev;
+
+ return AE_OK;
+}
+#endif
+
+static const struct of_device_id xgene_mdio_of_match[] = {
+ {
+ .compatible = "apm,xgene-mdio-rgmii",
+ .data = (void *)XGENE_MDIO_RGMII
+ },
+ {
+ .compatible = "apm,xgene-mdio-xfi",
+ .data = (void *)XGENE_MDIO_XFI
+ },
+ {},
+};
+MODULE_DEVICE_TABLE(of, xgene_mdio_of_match);
+
+#ifdef CONFIG_ACPI
+static const struct acpi_device_id xgene_mdio_acpi_match[] = {
+ { "APMC0D65", XGENE_MDIO_RGMII },
+ { "APMC0D66", XGENE_MDIO_XFI },
+ { }
+};
+
+MODULE_DEVICE_TABLE(acpi, xgene_mdio_acpi_match);
+#endif
+
+
+static int xgene_mdio_probe(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct mii_bus *mdio_bus;
+ const struct of_device_id *of_id;
+ struct xgene_mdio_pdata *pdata;
+ void __iomem *csr_base;
+ int mdio_id = 0, ret = 0;
+
+ of_id = of_match_device(xgene_mdio_of_match, &pdev->dev);
+ if (of_id) {
+ mdio_id = (enum xgene_mdio_id)of_id->data;
+ } else {
+#ifdef CONFIG_ACPI
+ const struct acpi_device_id *acpi_id;
+
+ acpi_id = acpi_match_device(xgene_mdio_acpi_match, &pdev->dev);
+ if (acpi_id)
+ mdio_id = (enum xgene_mdio_id)acpi_id->driver_data;
+#endif
+ }
+
+ if (!mdio_id)
+ return -ENODEV;
+
+ pdata = devm_kzalloc(dev, sizeof(struct xgene_mdio_pdata), GFP_KERNEL);
+ if (!pdata)
+ return -ENOMEM;
+ pdata->mdio_id = mdio_id;
+ pdata->dev = dev;
+
+ csr_base = devm_platform_ioremap_resource(pdev, 0);
+ if (IS_ERR(csr_base))
+ return PTR_ERR(csr_base);
+ pdata->mac_csr_addr = csr_base;
+ pdata->mdio_csr_addr = csr_base + BLOCK_XG_MDIO_CSR_OFFSET;
+ pdata->diag_csr_addr = csr_base + BLOCK_DIAG_CSR_OFFSET;
+
+ if (mdio_id == XGENE_MDIO_RGMII)
+ spin_lock_init(&pdata->mac_lock);
+
+ if (dev->of_node) {
+ pdata->clk = devm_clk_get(dev, NULL);
+ if (IS_ERR(pdata->clk)) {
+ dev_err(dev, "Unable to retrieve clk\n");
+ return PTR_ERR(pdata->clk);
+ }
+ }
+
+ ret = xgene_mdio_reset(pdata);
+ if (ret)
+ return ret;
+
+ mdio_bus = mdiobus_alloc();
+ if (!mdio_bus) {
+ ret = -ENOMEM;
+ goto out_clk;
+ }
+
+ mdio_bus->name = "APM X-Gene MDIO bus";
+
+ if (mdio_id == XGENE_MDIO_RGMII) {
+ mdio_bus->read = xgene_mdio_rgmii_read;
+ mdio_bus->write = xgene_mdio_rgmii_write;
+ mdio_bus->priv = (void __force *)pdata;
+ snprintf(mdio_bus->id, MII_BUS_ID_SIZE, "%s",
+ "xgene-mii-rgmii");
+ } else {
+ mdio_bus->read = xgene_xfi_mdio_read;
+ mdio_bus->write = xgene_xfi_mdio_write;
+ mdio_bus->priv = (void __force *)pdata->mdio_csr_addr;
+ snprintf(mdio_bus->id, MII_BUS_ID_SIZE, "%s",
+ "xgene-mii-xfi");
+ }
+
+ mdio_bus->parent = dev;
+ platform_set_drvdata(pdev, pdata);
+
+ if (dev->of_node) {
+ ret = of_mdiobus_register(mdio_bus, dev->of_node);
+ } else {
+#ifdef CONFIG_ACPI
+ /* Mask out all PHYs from auto probing. */
+ mdio_bus->phy_mask = ~0;
+ ret = mdiobus_register(mdio_bus);
+ if (ret)
+ goto out_mdiobus;
+
+ acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_HANDLE(dev), 1,
+ acpi_register_phy, NULL, mdio_bus, NULL);
+#endif
+ }
+
+ if (ret)
+ goto out_mdiobus;
+
+ pdata->mdio_bus = mdio_bus;
+ xgene_mdio_status = true;
+
+ return 0;
+
+out_mdiobus:
+ mdiobus_free(mdio_bus);
+
+out_clk:
+ if (dev->of_node)
+ clk_disable_unprepare(pdata->clk);
+
+ return ret;
+}
+
+static int xgene_mdio_remove(struct platform_device *pdev)
+{
+ struct xgene_mdio_pdata *pdata = platform_get_drvdata(pdev);
+ struct mii_bus *mdio_bus = pdata->mdio_bus;
+ struct device *dev = &pdev->dev;
+
+ mdiobus_unregister(mdio_bus);
+ mdiobus_free(mdio_bus);
+
+ if (dev->of_node)
+ clk_disable_unprepare(pdata->clk);
+
+ return 0;
+}
+
+static struct platform_driver xgene_mdio_driver = {
+ .driver = {
+ .name = "xgene-mdio",
+ .of_match_table = of_match_ptr(xgene_mdio_of_match),
+ .acpi_match_table = ACPI_PTR(xgene_mdio_acpi_match),
+ },
+ .probe = xgene_mdio_probe,
+ .remove = xgene_mdio_remove,
+};
+
+module_platform_driver(xgene_mdio_driver);
+
+MODULE_DESCRIPTION("APM X-Gene SoC MDIO driver");
+MODULE_AUTHOR("Iyappan Subramanian <isubramanian@apm.com>");
+MODULE_LICENSE("GPL");
# PHY Layer Configuration
#
-menuconfig MDIO_DEVICE
- tristate "MDIO bus device drivers"
- help
- MDIO devices and driver infrastructure code.
-
-if MDIO_DEVICE
-
-config MDIO_BUS
- tristate
- default m if PHYLIB=m
- default MDIO_DEVICE
- help
- This internal symbol is used for link time dependencies and it
- reflects whether the mdio_bus/mdio_device code is built as a
- loadable module or built-in.
-
-if MDIO_BUS
-
-config MDIO_DEVRES
- tristate
-
-config MDIO_ASPEED
- tristate "ASPEED MDIO bus controller"
- depends on ARCH_ASPEED || COMPILE_TEST
- depends on OF_MDIO && HAS_IOMEM
- help
- This module provides a driver for the independent MDIO bus
- controllers found in the ASPEED AST2600 SoC. This is a driver for the
- third revision of the ASPEED MDIO register interface - the first two
- revisions are the "old" and "new" interfaces found in the AST2400 and
- AST2500, embedded in the MAC. For legacy reasons, FTGMAC100 driver
- continues to drive the embedded MDIO controller for the AST2400 and
- AST2500 SoCs, so say N if AST2600 support is not required.
-
-config MDIO_BCM_IPROC
- tristate "Broadcom iProc MDIO bus controller"
- depends on ARCH_BCM_IPROC || COMPILE_TEST
- depends on HAS_IOMEM && OF_MDIO
- default ARCH_BCM_IPROC
- help
- This module provides a driver for the MDIO busses found in the
- Broadcom iProc SoC's.
-
-config MDIO_BCM_UNIMAC
- tristate "Broadcom UniMAC MDIO bus controller"
- depends on HAS_IOMEM
- help
- This module provides a driver for the Broadcom UniMAC MDIO busses.
- This hardware can be found in the Broadcom GENET Ethernet MAC
- controllers as well as some Broadcom Ethernet switches such as the
- Starfighter 2 switches.
-
-config MDIO_BITBANG
- tristate "Bitbanged MDIO buses"
- help
- This module implements the MDIO bus protocol in software,
- for use by low level drivers that export the ability to
- drive the relevant pins.
-
- If in doubt, say N.
-
-config MDIO_BUS_MUX
- tristate
- depends on OF_MDIO
- help
- This module provides a driver framework for MDIO bus
- multiplexers which connect one of several child MDIO busses
- to a parent bus. Switching between child busses is done by
- device specific drivers.
-
-config MDIO_BUS_MUX_BCM_IPROC
- tristate "Broadcom iProc based MDIO bus multiplexers"
- depends on OF && OF_MDIO && (ARCH_BCM_IPROC || COMPILE_TEST)
- select MDIO_BUS_MUX
- default ARCH_BCM_IPROC
- help
- This module provides a driver for MDIO bus multiplexers found in
- iProc based Broadcom SoCs. This multiplexer connects one of several
- child MDIO bus to a parent bus. Buses could be internal as well as
- external and selection logic lies inside the same multiplexer.
-
-config MDIO_BUS_MUX_GPIO
- tristate "GPIO controlled MDIO bus multiplexers"
- depends on OF_GPIO && OF_MDIO
- select MDIO_BUS_MUX
- help
- This module provides a driver for MDIO bus multiplexers that
- are controlled via GPIO lines. The multiplexer connects one of
- several child MDIO busses to a parent bus. Child bus
- selection is under the control of GPIO lines.
-
-config MDIO_BUS_MUX_MESON_G12A
- tristate "Amlogic G12a based MDIO bus multiplexer"
- depends on ARCH_MESON || COMPILE_TEST
- depends on OF_MDIO && HAS_IOMEM && COMMON_CLK
- select MDIO_BUS_MUX
- default m if ARCH_MESON
- help
- This module provides a driver for the MDIO multiplexer/glue of
- the amlogic g12a SoC. The multiplexers connects either the external
- or the internal MDIO bus to the parent bus.
-
-config MDIO_BUS_MUX_MMIOREG
- tristate "MMIO device-controlled MDIO bus multiplexers"
- depends on OF_MDIO && HAS_IOMEM
- select MDIO_BUS_MUX
- help
- This module provides a driver for MDIO bus multiplexers that
- are controlled via a simple memory-mapped device, like an FPGA.
- The multiplexer connects one of several child MDIO busses to a
- parent bus. Child bus selection is under the control of one of
- the FPGA's registers.
-
- Currently, only 8/16/32 bits registers are supported.
-
-config MDIO_BUS_MUX_MULTIPLEXER
- tristate "MDIO bus multiplexer using kernel multiplexer subsystem"
- depends on OF_MDIO
- select MULTIPLEXER
- select MDIO_BUS_MUX
- help
- This module provides a driver for MDIO bus multiplexer
- that is controlled via the kernel multiplexer subsystem. The
- bus multiplexer connects one of several child MDIO busses to
- a parent bus. Child bus selection is under the control of
- the kernel multiplexer subsystem.
-
-config MDIO_CAVIUM
- tristate
-
-config MDIO_GPIO
- tristate "GPIO lib-based bitbanged MDIO buses"
- depends on MDIO_BITBANG
- depends on GPIOLIB || COMPILE_TEST
- help
- Supports GPIO lib-based MDIO busses.
-
- To compile this driver as a module, choose M here: the module
- will be called mdio-gpio.
-
-config MDIO_HISI_FEMAC
- tristate "Hisilicon FEMAC MDIO bus controller"
- depends on HAS_IOMEM && OF_MDIO
- help
- This module provides a driver for the MDIO busses found in the
- Hisilicon SoC that have an Fast Ethernet MAC.
-
-config MDIO_I2C
- tristate
- depends on I2C
- help
- Support I2C based PHYs. This provides a MDIO bus bridged
- to I2C to allow PHYs connected in I2C mode to be accessed
- using the existing infrastructure.
-
- This is library mode.
-
-config MDIO_IPQ4019
- tristate "Qualcomm IPQ4019 MDIO interface support"
- depends on HAS_IOMEM && OF_MDIO
- help
- This driver supports the MDIO interface found in Qualcomm
- IPQ40xx series Soc-s.
-
-config MDIO_IPQ8064
- tristate "Qualcomm IPQ8064 MDIO interface support"
- depends on HAS_IOMEM && OF_MDIO
- depends on MFD_SYSCON
- help
- This driver supports the MDIO interface found in the network
- interface units of the IPQ8064 SoC
-
-config MDIO_MOXART
- tristate "MOXA ART MDIO interface support"
- depends on ARCH_MOXART || COMPILE_TEST
- help
- This driver supports the MDIO interface found in the network
- interface units of the MOXA ART SoC
-
-config MDIO_MSCC_MIIM
- tristate "Microsemi MIIM interface support"
- depends on HAS_IOMEM
- select MDIO_DEVRES
- help
- This driver supports the MIIM (MDIO) interface found in the network
- switches of the Microsemi SoCs; it is recommended to switch on
- CONFIG_HIGH_RES_TIMERS
-
-config MDIO_MVUSB
- tristate "Marvell USB to MDIO Adapter"
- depends on USB
- select MDIO_DEVRES
- help
- A USB to MDIO converter present on development boards for
- Marvell's Link Street family of Ethernet switches.
-
-config MDIO_OCTEON
- tristate "Octeon and some ThunderX SOCs MDIO buses"
- depends on (64BIT && OF_MDIO) || COMPILE_TEST
- depends on HAS_IOMEM
- select MDIO_CAVIUM
- help
- This module provides a driver for the Octeon and ThunderX MDIO
- buses. It is required by the Octeon and ThunderX ethernet device
- drivers on some systems.
-
-config MDIO_SUN4I
- tristate "Allwinner sun4i MDIO interface support"
- depends on ARCH_SUNXI || COMPILE_TEST
- help
- This driver supports the MDIO interface found in the network
- interface units of the Allwinner SoC that have an EMAC (A10,
- A12, A10s, etc.)
-
-config MDIO_THUNDER
- tristate "ThunderX SOCs MDIO buses"
- depends on 64BIT
- depends on PCI
- select MDIO_CAVIUM
- help
- This driver supports the MDIO interfaces found on Cavium
- ThunderX SoCs when the MDIO bus device appears as a PCI
- device.
-
-config MDIO_XGENE
- tristate "APM X-Gene SoC MDIO bus controller"
- depends on ARCH_XGENE || COMPILE_TEST
- help
- This module provides a driver for the MDIO busses found in the
- APM X-Gene SoC's.
-
-endif
-endif
-
config PHYLINK
tristate
depends on NETDEVICES
# SPDX-License-Identifier: GPL-2.0
-# Makefile for Linux PHY drivers and MDIO bus drivers
+# Makefile for Linux PHY drivers
libphy-y := phy.o phy-c45.o phy-core.o phy_device.o \
linkmode.o
obj-$(CONFIG_PHYLINK) += phylink.o
obj-$(CONFIG_PHYLIB) += libphy.o
-obj-$(CONFIG_MDIO_ASPEED) += mdio-aspeed.o
-obj-$(CONFIG_MDIO_BCM_IPROC) += mdio-bcm-iproc.o
-obj-$(CONFIG_MDIO_BCM_UNIMAC) += mdio-bcm-unimac.o
-obj-$(CONFIG_MDIO_BITBANG) += mdio-bitbang.o
-obj-$(CONFIG_MDIO_BUS_MUX) += mdio-mux.o
-obj-$(CONFIG_MDIO_BUS_MUX_BCM_IPROC) += mdio-mux-bcm-iproc.o
-obj-$(CONFIG_MDIO_BUS_MUX_GPIO) += mdio-mux-gpio.o
-obj-$(CONFIG_MDIO_BUS_MUX_MESON_G12A) += mdio-mux-meson-g12a.o
-obj-$(CONFIG_MDIO_BUS_MUX_MMIOREG) += mdio-mux-mmioreg.o
-obj-$(CONFIG_MDIO_BUS_MUX_MULTIPLEXER) += mdio-mux-multiplexer.o
-obj-$(CONFIG_MDIO_CAVIUM) += mdio-cavium.o
-obj-$(CONFIG_MDIO_GPIO) += mdio-gpio.o
-obj-$(CONFIG_MDIO_HISI_FEMAC) += mdio-hisi-femac.o
-obj-$(CONFIG_MDIO_I2C) += mdio-i2c.o
-obj-$(CONFIG_MDIO_IPQ4019) += mdio-ipq4019.o
-obj-$(CONFIG_MDIO_IPQ8064) += mdio-ipq8064.o
-obj-$(CONFIG_MDIO_MOXART) += mdio-moxart.o
-obj-$(CONFIG_MDIO_MSCC_MIIM) += mdio-mscc-miim.o
-obj-$(CONFIG_MDIO_MVUSB) += mdio-mvusb.o
-obj-$(CONFIG_MDIO_OCTEON) += mdio-octeon.o
-obj-$(CONFIG_MDIO_SUN4I) += mdio-sun4i.o
-obj-$(CONFIG_MDIO_THUNDER) += mdio-thunder.o
-obj-$(CONFIG_MDIO_XGENE) += mdio-xgene.o
-
obj-$(CONFIG_NETWORK_PHY_TIMESTAMPING) += mii_timestamper.o
obj-$(CONFIG_SFP) += sfp.o
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0-or-later
-/* Copyright (C) 2019 IBM Corp. */
-
-#include <linux/bitfield.h>
-#include <linux/delay.h>
-#include <linux/iopoll.h>
-#include <linux/mdio.h>
-#include <linux/module.h>
-#include <linux/of.h>
-#include <linux/of_mdio.h>
-#include <linux/phy.h>
-#include <linux/platform_device.h>
-
-#define DRV_NAME "mdio-aspeed"
-
-#define ASPEED_MDIO_CTRL 0x0
-#define ASPEED_MDIO_CTRL_FIRE BIT(31)
-#define ASPEED_MDIO_CTRL_ST BIT(28)
-#define ASPEED_MDIO_CTRL_ST_C45 0
-#define ASPEED_MDIO_CTRL_ST_C22 1
-#define ASPEED_MDIO_CTRL_OP GENMASK(27, 26)
-#define MDIO_C22_OP_WRITE 0b01
-#define MDIO_C22_OP_READ 0b10
-#define ASPEED_MDIO_CTRL_PHYAD GENMASK(25, 21)
-#define ASPEED_MDIO_CTRL_REGAD GENMASK(20, 16)
-#define ASPEED_MDIO_CTRL_MIIWDATA GENMASK(15, 0)
-
-#define ASPEED_MDIO_DATA 0x4
-#define ASPEED_MDIO_DATA_MDC_THRES GENMASK(31, 24)
-#define ASPEED_MDIO_DATA_MDIO_EDGE BIT(23)
-#define ASPEED_MDIO_DATA_MDIO_LATCH GENMASK(22, 20)
-#define ASPEED_MDIO_DATA_IDLE BIT(16)
-#define ASPEED_MDIO_DATA_MIIRDATA GENMASK(15, 0)
-
-#define ASPEED_MDIO_INTERVAL_US 100
-#define ASPEED_MDIO_TIMEOUT_US (ASPEED_MDIO_INTERVAL_US * 10)
-
-struct aspeed_mdio {
- void __iomem *base;
-};
-
-static int aspeed_mdio_read(struct mii_bus *bus, int addr, int regnum)
-{
- struct aspeed_mdio *ctx = bus->priv;
- u32 ctrl;
- u32 data;
- int rc;
-
- dev_dbg(&bus->dev, "%s: addr: %d, regnum: %d\n", __func__, addr,
- regnum);
-
- /* Just clause 22 for the moment */
- if (regnum & MII_ADDR_C45)
- return -EOPNOTSUPP;
-
- ctrl = ASPEED_MDIO_CTRL_FIRE
- | FIELD_PREP(ASPEED_MDIO_CTRL_ST, ASPEED_MDIO_CTRL_ST_C22)
- | FIELD_PREP(ASPEED_MDIO_CTRL_OP, MDIO_C22_OP_READ)
- | FIELD_PREP(ASPEED_MDIO_CTRL_PHYAD, addr)
- | FIELD_PREP(ASPEED_MDIO_CTRL_REGAD, regnum);
-
- iowrite32(ctrl, ctx->base + ASPEED_MDIO_CTRL);
-
- rc = readl_poll_timeout(ctx->base + ASPEED_MDIO_DATA, data,
- data & ASPEED_MDIO_DATA_IDLE,
- ASPEED_MDIO_INTERVAL_US,
- ASPEED_MDIO_TIMEOUT_US);
- if (rc < 0)
- return rc;
-
- return FIELD_GET(ASPEED_MDIO_DATA_MIIRDATA, data);
-}
-
-static int aspeed_mdio_write(struct mii_bus *bus, int addr, int regnum, u16 val)
-{
- struct aspeed_mdio *ctx = bus->priv;
- u32 ctrl;
-
- dev_dbg(&bus->dev, "%s: addr: %d, regnum: %d, val: 0x%x\n",
- __func__, addr, regnum, val);
-
- /* Just clause 22 for the moment */
- if (regnum & MII_ADDR_C45)
- return -EOPNOTSUPP;
-
- ctrl = ASPEED_MDIO_CTRL_FIRE
- | FIELD_PREP(ASPEED_MDIO_CTRL_ST, ASPEED_MDIO_CTRL_ST_C22)
- | FIELD_PREP(ASPEED_MDIO_CTRL_OP, MDIO_C22_OP_WRITE)
- | FIELD_PREP(ASPEED_MDIO_CTRL_PHYAD, addr)
- | FIELD_PREP(ASPEED_MDIO_CTRL_REGAD, regnum)
- | FIELD_PREP(ASPEED_MDIO_CTRL_MIIWDATA, val);
-
- iowrite32(ctrl, ctx->base + ASPEED_MDIO_CTRL);
-
- return readl_poll_timeout(ctx->base + ASPEED_MDIO_CTRL, ctrl,
- !(ctrl & ASPEED_MDIO_CTRL_FIRE),
- ASPEED_MDIO_INTERVAL_US,
- ASPEED_MDIO_TIMEOUT_US);
-}
-
-static int aspeed_mdio_probe(struct platform_device *pdev)
-{
- struct aspeed_mdio *ctx;
- struct mii_bus *bus;
- int rc;
-
- bus = devm_mdiobus_alloc_size(&pdev->dev, sizeof(*ctx));
- if (!bus)
- return -ENOMEM;
-
- ctx = bus->priv;
- ctx->base = devm_platform_ioremap_resource(pdev, 0);
- if (IS_ERR(ctx->base))
- return PTR_ERR(ctx->base);
-
- bus->name = DRV_NAME;
- snprintf(bus->id, MII_BUS_ID_SIZE, "%s%d", pdev->name, pdev->id);
- bus->parent = &pdev->dev;
- bus->read = aspeed_mdio_read;
- bus->write = aspeed_mdio_write;
-
- rc = of_mdiobus_register(bus, pdev->dev.of_node);
- if (rc) {
- dev_err(&pdev->dev, "Cannot register MDIO bus!\n");
- return rc;
- }
-
- platform_set_drvdata(pdev, bus);
-
- return 0;
-}
-
-static int aspeed_mdio_remove(struct platform_device *pdev)
-{
- mdiobus_unregister(platform_get_drvdata(pdev));
-
- return 0;
-}
-
-static const struct of_device_id aspeed_mdio_of_match[] = {
- { .compatible = "aspeed,ast2600-mdio", },
- { },
-};
-
-static struct platform_driver aspeed_mdio_driver = {
- .driver = {
- .name = DRV_NAME,
- .of_match_table = aspeed_mdio_of_match,
- },
- .probe = aspeed_mdio_probe,
- .remove = aspeed_mdio_remove,
-};
-
-module_platform_driver(aspeed_mdio_driver);
-
-MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
-MODULE_LICENSE("GPL");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2015 Broadcom Corporation
- */
-
-#include <linux/delay.h>
-#include <linux/io.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/of.h>
-#include <linux/of_platform.h>
-#include <linux/of_mdio.h>
-#include <linux/phy.h>
-#include <linux/platform_device.h>
-#include <linux/sched.h>
-
-#define IPROC_GPHY_MDCDIV 0x1a
-
-#define MII_CTRL_OFFSET 0x000
-
-#define MII_CTRL_DIV_SHIFT 0
-#define MII_CTRL_PRE_SHIFT 7
-#define MII_CTRL_BUSY_SHIFT 8
-
-#define MII_DATA_OFFSET 0x004
-#define MII_DATA_MASK 0xffff
-#define MII_DATA_TA_SHIFT 16
-#define MII_DATA_TA_VAL 2
-#define MII_DATA_RA_SHIFT 18
-#define MII_DATA_PA_SHIFT 23
-#define MII_DATA_OP_SHIFT 28
-#define MII_DATA_OP_WRITE 1
-#define MII_DATA_OP_READ 2
-#define MII_DATA_SB_SHIFT 30
-
-struct iproc_mdio_priv {
- struct mii_bus *mii_bus;
- void __iomem *base;
-};
-
-static inline int iproc_mdio_wait_for_idle(void __iomem *base)
-{
- u32 val;
- unsigned int timeout = 1000; /* loop for 1s */
-
- do {
- val = readl(base + MII_CTRL_OFFSET);
- if ((val & BIT(MII_CTRL_BUSY_SHIFT)) == 0)
- return 0;
-
- usleep_range(1000, 2000);
- } while (timeout--);
-
- return -ETIMEDOUT;
-}
-
-static inline void iproc_mdio_config_clk(void __iomem *base)
-{
- u32 val;
-
- val = (IPROC_GPHY_MDCDIV << MII_CTRL_DIV_SHIFT) |
- BIT(MII_CTRL_PRE_SHIFT);
- writel(val, base + MII_CTRL_OFFSET);
-}
-
-static int iproc_mdio_read(struct mii_bus *bus, int phy_id, int reg)
-{
- struct iproc_mdio_priv *priv = bus->priv;
- u32 cmd;
- int rc;
-
- rc = iproc_mdio_wait_for_idle(priv->base);
- if (rc)
- return rc;
-
- /* Prepare the read operation */
- cmd = (MII_DATA_TA_VAL << MII_DATA_TA_SHIFT) |
- (reg << MII_DATA_RA_SHIFT) |
- (phy_id << MII_DATA_PA_SHIFT) |
- BIT(MII_DATA_SB_SHIFT) |
- (MII_DATA_OP_READ << MII_DATA_OP_SHIFT);
-
- writel(cmd, priv->base + MII_DATA_OFFSET);
-
- rc = iproc_mdio_wait_for_idle(priv->base);
- if (rc)
- return rc;
-
- cmd = readl(priv->base + MII_DATA_OFFSET) & MII_DATA_MASK;
-
- return cmd;
-}
-
-static int iproc_mdio_write(struct mii_bus *bus, int phy_id,
- int reg, u16 val)
-{
- struct iproc_mdio_priv *priv = bus->priv;
- u32 cmd;
- int rc;
-
- rc = iproc_mdio_wait_for_idle(priv->base);
- if (rc)
- return rc;
-
- /* Prepare the write operation */
- cmd = (MII_DATA_TA_VAL << MII_DATA_TA_SHIFT) |
- (reg << MII_DATA_RA_SHIFT) |
- (phy_id << MII_DATA_PA_SHIFT) |
- BIT(MII_DATA_SB_SHIFT) |
- (MII_DATA_OP_WRITE << MII_DATA_OP_SHIFT) |
- ((u32)(val) & MII_DATA_MASK);
-
- writel(cmd, priv->base + MII_DATA_OFFSET);
-
- rc = iproc_mdio_wait_for_idle(priv->base);
- if (rc)
- return rc;
-
- return 0;
-}
-
-static int iproc_mdio_probe(struct platform_device *pdev)
-{
- struct iproc_mdio_priv *priv;
- struct mii_bus *bus;
- int rc;
-
- priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
- if (!priv)
- return -ENOMEM;
-
- priv->base = devm_platform_ioremap_resource(pdev, 0);
- if (IS_ERR(priv->base)) {
- dev_err(&pdev->dev, "failed to ioremap register\n");
- return PTR_ERR(priv->base);
- }
-
- priv->mii_bus = mdiobus_alloc();
- if (!priv->mii_bus) {
- dev_err(&pdev->dev, "MDIO bus alloc failed\n");
- return -ENOMEM;
- }
-
- bus = priv->mii_bus;
- bus->priv = priv;
- bus->name = "iProc MDIO bus";
- snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d", pdev->name, pdev->id);
- bus->parent = &pdev->dev;
- bus->read = iproc_mdio_read;
- bus->write = iproc_mdio_write;
-
- iproc_mdio_config_clk(priv->base);
-
- rc = of_mdiobus_register(bus, pdev->dev.of_node);
- if (rc) {
- dev_err(&pdev->dev, "MDIO bus registration failed\n");
- goto err_iproc_mdio;
- }
-
- platform_set_drvdata(pdev, priv);
-
- dev_info(&pdev->dev, "Broadcom iProc MDIO bus registered\n");
-
- return 0;
-
-err_iproc_mdio:
- mdiobus_free(bus);
- return rc;
-}
-
-static int iproc_mdio_remove(struct platform_device *pdev)
-{
- struct iproc_mdio_priv *priv = platform_get_drvdata(pdev);
-
- mdiobus_unregister(priv->mii_bus);
- mdiobus_free(priv->mii_bus);
-
- return 0;
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int iproc_mdio_resume(struct device *dev)
-{
- struct platform_device *pdev = to_platform_device(dev);
- struct iproc_mdio_priv *priv = platform_get_drvdata(pdev);
-
- /* restore the mii clock configuration */
- iproc_mdio_config_clk(priv->base);
-
- return 0;
-}
-
-static const struct dev_pm_ops iproc_mdio_pm_ops = {
- .resume = iproc_mdio_resume
-};
-#endif /* CONFIG_PM_SLEEP */
-
-static const struct of_device_id iproc_mdio_of_match[] = {
- { .compatible = "brcm,iproc-mdio", },
- { /* sentinel */ },
-};
-MODULE_DEVICE_TABLE(of, iproc_mdio_of_match);
-
-static struct platform_driver iproc_mdio_driver = {
- .driver = {
- .name = "iproc-mdio",
- .of_match_table = iproc_mdio_of_match,
-#ifdef CONFIG_PM_SLEEP
- .pm = &iproc_mdio_pm_ops,
-#endif
- },
- .probe = iproc_mdio_probe,
- .remove = iproc_mdio_remove,
-};
-
-module_platform_driver(iproc_mdio_driver);
-
-MODULE_AUTHOR("Broadcom Corporation");
-MODULE_DESCRIPTION("Broadcom iProc MDIO bus controller");
-MODULE_LICENSE("GPL v2");
-MODULE_ALIAS("platform:iproc-mdio");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0+
-/*
- * Broadcom UniMAC MDIO bus controller driver
- *
- * Copyright (C) 2014-2017 Broadcom
- */
-
-#include <linux/kernel.h>
-#include <linux/phy.h>
-#include <linux/platform_device.h>
-#include <linux/sched.h>
-#include <linux/module.h>
-#include <linux/io.h>
-#include <linux/delay.h>
-#include <linux/clk.h>
-
-#include <linux/of.h>
-#include <linux/of_platform.h>
-#include <linux/of_mdio.h>
-
-#include <linux/platform_data/mdio-bcm-unimac.h>
-
-#define MDIO_CMD 0x00
-#define MDIO_START_BUSY (1 << 29)
-#define MDIO_READ_FAIL (1 << 28)
-#define MDIO_RD (2 << 26)
-#define MDIO_WR (1 << 26)
-#define MDIO_PMD_SHIFT 21
-#define MDIO_PMD_MASK 0x1F
-#define MDIO_REG_SHIFT 16
-#define MDIO_REG_MASK 0x1F
-
-#define MDIO_CFG 0x04
-#define MDIO_C22 (1 << 0)
-#define MDIO_C45 0
-#define MDIO_CLK_DIV_SHIFT 4
-#define MDIO_CLK_DIV_MASK 0x3F
-#define MDIO_SUPP_PREAMBLE (1 << 12)
-
-struct unimac_mdio_priv {
- struct mii_bus *mii_bus;
- void __iomem *base;
- int (*wait_func) (void *wait_func_data);
- void *wait_func_data;
- struct clk *clk;
- u32 clk_freq;
-};
-
-static inline u32 unimac_mdio_readl(struct unimac_mdio_priv *priv, u32 offset)
-{
- /* MIPS chips strapped for BE will automagically configure the
- * peripheral registers for CPU-native byte order.
- */
- if (IS_ENABLED(CONFIG_MIPS) && IS_ENABLED(CONFIG_CPU_BIG_ENDIAN))
- return __raw_readl(priv->base + offset);
- else
- return readl_relaxed(priv->base + offset);
-}
-
-static inline void unimac_mdio_writel(struct unimac_mdio_priv *priv, u32 val,
- u32 offset)
-{
- if (IS_ENABLED(CONFIG_MIPS) && IS_ENABLED(CONFIG_CPU_BIG_ENDIAN))
- __raw_writel(val, priv->base + offset);
- else
- writel_relaxed(val, priv->base + offset);
-}
-
-static inline void unimac_mdio_start(struct unimac_mdio_priv *priv)
-{
- u32 reg;
-
- reg = unimac_mdio_readl(priv, MDIO_CMD);
- reg |= MDIO_START_BUSY;
- unimac_mdio_writel(priv, reg, MDIO_CMD);
-}
-
-static inline unsigned int unimac_mdio_busy(struct unimac_mdio_priv *priv)
-{
- return unimac_mdio_readl(priv, MDIO_CMD) & MDIO_START_BUSY;
-}
-
-static int unimac_mdio_poll(void *wait_func_data)
-{
- struct unimac_mdio_priv *priv = wait_func_data;
- unsigned int timeout = 1000;
-
- do {
- if (!unimac_mdio_busy(priv))
- return 0;
-
- usleep_range(1000, 2000);
- } while (--timeout);
-
- return -ETIMEDOUT;
-}
-
-static int unimac_mdio_read(struct mii_bus *bus, int phy_id, int reg)
-{
- struct unimac_mdio_priv *priv = bus->priv;
- int ret;
- u32 cmd;
-
- /* Prepare the read operation */
- cmd = MDIO_RD | (phy_id << MDIO_PMD_SHIFT) | (reg << MDIO_REG_SHIFT);
- unimac_mdio_writel(priv, cmd, MDIO_CMD);
-
- /* Start MDIO transaction */
- unimac_mdio_start(priv);
-
- ret = priv->wait_func(priv->wait_func_data);
- if (ret)
- return ret;
-
- cmd = unimac_mdio_readl(priv, MDIO_CMD);
-
- /* Some broken devices are known not to release the line during
- * turn-around, e.g: Broadcom BCM53125 external switches, so check for
- * that condition here and ignore the MDIO controller read failure
- * indication.
- */
- if (!(bus->phy_ignore_ta_mask & 1 << phy_id) && (cmd & MDIO_READ_FAIL))
- return -EIO;
-
- return cmd & 0xffff;
-}
-
-static int unimac_mdio_write(struct mii_bus *bus, int phy_id,
- int reg, u16 val)
-{
- struct unimac_mdio_priv *priv = bus->priv;
- u32 cmd;
-
- /* Prepare the write operation */
- cmd = MDIO_WR | (phy_id << MDIO_PMD_SHIFT) |
- (reg << MDIO_REG_SHIFT) | (0xffff & val);
- unimac_mdio_writel(priv, cmd, MDIO_CMD);
-
- unimac_mdio_start(priv);
-
- return priv->wait_func(priv->wait_func_data);
-}
-
-/* Workaround for integrated BCM7xxx Gigabit PHYs which have a problem with
- * their internal MDIO management controller making them fail to successfully
- * be read from or written to for the first transaction. We insert a dummy
- * BMSR read here to make sure that phy_get_device() and get_phy_id() can
- * correctly read the PHY MII_PHYSID1/2 registers and successfully register a
- * PHY device for this peripheral.
- *
- * Once the PHY driver is registered, we can workaround subsequent reads from
- * there (e.g: during system-wide power management).
- *
- * bus->reset is invoked before mdiobus_scan during mdiobus_register and is
- * therefore the right location to stick that workaround. Since we do not want
- * to read from non-existing PHYs, we either use bus->phy_mask or do a manual
- * Device Tree scan to limit the search area.
- */
-static int unimac_mdio_reset(struct mii_bus *bus)
-{
- struct device_node *np = bus->dev.of_node;
- struct device_node *child;
- u32 read_mask = 0;
- int addr;
-
- if (!np) {
- read_mask = ~bus->phy_mask;
- } else {
- for_each_available_child_of_node(np, child) {
- addr = of_mdio_parse_addr(&bus->dev, child);
- if (addr < 0)
- continue;
-
- read_mask |= 1 << addr;
- }
- }
-
- for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
- if (read_mask & 1 << addr) {
- dev_dbg(&bus->dev, "Workaround for PHY @ %d\n", addr);
- mdiobus_read(bus, addr, MII_BMSR);
- }
- }
-
- return 0;
-}
-
-static void unimac_mdio_clk_set(struct unimac_mdio_priv *priv)
-{
- unsigned long rate;
- u32 reg, div;
-
- /* Keep the hardware default values */
- if (!priv->clk_freq)
- return;
-
- if (!priv->clk)
- rate = 250000000;
- else
- rate = clk_get_rate(priv->clk);
-
- div = (rate / (2 * priv->clk_freq)) - 1;
- if (div & ~MDIO_CLK_DIV_MASK) {
- pr_warn("Incorrect MDIO clock frequency, ignoring\n");
- return;
- }
-
- /* The MDIO clock is the reference clock (typicaly 250Mhz) divided by
- * 2 x (MDIO_CLK_DIV + 1)
- */
- reg = unimac_mdio_readl(priv, MDIO_CFG);
- reg &= ~(MDIO_CLK_DIV_MASK << MDIO_CLK_DIV_SHIFT);
- reg |= div << MDIO_CLK_DIV_SHIFT;
- unimac_mdio_writel(priv, reg, MDIO_CFG);
-}
-
-static int unimac_mdio_probe(struct platform_device *pdev)
-{
- struct unimac_mdio_pdata *pdata = pdev->dev.platform_data;
- struct unimac_mdio_priv *priv;
- struct device_node *np;
- struct mii_bus *bus;
- struct resource *r;
- int ret;
-
- np = pdev->dev.of_node;
-
- priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
- if (!priv)
- return -ENOMEM;
-
- r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- if (!r)
- return -EINVAL;
-
- /* Just ioremap, as this MDIO block is usually integrated into an
- * Ethernet MAC controller register range
- */
- priv->base = devm_ioremap(&pdev->dev, r->start, resource_size(r));
- if (!priv->base) {
- dev_err(&pdev->dev, "failed to remap register\n");
- return -ENOMEM;
- }
-
- priv->clk = devm_clk_get_optional(&pdev->dev, NULL);
- if (IS_ERR(priv->clk))
- return PTR_ERR(priv->clk);
-
- ret = clk_prepare_enable(priv->clk);
- if (ret)
- return ret;
-
- if (of_property_read_u32(np, "clock-frequency", &priv->clk_freq))
- priv->clk_freq = 0;
-
- unimac_mdio_clk_set(priv);
-
- priv->mii_bus = mdiobus_alloc();
- if (!priv->mii_bus) {
- ret = -ENOMEM;
- goto out_clk_disable;
- }
-
- bus = priv->mii_bus;
- bus->priv = priv;
- if (pdata) {
- bus->name = pdata->bus_name;
- priv->wait_func = pdata->wait_func;
- priv->wait_func_data = pdata->wait_func_data;
- bus->phy_mask = ~pdata->phy_mask;
- } else {
- bus->name = "unimac MII bus";
- priv->wait_func_data = priv;
- priv->wait_func = unimac_mdio_poll;
- }
- bus->parent = &pdev->dev;
- bus->read = unimac_mdio_read;
- bus->write = unimac_mdio_write;
- bus->reset = unimac_mdio_reset;
- snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d", pdev->name, pdev->id);
-
- ret = of_mdiobus_register(bus, np);
- if (ret) {
- dev_err(&pdev->dev, "MDIO bus registration failed\n");
- goto out_mdio_free;
- }
-
- platform_set_drvdata(pdev, priv);
-
- dev_info(&pdev->dev, "Broadcom UniMAC MDIO bus\n");
-
- return 0;
-
-out_mdio_free:
- mdiobus_free(bus);
-out_clk_disable:
- clk_disable_unprepare(priv->clk);
- return ret;
-}
-
-static int unimac_mdio_remove(struct platform_device *pdev)
-{
- struct unimac_mdio_priv *priv = platform_get_drvdata(pdev);
-
- mdiobus_unregister(priv->mii_bus);
- mdiobus_free(priv->mii_bus);
- clk_disable_unprepare(priv->clk);
-
- return 0;
-}
-
-static int __maybe_unused unimac_mdio_suspend(struct device *d)
-{
- struct unimac_mdio_priv *priv = dev_get_drvdata(d);
-
- clk_disable_unprepare(priv->clk);
-
- return 0;
-}
-
-static int __maybe_unused unimac_mdio_resume(struct device *d)
-{
- struct unimac_mdio_priv *priv = dev_get_drvdata(d);
- int ret;
-
- ret = clk_prepare_enable(priv->clk);
- if (ret)
- return ret;
-
- unimac_mdio_clk_set(priv);
-
- return 0;
-}
-
-static SIMPLE_DEV_PM_OPS(unimac_mdio_pm_ops,
- unimac_mdio_suspend, unimac_mdio_resume);
-
-static const struct of_device_id unimac_mdio_ids[] = {
- { .compatible = "brcm,genet-mdio-v5", },
- { .compatible = "brcm,genet-mdio-v4", },
- { .compatible = "brcm,genet-mdio-v3", },
- { .compatible = "brcm,genet-mdio-v2", },
- { .compatible = "brcm,genet-mdio-v1", },
- { .compatible = "brcm,unimac-mdio", },
- { /* sentinel */ },
-};
-MODULE_DEVICE_TABLE(of, unimac_mdio_ids);
-
-static struct platform_driver unimac_mdio_driver = {
- .driver = {
- .name = UNIMAC_MDIO_DRV_NAME,
- .of_match_table = unimac_mdio_ids,
- .pm = &unimac_mdio_pm_ops,
- },
- .probe = unimac_mdio_probe,
- .remove = unimac_mdio_remove,
-};
-module_platform_driver(unimac_mdio_driver);
-
-MODULE_AUTHOR("Broadcom Corporation");
-MODULE_DESCRIPTION("Broadcom UniMAC MDIO bus controller");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:" UNIMAC_MDIO_DRV_NAME);
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Bitbanged MDIO support.
- *
- * Author: Scott Wood <scottwood@freescale.com>
- * Copyright (c) 2007 Freescale Semiconductor
- *
- * Based on CPM2 MDIO code which is:
- *
- * Copyright (c) 2003 Intracom S.A.
- * by Pantelis Antoniou <panto@intracom.gr>
- *
- * 2005 (c) MontaVista Software, Inc.
- * Vitaly Bordug <vbordug@ru.mvista.com>
- */
-
-#include <linux/module.h>
-#include <linux/mdio-bitbang.h>
-#include <linux/types.h>
-#include <linux/delay.h>
-
-#define MDIO_READ 2
-#define MDIO_WRITE 1
-
-#define MDIO_C45 (1<<15)
-#define MDIO_C45_ADDR (MDIO_C45 | 0)
-#define MDIO_C45_READ (MDIO_C45 | 3)
-#define MDIO_C45_WRITE (MDIO_C45 | 1)
-
-#define MDIO_SETUP_TIME 10
-#define MDIO_HOLD_TIME 10
-
-/* Minimum MDC period is 400 ns, plus some margin for error. MDIO_DELAY
- * is done twice per period.
- */
-#define MDIO_DELAY 250
-
-/* The PHY may take up to 300 ns to produce data, plus some margin
- * for error.
- */
-#define MDIO_READ_DELAY 350
-
-/* MDIO must already be configured as output. */
-static void mdiobb_send_bit(struct mdiobb_ctrl *ctrl, int val)
-{
- const struct mdiobb_ops *ops = ctrl->ops;
-
- ops->set_mdio_data(ctrl, val);
- ndelay(MDIO_DELAY);
- ops->set_mdc(ctrl, 1);
- ndelay(MDIO_DELAY);
- ops->set_mdc(ctrl, 0);
-}
-
-/* MDIO must already be configured as input. */
-static int mdiobb_get_bit(struct mdiobb_ctrl *ctrl)
-{
- const struct mdiobb_ops *ops = ctrl->ops;
-
- ndelay(MDIO_DELAY);
- ops->set_mdc(ctrl, 1);
- ndelay(MDIO_READ_DELAY);
- ops->set_mdc(ctrl, 0);
-
- return ops->get_mdio_data(ctrl);
-}
-
-/* MDIO must already be configured as output. */
-static void mdiobb_send_num(struct mdiobb_ctrl *ctrl, u16 val, int bits)
-{
- int i;
-
- for (i = bits - 1; i >= 0; i--)
- mdiobb_send_bit(ctrl, (val >> i) & 1);
-}
-
-/* MDIO must already be configured as input. */
-static u16 mdiobb_get_num(struct mdiobb_ctrl *ctrl, int bits)
-{
- int i;
- u16 ret = 0;
-
- for (i = bits - 1; i >= 0; i--) {
- ret <<= 1;
- ret |= mdiobb_get_bit(ctrl);
- }
-
- return ret;
-}
-
-/* Utility to send the preamble, address, and
- * register (common to read and write).
- */
-static void mdiobb_cmd(struct mdiobb_ctrl *ctrl, int op, u8 phy, u8 reg)
-{
- const struct mdiobb_ops *ops = ctrl->ops;
- int i;
-
- ops->set_mdio_dir(ctrl, 1);
-
- /*
- * Send a 32 bit preamble ('1's) with an extra '1' bit for good
- * measure. The IEEE spec says this is a PHY optional
- * requirement. The AMD 79C874 requires one after power up and
- * one after a MII communications error. This means that we are
- * doing more preambles than we need, but it is safer and will be
- * much more robust.
- */
-
- for (i = 0; i < 32; i++)
- mdiobb_send_bit(ctrl, 1);
-
- /* send the start bit (01) and the read opcode (10) or write (01).
- Clause 45 operation uses 00 for the start and 11, 10 for
- read/write */
- mdiobb_send_bit(ctrl, 0);
- if (op & MDIO_C45)
- mdiobb_send_bit(ctrl, 0);
- else
- mdiobb_send_bit(ctrl, 1);
- mdiobb_send_bit(ctrl, (op >> 1) & 1);
- mdiobb_send_bit(ctrl, (op >> 0) & 1);
-
- mdiobb_send_num(ctrl, phy, 5);
- mdiobb_send_num(ctrl, reg, 5);
-}
-
-/* In clause 45 mode all commands are prefixed by MDIO_ADDR to specify the
- lower 16 bits of the 21 bit address. This transfer is done identically to a
- MDIO_WRITE except for a different code. To enable clause 45 mode or
- MII_ADDR_C45 into the address. Theoretically clause 45 and normal devices
- can exist on the same bus. Normal devices should ignore the MDIO_ADDR
- phase. */
-static int mdiobb_cmd_addr(struct mdiobb_ctrl *ctrl, int phy, u32 addr)
-{
- unsigned int dev_addr = (addr >> 16) & 0x1F;
- unsigned int reg = addr & 0xFFFF;
- mdiobb_cmd(ctrl, MDIO_C45_ADDR, phy, dev_addr);
-
- /* send the turnaround (10) */
- mdiobb_send_bit(ctrl, 1);
- mdiobb_send_bit(ctrl, 0);
-
- mdiobb_send_num(ctrl, reg, 16);
-
- ctrl->ops->set_mdio_dir(ctrl, 0);
- mdiobb_get_bit(ctrl);
-
- return dev_addr;
-}
-
-static int mdiobb_read(struct mii_bus *bus, int phy, int reg)
-{
- struct mdiobb_ctrl *ctrl = bus->priv;
- int ret, i;
-
- if (reg & MII_ADDR_C45) {
- reg = mdiobb_cmd_addr(ctrl, phy, reg);
- mdiobb_cmd(ctrl, MDIO_C45_READ, phy, reg);
- } else
- mdiobb_cmd(ctrl, MDIO_READ, phy, reg);
-
- ctrl->ops->set_mdio_dir(ctrl, 0);
-
- /* check the turnaround bit: the PHY should be driving it to zero, if this
- * PHY is listed in phy_ignore_ta_mask as having broken TA, skip that
- */
- if (mdiobb_get_bit(ctrl) != 0 &&
- !(bus->phy_ignore_ta_mask & (1 << phy))) {
- /* PHY didn't drive TA low -- flush any bits it
- * may be trying to send.
- */
- for (i = 0; i < 32; i++)
- mdiobb_get_bit(ctrl);
-
- return 0xffff;
- }
-
- ret = mdiobb_get_num(ctrl, 16);
- mdiobb_get_bit(ctrl);
- return ret;
-}
-
-static int mdiobb_write(struct mii_bus *bus, int phy, int reg, u16 val)
-{
- struct mdiobb_ctrl *ctrl = bus->priv;
-
- if (reg & MII_ADDR_C45) {
- reg = mdiobb_cmd_addr(ctrl, phy, reg);
- mdiobb_cmd(ctrl, MDIO_C45_WRITE, phy, reg);
- } else
- mdiobb_cmd(ctrl, MDIO_WRITE, phy, reg);
-
- /* send the turnaround (10) */
- mdiobb_send_bit(ctrl, 1);
- mdiobb_send_bit(ctrl, 0);
-
- mdiobb_send_num(ctrl, val, 16);
-
- ctrl->ops->set_mdio_dir(ctrl, 0);
- mdiobb_get_bit(ctrl);
- return 0;
-}
-
-struct mii_bus *alloc_mdio_bitbang(struct mdiobb_ctrl *ctrl)
-{
- struct mii_bus *bus;
-
- bus = mdiobus_alloc();
- if (!bus)
- return NULL;
-
- __module_get(ctrl->ops->owner);
-
- bus->read = mdiobb_read;
- bus->write = mdiobb_write;
- bus->priv = ctrl;
-
- return bus;
-}
-EXPORT_SYMBOL(alloc_mdio_bitbang);
-
-void free_mdio_bitbang(struct mii_bus *bus)
-{
- struct mdiobb_ctrl *ctrl = bus->priv;
-
- module_put(ctrl->ops->owner);
- mdiobus_free(bus);
-}
-EXPORT_SYMBOL(free_mdio_bitbang);
-
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2009-2016 Cavium, Inc.
- */
-
-#include <linux/delay.h>
-#include <linux/module.h>
-#include <linux/phy.h>
-#include <linux/io.h>
-
-#include "mdio-cavium.h"
-
-static void cavium_mdiobus_set_mode(struct cavium_mdiobus *p,
- enum cavium_mdiobus_mode m)
-{
- union cvmx_smix_clk smi_clk;
-
- if (m == p->mode)
- return;
-
- smi_clk.u64 = oct_mdio_readq(p->register_base + SMI_CLK);
- smi_clk.s.mode = (m == C45) ? 1 : 0;
- smi_clk.s.preamble = 1;
- oct_mdio_writeq(smi_clk.u64, p->register_base + SMI_CLK);
- p->mode = m;
-}
-
-static int cavium_mdiobus_c45_addr(struct cavium_mdiobus *p,
- int phy_id, int regnum)
-{
- union cvmx_smix_cmd smi_cmd;
- union cvmx_smix_wr_dat smi_wr;
- int timeout = 1000;
-
- cavium_mdiobus_set_mode(p, C45);
-
- smi_wr.u64 = 0;
- smi_wr.s.dat = regnum & 0xffff;
- oct_mdio_writeq(smi_wr.u64, p->register_base + SMI_WR_DAT);
-
- regnum = (regnum >> 16) & 0x1f;
-
- smi_cmd.u64 = 0;
- smi_cmd.s.phy_op = 0; /* MDIO_CLAUSE_45_ADDRESS */
- smi_cmd.s.phy_adr = phy_id;
- smi_cmd.s.reg_adr = regnum;
- oct_mdio_writeq(smi_cmd.u64, p->register_base + SMI_CMD);
-
- do {
- /* Wait 1000 clocks so we don't saturate the RSL bus
- * doing reads.
- */
- __delay(1000);
- smi_wr.u64 = oct_mdio_readq(p->register_base + SMI_WR_DAT);
- } while (smi_wr.s.pending && --timeout);
-
- if (timeout <= 0)
- return -EIO;
- return 0;
-}
-
-int cavium_mdiobus_read(struct mii_bus *bus, int phy_id, int regnum)
-{
- struct cavium_mdiobus *p = bus->priv;
- union cvmx_smix_cmd smi_cmd;
- union cvmx_smix_rd_dat smi_rd;
- unsigned int op = 1; /* MDIO_CLAUSE_22_READ */
- int timeout = 1000;
-
- if (regnum & MII_ADDR_C45) {
- int r = cavium_mdiobus_c45_addr(p, phy_id, regnum);
-
- if (r < 0)
- return r;
-
- regnum = (regnum >> 16) & 0x1f;
- op = 3; /* MDIO_CLAUSE_45_READ */
- } else {
- cavium_mdiobus_set_mode(p, C22);
- }
-
- smi_cmd.u64 = 0;
- smi_cmd.s.phy_op = op;
- smi_cmd.s.phy_adr = phy_id;
- smi_cmd.s.reg_adr = regnum;
- oct_mdio_writeq(smi_cmd.u64, p->register_base + SMI_CMD);
-
- do {
- /* Wait 1000 clocks so we don't saturate the RSL bus
- * doing reads.
- */
- __delay(1000);
- smi_rd.u64 = oct_mdio_readq(p->register_base + SMI_RD_DAT);
- } while (smi_rd.s.pending && --timeout);
-
- if (smi_rd.s.val)
- return smi_rd.s.dat;
- else
- return -EIO;
-}
-EXPORT_SYMBOL(cavium_mdiobus_read);
-
-int cavium_mdiobus_write(struct mii_bus *bus, int phy_id, int regnum, u16 val)
-{
- struct cavium_mdiobus *p = bus->priv;
- union cvmx_smix_cmd smi_cmd;
- union cvmx_smix_wr_dat smi_wr;
- unsigned int op = 0; /* MDIO_CLAUSE_22_WRITE */
- int timeout = 1000;
-
- if (regnum & MII_ADDR_C45) {
- int r = cavium_mdiobus_c45_addr(p, phy_id, regnum);
-
- if (r < 0)
- return r;
-
- regnum = (regnum >> 16) & 0x1f;
- op = 1; /* MDIO_CLAUSE_45_WRITE */
- } else {
- cavium_mdiobus_set_mode(p, C22);
- }
-
- smi_wr.u64 = 0;
- smi_wr.s.dat = val;
- oct_mdio_writeq(smi_wr.u64, p->register_base + SMI_WR_DAT);
-
- smi_cmd.u64 = 0;
- smi_cmd.s.phy_op = op;
- smi_cmd.s.phy_adr = phy_id;
- smi_cmd.s.reg_adr = regnum;
- oct_mdio_writeq(smi_cmd.u64, p->register_base + SMI_CMD);
-
- do {
- /* Wait 1000 clocks so we don't saturate the RSL bus
- * doing reads.
- */
- __delay(1000);
- smi_wr.u64 = oct_mdio_readq(p->register_base + SMI_WR_DAT);
- } while (smi_wr.s.pending && --timeout);
-
- if (timeout <= 0)
- return -EIO;
-
- return 0;
-}
-EXPORT_SYMBOL(cavium_mdiobus_write);
-
-MODULE_DESCRIPTION("Common code for OCTEON and Thunder MDIO bus drivers");
-MODULE_AUTHOR("David Daney");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (C) 2009-2016 Cavium, Inc.
- */
-
-enum cavium_mdiobus_mode {
- UNINIT = 0,
- C22,
- C45
-};
-
-#define SMI_CMD 0x0
-#define SMI_WR_DAT 0x8
-#define SMI_RD_DAT 0x10
-#define SMI_CLK 0x18
-#define SMI_EN 0x20
-
-#ifdef __BIG_ENDIAN_BITFIELD
-#define OCT_MDIO_BITFIELD_FIELD(field, more) \
- field; \
- more
-
-#else
-#define OCT_MDIO_BITFIELD_FIELD(field, more) \
- more \
- field;
-
-#endif
-
-union cvmx_smix_clk {
- u64 u64;
- struct cvmx_smix_clk_s {
- OCT_MDIO_BITFIELD_FIELD(u64 reserved_25_63:39,
- OCT_MDIO_BITFIELD_FIELD(u64 mode:1,
- OCT_MDIO_BITFIELD_FIELD(u64 reserved_21_23:3,
- OCT_MDIO_BITFIELD_FIELD(u64 sample_hi:5,
- OCT_MDIO_BITFIELD_FIELD(u64 sample_mode:1,
- OCT_MDIO_BITFIELD_FIELD(u64 reserved_14_14:1,
- OCT_MDIO_BITFIELD_FIELD(u64 clk_idle:1,
- OCT_MDIO_BITFIELD_FIELD(u64 preamble:1,
- OCT_MDIO_BITFIELD_FIELD(u64 sample:4,
- OCT_MDIO_BITFIELD_FIELD(u64 phase:8,
- ;))))))))))
- } s;
-};
-
-union cvmx_smix_cmd {
- u64 u64;
- struct cvmx_smix_cmd_s {
- OCT_MDIO_BITFIELD_FIELD(u64 reserved_18_63:46,
- OCT_MDIO_BITFIELD_FIELD(u64 phy_op:2,
- OCT_MDIO_BITFIELD_FIELD(u64 reserved_13_15:3,
- OCT_MDIO_BITFIELD_FIELD(u64 phy_adr:5,
- OCT_MDIO_BITFIELD_FIELD(u64 reserved_5_7:3,
- OCT_MDIO_BITFIELD_FIELD(u64 reg_adr:5,
- ;))))))
- } s;
-};
-
-union cvmx_smix_en {
- u64 u64;
- struct cvmx_smix_en_s {
- OCT_MDIO_BITFIELD_FIELD(u64 reserved_1_63:63,
- OCT_MDIO_BITFIELD_FIELD(u64 en:1,
- ;))
- } s;
-};
-
-union cvmx_smix_rd_dat {
- u64 u64;
- struct cvmx_smix_rd_dat_s {
- OCT_MDIO_BITFIELD_FIELD(u64 reserved_18_63:46,
- OCT_MDIO_BITFIELD_FIELD(u64 pending:1,
- OCT_MDIO_BITFIELD_FIELD(u64 val:1,
- OCT_MDIO_BITFIELD_FIELD(u64 dat:16,
- ;))))
- } s;
-};
-
-union cvmx_smix_wr_dat {
- u64 u64;
- struct cvmx_smix_wr_dat_s {
- OCT_MDIO_BITFIELD_FIELD(u64 reserved_18_63:46,
- OCT_MDIO_BITFIELD_FIELD(u64 pending:1,
- OCT_MDIO_BITFIELD_FIELD(u64 val:1,
- OCT_MDIO_BITFIELD_FIELD(u64 dat:16,
- ;))))
- } s;
-};
-
-struct cavium_mdiobus {
- struct mii_bus *mii_bus;
- void __iomem *register_base;
- enum cavium_mdiobus_mode mode;
-};
-
-#ifdef CONFIG_CAVIUM_OCTEON_SOC
-
-#include <asm/octeon/octeon.h>
-
-static inline void oct_mdio_writeq(u64 val, void __iomem *addr)
-{
- cvmx_write_csr((u64 __force)addr, val);
-}
-
-static inline u64 oct_mdio_readq(void __iomem *addr)
-{
- return cvmx_read_csr((u64 __force)addr);
-}
-#else
-#include <linux/io-64-nonatomic-lo-hi.h>
-
-#define oct_mdio_writeq(val, addr) writeq(val, addr)
-#define oct_mdio_readq(addr) readq(addr)
-#endif
-
-int cavium_mdiobus_read(struct mii_bus *bus, int phy_id, int regnum);
-int cavium_mdiobus_write(struct mii_bus *bus, int phy_id, int regnum, u16 val);
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/*
- * GPIO based MDIO bitbang driver.
- * Supports OpenFirmware.
- *
- * Copyright (c) 2008 CSE Semaphore Belgium.
- * by Laurent Pinchart <laurentp@cse-semaphore.com>
- *
- * Copyright (C) 2008, Paulius Zaleckas <paulius.zaleckas@teltonika.lt>
- *
- * Based on earlier work by
- *
- * Copyright (c) 2003 Intracom S.A.
- * by Pantelis Antoniou <panto@intracom.gr>
- *
- * 2005 (c) MontaVista Software, Inc.
- * Vitaly Bordug <vbordug@ru.mvista.com>
- */
-
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/interrupt.h>
-#include <linux/platform_device.h>
-#include <linux/platform_data/mdio-gpio.h>
-#include <linux/mdio-bitbang.h>
-#include <linux/mdio-gpio.h>
-#include <linux/gpio/consumer.h>
-#include <linux/of_mdio.h>
-
-struct mdio_gpio_info {
- struct mdiobb_ctrl ctrl;
- struct gpio_desc *mdc, *mdio, *mdo;
-};
-
-static int mdio_gpio_get_data(struct device *dev,
- struct mdio_gpio_info *bitbang)
-{
- bitbang->mdc = devm_gpiod_get_index(dev, NULL, MDIO_GPIO_MDC,
- GPIOD_OUT_LOW);
- if (IS_ERR(bitbang->mdc))
- return PTR_ERR(bitbang->mdc);
-
- bitbang->mdio = devm_gpiod_get_index(dev, NULL, MDIO_GPIO_MDIO,
- GPIOD_IN);
- if (IS_ERR(bitbang->mdio))
- return PTR_ERR(bitbang->mdio);
-
- bitbang->mdo = devm_gpiod_get_index_optional(dev, NULL, MDIO_GPIO_MDO,
- GPIOD_OUT_LOW);
- return PTR_ERR_OR_ZERO(bitbang->mdo);
-}
-
-static void mdio_dir(struct mdiobb_ctrl *ctrl, int dir)
-{
- struct mdio_gpio_info *bitbang =
- container_of(ctrl, struct mdio_gpio_info, ctrl);
-
- if (bitbang->mdo) {
- /* Separate output pin. Always set its value to high
- * when changing direction. If direction is input,
- * assume the pin serves as pull-up. If direction is
- * output, the default value is high.
- */
- gpiod_set_value_cansleep(bitbang->mdo, 1);
- return;
- }
-
- if (dir)
- gpiod_direction_output(bitbang->mdio, 1);
- else
- gpiod_direction_input(bitbang->mdio);
-}
-
-static int mdio_get(struct mdiobb_ctrl *ctrl)
-{
- struct mdio_gpio_info *bitbang =
- container_of(ctrl, struct mdio_gpio_info, ctrl);
-
- return gpiod_get_value_cansleep(bitbang->mdio);
-}
-
-static void mdio_set(struct mdiobb_ctrl *ctrl, int what)
-{
- struct mdio_gpio_info *bitbang =
- container_of(ctrl, struct mdio_gpio_info, ctrl);
-
- if (bitbang->mdo)
- gpiod_set_value_cansleep(bitbang->mdo, what);
- else
- gpiod_set_value_cansleep(bitbang->mdio, what);
-}
-
-static void mdc_set(struct mdiobb_ctrl *ctrl, int what)
-{
- struct mdio_gpio_info *bitbang =
- container_of(ctrl, struct mdio_gpio_info, ctrl);
-
- gpiod_set_value_cansleep(bitbang->mdc, what);
-}
-
-static const struct mdiobb_ops mdio_gpio_ops = {
- .owner = THIS_MODULE,
- .set_mdc = mdc_set,
- .set_mdio_dir = mdio_dir,
- .set_mdio_data = mdio_set,
- .get_mdio_data = mdio_get,
-};
-
-static struct mii_bus *mdio_gpio_bus_init(struct device *dev,
- struct mdio_gpio_info *bitbang,
- int bus_id)
-{
- struct mdio_gpio_platform_data *pdata = dev_get_platdata(dev);
- struct mii_bus *new_bus;
-
- bitbang->ctrl.ops = &mdio_gpio_ops;
-
- new_bus = alloc_mdio_bitbang(&bitbang->ctrl);
- if (!new_bus)
- return NULL;
-
- new_bus->name = "GPIO Bitbanged MDIO";
- new_bus->parent = dev;
-
- if (bus_id != -1)
- snprintf(new_bus->id, MII_BUS_ID_SIZE, "gpio-%x", bus_id);
- else
- strncpy(new_bus->id, "gpio", MII_BUS_ID_SIZE);
-
- if (pdata) {
- new_bus->phy_mask = pdata->phy_mask;
- new_bus->phy_ignore_ta_mask = pdata->phy_ignore_ta_mask;
- }
-
- dev_set_drvdata(dev, new_bus);
-
- return new_bus;
-}
-
-static void mdio_gpio_bus_deinit(struct device *dev)
-{
- struct mii_bus *bus = dev_get_drvdata(dev);
-
- free_mdio_bitbang(bus);
-}
-
-static void mdio_gpio_bus_destroy(struct device *dev)
-{
- struct mii_bus *bus = dev_get_drvdata(dev);
-
- mdiobus_unregister(bus);
- mdio_gpio_bus_deinit(dev);
-}
-
-static int mdio_gpio_probe(struct platform_device *pdev)
-{
- struct mdio_gpio_info *bitbang;
- struct mii_bus *new_bus;
- int ret, bus_id;
-
- bitbang = devm_kzalloc(&pdev->dev, sizeof(*bitbang), GFP_KERNEL);
- if (!bitbang)
- return -ENOMEM;
-
- ret = mdio_gpio_get_data(&pdev->dev, bitbang);
- if (ret)
- return ret;
-
- if (pdev->dev.of_node) {
- bus_id = of_alias_get_id(pdev->dev.of_node, "mdio-gpio");
- if (bus_id < 0) {
- dev_warn(&pdev->dev, "failed to get alias id\n");
- bus_id = 0;
- }
- } else {
- bus_id = pdev->id;
- }
-
- new_bus = mdio_gpio_bus_init(&pdev->dev, bitbang, bus_id);
- if (!new_bus)
- return -ENODEV;
-
- ret = of_mdiobus_register(new_bus, pdev->dev.of_node);
- if (ret)
- mdio_gpio_bus_deinit(&pdev->dev);
-
- return ret;
-}
-
-static int mdio_gpio_remove(struct platform_device *pdev)
-{
- mdio_gpio_bus_destroy(&pdev->dev);
-
- return 0;
-}
-
-static const struct of_device_id mdio_gpio_of_match[] = {
- { .compatible = "virtual,mdio-gpio", },
- { /* sentinel */ }
-};
-MODULE_DEVICE_TABLE(of, mdio_gpio_of_match);
-
-static struct platform_driver mdio_gpio_driver = {
- .probe = mdio_gpio_probe,
- .remove = mdio_gpio_remove,
- .driver = {
- .name = "mdio-gpio",
- .of_match_table = mdio_gpio_of_match,
- },
-};
-
-module_platform_driver(mdio_gpio_driver);
-
-MODULE_ALIAS("platform:mdio-gpio");
-MODULE_AUTHOR("Laurent Pinchart, Paulius Zaleckas");
-MODULE_LICENSE("GPL v2");
-MODULE_DESCRIPTION("Generic driver for MDIO bus emulation using GPIO");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0+
-/*
- * Hisilicon Fast Ethernet MDIO Bus Driver
- *
- * Copyright (c) 2016 HiSilicon Technologies Co., Ltd.
- */
-
-#include <linux/clk.h>
-#include <linux/iopoll.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/of_address.h>
-#include <linux/of_mdio.h>
-#include <linux/platform_device.h>
-
-#define MDIO_RWCTRL 0x00
-#define MDIO_RO_DATA 0x04
-#define MDIO_WRITE BIT(13)
-#define MDIO_RW_FINISH BIT(15)
-#define BIT_PHY_ADDR_OFFSET 8
-#define BIT_WR_DATA_OFFSET 16
-
-struct hisi_femac_mdio_data {
- struct clk *clk;
- void __iomem *membase;
-};
-
-static int hisi_femac_mdio_wait_ready(struct hisi_femac_mdio_data *data)
-{
- u32 val;
-
- return readl_poll_timeout(data->membase + MDIO_RWCTRL,
- val, val & MDIO_RW_FINISH, 20, 10000);
-}
-
-static int hisi_femac_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
-{
- struct hisi_femac_mdio_data *data = bus->priv;
- int ret;
-
- ret = hisi_femac_mdio_wait_ready(data);
- if (ret)
- return ret;
-
- writel((mii_id << BIT_PHY_ADDR_OFFSET) | regnum,
- data->membase + MDIO_RWCTRL);
-
- ret = hisi_femac_mdio_wait_ready(data);
- if (ret)
- return ret;
-
- return readl(data->membase + MDIO_RO_DATA) & 0xFFFF;
-}
-
-static int hisi_femac_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
- u16 value)
-{
- struct hisi_femac_mdio_data *data = bus->priv;
- int ret;
-
- ret = hisi_femac_mdio_wait_ready(data);
- if (ret)
- return ret;
-
- writel(MDIO_WRITE | (value << BIT_WR_DATA_OFFSET) |
- (mii_id << BIT_PHY_ADDR_OFFSET) | regnum,
- data->membase + MDIO_RWCTRL);
-
- return hisi_femac_mdio_wait_ready(data);
-}
-
-static int hisi_femac_mdio_probe(struct platform_device *pdev)
-{
- struct device_node *np = pdev->dev.of_node;
- struct mii_bus *bus;
- struct hisi_femac_mdio_data *data;
- int ret;
-
- bus = mdiobus_alloc_size(sizeof(*data));
- if (!bus)
- return -ENOMEM;
-
- bus->name = "hisi_femac_mii_bus";
- bus->read = &hisi_femac_mdio_read;
- bus->write = &hisi_femac_mdio_write;
- snprintf(bus->id, MII_BUS_ID_SIZE, "%s", pdev->name);
- bus->parent = &pdev->dev;
-
- data = bus->priv;
- data->membase = devm_platform_ioremap_resource(pdev, 0);
- if (IS_ERR(data->membase)) {
- ret = PTR_ERR(data->membase);
- goto err_out_free_mdiobus;
- }
-
- data->clk = devm_clk_get(&pdev->dev, NULL);
- if (IS_ERR(data->clk)) {
- ret = PTR_ERR(data->clk);
- goto err_out_free_mdiobus;
- }
-
- ret = clk_prepare_enable(data->clk);
- if (ret)
- goto err_out_free_mdiobus;
-
- ret = of_mdiobus_register(bus, np);
- if (ret)
- goto err_out_disable_clk;
-
- platform_set_drvdata(pdev, bus);
-
- return 0;
-
-err_out_disable_clk:
- clk_disable_unprepare(data->clk);
-err_out_free_mdiobus:
- mdiobus_free(bus);
- return ret;
-}
-
-static int hisi_femac_mdio_remove(struct platform_device *pdev)
-{
- struct mii_bus *bus = platform_get_drvdata(pdev);
- struct hisi_femac_mdio_data *data = bus->priv;
-
- mdiobus_unregister(bus);
- clk_disable_unprepare(data->clk);
- mdiobus_free(bus);
-
- return 0;
-}
-
-static const struct of_device_id hisi_femac_mdio_dt_ids[] = {
- { .compatible = "hisilicon,hisi-femac-mdio" },
- { }
-};
-MODULE_DEVICE_TABLE(of, hisi_femac_mdio_dt_ids);
-
-static struct platform_driver hisi_femac_mdio_driver = {
- .probe = hisi_femac_mdio_probe,
- .remove = hisi_femac_mdio_remove,
- .driver = {
- .name = "hisi-femac-mdio",
- .of_match_table = hisi_femac_mdio_dt_ids,
- },
-};
-
-module_platform_driver(hisi_femac_mdio_driver);
-
-MODULE_DESCRIPTION("Hisilicon Fast Ethernet MAC MDIO interface driver");
-MODULE_AUTHOR("Dongpo Li <lidongpo@hisilicon.com>");
-MODULE_LICENSE("GPL");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/*
- * MDIO I2C bridge
- *
- * Copyright (C) 2015-2016 Russell King
- *
- * Network PHYs can appear on I2C buses when they are part of SFP module.
- * This driver exposes these PHYs to the networking PHY code, allowing
- * our PHY drivers access to these PHYs, and so allowing configuration
- * of their settings.
- */
-#include <linux/i2c.h>
-#include <linux/mdio/mdio-i2c.h>
-#include <linux/phy.h>
-
-/*
- * I2C bus addresses 0x50 and 0x51 are normally an EEPROM, which is
- * specified to be present in SFP modules. These correspond with PHY
- * addresses 16 and 17. Disallow access to these "phy" addresses.
- */
-static bool i2c_mii_valid_phy_id(int phy_id)
-{
- return phy_id != 0x10 && phy_id != 0x11;
-}
-
-static unsigned int i2c_mii_phy_addr(int phy_id)
-{
- return phy_id + 0x40;
-}
-
-static int i2c_mii_read(struct mii_bus *bus, int phy_id, int reg)
-{
- struct i2c_adapter *i2c = bus->priv;
- struct i2c_msg msgs[2];
- u8 addr[3], data[2], *p;
- int bus_addr, ret;
-
- if (!i2c_mii_valid_phy_id(phy_id))
- return 0xffff;
-
- p = addr;
- if (reg & MII_ADDR_C45) {
- *p++ = 0x20 | ((reg >> 16) & 31);
- *p++ = reg >> 8;
- }
- *p++ = reg;
-
- bus_addr = i2c_mii_phy_addr(phy_id);
- msgs[0].addr = bus_addr;
- msgs[0].flags = 0;
- msgs[0].len = p - addr;
- msgs[0].buf = addr;
- msgs[1].addr = bus_addr;
- msgs[1].flags = I2C_M_RD;
- msgs[1].len = sizeof(data);
- msgs[1].buf = data;
-
- ret = i2c_transfer(i2c, msgs, ARRAY_SIZE(msgs));
- if (ret != ARRAY_SIZE(msgs))
- return 0xffff;
-
- return data[0] << 8 | data[1];
-}
-
-static int i2c_mii_write(struct mii_bus *bus, int phy_id, int reg, u16 val)
-{
- struct i2c_adapter *i2c = bus->priv;
- struct i2c_msg msg;
- int ret;
- u8 data[5], *p;
-
- if (!i2c_mii_valid_phy_id(phy_id))
- return 0;
-
- p = data;
- if (reg & MII_ADDR_C45) {
- *p++ = (reg >> 16) & 31;
- *p++ = reg >> 8;
- }
- *p++ = reg;
- *p++ = val >> 8;
- *p++ = val;
-
- msg.addr = i2c_mii_phy_addr(phy_id);
- msg.flags = 0;
- msg.len = p - data;
- msg.buf = data;
-
- ret = i2c_transfer(i2c, &msg, 1);
-
- return ret < 0 ? ret : 0;
-}
-
-struct mii_bus *mdio_i2c_alloc(struct device *parent, struct i2c_adapter *i2c)
-{
- struct mii_bus *mii;
-
- if (!i2c_check_functionality(i2c, I2C_FUNC_I2C))
- return ERR_PTR(-EINVAL);
-
- mii = mdiobus_alloc();
- if (!mii)
- return ERR_PTR(-ENOMEM);
-
- snprintf(mii->id, MII_BUS_ID_SIZE, "i2c:%s", dev_name(parent));
- mii->parent = parent;
- mii->read = i2c_mii_read;
- mii->write = i2c_mii_write;
- mii->priv = i2c;
-
- return mii;
-}
-EXPORT_SYMBOL_GPL(mdio_i2c_alloc);
-
-MODULE_AUTHOR("Russell King");
-MODULE_DESCRIPTION("MDIO I2C bridge library");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
-/* Copyright (c) 2015, The Linux Foundation. All rights reserved. */
-/* Copyright (c) 2020 Sartura Ltd. */
-
-#include <linux/delay.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/io.h>
-#include <linux/iopoll.h>
-#include <linux/of_address.h>
-#include <linux/of_mdio.h>
-#include <linux/phy.h>
-#include <linux/platform_device.h>
-
-#define MDIO_ADDR_REG 0x44
-#define MDIO_DATA_WRITE_REG 0x48
-#define MDIO_DATA_READ_REG 0x4c
-#define MDIO_CMD_REG 0x50
-#define MDIO_CMD_ACCESS_BUSY BIT(16)
-#define MDIO_CMD_ACCESS_START BIT(8)
-#define MDIO_CMD_ACCESS_CODE_READ 0
-#define MDIO_CMD_ACCESS_CODE_WRITE 1
-
-#define ipq4019_MDIO_TIMEOUT 10000
-#define ipq4019_MDIO_SLEEP 10
-
-struct ipq4019_mdio_data {
- void __iomem *membase;
-};
-
-static int ipq4019_mdio_wait_busy(struct mii_bus *bus)
-{
- struct ipq4019_mdio_data *priv = bus->priv;
- unsigned int busy;
-
- return readl_poll_timeout(priv->membase + MDIO_CMD_REG, busy,
- (busy & MDIO_CMD_ACCESS_BUSY) == 0,
- ipq4019_MDIO_SLEEP, ipq4019_MDIO_TIMEOUT);
-}
-
-static int ipq4019_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
-{
- struct ipq4019_mdio_data *priv = bus->priv;
- unsigned int cmd;
-
- /* Reject clause 45 */
- if (regnum & MII_ADDR_C45)
- return -EOPNOTSUPP;
-
- if (ipq4019_mdio_wait_busy(bus))
- return -ETIMEDOUT;
-
- /* issue the phy address and reg */
- writel((mii_id << 8) | regnum, priv->membase + MDIO_ADDR_REG);
-
- cmd = MDIO_CMD_ACCESS_START | MDIO_CMD_ACCESS_CODE_READ;
-
- /* issue read command */
- writel(cmd, priv->membase + MDIO_CMD_REG);
-
- /* Wait read complete */
- if (ipq4019_mdio_wait_busy(bus))
- return -ETIMEDOUT;
-
- /* Read and return data */
- return readl(priv->membase + MDIO_DATA_READ_REG);
-}
-
-static int ipq4019_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
- u16 value)
-{
- struct ipq4019_mdio_data *priv = bus->priv;
- unsigned int cmd;
-
- /* Reject clause 45 */
- if (regnum & MII_ADDR_C45)
- return -EOPNOTSUPP;
-
- if (ipq4019_mdio_wait_busy(bus))
- return -ETIMEDOUT;
-
- /* issue the phy address and reg */
- writel((mii_id << 8) | regnum, priv->membase + MDIO_ADDR_REG);
-
- /* issue write data */
- writel(value, priv->membase + MDIO_DATA_WRITE_REG);
-
- cmd = MDIO_CMD_ACCESS_START | MDIO_CMD_ACCESS_CODE_WRITE;
- /* issue write command */
- writel(cmd, priv->membase + MDIO_CMD_REG);
-
- /* Wait write complete */
- if (ipq4019_mdio_wait_busy(bus))
- return -ETIMEDOUT;
-
- return 0;
-}
-
-static int ipq4019_mdio_probe(struct platform_device *pdev)
-{
- struct ipq4019_mdio_data *priv;
- struct mii_bus *bus;
- int ret;
-
- bus = devm_mdiobus_alloc_size(&pdev->dev, sizeof(*priv));
- if (!bus)
- return -ENOMEM;
-
- priv = bus->priv;
-
- priv->membase = devm_platform_ioremap_resource(pdev, 0);
- if (IS_ERR(priv->membase))
- return PTR_ERR(priv->membase);
-
- bus->name = "ipq4019_mdio";
- bus->read = ipq4019_mdio_read;
- bus->write = ipq4019_mdio_write;
- bus->parent = &pdev->dev;
- snprintf(bus->id, MII_BUS_ID_SIZE, "%s%d", pdev->name, pdev->id);
-
- ret = of_mdiobus_register(bus, pdev->dev.of_node);
- if (ret) {
- dev_err(&pdev->dev, "Cannot register MDIO bus!\n");
- return ret;
- }
-
- platform_set_drvdata(pdev, bus);
-
- return 0;
-}
-
-static int ipq4019_mdio_remove(struct platform_device *pdev)
-{
- struct mii_bus *bus = platform_get_drvdata(pdev);
-
- mdiobus_unregister(bus);
-
- return 0;
-}
-
-static const struct of_device_id ipq4019_mdio_dt_ids[] = {
- { .compatible = "qcom,ipq4019-mdio" },
- { }
-};
-MODULE_DEVICE_TABLE(of, ipq4019_mdio_dt_ids);
-
-static struct platform_driver ipq4019_mdio_driver = {
- .probe = ipq4019_mdio_probe,
- .remove = ipq4019_mdio_remove,
- .driver = {
- .name = "ipq4019-mdio",
- .of_match_table = ipq4019_mdio_dt_ids,
- },
-};
-
-module_platform_driver(ipq4019_mdio_driver);
-
-MODULE_DESCRIPTION("ipq4019 MDIO interface driver");
-MODULE_AUTHOR("Qualcomm Atheros");
-MODULE_LICENSE("Dual BSD/GPL");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/* Qualcomm IPQ8064 MDIO interface driver
- *
- * Copyright (C) 2019 Christian Lamparter <chunkeey@gmail.com>
- * Copyright (C) 2020 Ansuel Smith <ansuelsmth@gmail.com>
- */
-
-#include <linux/delay.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/regmap.h>
-#include <linux/of_mdio.h>
-#include <linux/phy.h>
-#include <linux/platform_device.h>
-#include <linux/mfd/syscon.h>
-
-/* MII address register definitions */
-#define MII_ADDR_REG_ADDR 0x10
-#define MII_BUSY BIT(0)
-#define MII_WRITE BIT(1)
-#define MII_CLKRANGE_60_100M (0 << 2)
-#define MII_CLKRANGE_100_150M (1 << 2)
-#define MII_CLKRANGE_20_35M (2 << 2)
-#define MII_CLKRANGE_35_60M (3 << 2)
-#define MII_CLKRANGE_150_250M (4 << 2)
-#define MII_CLKRANGE_250_300M (5 << 2)
-#define MII_CLKRANGE_MASK GENMASK(4, 2)
-#define MII_REG_SHIFT 6
-#define MII_REG_MASK GENMASK(10, 6)
-#define MII_ADDR_SHIFT 11
-#define MII_ADDR_MASK GENMASK(15, 11)
-
-#define MII_DATA_REG_ADDR 0x14
-
-#define MII_MDIO_DELAY_USEC (1000)
-#define MII_MDIO_RETRY_MSEC (10)
-
-struct ipq8064_mdio {
- struct regmap *base; /* NSS_GMAC0_BASE */
-};
-
-static int
-ipq8064_mdio_wait_busy(struct ipq8064_mdio *priv)
-{
- u32 busy;
-
- return regmap_read_poll_timeout(priv->base, MII_ADDR_REG_ADDR, busy,
- !(busy & MII_BUSY), MII_MDIO_DELAY_USEC,
- MII_MDIO_RETRY_MSEC * USEC_PER_MSEC);
-}
-
-static int
-ipq8064_mdio_read(struct mii_bus *bus, int phy_addr, int reg_offset)
-{
- u32 miiaddr = MII_BUSY | MII_CLKRANGE_250_300M;
- struct ipq8064_mdio *priv = bus->priv;
- u32 ret_val;
- int err;
-
- /* Reject clause 45 */
- if (reg_offset & MII_ADDR_C45)
- return -EOPNOTSUPP;
-
- miiaddr |= ((phy_addr << MII_ADDR_SHIFT) & MII_ADDR_MASK) |
- ((reg_offset << MII_REG_SHIFT) & MII_REG_MASK);
-
- regmap_write(priv->base, MII_ADDR_REG_ADDR, miiaddr);
- usleep_range(8, 10);
-
- err = ipq8064_mdio_wait_busy(priv);
- if (err)
- return err;
-
- regmap_read(priv->base, MII_DATA_REG_ADDR, &ret_val);
- return (int)ret_val;
-}
-
-static int
-ipq8064_mdio_write(struct mii_bus *bus, int phy_addr, int reg_offset, u16 data)
-{
- u32 miiaddr = MII_WRITE | MII_BUSY | MII_CLKRANGE_250_300M;
- struct ipq8064_mdio *priv = bus->priv;
-
- /* Reject clause 45 */
- if (reg_offset & MII_ADDR_C45)
- return -EOPNOTSUPP;
-
- regmap_write(priv->base, MII_DATA_REG_ADDR, data);
-
- miiaddr |= ((phy_addr << MII_ADDR_SHIFT) & MII_ADDR_MASK) |
- ((reg_offset << MII_REG_SHIFT) & MII_REG_MASK);
-
- regmap_write(priv->base, MII_ADDR_REG_ADDR, miiaddr);
- usleep_range(8, 10);
-
- return ipq8064_mdio_wait_busy(priv);
-}
-
-static int
-ipq8064_mdio_probe(struct platform_device *pdev)
-{
- struct device_node *np = pdev->dev.of_node;
- struct ipq8064_mdio *priv;
- struct mii_bus *bus;
- int ret;
-
- bus = devm_mdiobus_alloc_size(&pdev->dev, sizeof(*priv));
- if (!bus)
- return -ENOMEM;
-
- bus->name = "ipq8064_mdio_bus";
- bus->read = ipq8064_mdio_read;
- bus->write = ipq8064_mdio_write;
- snprintf(bus->id, MII_BUS_ID_SIZE, "%s-mii", dev_name(&pdev->dev));
- bus->parent = &pdev->dev;
-
- priv = bus->priv;
- priv->base = device_node_to_regmap(np);
- if (IS_ERR(priv->base)) {
- if (priv->base == ERR_PTR(-EPROBE_DEFER))
- return -EPROBE_DEFER;
-
- dev_err(&pdev->dev, "error getting device regmap, error=%pe\n",
- priv->base);
- return PTR_ERR(priv->base);
- }
-
- ret = of_mdiobus_register(bus, np);
- if (ret)
- return ret;
-
- platform_set_drvdata(pdev, bus);
- return 0;
-}
-
-static int
-ipq8064_mdio_remove(struct platform_device *pdev)
-{
- struct mii_bus *bus = platform_get_drvdata(pdev);
-
- mdiobus_unregister(bus);
-
- return 0;
-}
-
-static const struct of_device_id ipq8064_mdio_dt_ids[] = {
- { .compatible = "qcom,ipq8064-mdio" },
- { }
-};
-MODULE_DEVICE_TABLE(of, ipq8064_mdio_dt_ids);
-
-static struct platform_driver ipq8064_mdio_driver = {
- .probe = ipq8064_mdio_probe,
- .remove = ipq8064_mdio_remove,
- .driver = {
- .name = "ipq8064-mdio",
- .of_match_table = ipq8064_mdio_dt_ids,
- },
-};
-
-module_platform_driver(ipq8064_mdio_driver);
-
-MODULE_DESCRIPTION("Qualcomm IPQ8064 MDIO interface driver");
-MODULE_AUTHOR("Christian Lamparter <chunkeey@gmail.com>");
-MODULE_AUTHOR("Ansuel Smith <ansuelsmth@gmail.com>");
-MODULE_LICENSE("GPL");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/* MOXA ART Ethernet (RTL8201CP) MDIO interface driver
- *
- * Copyright (C) 2013 Jonas Jensen <jonas.jensen@gmail.com>
- */
-
-#include <linux/delay.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/mutex.h>
-#include <linux/of_address.h>
-#include <linux/of_mdio.h>
-#include <linux/phy.h>
-#include <linux/platform_device.h>
-
-#define REG_PHY_CTRL 0
-#define REG_PHY_WRITE_DATA 4
-
-/* REG_PHY_CTRL */
-#define MIIWR BIT(27) /* init write sequence (auto cleared)*/
-#define MIIRD BIT(26)
-#define REGAD_MASK 0x3e00000
-#define PHYAD_MASK 0x1f0000
-#define MIIRDATA_MASK 0xffff
-
-/* REG_PHY_WRITE_DATA */
-#define MIIWDATA_MASK 0xffff
-
-struct moxart_mdio_data {
- void __iomem *base;
-};
-
-static int moxart_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
-{
- struct moxart_mdio_data *data = bus->priv;
- u32 ctrl = 0;
- unsigned int count = 5;
-
- dev_dbg(&bus->dev, "%s\n", __func__);
-
- ctrl |= MIIRD | ((mii_id << 16) & PHYAD_MASK) |
- ((regnum << 21) & REGAD_MASK);
-
- writel(ctrl, data->base + REG_PHY_CTRL);
-
- do {
- ctrl = readl(data->base + REG_PHY_CTRL);
-
- if (!(ctrl & MIIRD))
- return ctrl & MIIRDATA_MASK;
-
- mdelay(10);
- count--;
- } while (count > 0);
-
- dev_dbg(&bus->dev, "%s timed out\n", __func__);
-
- return -ETIMEDOUT;
-}
-
-static int moxart_mdio_write(struct mii_bus *bus, int mii_id,
- int regnum, u16 value)
-{
- struct moxart_mdio_data *data = bus->priv;
- u32 ctrl = 0;
- unsigned int count = 5;
-
- dev_dbg(&bus->dev, "%s\n", __func__);
-
- ctrl |= MIIWR | ((mii_id << 16) & PHYAD_MASK) |
- ((regnum << 21) & REGAD_MASK);
-
- value &= MIIWDATA_MASK;
-
- writel(value, data->base + REG_PHY_WRITE_DATA);
- writel(ctrl, data->base + REG_PHY_CTRL);
-
- do {
- ctrl = readl(data->base + REG_PHY_CTRL);
-
- if (!(ctrl & MIIWR))
- return 0;
-
- mdelay(10);
- count--;
- } while (count > 0);
-
- dev_dbg(&bus->dev, "%s timed out\n", __func__);
-
- return -ETIMEDOUT;
-}
-
-static int moxart_mdio_reset(struct mii_bus *bus)
-{
- int data, i;
-
- for (i = 0; i < PHY_MAX_ADDR; i++) {
- data = moxart_mdio_read(bus, i, MII_BMCR);
- if (data < 0)
- continue;
-
- data |= BMCR_RESET;
- if (moxart_mdio_write(bus, i, MII_BMCR, data) < 0)
- continue;
- }
-
- return 0;
-}
-
-static int moxart_mdio_probe(struct platform_device *pdev)
-{
- struct device_node *np = pdev->dev.of_node;
- struct mii_bus *bus;
- struct moxart_mdio_data *data;
- int ret, i;
-
- bus = mdiobus_alloc_size(sizeof(*data));
- if (!bus)
- return -ENOMEM;
-
- bus->name = "MOXA ART Ethernet MII";
- bus->read = &moxart_mdio_read;
- bus->write = &moxart_mdio_write;
- bus->reset = &moxart_mdio_reset;
- snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d-mii", pdev->name, pdev->id);
- bus->parent = &pdev->dev;
-
- /* Setting PHY_IGNORE_INTERRUPT here even if it has no effect,
- * of_mdiobus_register() sets these PHY_POLL.
- * Ideally, the interrupt from MAC controller could be used to
- * detect link state changes, not polling, i.e. if there was
- * a way phy_driver could set PHY_HAS_INTERRUPT but have that
- * interrupt handled in ethernet drivercode.
- */
- for (i = 0; i < PHY_MAX_ADDR; i++)
- bus->irq[i] = PHY_IGNORE_INTERRUPT;
-
- data = bus->priv;
- data->base = devm_platform_ioremap_resource(pdev, 0);
- if (IS_ERR(data->base)) {
- ret = PTR_ERR(data->base);
- goto err_out_free_mdiobus;
- }
-
- ret = of_mdiobus_register(bus, np);
- if (ret < 0)
- goto err_out_free_mdiobus;
-
- platform_set_drvdata(pdev, bus);
-
- return 0;
-
-err_out_free_mdiobus:
- mdiobus_free(bus);
- return ret;
-}
-
-static int moxart_mdio_remove(struct platform_device *pdev)
-{
- struct mii_bus *bus = platform_get_drvdata(pdev);
-
- mdiobus_unregister(bus);
- mdiobus_free(bus);
-
- return 0;
-}
-
-static const struct of_device_id moxart_mdio_dt_ids[] = {
- { .compatible = "moxa,moxart-mdio" },
- { }
-};
-MODULE_DEVICE_TABLE(of, moxart_mdio_dt_ids);
-
-static struct platform_driver moxart_mdio_driver = {
- .probe = moxart_mdio_probe,
- .remove = moxart_mdio_remove,
- .driver = {
- .name = "moxart-mdio",
- .of_match_table = moxart_mdio_dt_ids,
- },
-};
-
-module_platform_driver(moxart_mdio_driver);
-
-MODULE_DESCRIPTION("MOXA ART MDIO interface driver");
-MODULE_AUTHOR("Jonas Jensen <jonas.jensen@gmail.com>");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-// SPDX-License-Identifier: (GPL-2.0 OR MIT)
-/*
- * Driver for the MDIO interface of Microsemi network switches.
- *
- * Author: Alexandre Belloni <alexandre.belloni@bootlin.com>
- * Copyright (c) 2017 Microsemi Corporation
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/phy.h>
-#include <linux/platform_device.h>
-#include <linux/bitops.h>
-#include <linux/io.h>
-#include <linux/iopoll.h>
-#include <linux/of_mdio.h>
-
-#define MSCC_MIIM_REG_STATUS 0x0
-#define MSCC_MIIM_STATUS_STAT_PENDING BIT(2)
-#define MSCC_MIIM_STATUS_STAT_BUSY BIT(3)
-#define MSCC_MIIM_REG_CMD 0x8
-#define MSCC_MIIM_CMD_OPR_WRITE BIT(1)
-#define MSCC_MIIM_CMD_OPR_READ BIT(2)
-#define MSCC_MIIM_CMD_WRDATA_SHIFT 4
-#define MSCC_MIIM_CMD_REGAD_SHIFT 20
-#define MSCC_MIIM_CMD_PHYAD_SHIFT 25
-#define MSCC_MIIM_CMD_VLD BIT(31)
-#define MSCC_MIIM_REG_DATA 0xC
-#define MSCC_MIIM_DATA_ERROR (BIT(16) | BIT(17))
-
-#define MSCC_PHY_REG_PHY_CFG 0x0
-#define PHY_CFG_PHY_ENA (BIT(0) | BIT(1) | BIT(2) | BIT(3))
-#define PHY_CFG_PHY_COMMON_RESET BIT(4)
-#define PHY_CFG_PHY_RESET (BIT(5) | BIT(6) | BIT(7) | BIT(8))
-#define MSCC_PHY_REG_PHY_STATUS 0x4
-
-struct mscc_miim_dev {
- void __iomem *regs;
- void __iomem *phy_regs;
-};
-
-/* When high resolution timers aren't built-in: we can't use usleep_range() as
- * we would sleep way too long. Use udelay() instead.
- */
-#define mscc_readl_poll_timeout(addr, val, cond, delay_us, timeout_us) \
-({ \
- if (!IS_ENABLED(CONFIG_HIGH_RES_TIMERS)) \
- readl_poll_timeout_atomic(addr, val, cond, delay_us, \
- timeout_us); \
- readl_poll_timeout(addr, val, cond, delay_us, timeout_us); \
-})
-
-static int mscc_miim_wait_ready(struct mii_bus *bus)
-{
- struct mscc_miim_dev *miim = bus->priv;
- u32 val;
-
- return mscc_readl_poll_timeout(miim->regs + MSCC_MIIM_REG_STATUS, val,
- !(val & MSCC_MIIM_STATUS_STAT_BUSY), 50,
- 10000);
-}
-
-static int mscc_miim_wait_pending(struct mii_bus *bus)
-{
- struct mscc_miim_dev *miim = bus->priv;
- u32 val;
-
- return mscc_readl_poll_timeout(miim->regs + MSCC_MIIM_REG_STATUS, val,
- !(val & MSCC_MIIM_STATUS_STAT_PENDING),
- 50, 10000);
-}
-
-static int mscc_miim_read(struct mii_bus *bus, int mii_id, int regnum)
-{
- struct mscc_miim_dev *miim = bus->priv;
- u32 val;
- int ret;
-
- ret = mscc_miim_wait_pending(bus);
- if (ret)
- goto out;
-
- writel(MSCC_MIIM_CMD_VLD | (mii_id << MSCC_MIIM_CMD_PHYAD_SHIFT) |
- (regnum << MSCC_MIIM_CMD_REGAD_SHIFT) | MSCC_MIIM_CMD_OPR_READ,
- miim->regs + MSCC_MIIM_REG_CMD);
-
- ret = mscc_miim_wait_ready(bus);
- if (ret)
- goto out;
-
- val = readl(miim->regs + MSCC_MIIM_REG_DATA);
- if (val & MSCC_MIIM_DATA_ERROR) {
- ret = -EIO;
- goto out;
- }
-
- ret = val & 0xFFFF;
-out:
- return ret;
-}
-
-static int mscc_miim_write(struct mii_bus *bus, int mii_id,
- int regnum, u16 value)
-{
- struct mscc_miim_dev *miim = bus->priv;
- int ret;
-
- ret = mscc_miim_wait_pending(bus);
- if (ret < 0)
- goto out;
-
- writel(MSCC_MIIM_CMD_VLD | (mii_id << MSCC_MIIM_CMD_PHYAD_SHIFT) |
- (regnum << MSCC_MIIM_CMD_REGAD_SHIFT) |
- (value << MSCC_MIIM_CMD_WRDATA_SHIFT) |
- MSCC_MIIM_CMD_OPR_WRITE,
- miim->regs + MSCC_MIIM_REG_CMD);
-
-out:
- return ret;
-}
-
-static int mscc_miim_reset(struct mii_bus *bus)
-{
- struct mscc_miim_dev *miim = bus->priv;
-
- if (miim->phy_regs) {
- writel(0, miim->phy_regs + MSCC_PHY_REG_PHY_CFG);
- writel(0x1ff, miim->phy_regs + MSCC_PHY_REG_PHY_CFG);
- mdelay(500);
- }
-
- return 0;
-}
-
-static int mscc_miim_probe(struct platform_device *pdev)
-{
- struct resource *res;
- struct mii_bus *bus;
- struct mscc_miim_dev *dev;
- int ret;
-
- res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- if (!res)
- return -ENODEV;
-
- bus = devm_mdiobus_alloc_size(&pdev->dev, sizeof(*dev));
- if (!bus)
- return -ENOMEM;
-
- bus->name = "mscc_miim";
- bus->read = mscc_miim_read;
- bus->write = mscc_miim_write;
- bus->reset = mscc_miim_reset;
- snprintf(bus->id, MII_BUS_ID_SIZE, "%s-mii", dev_name(&pdev->dev));
- bus->parent = &pdev->dev;
-
- dev = bus->priv;
- dev->regs = devm_ioremap_resource(&pdev->dev, res);
- if (IS_ERR(dev->regs)) {
- dev_err(&pdev->dev, "Unable to map MIIM registers\n");
- return PTR_ERR(dev->regs);
- }
-
- res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
- if (res) {
- dev->phy_regs = devm_ioremap_resource(&pdev->dev, res);
- if (IS_ERR(dev->phy_regs)) {
- dev_err(&pdev->dev, "Unable to map internal phy registers\n");
- return PTR_ERR(dev->phy_regs);
- }
- }
-
- ret = of_mdiobus_register(bus, pdev->dev.of_node);
- if (ret < 0) {
- dev_err(&pdev->dev, "Cannot register MDIO bus (%d)\n", ret);
- return ret;
- }
-
- platform_set_drvdata(pdev, bus);
-
- return 0;
-}
-
-static int mscc_miim_remove(struct platform_device *pdev)
-{
- struct mii_bus *bus = platform_get_drvdata(pdev);
-
- mdiobus_unregister(bus);
-
- return 0;
-}
-
-static const struct of_device_id mscc_miim_match[] = {
- { .compatible = "mscc,ocelot-miim" },
- { }
-};
-MODULE_DEVICE_TABLE(of, mscc_miim_match);
-
-static struct platform_driver mscc_miim_driver = {
- .probe = mscc_miim_probe,
- .remove = mscc_miim_remove,
- .driver = {
- .name = "mscc-miim",
- .of_match_table = mscc_miim_match,
- },
-};
-
-module_platform_driver(mscc_miim_driver);
-
-MODULE_DESCRIPTION("Microsemi MIIM driver");
-MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@bootlin.com>");
-MODULE_LICENSE("Dual MIT/GPL");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright 2016 Broadcom
- */
-#include <linux/clk.h>
-#include <linux/platform_device.h>
-#include <linux/device.h>
-#include <linux/of_mdio.h>
-#include <linux/module.h>
-#include <linux/phy.h>
-#include <linux/mdio-mux.h>
-#include <linux/delay.h>
-#include <linux/iopoll.h>
-
-#define MDIO_RATE_ADJ_EXT_OFFSET 0x000
-#define MDIO_RATE_ADJ_INT_OFFSET 0x004
-#define MDIO_RATE_ADJ_DIVIDENT_SHIFT 16
-
-#define MDIO_SCAN_CTRL_OFFSET 0x008
-#define MDIO_SCAN_CTRL_OVRIDE_EXT_MSTR 28
-
-#define MDIO_PARAM_OFFSET 0x23c
-#define MDIO_PARAM_MIIM_CYCLE 29
-#define MDIO_PARAM_INTERNAL_SEL 25
-#define MDIO_PARAM_BUS_ID 22
-#define MDIO_PARAM_C45_SEL 21
-#define MDIO_PARAM_PHY_ID 16
-#define MDIO_PARAM_PHY_DATA 0
-
-#define MDIO_READ_OFFSET 0x240
-#define MDIO_READ_DATA_MASK 0xffff
-#define MDIO_ADDR_OFFSET 0x244
-
-#define MDIO_CTRL_OFFSET 0x248
-#define MDIO_CTRL_WRITE_OP 0x1
-#define MDIO_CTRL_READ_OP 0x2
-
-#define MDIO_STAT_OFFSET 0x24c
-#define MDIO_STAT_DONE 1
-
-#define BUS_MAX_ADDR 32
-#define EXT_BUS_START_ADDR 16
-
-#define MDIO_REG_ADDR_SPACE_SIZE 0x250
-
-#define MDIO_OPERATING_FREQUENCY 11000000
-#define MDIO_RATE_ADJ_DIVIDENT 1
-
-struct iproc_mdiomux_desc {
- void *mux_handle;
- void __iomem *base;
- struct device *dev;
- struct mii_bus *mii_bus;
- struct clk *core_clk;
-};
-
-static void mdio_mux_iproc_config(struct iproc_mdiomux_desc *md)
-{
- u32 divisor;
- u32 val;
-
- /* Disable external mdio master access */
- val = readl(md->base + MDIO_SCAN_CTRL_OFFSET);
- val |= BIT(MDIO_SCAN_CTRL_OVRIDE_EXT_MSTR);
- writel(val, md->base + MDIO_SCAN_CTRL_OFFSET);
-
- if (md->core_clk) {
- /* use rate adjust regs to derrive the mdio's operating
- * frequency from the specified core clock
- */
- divisor = clk_get_rate(md->core_clk) / MDIO_OPERATING_FREQUENCY;
- divisor = divisor / (MDIO_RATE_ADJ_DIVIDENT + 1);
- val = divisor;
- val |= MDIO_RATE_ADJ_DIVIDENT << MDIO_RATE_ADJ_DIVIDENT_SHIFT;
- writel(val, md->base + MDIO_RATE_ADJ_EXT_OFFSET);
- writel(val, md->base + MDIO_RATE_ADJ_INT_OFFSET);
- }
-}
-
-static int iproc_mdio_wait_for_idle(void __iomem *base, bool result)
-{
- u32 val;
-
- return readl_poll_timeout(base + MDIO_STAT_OFFSET, val,
- (val & MDIO_STAT_DONE) == result,
- 2000, 1000000);
-}
-
-/* start_miim_ops- Program and start MDIO transaction over mdio bus.
- * @base: Base address
- * @phyid: phyid of the selected bus.
- * @reg: register offset to be read/written.
- * @val :0 if read op else value to be written in @reg;
- * @op: Operation that need to be carried out.
- * MDIO_CTRL_READ_OP: Read transaction.
- * MDIO_CTRL_WRITE_OP: Write transaction.
- *
- * Return value: Successful Read operation returns read reg values and write
- * operation returns 0. Failure operation returns negative error code.
- */
-static int start_miim_ops(void __iomem *base,
- u16 phyid, u32 reg, u16 val, u32 op)
-{
- u32 param;
- int ret;
-
- writel(0, base + MDIO_CTRL_OFFSET);
- ret = iproc_mdio_wait_for_idle(base, 0);
- if (ret)
- goto err;
-
- param = readl(base + MDIO_PARAM_OFFSET);
- param |= phyid << MDIO_PARAM_PHY_ID;
- param |= val << MDIO_PARAM_PHY_DATA;
- if (reg & MII_ADDR_C45)
- param |= BIT(MDIO_PARAM_C45_SEL);
-
- writel(param, base + MDIO_PARAM_OFFSET);
-
- writel(reg, base + MDIO_ADDR_OFFSET);
-
- writel(op, base + MDIO_CTRL_OFFSET);
-
- ret = iproc_mdio_wait_for_idle(base, 1);
- if (ret)
- goto err;
-
- if (op == MDIO_CTRL_READ_OP)
- ret = readl(base + MDIO_READ_OFFSET) & MDIO_READ_DATA_MASK;
-err:
- return ret;
-}
-
-static int iproc_mdiomux_read(struct mii_bus *bus, int phyid, int reg)
-{
- struct iproc_mdiomux_desc *md = bus->priv;
- int ret;
-
- ret = start_miim_ops(md->base, phyid, reg, 0, MDIO_CTRL_READ_OP);
- if (ret < 0)
- dev_err(&bus->dev, "mdiomux read operation failed!!!");
-
- return ret;
-}
-
-static int iproc_mdiomux_write(struct mii_bus *bus,
- int phyid, int reg, u16 val)
-{
- struct iproc_mdiomux_desc *md = bus->priv;
- int ret;
-
- /* Write val at reg offset */
- ret = start_miim_ops(md->base, phyid, reg, val, MDIO_CTRL_WRITE_OP);
- if (ret < 0)
- dev_err(&bus->dev, "mdiomux write operation failed!!!");
-
- return ret;
-}
-
-static int mdio_mux_iproc_switch_fn(int current_child, int desired_child,
- void *data)
-{
- struct iproc_mdiomux_desc *md = data;
- u32 param, bus_id;
- bool bus_dir;
-
- /* select bus and its properties */
- bus_dir = (desired_child < EXT_BUS_START_ADDR);
- bus_id = bus_dir ? desired_child : (desired_child - EXT_BUS_START_ADDR);
-
- param = (bus_dir ? 1 : 0) << MDIO_PARAM_INTERNAL_SEL;
- param |= (bus_id << MDIO_PARAM_BUS_ID);
-
- writel(param, md->base + MDIO_PARAM_OFFSET);
- return 0;
-}
-
-static int mdio_mux_iproc_probe(struct platform_device *pdev)
-{
- struct iproc_mdiomux_desc *md;
- struct mii_bus *bus;
- struct resource *res;
- int rc;
-
- md = devm_kzalloc(&pdev->dev, sizeof(*md), GFP_KERNEL);
- if (!md)
- return -ENOMEM;
- md->dev = &pdev->dev;
-
- res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- if (res->start & 0xfff) {
- /* For backward compatibility in case the
- * base address is specified with an offset.
- */
- dev_info(&pdev->dev, "fix base address in dt-blob\n");
- res->start &= ~0xfff;
- res->end = res->start + MDIO_REG_ADDR_SPACE_SIZE - 1;
- }
- md->base = devm_ioremap_resource(&pdev->dev, res);
- if (IS_ERR(md->base)) {
- dev_err(&pdev->dev, "failed to ioremap register\n");
- return PTR_ERR(md->base);
- }
-
- md->mii_bus = devm_mdiobus_alloc(&pdev->dev);
- if (!md->mii_bus) {
- dev_err(&pdev->dev, "mdiomux bus alloc failed\n");
- return -ENOMEM;
- }
-
- md->core_clk = devm_clk_get(&pdev->dev, NULL);
- if (md->core_clk == ERR_PTR(-ENOENT) ||
- md->core_clk == ERR_PTR(-EINVAL))
- md->core_clk = NULL;
- else if (IS_ERR(md->core_clk))
- return PTR_ERR(md->core_clk);
-
- rc = clk_prepare_enable(md->core_clk);
- if (rc) {
- dev_err(&pdev->dev, "failed to enable core clk\n");
- return rc;
- }
-
- bus = md->mii_bus;
- bus->priv = md;
- bus->name = "iProc MDIO mux bus";
- snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d", pdev->name, pdev->id);
- bus->parent = &pdev->dev;
- bus->read = iproc_mdiomux_read;
- bus->write = iproc_mdiomux_write;
-
- bus->phy_mask = ~0;
- bus->dev.of_node = pdev->dev.of_node;
- rc = mdiobus_register(bus);
- if (rc) {
- dev_err(&pdev->dev, "mdiomux registration failed\n");
- goto out_clk;
- }
-
- platform_set_drvdata(pdev, md);
-
- rc = mdio_mux_init(md->dev, md->dev->of_node, mdio_mux_iproc_switch_fn,
- &md->mux_handle, md, md->mii_bus);
- if (rc) {
- dev_info(md->dev, "mdiomux initialization failed\n");
- goto out_register;
- }
-
- mdio_mux_iproc_config(md);
-
- dev_info(md->dev, "iProc mdiomux registered\n");
- return 0;
-
-out_register:
- mdiobus_unregister(bus);
-out_clk:
- clk_disable_unprepare(md->core_clk);
- return rc;
-}
-
-static int mdio_mux_iproc_remove(struct platform_device *pdev)
-{
- struct iproc_mdiomux_desc *md = platform_get_drvdata(pdev);
-
- mdio_mux_uninit(md->mux_handle);
- mdiobus_unregister(md->mii_bus);
- clk_disable_unprepare(md->core_clk);
-
- return 0;
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int mdio_mux_iproc_suspend(struct device *dev)
-{
- struct iproc_mdiomux_desc *md = dev_get_drvdata(dev);
-
- clk_disable_unprepare(md->core_clk);
-
- return 0;
-}
-
-static int mdio_mux_iproc_resume(struct device *dev)
-{
- struct iproc_mdiomux_desc *md = dev_get_drvdata(dev);
- int rc;
-
- rc = clk_prepare_enable(md->core_clk);
- if (rc) {
- dev_err(md->dev, "failed to enable core clk\n");
- return rc;
- }
- mdio_mux_iproc_config(md);
-
- return 0;
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(mdio_mux_iproc_pm_ops,
- mdio_mux_iproc_suspend, mdio_mux_iproc_resume);
-
-static const struct of_device_id mdio_mux_iproc_match[] = {
- {
- .compatible = "brcm,mdio-mux-iproc",
- },
- {},
-};
-MODULE_DEVICE_TABLE(of, mdio_mux_iproc_match);
-
-static struct platform_driver mdiomux_iproc_driver = {
- .driver = {
- .name = "mdio-mux-iproc",
- .of_match_table = mdio_mux_iproc_match,
- .pm = &mdio_mux_iproc_pm_ops,
- },
- .probe = mdio_mux_iproc_probe,
- .remove = mdio_mux_iproc_remove,
-};
-
-module_platform_driver(mdiomux_iproc_driver);
-
-MODULE_DESCRIPTION("iProc MDIO Mux Bus Driver");
-MODULE_AUTHOR("Pramod Kumar <pramod.kumar@broadcom.com>");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2011, 2012 Cavium, Inc.
- */
-
-#include <linux/platform_device.h>
-#include <linux/device.h>
-#include <linux/of_mdio.h>
-#include <linux/module.h>
-#include <linux/phy.h>
-#include <linux/mdio-mux.h>
-#include <linux/gpio/consumer.h>
-
-#define DRV_VERSION "1.1"
-#define DRV_DESCRIPTION "GPIO controlled MDIO bus multiplexer driver"
-
-struct mdio_mux_gpio_state {
- struct gpio_descs *gpios;
- void *mux_handle;
-};
-
-static int mdio_mux_gpio_switch_fn(int current_child, int desired_child,
- void *data)
-{
- struct mdio_mux_gpio_state *s = data;
- DECLARE_BITMAP(values, BITS_PER_TYPE(desired_child));
-
- if (current_child == desired_child)
- return 0;
-
- values[0] = desired_child;
-
- gpiod_set_array_value_cansleep(s->gpios->ndescs, s->gpios->desc,
- s->gpios->info, values);
-
- return 0;
-}
-
-static int mdio_mux_gpio_probe(struct platform_device *pdev)
-{
- struct mdio_mux_gpio_state *s;
- struct gpio_descs *gpios;
- int r;
-
- gpios = devm_gpiod_get_array(&pdev->dev, NULL, GPIOD_OUT_LOW);
- if (IS_ERR(gpios))
- return PTR_ERR(gpios);
-
- s = devm_kzalloc(&pdev->dev, sizeof(*s), GFP_KERNEL);
- if (!s)
- return -ENOMEM;
-
- s->gpios = gpios;
-
- r = mdio_mux_init(&pdev->dev, pdev->dev.of_node,
- mdio_mux_gpio_switch_fn, &s->mux_handle, s, NULL);
-
- if (r != 0)
- return r;
-
- pdev->dev.platform_data = s;
- return 0;
-}
-
-static int mdio_mux_gpio_remove(struct platform_device *pdev)
-{
- struct mdio_mux_gpio_state *s = dev_get_platdata(&pdev->dev);
- mdio_mux_uninit(s->mux_handle);
- return 0;
-}
-
-static const struct of_device_id mdio_mux_gpio_match[] = {
- {
- .compatible = "mdio-mux-gpio",
- },
- {
- /* Legacy compatible property. */
- .compatible = "cavium,mdio-mux-sn74cbtlv3253",
- },
- {},
-};
-MODULE_DEVICE_TABLE(of, mdio_mux_gpio_match);
-
-static struct platform_driver mdio_mux_gpio_driver = {
- .driver = {
- .name = "mdio-mux-gpio",
- .of_match_table = mdio_mux_gpio_match,
- },
- .probe = mdio_mux_gpio_probe,
- .remove = mdio_mux_gpio_remove,
-};
-
-module_platform_driver(mdio_mux_gpio_driver);
-
-MODULE_DESCRIPTION(DRV_DESCRIPTION);
-MODULE_VERSION(DRV_VERSION);
-MODULE_AUTHOR("David Daney");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/* Copyright (c) 2019 Baylibre, SAS.
- * Author: Jerome Brunet <jbrunet@baylibre.com>
- */
-
-#include <linux/bitfield.h>
-#include <linux/clk.h>
-#include <linux/clk-provider.h>
-#include <linux/device.h>
-#include <linux/io.h>
-#include <linux/iopoll.h>
-#include <linux/mdio-mux.h>
-#include <linux/module.h>
-#include <linux/phy.h>
-#include <linux/platform_device.h>
-
-#define ETH_PLL_STS 0x40
-#define ETH_PLL_CTL0 0x44
-#define PLL_CTL0_LOCK_DIG BIT(30)
-#define PLL_CTL0_RST BIT(29)
-#define PLL_CTL0_EN BIT(28)
-#define PLL_CTL0_SEL BIT(23)
-#define PLL_CTL0_N GENMASK(14, 10)
-#define PLL_CTL0_M GENMASK(8, 0)
-#define PLL_LOCK_TIMEOUT 1000000
-#define PLL_MUX_NUM_PARENT 2
-#define ETH_PLL_CTL1 0x48
-#define ETH_PLL_CTL2 0x4c
-#define ETH_PLL_CTL3 0x50
-#define ETH_PLL_CTL4 0x54
-#define ETH_PLL_CTL5 0x58
-#define ETH_PLL_CTL6 0x5c
-#define ETH_PLL_CTL7 0x60
-
-#define ETH_PHY_CNTL0 0x80
-#define EPHY_G12A_ID 0x33010180
-#define ETH_PHY_CNTL1 0x84
-#define PHY_CNTL1_ST_MODE GENMASK(2, 0)
-#define PHY_CNTL1_ST_PHYADD GENMASK(7, 3)
-#define EPHY_DFLT_ADD 8
-#define PHY_CNTL1_MII_MODE GENMASK(15, 14)
-#define EPHY_MODE_RMII 0x1
-#define PHY_CNTL1_CLK_EN BIT(16)
-#define PHY_CNTL1_CLKFREQ BIT(17)
-#define PHY_CNTL1_PHY_ENB BIT(18)
-#define ETH_PHY_CNTL2 0x88
-#define PHY_CNTL2_USE_INTERNAL BIT(5)
-#define PHY_CNTL2_SMI_SRC_MAC BIT(6)
-#define PHY_CNTL2_RX_CLK_EPHY BIT(9)
-
-#define MESON_G12A_MDIO_EXTERNAL_ID 0
-#define MESON_G12A_MDIO_INTERNAL_ID 1
-
-struct g12a_mdio_mux {
- bool pll_is_enabled;
- void __iomem *regs;
- void *mux_handle;
- struct clk *pclk;
- struct clk *pll;
-};
-
-struct g12a_ephy_pll {
- void __iomem *base;
- struct clk_hw hw;
-};
-
-#define g12a_ephy_pll_to_dev(_hw) \
- container_of(_hw, struct g12a_ephy_pll, hw)
-
-static unsigned long g12a_ephy_pll_recalc_rate(struct clk_hw *hw,
- unsigned long parent_rate)
-{
- struct g12a_ephy_pll *pll = g12a_ephy_pll_to_dev(hw);
- u32 val, m, n;
-
- val = readl(pll->base + ETH_PLL_CTL0);
- m = FIELD_GET(PLL_CTL0_M, val);
- n = FIELD_GET(PLL_CTL0_N, val);
-
- return parent_rate * m / n;
-}
-
-static int g12a_ephy_pll_enable(struct clk_hw *hw)
-{
- struct g12a_ephy_pll *pll = g12a_ephy_pll_to_dev(hw);
- u32 val = readl(pll->base + ETH_PLL_CTL0);
-
- /* Apply both enable an reset */
- val |= PLL_CTL0_RST | PLL_CTL0_EN;
- writel(val, pll->base + ETH_PLL_CTL0);
-
- /* Clear the reset to let PLL lock */
- val &= ~PLL_CTL0_RST;
- writel(val, pll->base + ETH_PLL_CTL0);
-
- /* Poll on the digital lock instead of the usual analog lock
- * This is done because bit 31 is unreliable on some SoC. Bit
- * 31 may indicate that the PLL is not lock eventhough the clock
- * is actually running
- */
- return readl_poll_timeout(pll->base + ETH_PLL_CTL0, val,
- val & PLL_CTL0_LOCK_DIG, 0, PLL_LOCK_TIMEOUT);
-}
-
-static void g12a_ephy_pll_disable(struct clk_hw *hw)
-{
- struct g12a_ephy_pll *pll = g12a_ephy_pll_to_dev(hw);
- u32 val;
-
- val = readl(pll->base + ETH_PLL_CTL0);
- val &= ~PLL_CTL0_EN;
- val |= PLL_CTL0_RST;
- writel(val, pll->base + ETH_PLL_CTL0);
-}
-
-static int g12a_ephy_pll_is_enabled(struct clk_hw *hw)
-{
- struct g12a_ephy_pll *pll = g12a_ephy_pll_to_dev(hw);
- unsigned int val;
-
- val = readl(pll->base + ETH_PLL_CTL0);
-
- return (val & PLL_CTL0_LOCK_DIG) ? 1 : 0;
-}
-
-static int g12a_ephy_pll_init(struct clk_hw *hw)
-{
- struct g12a_ephy_pll *pll = g12a_ephy_pll_to_dev(hw);
-
- /* Apply PLL HW settings */
- writel(0x29c0040a, pll->base + ETH_PLL_CTL0);
- writel(0x927e0000, pll->base + ETH_PLL_CTL1);
- writel(0xac5f49e5, pll->base + ETH_PLL_CTL2);
- writel(0x00000000, pll->base + ETH_PLL_CTL3);
- writel(0x00000000, pll->base + ETH_PLL_CTL4);
- writel(0x20200000, pll->base + ETH_PLL_CTL5);
- writel(0x0000c002, pll->base + ETH_PLL_CTL6);
- writel(0x00000023, pll->base + ETH_PLL_CTL7);
-
- return 0;
-}
-
-static const struct clk_ops g12a_ephy_pll_ops = {
- .recalc_rate = g12a_ephy_pll_recalc_rate,
- .is_enabled = g12a_ephy_pll_is_enabled,
- .enable = g12a_ephy_pll_enable,
- .disable = g12a_ephy_pll_disable,
- .init = g12a_ephy_pll_init,
-};
-
-static int g12a_enable_internal_mdio(struct g12a_mdio_mux *priv)
-{
- int ret;
-
- /* Enable the phy clock */
- if (!priv->pll_is_enabled) {
- ret = clk_prepare_enable(priv->pll);
- if (ret)
- return ret;
- }
-
- priv->pll_is_enabled = true;
-
- /* Initialize ephy control */
- writel(EPHY_G12A_ID, priv->regs + ETH_PHY_CNTL0);
- writel(FIELD_PREP(PHY_CNTL1_ST_MODE, 3) |
- FIELD_PREP(PHY_CNTL1_ST_PHYADD, EPHY_DFLT_ADD) |
- FIELD_PREP(PHY_CNTL1_MII_MODE, EPHY_MODE_RMII) |
- PHY_CNTL1_CLK_EN |
- PHY_CNTL1_CLKFREQ |
- PHY_CNTL1_PHY_ENB,
- priv->regs + ETH_PHY_CNTL1);
- writel(PHY_CNTL2_USE_INTERNAL |
- PHY_CNTL2_SMI_SRC_MAC |
- PHY_CNTL2_RX_CLK_EPHY,
- priv->regs + ETH_PHY_CNTL2);
-
- return 0;
-}
-
-static int g12a_enable_external_mdio(struct g12a_mdio_mux *priv)
-{
- /* Reset the mdio bus mux */
- writel_relaxed(0x0, priv->regs + ETH_PHY_CNTL2);
-
- /* Disable the phy clock if enabled */
- if (priv->pll_is_enabled) {
- clk_disable_unprepare(priv->pll);
- priv->pll_is_enabled = false;
- }
-
- return 0;
-}
-
-static int g12a_mdio_switch_fn(int current_child, int desired_child,
- void *data)
-{
- struct g12a_mdio_mux *priv = dev_get_drvdata(data);
-
- if (current_child == desired_child)
- return 0;
-
- switch (desired_child) {
- case MESON_G12A_MDIO_EXTERNAL_ID:
- return g12a_enable_external_mdio(priv);
- case MESON_G12A_MDIO_INTERNAL_ID:
- return g12a_enable_internal_mdio(priv);
- default:
- return -EINVAL;
- }
-}
-
-static const struct of_device_id g12a_mdio_mux_match[] = {
- { .compatible = "amlogic,g12a-mdio-mux", },
- {},
-};
-MODULE_DEVICE_TABLE(of, g12a_mdio_mux_match);
-
-static int g12a_ephy_glue_clk_register(struct device *dev)
-{
- struct g12a_mdio_mux *priv = dev_get_drvdata(dev);
- const char *parent_names[PLL_MUX_NUM_PARENT];
- struct clk_init_data init;
- struct g12a_ephy_pll *pll;
- struct clk_mux *mux;
- struct clk *clk;
- char *name;
- int i;
-
- /* get the mux parents */
- for (i = 0; i < PLL_MUX_NUM_PARENT; i++) {
- char in_name[8];
-
- snprintf(in_name, sizeof(in_name), "clkin%d", i);
- clk = devm_clk_get(dev, in_name);
- if (IS_ERR(clk)) {
- if (PTR_ERR(clk) != -EPROBE_DEFER)
- dev_err(dev, "Missing clock %s\n", in_name);
- return PTR_ERR(clk);
- }
-
- parent_names[i] = __clk_get_name(clk);
- }
-
- /* create the input mux */
- mux = devm_kzalloc(dev, sizeof(*mux), GFP_KERNEL);
- if (!mux)
- return -ENOMEM;
-
- name = kasprintf(GFP_KERNEL, "%s#mux", dev_name(dev));
- if (!name)
- return -ENOMEM;
-
- init.name = name;
- init.ops = &clk_mux_ro_ops;
- init.flags = 0;
- init.parent_names = parent_names;
- init.num_parents = PLL_MUX_NUM_PARENT;
-
- mux->reg = priv->regs + ETH_PLL_CTL0;
- mux->shift = __ffs(PLL_CTL0_SEL);
- mux->mask = PLL_CTL0_SEL >> mux->shift;
- mux->hw.init = &init;
-
- clk = devm_clk_register(dev, &mux->hw);
- kfree(name);
- if (IS_ERR(clk)) {
- dev_err(dev, "failed to register input mux\n");
- return PTR_ERR(clk);
- }
-
- /* create the pll */
- pll = devm_kzalloc(dev, sizeof(*pll), GFP_KERNEL);
- if (!pll)
- return -ENOMEM;
-
- name = kasprintf(GFP_KERNEL, "%s#pll", dev_name(dev));
- if (!name)
- return -ENOMEM;
-
- init.name = name;
- init.ops = &g12a_ephy_pll_ops;
- init.flags = 0;
- parent_names[0] = __clk_get_name(clk);
- init.parent_names = parent_names;
- init.num_parents = 1;
-
- pll->base = priv->regs;
- pll->hw.init = &init;
-
- clk = devm_clk_register(dev, &pll->hw);
- kfree(name);
- if (IS_ERR(clk)) {
- dev_err(dev, "failed to register input mux\n");
- return PTR_ERR(clk);
- }
-
- priv->pll = clk;
-
- return 0;
-}
-
-static int g12a_mdio_mux_probe(struct platform_device *pdev)
-{
- struct device *dev = &pdev->dev;
- struct g12a_mdio_mux *priv;
- int ret;
-
- priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
- if (!priv)
- return -ENOMEM;
-
- platform_set_drvdata(pdev, priv);
-
- priv->regs = devm_platform_ioremap_resource(pdev, 0);
- if (IS_ERR(priv->regs))
- return PTR_ERR(priv->regs);
-
- priv->pclk = devm_clk_get(dev, "pclk");
- if (IS_ERR(priv->pclk)) {
- ret = PTR_ERR(priv->pclk);
- if (ret != -EPROBE_DEFER)
- dev_err(dev, "failed to get peripheral clock\n");
- return ret;
- }
-
- /* Make sure the device registers are clocked */
- ret = clk_prepare_enable(priv->pclk);
- if (ret) {
- dev_err(dev, "failed to enable peripheral clock");
- return ret;
- }
-
- /* Register PLL in CCF */
- ret = g12a_ephy_glue_clk_register(dev);
- if (ret)
- goto err;
-
- ret = mdio_mux_init(dev, dev->of_node, g12a_mdio_switch_fn,
- &priv->mux_handle, dev, NULL);
- if (ret) {
- if (ret != -EPROBE_DEFER)
- dev_err(dev, "mdio multiplexer init failed: %d", ret);
- goto err;
- }
-
- return 0;
-
-err:
- clk_disable_unprepare(priv->pclk);
- return ret;
-}
-
-static int g12a_mdio_mux_remove(struct platform_device *pdev)
-{
- struct g12a_mdio_mux *priv = platform_get_drvdata(pdev);
-
- mdio_mux_uninit(priv->mux_handle);
-
- if (priv->pll_is_enabled)
- clk_disable_unprepare(priv->pll);
-
- clk_disable_unprepare(priv->pclk);
-
- return 0;
-}
-
-static struct platform_driver g12a_mdio_mux_driver = {
- .probe = g12a_mdio_mux_probe,
- .remove = g12a_mdio_mux_remove,
- .driver = {
- .name = "g12a-mdio_mux",
- .of_match_table = g12a_mdio_mux_match,
- },
-};
-module_platform_driver(g12a_mdio_mux_driver);
-
-MODULE_DESCRIPTION("Amlogic G12a MDIO multiplexer driver");
-MODULE_AUTHOR("Jerome Brunet <jbrunet@baylibre.com>");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Simple memory-mapped device MDIO MUX driver
- *
- * Author: Timur Tabi <timur@freescale.com>
- *
- * Copyright 2012 Freescale Semiconductor, Inc.
- */
-
-#include <linux/platform_device.h>
-#include <linux/device.h>
-#include <linux/of_address.h>
-#include <linux/of_mdio.h>
-#include <linux/module.h>
-#include <linux/phy.h>
-#include <linux/mdio-mux.h>
-
-struct mdio_mux_mmioreg_state {
- void *mux_handle;
- phys_addr_t phys;
- unsigned int iosize;
- unsigned int mask;
-};
-
-/*
- * MDIO multiplexing switch function
- *
- * This function is called by the mdio-mux layer when it thinks the mdio bus
- * multiplexer needs to switch.
- *
- * 'current_child' is the current value of the mux register (masked via
- * s->mask).
- *
- * 'desired_child' is the value of the 'reg' property of the target child MDIO
- * node.
- *
- * The first time this function is called, current_child == -1.
- *
- * If current_child == desired_child, then the mux is already set to the
- * correct bus.
- */
-static int mdio_mux_mmioreg_switch_fn(int current_child, int desired_child,
- void *data)
-{
- struct mdio_mux_mmioreg_state *s = data;
-
- if (current_child ^ desired_child) {
- void __iomem *p = ioremap(s->phys, s->iosize);
- if (!p)
- return -ENOMEM;
-
- switch (s->iosize) {
- case sizeof(uint8_t): {
- uint8_t x, y;
-
- x = ioread8(p);
- y = (x & ~s->mask) | desired_child;
- if (x != y) {
- iowrite8((x & ~s->mask) | desired_child, p);
- pr_debug("%s: %02x -> %02x\n", __func__, x, y);
- }
-
- break;
- }
- case sizeof(uint16_t): {
- uint16_t x, y;
-
- x = ioread16(p);
- y = (x & ~s->mask) | desired_child;
- if (x != y) {
- iowrite16((x & ~s->mask) | desired_child, p);
- pr_debug("%s: %04x -> %04x\n", __func__, x, y);
- }
-
- break;
- }
- case sizeof(uint32_t): {
- uint32_t x, y;
-
- x = ioread32(p);
- y = (x & ~s->mask) | desired_child;
- if (x != y) {
- iowrite32((x & ~s->mask) | desired_child, p);
- pr_debug("%s: %08x -> %08x\n", __func__, x, y);
- }
-
- break;
- }
- }
-
- iounmap(p);
- }
-
- return 0;
-}
-
-static int mdio_mux_mmioreg_probe(struct platform_device *pdev)
-{
- struct device_node *np2, *np = pdev->dev.of_node;
- struct mdio_mux_mmioreg_state *s;
- struct resource res;
- const __be32 *iprop;
- int len, ret;
-
- dev_dbg(&pdev->dev, "probing node %pOF\n", np);
-
- s = devm_kzalloc(&pdev->dev, sizeof(*s), GFP_KERNEL);
- if (!s)
- return -ENOMEM;
-
- ret = of_address_to_resource(np, 0, &res);
- if (ret) {
- dev_err(&pdev->dev, "could not obtain memory map for node %pOF\n",
- np);
- return ret;
- }
- s->phys = res.start;
-
- s->iosize = resource_size(&res);
- if (s->iosize != sizeof(uint8_t) &&
- s->iosize != sizeof(uint16_t) &&
- s->iosize != sizeof(uint32_t)) {
- dev_err(&pdev->dev, "only 8/16/32-bit registers are supported\n");
- return -EINVAL;
- }
-
- iprop = of_get_property(np, "mux-mask", &len);
- if (!iprop || len != sizeof(uint32_t)) {
- dev_err(&pdev->dev, "missing or invalid mux-mask property\n");
- return -ENODEV;
- }
- if (be32_to_cpup(iprop) >= BIT(s->iosize * 8)) {
- dev_err(&pdev->dev, "only 8/16/32-bit registers are supported\n");
- return -EINVAL;
- }
- s->mask = be32_to_cpup(iprop);
-
- /*
- * Verify that the 'reg' property of each child MDIO bus does not
- * set any bits outside of the 'mask'.
- */
- for_each_available_child_of_node(np, np2) {
- iprop = of_get_property(np2, "reg", &len);
- if (!iprop || len != sizeof(uint32_t)) {
- dev_err(&pdev->dev, "mdio-mux child node %pOF is "
- "missing a 'reg' property\n", np2);
- of_node_put(np2);
- return -ENODEV;
- }
- if (be32_to_cpup(iprop) & ~s->mask) {
- dev_err(&pdev->dev, "mdio-mux child node %pOF has "
- "a 'reg' value with unmasked bits\n",
- np2);
- of_node_put(np2);
- return -ENODEV;
- }
- }
-
- ret = mdio_mux_init(&pdev->dev, pdev->dev.of_node,
- mdio_mux_mmioreg_switch_fn,
- &s->mux_handle, s, NULL);
- if (ret) {
- if (ret != -EPROBE_DEFER)
- dev_err(&pdev->dev,
- "failed to register mdio-mux bus %pOF\n", np);
- return ret;
- }
-
- pdev->dev.platform_data = s;
-
- return 0;
-}
-
-static int mdio_mux_mmioreg_remove(struct platform_device *pdev)
-{
- struct mdio_mux_mmioreg_state *s = dev_get_platdata(&pdev->dev);
-
- mdio_mux_uninit(s->mux_handle);
-
- return 0;
-}
-
-static const struct of_device_id mdio_mux_mmioreg_match[] = {
- {
- .compatible = "mdio-mux-mmioreg",
- },
- {},
-};
-MODULE_DEVICE_TABLE(of, mdio_mux_mmioreg_match);
-
-static struct platform_driver mdio_mux_mmioreg_driver = {
- .driver = {
- .name = "mdio-mux-mmioreg",
- .of_match_table = mdio_mux_mmioreg_match,
- },
- .probe = mdio_mux_mmioreg_probe,
- .remove = mdio_mux_mmioreg_remove,
-};
-
-module_platform_driver(mdio_mux_mmioreg_driver);
-
-MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
-MODULE_DESCRIPTION("Memory-mapped device MDIO MUX driver");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0+
-/* MDIO bus multiplexer using kernel multiplexer subsystem
- *
- * Copyright 2019 NXP
- */
-
-#include <linux/platform_device.h>
-#include <linux/mdio-mux.h>
-#include <linux/module.h>
-#include <linux/mux/consumer.h>
-
-struct mdio_mux_multiplexer_state {
- struct mux_control *muxc;
- bool do_deselect;
- void *mux_handle;
-};
-
-/**
- * mdio_mux_multiplexer_switch_fn - This function is called by the mdio-mux
- * layer when it thinks the mdio bus
- * multiplexer needs to switch.
- * @current_child: current value of the mux register.
- * @desired_child: value of the 'reg' property of the target child MDIO node.
- * @data: Private data used by this switch_fn passed to mdio_mux_init function
- * via mdio_mux_init(.., .., .., .., data, ..).
- *
- * The first time this function is called, current_child == -1.
- * If current_child == desired_child, then the mux is already set to the
- * correct bus.
- */
-static int mdio_mux_multiplexer_switch_fn(int current_child, int desired_child,
- void *data)
-{
- struct platform_device *pdev;
- struct mdio_mux_multiplexer_state *s;
- int ret = 0;
-
- pdev = (struct platform_device *)data;
- s = platform_get_drvdata(pdev);
-
- if (!(current_child ^ desired_child))
- return 0;
-
- if (s->do_deselect)
- ret = mux_control_deselect(s->muxc);
- if (ret) {
- dev_err(&pdev->dev, "mux_control_deselect failed in %s: %d\n",
- __func__, ret);
- return ret;
- }
-
- ret = mux_control_select(s->muxc, desired_child);
- if (!ret) {
- dev_dbg(&pdev->dev, "%s %d -> %d\n", __func__, current_child,
- desired_child);
- s->do_deselect = true;
- } else {
- s->do_deselect = false;
- }
-
- return ret;
-}
-
-static int mdio_mux_multiplexer_probe(struct platform_device *pdev)
-{
- struct device *dev = &pdev->dev;
- struct mdio_mux_multiplexer_state *s;
- int ret = 0;
-
- s = devm_kzalloc(&pdev->dev, sizeof(*s), GFP_KERNEL);
- if (!s)
- return -ENOMEM;
-
- s->muxc = devm_mux_control_get(dev, NULL);
- if (IS_ERR(s->muxc)) {
- ret = PTR_ERR(s->muxc);
- if (ret != -EPROBE_DEFER)
- dev_err(&pdev->dev, "Failed to get mux: %d\n", ret);
- return ret;
- }
-
- platform_set_drvdata(pdev, s);
-
- ret = mdio_mux_init(&pdev->dev, pdev->dev.of_node,
- mdio_mux_multiplexer_switch_fn, &s->mux_handle,
- pdev, NULL);
-
- return ret;
-}
-
-static int mdio_mux_multiplexer_remove(struct platform_device *pdev)
-{
- struct mdio_mux_multiplexer_state *s = platform_get_drvdata(pdev);
-
- mdio_mux_uninit(s->mux_handle);
-
- if (s->do_deselect)
- mux_control_deselect(s->muxc);
-
- return 0;
-}
-
-static const struct of_device_id mdio_mux_multiplexer_match[] = {
- { .compatible = "mdio-mux-multiplexer", },
- {},
-};
-MODULE_DEVICE_TABLE(of, mdio_mux_multiplexer_match);
-
-static struct platform_driver mdio_mux_multiplexer_driver = {
- .driver = {
- .name = "mdio-mux-multiplexer",
- .of_match_table = mdio_mux_multiplexer_match,
- },
- .probe = mdio_mux_multiplexer_probe,
- .remove = mdio_mux_multiplexer_remove,
-};
-
-module_platform_driver(mdio_mux_multiplexer_driver);
-
-MODULE_DESCRIPTION("MDIO bus multiplexer using kernel multiplexer subsystem");
-MODULE_AUTHOR("Pankaj Bansal <pankaj.bansal@nxp.com>");
-MODULE_LICENSE("GPL");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2011, 2012 Cavium, Inc.
- */
-
-#include <linux/platform_device.h>
-#include <linux/mdio-mux.h>
-#include <linux/of_mdio.h>
-#include <linux/device.h>
-#include <linux/module.h>
-#include <linux/phy.h>
-
-#define DRV_DESCRIPTION "MDIO bus multiplexer driver"
-
-struct mdio_mux_child_bus;
-
-struct mdio_mux_parent_bus {
- struct mii_bus *mii_bus;
- int current_child;
- int parent_id;
- void *switch_data;
- int (*switch_fn)(int current_child, int desired_child, void *data);
-
- /* List of our children linked through their next fields. */
- struct mdio_mux_child_bus *children;
-};
-
-struct mdio_mux_child_bus {
- struct mii_bus *mii_bus;
- struct mdio_mux_parent_bus *parent;
- struct mdio_mux_child_bus *next;
- int bus_number;
-};
-
-/*
- * The parent bus' lock is used to order access to the switch_fn.
- */
-static int mdio_mux_read(struct mii_bus *bus, int phy_id, int regnum)
-{
- struct mdio_mux_child_bus *cb = bus->priv;
- struct mdio_mux_parent_bus *pb = cb->parent;
- int r;
-
- mutex_lock_nested(&pb->mii_bus->mdio_lock, MDIO_MUTEX_MUX);
- r = pb->switch_fn(pb->current_child, cb->bus_number, pb->switch_data);
- if (r)
- goto out;
-
- pb->current_child = cb->bus_number;
-
- r = pb->mii_bus->read(pb->mii_bus, phy_id, regnum);
-out:
- mutex_unlock(&pb->mii_bus->mdio_lock);
-
- return r;
-}
-
-/*
- * The parent bus' lock is used to order access to the switch_fn.
- */
-static int mdio_mux_write(struct mii_bus *bus, int phy_id,
- int regnum, u16 val)
-{
- struct mdio_mux_child_bus *cb = bus->priv;
- struct mdio_mux_parent_bus *pb = cb->parent;
-
- int r;
-
- mutex_lock_nested(&pb->mii_bus->mdio_lock, MDIO_MUTEX_MUX);
- r = pb->switch_fn(pb->current_child, cb->bus_number, pb->switch_data);
- if (r)
- goto out;
-
- pb->current_child = cb->bus_number;
-
- r = pb->mii_bus->write(pb->mii_bus, phy_id, regnum, val);
-out:
- mutex_unlock(&pb->mii_bus->mdio_lock);
-
- return r;
-}
-
-static int parent_count;
-
-int mdio_mux_init(struct device *dev,
- struct device_node *mux_node,
- int (*switch_fn)(int cur, int desired, void *data),
- void **mux_handle,
- void *data,
- struct mii_bus *mux_bus)
-{
- struct device_node *parent_bus_node;
- struct device_node *child_bus_node;
- int r, ret_val;
- struct mii_bus *parent_bus;
- struct mdio_mux_parent_bus *pb;
- struct mdio_mux_child_bus *cb;
-
- if (!mux_node)
- return -ENODEV;
-
- if (!mux_bus) {
- parent_bus_node = of_parse_phandle(mux_node,
- "mdio-parent-bus", 0);
-
- if (!parent_bus_node)
- return -ENODEV;
-
- parent_bus = of_mdio_find_bus(parent_bus_node);
- if (!parent_bus) {
- ret_val = -EPROBE_DEFER;
- goto err_parent_bus;
- }
- } else {
- parent_bus_node = NULL;
- parent_bus = mux_bus;
- get_device(&parent_bus->dev);
- }
-
- pb = devm_kzalloc(dev, sizeof(*pb), GFP_KERNEL);
- if (!pb) {
- ret_val = -ENOMEM;
- goto err_pb_kz;
- }
-
- pb->switch_data = data;
- pb->switch_fn = switch_fn;
- pb->current_child = -1;
- pb->parent_id = parent_count++;
- pb->mii_bus = parent_bus;
-
- ret_val = -ENODEV;
- for_each_available_child_of_node(mux_node, child_bus_node) {
- int v;
-
- r = of_property_read_u32(child_bus_node, "reg", &v);
- if (r) {
- dev_err(dev,
- "Error: Failed to find reg for child %pOF\n",
- child_bus_node);
- continue;
- }
-
- cb = devm_kzalloc(dev, sizeof(*cb), GFP_KERNEL);
- if (!cb) {
- ret_val = -ENOMEM;
- continue;
- }
- cb->bus_number = v;
- cb->parent = pb;
-
- cb->mii_bus = mdiobus_alloc();
- if (!cb->mii_bus) {
- ret_val = -ENOMEM;
- devm_kfree(dev, cb);
- continue;
- }
- cb->mii_bus->priv = cb;
-
- cb->mii_bus->name = "mdio_mux";
- snprintf(cb->mii_bus->id, MII_BUS_ID_SIZE, "%x.%x",
- pb->parent_id, v);
- cb->mii_bus->parent = dev;
- cb->mii_bus->read = mdio_mux_read;
- cb->mii_bus->write = mdio_mux_write;
- r = of_mdiobus_register(cb->mii_bus, child_bus_node);
- if (r) {
- dev_err(dev,
- "Error: Failed to register MDIO bus for child %pOF\n",
- child_bus_node);
- mdiobus_free(cb->mii_bus);
- devm_kfree(dev, cb);
- } else {
- cb->next = pb->children;
- pb->children = cb;
- }
- }
- if (pb->children) {
- *mux_handle = pb;
- return 0;
- }
-
- dev_err(dev, "Error: No acceptable child buses found\n");
- devm_kfree(dev, pb);
-err_pb_kz:
- put_device(&parent_bus->dev);
-err_parent_bus:
- of_node_put(parent_bus_node);
- return ret_val;
-}
-EXPORT_SYMBOL_GPL(mdio_mux_init);
-
-void mdio_mux_uninit(void *mux_handle)
-{
- struct mdio_mux_parent_bus *pb = mux_handle;
- struct mdio_mux_child_bus *cb = pb->children;
-
- while (cb) {
- mdiobus_unregister(cb->mii_bus);
- mdiobus_free(cb->mii_bus);
- cb = cb->next;
- }
-
- put_device(&pb->mii_bus->dev);
-}
-EXPORT_SYMBOL_GPL(mdio_mux_uninit);
-
-MODULE_DESCRIPTION(DRV_DESCRIPTION);
-MODULE_AUTHOR("David Daney");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/of_mdio.h>
-#include <linux/phy.h>
-#include <linux/usb.h>
-
-#define USB_MARVELL_VID 0x1286
-
-static const struct usb_device_id mvusb_mdio_table[] = {
- { USB_DEVICE(USB_MARVELL_VID, 0x1fa4) },
-
- {}
-};
-MODULE_DEVICE_TABLE(usb, mvusb_mdio_table);
-
-enum {
- MVUSB_CMD_PREAMBLE0,
- MVUSB_CMD_PREAMBLE1,
- MVUSB_CMD_ADDR,
- MVUSB_CMD_VAL,
-};
-
-struct mvusb_mdio {
- struct usb_device *udev;
- struct mii_bus *mdio;
-
- __le16 buf[4];
-};
-
-static int mvusb_mdio_read(struct mii_bus *mdio, int dev, int reg)
-{
- struct mvusb_mdio *mvusb = mdio->priv;
- int err, alen;
-
- if (dev & MII_ADDR_C45)
- return -EOPNOTSUPP;
-
- mvusb->buf[MVUSB_CMD_ADDR] = cpu_to_le16(0xa400 | (dev << 5) | reg);
-
- err = usb_bulk_msg(mvusb->udev, usb_sndbulkpipe(mvusb->udev, 2),
- mvusb->buf, 6, &alen, 100);
- if (err)
- return err;
-
- err = usb_bulk_msg(mvusb->udev, usb_rcvbulkpipe(mvusb->udev, 6),
- &mvusb->buf[MVUSB_CMD_VAL], 2, &alen, 100);
- if (err)
- return err;
-
- return le16_to_cpu(mvusb->buf[MVUSB_CMD_VAL]);
-}
-
-static int mvusb_mdio_write(struct mii_bus *mdio, int dev, int reg, u16 val)
-{
- struct mvusb_mdio *mvusb = mdio->priv;
- int alen;
-
- if (dev & MII_ADDR_C45)
- return -EOPNOTSUPP;
-
- mvusb->buf[MVUSB_CMD_ADDR] = cpu_to_le16(0x8000 | (dev << 5) | reg);
- mvusb->buf[MVUSB_CMD_VAL] = cpu_to_le16(val);
-
- return usb_bulk_msg(mvusb->udev, usb_sndbulkpipe(mvusb->udev, 2),
- mvusb->buf, 8, &alen, 100);
-}
-
-static int mvusb_mdio_probe(struct usb_interface *interface,
- const struct usb_device_id *id)
-{
- struct device *dev = &interface->dev;
- struct mvusb_mdio *mvusb;
- struct mii_bus *mdio;
-
- mdio = devm_mdiobus_alloc_size(dev, sizeof(*mvusb));
- if (!mdio)
- return -ENOMEM;
-
- mvusb = mdio->priv;
- mvusb->mdio = mdio;
- mvusb->udev = usb_get_dev(interface_to_usbdev(interface));
-
- /* Reversed from USB PCAPs, no idea what these mean. */
- mvusb->buf[MVUSB_CMD_PREAMBLE0] = cpu_to_le16(0xe800);
- mvusb->buf[MVUSB_CMD_PREAMBLE1] = cpu_to_le16(0x0001);
-
- snprintf(mdio->id, MII_BUS_ID_SIZE, "mvusb-%s", dev_name(dev));
- mdio->name = mdio->id;
- mdio->parent = dev;
- mdio->read = mvusb_mdio_read;
- mdio->write = mvusb_mdio_write;
-
- usb_set_intfdata(interface, mvusb);
- return of_mdiobus_register(mdio, dev->of_node);
-}
-
-static void mvusb_mdio_disconnect(struct usb_interface *interface)
-{
- struct mvusb_mdio *mvusb = usb_get_intfdata(interface);
- struct usb_device *udev = mvusb->udev;
-
- mdiobus_unregister(mvusb->mdio);
- usb_set_intfdata(interface, NULL);
- usb_put_dev(udev);
-}
-
-static struct usb_driver mvusb_mdio_driver = {
- .name = "mvusb_mdio",
- .id_table = mvusb_mdio_table,
- .probe = mvusb_mdio_probe,
- .disconnect = mvusb_mdio_disconnect,
-};
-
-module_usb_driver(mvusb_mdio_driver);
-
-MODULE_AUTHOR("Tobias Waldekranz <tobias@waldekranz.com>");
-MODULE_DESCRIPTION("Marvell USB MDIO Adapter");
-MODULE_LICENSE("GPL");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2009-2015 Cavium, Inc.
- */
-
-#include <linux/platform_device.h>
-#include <linux/of_address.h>
-#include <linux/of_mdio.h>
-#include <linux/module.h>
-#include <linux/gfp.h>
-#include <linux/phy.h>
-#include <linux/io.h>
-
-#include "mdio-cavium.h"
-
-static int octeon_mdiobus_probe(struct platform_device *pdev)
-{
- struct cavium_mdiobus *bus;
- struct mii_bus *mii_bus;
- struct resource *res_mem;
- resource_size_t mdio_phys;
- resource_size_t regsize;
- union cvmx_smix_en smi_en;
- int err = -ENOENT;
-
- mii_bus = devm_mdiobus_alloc_size(&pdev->dev, sizeof(*bus));
- if (!mii_bus)
- return -ENOMEM;
-
- res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- if (res_mem == NULL) {
- dev_err(&pdev->dev, "found no memory resource\n");
- return -ENXIO;
- }
-
- bus = mii_bus->priv;
- bus->mii_bus = mii_bus;
- mdio_phys = res_mem->start;
- regsize = resource_size(res_mem);
-
- if (!devm_request_mem_region(&pdev->dev, mdio_phys, regsize,
- res_mem->name)) {
- dev_err(&pdev->dev, "request_mem_region failed\n");
- return -ENXIO;
- }
-
- bus->register_base = devm_ioremap(&pdev->dev, mdio_phys, regsize);
- if (!bus->register_base) {
- dev_err(&pdev->dev, "dev_ioremap failed\n");
- return -ENOMEM;
- }
-
- smi_en.u64 = 0;
- smi_en.s.en = 1;
- oct_mdio_writeq(smi_en.u64, bus->register_base + SMI_EN);
-
- bus->mii_bus->name = KBUILD_MODNAME;
- snprintf(bus->mii_bus->id, MII_BUS_ID_SIZE, "%px", bus->register_base);
- bus->mii_bus->parent = &pdev->dev;
-
- bus->mii_bus->read = cavium_mdiobus_read;
- bus->mii_bus->write = cavium_mdiobus_write;
-
- platform_set_drvdata(pdev, bus);
-
- err = of_mdiobus_register(bus->mii_bus, pdev->dev.of_node);
- if (err)
- goto fail_register;
-
- dev_info(&pdev->dev, "Probed\n");
-
- return 0;
-fail_register:
- mdiobus_free(bus->mii_bus);
- smi_en.u64 = 0;
- oct_mdio_writeq(smi_en.u64, bus->register_base + SMI_EN);
- return err;
-}
-
-static int octeon_mdiobus_remove(struct platform_device *pdev)
-{
- struct cavium_mdiobus *bus;
- union cvmx_smix_en smi_en;
-
- bus = platform_get_drvdata(pdev);
-
- mdiobus_unregister(bus->mii_bus);
- mdiobus_free(bus->mii_bus);
- smi_en.u64 = 0;
- oct_mdio_writeq(smi_en.u64, bus->register_base + SMI_EN);
- return 0;
-}
-
-static const struct of_device_id octeon_mdiobus_match[] = {
- {
- .compatible = "cavium,octeon-3860-mdio",
- },
- {},
-};
-MODULE_DEVICE_TABLE(of, octeon_mdiobus_match);
-
-static struct platform_driver octeon_mdiobus_driver = {
- .driver = {
- .name = KBUILD_MODNAME,
- .of_match_table = octeon_mdiobus_match,
- },
- .probe = octeon_mdiobus_probe,
- .remove = octeon_mdiobus_remove,
-};
-
-module_platform_driver(octeon_mdiobus_driver);
-
-MODULE_DESCRIPTION("Cavium OCTEON MDIO bus driver");
-MODULE_AUTHOR("David Daney");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Allwinner EMAC MDIO interface driver
- *
- * Copyright 2012-2013 Stefan Roese <sr@denx.de>
- * Copyright 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
- *
- * Based on the Linux driver provided by Allwinner:
- * Copyright (C) 1997 Sten Wang
- */
-
-#include <linux/delay.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/mutex.h>
-#include <linux/of_address.h>
-#include <linux/of_mdio.h>
-#include <linux/phy.h>
-#include <linux/platform_device.h>
-#include <linux/regulator/consumer.h>
-
-#define EMAC_MAC_MCMD_REG (0x00)
-#define EMAC_MAC_MADR_REG (0x04)
-#define EMAC_MAC_MWTD_REG (0x08)
-#define EMAC_MAC_MRDD_REG (0x0c)
-#define EMAC_MAC_MIND_REG (0x10)
-#define EMAC_MAC_SSRR_REG (0x14)
-
-#define MDIO_TIMEOUT (msecs_to_jiffies(100))
-
-struct sun4i_mdio_data {
- void __iomem *membase;
- struct regulator *regulator;
-};
-
-static int sun4i_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
-{
- struct sun4i_mdio_data *data = bus->priv;
- unsigned long timeout_jiffies;
- int value;
-
- /* issue the phy address and reg */
- writel((mii_id << 8) | regnum, data->membase + EMAC_MAC_MADR_REG);
- /* pull up the phy io line */
- writel(0x1, data->membase + EMAC_MAC_MCMD_REG);
-
- /* Wait read complete */
- timeout_jiffies = jiffies + MDIO_TIMEOUT;
- while (readl(data->membase + EMAC_MAC_MIND_REG) & 0x1) {
- if (time_is_before_jiffies(timeout_jiffies))
- return -ETIMEDOUT;
- msleep(1);
- }
-
- /* push down the phy io line */
- writel(0x0, data->membase + EMAC_MAC_MCMD_REG);
- /* and read data */
- value = readl(data->membase + EMAC_MAC_MRDD_REG);
-
- return value;
-}
-
-static int sun4i_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
- u16 value)
-{
- struct sun4i_mdio_data *data = bus->priv;
- unsigned long timeout_jiffies;
-
- /* issue the phy address and reg */
- writel((mii_id << 8) | regnum, data->membase + EMAC_MAC_MADR_REG);
- /* pull up the phy io line */
- writel(0x1, data->membase + EMAC_MAC_MCMD_REG);
-
- /* Wait read complete */
- timeout_jiffies = jiffies + MDIO_TIMEOUT;
- while (readl(data->membase + EMAC_MAC_MIND_REG) & 0x1) {
- if (time_is_before_jiffies(timeout_jiffies))
- return -ETIMEDOUT;
- msleep(1);
- }
-
- /* push down the phy io line */
- writel(0x0, data->membase + EMAC_MAC_MCMD_REG);
- /* and write data */
- writel(value, data->membase + EMAC_MAC_MWTD_REG);
-
- return 0;
-}
-
-static int sun4i_mdio_probe(struct platform_device *pdev)
-{
- struct device_node *np = pdev->dev.of_node;
- struct mii_bus *bus;
- struct sun4i_mdio_data *data;
- int ret;
-
- bus = mdiobus_alloc_size(sizeof(*data));
- if (!bus)
- return -ENOMEM;
-
- bus->name = "sun4i_mii_bus";
- bus->read = &sun4i_mdio_read;
- bus->write = &sun4i_mdio_write;
- snprintf(bus->id, MII_BUS_ID_SIZE, "%s-mii", dev_name(&pdev->dev));
- bus->parent = &pdev->dev;
-
- data = bus->priv;
- data->membase = devm_platform_ioremap_resource(pdev, 0);
- if (IS_ERR(data->membase)) {
- ret = PTR_ERR(data->membase);
- goto err_out_free_mdiobus;
- }
-
- data->regulator = devm_regulator_get(&pdev->dev, "phy");
- if (IS_ERR(data->regulator)) {
- if (PTR_ERR(data->regulator) == -EPROBE_DEFER) {
- ret = -EPROBE_DEFER;
- goto err_out_free_mdiobus;
- }
-
- dev_info(&pdev->dev, "no regulator found\n");
- data->regulator = NULL;
- } else {
- ret = regulator_enable(data->regulator);
- if (ret)
- goto err_out_free_mdiobus;
- }
-
- ret = of_mdiobus_register(bus, np);
- if (ret < 0)
- goto err_out_disable_regulator;
-
- platform_set_drvdata(pdev, bus);
-
- return 0;
-
-err_out_disable_regulator:
- if (data->regulator)
- regulator_disable(data->regulator);
-err_out_free_mdiobus:
- mdiobus_free(bus);
- return ret;
-}
-
-static int sun4i_mdio_remove(struct platform_device *pdev)
-{
- struct mii_bus *bus = platform_get_drvdata(pdev);
- struct sun4i_mdio_data *data = bus->priv;
-
- mdiobus_unregister(bus);
- if (data->regulator)
- regulator_disable(data->regulator);
- mdiobus_free(bus);
-
- return 0;
-}
-
-static const struct of_device_id sun4i_mdio_dt_ids[] = {
- { .compatible = "allwinner,sun4i-a10-mdio" },
-
- /* Deprecated */
- { .compatible = "allwinner,sun4i-mdio" },
- { }
-};
-MODULE_DEVICE_TABLE(of, sun4i_mdio_dt_ids);
-
-static struct platform_driver sun4i_mdio_driver = {
- .probe = sun4i_mdio_probe,
- .remove = sun4i_mdio_remove,
- .driver = {
- .name = "sun4i-mdio",
- .of_match_table = sun4i_mdio_dt_ids,
- },
-};
-
-module_platform_driver(sun4i_mdio_driver);
-
-MODULE_DESCRIPTION("Allwinner EMAC MDIO interface driver");
-MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2009-2016 Cavium, Inc.
- */
-
-#include <linux/of_address.h>
-#include <linux/of_mdio.h>
-#include <linux/module.h>
-#include <linux/gfp.h>
-#include <linux/phy.h>
-#include <linux/io.h>
-#include <linux/acpi.h>
-#include <linux/pci.h>
-
-#include "mdio-cavium.h"
-
-struct thunder_mdiobus_nexus {
- void __iomem *bar0;
- struct cavium_mdiobus *buses[4];
-};
-
-static int thunder_mdiobus_pci_probe(struct pci_dev *pdev,
- const struct pci_device_id *ent)
-{
- struct device_node *node;
- struct fwnode_handle *fwn;
- struct thunder_mdiobus_nexus *nexus;
- int err;
- int i;
-
- nexus = devm_kzalloc(&pdev->dev, sizeof(*nexus), GFP_KERNEL);
- if (!nexus)
- return -ENOMEM;
-
- pci_set_drvdata(pdev, nexus);
-
- err = pcim_enable_device(pdev);
- if (err) {
- dev_err(&pdev->dev, "Failed to enable PCI device\n");
- pci_set_drvdata(pdev, NULL);
- return err;
- }
-
- err = pci_request_regions(pdev, KBUILD_MODNAME);
- if (err) {
- dev_err(&pdev->dev, "pci_request_regions failed\n");
- goto err_disable_device;
- }
-
- nexus->bar0 = pcim_iomap(pdev, 0, pci_resource_len(pdev, 0));
- if (!nexus->bar0) {
- err = -ENOMEM;
- goto err_release_regions;
- }
-
- i = 0;
- device_for_each_child_node(&pdev->dev, fwn) {
- struct resource r;
- struct mii_bus *mii_bus;
- struct cavium_mdiobus *bus;
- union cvmx_smix_en smi_en;
-
- /* If it is not an OF node we cannot handle it yet, so
- * exit the loop.
- */
- node = to_of_node(fwn);
- if (!node)
- break;
-
- err = of_address_to_resource(node, 0, &r);
- if (err) {
- dev_err(&pdev->dev,
- "Couldn't translate address for \"%pOFn\"\n",
- node);
- break;
- }
-
- mii_bus = devm_mdiobus_alloc_size(&pdev->dev, sizeof(*bus));
- if (!mii_bus)
- break;
- bus = mii_bus->priv;
- bus->mii_bus = mii_bus;
-
- nexus->buses[i] = bus;
- i++;
-
- bus->register_base = nexus->bar0 +
- r.start - pci_resource_start(pdev, 0);
-
- smi_en.u64 = 0;
- smi_en.s.en = 1;
- oct_mdio_writeq(smi_en.u64, bus->register_base + SMI_EN);
- bus->mii_bus->name = KBUILD_MODNAME;
- snprintf(bus->mii_bus->id, MII_BUS_ID_SIZE, "%llx", r.start);
- bus->mii_bus->parent = &pdev->dev;
- bus->mii_bus->read = cavium_mdiobus_read;
- bus->mii_bus->write = cavium_mdiobus_write;
-
- err = of_mdiobus_register(bus->mii_bus, node);
- if (err)
- dev_err(&pdev->dev, "of_mdiobus_register failed\n");
-
- dev_info(&pdev->dev, "Added bus at %llx\n", r.start);
- if (i >= ARRAY_SIZE(nexus->buses))
- break;
- }
- return 0;
-
-err_release_regions:
- pci_release_regions(pdev);
-
-err_disable_device:
- pci_set_drvdata(pdev, NULL);
- return err;
-}
-
-static void thunder_mdiobus_pci_remove(struct pci_dev *pdev)
-{
- int i;
- struct thunder_mdiobus_nexus *nexus = pci_get_drvdata(pdev);
-
- for (i = 0; i < ARRAY_SIZE(nexus->buses); i++) {
- struct cavium_mdiobus *bus = nexus->buses[i];
-
- if (!bus)
- continue;
-
- mdiobus_unregister(bus->mii_bus);
- mdiobus_free(bus->mii_bus);
- oct_mdio_writeq(0, bus->register_base + SMI_EN);
- }
- pci_release_regions(pdev);
- pci_set_drvdata(pdev, NULL);
-}
-
-static const struct pci_device_id thunder_mdiobus_id_table[] = {
- { PCI_DEVICE(PCI_VENDOR_ID_CAVIUM, 0xa02b) },
- { 0, } /* End of table. */
-};
-MODULE_DEVICE_TABLE(pci, thunder_mdiobus_id_table);
-
-static struct pci_driver thunder_mdiobus_driver = {
- .name = KBUILD_MODNAME,
- .id_table = thunder_mdiobus_id_table,
- .probe = thunder_mdiobus_pci_probe,
- .remove = thunder_mdiobus_pci_remove,
-};
-
-module_pci_driver(thunder_mdiobus_driver);
-
-MODULE_DESCRIPTION("Cavium ThunderX MDIO bus driver");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0+
-/* Applied Micro X-Gene SoC MDIO Driver
- *
- * Copyright (c) 2016, Applied Micro Circuits Corporation
- * Author: Iyappan Subramanian <isubramanian@apm.com>
- */
-
-#include <linux/acpi.h>
-#include <linux/clk.h>
-#include <linux/device.h>
-#include <linux/efi.h>
-#include <linux/if_vlan.h>
-#include <linux/io.h>
-#include <linux/mdio/mdio-xgene.h>
-#include <linux/module.h>
-#include <linux/of_platform.h>
-#include <linux/of_net.h>
-#include <linux/of_mdio.h>
-#include <linux/prefetch.h>
-#include <linux/phy.h>
-#include <net/ip.h>
-
-static bool xgene_mdio_status;
-
-u32 xgene_mdio_rd_mac(struct xgene_mdio_pdata *pdata, u32 rd_addr)
-{
- void __iomem *addr, *rd, *cmd, *cmd_done;
- u32 done, rd_data = BUSY_MASK;
- u8 wait = 10;
-
- addr = pdata->mac_csr_addr + MAC_ADDR_REG_OFFSET;
- rd = pdata->mac_csr_addr + MAC_READ_REG_OFFSET;
- cmd = pdata->mac_csr_addr + MAC_COMMAND_REG_OFFSET;
- cmd_done = pdata->mac_csr_addr + MAC_COMMAND_DONE_REG_OFFSET;
-
- spin_lock(&pdata->mac_lock);
- iowrite32(rd_addr, addr);
- iowrite32(XGENE_ENET_RD_CMD, cmd);
-
- while (!(done = ioread32(cmd_done)) && wait--)
- udelay(1);
-
- if (done)
- rd_data = ioread32(rd);
-
- iowrite32(0, cmd);
- spin_unlock(&pdata->mac_lock);
-
- return rd_data;
-}
-EXPORT_SYMBOL(xgene_mdio_rd_mac);
-
-void xgene_mdio_wr_mac(struct xgene_mdio_pdata *pdata, u32 wr_addr, u32 data)
-{
- void __iomem *addr, *wr, *cmd, *cmd_done;
- u8 wait = 10;
- u32 done;
-
- addr = pdata->mac_csr_addr + MAC_ADDR_REG_OFFSET;
- wr = pdata->mac_csr_addr + MAC_WRITE_REG_OFFSET;
- cmd = pdata->mac_csr_addr + MAC_COMMAND_REG_OFFSET;
- cmd_done = pdata->mac_csr_addr + MAC_COMMAND_DONE_REG_OFFSET;
-
- spin_lock(&pdata->mac_lock);
- iowrite32(wr_addr, addr);
- iowrite32(data, wr);
- iowrite32(XGENE_ENET_WR_CMD, cmd);
-
- while (!(done = ioread32(cmd_done)) && wait--)
- udelay(1);
-
- if (!done)
- pr_err("MCX mac write failed, addr: 0x%04x\n", wr_addr);
-
- iowrite32(0, cmd);
- spin_unlock(&pdata->mac_lock);
-}
-EXPORT_SYMBOL(xgene_mdio_wr_mac);
-
-int xgene_mdio_rgmii_read(struct mii_bus *bus, int phy_id, int reg)
-{
- struct xgene_mdio_pdata *pdata = (struct xgene_mdio_pdata *)bus->priv;
- u32 data, done;
- u8 wait = 10;
-
- data = SET_VAL(PHY_ADDR, phy_id) | SET_VAL(REG_ADDR, reg);
- xgene_mdio_wr_mac(pdata, MII_MGMT_ADDRESS_ADDR, data);
- xgene_mdio_wr_mac(pdata, MII_MGMT_COMMAND_ADDR, READ_CYCLE_MASK);
- do {
- usleep_range(5, 10);
- done = xgene_mdio_rd_mac(pdata, MII_MGMT_INDICATORS_ADDR);
- } while ((done & BUSY_MASK) && wait--);
-
- if (done & BUSY_MASK) {
- dev_err(&bus->dev, "MII_MGMT read failed\n");
- return -EBUSY;
- }
-
- data = xgene_mdio_rd_mac(pdata, MII_MGMT_STATUS_ADDR);
- xgene_mdio_wr_mac(pdata, MII_MGMT_COMMAND_ADDR, 0);
-
- return data;
-}
-EXPORT_SYMBOL(xgene_mdio_rgmii_read);
-
-int xgene_mdio_rgmii_write(struct mii_bus *bus, int phy_id, int reg, u16 data)
-{
- struct xgene_mdio_pdata *pdata = (struct xgene_mdio_pdata *)bus->priv;
- u32 val, done;
- u8 wait = 10;
-
- val = SET_VAL(PHY_ADDR, phy_id) | SET_VAL(REG_ADDR, reg);
- xgene_mdio_wr_mac(pdata, MII_MGMT_ADDRESS_ADDR, val);
-
- xgene_mdio_wr_mac(pdata, MII_MGMT_CONTROL_ADDR, data);
- do {
- usleep_range(5, 10);
- done = xgene_mdio_rd_mac(pdata, MII_MGMT_INDICATORS_ADDR);
- } while ((done & BUSY_MASK) && wait--);
-
- if (done & BUSY_MASK) {
- dev_err(&bus->dev, "MII_MGMT write failed\n");
- return -EBUSY;
- }
-
- return 0;
-}
-EXPORT_SYMBOL(xgene_mdio_rgmii_write);
-
-static u32 xgene_menet_rd_diag_csr(struct xgene_mdio_pdata *pdata, u32 offset)
-{
- return ioread32(pdata->diag_csr_addr + offset);
-}
-
-static void xgene_menet_wr_diag_csr(struct xgene_mdio_pdata *pdata,
- u32 offset, u32 val)
-{
- iowrite32(val, pdata->diag_csr_addr + offset);
-}
-
-static int xgene_enet_ecc_init(struct xgene_mdio_pdata *pdata)
-{
- u32 data;
- u8 wait = 10;
-
- xgene_menet_wr_diag_csr(pdata, MENET_CFG_MEM_RAM_SHUTDOWN_ADDR, 0x0);
- do {
- usleep_range(100, 110);
- data = xgene_menet_rd_diag_csr(pdata, MENET_BLOCK_MEM_RDY_ADDR);
- } while ((data != 0xffffffff) && wait--);
-
- if (data != 0xffffffff) {
- dev_err(pdata->dev, "Failed to release memory from shutdown\n");
- return -ENODEV;
- }
-
- return 0;
-}
-
-static void xgene_gmac_reset(struct xgene_mdio_pdata *pdata)
-{
- xgene_mdio_wr_mac(pdata, MAC_CONFIG_1_ADDR, SOFT_RESET);
- xgene_mdio_wr_mac(pdata, MAC_CONFIG_1_ADDR, 0);
-}
-
-static int xgene_mdio_reset(struct xgene_mdio_pdata *pdata)
-{
- int ret;
-
- if (pdata->dev->of_node) {
- clk_prepare_enable(pdata->clk);
- udelay(5);
- clk_disable_unprepare(pdata->clk);
- udelay(5);
- clk_prepare_enable(pdata->clk);
- udelay(5);
- } else {
-#ifdef CONFIG_ACPI
- acpi_evaluate_object(ACPI_HANDLE(pdata->dev),
- "_RST", NULL, NULL);
-#endif
- }
-
- ret = xgene_enet_ecc_init(pdata);
- if (ret) {
- if (pdata->dev->of_node)
- clk_disable_unprepare(pdata->clk);
- return ret;
- }
- xgene_gmac_reset(pdata);
-
- return 0;
-}
-
-static void xgene_enet_rd_mdio_csr(void __iomem *base_addr,
- u32 offset, u32 *val)
-{
- void __iomem *addr = base_addr + offset;
-
- *val = ioread32(addr);
-}
-
-static void xgene_enet_wr_mdio_csr(void __iomem *base_addr,
- u32 offset, u32 val)
-{
- void __iomem *addr = base_addr + offset;
-
- iowrite32(val, addr);
-}
-
-static int xgene_xfi_mdio_write(struct mii_bus *bus, int phy_id,
- int reg, u16 data)
-{
- void __iomem *addr = (void __iomem *)bus->priv;
- int timeout = 100;
- u32 status, val;
-
- val = SET_VAL(HSTPHYADX, phy_id) | SET_VAL(HSTREGADX, reg) |
- SET_VAL(HSTMIIMWRDAT, data);
- xgene_enet_wr_mdio_csr(addr, MIIM_FIELD_ADDR, val);
-
- val = HSTLDCMD | SET_VAL(HSTMIIMCMD, MIIM_CMD_LEGACY_WRITE);
- xgene_enet_wr_mdio_csr(addr, MIIM_COMMAND_ADDR, val);
-
- do {
- usleep_range(5, 10);
- xgene_enet_rd_mdio_csr(addr, MIIM_INDICATOR_ADDR, &status);
- } while ((status & BUSY_MASK) && timeout--);
-
- xgene_enet_wr_mdio_csr(addr, MIIM_COMMAND_ADDR, 0);
-
- return 0;
-}
-
-static int xgene_xfi_mdio_read(struct mii_bus *bus, int phy_id, int reg)
-{
- void __iomem *addr = (void __iomem *)bus->priv;
- u32 data, status, val;
- int timeout = 100;
-
- val = SET_VAL(HSTPHYADX, phy_id) | SET_VAL(HSTREGADX, reg);
- xgene_enet_wr_mdio_csr(addr, MIIM_FIELD_ADDR, val);
-
- val = HSTLDCMD | SET_VAL(HSTMIIMCMD, MIIM_CMD_LEGACY_READ);
- xgene_enet_wr_mdio_csr(addr, MIIM_COMMAND_ADDR, val);
-
- do {
- usleep_range(5, 10);
- xgene_enet_rd_mdio_csr(addr, MIIM_INDICATOR_ADDR, &status);
- } while ((status & BUSY_MASK) && timeout--);
-
- if (status & BUSY_MASK) {
- pr_err("XGENET_MII_MGMT write failed\n");
- return -EBUSY;
- }
-
- xgene_enet_rd_mdio_csr(addr, MIIMRD_FIELD_ADDR, &data);
- xgene_enet_wr_mdio_csr(addr, MIIM_COMMAND_ADDR, 0);
-
- return data;
-}
-
-struct phy_device *xgene_enet_phy_register(struct mii_bus *bus, int phy_addr)
-{
- struct phy_device *phy_dev;
-
- phy_dev = get_phy_device(bus, phy_addr, false);
- if (!phy_dev || IS_ERR(phy_dev))
- return NULL;
-
- if (phy_device_register(phy_dev))
- phy_device_free(phy_dev);
-
- return phy_dev;
-}
-EXPORT_SYMBOL(xgene_enet_phy_register);
-
-#ifdef CONFIG_ACPI
-static acpi_status acpi_register_phy(acpi_handle handle, u32 lvl,
- void *context, void **ret)
-{
- struct mii_bus *mdio = context;
- struct acpi_device *adev;
- struct phy_device *phy_dev;
- const union acpi_object *obj;
- u32 phy_addr;
-
- if (acpi_bus_get_device(handle, &adev))
- return AE_OK;
-
- if (acpi_dev_get_property(adev, "phy-channel", ACPI_TYPE_INTEGER, &obj))
- return AE_OK;
- phy_addr = obj->integer.value;
-
- phy_dev = xgene_enet_phy_register(mdio, phy_addr);
- adev->driver_data = phy_dev;
-
- return AE_OK;
-}
-#endif
-
-static const struct of_device_id xgene_mdio_of_match[] = {
- {
- .compatible = "apm,xgene-mdio-rgmii",
- .data = (void *)XGENE_MDIO_RGMII
- },
- {
- .compatible = "apm,xgene-mdio-xfi",
- .data = (void *)XGENE_MDIO_XFI
- },
- {},
-};
-MODULE_DEVICE_TABLE(of, xgene_mdio_of_match);
-
-#ifdef CONFIG_ACPI
-static const struct acpi_device_id xgene_mdio_acpi_match[] = {
- { "APMC0D65", XGENE_MDIO_RGMII },
- { "APMC0D66", XGENE_MDIO_XFI },
- { }
-};
-
-MODULE_DEVICE_TABLE(acpi, xgene_mdio_acpi_match);
-#endif
-
-
-static int xgene_mdio_probe(struct platform_device *pdev)
-{
- struct device *dev = &pdev->dev;
- struct mii_bus *mdio_bus;
- const struct of_device_id *of_id;
- struct xgene_mdio_pdata *pdata;
- void __iomem *csr_base;
- int mdio_id = 0, ret = 0;
-
- of_id = of_match_device(xgene_mdio_of_match, &pdev->dev);
- if (of_id) {
- mdio_id = (enum xgene_mdio_id)of_id->data;
- } else {
-#ifdef CONFIG_ACPI
- const struct acpi_device_id *acpi_id;
-
- acpi_id = acpi_match_device(xgene_mdio_acpi_match, &pdev->dev);
- if (acpi_id)
- mdio_id = (enum xgene_mdio_id)acpi_id->driver_data;
-#endif
- }
-
- if (!mdio_id)
- return -ENODEV;
-
- pdata = devm_kzalloc(dev, sizeof(struct xgene_mdio_pdata), GFP_KERNEL);
- if (!pdata)
- return -ENOMEM;
- pdata->mdio_id = mdio_id;
- pdata->dev = dev;
-
- csr_base = devm_platform_ioremap_resource(pdev, 0);
- if (IS_ERR(csr_base))
- return PTR_ERR(csr_base);
- pdata->mac_csr_addr = csr_base;
- pdata->mdio_csr_addr = csr_base + BLOCK_XG_MDIO_CSR_OFFSET;
- pdata->diag_csr_addr = csr_base + BLOCK_DIAG_CSR_OFFSET;
-
- if (mdio_id == XGENE_MDIO_RGMII)
- spin_lock_init(&pdata->mac_lock);
-
- if (dev->of_node) {
- pdata->clk = devm_clk_get(dev, NULL);
- if (IS_ERR(pdata->clk)) {
- dev_err(dev, "Unable to retrieve clk\n");
- return PTR_ERR(pdata->clk);
- }
- }
-
- ret = xgene_mdio_reset(pdata);
- if (ret)
- return ret;
-
- mdio_bus = mdiobus_alloc();
- if (!mdio_bus) {
- ret = -ENOMEM;
- goto out_clk;
- }
-
- mdio_bus->name = "APM X-Gene MDIO bus";
-
- if (mdio_id == XGENE_MDIO_RGMII) {
- mdio_bus->read = xgene_mdio_rgmii_read;
- mdio_bus->write = xgene_mdio_rgmii_write;
- mdio_bus->priv = (void __force *)pdata;
- snprintf(mdio_bus->id, MII_BUS_ID_SIZE, "%s",
- "xgene-mii-rgmii");
- } else {
- mdio_bus->read = xgene_xfi_mdio_read;
- mdio_bus->write = xgene_xfi_mdio_write;
- mdio_bus->priv = (void __force *)pdata->mdio_csr_addr;
- snprintf(mdio_bus->id, MII_BUS_ID_SIZE, "%s",
- "xgene-mii-xfi");
- }
-
- mdio_bus->parent = dev;
- platform_set_drvdata(pdev, pdata);
-
- if (dev->of_node) {
- ret = of_mdiobus_register(mdio_bus, dev->of_node);
- } else {
-#ifdef CONFIG_ACPI
- /* Mask out all PHYs from auto probing. */
- mdio_bus->phy_mask = ~0;
- ret = mdiobus_register(mdio_bus);
- if (ret)
- goto out_mdiobus;
-
- acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_HANDLE(dev), 1,
- acpi_register_phy, NULL, mdio_bus, NULL);
-#endif
- }
-
- if (ret)
- goto out_mdiobus;
-
- pdata->mdio_bus = mdio_bus;
- xgene_mdio_status = true;
-
- return 0;
-
-out_mdiobus:
- mdiobus_free(mdio_bus);
-
-out_clk:
- if (dev->of_node)
- clk_disable_unprepare(pdata->clk);
-
- return ret;
-}
-
-static int xgene_mdio_remove(struct platform_device *pdev)
-{
- struct xgene_mdio_pdata *pdata = platform_get_drvdata(pdev);
- struct mii_bus *mdio_bus = pdata->mdio_bus;
- struct device *dev = &pdev->dev;
-
- mdiobus_unregister(mdio_bus);
- mdiobus_free(mdio_bus);
-
- if (dev->of_node)
- clk_disable_unprepare(pdata->clk);
-
- return 0;
-}
-
-static struct platform_driver xgene_mdio_driver = {
- .driver = {
- .name = "xgene-mdio",
- .of_match_table = of_match_ptr(xgene_mdio_of_match),
- .acpi_match_table = ACPI_PTR(xgene_mdio_acpi_match),
- },
- .probe = xgene_mdio_probe,
- .remove = xgene_mdio_remove,
-};
-
-module_platform_driver(xgene_mdio_driver);
-
-MODULE_DESCRIPTION("APM X-Gene SoC MDIO driver");
-MODULE_AUTHOR("Iyappan Subramanian <isubramanian@apm.com>");
-MODULE_LICENSE("GPL");
projects / kernel.git / commitdiff