phy.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2021 IP-Logix Inc.
 * Copyright 2022 NXP
 * Copyright (c) 2025 Aerlync Labs Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_DRIVERS_PHY_H_
#define ZEPHYR_INCLUDE_DRIVERS_PHY_H_

#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/sys/util_macro.h>
#include <errno.h>
 
#ifdef __cplusplus
extern "C" {
#endif

enum phy_link_speed {
        LINK_HALF_10BASE = BIT(0),
        LINK_FULL_10BASE = BIT(1),
        LINK_HALF_100BASE = BIT(2),
        LINK_FULL_100BASE = BIT(3),
        LINK_HALF_1000BASE = BIT(4),
        LINK_FULL_1000BASE = BIT(5),
        LINK_FULL_2500BASE = BIT(6),
        LINK_FULL_5000BASE = BIT(7),
};

#define PHY_LINK_IS_FULL_DUPLEX(x)                                                                 \
        (x & (LINK_FULL_10BASE | LINK_FULL_100BASE | LINK_FULL_1000BASE | LINK_FULL_2500BASE |     \
              LINK_FULL_5000BASE))

#define PHY_LINK_IS_SPEED_1000M(x) (x & (LINK_HALF_1000BASE | LINK_FULL_1000BASE))

#define PHY_LINK_IS_SPEED_100M(x) (x & (LINK_HALF_100BASE | LINK_FULL_100BASE))

#define PHY_LINK_IS_SPEED_10M(x) (x & (LINK_HALF_10BASE | LINK_FULL_10BASE))

struct phy_link_state {
        enum phy_link_speed speed;
        bool is_up;
};

enum phy_cfg_link_flag {
        PHY_FLAG_AUTO_NEGOTIATION_DISABLED = BIT(0),
};

struct phy_plca_cfg {
        uint8_t version;
        bool enable;
        uint8_t node_id;
        uint8_t node_count;
        uint8_t burst_count;
        uint8_t burst_timer;
        uint8_t to_timer;
};

typedef void (*phy_callback_t)(const struct device *dev, struct phy_link_state *state,
                               void *user_data);


__subsystem struct ethphy_driver_api {
        int (*get_link)(const struct device *dev, struct phy_link_state *state);

        int (*cfg_link)(const struct device *dev, enum phy_link_speed adv_speeds,
                        enum phy_cfg_link_flag flags);

        int (*link_cb_set)(const struct device *dev, phy_callback_t cb, void *user_data);

        int (*read)(const struct device *dev, uint16_t reg_addr, uint32_t *data);

        int (*write)(const struct device *dev, uint16_t reg_addr, uint32_t data);

        int (*read_c45)(const struct device *dev, uint8_t devad, uint16_t regad, uint16_t *data);

        int (*write_c45)(const struct device *dev, uint8_t devad, uint16_t regad, uint16_t data);
 
#if defined(CONFIG_ETH_PHY_API_PLCA) || defined(__DOXYGEN__)
        int (*set_plca_cfg)(const struct device *dev, struct phy_plca_cfg *plca_cfg);

        int (*get_plca_cfg)(const struct device *dev, struct phy_plca_cfg *plca_cfg);

        int (*get_plca_sts)(const struct device *dev, bool *plca_sts);
#endif /* CONFIG_ETH_PHY_API_PLCA */
};


static inline int phy_configure_link(const struct device *dev, enum phy_link_speed speeds,
                                     enum phy_cfg_link_flag flags)
{
        if (DEVICE_API_GET(ethphy, dev)->cfg_link == NULL) {
                return -ENOSYS;
        }
 
        /* Check if only one speed is set, when auto-negotiation is disabled */
        if ((flags & PHY_FLAG_AUTO_NEGOTIATION_DISABLED) && !IS_POWER_OF_TWO(speeds)) {
                return -EINVAL;
        }
 
        return DEVICE_API_GET(ethphy, dev)->cfg_link(dev, speeds, flags);
}

static inline int phy_get_link_state(const struct device *dev, struct phy_link_state *state)
{
        if (DEVICE_API_GET(ethphy, dev)->get_link == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(ethphy, dev)->get_link(dev, state);
}

static inline int phy_link_callback_set(const struct device *dev, phy_callback_t callback,
                                        void *user_data)
{
        if (DEVICE_API_GET(ethphy, dev)->link_cb_set == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(ethphy, dev)->link_cb_set(dev, callback, user_data);
}

static inline int phy_read(const struct device *dev, uint16_t reg_addr, uint32_t *value)
{
        if (DEVICE_API_GET(ethphy, dev)->read == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(ethphy, dev)->read(dev, reg_addr, value);
}

static inline int phy_write(const struct device *dev, uint16_t reg_addr, uint32_t value)
{
        if (DEVICE_API_GET(ethphy, dev)->write == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(ethphy, dev)->write(dev, reg_addr, value);
}

static inline int phy_read_c45(const struct device *dev, uint8_t devad, uint16_t regad,
                               uint16_t *data)
{
        if (DEVICE_API_GET(ethphy, dev)->read_c45 == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(ethphy, dev)->read_c45(dev, devad, regad, data);
}

static inline int phy_write_c45(const struct device *dev, uint8_t devad, uint16_t regad,
                                uint16_t data)
{
        if (DEVICE_API_GET(ethphy, dev)->write_c45 == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(ethphy, dev)->write_c45(dev, devad, regad, data);
}

static inline int phy_set_plca_cfg(__maybe_unused const struct device *dev,
                                   __maybe_unused struct phy_plca_cfg *plca_cfg)
{
#if defined(CONFIG_ETH_PHY_API_PLCA)
        if (DEVICE_API_GET(ethphy, dev)->set_plca_cfg == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(ethphy, dev)->set_plca_cfg(dev, plca_cfg);
#else
        return -ENOSYS;
#endif /* CONFIG_ETH_PHY_API_PLCA */
}

static inline int phy_get_plca_cfg(__maybe_unused const struct device *dev,
                                   __maybe_unused struct phy_plca_cfg *plca_cfg)
{
#if defined(CONFIG_ETH_PHY_API_PLCA)
        if (DEVICE_API_GET(ethphy, dev)->get_plca_cfg == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(ethphy, dev)->get_plca_cfg(dev, plca_cfg);
#else
        return -ENOSYS;
#endif /* CONFIG_ETH_PHY_API_PLCA */
}

static inline int phy_get_plca_sts(__maybe_unused const struct device *dev,
                                   __maybe_unused bool *plca_status)
{
#if defined(CONFIG_ETH_PHY_API_PLCA)
        if (DEVICE_API_GET(ethphy, dev)->get_plca_sts == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(ethphy, dev)->get_plca_sts(dev, plca_status);
#else
        return -ENOSYS;
#endif /* CONFIG_ETH_PHY_API_PLCA */
}
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_DRIVERS_PHY_H_ */