2010-04-29 14:12:41 +08:00
|
|
|
/*
|
|
|
|
* drivers/net/phy/micrel.c
|
|
|
|
*
|
|
|
|
* Driver for Micrel PHYs
|
|
|
|
*
|
|
|
|
* Author: David J. Choi
|
|
|
|
*
|
2013-01-23 22:05:15 +08:00
|
|
|
* Copyright (c) 2010-2013 Micrel, Inc.
|
2014-11-19 19:59:23 +08:00
|
|
|
* Copyright (c) 2014 Johan Hovold <johan@kernel.org>
|
2010-04-29 14:12:41 +08:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of the GNU General Public License as published by the
|
|
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
|
|
* option) any later version.
|
|
|
|
*
|
2013-01-23 22:05:15 +08:00
|
|
|
* Support : Micrel Phys:
|
|
|
|
* Giga phys: ksz9021, ksz9031
|
|
|
|
* 100/10 Phys : ksz8001, ksz8721, ksz8737, ksz8041
|
|
|
|
* ksz8021, ksz8031, ksz8051,
|
|
|
|
* ksz8081, ksz8091,
|
|
|
|
* ksz8061,
|
|
|
|
* Switch : ksz8873, ksz886x
|
2017-06-01 04:19:13 +08:00
|
|
|
* ksz9477
|
2010-04-29 14:12:41 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/phy.h>
|
2011-02-14 10:05:33 +08:00
|
|
|
#include <linux/micrel_phy.h>
|
2013-08-21 09:46:12 +08:00
|
|
|
#include <linux/of.h>
|
2014-10-10 15:48:05 +08:00
|
|
|
#include <linux/clk.h>
|
2010-04-29 14:12:41 +08:00
|
|
|
|
2012-09-24 00:58:49 +08:00
|
|
|
/* Operation Mode Strap Override */
|
|
|
|
#define MII_KSZPHY_OMSO 0x16
|
2014-11-12 03:00:09 +08:00
|
|
|
#define KSZPHY_OMSO_B_CAST_OFF BIT(9)
|
2015-02-14 04:35:33 +08:00
|
|
|
#define KSZPHY_OMSO_NAND_TREE_ON BIT(5)
|
2014-11-12 03:00:09 +08:00
|
|
|
#define KSZPHY_OMSO_RMII_OVERRIDE BIT(1)
|
|
|
|
#define KSZPHY_OMSO_MII_OVERRIDE BIT(0)
|
2012-09-24 00:58:49 +08:00
|
|
|
|
2010-06-28 23:23:41 +08:00
|
|
|
/* general Interrupt control/status reg in vendor specific block. */
|
|
|
|
#define MII_KSZPHY_INTCS 0x1B
|
2014-11-12 03:00:09 +08:00
|
|
|
#define KSZPHY_INTCS_JABBER BIT(15)
|
|
|
|
#define KSZPHY_INTCS_RECEIVE_ERR BIT(14)
|
|
|
|
#define KSZPHY_INTCS_PAGE_RECEIVE BIT(13)
|
|
|
|
#define KSZPHY_INTCS_PARELLEL BIT(12)
|
|
|
|
#define KSZPHY_INTCS_LINK_PARTNER_ACK BIT(11)
|
|
|
|
#define KSZPHY_INTCS_LINK_DOWN BIT(10)
|
|
|
|
#define KSZPHY_INTCS_REMOTE_FAULT BIT(9)
|
|
|
|
#define KSZPHY_INTCS_LINK_UP BIT(8)
|
2010-06-28 23:23:41 +08:00
|
|
|
#define KSZPHY_INTCS_ALL (KSZPHY_INTCS_LINK_UP |\
|
|
|
|
KSZPHY_INTCS_LINK_DOWN)
|
|
|
|
|
2014-11-12 03:00:14 +08:00
|
|
|
/* PHY Control 1 */
|
|
|
|
#define MII_KSZPHY_CTRL_1 0x1e
|
|
|
|
|
|
|
|
/* PHY Control 2 / PHY Control (if no PHY Control 1) */
|
|
|
|
#define MII_KSZPHY_CTRL_2 0x1f
|
|
|
|
#define MII_KSZPHY_CTRL MII_KSZPHY_CTRL_2
|
2010-06-28 23:23:41 +08:00
|
|
|
/* bitmap of PHY register to set interrupt mode */
|
2014-11-12 03:00:09 +08:00
|
|
|
#define KSZPHY_CTRL_INT_ACTIVE_HIGH BIT(9)
|
2014-11-19 19:59:18 +08:00
|
|
|
#define KSZPHY_RMII_REF_CLK_SEL BIT(7)
|
2010-06-28 23:23:41 +08:00
|
|
|
|
2013-08-21 09:46:12 +08:00
|
|
|
/* Write/read to/from extended registers */
|
|
|
|
#define MII_KSZPHY_EXTREG 0x0b
|
|
|
|
#define KSZPHY_EXTREG_WRITE 0x8000
|
|
|
|
|
|
|
|
#define MII_KSZPHY_EXTREG_WRITE 0x0c
|
|
|
|
#define MII_KSZPHY_EXTREG_READ 0x0d
|
|
|
|
|
|
|
|
/* Extended registers */
|
|
|
|
#define MII_KSZPHY_CLK_CONTROL_PAD_SKEW 0x104
|
|
|
|
#define MII_KSZPHY_RX_DATA_PAD_SKEW 0x105
|
|
|
|
#define MII_KSZPHY_TX_DATA_PAD_SKEW 0x106
|
|
|
|
|
|
|
|
#define PS_TO_REG 200
|
|
|
|
|
2015-12-30 23:28:27 +08:00
|
|
|
struct kszphy_hw_stat {
|
|
|
|
const char *string;
|
|
|
|
u8 reg;
|
|
|
|
u8 bits;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct kszphy_hw_stat kszphy_hw_stats[] = {
|
|
|
|
{ "phy_receive_errors", 21, 16},
|
|
|
|
{ "phy_idle_errors", 10, 8 },
|
|
|
|
};
|
|
|
|
|
2014-11-19 19:59:15 +08:00
|
|
|
struct kszphy_type {
|
|
|
|
u32 led_mode_reg;
|
2014-11-19 19:59:22 +08:00
|
|
|
u16 interrupt_level_mask;
|
2014-11-19 19:59:17 +08:00
|
|
|
bool has_broadcast_disable;
|
2015-02-14 04:35:33 +08:00
|
|
|
bool has_nand_tree_disable;
|
2014-11-19 19:59:18 +08:00
|
|
|
bool has_rmii_ref_clk_sel;
|
2014-11-19 19:59:15 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct kszphy_priv {
|
|
|
|
const struct kszphy_type *type;
|
2014-11-19 19:59:16 +08:00
|
|
|
int led_mode;
|
2014-11-19 19:59:18 +08:00
|
|
|
bool rmii_ref_clk_sel;
|
|
|
|
bool rmii_ref_clk_sel_val;
|
2015-12-30 23:28:27 +08:00
|
|
|
u64 stats[ARRAY_SIZE(kszphy_hw_stats)];
|
2014-11-19 19:59:15 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct kszphy_type ksz8021_type = {
|
|
|
|
.led_mode_reg = MII_KSZPHY_CTRL_2,
|
2014-12-23 19:59:17 +08:00
|
|
|
.has_broadcast_disable = true,
|
2015-02-14 04:35:33 +08:00
|
|
|
.has_nand_tree_disable = true,
|
2014-11-19 19:59:18 +08:00
|
|
|
.has_rmii_ref_clk_sel = true,
|
2014-11-19 19:59:15 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct kszphy_type ksz8041_type = {
|
|
|
|
.led_mode_reg = MII_KSZPHY_CTRL_1,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct kszphy_type ksz8051_type = {
|
|
|
|
.led_mode_reg = MII_KSZPHY_CTRL_2,
|
2015-02-14 04:35:33 +08:00
|
|
|
.has_nand_tree_disable = true,
|
2014-11-19 19:59:15 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct kszphy_type ksz8081_type = {
|
|
|
|
.led_mode_reg = MII_KSZPHY_CTRL_2,
|
2014-11-19 19:59:17 +08:00
|
|
|
.has_broadcast_disable = true,
|
2015-02-14 04:35:33 +08:00
|
|
|
.has_nand_tree_disable = true,
|
2014-11-19 19:59:19 +08:00
|
|
|
.has_rmii_ref_clk_sel = true,
|
2014-11-19 19:59:15 +08:00
|
|
|
};
|
|
|
|
|
2014-11-19 19:59:22 +08:00
|
|
|
static const struct kszphy_type ks8737_type = {
|
|
|
|
.interrupt_level_mask = BIT(14),
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct kszphy_type ksz9021_type = {
|
|
|
|
.interrupt_level_mask = BIT(14),
|
|
|
|
};
|
|
|
|
|
2013-08-21 09:46:12 +08:00
|
|
|
static int kszphy_extended_write(struct phy_device *phydev,
|
2013-12-18 13:38:11 +08:00
|
|
|
u32 regnum, u16 val)
|
2013-08-21 09:46:12 +08:00
|
|
|
{
|
|
|
|
phy_write(phydev, MII_KSZPHY_EXTREG, KSZPHY_EXTREG_WRITE | regnum);
|
|
|
|
return phy_write(phydev, MII_KSZPHY_EXTREG_WRITE, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int kszphy_extended_read(struct phy_device *phydev,
|
2013-12-18 13:38:11 +08:00
|
|
|
u32 regnum)
|
2013-08-21 09:46:12 +08:00
|
|
|
{
|
|
|
|
phy_write(phydev, MII_KSZPHY_EXTREG, regnum);
|
|
|
|
return phy_read(phydev, MII_KSZPHY_EXTREG_READ);
|
|
|
|
}
|
|
|
|
|
2010-06-28 23:23:41 +08:00
|
|
|
static int kszphy_ack_interrupt(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
/* bit[7..0] int status, which is a read and clear register. */
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = phy_read(phydev, MII_KSZPHY_INTCS);
|
|
|
|
|
|
|
|
return (rc < 0) ? rc : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int kszphy_config_intr(struct phy_device *phydev)
|
|
|
|
{
|
2014-11-19 19:59:22 +08:00
|
|
|
const struct kszphy_type *type = phydev->drv->driver_data;
|
|
|
|
int temp;
|
|
|
|
u16 mask;
|
2010-06-28 23:23:41 +08:00
|
|
|
|
2014-11-19 19:59:22 +08:00
|
|
|
if (type && type->interrupt_level_mask)
|
|
|
|
mask = type->interrupt_level_mask;
|
|
|
|
else
|
|
|
|
mask = KSZPHY_CTRL_INT_ACTIVE_HIGH;
|
2010-06-28 23:23:41 +08:00
|
|
|
|
|
|
|
/* set the interrupt pin active low */
|
|
|
|
temp = phy_read(phydev, MII_KSZPHY_CTRL);
|
2014-11-12 03:00:08 +08:00
|
|
|
if (temp < 0)
|
|
|
|
return temp;
|
2014-11-19 19:59:22 +08:00
|
|
|
temp &= ~mask;
|
2010-06-28 23:23:41 +08:00
|
|
|
phy_write(phydev, MII_KSZPHY_CTRL, temp);
|
|
|
|
|
2014-11-19 19:59:22 +08:00
|
|
|
/* enable / disable interrupts */
|
|
|
|
if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
|
|
|
|
temp = KSZPHY_INTCS_ALL;
|
|
|
|
else
|
|
|
|
temp = 0;
|
2010-06-28 23:23:41 +08:00
|
|
|
|
2014-11-19 19:59:22 +08:00
|
|
|
return phy_write(phydev, MII_KSZPHY_INTCS, temp);
|
2010-06-28 23:23:41 +08:00
|
|
|
}
|
2010-04-29 14:12:41 +08:00
|
|
|
|
2014-11-19 19:59:18 +08:00
|
|
|
static int kszphy_rmii_clk_sel(struct phy_device *phydev, bool val)
|
|
|
|
{
|
|
|
|
int ctrl;
|
|
|
|
|
|
|
|
ctrl = phy_read(phydev, MII_KSZPHY_CTRL);
|
|
|
|
if (ctrl < 0)
|
|
|
|
return ctrl;
|
|
|
|
|
|
|
|
if (val)
|
|
|
|
ctrl |= KSZPHY_RMII_REF_CLK_SEL;
|
|
|
|
else
|
|
|
|
ctrl &= ~KSZPHY_RMII_REF_CLK_SEL;
|
|
|
|
|
|
|
|
return phy_write(phydev, MII_KSZPHY_CTRL, ctrl);
|
|
|
|
}
|
|
|
|
|
2014-11-19 19:59:16 +08:00
|
|
|
static int kszphy_setup_led(struct phy_device *phydev, u32 reg, int val)
|
2014-02-26 19:48:00 +08:00
|
|
|
{
|
2014-11-12 03:00:14 +08:00
|
|
|
int rc, temp, shift;
|
2014-11-12 03:00:12 +08:00
|
|
|
|
2014-11-12 03:00:14 +08:00
|
|
|
switch (reg) {
|
|
|
|
case MII_KSZPHY_CTRL_1:
|
|
|
|
shift = 14;
|
|
|
|
break;
|
|
|
|
case MII_KSZPHY_CTRL_2:
|
|
|
|
shift = 4;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2014-02-26 19:48:00 +08:00
|
|
|
temp = phy_read(phydev, reg);
|
2014-11-12 03:00:13 +08:00
|
|
|
if (temp < 0) {
|
|
|
|
rc = temp;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-02-26 19:48:00 +08:00
|
|
|
|
2014-03-19 07:58:16 +08:00
|
|
|
temp &= ~(3 << shift);
|
2014-02-26 19:48:00 +08:00
|
|
|
temp |= val << shift;
|
|
|
|
rc = phy_write(phydev, reg, temp);
|
2014-11-12 03:00:13 +08:00
|
|
|
out:
|
|
|
|
if (rc < 0)
|
2016-01-07 03:11:09 +08:00
|
|
|
phydev_err(phydev, "failed to set led mode\n");
|
2014-02-26 19:48:00 +08:00
|
|
|
|
2014-11-12 03:00:13 +08:00
|
|
|
return rc;
|
2014-02-26 19:48:00 +08:00
|
|
|
}
|
|
|
|
|
2014-11-12 03:00:10 +08:00
|
|
|
/* Disable PHY address 0 as the broadcast address, so that it can be used as a
|
|
|
|
* unique (non-broadcast) address on a shared bus.
|
|
|
|
*/
|
|
|
|
static int kszphy_broadcast_disable(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = phy_read(phydev, MII_KSZPHY_OMSO);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = phy_write(phydev, MII_KSZPHY_OMSO, ret | KSZPHY_OMSO_B_CAST_OFF);
|
|
|
|
out:
|
|
|
|
if (ret)
|
2016-01-07 03:11:09 +08:00
|
|
|
phydev_err(phydev, "failed to disable broadcast address\n");
|
2014-11-12 03:00:10 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-02-14 04:35:33 +08:00
|
|
|
static int kszphy_nand_tree_disable(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = phy_read(phydev, MII_KSZPHY_OMSO);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (!(ret & KSZPHY_OMSO_NAND_TREE_ON))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = phy_write(phydev, MII_KSZPHY_OMSO,
|
|
|
|
ret & ~KSZPHY_OMSO_NAND_TREE_ON);
|
|
|
|
out:
|
|
|
|
if (ret)
|
2016-01-07 03:11:09 +08:00
|
|
|
phydev_err(phydev, "failed to disable NAND tree mode\n");
|
2015-02-14 04:35:33 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-05-31 18:29:30 +08:00
|
|
|
/* Some config bits need to be set again on resume, handle them here. */
|
|
|
|
static int kszphy_config_reset(struct phy_device *phydev)
|
2010-04-29 14:12:41 +08:00
|
|
|
{
|
2014-11-19 19:59:15 +08:00
|
|
|
struct kszphy_priv *priv = phydev->priv;
|
2014-11-19 19:59:18 +08:00
|
|
|
int ret;
|
2010-04-29 14:12:41 +08:00
|
|
|
|
2014-11-19 19:59:18 +08:00
|
|
|
if (priv->rmii_ref_clk_sel) {
|
|
|
|
ret = kszphy_rmii_clk_sel(phydev, priv->rmii_ref_clk_sel_val);
|
|
|
|
if (ret) {
|
2016-01-07 03:11:09 +08:00
|
|
|
phydev_err(phydev,
|
|
|
|
"failed to set rmii reference clock\n");
|
2014-11-19 19:59:18 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-19 19:59:16 +08:00
|
|
|
if (priv->led_mode >= 0)
|
2017-05-31 18:29:30 +08:00
|
|
|
kszphy_setup_led(phydev, priv->type->led_mode_reg, priv->led_mode);
|
2014-11-19 19:59:15 +08:00
|
|
|
|
|
|
|
return 0;
|
2014-02-26 19:48:00 +08:00
|
|
|
}
|
|
|
|
|
2017-05-31 18:29:30 +08:00
|
|
|
static int kszphy_config_init(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
struct kszphy_priv *priv = phydev->priv;
|
|
|
|
const struct kszphy_type *type;
|
|
|
|
|
|
|
|
if (!priv)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
type = priv->type;
|
|
|
|
|
|
|
|
if (type->has_broadcast_disable)
|
|
|
|
kszphy_broadcast_disable(phydev);
|
|
|
|
|
|
|
|
if (type->has_nand_tree_disable)
|
|
|
|
kszphy_nand_tree_disable(phydev);
|
|
|
|
|
|
|
|
return kszphy_config_reset(phydev);
|
|
|
|
}
|
|
|
|
|
2016-07-14 22:29:43 +08:00
|
|
|
static int ksz8041_config_init(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
struct device_node *of_node = phydev->mdio.dev.of_node;
|
|
|
|
|
|
|
|
/* Limit supported and advertised modes in fiber mode */
|
|
|
|
if (of_property_read_bool(of_node, "micrel,fiber-mode")) {
|
|
|
|
phydev->dev_flags |= MICREL_PHY_FXEN;
|
2016-11-22 00:53:31 +08:00
|
|
|
phydev->supported &= SUPPORTED_100baseT_Full |
|
2016-07-14 22:29:43 +08:00
|
|
|
SUPPORTED_100baseT_Half;
|
2016-11-22 00:53:31 +08:00
|
|
|
phydev->supported |= SUPPORTED_FIBRE;
|
|
|
|
phydev->advertising &= ADVERTISED_100baseT_Full |
|
2016-07-14 22:29:43 +08:00
|
|
|
ADVERTISED_100baseT_Half;
|
2016-11-22 00:53:31 +08:00
|
|
|
phydev->advertising |= ADVERTISED_FIBRE;
|
2016-07-14 22:29:43 +08:00
|
|
|
phydev->autoneg = AUTONEG_DISABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return kszphy_config_init(phydev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ksz8041_config_aneg(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
/* Skip auto-negotiation in fiber mode */
|
|
|
|
if (phydev->dev_flags & MICREL_PHY_FXEN) {
|
|
|
|
phydev->speed = SPEED_100;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return genphy_config_aneg(phydev);
|
|
|
|
}
|
|
|
|
|
2013-08-21 09:46:12 +08:00
|
|
|
static int ksz9021_load_values_from_of(struct phy_device *phydev,
|
2015-06-06 07:00:24 +08:00
|
|
|
const struct device_node *of_node,
|
|
|
|
u16 reg,
|
|
|
|
const char *field1, const char *field2,
|
|
|
|
const char *field3, const char *field4)
|
2013-08-21 09:46:12 +08:00
|
|
|
{
|
|
|
|
int val1 = -1;
|
|
|
|
int val2 = -2;
|
|
|
|
int val3 = -3;
|
|
|
|
int val4 = -4;
|
|
|
|
int newval;
|
|
|
|
int matches = 0;
|
|
|
|
|
|
|
|
if (!of_property_read_u32(of_node, field1, &val1))
|
|
|
|
matches++;
|
|
|
|
|
|
|
|
if (!of_property_read_u32(of_node, field2, &val2))
|
|
|
|
matches++;
|
|
|
|
|
|
|
|
if (!of_property_read_u32(of_node, field3, &val3))
|
|
|
|
matches++;
|
|
|
|
|
|
|
|
if (!of_property_read_u32(of_node, field4, &val4))
|
|
|
|
matches++;
|
|
|
|
|
|
|
|
if (!matches)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (matches < 4)
|
|
|
|
newval = kszphy_extended_read(phydev, reg);
|
|
|
|
else
|
|
|
|
newval = 0;
|
|
|
|
|
|
|
|
if (val1 != -1)
|
|
|
|
newval = ((newval & 0xfff0) | ((val1 / PS_TO_REG) & 0xf) << 0);
|
|
|
|
|
2014-04-22 21:01:04 +08:00
|
|
|
if (val2 != -2)
|
2013-08-21 09:46:12 +08:00
|
|
|
newval = ((newval & 0xff0f) | ((val2 / PS_TO_REG) & 0xf) << 4);
|
|
|
|
|
2014-04-22 21:01:04 +08:00
|
|
|
if (val3 != -3)
|
2013-08-21 09:46:12 +08:00
|
|
|
newval = ((newval & 0xf0ff) | ((val3 / PS_TO_REG) & 0xf) << 8);
|
|
|
|
|
2014-04-22 21:01:04 +08:00
|
|
|
if (val4 != -4)
|
2013-08-21 09:46:12 +08:00
|
|
|
newval = ((newval & 0x0fff) | ((val4 / PS_TO_REG) & 0xf) << 12);
|
|
|
|
|
|
|
|
return kszphy_extended_write(phydev, reg, newval);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ksz9021_config_init(struct phy_device *phydev)
|
|
|
|
{
|
2016-01-07 03:11:16 +08:00
|
|
|
const struct device *dev = &phydev->mdio.dev;
|
2015-06-06 07:00:24 +08:00
|
|
|
const struct device_node *of_node = dev->of_node;
|
2015-12-10 02:56:31 +08:00
|
|
|
const struct device *dev_walker;
|
|
|
|
|
|
|
|
/* The Micrel driver has a deprecated option to place phy OF
|
|
|
|
* properties in the MAC node. Walk up the tree of devices to
|
|
|
|
* find a device with an OF node.
|
|
|
|
*/
|
2016-01-07 03:11:16 +08:00
|
|
|
dev_walker = &phydev->mdio.dev;
|
2015-12-10 02:56:31 +08:00
|
|
|
do {
|
|
|
|
of_node = dev_walker->of_node;
|
|
|
|
dev_walker = dev_walker->parent;
|
|
|
|
|
|
|
|
} while (!of_node && dev_walker);
|
2013-08-21 09:46:12 +08:00
|
|
|
|
|
|
|
if (of_node) {
|
|
|
|
ksz9021_load_values_from_of(phydev, of_node,
|
|
|
|
MII_KSZPHY_CLK_CONTROL_PAD_SKEW,
|
|
|
|
"txen-skew-ps", "txc-skew-ps",
|
|
|
|
"rxdv-skew-ps", "rxc-skew-ps");
|
|
|
|
ksz9021_load_values_from_of(phydev, of_node,
|
|
|
|
MII_KSZPHY_RX_DATA_PAD_SKEW,
|
|
|
|
"rxd0-skew-ps", "rxd1-skew-ps",
|
|
|
|
"rxd2-skew-ps", "rxd3-skew-ps");
|
|
|
|
ksz9021_load_values_from_of(phydev, of_node,
|
|
|
|
MII_KSZPHY_TX_DATA_PAD_SKEW,
|
|
|
|
"txd0-skew-ps", "txd1-skew-ps",
|
|
|
|
"txd2-skew-ps", "txd3-skew-ps");
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-06 15:40:17 +08:00
|
|
|
#define MII_KSZ9031RN_MMD_CTRL_REG 0x0d
|
|
|
|
#define MII_KSZ9031RN_MMD_REGDATA_REG 0x0e
|
|
|
|
#define OP_DATA 1
|
|
|
|
#define KSZ9031_PS_TO_REG 60
|
|
|
|
|
|
|
|
/* Extended registers */
|
2015-06-06 07:00:26 +08:00
|
|
|
/* MMD Address 0x0 */
|
|
|
|
#define MII_KSZ9031RN_FLP_BURST_TX_LO 3
|
|
|
|
#define MII_KSZ9031RN_FLP_BURST_TX_HI 4
|
|
|
|
|
2015-06-06 07:00:25 +08:00
|
|
|
/* MMD Address 0x2 */
|
2014-05-06 15:40:17 +08:00
|
|
|
#define MII_KSZ9031RN_CONTROL_PAD_SKEW 4
|
|
|
|
#define MII_KSZ9031RN_RX_DATA_PAD_SKEW 5
|
|
|
|
#define MII_KSZ9031RN_TX_DATA_PAD_SKEW 6
|
|
|
|
#define MII_KSZ9031RN_CLK_PAD_SKEW 8
|
|
|
|
|
2016-10-04 13:52:04 +08:00
|
|
|
/* MMD Address 0x1C */
|
|
|
|
#define MII_KSZ9031RN_EDPD 0x23
|
|
|
|
#define MII_KSZ9031RN_EDPD_ENABLE BIT(0)
|
|
|
|
|
2014-05-06 15:40:17 +08:00
|
|
|
static int ksz9031_extended_write(struct phy_device *phydev,
|
|
|
|
u8 mode, u32 dev_addr, u32 regnum, u16 val)
|
|
|
|
{
|
|
|
|
phy_write(phydev, MII_KSZ9031RN_MMD_CTRL_REG, dev_addr);
|
|
|
|
phy_write(phydev, MII_KSZ9031RN_MMD_REGDATA_REG, regnum);
|
|
|
|
phy_write(phydev, MII_KSZ9031RN_MMD_CTRL_REG, (mode << 14) | dev_addr);
|
|
|
|
return phy_write(phydev, MII_KSZ9031RN_MMD_REGDATA_REG, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ksz9031_extended_read(struct phy_device *phydev,
|
|
|
|
u8 mode, u32 dev_addr, u32 regnum)
|
|
|
|
{
|
|
|
|
phy_write(phydev, MII_KSZ9031RN_MMD_CTRL_REG, dev_addr);
|
|
|
|
phy_write(phydev, MII_KSZ9031RN_MMD_REGDATA_REG, regnum);
|
|
|
|
phy_write(phydev, MII_KSZ9031RN_MMD_CTRL_REG, (mode << 14) | dev_addr);
|
|
|
|
return phy_read(phydev, MII_KSZ9031RN_MMD_REGDATA_REG);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ksz9031_of_load_skew_values(struct phy_device *phydev,
|
2015-06-06 07:00:24 +08:00
|
|
|
const struct device_node *of_node,
|
2014-05-06 15:40:17 +08:00
|
|
|
u16 reg, size_t field_sz,
|
2015-06-06 07:00:24 +08:00
|
|
|
const char *field[], u8 numfields)
|
2014-05-06 15:40:17 +08:00
|
|
|
{
|
|
|
|
int val[4] = {-1, -2, -3, -4};
|
|
|
|
int matches = 0;
|
|
|
|
u16 mask;
|
|
|
|
u16 maxval;
|
|
|
|
u16 newval;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < numfields; i++)
|
|
|
|
if (!of_property_read_u32(of_node, field[i], val + i))
|
|
|
|
matches++;
|
|
|
|
|
|
|
|
if (!matches)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (matches < numfields)
|
|
|
|
newval = ksz9031_extended_read(phydev, OP_DATA, 2, reg);
|
|
|
|
else
|
|
|
|
newval = 0;
|
|
|
|
|
|
|
|
maxval = (field_sz == 4) ? 0xf : 0x1f;
|
|
|
|
for (i = 0; i < numfields; i++)
|
|
|
|
if (val[i] != -(i + 1)) {
|
|
|
|
mask = 0xffff;
|
|
|
|
mask ^= maxval << (field_sz * i);
|
|
|
|
newval = (newval & mask) |
|
|
|
|
(((val[i] / KSZ9031_PS_TO_REG) & maxval)
|
|
|
|
<< (field_sz * i));
|
|
|
|
}
|
|
|
|
|
|
|
|
return ksz9031_extended_write(phydev, OP_DATA, 2, reg, newval);
|
|
|
|
}
|
|
|
|
|
2017-11-30 18:08:29 +08:00
|
|
|
/* Center KSZ9031RNX FLP timing at 16ms. */
|
2015-06-06 07:00:26 +08:00
|
|
|
static int ksz9031_center_flp_timing(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int result;
|
|
|
|
|
|
|
|
result = ksz9031_extended_write(phydev, OP_DATA, 0,
|
|
|
|
MII_KSZ9031RN_FLP_BURST_TX_HI, 0x0006);
|
2017-11-30 18:08:29 +08:00
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
2015-06-06 07:00:26 +08:00
|
|
|
result = ksz9031_extended_write(phydev, OP_DATA, 0,
|
|
|
|
MII_KSZ9031RN_FLP_BURST_TX_LO, 0x1A80);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
return genphy_restart_aneg(phydev);
|
|
|
|
}
|
|
|
|
|
2016-10-04 13:52:04 +08:00
|
|
|
/* Enable energy-detect power-down mode */
|
|
|
|
static int ksz9031_enable_edpd(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int reg;
|
|
|
|
|
|
|
|
reg = ksz9031_extended_read(phydev, OP_DATA, 0x1C, MII_KSZ9031RN_EDPD);
|
|
|
|
if (reg < 0)
|
|
|
|
return reg;
|
|
|
|
return ksz9031_extended_write(phydev, OP_DATA, 0x1C, MII_KSZ9031RN_EDPD,
|
|
|
|
reg | MII_KSZ9031RN_EDPD_ENABLE);
|
|
|
|
}
|
|
|
|
|
2014-05-06 15:40:17 +08:00
|
|
|
static int ksz9031_config_init(struct phy_device *phydev)
|
|
|
|
{
|
2016-01-07 03:11:16 +08:00
|
|
|
const struct device *dev = &phydev->mdio.dev;
|
2015-06-06 07:00:24 +08:00
|
|
|
const struct device_node *of_node = dev->of_node;
|
|
|
|
static const char *clk_skews[2] = {"rxc-skew-ps", "txc-skew-ps"};
|
|
|
|
static const char *rx_data_skews[4] = {
|
2014-05-06 15:40:17 +08:00
|
|
|
"rxd0-skew-ps", "rxd1-skew-ps",
|
|
|
|
"rxd2-skew-ps", "rxd3-skew-ps"
|
|
|
|
};
|
2015-06-06 07:00:24 +08:00
|
|
|
static const char *tx_data_skews[4] = {
|
2014-05-06 15:40:17 +08:00
|
|
|
"txd0-skew-ps", "txd1-skew-ps",
|
|
|
|
"txd2-skew-ps", "txd3-skew-ps"
|
|
|
|
};
|
2015-06-06 07:00:24 +08:00
|
|
|
static const char *control_skews[2] = {"txen-skew-ps", "rxdv-skew-ps"};
|
2016-01-07 16:31:15 +08:00
|
|
|
const struct device *dev_walker;
|
2016-10-04 13:52:04 +08:00
|
|
|
int result;
|
|
|
|
|
|
|
|
result = ksz9031_enable_edpd(phydev);
|
|
|
|
if (result < 0)
|
|
|
|
return result;
|
2014-05-06 15:40:17 +08:00
|
|
|
|
2016-01-07 16:31:15 +08:00
|
|
|
/* The Micrel driver has a deprecated option to place phy OF
|
|
|
|
* properties in the MAC node. Walk up the tree of devices to
|
|
|
|
* find a device with an OF node.
|
|
|
|
*/
|
2016-01-12 12:55:43 +08:00
|
|
|
dev_walker = &phydev->mdio.dev;
|
2016-01-07 16:31:15 +08:00
|
|
|
do {
|
|
|
|
of_node = dev_walker->of_node;
|
|
|
|
dev_walker = dev_walker->parent;
|
|
|
|
} while (!of_node && dev_walker);
|
2014-05-06 15:40:17 +08:00
|
|
|
|
|
|
|
if (of_node) {
|
|
|
|
ksz9031_of_load_skew_values(phydev, of_node,
|
|
|
|
MII_KSZ9031RN_CLK_PAD_SKEW, 5,
|
|
|
|
clk_skews, 2);
|
|
|
|
|
|
|
|
ksz9031_of_load_skew_values(phydev, of_node,
|
|
|
|
MII_KSZ9031RN_CONTROL_PAD_SKEW, 4,
|
|
|
|
control_skews, 2);
|
|
|
|
|
|
|
|
ksz9031_of_load_skew_values(phydev, of_node,
|
|
|
|
MII_KSZ9031RN_RX_DATA_PAD_SKEW, 4,
|
|
|
|
rx_data_skews, 4);
|
|
|
|
|
|
|
|
ksz9031_of_load_skew_values(phydev, of_node,
|
|
|
|
MII_KSZ9031RN_TX_DATA_PAD_SKEW, 4,
|
|
|
|
tx_data_skews, 4);
|
|
|
|
}
|
2015-06-06 07:00:26 +08:00
|
|
|
|
|
|
|
return ksz9031_center_flp_timing(phydev);
|
2014-05-06 15:40:17 +08:00
|
|
|
}
|
|
|
|
|
2012-11-21 13:38:07 +08:00
|
|
|
#define KSZ8873MLL_GLOBAL_CONTROL_4 0x06
|
2014-11-12 03:00:09 +08:00
|
|
|
#define KSZ8873MLL_GLOBAL_CONTROL_4_DUPLEX BIT(6)
|
|
|
|
#define KSZ8873MLL_GLOBAL_CONTROL_4_SPEED BIT(4)
|
2013-08-06 16:29:35 +08:00
|
|
|
static int ksz8873mll_read_status(struct phy_device *phydev)
|
2012-11-21 13:38:07 +08:00
|
|
|
{
|
|
|
|
int regval;
|
|
|
|
|
|
|
|
/* dummy read */
|
|
|
|
regval = phy_read(phydev, KSZ8873MLL_GLOBAL_CONTROL_4);
|
|
|
|
|
|
|
|
regval = phy_read(phydev, KSZ8873MLL_GLOBAL_CONTROL_4);
|
|
|
|
|
|
|
|
if (regval & KSZ8873MLL_GLOBAL_CONTROL_4_DUPLEX)
|
|
|
|
phydev->duplex = DUPLEX_HALF;
|
|
|
|
else
|
|
|
|
phydev->duplex = DUPLEX_FULL;
|
|
|
|
|
|
|
|
if (regval & KSZ8873MLL_GLOBAL_CONTROL_4_SPEED)
|
|
|
|
phydev->speed = SPEED_10;
|
|
|
|
else
|
|
|
|
phydev->speed = SPEED_100;
|
|
|
|
|
|
|
|
phydev->link = 1;
|
|
|
|
phydev->pause = phydev->asym_pause = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-10-22 03:17:04 +08:00
|
|
|
static int ksz9031_read_status(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
int regval;
|
|
|
|
|
|
|
|
err = genphy_read_status(phydev);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* Make sure the PHY is not broken. Read idle error count,
|
|
|
|
* and reset the PHY if it is maxed out.
|
|
|
|
*/
|
|
|
|
regval = phy_read(phydev, MII_STAT1000);
|
|
|
|
if ((regval & 0xFF) == 0xFF) {
|
|
|
|
phy_init_hw(phydev);
|
|
|
|
phydev->link = 0;
|
2017-06-21 01:48:11 +08:00
|
|
|
if (phydev->drv->config_intr && phy_interrupt_is_valid(phydev))
|
|
|
|
phydev->drv->config_intr(phydev);
|
2017-12-21 08:45:10 +08:00
|
|
|
return genphy_config_aneg(phydev);
|
2015-10-22 03:17:04 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-21 13:38:07 +08:00
|
|
|
static int ksz8873mll_config_aneg(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-07-30 04:19:58 +08:00
|
|
|
/* This routine returns -1 as an indication to the caller that the
|
|
|
|
* Micrel ksz9021 10/100/1000 PHY does not support standard IEEE
|
|
|
|
* MMD extended PHY registers.
|
|
|
|
*/
|
|
|
|
static int
|
2017-03-22 00:36:58 +08:00
|
|
|
ksz9021_rd_mmd_phyreg(struct phy_device *phydev, int devad, u16 regnum)
|
2014-07-30 04:19:58 +08:00
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This routine does nothing since the Micrel ksz9021 does not support
|
|
|
|
* standard IEEE MMD extended PHY registers.
|
|
|
|
*/
|
2017-03-22 00:36:58 +08:00
|
|
|
static int
|
|
|
|
ksz9021_wr_mmd_phyreg(struct phy_device *phydev, int devad, u16 regnum, u16 val)
|
2014-07-30 04:19:58 +08:00
|
|
|
{
|
2017-03-22 00:36:58 +08:00
|
|
|
return -1;
|
2014-07-30 04:19:58 +08:00
|
|
|
}
|
|
|
|
|
2015-12-30 23:28:27 +08:00
|
|
|
static int kszphy_get_sset_count(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
return ARRAY_SIZE(kszphy_hw_stats);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void kszphy_get_strings(struct phy_device *phydev, u8 *data)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(kszphy_hw_stats); i++) {
|
|
|
|
memcpy(data + i * ETH_GSTRING_LEN,
|
|
|
|
kszphy_hw_stats[i].string, ETH_GSTRING_LEN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef UINT64_MAX
|
|
|
|
#define UINT64_MAX (u64)(~((u64)0))
|
|
|
|
#endif
|
|
|
|
static u64 kszphy_get_stat(struct phy_device *phydev, int i)
|
|
|
|
{
|
|
|
|
struct kszphy_hw_stat stat = kszphy_hw_stats[i];
|
|
|
|
struct kszphy_priv *priv = phydev->priv;
|
2016-02-20 07:35:29 +08:00
|
|
|
int val;
|
|
|
|
u64 ret;
|
2015-12-30 23:28:27 +08:00
|
|
|
|
|
|
|
val = phy_read(phydev, stat.reg);
|
|
|
|
if (val < 0) {
|
2016-02-20 07:35:29 +08:00
|
|
|
ret = UINT64_MAX;
|
2015-12-30 23:28:27 +08:00
|
|
|
} else {
|
|
|
|
val = val & ((1 << stat.bits) - 1);
|
|
|
|
priv->stats[i] += val;
|
2016-02-20 07:35:29 +08:00
|
|
|
ret = priv->stats[i];
|
2015-12-30 23:28:27 +08:00
|
|
|
}
|
|
|
|
|
2016-02-20 07:35:29 +08:00
|
|
|
return ret;
|
2015-12-30 23:28:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void kszphy_get_stats(struct phy_device *phydev,
|
|
|
|
struct ethtool_stats *stats, u64 *data)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(kszphy_hw_stats); i++)
|
|
|
|
data[i] = kszphy_get_stat(phydev, i);
|
|
|
|
}
|
|
|
|
|
2016-08-05 14:35:41 +08:00
|
|
|
static int kszphy_suspend(struct phy_device *phydev)
|
2016-02-27 02:18:22 +08:00
|
|
|
{
|
2016-08-05 14:35:41 +08:00
|
|
|
/* Disable PHY Interrupts */
|
|
|
|
if (phy_interrupt_is_valid(phydev)) {
|
|
|
|
phydev->interrupts = PHY_INTERRUPT_DISABLED;
|
|
|
|
if (phydev->drv->config_intr)
|
|
|
|
phydev->drv->config_intr(phydev);
|
|
|
|
}
|
2016-02-27 02:18:22 +08:00
|
|
|
|
2016-08-05 14:35:41 +08:00
|
|
|
return genphy_suspend(phydev);
|
|
|
|
}
|
2016-02-27 02:18:22 +08:00
|
|
|
|
2016-08-05 14:35:41 +08:00
|
|
|
static int kszphy_resume(struct phy_device *phydev)
|
|
|
|
{
|
2017-05-31 18:29:30 +08:00
|
|
|
int ret;
|
|
|
|
|
2016-08-05 14:35:41 +08:00
|
|
|
genphy_resume(phydev);
|
2016-02-27 02:18:22 +08:00
|
|
|
|
2017-05-31 18:29:30 +08:00
|
|
|
ret = kszphy_config_reset(phydev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2016-08-05 14:35:41 +08:00
|
|
|
/* Enable PHY Interrupts */
|
|
|
|
if (phy_interrupt_is_valid(phydev)) {
|
|
|
|
phydev->interrupts = PHY_INTERRUPT_ENABLED;
|
|
|
|
if (phydev->drv->config_intr)
|
|
|
|
phydev->drv->config_intr(phydev);
|
|
|
|
}
|
2016-02-27 02:18:22 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-19 19:59:15 +08:00
|
|
|
static int kszphy_probe(struct phy_device *phydev)
|
|
|
|
{
|
|
|
|
const struct kszphy_type *type = phydev->drv->driver_data;
|
2016-01-07 03:11:16 +08:00
|
|
|
const struct device_node *np = phydev->mdio.dev.of_node;
|
2014-11-19 19:59:15 +08:00
|
|
|
struct kszphy_priv *priv;
|
2014-11-19 19:59:18 +08:00
|
|
|
struct clk *clk;
|
2014-11-19 19:59:16 +08:00
|
|
|
int ret;
|
2014-11-19 19:59:15 +08:00
|
|
|
|
2016-01-07 03:11:16 +08:00
|
|
|
priv = devm_kzalloc(&phydev->mdio.dev, sizeof(*priv), GFP_KERNEL);
|
2014-11-19 19:59:15 +08:00
|
|
|
if (!priv)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
phydev->priv = priv;
|
|
|
|
|
|
|
|
priv->type = type;
|
|
|
|
|
2014-11-19 19:59:16 +08:00
|
|
|
if (type->led_mode_reg) {
|
|
|
|
ret = of_property_read_u32(np, "micrel,led-mode",
|
|
|
|
&priv->led_mode);
|
|
|
|
if (ret)
|
|
|
|
priv->led_mode = -1;
|
|
|
|
|
|
|
|
if (priv->led_mode > 3) {
|
2016-01-07 03:11:09 +08:00
|
|
|
phydev_err(phydev, "invalid led mode: 0x%02x\n",
|
|
|
|
priv->led_mode);
|
2014-11-19 19:59:16 +08:00
|
|
|
priv->led_mode = -1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
priv->led_mode = -1;
|
|
|
|
}
|
|
|
|
|
2016-01-07 03:11:16 +08:00
|
|
|
clk = devm_clk_get(&phydev->mdio.dev, "rmii-ref");
|
2015-05-12 15:43:14 +08:00
|
|
|
/* NOTE: clk may be NULL if building without CONFIG_HAVE_CLK */
|
|
|
|
if (!IS_ERR_OR_NULL(clk)) {
|
2014-10-10 15:48:05 +08:00
|
|
|
unsigned long rate = clk_get_rate(clk);
|
2014-11-19 19:59:19 +08:00
|
|
|
bool rmii_ref_clk_sel_25_mhz;
|
2014-10-10 15:48:05 +08:00
|
|
|
|
2014-11-19 19:59:18 +08:00
|
|
|
priv->rmii_ref_clk_sel = type->has_rmii_ref_clk_sel;
|
2014-11-19 19:59:19 +08:00
|
|
|
rmii_ref_clk_sel_25_mhz = of_property_read_bool(np,
|
|
|
|
"micrel,rmii-reference-clock-select-25-mhz");
|
2014-11-19 19:59:18 +08:00
|
|
|
|
2014-10-10 15:48:05 +08:00
|
|
|
if (rate > 24500000 && rate < 25500000) {
|
2014-11-19 19:59:19 +08:00
|
|
|
priv->rmii_ref_clk_sel_val = rmii_ref_clk_sel_25_mhz;
|
2014-10-10 15:48:05 +08:00
|
|
|
} else if (rate > 49500000 && rate < 50500000) {
|
2014-11-19 19:59:19 +08:00
|
|
|
priv->rmii_ref_clk_sel_val = !rmii_ref_clk_sel_25_mhz;
|
2014-10-10 15:48:05 +08:00
|
|
|
} else {
|
2016-01-07 03:11:09 +08:00
|
|
|
phydev_err(phydev, "Clock rate out of range: %ld\n",
|
|
|
|
rate);
|
2014-10-10 15:48:05 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-19 19:59:18 +08:00
|
|
|
/* Support legacy board-file configuration */
|
|
|
|
if (phydev->dev_flags & MICREL_PHY_50MHZ_CLK) {
|
|
|
|
priv->rmii_ref_clk_sel = true;
|
|
|
|
priv->rmii_ref_clk_sel_val = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2014-10-10 15:48:05 +08:00
|
|
|
}
|
|
|
|
|
2012-07-04 13:44:34 +08:00
|
|
|
static struct phy_driver ksphy_driver[] = {
|
|
|
|
{
|
2010-06-28 23:23:41 +08:00
|
|
|
.phy_id = PHY_ID_KS8737,
|
2016-05-12 04:02:05 +08:00
|
|
|
.phy_id_mask = MICREL_PHY_ID_MASK,
|
2010-06-28 23:23:41 +08:00
|
|
|
.name = "Micrel KS8737",
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
.features = PHY_BASIC_FEATURES,
|
2017-05-17 00:29:11 +08:00
|
|
|
.flags = PHY_HAS_INTERRUPT,
|
2014-11-19 19:59:22 +08:00
|
|
|
.driver_data = &ks8737_type,
|
2010-06-28 23:23:41 +08:00
|
|
|
.config_init = kszphy_config_init,
|
|
|
|
.ack_interrupt = kszphy_ack_interrupt,
|
2014-11-19 19:59:22 +08:00
|
|
|
.config_intr = kszphy_config_intr,
|
2013-09-20 01:40:48 +08:00
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2012-09-24 00:58:49 +08:00
|
|
|
}, {
|
|
|
|
.phy_id = PHY_ID_KSZ8021,
|
|
|
|
.phy_id_mask = 0x00ffffff,
|
2013-01-23 22:05:15 +08:00
|
|
|
.name = "Micrel KSZ8021 or KSZ8031",
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
.features = PHY_BASIC_FEATURES,
|
2017-05-17 00:29:11 +08:00
|
|
|
.flags = PHY_HAS_INTERRUPT,
|
2014-11-19 19:59:15 +08:00
|
|
|
.driver_data = &ksz8021_type,
|
2014-11-19 19:59:18 +08:00
|
|
|
.probe = kszphy_probe,
|
2014-12-23 19:59:17 +08:00
|
|
|
.config_init = kszphy_config_init,
|
2012-09-24 00:58:49 +08:00
|
|
|
.ack_interrupt = kszphy_ack_interrupt,
|
|
|
|
.config_intr = kszphy_config_intr,
|
2015-12-30 23:28:27 +08:00
|
|
|
.get_sset_count = kszphy_get_sset_count,
|
|
|
|
.get_strings = kszphy_get_strings,
|
|
|
|
.get_stats = kszphy_get_stats,
|
2013-09-20 01:40:48 +08:00
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2013-03-11 06:50:02 +08:00
|
|
|
}, {
|
|
|
|
.phy_id = PHY_ID_KSZ8031,
|
|
|
|
.phy_id_mask = 0x00ffffff,
|
|
|
|
.name = "Micrel KSZ8031",
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
.features = PHY_BASIC_FEATURES,
|
2017-05-17 00:29:11 +08:00
|
|
|
.flags = PHY_HAS_INTERRUPT,
|
2014-11-19 19:59:15 +08:00
|
|
|
.driver_data = &ksz8021_type,
|
2014-11-19 19:59:18 +08:00
|
|
|
.probe = kszphy_probe,
|
2014-12-23 19:59:17 +08:00
|
|
|
.config_init = kszphy_config_init,
|
2013-03-11 06:50:02 +08:00
|
|
|
.ack_interrupt = kszphy_ack_interrupt,
|
|
|
|
.config_intr = kszphy_config_intr,
|
2015-12-30 23:28:27 +08:00
|
|
|
.get_sset_count = kszphy_get_sset_count,
|
|
|
|
.get_strings = kszphy_get_strings,
|
|
|
|
.get_stats = kszphy_get_stats,
|
2013-09-20 01:40:48 +08:00
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2012-07-04 13:44:34 +08:00
|
|
|
}, {
|
2012-09-24 00:58:50 +08:00
|
|
|
.phy_id = PHY_ID_KSZ8041,
|
2016-05-12 04:02:05 +08:00
|
|
|
.phy_id_mask = MICREL_PHY_ID_MASK,
|
2012-09-24 00:58:50 +08:00
|
|
|
.name = "Micrel KSZ8041",
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
.features = PHY_BASIC_FEATURES,
|
2017-05-17 00:29:11 +08:00
|
|
|
.flags = PHY_HAS_INTERRUPT,
|
2014-11-19 19:59:15 +08:00
|
|
|
.driver_data = &ksz8041_type,
|
|
|
|
.probe = kszphy_probe,
|
2016-07-14 22:29:43 +08:00
|
|
|
.config_init = ksz8041_config_init,
|
|
|
|
.config_aneg = ksz8041_config_aneg,
|
2010-06-28 23:23:41 +08:00
|
|
|
.ack_interrupt = kszphy_ack_interrupt,
|
|
|
|
.config_intr = kszphy_config_intr,
|
2015-12-30 23:28:27 +08:00
|
|
|
.get_sset_count = kszphy_get_sset_count,
|
|
|
|
.get_strings = kszphy_get_strings,
|
|
|
|
.get_stats = kszphy_get_stats,
|
2013-09-20 01:40:48 +08:00
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2013-12-10 07:20:41 +08:00
|
|
|
}, {
|
|
|
|
.phy_id = PHY_ID_KSZ8041RNLI,
|
2016-05-12 04:02:05 +08:00
|
|
|
.phy_id_mask = MICREL_PHY_ID_MASK,
|
2013-12-10 07:20:41 +08:00
|
|
|
.name = "Micrel KSZ8041RNLI",
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
.features = PHY_BASIC_FEATURES,
|
2017-05-17 00:29:11 +08:00
|
|
|
.flags = PHY_HAS_INTERRUPT,
|
2014-11-19 19:59:15 +08:00
|
|
|
.driver_data = &ksz8041_type,
|
|
|
|
.probe = kszphy_probe,
|
|
|
|
.config_init = kszphy_config_init,
|
2013-12-10 07:20:41 +08:00
|
|
|
.ack_interrupt = kszphy_ack_interrupt,
|
|
|
|
.config_intr = kszphy_config_intr,
|
2015-12-30 23:28:27 +08:00
|
|
|
.get_sset_count = kszphy_get_sset_count,
|
|
|
|
.get_strings = kszphy_get_strings,
|
|
|
|
.get_stats = kszphy_get_stats,
|
2013-12-10 07:20:41 +08:00
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2012-07-04 13:44:34 +08:00
|
|
|
}, {
|
2012-09-24 00:58:50 +08:00
|
|
|
.phy_id = PHY_ID_KSZ8051,
|
2016-05-12 04:02:05 +08:00
|
|
|
.phy_id_mask = MICREL_PHY_ID_MASK,
|
2012-09-24 00:58:50 +08:00
|
|
|
.name = "Micrel KSZ8051",
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
.features = PHY_BASIC_FEATURES,
|
2017-05-17 00:29:11 +08:00
|
|
|
.flags = PHY_HAS_INTERRUPT,
|
2014-11-19 19:59:15 +08:00
|
|
|
.driver_data = &ksz8051_type,
|
|
|
|
.probe = kszphy_probe,
|
2014-11-19 19:59:18 +08:00
|
|
|
.config_init = kszphy_config_init,
|
2010-06-28 23:23:41 +08:00
|
|
|
.ack_interrupt = kszphy_ack_interrupt,
|
|
|
|
.config_intr = kszphy_config_intr,
|
2015-12-30 23:28:27 +08:00
|
|
|
.get_sset_count = kszphy_get_sset_count,
|
|
|
|
.get_strings = kszphy_get_strings,
|
|
|
|
.get_stats = kszphy_get_stats,
|
2013-09-20 01:40:48 +08:00
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2012-07-04 13:44:34 +08:00
|
|
|
}, {
|
2012-09-24 00:58:50 +08:00
|
|
|
.phy_id = PHY_ID_KSZ8001,
|
|
|
|
.name = "Micrel KSZ8001 or KS8721",
|
2016-07-29 18:12:08 +08:00
|
|
|
.phy_id_mask = 0x00fffffc,
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
.features = PHY_BASIC_FEATURES,
|
2017-05-17 00:29:11 +08:00
|
|
|
.flags = PHY_HAS_INTERRUPT,
|
2014-11-19 19:59:15 +08:00
|
|
|
.driver_data = &ksz8041_type,
|
|
|
|
.probe = kszphy_probe,
|
|
|
|
.config_init = kszphy_config_init,
|
2010-06-28 23:23:41 +08:00
|
|
|
.ack_interrupt = kszphy_ack_interrupt,
|
|
|
|
.config_intr = kszphy_config_intr,
|
2015-12-30 23:28:27 +08:00
|
|
|
.get_sset_count = kszphy_get_sset_count,
|
|
|
|
.get_strings = kszphy_get_strings,
|
|
|
|
.get_stats = kszphy_get_stats,
|
2013-09-20 01:40:48 +08:00
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2013-01-23 22:05:15 +08:00
|
|
|
}, {
|
|
|
|
.phy_id = PHY_ID_KSZ8081,
|
|
|
|
.name = "Micrel KSZ8081 or KSZ8091",
|
2016-05-12 04:02:05 +08:00
|
|
|
.phy_id_mask = MICREL_PHY_ID_MASK,
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
.features = PHY_BASIC_FEATURES,
|
2017-05-17 00:29:11 +08:00
|
|
|
.flags = PHY_HAS_INTERRUPT,
|
2014-11-19 19:59:15 +08:00
|
|
|
.driver_data = &ksz8081_type,
|
|
|
|
.probe = kszphy_probe,
|
2014-11-19 19:59:17 +08:00
|
|
|
.config_init = kszphy_config_init,
|
2013-01-23 22:05:15 +08:00
|
|
|
.ack_interrupt = kszphy_ack_interrupt,
|
|
|
|
.config_intr = kszphy_config_intr,
|
2015-12-30 23:28:27 +08:00
|
|
|
.get_sset_count = kszphy_get_sset_count,
|
|
|
|
.get_strings = kszphy_get_strings,
|
|
|
|
.get_stats = kszphy_get_stats,
|
2016-08-05 14:35:41 +08:00
|
|
|
.suspend = kszphy_suspend,
|
2016-02-27 02:18:22 +08:00
|
|
|
.resume = kszphy_resume,
|
2013-01-23 22:05:15 +08:00
|
|
|
}, {
|
|
|
|
.phy_id = PHY_ID_KSZ8061,
|
|
|
|
.name = "Micrel KSZ8061",
|
2016-05-12 04:02:05 +08:00
|
|
|
.phy_id_mask = MICREL_PHY_ID_MASK,
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
.features = PHY_BASIC_FEATURES,
|
2017-05-17 00:29:11 +08:00
|
|
|
.flags = PHY_HAS_INTERRUPT,
|
2013-01-23 22:05:15 +08:00
|
|
|
.config_init = kszphy_config_init,
|
|
|
|
.ack_interrupt = kszphy_ack_interrupt,
|
|
|
|
.config_intr = kszphy_config_intr,
|
2013-09-20 01:40:48 +08:00
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2012-07-04 13:44:34 +08:00
|
|
|
}, {
|
2010-04-29 14:12:41 +08:00
|
|
|
.phy_id = PHY_ID_KSZ9021,
|
2012-06-18 06:52:09 +08:00
|
|
|
.phy_id_mask = 0x000ffffe,
|
2010-04-29 14:12:41 +08:00
|
|
|
.name = "Micrel KSZ9021 Gigabit PHY",
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
.features = PHY_GBIT_FEATURES,
|
2017-05-17 00:29:11 +08:00
|
|
|
.flags = PHY_HAS_INTERRUPT,
|
2014-11-19 19:59:22 +08:00
|
|
|
.driver_data = &ksz9021_type,
|
net: phy: micrel: fix crash when statistic requested for KSZ9031 phy
Now the command:
ethtool --phy-statistics eth0
will cause system crash with meassage "Unable to handle kernel NULL pointer
dereference at virtual address 00000010" from:
(kszphy_get_stats) from [<c069f1d8>] (ethtool_get_phy_stats+0xd8/0x210)
(ethtool_get_phy_stats) from [<c06a0738>] (dev_ethtool+0x5b8/0x228c)
(dev_ethtool) from [<c06b5484>] (dev_ioctl+0x3fc/0x964)
(dev_ioctl) from [<c0679f7c>] (sock_ioctl+0x170/0x2c0)
(sock_ioctl) from [<c02419d4>] (do_vfs_ioctl+0xa8/0x95c)
(do_vfs_ioctl) from [<c02422c4>] (SyS_ioctl+0x3c/0x64)
(SyS_ioctl) from [<c0107d60>] (ret_fast_syscall+0x0/0x44)
The reason: phy_driver structure for KSZ9031 phy has no .probe() callback
defined. As result, struct phy_device *phydev->priv pointer will not be
initializes (null).
This issue will affect also following phys:
KSZ8795, KSZ886X, KSZ8873MLL, KSZ9031, KSZ9021, KSZ8061, KS8737
Fix it by:
- adding .probe() = kszphy_probe() callback to KSZ9031, KSZ9021
phys. The kszphy_probe() can be re-used as it doesn't do any phy specific
settings.
- removing statistic callbacks from other phys (KSZ8795, KSZ886X,
KSZ8873MLL, KSZ8061, KS8737) as they doesn't have corresponding
statistic counters.
Fixes: 2b2427d06426 ("phy: micrel: Add ethtool statistics counters")
Signed-off-by: Grygorii Strashko <grygorii.strashko@ti.com>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-04-14 03:11:27 +08:00
|
|
|
.probe = kszphy_probe,
|
2013-08-21 09:46:12 +08:00
|
|
|
.config_init = ksz9021_config_init,
|
2010-06-28 23:23:41 +08:00
|
|
|
.ack_interrupt = kszphy_ack_interrupt,
|
2014-11-19 19:59:22 +08:00
|
|
|
.config_intr = kszphy_config_intr,
|
2015-12-30 23:28:27 +08:00
|
|
|
.get_sset_count = kszphy_get_sset_count,
|
|
|
|
.get_strings = kszphy_get_strings,
|
|
|
|
.get_stats = kszphy_get_stats,
|
2013-09-20 01:40:48 +08:00
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2017-03-22 00:36:58 +08:00
|
|
|
.read_mmd = ksz9021_rd_mmd_phyreg,
|
|
|
|
.write_mmd = ksz9021_wr_mmd_phyreg,
|
2013-01-23 22:05:15 +08:00
|
|
|
}, {
|
|
|
|
.phy_id = PHY_ID_KSZ9031,
|
2016-05-12 04:02:05 +08:00
|
|
|
.phy_id_mask = MICREL_PHY_ID_MASK,
|
2013-01-23 22:05:15 +08:00
|
|
|
.name = "Micrel KSZ9031 Gigabit PHY",
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
.features = PHY_GBIT_FEATURES,
|
2017-05-17 00:29:11 +08:00
|
|
|
.flags = PHY_HAS_INTERRUPT,
|
2014-11-19 19:59:22 +08:00
|
|
|
.driver_data = &ksz9021_type,
|
net: phy: micrel: fix crash when statistic requested for KSZ9031 phy
Now the command:
ethtool --phy-statistics eth0
will cause system crash with meassage "Unable to handle kernel NULL pointer
dereference at virtual address 00000010" from:
(kszphy_get_stats) from [<c069f1d8>] (ethtool_get_phy_stats+0xd8/0x210)
(ethtool_get_phy_stats) from [<c06a0738>] (dev_ethtool+0x5b8/0x228c)
(dev_ethtool) from [<c06b5484>] (dev_ioctl+0x3fc/0x964)
(dev_ioctl) from [<c0679f7c>] (sock_ioctl+0x170/0x2c0)
(sock_ioctl) from [<c02419d4>] (do_vfs_ioctl+0xa8/0x95c)
(do_vfs_ioctl) from [<c02422c4>] (SyS_ioctl+0x3c/0x64)
(SyS_ioctl) from [<c0107d60>] (ret_fast_syscall+0x0/0x44)
The reason: phy_driver structure for KSZ9031 phy has no .probe() callback
defined. As result, struct phy_device *phydev->priv pointer will not be
initializes (null).
This issue will affect also following phys:
KSZ8795, KSZ886X, KSZ8873MLL, KSZ9031, KSZ9021, KSZ8061, KS8737
Fix it by:
- adding .probe() = kszphy_probe() callback to KSZ9031, KSZ9021
phys. The kszphy_probe() can be re-used as it doesn't do any phy specific
settings.
- removing statistic callbacks from other phys (KSZ8795, KSZ886X,
KSZ8873MLL, KSZ8061, KS8737) as they doesn't have corresponding
statistic counters.
Fixes: 2b2427d06426 ("phy: micrel: Add ethtool statistics counters")
Signed-off-by: Grygorii Strashko <grygorii.strashko@ti.com>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-04-14 03:11:27 +08:00
|
|
|
.probe = kszphy_probe,
|
2014-05-06 15:40:17 +08:00
|
|
|
.config_init = ksz9031_config_init,
|
2015-10-22 03:17:04 +08:00
|
|
|
.read_status = ksz9031_read_status,
|
2013-01-23 22:05:15 +08:00
|
|
|
.ack_interrupt = kszphy_ack_interrupt,
|
2014-11-19 19:59:22 +08:00
|
|
|
.config_intr = kszphy_config_intr,
|
2015-12-30 23:28:27 +08:00
|
|
|
.get_sset_count = kszphy_get_sset_count,
|
|
|
|
.get_strings = kszphy_get_strings,
|
|
|
|
.get_stats = kszphy_get_stats,
|
2013-09-20 01:40:48 +08:00
|
|
|
.suspend = genphy_suspend,
|
2016-08-23 04:57:16 +08:00
|
|
|
.resume = kszphy_resume,
|
2012-11-21 13:38:07 +08:00
|
|
|
}, {
|
|
|
|
.phy_id = PHY_ID_KSZ8873MLL,
|
2016-05-12 04:02:05 +08:00
|
|
|
.phy_id_mask = MICREL_PHY_ID_MASK,
|
2012-11-21 13:38:07 +08:00
|
|
|
.name = "Micrel KSZ8873MLL Switch",
|
|
|
|
.config_init = kszphy_config_init,
|
|
|
|
.config_aneg = ksz8873mll_config_aneg,
|
|
|
|
.read_status = ksz8873mll_read_status,
|
2013-09-20 01:40:48 +08:00
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2013-01-23 22:05:15 +08:00
|
|
|
}, {
|
|
|
|
.phy_id = PHY_ID_KSZ886X,
|
2016-05-12 04:02:05 +08:00
|
|
|
.phy_id_mask = MICREL_PHY_ID_MASK,
|
2013-01-23 22:05:15 +08:00
|
|
|
.name = "Micrel KSZ886X Switch",
|
net: phy: phy drivers should not set SUPPORTED_[Asym_]Pause
Instead of having individual PHY drivers set the SUPPORTED_Pause and
SUPPORTED_Asym_Pause flags, phylib itself should set those flags,
unless there is a hardware erratum or other special case. During
autonegotiation, the PHYs will determine whether to enable pause
frame support.
Pause frames are a feature that is supported by the MAC. It is the MAC
that generates the frames and that processes them. The PHY can only be
configured to allow them to pass through.
This commit also effectively reverts the recently applied c7a61319
("net: phy: dp83848: Support ethernet pause frames").
So the new process is:
1) Unless the PHY driver overrides it, phylib sets the SUPPORTED_Pause
and SUPPORTED_AsymPause bits in phydev->supported. This indicates that
the PHY supports pause frames.
2) The MAC driver checks phydev->supported before it calls phy_start().
If (SUPPORTED_Pause | SUPPORTED_AsymPause) is set, then the MAC driver
sets those bits in phydev->advertising, if it wants to enable pause
frame support.
3) When the link state changes, the MAC driver checks phydev->pause and
phydev->asym_pause, If the bits are set, then it enables the corresponding
features in the MAC. The algorithm is:
if (phydev->pause)
The MAC should be programmed to receive and honor
pause frames it receives, i.e. enable receive flow control.
if (phydev->pause != phydev->asym_pause)
The MAC should be programmed to transmit pause
frames when needed, i.e. enable transmit flow control.
Signed-off-by: Timur Tabi <timur@codeaurora.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-12-08 03:20:51 +08:00
|
|
|
.features = PHY_BASIC_FEATURES,
|
2017-05-17 00:29:11 +08:00
|
|
|
.flags = PHY_HAS_INTERRUPT,
|
2013-01-23 22:05:15 +08:00
|
|
|
.config_init = kszphy_config_init,
|
2013-09-20 01:40:48 +08:00
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2017-01-27 15:46:23 +08:00
|
|
|
}, {
|
|
|
|
.phy_id = PHY_ID_KSZ8795,
|
|
|
|
.phy_id_mask = MICREL_PHY_ID_MASK,
|
|
|
|
.name = "Micrel KSZ8795",
|
2017-01-28 04:39:03 +08:00
|
|
|
.features = PHY_BASIC_FEATURES,
|
2017-05-17 00:29:11 +08:00
|
|
|
.flags = PHY_HAS_INTERRUPT,
|
2017-01-27 15:46:23 +08:00
|
|
|
.config_init = kszphy_config_init,
|
|
|
|
.config_aneg = ksz8873mll_config_aneg,
|
|
|
|
.read_status = ksz8873mll_read_status,
|
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2017-06-01 04:19:13 +08:00
|
|
|
}, {
|
|
|
|
.phy_id = PHY_ID_KSZ9477,
|
|
|
|
.phy_id_mask = MICREL_PHY_ID_MASK,
|
|
|
|
.name = "Microchip KSZ9477",
|
|
|
|
.features = PHY_GBIT_FEATURES,
|
|
|
|
.config_init = kszphy_config_init,
|
|
|
|
.suspend = genphy_suspend,
|
|
|
|
.resume = genphy_resume,
|
2012-07-04 13:44:34 +08:00
|
|
|
} };
|
2010-04-29 14:12:41 +08:00
|
|
|
|
2014-11-12 02:45:59 +08:00
|
|
|
module_phy_driver(ksphy_driver);
|
2010-04-29 14:12:41 +08:00
|
|
|
|
|
|
|
MODULE_DESCRIPTION("Micrel PHY driver");
|
|
|
|
MODULE_AUTHOR("David J. Choi");
|
|
|
|
MODULE_LICENSE("GPL");
|
2010-05-04 06:48:29 +08:00
|
|
|
|
2010-10-04 07:43:32 +08:00
|
|
|
static struct mdio_device_id __maybe_unused micrel_tbl[] = {
|
2012-06-18 06:52:09 +08:00
|
|
|
{ PHY_ID_KSZ9021, 0x000ffffe },
|
2016-05-12 04:02:05 +08:00
|
|
|
{ PHY_ID_KSZ9031, MICREL_PHY_ID_MASK },
|
2016-07-29 18:12:08 +08:00
|
|
|
{ PHY_ID_KSZ8001, 0x00fffffc },
|
2016-05-12 04:02:05 +08:00
|
|
|
{ PHY_ID_KS8737, MICREL_PHY_ID_MASK },
|
2012-09-24 00:58:49 +08:00
|
|
|
{ PHY_ID_KSZ8021, 0x00ffffff },
|
2013-03-11 06:50:02 +08:00
|
|
|
{ PHY_ID_KSZ8031, 0x00ffffff },
|
2016-05-12 04:02:05 +08:00
|
|
|
{ PHY_ID_KSZ8041, MICREL_PHY_ID_MASK },
|
|
|
|
{ PHY_ID_KSZ8051, MICREL_PHY_ID_MASK },
|
|
|
|
{ PHY_ID_KSZ8061, MICREL_PHY_ID_MASK },
|
|
|
|
{ PHY_ID_KSZ8081, MICREL_PHY_ID_MASK },
|
|
|
|
{ PHY_ID_KSZ8873MLL, MICREL_PHY_ID_MASK },
|
|
|
|
{ PHY_ID_KSZ886X, MICREL_PHY_ID_MASK },
|
2010-05-04 06:48:29 +08:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(mdio, micrel_tbl);
|