Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-12-01 08:31:37 +00:00
Code Issues Packages Projects Releases Wiki Activity
ff8d523cc4
linux/drivers/net/pcs/pcs-xpcs-plat.c
Serge Semin f6bb3e9d98 net: pcs: xpcs: Add Synopsys DW xPCS platform device driver 
Synopsys DesignWare XPCS IP-core can be synthesized with the device CSRs
being accessible over the MCI or APB3 interface instead of the MDIO bus
(see the CSR_INTERFACE HDL parameter). Thus all the PCS registers can be
just memory mapped and be a subject of the standard MMIO operations of
course taking into account the peculiarities of the Clause C45 CSRs
mapping. From that perspective the DW XPCS devices would look as just
normal platform devices for the kernel.

On the other hand in order to have the DW XPCS devices handled by the
pcs-xpcs.c driver they need to be registered in the framework of the
MDIO-subsystem. So the suggested change is about providing a DW XPCS
platform device driver registering a virtual MDIO-bus with a single
MDIO-device representing the DW XPCS device.

DW XPCS platform device is supposed to be described by the respective
compatible string "snps,dw-xpcs" (or with the PMA-specific compatible
string), CSRs memory space and optional peripheral bus and reference clock
sources. Depending on the INDIRECT_ACCESS IP-core synthesize parameter the
memory-mapped reg-space can be represented as either directly or
indirectly mapped Clause 45 space. In the former case the particular
address is determined based on the MMD device and the registers offset (5
+ 16 bits all together) within the device reg-space. In the later case
there is only 8 lower address bits are utilized for the registers mapping
(255 CSRs). The upper bits are supposed to be written into the respective
viewport CSR in order to select the respective MMD sub-page.

Note, only the peripheral bus clock source is requested in the platform
device probe procedure. The core and pad clocks handling has been
implemented in the framework of the xpcs_create() method intentionally
since the clocks-related setups are supposed to be performed later, during
the DW XPCS main configuration procedures. (For instance they will be
required for the DW Gen5 10G PMA configuration.)

Signed-off-by: Serge Semin <fancer.lancer@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2024-07-05 09:35:50 +01:00

