tdl-xoa-driver 1.0.0__py3-none-any.whl

xoa_driver/internals/hli_v1/ports/port_l23/pcs_pma_ghijkl.py

@@ -0,0 +1,369 @@
+from typing import (
+    TYPE_CHECKING,
+    Tuple,
+)
+from typing_extensions import Self
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    PP_ALARMS_ERRORS,
+    PP_TXLANECONFIG,
+    PP_TXLANEINJECT,
+    PP_TXPRBSCONFIG,
+    PP_TXERRORRATE,
+    PP_TXINJECTONE,
+    PP_RXTOTALSTATS,
+    PP_RXFECSTATS,
+    PP_RXLANELOCK,
+    PP_RXLANESTATUS,
+    PP_RXLANEERRORS,
+    PP_RXPRBSSTATUS,
+    PP_RXCLEAR,
+    PP_RXLASERPOWER,
+    PP_TXLASERPOWER,
+    PP_EYEMEASURE,
+    PP_EYERESOLUTION,
+    PP_EYEREAD,
+    PP_EYEINFO,
+    PP_PHYTXEQ,
+    PP_PHYRETUNE,
+    PP_PHYAUTOTUNE,
+    PP_EYEBER,
+    PP_PHYAUTONEG,
+    PP_TXPRBSTYPE,
+    PP_RXPRBSTYPE,
+    # PP_FECMODE, # moved to all genuine ports
+    PP_EYEDWELLBITS,
+    PP_PHYSIGNALSTATUS,
+    PP_PRBSTYPE,
+    PP_PHYSETTINGS,
+    PP_PHYRXEQ,
+)
+from xoa_driver import enums
+
+
+class PcsPmaAlarms:
+    """L23 high-speed port PCS/PMA alarms"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.errors = PP_ALARMS_ERRORS(conn, module_id, port_id)
+        """Error count of each alarm on a L23 high-speed port.
+
+        :type: PP_ALARMS_ERRORS
+        """
+
+
+class PcsPmaTransceiver:
+    """L23 high-speed port PCS/PMA transceivers"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.tx_laser_power = PP_TXLASERPOWER(conn, module_id, port_id)
+        """Power of TX laser.
+
+        :type: PP_TXLASERPOWER
+        """
+
+        self.rx_laser_power = PP_RXLASERPOWER(conn, module_id, port_id)
+        """Power of RX laser.
+
+        :type: PP_RXLASERPOWER
+        """
+
+
+class PcsPmaRxLaneStatus:
+    """L23 high-speed port PCS/PMA lane status"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, lane_idx: int) -> None:
+        self.errors = PP_RXLANEERRORS(conn, module_id, port_id, lane_idx)
+        """RX lane error statistics.
+
+        :type: PP_RXLANEERRORS
+        """
+
+        self.lock = PP_RXLANELOCK(conn, module_id, port_id, lane_idx)
+        """RX lane lock.
+
+        :type: PP_RXLANELOCK
+        """
+
+        self.status = PP_RXLANESTATUS(conn, module_id, port_id, lane_idx)
+        """RX lane status
+
+        :type: PP_RXLANESTATUS
+        """
+
+
+class PcsPmaTxErrorGeneration:
+    """L23 high-speed port PCS/PMA TX error generation."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.error_rate = PP_TXERRORRATE(conn, module_id, port_id)
+        """The rate of continuous bit-level error injection.
+
+        :type: PP_TXERRORRATE
+        """
+
+        self.inject_one = PP_TXINJECTONE(conn, module_id, port_id)
+        """Inject a single bit-level error.
+
+        :type: PP_TXINJECTONE
+        """
+
+
+class PcsPmaRx:
+    """L23 high-speed port PCS/PMA RX"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.total_status = PP_RXTOTALSTATS(conn, module_id, port_id)
+        """RX FEC total counters.
+
+        :type: PP_RXTOTALSTATS
+        """
+
+        self.fec_status = PP_RXFECSTATS(conn, module_id, port_id)
+        """RX FEC statistics.
+
+        :type: PP_RXFECSTATS
+        """
+
+        self.clear = PP_RXCLEAR(conn, module_id, port_id)
+        """Clear all the PCS/PMA receiver statistics.
+
+        :type: PP_RXCLEAR
+        """
+
+
+class PcsPmaPhy:
+    """L23 high-speed port PCS/PMA PHY settings."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.auto_neg = PP_PHYAUTONEG(conn, module_id, port_id)
+        """ Auto-negotiation settings of the PHY.
+
+        :type: PP_PHYAUTONEG
+        """
+
+        self.signal_status = PP_PHYSIGNALSTATUS(conn, module_id, port_id)
+        """The PHY signal status.
+
+        :type: PP_PHYSIGNALSTATUS
+        """
+
+        self.settings = PP_PHYSETTINGS(conn, module_id, port_id)
+        """Low-level PHY settings
+
+        :type: PP_PHYSETTINGS
+        """
+
+
+class Lane:
+    """L23 high-speed port lane configuration and status."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, lane_idx: int) -> None:
+        self.rx_status = PcsPmaRxLaneStatus(conn, module_id, port_id, lane_idx)
+        """PCS/PMA RX lane status.
+        """
+
+        self.tx_error_inject = PP_TXLANEINJECT(conn, module_id, port_id, lane_idx)
+        """Inject CAUI error into a TX lane.
+
+        :type: PP_TXLANEINJECT
+        """
+
+        self.tx_config = PP_TXLANECONFIG(conn, module_id, port_id, lane_idx)
+        """TX lane configuration.
+
+        :type: PP_TXLANECONFIG
+        """
+
+
+class PcsPma:
+    """L23 high-speed port PCS/PMA"""
+
+    def __init__(self, conn: "itf.IConnection", port) -> None:
+        self._conn = conn
+        self.__port = port
+
+        self.alarms = PcsPmaAlarms(conn, *port.kind)
+        """PCS/PMA alarms
+
+        :type: PcsPmaAlarms
+        """
+
+        self.transceiver = PcsPmaTransceiver(conn, *port.kind)
+        """PCS/PMA transceiver
+
+        :type: PcsPmaTransceiver
+        """
+
+        self.error_gen = PcsPmaTxErrorGeneration(conn, *port.kind)
+        """PCS/PMA error generation
+
+        :type: PcsPmaTxErrorGeneration
+        """
+
+        self.rx = PcsPmaRx(conn, *port.kind)
+        """PCS/PMA RX
+
+        :type: PcsPmaRx
+        """
+
+        self.phy = PcsPmaPhy(conn, *port.kind)
+        """PCS/PMA PHY
+
+        :type: PcsPmaPhy
+        """
+
+        self.prbs_config = PRBSConfig(conn, *port.kind)
+        """PCS/PMA PRBS Configuration
+        
+        :type: PRBSConfig
+        """
+
+        self.lanes: Tuple["Lane", ...] = tuple(
+            Lane(self._conn, *self.__port.kind, lane_idx=idx)
+            for idx in range(self.__port.info.capabilities.lane_count)
+        )  # TODO: need to fix, currently port.info.capabilities must be none because lanes are created before awaiting the port
+
+
+class PRBSConfig:
+    """L23 high-speed port PRBS configuration."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.type = PP_PRBSTYPE(conn, module_id, port_id)
+        """PRBS type used when in PRBS mode.
+
+        :type: PP_PRBSTYPE
+        """
+
+
+class SDEyeDiagram:
+    """L23 high-speed port SerDes eye diagram."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, serdes_xindex: int) -> None:
+        self.__conn = conn
+        self.__module_id = module_id
+        self.__port_id = port_id
+        self.__serdes_index = serdes_xindex
+        self.measure = PP_EYEMEASURE(conn, module_id, port_id, serdes_xindex)
+        """BER eye measurement.
+
+        :type: PP_EYEMEASURE
+        """
+
+        self.resolution = PP_EYERESOLUTION(conn, module_id, port_id, serdes_xindex)
+        """Resolution for BER eye measurement.
+
+        :type: PP_EYERESOLUTION
+        """
+
+        self.info = PP_EYEINFO(conn, module_id, port_id, serdes_xindex)
+        """Information of BER eye measurement.
+
+        :type: PP_EYEINFO
+        """
+
+        self.ber = PP_EYEBER(conn, module_id, port_id, serdes_xindex)
+        """BER estimation of an eye diagram.
+
+        :type: PP_EYEBER
+        """
+
+        self.dwell_bits = PP_EYEDWELLBITS(conn, module_id, port_id, serdes_xindex)
+        """Dwell bits for an eye capture.
+
+        :type: PP_EYEDWELLBITS
+        """
+
+    def __await__(self):
+        return self._setup().__await__()
+
+    async def _setup(self) -> Self:
+        resolution = await self.resolution.get()
+        self.read_column = tuple(
+            PP_EYEREAD(
+                self.__conn,
+                self.__module_id,
+                self.__port_id,
+                self.__serdes_index,
+                _colum_xindex=x
+            )
+            for x in range(resolution.x_resolution)
+        )
+        return self
+
+
+class SDPhy:
+    """L23 high-speed port SerDes PHY configuration and status."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, serdes_xindex: int) -> None:
+        self.tx_equalizer = PP_PHYTXEQ(conn, module_id, port_id, serdes_xindex)
+        """Equalizer settings of the on-board PHY in the TX direction.
+
+        :type: PP_PHYTXEQ
+        """
+
+        self.rx_equalizer = PP_PHYRXEQ(conn, module_id, port_id, serdes_xindex)
+        """Equalizer settings of the on-board PHY in the RX direction.
+
+        :type: PP_PHYRXEQ
+        """
+
+        self.retune = PP_PHYRETUNE(conn, module_id, port_id, serdes_xindex)
+        """Retuning of the PHY.
+
+        :type: PP_PHYRETUNE
+        """
+
+        self.autotune = PP_PHYAUTOTUNE(conn, module_id, port_id, serdes_xindex)
+        """Autotune of the PHY.
+
+        :type: PP_PHYAUTOTUNE
+        """
+
+class Prbs:
+    """L23 high-speed port SerDes PRBS configuration and status."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, serdes_xindex: int) -> None:
+        self.control = PP_TXPRBSCONFIG(conn, module_id, port_id, serdes_xindex)
+        """TX PRBS configuration of a SerDes.
+
+        :type: PP_TXPRBSCONFIG
+        """
+
+        self.status = PP_RXPRBSSTATUS(conn, module_id, port_id, serdes_xindex)
+        """RX PRBS status on a SerDes
+
+        :type: PP_RXPRBSSTATUS
+        """
+
+
+
+class SerDes:
+    """L23 high-speed port SerDes configuration and status."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, serdes_xindex: int) -> None:
+        self.prbs = Prbs(conn, module_id, port_id, serdes_xindex)
+        """PRBS configuration
+
+        :type: Prbs
+        """
+
+        self.phy = SDPhy(conn, module_id, port_id, serdes_xindex)
+        """PHY configuration
+
+        :type: SDPhy
+        """
+
+        self.eye_diagram = SDEyeDiagram(conn, module_id, port_id, serdes_xindex)
+        """Eye diagram
+
+        :type: SDEyeDiagram
+        """
+
+    def __await__(self):
+        return self._setup().__await__()
+
+    async def _setup(self) -> Self:
+        await self.eye_diagram
+        return self

