LXR uboot/drivers/net/phy/micrel.c

   1/*
   2 * Micrel PHY drivers
   3 *
   4 * SPDX-License-Identifier:     GPL-2.0+
   5 *
   6 * Copyright 2010-2011 Freescale Semiconductor, Inc.
   7 * author Andy Fleming
   8 * (C) 2012 NetModule AG, David Andrey, added KSZ9031
   9 */
  10#include <config.h>
  11#include <common.h>
  12#include <dm.h>
  13#include <errno.h>
  14#include <fdtdec.h>
  15#include <micrel.h>
  16#include <phy.h>
  17
  18DECLARE_GLOBAL_DATA_PTR;
  19
  20static struct phy_driver KSZ804_driver = {
  21        .name = "Micrel KSZ804",
  22        .uid = 0x221510,
  23        .mask = 0xfffff0,
  24        .features = PHY_BASIC_FEATURES,
  25        .config = &genphy_config,
  26        .startup = &genphy_startup,
  27        .shutdown = &genphy_shutdown,
  28};
  29
  30#define MII_KSZPHY_OMSO         0x16
  31#define KSZPHY_OMSO_B_CAST_OFF  (1 << 9)
  32
  33static int ksz_genconfig_bcastoff(struct phy_device *phydev)
  34{
  35        int ret;
  36
  37        ret = phy_read(phydev, MDIO_DEVAD_NONE, MII_KSZPHY_OMSO);
  38        if (ret < 0)
  39                return ret;
  40
  41        ret = phy_write(phydev, MDIO_DEVAD_NONE, MII_KSZPHY_OMSO,
  42                        ret | KSZPHY_OMSO_B_CAST_OFF);
  43        if (ret < 0)
  44                return ret;
  45
  46        return genphy_config(phydev);
  47}
  48
  49static struct phy_driver KSZ8031_driver = {
  50        .name = "Micrel KSZ8021/KSZ8031",
  51        .uid = 0x221550,
  52        .mask = 0xfffff0,
  53        .features = PHY_BASIC_FEATURES,
  54        .config = &ksz_genconfig_bcastoff,
  55        .startup = &genphy_startup,
  56        .shutdown = &genphy_shutdown,
  57};
  58
  59/**
  60 * KSZ8051
  61 */
  62#define MII_KSZ8051_PHY_OMSO                    0x16
  63#define MII_KSZ8051_PHY_OMSO_NAND_TREE_ON       (1 << 5)
  64
  65static int ksz8051_config(struct phy_device *phydev)
  66{
  67        unsigned val;
  68
  69        /* Disable NAND-tree */
  70        val = phy_read(phydev, MDIO_DEVAD_NONE, MII_KSZ8051_PHY_OMSO);
  71        val &= ~MII_KSZ8051_PHY_OMSO_NAND_TREE_ON;
  72        phy_write(phydev, MDIO_DEVAD_NONE, MII_KSZ8051_PHY_OMSO, val);
  73
  74        return genphy_config(phydev);
  75}
  76
  77static struct phy_driver KSZ8051_driver = {
  78        .name = "Micrel KSZ8051",
  79        .uid = 0x221550,
  80        .mask = 0xfffff0,
  81        .features = PHY_BASIC_FEATURES,
  82        .config = &ksz8051_config,
  83        .startup = &genphy_startup,
  84        .shutdown = &genphy_shutdown,
  85};
  86
  87static struct phy_driver KSZ8081_driver = {
  88        .name = "Micrel KSZ8081",
  89        .uid = 0x221560,
  90        .mask = 0xfffff0,
  91        .features = PHY_BASIC_FEATURES,
  92        .config = &ksz_genconfig_bcastoff,
  93        .startup = &genphy_startup,
  94        .shutdown = &genphy_shutdown,
  95};
  96
  97/**
  98 * KSZ8895
  99 */
 100
 101static unsigned short smireg_to_phy(unsigned short reg)
 102{
 103        return ((reg & 0xc0) >> 3) + 0x06 + ((reg & 0x20) >> 5);
 104}
 105
 106static unsigned short smireg_to_reg(unsigned short reg)
 107{
 108        return reg & 0x1F;
 109}
 110
 111static void ksz8895_write_smireg(struct phy_device *phydev, int smireg, int val)
 112{
 113        phydev->bus->write(phydev->bus, smireg_to_phy(smireg), MDIO_DEVAD_NONE,
 114                                                smireg_to_reg(smireg), val);
 115}
 116
 117#if 0
 118static int ksz8895_read_smireg(struct phy_device *phydev, int smireg)
 119{
 120        return phydev->bus->read(phydev->bus, smireg_to_phy(smireg),
 121                                        MDIO_DEVAD_NONE, smireg_to_reg(smireg));
 122}
 123#endif
 124
 125int ksz8895_config(struct phy_device *phydev)
 126{
 127        /* we are connected directly to the switch without
 128         * dedicated PHY. SCONF1 == 001 */
 129        phydev->link = 1;
 130        phydev->duplex = DUPLEX_FULL;
 131        phydev->speed = SPEED_100;
 132
 133        /* Force the switch to start */
 134        ksz8895_write_smireg(phydev, 1, 1);
 135
 136        return 0;
 137}
 138
 139static int ksz8895_startup(struct phy_device *phydev)
 140{
 141        return 0;
 142}
 143
 144static struct phy_driver ksz8895_driver = {
 145        .name = "Micrel KSZ8895/KSZ8864",
 146        .uid  = 0x221450,
 147        .mask = 0xffffe1,
 148        .features = PHY_BASIC_FEATURES,
 149        .config   = &ksz8895_config,
 150        .startup  = &ksz8895_startup,
 151        .shutdown = &genphy_shutdown,
 152};
 153
 154#ifndef CONFIG_PHY_MICREL_KSZ9021
 155/*
 156 * I can't believe Micrel used the exact same part number
 157 * for the KSZ9021. Shame Micrel, Shame!
 158 */
 159static struct phy_driver KS8721_driver = {
 160        .name = "Micrel KS8721BL",
 161        .uid = 0x221610,
 162        .mask = 0xfffff0,
 163        .features = PHY_BASIC_FEATURES,
 164        .config = &genphy_config,
 165        .startup = &genphy_startup,
 166        .shutdown = &genphy_shutdown,
 167};
 168#endif
 169
 170
 171/*
 172 * KSZ9021 - KSZ9031 common
 173 */
 174
 175#define MII_KSZ90xx_PHY_CTL             0x1f
 176#define MIIM_KSZ90xx_PHYCTL_1000        (1 << 6)
 177#define MIIM_KSZ90xx_PHYCTL_100         (1 << 5)
 178#define MIIM_KSZ90xx_PHYCTL_10          (1 << 4)
 179#define MIIM_KSZ90xx_PHYCTL_DUPLEX      (1 << 3)
 180
 181static int ksz90xx_startup(struct phy_device *phydev)
 182{
 183        unsigned phy_ctl;
 184        int ret;
 185
 186        ret = genphy_update_link(phydev);
 187        if (ret)
 188                return ret;
 189
 190        phy_ctl = phy_read(phydev, MDIO_DEVAD_NONE, MII_KSZ90xx_PHY_CTL);
 191
 192        if (phy_ctl & MIIM_KSZ90xx_PHYCTL_DUPLEX)
 193                phydev->duplex = DUPLEX_FULL;
 194        else
 195                phydev->duplex = DUPLEX_HALF;
 196
 197        if (phy_ctl & MIIM_KSZ90xx_PHYCTL_1000)
 198                phydev->speed = SPEED_1000;
 199        else if (phy_ctl & MIIM_KSZ90xx_PHYCTL_100)
 200                phydev->speed = SPEED_100;
 201        else if (phy_ctl & MIIM_KSZ90xx_PHYCTL_10)
 202                phydev->speed = SPEED_10;
 203        return 0;
 204}
 205
 206/* Common OF config bits for KSZ9021 and KSZ9031 */
 207#if defined(CONFIG_PHY_MICREL_KSZ9021) || defined(CONFIG_PHY_MICREL_KSZ9031)
 208#ifdef CONFIG_DM_ETH
 209struct ksz90x1_reg_field {
 210        const char      *name;
 211        const u8        size;   /* Size of the bitfield, in bits */
 212        const u8        off;    /* Offset from bit 0 */
 213        const u8        dflt;   /* Default value */
 214};
 215
 216struct ksz90x1_ofcfg {
 217        const u16                       reg;
 218        const u16                       devad;
 219        const struct ksz90x1_reg_field  *grp;
 220        const u16                       grpsz;
 221};
 222
 223static const struct ksz90x1_reg_field ksz90x1_rxd_grp[] = {
 224        { "rxd0-skew-ps", 4, 0, 0x7 }, { "rxd1-skew-ps", 4, 4, 0x7 },
 225        { "rxd2-skew-ps", 4, 8, 0x7 }, { "rxd3-skew-ps", 4, 12, 0x7 }
 226};
 227
 228static const struct ksz90x1_reg_field ksz90x1_txd_grp[] = {
 229        { "txd0-skew-ps", 4, 0, 0x7 }, { "txd1-skew-ps", 4, 4, 0x7 },
 230        { "txd2-skew-ps", 4, 8, 0x7 }, { "txd3-skew-ps", 4, 12, 0x7 },
 231};
 232
 233static int ksz90x1_of_config_group(struct phy_device *phydev,
 234                                   struct ksz90x1_ofcfg *ofcfg)
 235{
 236        struct udevice *dev = phydev->dev;
 237        struct phy_driver *drv = phydev->drv;
 238        const int ps_to_regval = 60;
 239        int val[4];
 240        int i, changed = 0, offset, max;
 241        u16 regval = 0;
 242
 243        if (!drv || !drv->writeext)
 244                return -EOPNOTSUPP;
 245
 246        for (i = 0; i < ofcfg->grpsz; i++) {
 247                val[i] = fdtdec_get_uint(gd->fdt_blob, dev_of_offset(dev),
 248                                         ofcfg->grp[i].name, -1);
 249                offset = ofcfg->grp[i].off;
 250                if (val[i] == -1) {
 251                        /* Default register value for KSZ9021 */
 252                        regval |= ofcfg->grp[i].dflt << offset;
 253                } else {
 254                        changed = 1;    /* Value was changed in OF */
 255                        /* Calculate the register value and fix corner cases */
 256                        if (val[i] > ps_to_regval * 0xf) {
 257                                max = (1 << ofcfg->grp[i].size) - 1;
 258                                regval |= max << offset;
 259                        } else {
 260                                regval |= (val[i] / ps_to_regval) << offset;
 261                        }
 262                }
 263        }
 264
 265        if (!changed)
 266                return 0;
 267
 268        return drv->writeext(phydev, 0, ofcfg->devad, ofcfg->reg, regval);
 269}
 270#endif
 271#endif
 272
 273#ifdef CONFIG_PHY_MICREL_KSZ9021
 274/*
 275 * KSZ9021
 276 */
 277
 278/* PHY Registers */
 279#define MII_KSZ9021_EXTENDED_CTRL       0x0b
 280#define MII_KSZ9021_EXTENDED_DATAW      0x0c
 281#define MII_KSZ9021_EXTENDED_DATAR      0x0d
 282
 283#define CTRL1000_PREFER_MASTER          (1 << 10)
 284#define CTRL1000_CONFIG_MASTER          (1 << 11)
 285#define CTRL1000_MANUAL_CONFIG          (1 << 12)
 286
 287#if defined(CONFIG_DM_ETH) && (defined(CONFIG_PHY_MICREL_KSZ9021) || \
 288                               defined(CONFIG_PHY_MICREL_KSZ9031))
 289static const struct ksz90x1_reg_field ksz9021_clk_grp[] = {
 290        { "txen-skew-ps", 4, 0, 0x7 }, { "txc-skew-ps", 4, 4, 0x7 },
 291        { "rxdv-skew-ps", 4, 8, 0x7 }, { "rxc-skew-ps", 4, 12, 0x7 },
 292};
 293
 294static int ksz9021_of_config(struct phy_device *phydev)
 295{
 296        struct ksz90x1_ofcfg ofcfg[] = {
 297                { MII_KSZ9021_EXT_RGMII_RX_DATA_SKEW, 0, ksz90x1_rxd_grp, 4 },
 298                { MII_KSZ9021_EXT_RGMII_TX_DATA_SKEW, 0, ksz90x1_txd_grp, 4 },
 299                { MII_KSZ9021_EXT_RGMII_CLOCK_SKEW, 0, ksz9021_clk_grp, 4 },
 300        };
 301        int i, ret = 0;
 302
 303        for (i = 0; i < ARRAY_SIZE(ofcfg); i++) {
 304                ret = ksz90x1_of_config_group(phydev, &(ofcfg[i]));
 305                if (ret)
 306                        return ret;
 307        }
 308
 309        return 0;
 310}
 311#else
 312static int ksz9021_of_config(struct phy_device *phydev)
 313{
 314        return 0;
 315}
 316#endif
 317
 318int ksz9021_phy_extended_write(struct phy_device *phydev, int regnum, u16 val)
 319{
 320        /* extended registers */
 321        phy_write(phydev, MDIO_DEVAD_NONE,
 322                MII_KSZ9021_EXTENDED_CTRL, regnum | 0x8000);
 323        return phy_write(phydev, MDIO_DEVAD_NONE,
 324                MII_KSZ9021_EXTENDED_DATAW, val);
 325}
 326
 327int ksz9021_phy_extended_read(struct phy_device *phydev, int regnum)
 328{
 329        /* extended registers */
 330        phy_write(phydev, MDIO_DEVAD_NONE, MII_KSZ9021_EXTENDED_CTRL, regnum);
 331        return phy_read(phydev, MDIO_DEVAD_NONE, MII_KSZ9021_EXTENDED_DATAR);
 332}
 333
 334
 335static int ksz9021_phy_extread(struct phy_device *phydev, int addr, int devaddr,
 336                              int regnum)
 337{
 338        return ksz9021_phy_extended_read(phydev, regnum);
 339}
 340
 341static int ksz9021_phy_extwrite(struct phy_device *phydev, int addr,
 342                               int devaddr, int regnum, u16 val)
 343{
 344        return ksz9021_phy_extended_write(phydev, regnum, val);
 345}
 346
 347/* Micrel ksz9021 */
 348static int ksz9021_config(struct phy_device *phydev)
 349{
 350        unsigned ctrl1000 = 0;
 351        const unsigned master = CTRL1000_PREFER_MASTER |
 352                        CTRL1000_CONFIG_MASTER | CTRL1000_MANUAL_CONFIG;
 353        unsigned features = phydev->drv->features;
 354        int ret;
 355
 356        ret = ksz9021_of_config(phydev);
 357        if (ret)
 358                return ret;
 359
 360        if (getenv("disable_giga"))
 361                features &= ~(SUPPORTED_1000baseT_Half |
 362                                SUPPORTED_1000baseT_Full);
 363        /* force master mode for 1000BaseT due to chip errata */
 364        if (features & SUPPORTED_1000baseT_Half)
 365                ctrl1000 |= ADVERTISE_1000HALF | master;
 366        if (features & SUPPORTED_1000baseT_Full)
 367                ctrl1000 |= ADVERTISE_1000FULL | master;
 368        phydev->advertising = phydev->supported = features;
 369        phy_write(phydev, MDIO_DEVAD_NONE, MII_CTRL1000, ctrl1000);
 370        genphy_config_aneg(phydev);
 371        genphy_restart_aneg(phydev);
 372        return 0;
 373}
 374
 375static struct phy_driver ksz9021_driver = {
 376        .name = "Micrel ksz9021",
 377        .uid  = 0x221610,
 378        .mask = 0xfffff0,
 379        .features = PHY_GBIT_FEATURES,
 380        .config = &ksz9021_config,
 381        .startup = &ksz90xx_startup,
 382        .shutdown = &genphy_shutdown,
 383        .writeext = &ksz9021_phy_extwrite,
 384        .readext = &ksz9021_phy_extread,
 385};
 386#endif
 387
 388/**
 389 * KSZ9031
 390 */
 391/* PHY Registers */
 392#define MII_KSZ9031_MMD_ACCES_CTRL      0x0d
 393#define MII_KSZ9031_MMD_REG_DATA        0x0e
 394
 395#if defined(CONFIG_DM_ETH) && (defined(CONFIG_PHY_MICREL_KSZ9021) || \
 396                               defined(CONFIG_PHY_MICREL_KSZ9031))
 397static const struct ksz90x1_reg_field ksz9031_ctl_grp[] =
 398        { { "txen-skew-ps", 4, 0, 0x7 }, { "rxdv-skew-ps", 4, 4, 0x7 } };
 399static const struct ksz90x1_reg_field ksz9031_clk_grp[] =
 400        { { "rxc-skew-ps", 5, 0, 0xf }, { "txc-skew-ps", 5, 5, 0xf } };
 401
 402static int ksz9031_of_config(struct phy_device *phydev)
 403{
 404        struct ksz90x1_ofcfg ofcfg[] = {
 405                { MII_KSZ9031_EXT_RGMII_CTRL_SIG_SKEW, 2, ksz9031_ctl_grp, 2 },
 406                { MII_KSZ9031_EXT_RGMII_RX_DATA_SKEW, 2, ksz90x1_rxd_grp, 4 },
 407                { MII_KSZ9031_EXT_RGMII_TX_DATA_SKEW, 2, ksz90x1_txd_grp, 4 },
 408                { MII_KSZ9031_EXT_RGMII_CLOCK_SKEW, 2, ksz9031_clk_grp, 2 },
 409        };
 410        int i, ret = 0;
 411
 412        for (i = 0; i < ARRAY_SIZE(ofcfg); i++) {
 413                ret = ksz90x1_of_config_group(phydev, &(ofcfg[i]));
 414                if (ret)
 415                        return ret;
 416        }
 417
 418        return 0;
 419}
 420
 421static int ksz9031_center_flp_timing(struct phy_device *phydev)
 422{
 423        struct phy_driver *drv = phydev->drv;
 424        int ret = 0;
 425
 426        if (!drv || !drv->writeext)
 427                return -EOPNOTSUPP;
 428
 429        ret = drv->writeext(phydev, 0, 0, MII_KSZ9031_FLP_BURST_TX_LO, 0x1A80);
 430        if (ret)
 431                return ret;
 432
 433        ret = drv->writeext(phydev, 0, 0, MII_KSZ9031_FLP_BURST_TX_HI, 0x6);
 434        return ret;
 435}
 436#else
 437static int ksz9031_of_config(struct phy_device *phydev)
 438{
 439        return 0;
 440}
 441static int ksz9031_center_flp_timing(struct phy_device *phydev)
 442{
 443        return 0;
 444}
 445#endif
 446
 447/* Accessors to extended registers*/
 448int ksz9031_phy_extended_write(struct phy_device *phydev,
 449                               int devaddr, int regnum, u16 mode, u16 val)
 450{
 451        /*select register addr for mmd*/
 452        phy_write(phydev, MDIO_DEVAD_NONE,
 453                  MII_KSZ9031_MMD_ACCES_CTRL, devaddr);
 454        /*select register for mmd*/
 455        phy_write(phydev, MDIO_DEVAD_NONE,
 456                  MII_KSZ9031_MMD_REG_DATA, regnum);
 457        /*setup mode*/
 458        phy_write(phydev, MDIO_DEVAD_NONE,
 459                  MII_KSZ9031_MMD_ACCES_CTRL, (mode | devaddr));
 460        /*write the value*/
 461        return  phy_write(phydev, MDIO_DEVAD_NONE,
 462                MII_KSZ9031_MMD_REG_DATA, val);
 463}
 464
 465int ksz9031_phy_extended_read(struct phy_device *phydev, int devaddr,
 466                              int regnum, u16 mode)
 467{
 468        phy_write(phydev, MDIO_DEVAD_NONE,
 469                  MII_KSZ9031_MMD_ACCES_CTRL, devaddr);
 470        phy_write(phydev, MDIO_DEVAD_NONE,
 471                  MII_KSZ9031_MMD_REG_DATA, regnum);
 472        phy_write(phydev, MDIO_DEVAD_NONE,
 473                  MII_KSZ9031_MMD_ACCES_CTRL, (devaddr | mode));
 474        return phy_read(phydev, MDIO_DEVAD_NONE, MII_KSZ9031_MMD_REG_DATA);
 475}
 476
 477static int ksz9031_phy_extread(struct phy_device *phydev, int addr, int devaddr,
 478                               int regnum)
 479{
 480        return ksz9031_phy_extended_read(phydev, devaddr, regnum,
 481                                         MII_KSZ9031_MOD_DATA_NO_POST_INC);
 482};
 483
 484static int ksz9031_phy_extwrite(struct phy_device *phydev, int addr,
 485                                int devaddr, int regnum, u16 val)
 486{
 487        return ksz9031_phy_extended_write(phydev, devaddr, regnum,
 488                                         MII_KSZ9031_MOD_DATA_POST_INC_RW, val);
 489};
 490
 491static int ksz9031_config(struct phy_device *phydev)
 492{
 493        int ret;
 494        ret = ksz9031_of_config(phydev);
 495        if (ret)
 496                return ret;
 497        ret = ksz9031_center_flp_timing(phydev);
 498        if (ret)
 499                return ret;
 500        return genphy_config(phydev);
 501}
 502
 503static struct phy_driver ksz9031_driver = {
 504        .name = "Micrel ksz9031",
 505        .uid  = 0x221620,
 506        .mask = 0xfffff0,
 507        .features = PHY_GBIT_FEATURES,
 508        .config   = &ksz9031_config,
 509        .startup  = &ksz90xx_startup,
 510        .shutdown = &genphy_shutdown,
 511        .writeext = &ksz9031_phy_extwrite,
 512        .readext = &ksz9031_phy_extread,
 513};
 514
 515int ksz886x_config(struct phy_device *phydev)
 516{
 517        /* we are connected directly to the switch without
 518         * dedicated PHY. */
 519        phydev->link = 1;
 520        phydev->duplex = DUPLEX_FULL;
 521        phydev->speed = SPEED_100;
 522        return 0;
 523}
 524
 525static int ksz886x_startup(struct phy_device *phydev)
 526{
 527        return 0;
 528}
 529
 530static struct phy_driver ksz886x_driver = {
 531        .name = "Micrel KSZ886x Switch",
 532        .uid  = 0x00221430,
 533        .mask = 0xfffff0,
 534        .features = PHY_BASIC_FEATURES,
 535        .config = &ksz886x_config,
 536        .startup = &ksz886x_startup,
 537        .shutdown = &genphy_shutdown,
 538};
 539
 540int phy_micrel_init(void)
 541{
 542        phy_register(&KSZ804_driver);
 543        phy_register(&KSZ8031_driver);
 544        phy_register(&KSZ8051_driver);
 545        phy_register(&KSZ8081_driver);
 546#ifdef CONFIG_PHY_MICREL_KSZ9021
 547        phy_register(&ksz9021_driver);
 548#else
 549        phy_register(&KS8721_driver);
 550#endif
 551        phy_register(&ksz9031_driver);
 552        phy_register(&ksz8895_driver);
 553        phy_register(&ksz886x_driver);
 554        return 0;
 555}
 556