2019-01-21 18:05:50 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2014-01-05 00:18:27 +00:00
|
|
|
/* MDIO Bus interface
|
2005-07-30 23:31:23 +00:00
|
|
|
*
|
|
|
|
* Author: Andy Fleming
|
|
|
|
*
|
|
|
|
* Copyright (c) 2004 Freescale Semiconductor, Inc.
|
|
|
|
*/
|
2012-06-09 07:49:07 +00:00
|
|
|
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2005-07-30 23:31:23 +00:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/unistd.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
2009-02-01 08:53:34 +00:00
|
|
|
#include <linux/device.h>
|
2017-04-21 13:15:38 +00:00
|
|
|
#include <linux/gpio.h>
|
|
|
|
#include <linux/gpio/consumer.h>
|
2012-06-27 07:33:37 +00:00
|
|
|
#include <linux/of_device.h>
|
2012-10-08 22:55:43 +00:00
|
|
|
#include <linux/of_mdio.h>
|
2017-04-21 13:15:38 +00:00
|
|
|
#include <linux/of_gpio.h>
|
2005-07-30 23:31:23 +00:00
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
2019-04-17 21:59:21 +00:00
|
|
|
#include <linux/reset.h>
|
2005-07-30 23:31:23 +00:00
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/mii.h>
|
|
|
|
#include <linux/ethtool.h>
|
|
|
|
#include <linux/phy.h>
|
2014-01-05 00:18:27 +00:00
|
|
|
#include <linux/io.h>
|
|
|
|
#include <linux/uaccess.h>
|
2005-07-30 23:31:23 +00:00
|
|
|
|
2016-11-22 15:47:11 +00:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/mdio.h>
|
|
|
|
|
2017-02-04 21:02:44 +00:00
|
|
|
#include "mdio-boardinfo.h"
|
|
|
|
|
2018-01-02 16:40:26 +00:00
|
|
|
static int mdiobus_register_gpiod(struct mdio_device *mdiodev)
|
2016-01-06 19:11:18 +00:00
|
|
|
{
|
2019-09-13 22:55:47 +00:00
|
|
|
int error;
|
2017-12-04 12:35:05 +00:00
|
|
|
|
|
|
|
/* Deassert the optional reset signal */
|
2019-09-13 22:55:47 +00:00
|
|
|
mdiodev->reset_gpio = gpiod_get_optional(&mdiodev->dev,
|
|
|
|
"reset", GPIOD_OUT_LOW);
|
|
|
|
error = PTR_ERR_OR_ZERO(mdiodev->reset_gpio);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
if (mdiodev->reset_gpio)
|
|
|
|
gpiod_set_consumer_name(mdiodev->reset_gpio, "PHY reset");
|
2017-12-04 12:35:05 +00:00
|
|
|
|
2019-04-17 21:59:21 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mdiobus_register_reset(struct mdio_device *mdiodev)
|
|
|
|
{
|
2020-01-13 13:05:29 +00:00
|
|
|
struct reset_control *reset;
|
|
|
|
|
|
|
|
reset = reset_control_get_optional_exclusive(&mdiodev->dev, "phy");
|
|
|
|
if (IS_ERR(reset))
|
|
|
|
return PTR_ERR(reset);
|
2019-04-17 21:59:21 +00:00
|
|
|
|
|
|
|
mdiodev->reset_ctrl = reset;
|
2017-12-04 12:35:05 +00:00
|
|
|
|
2018-01-02 16:40:26 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int mdiobus_register_device(struct mdio_device *mdiodev)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (mdiodev->bus->mdio_map[mdiodev->addr])
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY) {
|
|
|
|
err = mdiobus_register_gpiod(mdiodev);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2019-04-17 21:59:21 +00:00
|
|
|
|
|
|
|
err = mdiobus_register_reset(mdiodev);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* Assert the reset signal */
|
|
|
|
mdio_device_reset(mdiodev, 1);
|
2018-01-02 16:40:26 +00:00
|
|
|
}
|
|
|
|
|
2016-01-06 19:11:18 +00:00
|
|
|
mdiodev->bus->mdio_map[mdiodev->addr] = mdiodev;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdiobus_register_device);
|
|
|
|
|
|
|
|
int mdiobus_unregister_device(struct mdio_device *mdiodev)
|
|
|
|
{
|
|
|
|
if (mdiodev->bus->mdio_map[mdiodev->addr] != mdiodev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2019-11-22 21:44:51 +00:00
|
|
|
reset_control_put(mdiodev->reset_ctrl);
|
|
|
|
|
2016-01-06 19:11:18 +00:00
|
|
|
mdiodev->bus->mdio_map[mdiodev->addr] = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdiobus_unregister_device);
|
|
|
|
|
|
|
|
struct phy_device *mdiobus_get_phy(struct mii_bus *bus, int addr)
|
|
|
|
{
|
|
|
|
struct mdio_device *mdiodev = bus->mdio_map[addr];
|
|
|
|
|
|
|
|
if (!mdiodev)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!(mdiodev->flags & MDIO_DEVICE_FLAG_PHY))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return container_of(mdiodev, struct phy_device, mdio);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdiobus_get_phy);
|
|
|
|
|
|
|
|
bool mdiobus_is_registered_device(struct mii_bus *bus, int addr)
|
|
|
|
{
|
|
|
|
return bus->mdio_map[addr];
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdiobus_is_registered_device);
|
|
|
|
|
2008-10-08 23:29:57 +00:00
|
|
|
/**
|
2012-01-12 23:23:04 +00:00
|
|
|
* mdiobus_alloc_size - allocate a mii_bus structure
|
2012-01-21 09:03:04 +00:00
|
|
|
* @size: extra amount of memory to allocate for private storage.
|
|
|
|
* If non-zero, then bus->priv is points to that memory.
|
2008-10-08 23:29:57 +00:00
|
|
|
*
|
|
|
|
* Description: called by a bus driver to allocate an mii_bus
|
|
|
|
* structure to fill in.
|
|
|
|
*/
|
2012-01-12 23:23:04 +00:00
|
|
|
struct mii_bus *mdiobus_alloc_size(size_t size)
|
2008-10-08 23:29:57 +00:00
|
|
|
{
|
2008-10-08 23:33:40 +00:00
|
|
|
struct mii_bus *bus;
|
2012-01-12 23:23:04 +00:00
|
|
|
size_t aligned_size = ALIGN(sizeof(*bus), NETDEV_ALIGN);
|
|
|
|
size_t alloc_size;
|
2016-01-06 19:11:15 +00:00
|
|
|
int i;
|
2012-01-12 23:23:04 +00:00
|
|
|
|
|
|
|
/* If we alloc extra space, it should be aligned */
|
|
|
|
if (size)
|
|
|
|
alloc_size = aligned_size + size;
|
|
|
|
else
|
|
|
|
alloc_size = sizeof(*bus);
|
2008-10-08 23:33:40 +00:00
|
|
|
|
2012-01-12 23:23:04 +00:00
|
|
|
bus = kzalloc(alloc_size, GFP_KERNEL);
|
2016-01-12 09:34:36 +00:00
|
|
|
if (!bus)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
bus->state = MDIOBUS_ALLOCATED;
|
|
|
|
if (size)
|
|
|
|
bus->priv = (void *)bus + aligned_size;
|
2008-10-08 23:33:40 +00:00
|
|
|
|
2020-01-16 04:48:50 +00:00
|
|
|
/* Initialise the interrupts to polling and 64-bit seqcounts */
|
|
|
|
for (i = 0; i < PHY_MAX_ADDR; i++) {
|
2016-01-06 19:11:15 +00:00
|
|
|
bus->irq[i] = PHY_POLL;
|
2020-01-16 04:48:50 +00:00
|
|
|
u64_stats_init(&bus->stats[i].syncp);
|
|
|
|
}
|
2016-01-06 19:11:15 +00:00
|
|
|
|
2008-10-08 23:33:40 +00:00
|
|
|
return bus;
|
2008-10-08 23:29:57 +00:00
|
|
|
}
|
2012-01-12 23:23:04 +00:00
|
|
|
EXPORT_SYMBOL(mdiobus_alloc_size);
|
2008-10-08 23:29:57 +00:00
|
|
|
|
2014-04-30 12:23:33 +00:00
|
|
|
static void _devm_mdiobus_free(struct device *dev, void *res)
|
|
|
|
{
|
|
|
|
mdiobus_free(*(struct mii_bus **)res);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int devm_mdiobus_match(struct device *dev, void *res, void *data)
|
|
|
|
{
|
|
|
|
struct mii_bus **r = res;
|
|
|
|
|
|
|
|
if (WARN_ON(!r || !*r))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return *r == data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_mdiobus_alloc_size - Resource-managed mdiobus_alloc_size()
|
|
|
|
* @dev: Device to allocate mii_bus for
|
|
|
|
* @sizeof_priv: Space to allocate for private structure.
|
|
|
|
*
|
|
|
|
* Managed mdiobus_alloc_size. mii_bus allocated with this function is
|
|
|
|
* automatically freed on driver detach.
|
|
|
|
*
|
|
|
|
* If an mii_bus allocated with this function needs to be freed separately,
|
|
|
|
* devm_mdiobus_free() must be used.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
* Pointer to allocated mii_bus on success, NULL on failure.
|
|
|
|
*/
|
|
|
|
struct mii_bus *devm_mdiobus_alloc_size(struct device *dev, int sizeof_priv)
|
|
|
|
{
|
|
|
|
struct mii_bus **ptr, *bus;
|
|
|
|
|
|
|
|
ptr = devres_alloc(_devm_mdiobus_free, sizeof(*ptr), GFP_KERNEL);
|
|
|
|
if (!ptr)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* use raw alloc_dr for kmalloc caller tracing */
|
|
|
|
bus = mdiobus_alloc_size(sizeof_priv);
|
|
|
|
if (bus) {
|
|
|
|
*ptr = bus;
|
|
|
|
devres_add(dev, ptr);
|
|
|
|
} else {
|
|
|
|
devres_free(ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
return bus;
|
|
|
|
}
|
2014-05-08 14:46:52 +00:00
|
|
|
EXPORT_SYMBOL_GPL(devm_mdiobus_alloc_size);
|
2014-04-30 12:23:33 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_mdiobus_free - Resource-managed mdiobus_free()
|
|
|
|
* @dev: Device this mii_bus belongs to
|
|
|
|
* @bus: the mii_bus associated with the device
|
|
|
|
*
|
|
|
|
* Free mii_bus allocated with devm_mdiobus_alloc_size().
|
|
|
|
*/
|
|
|
|
void devm_mdiobus_free(struct device *dev, struct mii_bus *bus)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = devres_release(dev, _devm_mdiobus_free,
|
|
|
|
devm_mdiobus_match, bus);
|
|
|
|
WARN_ON(rc);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_mdiobus_free);
|
|
|
|
|
2008-10-08 23:33:40 +00:00
|
|
|
/**
|
|
|
|
* mdiobus_release - mii_bus device release callback
|
2008-10-14 01:46:22 +00:00
|
|
|
* @d: the target struct device that contains the mii_bus
|
2008-10-08 23:33:40 +00:00
|
|
|
*
|
|
|
|
* Description: called when the last reference to an mii_bus is
|
|
|
|
* dropped, to free the underlying memory.
|
|
|
|
*/
|
|
|
|
static void mdiobus_release(struct device *d)
|
|
|
|
{
|
|
|
|
struct mii_bus *bus = to_mii_bus(d);
|
2008-12-26 00:50:41 +00:00
|
|
|
BUG_ON(bus->state != MDIOBUS_RELEASED &&
|
|
|
|
/* for compatibility with error handling in drivers */
|
|
|
|
bus->state != MDIOBUS_ALLOCATED);
|
2008-10-08 23:33:40 +00:00
|
|
|
kfree(bus);
|
|
|
|
}
|
|
|
|
|
2020-01-16 04:48:50 +00:00
|
|
|
struct mdio_bus_stat_attr {
|
|
|
|
int addr;
|
|
|
|
unsigned int field_offset;
|
|
|
|
};
|
|
|
|
|
|
|
|
static u64 mdio_bus_get_stat(struct mdio_bus_stats *s, unsigned int offset)
|
|
|
|
{
|
|
|
|
const char *p = (const char *)s + offset;
|
|
|
|
unsigned int start;
|
|
|
|
u64 val = 0;
|
|
|
|
|
|
|
|
do {
|
|
|
|
start = u64_stats_fetch_begin(&s->syncp);
|
|
|
|
val = u64_stats_read((const u64_stats_t *)p);
|
|
|
|
} while (u64_stats_fetch_retry(&s->syncp, start));
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u64 mdio_bus_get_global_stat(struct mii_bus *bus, unsigned int offset)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
u64 val = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < PHY_MAX_ADDR; i++)
|
|
|
|
val += mdio_bus_get_stat(&bus->stats[i], offset);
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t mdio_bus_stat_field_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct mii_bus *bus = to_mii_bus(dev);
|
|
|
|
struct mdio_bus_stat_attr *sattr;
|
|
|
|
struct dev_ext_attribute *eattr;
|
|
|
|
u64 val;
|
|
|
|
|
|
|
|
eattr = container_of(attr, struct dev_ext_attribute, attr);
|
|
|
|
sattr = eattr->var;
|
|
|
|
|
|
|
|
if (sattr->addr < 0)
|
|
|
|
val = mdio_bus_get_global_stat(bus, sattr->field_offset);
|
|
|
|
else
|
|
|
|
val = mdio_bus_get_stat(&bus->stats[sattr->addr],
|
|
|
|
sattr->field_offset);
|
|
|
|
|
|
|
|
return sprintf(buf, "%llu\n", val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t mdio_bus_device_stat_field_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct mdio_device *mdiodev = to_mdio_device(dev);
|
|
|
|
struct mii_bus *bus = mdiodev->bus;
|
|
|
|
struct mdio_bus_stat_attr *sattr;
|
|
|
|
struct dev_ext_attribute *eattr;
|
|
|
|
int addr = mdiodev->addr;
|
|
|
|
u64 val;
|
|
|
|
|
|
|
|
eattr = container_of(attr, struct dev_ext_attribute, attr);
|
|
|
|
sattr = eattr->var;
|
|
|
|
|
|
|
|
val = mdio_bus_get_stat(&bus->stats[addr], sattr->field_offset);
|
|
|
|
|
|
|
|
return sprintf(buf, "%llu\n", val);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MDIO_BUS_STATS_ATTR_DECL(field, file) \
|
|
|
|
static struct dev_ext_attribute dev_attr_mdio_bus_##field = { \
|
|
|
|
.attr = { .attr = { .name = file, .mode = 0444 }, \
|
|
|
|
.show = mdio_bus_stat_field_show, \
|
|
|
|
}, \
|
|
|
|
.var = &((struct mdio_bus_stat_attr) { \
|
|
|
|
-1, offsetof(struct mdio_bus_stats, field) \
|
|
|
|
}), \
|
|
|
|
}; \
|
|
|
|
static struct dev_ext_attribute dev_attr_mdio_bus_device_##field = { \
|
|
|
|
.attr = { .attr = { .name = file, .mode = 0444 }, \
|
|
|
|
.show = mdio_bus_device_stat_field_show, \
|
|
|
|
}, \
|
|
|
|
.var = &((struct mdio_bus_stat_attr) { \
|
|
|
|
-1, offsetof(struct mdio_bus_stats, field) \
|
|
|
|
}), \
|
|
|
|
};
|
|
|
|
|
|
|
|
#define MDIO_BUS_STATS_ATTR(field) \
|
|
|
|
MDIO_BUS_STATS_ATTR_DECL(field, __stringify(field))
|
|
|
|
|
|
|
|
MDIO_BUS_STATS_ATTR(transfers);
|
|
|
|
MDIO_BUS_STATS_ATTR(errors);
|
|
|
|
MDIO_BUS_STATS_ATTR(writes);
|
|
|
|
MDIO_BUS_STATS_ATTR(reads);
|
|
|
|
|
|
|
|
#define MDIO_BUS_STATS_ADDR_ATTR_DECL(field, addr, file) \
|
|
|
|
static struct dev_ext_attribute dev_attr_mdio_bus_addr_##field##_##addr = { \
|
|
|
|
.attr = { .attr = { .name = file, .mode = 0444 }, \
|
|
|
|
.show = mdio_bus_stat_field_show, \
|
|
|
|
}, \
|
|
|
|
.var = &((struct mdio_bus_stat_attr) { \
|
|
|
|
addr, offsetof(struct mdio_bus_stats, field) \
|
|
|
|
}), \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MDIO_BUS_STATS_ADDR_ATTR(field, addr) \
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_DECL(field, addr, \
|
|
|
|
__stringify(field) "_" __stringify(addr))
|
|
|
|
|
|
|
|
#define MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(addr) \
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR(transfers, addr); \
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR(errors, addr); \
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR(writes, addr); \
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR(reads, addr) \
|
|
|
|
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(0);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(1);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(2);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(3);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(4);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(5);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(6);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(7);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(8);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(9);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(10);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(11);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(12);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(13);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(14);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(15);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(16);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(17);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(18);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(19);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(20);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(21);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(22);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(23);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(24);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(25);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(26);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(27);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(28);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(29);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(30);
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(31);
|
|
|
|
|
|
|
|
#define MDIO_BUS_STATS_ADDR_ATTR_GROUP(addr) \
|
|
|
|
&dev_attr_mdio_bus_addr_transfers_##addr.attr.attr, \
|
|
|
|
&dev_attr_mdio_bus_addr_errors_##addr.attr.attr, \
|
|
|
|
&dev_attr_mdio_bus_addr_writes_##addr.attr.attr, \
|
|
|
|
&dev_attr_mdio_bus_addr_reads_##addr.attr.attr \
|
|
|
|
|
|
|
|
static struct attribute *mdio_bus_statistics_attrs[] = {
|
|
|
|
&dev_attr_mdio_bus_transfers.attr.attr,
|
|
|
|
&dev_attr_mdio_bus_errors.attr.attr,
|
|
|
|
&dev_attr_mdio_bus_writes.attr.attr,
|
|
|
|
&dev_attr_mdio_bus_reads.attr.attr,
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(0),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(1),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(2),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(3),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(4),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(5),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(6),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(7),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(8),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(9),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(10),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(11),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(12),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(13),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(14),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(15),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(16),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(17),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(18),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(19),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(20),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(21),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(22),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(23),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(24),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(25),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(26),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(27),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(28),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(29),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(30),
|
|
|
|
MDIO_BUS_STATS_ADDR_ATTR_GROUP(31),
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group mdio_bus_statistics_group = {
|
|
|
|
.name = "statistics",
|
|
|
|
.attrs = mdio_bus_statistics_attrs,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group *mdio_bus_groups[] = {
|
|
|
|
&mdio_bus_statistics_group,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2008-10-08 23:33:40 +00:00
|
|
|
static struct class mdio_bus_class = {
|
|
|
|
.name = "mdio_bus",
|
|
|
|
.dev_release = mdiobus_release,
|
2020-01-16 04:48:50 +00:00
|
|
|
.dev_groups = mdio_bus_groups,
|
2008-10-08 23:33:40 +00:00
|
|
|
};
|
|
|
|
|
2020-02-24 22:53:58 +00:00
|
|
|
/**
|
|
|
|
* mdio_find_bus - Given the name of a mdiobus, find the mii_bus.
|
|
|
|
* @mdio_bus_np: Pointer to the mii_bus.
|
|
|
|
*
|
|
|
|
* Returns a reference to the mii_bus, or NULL if none found. The
|
|
|
|
* embedded struct device will have its reference count incremented,
|
|
|
|
* and this must be put_deviced'ed once the bus is finished with.
|
|
|
|
*/
|
|
|
|
struct mii_bus *mdio_find_bus(const char *mdio_name)
|
|
|
|
{
|
|
|
|
struct device *d;
|
|
|
|
|
|
|
|
d = class_find_device_by_name(&mdio_bus_class, mdio_name);
|
|
|
|
return d ? to_mii_bus(d) : NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdio_find_bus);
|
|
|
|
|
2012-05-11 05:47:01 +00:00
|
|
|
#if IS_ENABLED(CONFIG_OF_MDIO)
|
2012-05-02 15:16:37 +00:00
|
|
|
/**
|
|
|
|
* of_mdio_find_bus - Given an mii_bus node, find the mii_bus.
|
2012-06-08 14:07:19 +00:00
|
|
|
* @mdio_bus_np: Pointer to the mii_bus.
|
2012-05-02 15:16:37 +00:00
|
|
|
*
|
2015-09-24 19:35:52 +00:00
|
|
|
* Returns a reference to the mii_bus, or NULL if none found. The
|
|
|
|
* embedded struct device will have its reference count incremented,
|
|
|
|
* and this must be put once the bus is finished with.
|
2012-05-02 15:16:37 +00:00
|
|
|
*
|
|
|
|
* Because the association of a device_node and mii_bus is made via
|
|
|
|
* of_mdiobus_register(), the mii_bus cannot be found before it is
|
|
|
|
* registered with of_mdiobus_register().
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np)
|
|
|
|
{
|
|
|
|
struct device *d;
|
|
|
|
|
|
|
|
if (!mdio_bus_np)
|
|
|
|
return NULL;
|
|
|
|
|
2019-07-23 22:18:33 +00:00
|
|
|
d = class_find_device_by_of_node(&mdio_bus_class, mdio_bus_np);
|
2012-05-02 15:16:37 +00:00
|
|
|
return d ? to_mii_bus(d) : NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_mdio_find_bus);
|
2014-06-27 23:23:35 +00:00
|
|
|
|
2016-01-06 19:11:24 +00:00
|
|
|
/* Walk the list of subnodes of a mdio bus and look for a node that
|
|
|
|
* matches the mdio device's address with its 'reg' property. If
|
|
|
|
* found, set the of_node pointer for the mdio device. This allows
|
|
|
|
* auto-probed phy devices to be supplied with information passed in
|
|
|
|
* via DT.
|
2014-06-27 23:23:35 +00:00
|
|
|
*/
|
2016-01-06 19:11:24 +00:00
|
|
|
static void of_mdiobus_link_mdiodev(struct mii_bus *bus,
|
|
|
|
struct mdio_device *mdiodev)
|
2014-06-27 23:23:35 +00:00
|
|
|
{
|
2016-01-06 19:11:24 +00:00
|
|
|
struct device *dev = &mdiodev->dev;
|
2014-06-27 23:23:35 +00:00
|
|
|
struct device_node *child;
|
|
|
|
|
2016-01-06 19:11:16 +00:00
|
|
|
if (dev->of_node || !bus->dev.of_node)
|
2014-06-27 23:23:35 +00:00
|
|
|
return;
|
|
|
|
|
2016-01-06 19:11:16 +00:00
|
|
|
for_each_available_child_of_node(bus->dev.of_node, child) {
|
2014-06-27 23:23:35 +00:00
|
|
|
int addr;
|
|
|
|
|
2017-05-31 19:43:30 +00:00
|
|
|
addr = of_mdio_parse_addr(dev, child);
|
|
|
|
if (addr < 0)
|
2014-06-27 23:23:35 +00:00
|
|
|
continue;
|
|
|
|
|
2016-01-06 19:11:24 +00:00
|
|
|
if (addr == mdiodev->addr) {
|
2014-06-27 23:23:35 +00:00
|
|
|
dev->of_node = child;
|
2017-12-12 10:49:15 +00:00
|
|
|
dev->fwnode = of_fwnode_handle(child);
|
2014-06-27 23:23:35 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else /* !IS_ENABLED(CONFIG_OF_MDIO) */
|
2016-01-06 19:11:24 +00:00
|
|
|
static inline void of_mdiobus_link_mdiodev(struct mii_bus *mdio,
|
|
|
|
struct mdio_device *mdiodev)
|
2014-06-27 23:23:35 +00:00
|
|
|
{
|
|
|
|
}
|
2012-05-02 15:16:37 +00:00
|
|
|
#endif
|
|
|
|
|
2017-03-28 19:57:09 +00:00
|
|
|
/**
|
|
|
|
* mdiobus_create_device_from_board_info - create a full MDIO device given
|
|
|
|
* a mdio_board_info structure
|
|
|
|
* @bus: MDIO bus to create the devices on
|
|
|
|
* @bi: mdio_board_info structure describing the devices
|
|
|
|
*
|
|
|
|
* Returns 0 on success or < 0 on error.
|
|
|
|
*/
|
|
|
|
static int mdiobus_create_device(struct mii_bus *bus,
|
|
|
|
struct mdio_board_info *bi)
|
|
|
|
{
|
|
|
|
struct mdio_device *mdiodev;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
mdiodev = mdio_device_create(bus, bi->mdio_addr);
|
|
|
|
if (IS_ERR(mdiodev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
strncpy(mdiodev->modalias, bi->modalias,
|
|
|
|
sizeof(mdiodev->modalias));
|
|
|
|
mdiodev->bus_match = mdio_device_bus_match;
|
|
|
|
mdiodev->dev.platform_data = (void *)bi->platform_data;
|
|
|
|
|
|
|
|
ret = mdio_device_register(mdiodev);
|
|
|
|
if (ret)
|
|
|
|
mdio_device_free(mdiodev);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-03-06 10:41:48 +00:00
|
|
|
/**
|
2015-09-25 10:56:56 +00:00
|
|
|
* __mdiobus_register - bring up all the PHYs on a given bus and attach them to bus
|
2007-03-06 10:41:48 +00:00
|
|
|
* @bus: target mii_bus
|
2015-09-25 10:56:56 +00:00
|
|
|
* @owner: module containing bus accessor functions
|
2005-08-24 23:46:21 +00:00
|
|
|
*
|
2007-03-06 10:41:48 +00:00
|
|
|
* Description: Called by a bus driver to bring up all the PHYs
|
2015-09-25 10:56:56 +00:00
|
|
|
* on a given bus, and attach them to the bus. Drivers should use
|
|
|
|
* mdiobus_register() rather than __mdiobus_register() unless they
|
2016-01-06 19:11:25 +00:00
|
|
|
* need to pass a specific owner module. MDIO devices which are not
|
|
|
|
* PHYs will not be brought up by this function. They are expected to
|
|
|
|
* to be explicitly listed in DT and instantiated by of_mdiobus_register().
|
2007-03-06 10:41:48 +00:00
|
|
|
*
|
|
|
|
* Returns 0 on success or < 0 on error.
|
2005-08-24 23:46:21 +00:00
|
|
|
*/
|
2015-09-24 19:36:02 +00:00
|
|
|
int __mdiobus_register(struct mii_bus *bus, struct module *owner)
|
2005-08-24 23:46:21 +00:00
|
|
|
{
|
2016-01-06 19:11:27 +00:00
|
|
|
struct mdio_device *mdiodev;
|
2008-12-26 00:50:41 +00:00
|
|
|
int i, err;
|
2017-04-21 13:15:38 +00:00
|
|
|
struct gpio_desc *gpiod;
|
2005-08-24 23:46:21 +00:00
|
|
|
|
|
|
|
if (NULL == bus || NULL == bus->name ||
|
2014-01-05 00:18:27 +00:00
|
|
|
NULL == bus->read || NULL == bus->write)
|
2005-08-24 23:46:21 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2008-10-08 23:33:40 +00:00
|
|
|
BUG_ON(bus->state != MDIOBUS_ALLOCATED &&
|
|
|
|
bus->state != MDIOBUS_UNREGISTERED);
|
|
|
|
|
2015-09-24 19:36:02 +00:00
|
|
|
bus->owner = owner;
|
2008-10-08 23:33:40 +00:00
|
|
|
bus->dev.parent = bus->parent;
|
|
|
|
bus->dev.class = &mdio_bus_class;
|
|
|
|
bus->dev.groups = NULL;
|
2009-02-26 10:19:36 +00:00
|
|
|
dev_set_name(&bus->dev, "%s", bus->id);
|
2008-10-08 23:33:40 +00:00
|
|
|
|
|
|
|
err = device_register(&bus->dev);
|
|
|
|
if (err) {
|
2012-06-09 07:49:07 +00:00
|
|
|
pr_err("mii_bus %s failed to register\n", bus->id);
|
2008-10-08 23:33:40 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-02-20 00:13:53 +00:00
|
|
|
mutex_init(&bus->mdio_lock);
|
|
|
|
|
2017-06-12 20:55:38 +00:00
|
|
|
/* de-assert bus level PHY GPIO reset */
|
2017-06-12 20:55:39 +00:00
|
|
|
gpiod = devm_gpiod_get_optional(&bus->dev, "reset", GPIOD_OUT_LOW);
|
2017-06-12 20:55:38 +00:00
|
|
|
if (IS_ERR(gpiod)) {
|
2017-06-12 20:55:39 +00:00
|
|
|
dev_err(&bus->dev, "mii_bus %s couldn't get reset GPIO\n",
|
|
|
|
bus->id);
|
2019-01-16 09:53:58 +00:00
|
|
|
device_del(&bus->dev);
|
2017-06-12 20:55:39 +00:00
|
|
|
return PTR_ERR(gpiod);
|
|
|
|
} else if (gpiod) {
|
2017-06-12 20:55:38 +00:00
|
|
|
bus->reset_gpiod = gpiod;
|
|
|
|
|
|
|
|
gpiod_set_value_cansleep(gpiod, 1);
|
|
|
|
udelay(bus->reset_delay_us);
|
|
|
|
gpiod_set_value_cansleep(gpiod, 0);
|
2017-04-21 13:15:38 +00:00
|
|
|
}
|
|
|
|
|
2017-05-11 18:24:16 +00:00
|
|
|
if (bus->reset)
|
|
|
|
bus->reset(bus);
|
|
|
|
|
2005-08-24 23:46:21 +00:00
|
|
|
for (i = 0; i < PHY_MAX_ADDR; i++) {
|
2008-08-26 11:08:46 +00:00
|
|
|
if ((bus->phy_mask & (1 << i)) == 0) {
|
|
|
|
struct phy_device *phydev;
|
2005-08-24 23:46:21 +00:00
|
|
|
|
2008-08-26 11:08:46 +00:00
|
|
|
phydev = mdiobus_scan(bus, i);
|
2016-05-02 00:47:31 +00:00
|
|
|
if (IS_ERR(phydev) && (PTR_ERR(phydev) != -ENODEV)) {
|
2008-08-26 11:08:46 +00:00
|
|
|
err = PTR_ERR(phydev);
|
2008-12-26 00:50:41 +00:00
|
|
|
goto error;
|
|
|
|
}
|
2006-05-10 16:12:57 +00:00
|
|
|
}
|
2005-08-24 23:46:21 +00:00
|
|
|
}
|
|
|
|
|
2017-03-28 19:57:09 +00:00
|
|
|
mdiobus_setup_mdiodev_from_board_info(bus, mdiobus_create_device);
|
2017-02-04 21:02:44 +00:00
|
|
|
|
2008-12-26 00:50:41 +00:00
|
|
|
bus->state = MDIOBUS_REGISTERED;
|
2005-08-24 23:46:21 +00:00
|
|
|
pr_info("%s: probed\n", bus->name);
|
2008-12-26 00:50:41 +00:00
|
|
|
return 0;
|
2005-08-24 23:46:21 +00:00
|
|
|
|
2008-12-26 00:50:41 +00:00
|
|
|
error:
|
|
|
|
while (--i >= 0) {
|
2016-01-06 19:11:27 +00:00
|
|
|
mdiodev = bus->mdio_map[i];
|
|
|
|
if (!mdiodev)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
mdiodev->device_remove(mdiodev);
|
|
|
|
mdiodev->device_free(mdiodev);
|
2008-12-26 00:50:41 +00:00
|
|
|
}
|
2017-04-21 13:15:38 +00:00
|
|
|
|
|
|
|
/* Put PHYs in RESET to save power */
|
2017-09-08 22:38:07 +00:00
|
|
|
if (bus->reset_gpiod)
|
|
|
|
gpiod_set_value_cansleep(bus->reset_gpiod, 1);
|
2017-04-21 13:15:38 +00:00
|
|
|
|
2008-12-26 00:50:41 +00:00
|
|
|
device_del(&bus->dev);
|
2005-08-24 23:46:21 +00:00
|
|
|
return err;
|
|
|
|
}
|
2015-09-24 19:36:02 +00:00
|
|
|
EXPORT_SYMBOL(__mdiobus_register);
|
2005-08-24 23:46:21 +00:00
|
|
|
|
|
|
|
void mdiobus_unregister(struct mii_bus *bus)
|
|
|
|
{
|
2016-01-06 19:11:26 +00:00
|
|
|
struct mdio_device *mdiodev;
|
2005-08-24 23:46:21 +00:00
|
|
|
int i;
|
|
|
|
|
2008-10-08 23:33:40 +00:00
|
|
|
BUG_ON(bus->state != MDIOBUS_REGISTERED);
|
|
|
|
bus->state = MDIOBUS_UNREGISTERED;
|
|
|
|
|
2005-08-24 23:46:21 +00:00
|
|
|
for (i = 0; i < PHY_MAX_ADDR; i++) {
|
2016-01-06 19:11:26 +00:00
|
|
|
mdiodev = bus->mdio_map[i];
|
|
|
|
if (!mdiodev)
|
|
|
|
continue;
|
|
|
|
|
2019-04-17 21:59:22 +00:00
|
|
|
if (mdiodev->reset_gpio)
|
|
|
|
gpiod_put(mdiodev->reset_gpio);
|
2017-12-04 12:35:05 +00:00
|
|
|
|
2016-01-06 19:11:27 +00:00
|
|
|
mdiodev->device_remove(mdiodev);
|
|
|
|
mdiodev->device_free(mdiodev);
|
2005-08-24 23:46:21 +00:00
|
|
|
}
|
2017-04-21 13:15:38 +00:00
|
|
|
|
|
|
|
/* Put PHYs in RESET to save power */
|
2017-09-08 22:38:07 +00:00
|
|
|
if (bus->reset_gpiod)
|
|
|
|
gpiod_set_value_cansleep(bus->reset_gpiod, 1);
|
2017-04-21 13:15:38 +00:00
|
|
|
|
2015-09-01 13:36:05 +00:00
|
|
|
device_del(&bus->dev);
|
2005-08-24 23:46:21 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdiobus_unregister);
|
|
|
|
|
2008-10-08 23:29:57 +00:00
|
|
|
/**
|
|
|
|
* mdiobus_free - free a struct mii_bus
|
|
|
|
* @bus: mii_bus to free
|
|
|
|
*
|
2008-10-08 23:33:40 +00:00
|
|
|
* This function releases the reference to the underlying device
|
|
|
|
* object in the mii_bus. If this is the last reference, the mii_bus
|
|
|
|
* will be freed.
|
2008-10-08 23:29:57 +00:00
|
|
|
*/
|
|
|
|
void mdiobus_free(struct mii_bus *bus)
|
|
|
|
{
|
2014-01-05 00:18:27 +00:00
|
|
|
/* For compatibility with error handling in drivers. */
|
2008-10-08 23:33:40 +00:00
|
|
|
if (bus->state == MDIOBUS_ALLOCATED) {
|
|
|
|
kfree(bus);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
BUG_ON(bus->state != MDIOBUS_UNREGISTERED);
|
|
|
|
bus->state = MDIOBUS_RELEASED;
|
|
|
|
|
|
|
|
put_device(&bus->dev);
|
2008-10-08 23:29:57 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdiobus_free);
|
|
|
|
|
2016-01-06 19:11:25 +00:00
|
|
|
/**
|
|
|
|
* mdiobus_scan - scan a bus for MDIO devices.
|
|
|
|
* @bus: mii_bus to scan
|
|
|
|
* @addr: address on bus to scan
|
|
|
|
*
|
|
|
|
* This function scans the MDIO bus, looking for devices which can be
|
|
|
|
* identified using a vendor/product ID in registers 2 and 3. Not all
|
|
|
|
* MDIO devices have such registers, but PHY devices typically
|
|
|
|
* do. Hence this function assumes anything found is a PHY, or can be
|
|
|
|
* treated as a PHY. Other MDIO devices, such as switches, will
|
|
|
|
* probably not be found during the scan.
|
|
|
|
*/
|
2008-08-26 11:08:46 +00:00
|
|
|
struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev;
|
|
|
|
int err;
|
|
|
|
|
2012-06-27 07:33:35 +00:00
|
|
|
phydev = get_phy_device(bus, addr, false);
|
2016-04-24 17:30:53 +00:00
|
|
|
if (IS_ERR(phydev))
|
2008-08-26 11:08:46 +00:00
|
|
|
return phydev;
|
|
|
|
|
2014-05-24 07:34:26 +00:00
|
|
|
/*
|
|
|
|
* For DT, see if the auto-probed phy has a correspoding child
|
|
|
|
* in the bus node, and set the of_node pointer in this case.
|
|
|
|
*/
|
2016-01-06 19:11:24 +00:00
|
|
|
of_mdiobus_link_mdiodev(bus, &phydev->mdio);
|
2014-05-24 07:34:26 +00:00
|
|
|
|
2009-04-25 12:52:46 +00:00
|
|
|
err = phy_device_register(phydev);
|
2008-08-26 11:08:46 +00:00
|
|
|
if (err) {
|
|
|
|
phy_device_free(phydev);
|
2016-05-03 20:14:41 +00:00
|
|
|
return ERR_PTR(-ENODEV);
|
2008-08-26 11:08:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return phydev;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdiobus_scan);
|
|
|
|
|
2020-01-16 04:48:50 +00:00
|
|
|
static void mdiobus_stats_acct(struct mdio_bus_stats *stats, bool op, int ret)
|
|
|
|
{
|
|
|
|
u64_stats_update_begin(&stats->syncp);
|
|
|
|
|
|
|
|
u64_stats_inc(&stats->transfers);
|
|
|
|
if (ret < 0) {
|
|
|
|
u64_stats_inc(&stats->errors);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (op)
|
|
|
|
u64_stats_inc(&stats->reads);
|
|
|
|
else
|
|
|
|
u64_stats_inc(&stats->writes);
|
|
|
|
out:
|
|
|
|
u64_stats_update_end(&stats->syncp);
|
|
|
|
}
|
|
|
|
|
2018-01-02 10:58:27 +00:00
|
|
|
/**
|
|
|
|
* __mdiobus_read - Unlocked version of the mdiobus_read function
|
|
|
|
* @bus: the mii_bus struct
|
|
|
|
* @addr: the phy address
|
|
|
|
* @regnum: register number to read
|
|
|
|
*
|
|
|
|
* Read a MDIO bus register. Caller must hold the mdio bus lock.
|
|
|
|
*
|
|
|
|
* NOTE: MUST NOT be called from interrupt context.
|
|
|
|
*/
|
|
|
|
int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
WARN_ON_ONCE(!mutex_is_locked(&bus->mdio_lock));
|
|
|
|
|
|
|
|
retval = bus->read(bus, addr, regnum);
|
|
|
|
|
|
|
|
trace_mdio_access(bus, 1, addr, regnum, retval, retval);
|
2020-01-16 04:48:50 +00:00
|
|
|
mdiobus_stats_acct(&bus->stats[addr], true, retval);
|
2018-01-02 10:58:27 +00:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__mdiobus_read);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __mdiobus_write - Unlocked version of the mdiobus_write function
|
|
|
|
* @bus: the mii_bus struct
|
|
|
|
* @addr: the phy address
|
|
|
|
* @regnum: register number to write
|
|
|
|
* @val: value to write to @regnum
|
|
|
|
*
|
|
|
|
* Write a MDIO bus register. Caller must hold the mdio bus lock.
|
|
|
|
*
|
|
|
|
* NOTE: MUST NOT be called from interrupt context.
|
|
|
|
*/
|
|
|
|
int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
WARN_ON_ONCE(!mutex_is_locked(&bus->mdio_lock));
|
|
|
|
|
|
|
|
err = bus->write(bus, addr, regnum, val);
|
|
|
|
|
|
|
|
trace_mdio_access(bus, 0, addr, regnum, val, err);
|
2020-01-16 04:48:50 +00:00
|
|
|
mdiobus_stats_acct(&bus->stats[addr], false, err);
|
2018-01-02 10:58:27 +00:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__mdiobus_write);
|
|
|
|
|
2015-10-22 08:37:49 +00:00
|
|
|
/**
|
|
|
|
* mdiobus_read_nested - Nested version of the mdiobus_read function
|
|
|
|
* @bus: the mii_bus struct
|
|
|
|
* @addr: the phy address
|
|
|
|
* @regnum: register number to read
|
|
|
|
*
|
|
|
|
* In case of nested MDIO bus access avoid lockdep false positives by
|
|
|
|
* using mutex_lock_nested().
|
|
|
|
*
|
|
|
|
* NOTE: MUST NOT be called from interrupt context,
|
|
|
|
* because the bus read/write functions may wait for an interrupt
|
|
|
|
* to conclude the operation.
|
|
|
|
*/
|
|
|
|
int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
2020-03-17 14:52:26 +00:00
|
|
|
if (WARN_ON_ONCE(in_interrupt()))
|
|
|
|
return -EINVAL;
|
2015-10-22 08:37:49 +00:00
|
|
|
|
2016-04-11 19:40:05 +00:00
|
|
|
mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
|
2018-01-02 10:58:27 +00:00
|
|
|
retval = __mdiobus_read(bus, addr, regnum);
|
2015-10-22 08:37:49 +00:00
|
|
|
mutex_unlock(&bus->mdio_lock);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdiobus_read_nested);
|
|
|
|
|
2008-09-29 17:12:35 +00:00
|
|
|
/**
|
|
|
|
* mdiobus_read - Convenience function for reading a given MII mgmt register
|
|
|
|
* @bus: the mii_bus struct
|
|
|
|
* @addr: the phy address
|
|
|
|
* @regnum: register number to read
|
|
|
|
*
|
|
|
|
* NOTE: MUST NOT be called from interrupt context,
|
|
|
|
* because the bus read/write functions may wait for an interrupt
|
|
|
|
* to conclude the operation.
|
|
|
|
*/
|
2010-03-09 09:17:42 +00:00
|
|
|
int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
|
2008-09-29 17:12:35 +00:00
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
2020-03-17 14:52:26 +00:00
|
|
|
if (WARN_ON_ONCE(in_interrupt()))
|
|
|
|
return -EINVAL;
|
2008-09-29 17:12:35 +00:00
|
|
|
|
|
|
|
mutex_lock(&bus->mdio_lock);
|
2018-01-02 10:58:27 +00:00
|
|
|
retval = __mdiobus_read(bus, addr, regnum);
|
2008-09-29 17:12:35 +00:00
|
|
|
mutex_unlock(&bus->mdio_lock);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdiobus_read);
|
|
|
|
|
2015-10-22 08:37:49 +00:00
|
|
|
/**
|
|
|
|
* mdiobus_write_nested - Nested version of the mdiobus_write function
|
|
|
|
* @bus: the mii_bus struct
|
|
|
|
* @addr: the phy address
|
|
|
|
* @regnum: register number to write
|
|
|
|
* @val: value to write to @regnum
|
|
|
|
*
|
|
|
|
* In case of nested MDIO bus access avoid lockdep false positives by
|
|
|
|
* using mutex_lock_nested().
|
|
|
|
*
|
|
|
|
* NOTE: MUST NOT be called from interrupt context,
|
|
|
|
* because the bus read/write functions may wait for an interrupt
|
|
|
|
* to conclude the operation.
|
|
|
|
*/
|
|
|
|
int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2020-03-17 14:52:26 +00:00
|
|
|
if (WARN_ON_ONCE(in_interrupt()))
|
|
|
|
return -EINVAL;
|
2015-10-22 08:37:49 +00:00
|
|
|
|
2016-04-11 19:40:05 +00:00
|
|
|
mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
|
2018-01-02 10:58:27 +00:00
|
|
|
err = __mdiobus_write(bus, addr, regnum, val);
|
2015-10-22 08:37:49 +00:00
|
|
|
mutex_unlock(&bus->mdio_lock);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdiobus_write_nested);
|
|
|
|
|
2008-09-29 17:12:35 +00:00
|
|
|
/**
|
|
|
|
* mdiobus_write - Convenience function for writing a given MII mgmt register
|
|
|
|
* @bus: the mii_bus struct
|
|
|
|
* @addr: the phy address
|
|
|
|
* @regnum: register number to write
|
|
|
|
* @val: value to write to @regnum
|
|
|
|
*
|
|
|
|
* NOTE: MUST NOT be called from interrupt context,
|
|
|
|
* because the bus read/write functions may wait for an interrupt
|
|
|
|
* to conclude the operation.
|
|
|
|
*/
|
2010-03-09 09:17:42 +00:00
|
|
|
int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
|
2008-09-29 17:12:35 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2020-03-17 14:52:26 +00:00
|
|
|
if (WARN_ON_ONCE(in_interrupt()))
|
|
|
|
return -EINVAL;
|
2008-09-29 17:12:35 +00:00
|
|
|
|
|
|
|
mutex_lock(&bus->mdio_lock);
|
2018-01-02 10:58:27 +00:00
|
|
|
err = __mdiobus_write(bus, addr, regnum, val);
|
2008-09-29 17:12:35 +00:00
|
|
|
mutex_unlock(&bus->mdio_lock);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdiobus_write);
|
|
|
|
|
2007-03-06 10:41:48 +00:00
|
|
|
/**
|
2016-01-06 19:11:23 +00:00
|
|
|
* mdio_bus_match - determine if given MDIO driver supports the given
|
|
|
|
* MDIO device
|
|
|
|
* @dev: target MDIO device
|
|
|
|
* @drv: given MDIO driver
|
2005-07-30 23:31:23 +00:00
|
|
|
*
|
2016-01-06 19:11:23 +00:00
|
|
|
* Description: Given a MDIO device, and a MDIO driver, return 1 if
|
|
|
|
* the driver supports the device. Otherwise, return 0. This may
|
|
|
|
* require calling the devices own match function, since different classes
|
|
|
|
* of MDIO devices have different match criteria.
|
2005-07-30 23:31:23 +00:00
|
|
|
*/
|
|
|
|
static int mdio_bus_match(struct device *dev, struct device_driver *drv)
|
|
|
|
{
|
2016-01-06 19:11:23 +00:00
|
|
|
struct mdio_device *mdio = to_mdio_device(dev);
|
2005-07-30 23:31:23 +00:00
|
|
|
|
2012-06-27 07:33:37 +00:00
|
|
|
if (of_driver_match_device(dev, drv))
|
|
|
|
return 1;
|
|
|
|
|
2016-01-06 19:11:23 +00:00
|
|
|
if (mdio->bus_match)
|
|
|
|
return mdio->bus_match(dev, drv);
|
2012-06-27 07:33:37 +00:00
|
|
|
|
2016-01-06 19:11:23 +00:00
|
|
|
return 0;
|
2005-07-30 23:31:23 +00:00
|
|
|
}
|
|
|
|
|
net: fix auto-loading of Marvell DSA driver
Auto-loading of the Marvell DSA driver has stopped working with recent
kernels. This seems to be due to the change of binding for DSA devices,
moving them from the platform bus to the MDIO bus.
In order for module auto-loading to work, we need to provide a MODALIAS
string in the uevent file for the device. However, the device core does
not automatically provide this, and needs each bus_type to implement a
uevent method to generate these strings. The MDIO bus does not provide
such a method, so no MODALIAS string is provided:
.# cat /sys/bus/mdio_bus/devices/f1072004.mdio-mii\:04/uevent
DRIVER=mv88e6085
OF_NAME=switch
OF_FULLNAME=/soc/internal-regs/mdio@72004/switch@4
OF_COMPATIBLE_0=marvell,mv88e6085
OF_COMPATIBLE_N=1
In the case of OF-based devices, the solution is easy -
of_device_uevent_modalias() does the work for us. After this is done,
the uevent file looks like this:
.# cat /sys/bus/mdio_bus/devices/f1072004.mdio-mii\:04/uevent
DRIVER=mv88e6085
OF_NAME=switch
OF_FULLNAME=/soc/internal-regs/mdio@72004/switch@4
OF_COMPATIBLE_0=marvell,mv88e6085
OF_COMPATIBLE_N=1
MODALIAS=of:NswitchT<NULL>Cmarvell,mv88e6085
which results in auto-loading of the Marvell DSA driver on Clearfog
platforms.
Fixes: c0405563a613 ("ARM: dts: armada-388-clearfog: Utilize new DSA binding")
Signed-off-by: Russell King <rmk+kernel@armlinux.org.uk>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-30 20:38:18 +00:00
|
|
|
static int mdio_uevent(struct device *dev, struct kobj_uevent_env *env)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
/* Some devices have extra OF data and an OF-style MODALIAS */
|
|
|
|
rc = of_device_uevent_modalias(dev, env);
|
|
|
|
if (rc != -ENODEV)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-01-16 04:48:50 +00:00
|
|
|
static struct attribute *mdio_bus_device_statistics_attrs[] = {
|
|
|
|
&dev_attr_mdio_bus_device_transfers.attr.attr,
|
|
|
|
&dev_attr_mdio_bus_device_errors.attr.attr,
|
|
|
|
&dev_attr_mdio_bus_device_writes.attr.attr,
|
|
|
|
&dev_attr_mdio_bus_device_reads.attr.attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group mdio_bus_device_statistics_group = {
|
|
|
|
.name = "statistics",
|
|
|
|
.attrs = mdio_bus_device_statistics_attrs,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group *mdio_bus_dev_groups[] = {
|
|
|
|
&mdio_bus_device_statistics_group,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2005-07-30 23:31:23 +00:00
|
|
|
struct bus_type mdio_bus_type = {
|
|
|
|
.name = "mdio_bus",
|
2020-01-16 04:48:50 +00:00
|
|
|
.dev_groups = mdio_bus_dev_groups,
|
2005-07-30 23:31:23 +00:00
|
|
|
.match = mdio_bus_match,
|
net: fix auto-loading of Marvell DSA driver
Auto-loading of the Marvell DSA driver has stopped working with recent
kernels. This seems to be due to the change of binding for DSA devices,
moving them from the platform bus to the MDIO bus.
In order for module auto-loading to work, we need to provide a MODALIAS
string in the uevent file for the device. However, the device core does
not automatically provide this, and needs each bus_type to implement a
uevent method to generate these strings. The MDIO bus does not provide
such a method, so no MODALIAS string is provided:
.# cat /sys/bus/mdio_bus/devices/f1072004.mdio-mii\:04/uevent
DRIVER=mv88e6085
OF_NAME=switch
OF_FULLNAME=/soc/internal-regs/mdio@72004/switch@4
OF_COMPATIBLE_0=marvell,mv88e6085
OF_COMPATIBLE_N=1
In the case of OF-based devices, the solution is easy -
of_device_uevent_modalias() does the work for us. After this is done,
the uevent file looks like this:
.# cat /sys/bus/mdio_bus/devices/f1072004.mdio-mii\:04/uevent
DRIVER=mv88e6085
OF_NAME=switch
OF_FULLNAME=/soc/internal-regs/mdio@72004/switch@4
OF_COMPATIBLE_0=marvell,mv88e6085
OF_COMPATIBLE_N=1
MODALIAS=of:NswitchT<NULL>Cmarvell,mv88e6085
which results in auto-loading of the Marvell DSA driver on Clearfog
platforms.
Fixes: c0405563a613 ("ARM: dts: armada-388-clearfog: Utilize new DSA binding")
Signed-off-by: Russell King <rmk+kernel@armlinux.org.uk>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-30 20:38:18 +00:00
|
|
|
.uevent = mdio_uevent,
|
2005-07-30 23:31:23 +00:00
|
|
|
};
|
2006-08-15 06:00:29 +00:00
|
|
|
EXPORT_SYMBOL(mdio_bus_type);
|
2005-07-30 23:31:23 +00:00
|
|
|
|
2005-08-11 06:07:25 +00:00
|
|
|
int __init mdio_bus_init(void)
|
2005-07-30 23:31:23 +00:00
|
|
|
{
|
2008-10-08 23:33:40 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = class_register(&mdio_bus_class);
|
|
|
|
if (!ret) {
|
|
|
|
ret = bus_register(&mdio_bus_type);
|
|
|
|
if (ret)
|
|
|
|
class_unregister(&mdio_bus_class);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2005-07-30 23:31:23 +00:00
|
|
|
}
|
2017-03-23 17:01:19 +00:00
|
|
|
EXPORT_SYMBOL_GPL(mdio_bus_init);
|
2005-07-30 23:31:23 +00:00
|
|
|
|
2017-03-23 17:01:19 +00:00
|
|
|
#if IS_ENABLED(CONFIG_PHYLIB)
|
2005-09-03 21:05:06 +00:00
|
|
|
void mdio_bus_exit(void)
|
2005-08-24 23:46:21 +00:00
|
|
|
{
|
2008-10-08 23:33:40 +00:00
|
|
|
class_unregister(&mdio_bus_class);
|
2005-08-24 23:46:21 +00:00
|
|
|
bus_unregister(&mdio_bus_type);
|
|
|
|
}
|
2017-03-23 17:01:19 +00:00
|
|
|
EXPORT_SYMBOL_GPL(mdio_bus_exit);
|
|
|
|
#else
|
|
|
|
module_init(mdio_bus_init);
|
|
|
|
/* no module_exit, intentional */
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_DESCRIPTION("MDIO bus/device layer");
|
|
|
|
#endif
|