xoa_driver/internals/hli_v1/ports/port_l23/pcs_pma_ijkl_chimera.py

@@ -0,0 +1,60 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    PP_LINKFLAP_PARAMS,
+    PP_LINKFLAP_ENABLE,
+    PP_PMAERRPUL_PARAMS,
+    PP_PMAERRPUL_ENABLE,
+)
+
+
+class LinkFlap:
+    """L23 high-speed port link flap."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.params = PP_LINKFLAP_PARAMS(conn, module_id, port_id)
+        """Link flap parameters.
+        
+        :type: PP_LINKFLAP_PARAMS
+        """
+
+        self.enable = PP_LINKFLAP_ENABLE(conn, module_id, port_id)
+        """Link flap control.
+        
+        :type: PP_LINKFLAP_ENABLE
+        """
+
+
+class PmaPulseErrInj:
+    """L23 high-speed port PMA pulse error injection."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.params = PP_PMAERRPUL_PARAMS(conn, module_id, port_id)
+        """PMA pulse error injection parameters.
+        
+        :type: PP_PMAERRPUL_PARAMS
+        """
+
+        self.enable = PP_PMAERRPUL_ENABLE(conn, module_id, port_id)
+        """PMA pulse error injection control.
+        
+        :type: PP_PMAERRPUL_ENABLE
+        """
+
+
+class PcsPma:
+    """PCS/PMA settings"""
+
+    def __init__(self, conn: "itf.IConnection", port) -> None:
+        self.link_flap = LinkFlap(conn, *port.kind)
+        """Link flap settings.
+        
+        :type: LinkFlap
+        """
+
+        self.pma_pulse_err_inj = PmaPulseErrInj(conn, *port.kind)
+        """PMA pulse error injection settings.
+        
+        :type: PmaPulseErrInj
+        """