461 lines
11 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0
/*
* Synopsys DesignWare XPCS platform device driver
*
* Copyright (C) 2024 Serge Semin
*/
#include <linux/atomic.h>
#include <linux/bitfield.h>
#include <linux/clk.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/mdio.h>
#include <linux/module.h>
#include <linux/pcs/pcs-xpcs.h>
#include <linux/phy.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/property.h>
#include <linux/sizes.h>
#include "pcs-xpcs.h"
/* Page select register for the indirect MMIO CSRs access */
#define DW_VR_CSR_VIEWPORT 0xff
struct dw_xpcs_plat {
struct platform_device *pdev;
struct mii_bus *bus;
bool reg_indir;
int reg_width;
void __iomem *reg_base;
struct clk *cclk;
};
static ptrdiff_t xpcs_mmio_addr_format(int dev, int reg)
{
return FIELD_PREP(0x1f0000, dev) | FIELD_PREP(0xffff, reg);
}
static u16 xpcs_mmio_addr_page(ptrdiff_t csr)
{
return FIELD_GET(0x1fff00, csr);
}
static ptrdiff_t xpcs_mmio_addr_offset(ptrdiff_t csr)
{
return FIELD_GET(0xff, csr);
}
static int xpcs_mmio_read_reg_indirect(struct dw_xpcs_plat *pxpcs,
int dev, int reg)
{
ptrdiff_t csr, ofs;
u16 page;
int ret;
csr = xpcs_mmio_addr_format(dev, reg);
page = xpcs_mmio_addr_page(csr);
ofs = xpcs_mmio_addr_offset(csr);
ret = pm_runtime_resume_and_get(&pxpcs->pdev->dev);
if (ret)
return ret;
switch (pxpcs->reg_width) {
case 4:
writel(page, pxpcs->reg_base + (DW_VR_CSR_VIEWPORT << 2));
ret = readl(pxpcs->reg_base + (ofs << 2));
break;
default:
writew(page, pxpcs->reg_base + (DW_VR_CSR_VIEWPORT << 1));
ret = readw(pxpcs->reg_base + (ofs << 1));
break;
}
pm_runtime_put(&pxpcs->pdev->dev);
return ret;
}
static int xpcs_mmio_write_reg_indirect(struct dw_xpcs_plat *pxpcs,
int dev, int reg, u16 val)
{
ptrdiff_t csr, ofs;
u16 page;
int ret;
csr = xpcs_mmio_addr_format(dev, reg);
page = xpcs_mmio_addr_page(csr);
ofs = xpcs_mmio_addr_offset(csr);
ret = pm_runtime_resume_and_get(&pxpcs->pdev->dev);
if (ret)
return ret;
switch (pxpcs->reg_width) {
case 4:
writel(page, pxpcs->reg_base + (DW_VR_CSR_VIEWPORT << 2));
writel(val, pxpcs->reg_base + (ofs << 2));
break;
default:
writew(page, pxpcs->reg_base + (DW_VR_CSR_VIEWPORT << 1));
writew(val, pxpcs->reg_base + (ofs << 1));
break;
}
pm_runtime_put(&pxpcs->pdev->dev);
return 0;
}
static int xpcs_mmio_read_reg_direct(struct dw_xpcs_plat *pxpcs,
int dev, int reg)
{
ptrdiff_t csr;
int ret;
csr = xpcs_mmio_addr_format(dev, reg);
ret = pm_runtime_resume_and_get(&pxpcs->pdev->dev);
if (ret)
return ret;
switch (pxpcs->reg_width) {
case 4:
ret = readl(pxpcs->reg_base + (csr << 2));
break;
default:
ret = readw(pxpcs->reg_base + (csr << 1));
break;
}
pm_runtime_put(&pxpcs->pdev->dev);
return ret;
}
static int xpcs_mmio_write_reg_direct(struct dw_xpcs_plat *pxpcs,
int dev, int reg, u16 val)
{
ptrdiff_t csr;
int ret;
csr = xpcs_mmio_addr_format(dev, reg);
ret = pm_runtime_resume_and_get(&pxpcs->pdev->dev);
if (ret)
return ret;
switch (pxpcs->reg_width) {
case 4:
writel(val, pxpcs->reg_base + (csr << 2));
break;
default:
writew(val, pxpcs->reg_base + (csr << 1));
break;
}
pm_runtime_put(&pxpcs->pdev->dev);
return 0;
}
static int xpcs_mmio_read_c22(struct mii_bus *bus, int addr, int reg)
{
struct dw_xpcs_plat *pxpcs = bus->priv;
if (addr != 0)
return -ENODEV;
if (pxpcs->reg_indir)
return xpcs_mmio_read_reg_indirect(pxpcs, MDIO_MMD_VEND2, reg);
else
return xpcs_mmio_read_reg_direct(pxpcs, MDIO_MMD_VEND2, reg);
}
static int xpcs_mmio_write_c22(struct mii_bus *bus, int addr, int reg, u16 val)
{
struct dw_xpcs_plat *pxpcs = bus->priv;
if (addr != 0)
return -ENODEV;
if (pxpcs->reg_indir)
return xpcs_mmio_write_reg_indirect(pxpcs, MDIO_MMD_VEND2, reg, val);
else
return xpcs_mmio_write_reg_direct(pxpcs, MDIO_MMD_VEND2, reg, val);
}
static int xpcs_mmio_read_c45(struct mii_bus *bus, int addr, int dev, int reg)
{
struct dw_xpcs_plat *pxpcs = bus->priv;
if (addr != 0)
return -ENODEV;
if (pxpcs->reg_indir)
return xpcs_mmio_read_reg_indirect(pxpcs, dev, reg);
else
return xpcs_mmio_read_reg_direct(pxpcs, dev, reg);
}
static int xpcs_mmio_write_c45(struct mii_bus *bus, int addr, int dev,
int reg, u16 val)
{
struct dw_xpcs_plat *pxpcs = bus->priv;
if (addr != 0)
return -ENODEV;
if (pxpcs->reg_indir)
return xpcs_mmio_write_reg_indirect(pxpcs, dev, reg, val);
else
return xpcs_mmio_write_reg_direct(pxpcs, dev, reg, val);
}
static struct dw_xpcs_plat *xpcs_plat_create_data(struct platform_device *pdev)
{
struct dw_xpcs_plat *pxpcs;
pxpcs = devm_kzalloc(&pdev->dev, sizeof(*pxpcs), GFP_KERNEL);
if (!pxpcs)
return ERR_PTR(-ENOMEM);
pxpcs->pdev = pdev;
dev_set_drvdata(&pdev->dev, pxpcs);
return pxpcs;
}
static int xpcs_plat_init_res(struct dw_xpcs_plat *pxpcs)
{
struct platform_device *pdev = pxpcs->pdev;
struct device *dev = &pdev->dev;
resource_size_t spc_size;
struct resource *res;
if (!device_property_read_u32(dev, "reg-io-width", &pxpcs->reg_width)) {
if (pxpcs->reg_width != 2 && pxpcs->reg_width != 4) {
dev_err(dev, "Invalid reg-space data width\n");
return -EINVAL;
}
} else {
pxpcs->reg_width = 2;
}
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "direct") ?:
platform_get_resource_byname(pdev, IORESOURCE_MEM, "indirect");
if (!res) {
dev_err(dev, "No reg-space found\n");
return -EINVAL;
}
if (!strcmp(res->name, "indirect"))
pxpcs->reg_indir = true;
if (pxpcs->reg_indir)
spc_size = pxpcs->reg_width * SZ_256;
else
spc_size = pxpcs->reg_width * SZ_2M;
if (resource_size(res) < spc_size) {
dev_err(dev, "Invalid reg-space size\n");
return -EINVAL;
}
pxpcs->reg_base = devm_ioremap_resource(dev, res);
if (IS_ERR(pxpcs->reg_base)) {
dev_err(dev, "Failed to map reg-space\n");
return PTR_ERR(pxpcs->reg_base);
}
return 0;
}
static int xpcs_plat_init_clk(struct dw_xpcs_plat *pxpcs)
{
struct device *dev = &pxpcs->pdev->dev;
int ret;
pxpcs->cclk = devm_clk_get(dev, "csr");
if (IS_ERR(pxpcs->cclk))
return dev_err_probe(dev, PTR_ERR(pxpcs->cclk),
"Failed to get CSR clock\n");
pm_runtime_set_active(dev);
ret = devm_pm_runtime_enable(dev);
if (ret) {
dev_err(dev, "Failed to enable runtime-PM\n");
return ret;
}
return 0;
}
static int xpcs_plat_init_bus(struct dw_xpcs_plat *pxpcs)
{
struct device *dev = &pxpcs->pdev->dev;
static atomic_t id = ATOMIC_INIT(-1);
int ret;
pxpcs->bus = devm_mdiobus_alloc_size(dev, 0);
if (!pxpcs->bus)
return -ENOMEM;
pxpcs->bus->name = "DW XPCS MCI/APB3";
pxpcs->bus->read = xpcs_mmio_read_c22;
pxpcs->bus->write = xpcs_mmio_write_c22;
pxpcs->bus->read_c45 = xpcs_mmio_read_c45;
pxpcs->bus->write_c45 = xpcs_mmio_write_c45;
pxpcs->bus->phy_mask = ~0;
pxpcs->bus->parent = dev;
pxpcs->bus->priv = pxpcs;
snprintf(pxpcs->bus->id, MII_BUS_ID_SIZE,
"dwxpcs-%x", atomic_inc_return(&id));
/* MDIO-bus here serves as just a back-end engine abstracting out
* the MDIO and MCI/APB3 IO interfaces utilized for the DW XPCS CSRs
* access.
*/
ret = devm_mdiobus_register(dev, pxpcs->bus);
if (ret) {
dev_err(dev, "Failed to create MDIO bus\n");
return ret;
}
return 0;
}
/* Note there is no need in the next function antagonist because the MDIO-bus
* de-registration will effectively remove and destroy all the MDIO-devices
* registered on the bus.
*/
static int xpcs_plat_init_dev(struct dw_xpcs_plat *pxpcs)
{
struct device *dev = &pxpcs->pdev->dev;
struct mdio_device *mdiodev;
int ret;
/* There is a single memory-mapped DW XPCS device */
mdiodev = mdio_device_create(pxpcs->bus, 0);
if (IS_ERR(mdiodev))
return PTR_ERR(mdiodev);
/* Associate the FW-node with the device structure so it can be looked
* up later. Make sure DD-core is aware of the OF-node being re-used.
*/
device_set_node(&mdiodev->dev, fwnode_handle_get(dev_fwnode(dev)));
mdiodev->dev.of_node_reused = true;
/* Pass the data further so the DW XPCS driver core could use it */
mdiodev->dev.platform_data = (void *)device_get_match_data(dev);
ret = mdio_device_register(mdiodev);
if (ret) {
dev_err(dev, "Failed to register MDIO device\n");
goto err_clean_data;
}
return 0;
err_clean_data:
mdiodev->dev.platform_data = NULL;
fwnode_handle_put(dev_fwnode(&mdiodev->dev));
device_set_node(&mdiodev->dev, NULL);
mdio_device_free(mdiodev);
return ret;
}
static int xpcs_plat_probe(struct platform_device *pdev)
{
struct dw_xpcs_plat *pxpcs;
int ret;
pxpcs = xpcs_plat_create_data(pdev);
if (IS_ERR(pxpcs))
return PTR_ERR(pxpcs);
ret = xpcs_plat_init_res(pxpcs);
if (ret)
return ret;
ret = xpcs_plat_init_clk(pxpcs);
if (ret)
return ret;
ret = xpcs_plat_init_bus(pxpcs);
if (ret)
return ret;
ret = xpcs_plat_init_dev(pxpcs);
if (ret)
return ret;
return 0;
}
static int __maybe_unused xpcs_plat_pm_runtime_suspend(struct device *dev)
{
struct dw_xpcs_plat *pxpcs = dev_get_drvdata(dev);
clk_disable_unprepare(pxpcs->cclk);
return 0;
}
static int __maybe_unused xpcs_plat_pm_runtime_resume(struct device *dev)
{
struct dw_xpcs_plat *pxpcs = dev_get_drvdata(dev);
return clk_prepare_enable(pxpcs->cclk);
}
static const struct dev_pm_ops xpcs_plat_pm_ops = {
SET_RUNTIME_PM_OPS(xpcs_plat_pm_runtime_suspend,
xpcs_plat_pm_runtime_resume,
NULL)
};
DW_XPCS_INFO_DECLARE(xpcs_generic, DW_XPCS_ID_NATIVE, DW_XPCS_PMA_ID_NATIVE);
DW_XPCS_INFO_DECLARE(xpcs_pma_gen1_3g, DW_XPCS_ID_NATIVE, DW_XPCS_PMA_GEN1_3G_ID);
DW_XPCS_INFO_DECLARE(xpcs_pma_gen2_3g, DW_XPCS_ID_NATIVE, DW_XPCS_PMA_GEN2_3G_ID);
DW_XPCS_INFO_DECLARE(xpcs_pma_gen2_6g, DW_XPCS_ID_NATIVE, DW_XPCS_PMA_GEN2_6G_ID);
DW_XPCS_INFO_DECLARE(xpcs_pma_gen4_3g, DW_XPCS_ID_NATIVE, DW_XPCS_PMA_GEN4_3G_ID);
DW_XPCS_INFO_DECLARE(xpcs_pma_gen4_6g, DW_XPCS_ID_NATIVE, DW_XPCS_PMA_GEN4_6G_ID);
DW_XPCS_INFO_DECLARE(xpcs_pma_gen5_10g, DW_XPCS_ID_NATIVE, DW_XPCS_PMA_GEN5_10G_ID);
DW_XPCS_INFO_DECLARE(xpcs_pma_gen5_12g, DW_XPCS_ID_NATIVE, DW_XPCS_PMA_GEN5_12G_ID);
static const struct of_device_id xpcs_of_ids[] = {
{ .compatible = "snps,dw-xpcs", .data = &xpcs_generic },
{ .compatible = "snps,dw-xpcs-gen1-3g", .data = &xpcs_pma_gen1_3g },
{ .compatible = "snps,dw-xpcs-gen2-3g", .data = &xpcs_pma_gen2_3g },
{ .compatible = "snps,dw-xpcs-gen2-6g", .data = &xpcs_pma_gen2_6g },
{ .compatible = "snps,dw-xpcs-gen4-3g", .data = &xpcs_pma_gen4_3g },
{ .compatible = "snps,dw-xpcs-gen4-6g", .data = &xpcs_pma_gen4_6g },
{ .compatible = "snps,dw-xpcs-gen5-10g", .data = &xpcs_pma_gen5_10g },
{ .compatible = "snps,dw-xpcs-gen5-12g", .data = &xpcs_pma_gen5_12g },
{ /* sentinel */ },
};
MODULE_DEVICE_TABLE(of, xpcs_of_ids);
static struct platform_driver xpcs_plat_driver = {
.probe = xpcs_plat_probe,
.driver = {
.name = "dwxpcs",
.pm = &xpcs_plat_pm_ops,
.of_match_table = xpcs_of_ids,
},
};
module_platform_driver(xpcs_plat_driver);
MODULE_DESCRIPTION("Synopsys DesignWare XPCS platform device driver");
MODULE_AUTHOR("Signed-off-by: Serge Semin <fancer.lancer@gmail.com>");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink