Changeset 9da83e7 in rtems-libbsd


Ignore:
Timestamp:
May 24, 2017, 6:32:09 AM (2 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
7ece7548c1b05cf6bb10e6708b83b2401d45c250, 29cc431e0bcfe059d65ac3019f53eeafa5064ae8
Children:
03d1426
Parents:
66e83e0e
git-author:
Sebastian Huber <sebastian.huber@…> (05/24/17 06:32:09)
git-committer:
Sebastian Huber <sebastian.huber@…> (10/23/17 07:24:06)
Message:

dpaa: Support c45 phys

Location:
rtemsbsd
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • rtemsbsd/powerpc/include/linux/phy.h

    r66e83e0e r9da83e7  
    8181#define SUPPORTED_Pause                 (1U << 9)
    8282
     83#define MII_ADDR_C45 (1 << 30)
     84
    8385struct mdio_bus {
    84         int (*read)(struct mdio_bus *bus, int phy, int reg);
    85         int (*write)(struct mdio_bus *bus, int phy, int reg, int val);
     86        int (*read)(struct mdio_bus *bus, int addr, int reg);
     87        int (*write)(struct mdio_bus *bus, int addr, int reg, int val);
    8688        SLIST_ENTRY(mdio_bus) next;
    8789        int node;
     
    9294                struct device dev;
    9395                int addr;
     96                int is_c45;
    9497                struct mdio_bus *bus;
    9598        } mdio;
    9699};
    97100
    98 static inline int
    99 phy_read(struct phy_device *phy_dev, int reg)
    100 {
    101         struct mdio_bus *mdio_dev;
     101int phy_read(struct phy_device *phy_dev, int reg);
    102102
    103         mdio_dev = phy_dev->mdio.bus;
    104         return ((*mdio_dev->read)(mdio_dev, phy_dev->mdio.addr, (int)reg));
    105 }
    106 
    107 static inline int
    108 phy_write(struct phy_device *phy_dev, int reg, int val)
    109 {
    110         struct mdio_bus *mdio_dev;
    111 
    112         mdio_dev = phy_dev->mdio.bus;
    113         return ((*mdio_dev->write)(mdio_dev, phy_dev->mdio.addr, reg, val));
    114 }
     103int phy_write(struct phy_device *phy_dev, int reg, int val);
    115104
    116105#ifdef __cplusplus
  • rtemsbsd/sys/powerpc/fdt_phy.c

    r66e83e0e r9da83e7  
    5656};
    5757
    58 MTX_SYSINIT(mdio_mutex, &mdio.mutex, "FDT MDIO", MTX_DEF);
     58MTX_SYSINIT(mdio_mutex, &mdio.mutex, "MDIO", MTX_DEF);
     59
     60int
     61phy_read(struct phy_device *phy_dev, int reg)
     62{
     63        struct mdio_bus *mdio_dev;
     64        int val;
     65
     66        mdio_dev = phy_dev->mdio.bus;
     67        MDIO_LOCK();
     68        val = (*mdio_dev->read)(mdio_dev, phy_dev->mdio.addr,
     69            reg | phy_dev->mdio.is_c45);
     70        MDIO_UNLOCK();
     71        return (val);
     72}
     73
     74int
     75phy_write(struct phy_device *phy_dev, int reg, int val)
     76{
     77        struct mdio_bus *mdio_dev;
     78        int err;
     79
     80        mdio_dev = phy_dev->mdio.bus;
     81        MDIO_LOCK();
     82        err = (*mdio_dev->write)(mdio_dev, phy_dev->mdio.addr,
     83            reg | phy_dev->mdio.is_c45, val);
     84        MDIO_UNLOCK();
     85        return (err);
     86}
    5987
    6088static uint64_t
     
    158186
    159187static int
    160 fman_mdio_read(struct mdio_bus *base, int phy, int reg)
     188fman_mdio_setup(volatile struct fman_mdio_regs *regs, int addr, int reg,
     189    uint32_t *mdio_ctrl_p)
     190{
     191        uint32_t mdio_cfg;
     192        uint32_t mdio_ctrl;
     193        uint32_t reg_addr;
     194        int err;
     195
     196        err = fman_mdio_wait(regs);
     197        if (err != 0) {
     198                return (err);
     199        }
     200
     201        mdio_cfg = regs->mdio_cfg;
     202        if ((reg & MII_ADDR_C45) != 0) {
     203                reg_addr = (uint32_t)(reg >> 16);
     204                mdio_cfg |= MDIO_CFG_ENC45;
     205        } else {
     206                reg_addr = (uint32_t)reg;
     207                mdio_cfg &= ~MDIO_CFG_ENC45;
     208        }
     209        regs->mdio_cfg = mdio_cfg;
     210
     211        mdio_ctrl = MDIO_CTRL_PHY_ADDR(addr) | MDIO_CTRL_REG_ADDR(reg_addr);
     212        regs->mdio_ctrl = mdio_ctrl;
     213
     214        if ((reg & MII_ADDR_C45) != 0) {
     215                regs->mdio_addr = (uint32_t)(reg & 0xffff);
     216                err = fman_mdio_wait(regs);
     217                if (err != 0) {
     218                        return (err);
     219                }
     220        }
     221
     222        *mdio_ctrl_p = mdio_ctrl;
     223        return (0);
     224}
     225
     226static int
     227fman_mdio_read(struct mdio_bus *base, int addr, int reg)
    161228{
    162229        struct fman_mdio_bus *fm;
    163230        volatile struct fman_mdio_regs *regs;
     231        uint32_t mdio_ctrl;
    164232        int val;
    165233        int err;
     
    168236        regs = fm->regs;
    169237
    170         MDIO_LOCK();
     238        err = fman_mdio_setup(regs, addr, reg, &mdio_ctrl);
     239        if (err != 0) {
     240                return (-1);
     241        }
     242
     243        mdio_ctrl |= MDIO_CTRL_READ;
     244        regs->mdio_ctrl = mdio_ctrl;
    171245
    172246        err = fman_mdio_wait(regs);
    173         if (err == 0) {
    174                 uint32_t mdio_cfg;
    175                 uint32_t mdio_ctrl;
    176 
    177                 mdio_cfg = regs->mdio_cfg;
    178                 mdio_cfg &= ~MDIO_CFG_ENC45;
    179                 regs->mdio_cfg = mdio_cfg;
    180 
    181                 mdio_ctrl = MDIO_CTRL_PHY_ADDR(phy) | MDIO_CTRL_REG_ADDR(reg);
    182                 regs->mdio_ctrl = mdio_ctrl;
    183                 mdio_ctrl |= MDIO_CTRL_READ;
    184                 regs->mdio_ctrl = mdio_ctrl;
    185 
    186                 err = fman_mdio_wait(regs);
    187                 if (err == 0 && (regs->mdio_cfg & MDIO_CFG_RD_ERR) == 0) {
    188                         val = (int)(regs->mdio_data & 0xffff);
    189                 } else {
    190                         val = 0xffff;
    191                 }
     247        if (err == 0 && (regs->mdio_cfg & MDIO_CFG_RD_ERR) == 0) {
     248                val = (int)(regs->mdio_data & 0xffff);
    192249        } else {
    193                 val = 0xffff;
    194         }
    195 
    196         MDIO_UNLOCK();
     250                val = -1;
     251        }
    197252
    198253        return (val);
     
    200255
    201256static int
    202 fman_mdio_write(struct mdio_bus *base, int phy, int reg, int val)
     257fman_mdio_write(struct mdio_bus *base, int addr, int reg, int val)
    203258{
    204259        struct fman_mdio_bus *fm;
    205260        volatile struct fman_mdio_regs *regs;
     261        uint32_t mdio_ctrl;
    206262        int err;
    207263
     
    209265        regs = fm->regs;
    210266
    211         MDIO_LOCK();
    212 
    213         err = fman_mdio_wait(regs);
    214         if (err == 0) {
    215                 uint32_t mdio_cfg;
    216                 uint32_t mdio_ctrl;
    217 
    218                 mdio_cfg = regs->mdio_cfg;
    219                 mdio_cfg &= ~MDIO_CFG_ENC45;
    220                 regs->mdio_cfg = mdio_cfg;
    221 
    222                 mdio_ctrl = MDIO_CTRL_PHY_ADDR(phy) | MDIO_CTRL_REG_ADDR(reg);
    223                 regs->mdio_ctrl = mdio_ctrl;
    224 
    225                 regs->mdio_data = (uint32_t)(val & 0xffff);
    226 
    227                 fman_mdio_wait(regs);
    228         }
    229 
    230         MDIO_UNLOCK();
    231 
     267        err = fman_mdio_setup(regs, addr, reg, &mdio_ctrl);
     268        if (err != 0) {
     269                return (0);
     270        }
     271
     272        regs->mdio_data = (uint32_t)(val & 0xffff);
     273        fman_mdio_wait(regs);
    232274        return (0);
    233275}
     
    291333
    292334static struct phy_device *
    293 phy_obtain(const void *fdt, int mdio_node, int phy)
     335phy_obtain(const void *fdt, int is_c45, int mdio_node, int addr)
    294336{
    295337        struct phy_device *phy_dev;
     
    301343        }
    302344
    303         phy_dev->mdio.addr = phy;
     345        phy_dev->mdio.addr = addr;
     346        phy_dev->mdio.is_c45 = is_c45;
    304347        MDIO_LOCK();
    305348        err = find_mdio_bus(fdt, mdio_node, phy_dev);
     
    318361{
    319362        const void *fdt;
    320         const fdt32_t *phy;
     363        const fdt32_t *addr;
    321364        int len;
     365        int is_c45;
    322366        int mdio_node;
    323367
    324368        fdt = bsp_fdt_get();
    325369
    326         phy = fdt_getprop(fdt, dn->offset, "reg", &len);
    327         if (phy == NULL || len != sizeof(*phy)) {
    328                 return (NULL);
     370        addr = fdt_getprop(fdt, dn->offset, "reg", &len);
     371        if (addr == NULL || len != sizeof(*addr)) {
     372                return (NULL);
     373        }
     374
     375        if (of_device_is_compatible(dn, "ethernet-phy-ieee802.3-c45")) {
     376                is_c45 = MII_ADDR_C45;
     377        } else {
     378                is_c45 = 0;
    329379        }
    330380
     
    334384        }
    335385
    336         return (phy_obtain(fdt, mdio_node, (int)fdt32_to_cpu(*phy)));
    337 }
     386        return (phy_obtain(fdt, is_c45, mdio_node, (int)fdt32_to_cpu(*addr)));
     387}
Note: See TracChangeset for help on using the changeset viewer.