xoa_driver/internals/hli_v1/ports/port_l23/pcs_pma_l.py

@@ -0,0 +1,78 @@
+from typing import (
+    TYPE_CHECKING,
+    Tuple,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    PP_AUTONEG,
+    PP_AUTONEGSTATUS,
+    PP_LINKTRAIN,
+    PP_LINKTRAINSTATUS,
+)
+
+
+class AutoNeg:
+    """L23 high-speed port PCS/PMA auto-negotiation"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.settings = PP_AUTONEG(conn, module_id, port_id)
+        """Auto-negotiation settings of the PHY.
+        
+        :type: PP_AUTONEG
+        """
+
+        self.status = PP_AUTONEGSTATUS(conn, module_id, port_id)
+        """Status of auto-negotiation settings of the PHY.
+        
+        :type: PP_AUTONEGSTATUS
+        """
+
+
+class LinkTrain:
+    """L23 high-speed port PCS/PMA link training"""
+
+    def __init__(self, conn: "itf.IConnection", port) -> None:
+        self.settings = PP_LINKTRAIN(conn, *port.kind)
+        """Link training settings.
+        
+        :type: PP_LINKTRAIN
+        """
+
+        self.per_lane_status: Tuple[PP_LINKTRAINSTATUS, ...] = tuple(
+            PP_LINKTRAINSTATUS(conn, *port.kind, _serdes_xindex=idx)
+            for idx in range(port.info.capabilities.serdes_count)
+        ) 
+        """Link training status.
+        
+        :type: PP_LINKTRAINSTATUS
+        """
+
+
+class PcsPma:
+    """L23 high-speed port PCS/PMA settings"""
+
+    def __init__(self, conn: "itf.IConnection", port) -> None:
+        self.auto_neg = AutoNeg(conn, *port.kind)
+        """PCS/PMA auto-negotiation settings.
+        
+        :type: AutoNeg
+        """
+
+        self.link_training = LinkTrain(conn, port)
+        """PCS/PMA link training settings.
+        
+        :type: LinkTrain
+        """
+
+
+# # Temporary ports are not supporting LinkTrain, in future release of xenaserver it will be the same as regular PcsPma
+# class PcsPmaL1:
+#     """L23 high-speed port PCS/PMA settings"""
+
+#     def __init__(self, conn: "itf.IConnection", port) -> None:
+#         self.auto_neg = AutoNeg(conn, *port.kind)
+#         """PCS/PMA auto-negotiation settings.
+        
+#         :type: AutoNeg
+#         """

xoa_driver/internals/hli_v1/ports/port_l23/port_l23ve.py

@@ -0,0 +1,101 @@
+from typing import TYPE_CHECKING
+from .bases.port_l23 import BasePortL23
+from .bases.port_reception_statistics import PortReceptionStatistics
+from .bases.port_transmission_statistics import PortTransmissionStatistics
+
+from xoa_driver.internals.commands import (
+    P_MDIXMODE,
+    # P_ENGINENAMES, # TODO: need to implement
+    # P_ENGINELOAD, # TODO: need to implement
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.utils.indices import index_manager as idx_mgr
+from xoa_driver.internals.hli_v1.indices.streams.base_stream import BaseStreamIdx
+from xoa_driver.internals.hli_v1.indices.filter.base_filter import BaseFilterIdx
+from xoa_driver.internals.state_storage import ports_state
+
+VEStreamIndices = idx_mgr.IndexManager[BaseStreamIdx]
+VEFilterIndices = idx_mgr.IndexManager[BaseFilterIdx]
+
+
+class Engine:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        # self.names = P_ENGINENAMES(conn, module_id, port_id)
+        # self.load = P_ENGINELOAD(conn, module_id, port_id)
+        ...
+
+
+class L23VEPortStatistics:
+    """L23 VE port statistics"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = PortReceptionStatistics(conn, module_id, port_id)
+        """L23 VE port's RX statistics.
+        
+        :type: PortReceptionStatistics
+        """
+
+        self.tx = PortTransmissionStatistics(conn, module_id, port_id)
+        """L23 VE port's TX statistics.
+        
+        :type: PortTransmissionStatistics
+        """
+
+
+class PortL23VE(BasePortL23):
+    """L23 VE port"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        super().__init__(conn, module_id, port_id)
+
+        self._local_states = ports_state.PortL23LocalState()
+
+        self.mdix_mode = P_MDIXMODE(conn, module_id, port_id)
+        """MDI/MDIX mode.
+        
+        :type: P_MDIXMODE
+        """
+
+        self.engine = Engine(conn, module_id, port_id)
+        """Engine is not supported yet.
+        
+        :type: Engine
+        """
+
+        self.statistics = L23VEPortStatistics(conn, module_id, port_id)
+        """Port statistics.
+
+        :type: L23VEPortStatistics
+        """
+
+        self.streams: VEStreamIndices = idx_mgr.IndexManager(
+            conn,
+            BaseStreamIdx,
+            module_id,
+            port_id
+        )
+        """L23 VE port's stream index manager.
+        
+        :type: VEStreamIndices
+        """
+
+        self.filters: VEFilterIndices = idx_mgr.IndexManager(
+            conn,
+            BaseFilterIdx,
+            module_id,
+            port_id
+        )
+        """L23 VE port's filter index manager.
+        
+        :type: VEFilterIndices
+        """
+
+    @property
+    def info(self) -> ports_state.PortL23LocalState:
+        return self._local_states
+
+    async def _setup(self):
+        await self._local_states.initiate(self)
+        self._local_states.register_subscriptions(self)
+        return self