Skip to content

L
linux
Commit 33d21bd1 authored by Jakub Kicinski's avatar Jakub Kicinski
Browse files
Options

Merge branch 'net: Add support for Power over Ethernet (PoE)' 

Kory Maincent says:

====================
net: Add support for Power over Ethernet (PoE)

This patch series aims at adding support for PoE (Power over Ethernet),
based on the already existing support for PoDL (Power over Data Line)
implementation. In addition, it adds support for two specific PoE
controller, the Microchip PD692x0 and the TI TPS23881.
====================

Link: https://lore.kernel.org/all/20240417-feature_poe-v9-0-242293fd1900@bootlin.comSigned-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parents 80d953c8 20e6d190
Show whitespace changes
Inline Side-by-side
Showing with 3533 additions and 97 deletions
Documentation/devicetree/bindings/net/pse-pd/microchip,pd692x0.yaml 0 → 100644
View file @ 33d21bd1
# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
%YAML 1.2
---
$id: http://devicetree.org/schemas/net/pse-pd/microchip,pd692x0.yaml#
$schema: http://devicetree.org/meta-schemas/core.yaml#
title: Microchip PD692x0 Power Sourcing Equipment controller
maintainers:
- Kory Maincent <kory.maincent@bootlin.com>
allOf:
- $ref: pse-controller.yaml#
properties:
compatible:
enum:
- microchip,pd69200
- microchip,pd69210
- microchip,pd69220
reg:
maxItems: 1
managers:
type: object
description:
List of the PD69208T4/PD69204T4/PD69208M PSE managers. Each manager
have 4 or 8 physical ports according to the chip version. No need to
specify the SPI chip select as it is automatically detected by the
PD692x0 PSE controller. The PSE managers have to be described from
the lowest chip select to the greatest one, which is the detection
behavior of the PD692x0 PSE controller. The PD692x0 support up to
12 PSE managers which can expose up to 96 physical ports. All
physical ports available on a manager have to be described in the
incremental order even if they are not used.
properties:
"#address-cells":
const: 1
"#size-cells":
const: 0
required:
- "#address-cells"
- "#size-cells"
patternProperties:
"^manager@0[0-9a-b]$":
type: object
description:
PD69208T4/PD69204T4/PD69208M PSE manager exposing 4 or 8 physical
ports.
properties:
reg:
description:
Incremental index of the PSE manager starting from 0, ranging
from lowest to highest chip select, up to 11.
maxItems: 1
"#address-cells":
const: 1
"#size-cells":
const: 0
patternProperties:
'^port@[0-7]$':
type: object
required:
- reg
additionalProperties: false
required:
- reg
- "#address-cells"
- "#size-cells"
required:
- compatible
- reg
- pse-pis
unevaluatedProperties: false
examples:
- |
i2c {
#address-cells = <1>;
#size-cells = <0>;
ethernet-pse@3c {
compatible = "microchip,pd69200";
reg = <0x3c>;
managers {
#address-cells = <1>;
#size-cells = <0>;
manager@0 {
reg = <0>;
#address-cells = <1>;
#size-cells = <0>;
phys0: port@0 {
reg = <0>;
};
phys1: port@1 {
reg = <1>;
};
phys2: port@2 {
reg = <2>;
};
phys3: port@3 {
reg = <3>;
};
};
manager@1 {
reg = <1>;
#address-cells = <1>;
#size-cells = <0>;
phys4: port@0 {
reg = <0>;
};
phys5: port@1 {
reg = <1>;
};
phys6: port@2 {
reg = <2>;
};
phys7: port@3 {
reg = <3>;
};
};
};
pse-pis {
#address-cells = <1>;
#size-cells = <0>;
pse_pi0: pse-pi@0 {
reg = <0>;
#pse-cells = <0>;
pairset-names = "alternative-a", "alternative-b";
pairsets = <&phys0>, <&phys1>;
polarity-supported = "MDI", "S";
vpwr-supply = <&vpwr1>;
};
pse_pi1: pse-pi@1 {
reg = <1>;
#pse-cells = <0>;
pairset-names = "alternative-a";
pairsets = <&phys2>;
polarity-supported = "MDI";
vpwr-supply = <&vpwr2>;
};
};
};
};
Documentation/devicetree/bindings/net/pse-pd/pse-controller.yaml
View file @ 33d21bd1
......@@ -13,6 +13,7 @@ description: Binding for the Power Sourcing Equipment (PSE) as defined in the
maintainers:
- Oleksij Rempel <o.rempel@pengutronix.de>
- Kory Maincent <kory.maincent@bootlin.com>
properties:
$nodename:
......@@ -22,11 +23,105 @@ properties:
description:
Used to uniquely identify a PSE instance within an IC. Will be
0 on PSE nodes with only a single output and at least 1 on nodes
controlling several outputs.
controlling several outputs which are not described in the pse-pis
subnode. This property is deprecated, please use pse-pis instead.
enum: [0, 1]
required:
pse-pis:
type: object
description:
Overview of the PSE PIs provided by the controller.
properties:
"#address-cells":
const: 1
"#size-cells":
const: 0
required:
- "#address-cells"
- "#size-cells"
patternProperties:
"^pse-pi@[0-9a-f]+$":
type: object
description:
PSE PI for power delivery via pairsets, compliant with IEEE
802.3-2022, Section 145.2.4. Each pairset comprises a positive and
a negative VPSE pair, adhering to the pinout configurations
detailed in the standard.
See Documentation/networking/pse-pd/pse-pi.rst for details.
properties:
reg:
description:
Address describing the PSE PI index.
maxItems: 1
"#pse-cells":
const: 0
pairset-names:
$ref: /schemas/types.yaml#/definitions/string-array
description:
Names of the pairsets as per IEEE 802.3-2022, Section 145.2.4.
Each name should correspond to a phandle in the 'pairset'
property pointing to the power supply for that pairset.
minItems: 1
maxItems: 2
items:
enum:
- alternative-a
- alternative-b
pairsets:
$ref: /schemas/types.yaml#/definitions/phandle-array
description:
List of phandles, each pointing to the power supply for the
corresponding pairset named in 'pairset-names'. This property
aligns with IEEE 802.3-2022, Section 33.2.3 and 145.2.4.
PSE Pinout Alternatives (as per IEEE 802.3-2022 Table 145\u20133)
|-----------|---------------|---------------|---------------|---------------|
| Conductor | Alternative A | Alternative A | Alternative B | Alternative B |
| | (MDI-X) | (MDI) | (X) | (S) |
|-----------|---------------|---------------|---------------|---------------|
| 1 | Negative VPSE | Positive VPSE | - | - |
| 2 | Negative VPSE | Positive VPSE | - | - |
| 3 | Positive VPSE | Negative VPSE | - | - |
| 4 | - | - | Negative VPSE | Positive VPSE |
| 5 | - | - | Negative VPSE | Positive VPSE |
| 6 | Positive VPSE | Negative VPSE | - | - |
| 7 | - | - | Positive VPSE | Negative VPSE |
| 8 | - | - | Positive VPSE | Negative VPSE |
minItems: 1
maxItems: 2
polarity-supported:
$ref: /schemas/types.yaml#/definitions/string-array
description:
Polarity configuration supported by the PSE PI pairsets.
minItems: 1
maxItems: 4
items:
enum:
- MDI-X
- MDI
- X
- S
vpwr-supply:
description: Regulator power supply for the PSE PI.
required:
- reg
- "#pse-cells"
oneOf:
- required:
- "#pse-cells"
- required:
- pse-pis
additionalProperties: true
......
Documentation/devicetree/bindings/net/pse-pd/ti,tps23881.yaml 0 → 100644
View file @ 33d21bd1
# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
%YAML 1.2
---
$id: http://devicetree.org/schemas/net/pse-pd/ti,tps23881.yaml#
$schema: http://devicetree.org/meta-schemas/core.yaml#
title: TI TPS23881 Power Sourcing Equipment controller
maintainers:
- Kory Maincent <kory.maincent@bootlin.com>
allOf:
- $ref: pse-controller.yaml#
properties:
compatible:
enum:
- ti,tps23881
reg:
maxItems: 1
'#pse-cells':
const: 1
channels:
description: each set of 8 ports can be assigned to one physical
channels or two for PoE4. This parameter describes the configuration
of the ports conversion matrix that establishes relationship between
the logical ports and the physical channels.
type: object
patternProperties:
'^channel@[0-7]$':
type: object
required:
- reg
unevaluatedProperties: false
required:
- compatible
- reg
examples:
- |
i2c {
#address-cells = <1>;
#size-cells = <0>;
ethernet-pse@20 {
compatible = "ti,tps23881";
reg = <0x20>;
channels {
#address-cells = <1>;
#size-cells = <0>;
phys0: channel@0 {
reg = <0>;
};
phys1: channel@1 {
reg = <1>;
};
phys2: channel@2 {
reg = <2>;
};
};
pse-pis {
#address-cells = <1>;
#size-cells = <0>;
pse_pi0: pse-pi@0 {
reg = <0>;
#pse-cells = <0>;
pairset-names = "alternative-a", "alternative-b";
pairsets = <&phys0>, <&phys1>;
polarity-supported = "MDI", "S";
vpwr-supply = <&vpwr1>;
};
pse_pi1: pse-pi@1 {
reg = <1>;
#pse-cells = <0>;
pairset-names = "alternative-a";
pairsets = <&phys2>;
polarity-supported = "MDI";
vpwr-supply = <&vpwr2>;
};
};
};
};
Documentation/netlink/specs/ethtool.yaml
View file @ 33d21bd1
......@@ -899,17 +899,29 @@ attribute-sets:
type: nest
nested-attributes: header
-
name: admin-state
name: podl-pse-admin-state
type: u32
name-prefix: ethtool-a-podl-pse-
name-prefix: ethtool-a-
-
name: admin-control
name: podl-pse-admin-control
type: u32
name-prefix: ethtool-a-podl-pse-
name-prefix: ethtool-a-
-
name: pw-d-status
name: podl-pse-pw-d-status
type: u32
name-prefix: ethtool-a-podl-pse-
name-prefix: ethtool-a-
-
name: c33-pse-admin-state
type: u32
name-prefix: ethtool-a-
-
name: c33-pse-admin-control
type: u32
name-prefix: ethtool-a-
-
name: c33-pse-pw-d-status
type: u32
name-prefix: ethtool-a-
-
name: rss
attributes:
......@@ -1593,9 +1605,12 @@ operations:
reply:
attributes: &pse
- header
- admin-state
- admin-control
- pw-d-status
- podl-pse-admin-state
- podl-pse-admin-control
- podl-pse-pw-d-status
- c33-pse-admin-state
- c33-pse-admin-control
- c33-pse-pw-d-status
dump: *pse-get-op
-
name: pse-set
......
Documentation/networking/ethtool-netlink.rst
View file @ 33d21bd1
......@@ -1733,6 +1733,10 @@ Kernel response contents:
PSE functions
``ETHTOOL_A_PODL_PSE_PW_D_STATUS`` u32 power detection status of the
PoDL PSE.
``ETHTOOL_A_C33_PSE_ADMIN_STATE`` u32 Operational state of the PoE
PSE functions.
``ETHTOOL_A_C33_PSE_PW_D_STATUS`` u32 power detection status of the
PoE PSE.
====================================== ====== =============================
When set, the optional ``ETHTOOL_A_PODL_PSE_ADMIN_STATE`` attribute identifies
......@@ -1744,6 +1748,12 @@ aPoDLPSEAdminState. Possible values are:
.. kernel-doc:: include/uapi/linux/ethtool.h
:identifiers: ethtool_podl_pse_admin_state
The same goes for ``ETHTOOL_A_C33_PSE_ADMIN_STATE`` implementing
``IEEE 802.3-2022`` 30.9.1.1.2 aPSEAdminState.
.. kernel-doc:: include/uapi/linux/ethtool.h
:identifiers: ethtool_c33_pse_admin_state
When set, the optional ``ETHTOOL_A_PODL_PSE_PW_D_STATUS`` attribute identifies
the power detection status of the PoDL PSE. The status depend on internal PSE
state machine and automatic PD classification support. This option is
......@@ -1753,6 +1763,12 @@ Possible values are:
.. kernel-doc:: include/uapi/linux/ethtool.h
:identifiers: ethtool_podl_pse_pw_d_status
The same goes for ``ETHTOOL_A_C33_PSE_ADMIN_PW_D_STATUS`` implementing
``IEEE 802.3-2022`` 30.9.1.1.5 aPSEPowerDetectionStatus.
.. kernel-doc:: include/uapi/linux/ethtool.h
:identifiers: ethtool_c33_pse_pw_d_status
PSE_SET
=======
......@@ -1763,6 +1779,7 @@ Request contents:
====================================== ====== =============================
``ETHTOOL_A_PSE_HEADER`` nested request header
``ETHTOOL_A_PODL_PSE_ADMIN_CONTROL`` u32 Control PoDL PSE Admin state
``ETHTOOL_A_C33_PSE_ADMIN_CONTROL`` u32 Control PSE Admin state
====================================== ====== =============================
When set, the optional ``ETHTOOL_A_PODL_PSE_ADMIN_CONTROL`` attribute is used
......@@ -1770,6 +1787,9 @@ to control PoDL PSE Admin functions. This option is implementing
``IEEE 802.3-2018`` 30.15.1.2.1 acPoDLPSEAdminControl. See
``ETHTOOL_A_PODL_PSE_ADMIN_STATE`` for supported values.
The same goes for ``ETHTOOL_A_C33_PSE_ADMIN_CONTROL`` implementing
``IEEE 802.3-2022`` 30.9.1.2.1 acPSEAdminControl.
RSS_GET
=======
......
Documentation/networking/index.rst
View file @ 33d21bd1
......@@ -93,6 +93,7 @@ Contents:
plip
ppp_generic
proc_net_tcp
pse-pd/index
radiotap-headers
rds
regulatory
......
Documentation/networking/pse-pd/index.rst 0 → 100644
View file @ 33d21bd1
.. SPDX-License-Identifier: GPL-2.0
Power Sourcing Equipment (PSE) Documentation
============================================
.. toctree::
:maxdepth: 2
introduction
pse-pi
Documentation/networking/pse-pd/introduction.rst 0 → 100644
View file @ 33d21bd1
.. SPDX-License-Identifier: GPL-2.0
Power Sourcing Equipment (PSE) in IEEE 802.3 Standard
=====================================================
Overview
--------
Power Sourcing Equipment (PSE) is essential in networks for delivering power
along with data over Ethernet cables. It usually refers to devices like
switches and hubs that supply power to Powered Devices (PDs) such as IP
cameras, VoIP phones, and wireless access points.
PSE vs. PoDL PSE
----------------
PSE in the IEEE 802.3 standard generally refers to equipment that provides
power alongside data over Ethernet cables, typically associated with Power over
Ethernet (PoE).
PoDL PSE, or Power over Data Lines PSE, specifically denotes PSEs operating
with single balanced twisted-pair PHYs, as per Clause 104 of IEEE 802.3. PoDL
is significant in contexts like automotive and industrial controls where power
and data delivery over a single pair is advantageous.
IEEE 802.3-2018 Addendums and Related Clauses
---------------------------------------------
Key addenda to the IEEE 802.3-2018 standard relevant to power delivery over
Ethernet are as follows:
- **802.3af (Approved in 2003-06-12)**: Known as PoE in the market, detailed in
Clause 33, delivering up to 15.4W of power.
- **802.3at (Approved in 2009-09-11)**: Marketed as PoE+, enhancing PoE as
covered in Clause 33, increasing power delivery to up to 30W.
- **802.3bt (Approved in 2018-09-27)**: Known as 4PPoE in the market, outlined
in Clause 33. Type 3 delivers up to 60W, and Type 4 up to 100W.
- **802.3bu (Approved in 2016-12-07)**: Formerly referred to as PoDL, detailed
in Clause 104. Introduces Classes 0 - 9. Class 9 PoDL PSE delivers up to ~65W
Kernel Naming Convention Recommendations
----------------------------------------
For clarity and consistency within the Linux kernel's networking subsystem, the
following naming conventions are recommended:
- For general PSE (PoE) code, use "c33_pse" key words. For example:
``enum ethtool_c33_pse_admin_state c33_admin_control;``.
This aligns with Clause 33, encompassing various PoE forms.
- For PoDL PSE - specific code, use "podl_pse". For example:
``enum ethtool_podl_pse_admin_state podl_admin_control;`` to differentiate
PoDL PSE settings according to Clause 104.
Summary of Clause 33: Data Terminal Equipment (DTE) Power via Media Dependent Interface (MDI)
---------------------------------------------------------------------------------------------
Clause 33 of the IEEE 802.3 standard defines the functional and electrical
characteristics of Powered Device (PD) and Power Sourcing Equipment (PSE).
These entities enable power delivery using the same generic cabling as for data
transmission, integrating power with data communication for devices such as
10BASE-T, 100BASE-TX, or 1000BASE-T.
Summary of Clause 104: Power over Data Lines (PoDL) of Single Balanced Twisted-Pair Ethernet
--------------------------------------------------------------------------------------------
Clause 104 of the IEEE 802.3 standard delineates the functional and electrical
characteristics of PoDL Powered Devices (PDs) and PoDL Power Sourcing Equipment
(PSEs). These are designed for use with single balanced twisted-pair Ethernet
Physical Layers. In this clause, 'PSE' refers specifically to PoDL PSE, and
'PD' to PoDL PD. The key intent is to provide devices with a unified interface
for both data and the power required to process this data over a single
balanced twisted-pair Ethernet connection.
Documentation/networking/pse-pd/pse-pi.rst 0 → 100644
View file @ 33d21bd1
.. SPDX-License-Identifier: GPL-2.0
PSE Power Interface (PSE PI) Documentation
==========================================
The Power Sourcing Equipment Power Interface (PSE PI) plays a pivotal role in
the architecture of Power over Ethernet (PoE) systems. It is essentially a
blueprint that outlines how one or multiple power sources are connected to the
eight-pin modular jack, commonly known as the Ethernet RJ45 port. This
connection scheme is crucial for enabling the delivery of power alongside data
over Ethernet cables.
Documentation and Standards
---------------------------
The IEEE 802.3 standard provides detailed documentation on the PSE PI.
Specifically:
- Section "33.2.3 PI pin assignments" covers the pin assignments for PoE
systems that utilize two pairs for power delivery.
- Section "145.2.4 PSE PI" addresses the configuration for PoE systems that
deliver power over all four pairs of an Ethernet cable.
PSE PI and Single Pair Ethernet
-------------------------------
Single Pair Ethernet (SPE) represents a different approach to Ethernet
connectivity, utilizing just one pair of conductors for both data and power
transmission. Unlike the configurations detailed in the PSE PI for standard
Ethernet, which can involve multiple power sourcing arrangements across four or
two pairs of wires, SPE operates on a simpler model due to its single-pair
design. As a result, the complexities of choosing between alternative pin
assignments for power delivery, as described in the PSE PI for multi-pair
Ethernet, are not applicable to SPE.
Understanding PSE PI
--------------------
The Power Sourcing Equipment Power Interface (PSE PI) is a framework defining
how Power Sourcing Equipment (PSE) delivers power to Powered Devices (PDs) over
Ethernet cables. It details two main configurations for power delivery, known
as Alternative A and Alternative B, which are distinguished not only by their
method of power transmission but also by the implications for polarity and data
transmission direction.
Alternative A and B Overview
----------------------------
- **Alternative A:** Utilizes RJ45 conductors 1, 2, 3 and 6. In either case of
networks 10/100BaseT or 1G/2G/5G/10GBaseT, the pairs used are carrying data.
The power delivery's polarity in this alternative can vary based on the MDI
(Medium Dependent Interface) or MDI-X (Medium Dependent Interface Crossover)
configuration.
- **Alternative B:** Utilizes RJ45 conductors 4, 5, 7 and 8. In case of
10/100BaseT network the pairs used are spare pairs without data and are less
influenced by data transmission direction. This is not the case for
1G/2G/5G/10GBaseT network. Alternative B includes two configurations with
different polarities, known as variant X and variant S, to accommodate
different network requirements and device specifications.
Table 145-3 PSE Pinout Alternatives
-----------------------------------
The following table outlines the pin configurations for both Alternative A and
Alternative B.
+------------+-------------------+-----------------+-----------------+-----------------+
| Conductor | Alternative A | Alternative A | Alternative B | Alternative B |
| | (MDI-X) | (MDI) | (X) | (S) |
+============+===================+=================+=================+=================+
| 1 | Negative V | Positive V | - | - |
+------------+-------------------+-----------------+-----------------+-----------------+
| 2 | Negative V | Positive V | - | - |
+------------+-------------------+-----------------+-----------------+-----------------+
| 3 | Positive V | Negative V | - | - |
+------------+-------------------+-----------------+-----------------+-----------------+
| 4 | - | - | Negative V | Positive V |
+------------+-------------------+-----------------+-----------------+-----------------+
| 5 | - | - | Negative V | Positive V |
+------------+-------------------+-----------------+-----------------+-----------------+
| 6 | Positive V | Negative V | - | - |
+------------+-------------------+-----------------+-----------------+-----------------+
| 7 | - | - | Positive V | Negative V |
+------------+-------------------+-----------------+-----------------+-----------------+
| 8 | - | - | Positive V | Negative V |
+------------+-------------------+-----------------+-----------------+-----------------+
.. note::
- "Positive V" and "Negative V" indicate the voltage polarity for each pin.
- "-" indicates that the pin is not used for power delivery in that
specific configuration.
PSE PI compatibilities
----------------------
The following table outlines the compatibility between the pinout alternative
and the 1000/2.5G/5G/10GBaseT in the PSE 2 pairs connection.
+---------+---------------+---------------------+-----------------------+
| Variant | Alternative | Power Feeding Type | Compatibility with |
| | (A/B) | (Direct/Phantom) | 1000/2.5G/5G/10GBaseT |
+=========+===============+=====================+=======================+
| 1 | A | Phantom | Yes |
+---------+---------------+---------------------+-----------------------+
| 2 | B | Phantom | Yes |
+---------+---------------+---------------------+-----------------------+
| 3 | B | Direct | No |
+---------+---------------+---------------------+-----------------------+
.. note::
- "Direct" indicate a variant where the power is injected directly to pairs
without using magnetics in case of spare pairs.
- "Phantom" indicate power path over coils/magnetics as it is done for
Alternative A variant.
In case of PSE 4 pairs, a PSE supporting only 10/100BaseT (which mean Direct
Power on pinout Alternative B) is not compatible with a 4 pairs
1000/2.5G/5G/10GBaseT.
PSE Power Interface (PSE PI) Connection Diagram
-----------------------------------------------
The diagram below illustrates the connection architecture between the RJ45
port, the Ethernet PHY (Physical Layer), and the PSE PI (Power Sourcing
Equipment Power Interface), demonstrating how power and data are delivered
simultaneously through an Ethernet cable. The RJ45 port serves as the physical
interface for these connections, with each of its eight pins connected to both
the Ethernet PHY for data transmission and the PSE PI for power delivery.
.. code-block::
+--------------------------+
| |
| RJ45 Port |
| |
+--+--+--+--+--+--+--+--+--+ +-------------+
1| 2| 3| 4| 5| 6| 7| 8| | |
| | | | | | | o-------------------+ |
| | | | | | o--|-------------------+ +<--- PSE 1
| | | | | o--|--|-------------------+ |
| | | | o--|--|--|-------------------+ |
| | | o--|--|--|--|-------------------+ PSE PI |
| | o--|--|--|--|--|-------------------+ |
| o--|--|--|--|--|--|-------------------+ +<--- PSE 2 (optional)
o--|--|--|--|--|--|--|-------------------+ |
| | | | | | | | | |
+--+--+--+--+--+--+--+--+--+ +-------------+
| |
| Ethernet PHY |
| |
+--------------------------+
Simple PSE PI Configuration for Alternative A
---------------------------------------------
The diagram below illustrates a straightforward PSE PI (Power Sourcing
Equipment Power Interface) configuration designed to support the Alternative A
setup for Power over Ethernet (PoE). This implementation is tailored to provide
power delivery through the data-carrying pairs of an Ethernet cable, suitable
for either MDI or MDI-X configurations, albeit supporting one variation at a
time.
.. code-block::
+-------------+
| PSE PI |
8 -----+ +-------------+
7 -----+ Rail 1 |
6 -----+------+----------------------+
5 -----+ | |
4 -----+ | Rail 2 | PSE 1
3 -----+------/ +------------+
2 -----+--+-------------/ |
1 -----+--/ +-------------+
|
+-------------+
In this configuration:
- Pins 1 and 2, as well as pins 3 and 6, are utilized for power delivery in
addition to data transmission. This aligns with the standard wiring for
10/100BaseT Ethernet networks where these pairs are used for data.
- Rail 1 and Rail 2 represent the positive and negative voltage rails, with
Rail 1 connected to pins 1 and 2, and Rail 2 connected to pins 3 and 6.
More advanced PSE PI configurations may include integrated or external
switches to change the polarity of the voltage rails, allowing for
compatibility with both MDI and MDI-X configurations.
More complex PSE PI configurations may include additional components, to support
Alternative B, or to provide additional features such as power management, or
additional power delivery capabilities such as 2-pair or 4-pair power delivery.
.. code-block::
+-------------+
| PSE PI |
| +---+
8 -----+--------+ | +-------------+
7 -----+--------+ | Rail 1 |
6 -----+--------+ +-----------------+
5 -----+--------+ | |
4 -----+--------+ | Rail 2 | PSE 1
3 -----+--------+ +----------------+
2 -----+--------+ | |
1 -----+--------+ | +-------------+
| +---+
+-------------+
Device Tree Configuration: Describing PSE PI Configurations
-----------------------------------------------------------
The necessity for a separate PSE PI node in the device tree is influenced by
the intricacy of the Power over Ethernet (PoE) system's setup. Here are
descriptions of both simple and complex PSE PI configurations to illustrate
this decision-making process:
**Simple PSE PI Configuration:**
In a straightforward scenario, the PSE PI setup involves a direct, one-to-one
connection between a single PSE controller and an Ethernet port. This setup
typically supports basic PoE functionality without the need for dynamic
configuration or management of multiple power delivery modes. For such simple
configurations, detailing the PSE PI within the existing PSE controller's node
may suffice, as the system does not encompass additional complexity that
warrants a separate node. The primary focus here is on the clear and direct
association of power delivery to a specific Ethernet port.
**Complex PSE PI Configuration:**
Contrastingly, a complex PSE PI setup may encompass multiple PSE controllers or
auxiliary circuits that collectively manage power delivery to one Ethernet
port. Such configurations might support a range of PoE standards and require
the capability to dynamically configure power delivery based on the operational
mode (e.g., PoE2 versus PoE4) or specific requirements of connected devices. In
these instances, a dedicated PSE PI node becomes essential for accurately
documenting the system architecture. This node would serve to detail the
interactions between different PSE controllers, the support for various PoE
modes, and any additional logic required to coordinate power delivery across
the network infrastructure.
**Guidance:**
For simple PSE setups, including PSE PI information in the PSE controller node
might suffice due to the straightforward nature of these systems. However,
complex configurations, involving multiple components or advanced PoE features,
benefit from a dedicated PSE PI node. This method adheres to IEEE 802.3
specifications, improving documentation clarity and ensuring accurate
representation of the PoE system's complexity.
PSE PI Node: Essential Information
----------------------------------
The PSE PI (Power Sourcing Equipment Power Interface) node in a device tree can
include several key pieces of information critical for defining the power
delivery capabilities and configurations of a PoE (Power over Ethernet) system.
Below is a list of such information, along with explanations for their
necessity and reasons why they might not be found within a PSE controller node:
1. **Powered Pairs Configuration**
- *Description:* Identifies the pairs used for power delivery in the
Ethernet cable.
- *Necessity:* Essential to ensure the correct pairs are powered according
to the board's design.
- *PSE Controller Node:* Typically lacks details on physical pair usage,
focusing on power regulation.
2. **Polarity of Powered Pairs**
- *Description:* Specifies the polarity (positive or negative) for each
powered pair.
- *Necessity:* Critical for safe and effective power transmission to PDs.
- *PSE Controller Node:* Polarity management may exceed the standard
functionalities of PSE controllers.
3. **PSE Cells Association**
- *Description:* Details the association of PSE cells with Ethernet ports or
pairs in multi-cell configurations.
- *Necessity:* Allows for optimized power resource allocation in complex
systems.
- *PSE Controller Node:* Controllers may not manage cell associations
directly, focusing instead on power flow regulation.
4. **Support for PoE Standards**
- *Description:* Lists the PoE standards and configurations supported by the
system.
- *Necessity:* Ensures system compatibility with various PDs and adherence
to industry standards.
- *PSE Controller Node:* Specific capabilities may depend on the overall PSE
PI design rather than the controller alone. Multiple PSE cells per PI
do not necessarily imply support for multiple PoE standards.
5. **Protection Mechanisms**
- *Description:* Outlines additional protection mechanisms, such as
overcurrent protection and thermal management.
- *Necessity:* Provides extra safety and stability, complementing PSE
controller protections.
- *PSE Controller Node:* Some protections may be implemented via
board-specific hardware or algorithms external to the controller.
MAINTAINERS
View file @ 33d21bd1
......@@ -17779,6 +17779,7 @@ F: net/psample
PSE NETWORK DRIVER
M: Oleksij Rempel <o.rempel@pengutronix.de>
M: Kory Maincent <kory.maincent@bootlin.com>
L: netdev@vger.kernel.org
S: Maintained
F: Documentation/devicetree/bindings/net/pse-pd/
......
drivers/net/pse-pd/Kconfig
View file @ 33d21bd1
......@@ -20,4 +20,24 @@ config PSE_REGULATOR
Sourcing Equipment without automatic classification support. For
example for basic implementation of PoDL (802.3bu) specification.
config PSE_PD692X0
tristate "PD692X0 PSE controller"
depends on I2C
select FW_UPLOAD
help
This module provides support for PD692x0 regulator based Ethernet
Power Sourcing Equipment.
To compile this driver as a module, choose M here: the
module will be called pd692x0.
config PSE_TPS23881
tristate "TPS23881 PSE controller"
depends on I2C
help
This module provides support for TPS23881 regulator based Ethernet
Power Sourcing Equipment.
To compile this driver as a module, choose M here: the
module will be called tps23881.
endif
drivers/net/pse-pd/Makefile
View file @ 33d21bd1
......@@ -4,3 +4,5 @@
obj-$(CONFIG_PSE_CONTROLLER) += pse_core.o
obj-$(CONFIG_PSE_REGULATOR) += pse_regulator.o
obj-$(CONFIG_PSE_PD692X0) += pd692x0.o
obj-$(CONFIG_PSE_TPS23881) += tps23881.o
drivers/net/pse-pd/pd692x0.c 0 → 100644
View file @ 33d21bd1
// SPDX-License-Identifier: GPL-2.0-only
/*
* Driver for the Microchip PD692X0 PoE PSE Controller driver (I2C bus)
*
* Copyright (c) 2023 Bootlin, Kory Maincent <kory.maincent@bootlin.com>
*/
#include <linux/delay.h>
#include <linux/firmware.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/pse-pd/pse.h>
#define PD692X0_PSE_NAME "pd692x0_pse"
#define PD692X0_MAX_PIS 48
#define PD692X0_MAX_MANAGERS 12
#define PD692X0_MAX_MANAGER_PORTS 8
#define PD692X0_MAX_HW_PORTS (PD692X0_MAX_MANAGERS * PD692X0_MAX_MANAGER_PORTS)
#define PD69200_BT_PROD_VER 24
#define PD69210_BT_PROD_VER 26
#define PD69220_BT_PROD_VER 29
#define PD692X0_FW_MAJ_VER 3
#define PD692X0_FW_MIN_VER 5
#define PD692X0_FW_PATCH_VER 5
enum pd692x0_fw_state {
PD692X0_FW_UNKNOWN,
PD692X0_FW_OK,
PD692X0_FW_BROKEN,
PD692X0_FW_NEED_UPDATE,
PD692X0_FW_PREPARE,
PD692X0_FW_WRITE,
PD692X0_FW_COMPLETE,
};
struct pd692x0_msg {
u8 key;
u8 echo;
u8 sub[3];
u8 data[8];
__be16 chksum;
} __packed;
struct pd692x0_msg_ver {
u8 prod;
u8 maj_sw_ver;
u8 min_sw_ver;
u8 pa_sw_ver;
u8 param;
u8 build;
};
enum {
PD692X0_KEY_CMD,
PD692X0_KEY_PRG,
PD692X0_KEY_REQ,
PD692X0_KEY_TLM,
PD692X0_KEY_TEST,
PD692X0_KEY_REPORT = 0x52
};
enum {
PD692X0_MSG_RESET,
PD692X0_MSG_GET_SYS_STATUS,
PD692X0_MSG_GET_SW_VER,
PD692X0_MSG_SET_TMP_PORT_MATRIX,
PD692X0_MSG_PRG_PORT_MATRIX,
PD692X0_MSG_SET_PORT_PARAM,
PD692X0_MSG_GET_PORT_STATUS,
PD692X0_MSG_DOWNLOAD_CMD,
/* add new message above here */
PD692X0_MSG_CNT
};
struct pd692x0_priv {
struct i2c_client *client;
struct pse_controller_dev pcdev;
struct device_node *np;
enum pd692x0_fw_state fw_state;
struct fw_upload *fwl;
bool cancel_request;
u8 msg_id;
bool last_cmd_key;
unsigned long last_cmd_key_time;
enum ethtool_c33_pse_admin_state admin_state[PD692X0_MAX_PIS];
};
/* Template list of communication messages. The non-null bytes defined here
* constitute the fixed portion of the messages. The remaining bytes will
* be configured later within the functions. Refer to the "PD692x0 BT Serial
* Communication Protocol User Guide" for comprehensive details on messages
* content.
*/
static const struct pd692x0_msg pd692x0_msg_template_list[PD692X0_MSG_CNT] = {
[PD692X0_MSG_RESET] = {
.key = PD692X0_KEY_CMD,
.sub = {0x07, 0x55, 0x00},
.data = {0x55, 0x00, 0x55, 0x4e,
0x4e, 0x4e, 0x4e, 0x4e},
},
[PD692X0_MSG_GET_SYS_STATUS] = {
.key = PD692X0_KEY_REQ,
.sub = {0x07, 0xd0, 0x4e},
.data = {0x4e, 0x4e, 0x4e, 0x4e,
0x4e, 0x4e, 0x4e, 0x4e},
},
[PD692X0_MSG_GET_SW_VER] = {
.key = PD692X0_KEY_REQ,
.sub = {0x07, 0x1e, 0x21},
.data = {0x4e, 0x4e, 0x4e, 0x4e,
0x4e, 0x4e, 0x4e, 0x4e},
},
[PD692X0_MSG_SET_TMP_PORT_MATRIX] = {
.key = PD692X0_KEY_CMD,
.sub = {0x05, 0x43},
.data = { 0, 0x4e, 0x4e, 0x4e,
0x4e, 0x4e, 0x4e, 0x4e},
},
[PD692X0_MSG_PRG_PORT_MATRIX] = {
.key = PD692X0_KEY_CMD,
.sub = {0x07, 0x43, 0x4e},
.data = {0x4e, 0x4e, 0x4e, 0x4e,
0x4e, 0x4e, 0x4e, 0x4e},
},
[PD692X0_MSG_SET_PORT_PARAM] = {
.key = PD692X0_KEY_CMD,
.sub = {0x05, 0xc0},
.data = { 0, 0xff, 0xff, 0xff,
0x4e, 0x4e, 0x4e, 0x4e},
},
[PD692X0_MSG_GET_PORT_STATUS] = {
.key = PD692X0_KEY_REQ,
.sub = {0x05, 0xc1},
.data = {0x4e, 0x4e, 0x4e, 0x4e,
0x4e, 0x4e, 0x4e, 0x4e},
},
[PD692X0_MSG_DOWNLOAD_CMD] = {
.key = PD692X0_KEY_PRG,
.sub = {0xff, 0x99, 0x15},
.data = {0x16, 0x16, 0x99, 0x4e,
0x4e, 0x4e, 0x4e, 0x4e},
},
};
static u8 pd692x0_build_msg(struct pd692x0_msg *msg, u8 echo)
{
u8 *data = (u8 *)msg;
u16 chksum = 0;
int i;
msg->echo = echo++;
if (echo == 0xff)
echo = 0;
for (i = 0; i < sizeof(*msg) - sizeof(msg->chksum); i++)
chksum += data[i];
msg->chksum = cpu_to_be16(chksum);
return echo;
}
static int pd692x0_send_msg(struct pd692x0_priv *priv, struct pd692x0_msg *msg)
{
const struct i2c_client *client = priv->client;
int ret;
if (msg->key == PD692X0_KEY_CMD && priv->last_cmd_key) {
int cmd_msleep;
cmd_msleep = 30 - jiffies_to_msecs(jiffies - priv->last_cmd_key_time);
if (cmd_msleep > 0)
msleep(cmd_msleep);
}
/* Add echo and checksum bytes to the message */
priv->msg_id = pd692x0_build_msg(msg, priv->msg_id);
ret = i2c_master_send(client, (u8 *)msg, sizeof(*msg));
if (ret != sizeof(*msg))
return -EIO;
return 0;
}
static int pd692x0_reset(struct pd692x0_priv *priv)
{
const struct i2c_client *client = priv->client;
struct pd692x0_msg msg, buf = {0};
int ret;
msg = pd692x0_msg_template_list[PD692X0_MSG_RESET];
ret = pd692x0_send_msg(priv, &msg);
if (ret) {
dev_err(&client->dev,
"Failed to reset the controller (%pe)\n", ERR_PTR(ret));
return ret;
}
msleep(30);
ret = i2c_master_recv(client, (u8 *)&buf, sizeof(buf));
if (ret != sizeof(buf))
return ret < 0 ? ret : -EIO;
/* Is the reply a successful report message */
if (buf.key != PD692X0_KEY_REPORT || buf.sub[0] || buf.sub[1])
return -EIO;
msleep(300);
ret = i2c_master_recv(client, (u8 *)&buf, sizeof(buf));
if (ret != sizeof(buf))
return ret < 0 ? ret : -EIO;
/* Is the boot status without error */
if (buf.key != 0x03 || buf.echo != 0xff || buf.sub[0] & 0x1) {
dev_err(&client->dev, "PSE controller error\n");
return -EIO;
}
return 0;
}
static bool pd692x0_try_recv_msg(const struct i2c_client *client,
struct pd692x0_msg *msg,
struct pd692x0_msg *buf)
{
/* Wait 30ms before readback as mandated by the protocol */
msleep(30);
memset(buf, 0, sizeof(*buf));
i2c_master_recv(client, (u8 *)buf, sizeof(*buf));
if (buf->key)
return 0;
msleep(100);
memset(buf, 0, sizeof(*buf));
i2c_master_recv(client, (u8 *)buf, sizeof(*buf));
if (buf->key)
return 0;
return 1;
}
/* Implementation of I2C communication, specifically addressing scenarios
* involving communication loss. Refer to the "Synchronization During
* Communication Loss" section in the Communication Protocol document for
* further details.
*/
static int pd692x0_recv_msg(struct pd692x0_priv *priv,
struct pd692x0_msg *msg,
struct pd692x0_msg *buf)
{
const struct i2c_client *client = priv->client;
int ret;
ret = pd692x0_try_recv_msg(client, msg, buf);
if (!ret)
goto out_success;
dev_warn(&client->dev,
"Communication lost, rtnl is locked until communication is back!");
ret = pd692x0_send_msg(priv, msg);
if (ret)
return ret;
ret = pd692x0_try_recv_msg(client, msg, buf);
if (!ret)
goto out_success2;
msleep(10000);
ret = pd692x0_send_msg(priv, msg);
if (ret)
return ret;
ret = pd692x0_try_recv_msg(client, msg, buf);
if (!ret)
goto out_success2;
return pd692x0_reset(priv);
out_success2:
dev_warn(&client->dev, "Communication is back, rtnl is unlocked!");
out_success:
if (msg->key == PD692X0_KEY_CMD) {
priv->last_cmd_key = true;
priv->last_cmd_key_time = jiffies;
} else {
priv->last_cmd_key = false;
}
return 0;
}
static int pd692x0_sendrecv_msg(struct pd692x0_priv *priv,
struct pd692x0_msg *msg,
struct pd692x0_msg *buf)
{
struct device *dev = &priv->client->dev;
int ret;
ret = pd692x0_send_msg(priv, msg);
if (ret)
return ret;
ret = pd692x0_recv_msg(priv, msg, buf);
if (ret)
return ret;
if (msg->echo != buf->echo) {
dev_err(dev,
"Wrong match in message ID, expect %d received %d.\n",
msg->echo, buf->echo);
return -EIO;
}
/* If the reply is a report message is it successful */
if (buf->key == PD692X0_KEY_REPORT &&
(buf->sub[0] || buf->sub[1])) {
return -EIO;
}
return 0;
}
static struct pd692x0_priv *to_pd692x0_priv(struct pse_controller_dev *pcdev)
{
return container_of(pcdev, struct pd692x0_priv, pcdev);
}
static int pd692x0_fw_unavailable(struct pd692x0_priv *priv)
{
switch (priv->fw_state) {
case PD692X0_FW_OK:
return 0;
case PD692X0_FW_PREPARE:
case PD692X0_FW_WRITE:
case PD692X0_FW_COMPLETE:
dev_err(&priv->client->dev, "Firmware update in progress!\n");
return -EBUSY;
case PD692X0_FW_BROKEN:
case PD692X0_FW_NEED_UPDATE:
default:
dev_err(&priv->client->dev,
"Firmware issue. Please update it!\n");
return -EOPNOTSUPP;
}
}
static int pd692x0_pi_enable(struct pse_controller_dev *pcdev, int id)
{
struct pd692x0_priv *priv = to_pd692x0_priv(pcdev);
struct pd692x0_msg msg, buf = {0};
int ret;
ret = pd692x0_fw_unavailable(priv);
if (ret)
return ret;
if (priv->admin_state[id] == ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED)
return 0;
msg = pd692x0_msg_template_list[PD692X0_MSG_SET_PORT_PARAM];
msg.data[0] = 0x1;
msg.sub[2] = id;
ret = pd692x0_sendrecv_msg(priv, &msg, &buf);
if (ret < 0)
return ret;
priv->admin_state[id] = ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED;
return 0;
}
static int pd692x0_pi_disable(struct pse_controller_dev *pcdev, int id)
{
struct pd692x0_priv *priv = to_pd692x0_priv(pcdev);
struct pd692x0_msg msg, buf = {0};
int ret;
ret = pd692x0_fw_unavailable(priv);
if (ret)
return ret;
if (priv->admin_state[id] == ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED)
return 0;
msg = pd692x0_msg_template_list[PD692X0_MSG_SET_PORT_PARAM];
msg.data[0] = 0x0;
msg.sub[2] = id;
ret = pd692x0_sendrecv_msg(priv, &msg, &buf);
if (ret < 0)
return ret;
priv->admin_state[id] = ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED;
return 0;
}
static int pd692x0_pi_is_enabled(struct pse_controller_dev *pcdev, int id)
{
struct pd692x0_priv *priv = to_pd692x0_priv(pcdev);
struct pd692x0_msg msg, buf = {0};
int ret;
ret = pd692x0_fw_unavailable(priv);
if (ret)
return ret;
msg = pd692x0_msg_template_list[PD692X0_MSG_GET_PORT_STATUS];
msg.sub[2] = id;
ret = pd692x0_sendrecv_msg(priv, &msg, &buf);
if (ret < 0)
return ret;
if (buf.sub[1]) {
priv->admin_state[id] = ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED;
return 1;
} else {
priv->admin_state[id] = ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED;
return 0;
}
}
static int pd692x0_ethtool_get_status(struct pse_controller_dev *pcdev,
unsigned long id,
struct netlink_ext_ack *extack,
struct pse_control_status *status)
{
struct pd692x0_priv *priv = to_pd692x0_priv(pcdev);
struct pd692x0_msg msg, buf = {0};
int ret;
ret = pd692x0_fw_unavailable(priv);
if (ret)
return ret;
msg = pd692x0_msg_template_list[PD692X0_MSG_GET_PORT_STATUS];
msg.sub[2] = id;
ret = pd692x0_sendrecv_msg(priv, &msg, &buf);
if (ret < 0)
return ret;
/* Compare Port Status (Communication Protocol Document par. 7.1) */
if ((buf.sub[0] & 0xf0) == 0x80 || (buf.sub[0] & 0xf0) == 0x90)
status->c33_pw_status = ETHTOOL_C33_PSE_PW_D_STATUS_DELIVERING;
else if (buf.sub[0] == 0x1b || buf.sub[0] == 0x22)
status->c33_pw_status = ETHTOOL_C33_PSE_PW_D_STATUS_SEARCHING;
else if (buf.sub[0] == 0x12)
status->c33_pw_status = ETHTOOL_C33_PSE_PW_D_STATUS_FAULT;
else
status->c33_pw_status = ETHTOOL_C33_PSE_PW_D_STATUS_DISABLED;
if (buf.sub[1])
status->c33_admin_state = ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED;
else
status->c33_admin_state = ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED;
priv->admin_state[id] = status->c33_admin_state;
return 0;
}
static struct pd692x0_msg_ver pd692x0_get_sw_version(struct pd692x0_priv *priv)
{
struct device *dev = &priv->client->dev;
struct pd692x0_msg msg, buf = {0};
struct pd692x0_msg_ver ver = {0};
int ret;
msg = pd692x0_msg_template_list[PD692X0_MSG_GET_SW_VER];
ret = pd692x0_sendrecv_msg(priv, &msg, &buf);
if (ret < 0) {
dev_err(dev, "Failed to get PSE version (%pe)\n", ERR_PTR(ret));
return ver;
}
/* Extract version from the message */
ver.prod = buf.sub[2];
ver.maj_sw_ver = (buf.data[0] << 8 | buf.data[1]) / 100;
ver.min_sw_ver = ((buf.data[0] << 8 | buf.data[1]) / 10) % 10;
ver.pa_sw_ver = (buf.data[0] << 8 | buf.data[1]) % 10;
ver.param = buf.data[2];
ver.build = buf.data[3];
return ver;
}
struct pd692x0_manager {
struct device_node *port_node[PD692X0_MAX_MANAGER_PORTS];
int nports;
};
struct pd692x0_matrix {
u8 hw_port_a;
u8 hw_port_b;
};
static int
pd692x0_of_get_ports_manager(struct pd692x0_priv *priv,
struct pd692x0_manager *manager,
struct device_node *np)
{
struct device_node *node;
int ret, nports, i;
nports = 0;
for_each_child_of_node(np, node) {
u32 port;
if (!of_node_name_eq(node, "port"))
continue;
ret = of_property_read_u32(node, "reg", &port);
if (ret)
goto out;
if (port >= PD692X0_MAX_MANAGER_PORTS || port != nports) {
dev_err(&priv->client->dev,
"wrong number or order of manager ports (%d)\n",
port);
ret = -EINVAL;
goto out;
}
of_node_get(node);
manager->port_node[port] = node;
nports++;
}
manager->nports = nports;
return 0;
out:
for (i = 0; i < nports; i++) {
of_node_put(manager->port_node[i]);
manager->port_node[i] = NULL;
}
of_node_put(node);
return ret;
}
static int
pd692x0_of_get_managers(struct pd692x0_priv *priv,
struct pd692x0_manager manager[PD692X0_MAX_MANAGERS])
{
struct device_node *managers_node, *node;
int ret, nmanagers, i, j;
if (!priv->np)
return -EINVAL;
nmanagers = 0;
managers_node = of_get_child_by_name(priv->np, "managers");
if (!managers_node)
return -EINVAL;
for_each_child_of_node(managers_node, node) {
u32 manager_id;
if (!of_node_name_eq(node, "manager"))
continue;
ret = of_property_read_u32(node, "reg", &manager_id);
if (ret)
goto out;
if (manager_id >= PD692X0_MAX_MANAGERS ||
manager_id != nmanagers) {
dev_err(&priv->client->dev,
"wrong number or order of managers (%d)\n",
manager_id);
ret = -EINVAL;
goto out;
}
ret = pd692x0_of_get_ports_manager(priv, &manager[manager_id],
node);
if (ret)
goto out;
nmanagers++;
}
of_node_put(managers_node);
return nmanagers;
out:
for (i = 0; i < nmanagers; i++) {
for (j = 0; j < manager[i].nports; j++) {
of_node_put(manager[i].port_node[j]);
manager[i].port_node[j] = NULL;
}
}
of_node_put(node);
of_node_put(managers_node);
return ret;
}
static int
pd692x0_set_port_matrix(const struct pse_pi_pairset *pairset,
const struct pd692x0_manager *manager,
int nmanagers, struct pd692x0_matrix *port_matrix)
{
int i, j, port_cnt;
bool found = false;
if (!pairset->np)
return 0;
/* Look on every managers */
port_cnt = 0;
for (i = 0; i < nmanagers; i++) {
/* Look on every ports of the manager */
for (j = 0; j < manager[i].nports; j++) {
if (pairset->np == manager[i].port_node[j]) {
found = true;
break;
}
}
port_cnt += j;
if (found)
break;
}
if (!found)
return -ENODEV;
if (pairset->pinout == ALTERNATIVE_A)
port_matrix->hw_port_a = port_cnt;
else if (pairset->pinout == ALTERNATIVE_B)
port_matrix->hw_port_b = port_cnt;
return 0;
}
static int
pd692x0_set_ports_matrix(struct pd692x0_priv *priv,
const struct pd692x0_manager *manager,
int nmanagers,
struct pd692x0_matrix port_matrix[PD692X0_MAX_PIS])
{
struct pse_controller_dev *pcdev = &priv->pcdev;
int i, ret;
/* Init Matrix */
for (i = 0; i < PD692X0_MAX_PIS; i++) {
port_matrix[i].hw_port_a = 0xff;
port_matrix[i].hw_port_b = 0xff;
}
/* Update with values for every PSE PIs */
for (i = 0; i < pcdev->nr_lines; i++) {
ret = pd692x0_set_port_matrix(&pcdev->pi[i].pairset[0],
manager, nmanagers,
&port_matrix[i]);
if (ret) {
dev_err(&priv->client->dev,
"unable to configure pi %d pairset 0", i);
return ret;
}
ret = pd692x0_set_port_matrix(&pcdev->pi[i].pairset[1],
manager, nmanagers,
&port_matrix[i]);
if (ret) {
dev_err(&priv->client->dev,
"unable to configure pi %d pairset 1", i);
return ret;
}
}
return 0;
}
static int
pd692x0_write_ports_matrix(struct pd692x0_priv *priv,
const struct pd692x0_matrix port_matrix[PD692X0_MAX_PIS])
{
struct pd692x0_msg msg, buf;
int ret, i;
/* Write temporary Matrix */
msg = pd692x0_msg_template_list[PD692X0_MSG_SET_TMP_PORT_MATRIX];
for (i = 0; i < PD692X0_MAX_PIS; i++) {
msg.sub[2] = i;
msg.data[0] = port_matrix[i].hw_port_b;
msg.data[1] = port_matrix[i].hw_port_a;
ret = pd692x0_sendrecv_msg(priv, &msg, &buf);
if (ret < 0)
return ret;
}
/* Program Matrix */
msg = pd692x0_msg_template_list[PD692X0_MSG_PRG_PORT_MATRIX];
ret = pd692x0_sendrecv_msg(priv, &msg, &buf);
if (ret < 0)
return ret;
return 0;
}
static int pd692x0_setup_pi_matrix(struct pse_controller_dev *pcdev)
{
struct pd692x0_manager manager[PD692X0_MAX_MANAGERS] = {0};
struct pd692x0_priv *priv = to_pd692x0_priv(pcdev);
struct pd692x0_matrix port_matrix[PD692X0_MAX_PIS];
int ret, i, j, nmanagers;
/* Should we flash the port matrix */
if (priv->fw_state != PD692X0_FW_OK &&
priv->fw_state != PD692X0_FW_COMPLETE)
return 0;
ret = pd692x0_of_get_managers(priv, manager);
if (ret < 0)
return ret;
nmanagers = ret;
ret = pd692x0_set_ports_matrix(priv, manager, nmanagers, port_matrix);
if (ret)
goto out;
ret = pd692x0_write_ports_matrix(priv, port_matrix);
if (ret)
goto out;
out:
for (i = 0; i < nmanagers; i++) {
for (j = 0; j < manager[i].nports; j++)
of_node_put(manager[i].port_node[j]);
}
return ret;
}
static const struct pse_controller_ops pd692x0_ops = {
.setup_pi_matrix = pd692x0_setup_pi_matrix,
.ethtool_get_status = pd692x0_ethtool_get_status,
.pi_enable = pd692x0_pi_enable,
.pi_disable = pd692x0_pi_disable,
.pi_is_enabled = pd692x0_pi_is_enabled,
};
#define PD692X0_FW_LINE_MAX_SZ 0xff
static int pd692x0_fw_get_next_line(const u8 *data,
char *line, size_t size)
{
size_t line_size;
int i;
line_size = min_t(size_t, size, PD692X0_FW_LINE_MAX_SZ);
memset(line, 0, PD692X0_FW_LINE_MAX_SZ);
for (i = 0; i < line_size - 1; i++) {
if (*data == '\r' && *(data + 1) == '\n') {
line[i] = '\r';
line[i + 1] = '\n';
return i + 2;
}
line[i] = *data;
data++;
}
return -EIO;
}
static enum fw_upload_err
pd692x0_fw_recv_resp(const struct i2c_client *client, unsigned long ms_timeout,
const char *msg_ok, unsigned int msg_size)
{
/* Maximum controller response size */
char fw_msg_buf[5] = {0};
unsigned long timeout;
int ret;
if (msg_size > sizeof(fw_msg_buf))
return FW_UPLOAD_ERR_RW_ERROR;
/* Read until we get something */
timeout = msecs_to_jiffies(ms_timeout) + jiffies;
while (true) {
if (time_is_before_jiffies(timeout))
return FW_UPLOAD_ERR_TIMEOUT;
ret = i2c_master_recv(client, fw_msg_buf, 1);
if (ret < 0 || *fw_msg_buf == 0) {
usleep_range(1000, 2000);
continue;
} else {
break;
}
}
/* Read remaining characters */
ret = i2c_master_recv(client, fw_msg_buf + 1, msg_size - 1);
if (strncmp(fw_msg_buf, msg_ok, msg_size)) {
dev_err(&client->dev,
"Wrong FW download process answer (%*pE)\n",
msg_size, fw_msg_buf);
return FW_UPLOAD_ERR_HW_ERROR;
}
return FW_UPLOAD_ERR_NONE;
}
static int pd692x0_fw_write_line(const struct i2c_client *client,
const char line[PD692X0_FW_LINE_MAX_SZ],
const bool last_line)
{
int ret;
while (*line != 0) {
ret = i2c_master_send(client, line, 1);
if (ret < 0)
return FW_UPLOAD_ERR_RW_ERROR;
line++;
}
if (last_line) {
ret = pd692x0_fw_recv_resp(client, 100, "TP\r\n",
sizeof("TP\r\n") - 1);
if (ret)
return ret;
} else {
ret = pd692x0_fw_recv_resp(client, 100, "T*\r\n",
sizeof("T*\r\n") - 1);
if (ret)
return ret;
}
return FW_UPLOAD_ERR_NONE;
}
static enum fw_upload_err pd692x0_fw_reset(const struct i2c_client *client)
{
const struct pd692x0_msg zero = {0};
struct pd692x0_msg buf = {0};
unsigned long timeout;
char cmd[] = "RST";
int ret;
ret = i2c_master_send(client, cmd, strlen(cmd));
if (ret < 0) {
dev_err(&client->dev,
"Failed to reset the controller (%pe)\n",
ERR_PTR(ret));
return ret;
}
timeout = msecs_to_jiffies(10000) + jiffies;
while (true) {
if (time_is_before_jiffies(timeout))
return FW_UPLOAD_ERR_TIMEOUT;
ret = i2c_master_recv(client, (u8 *)&buf, sizeof(buf));
if (ret < 0 ||
!memcmp(&buf, &zero, sizeof(buf)))
usleep_range(1000, 2000);
else
break;
}
/* Is the reply a successful report message */
if (buf.key != PD692X0_KEY_TLM || buf.echo != 0xff ||
buf.sub[0] & 0x01) {
dev_err(&client->dev, "PSE controller error\n");
return FW_UPLOAD_ERR_HW_ERROR;
}
/* Is the firmware operational */
if (buf.sub[0] & 0x02) {
dev_err(&client->dev,
"PSE firmware error. Please update it.\n");
return FW_UPLOAD_ERR_HW_ERROR;
}
return FW_UPLOAD_ERR_NONE;
}
static enum fw_upload_err pd692x0_fw_prepare(struct fw_upload *fwl,
const u8 *data, u32 size)
{
struct pd692x0_priv *priv = fwl->dd_handle;
const struct i2c_client *client = priv->client;
enum pd692x0_fw_state last_fw_state;
int ret;
priv->cancel_request = false;
last_fw_state = priv->fw_state;
priv->fw_state = PD692X0_FW_PREPARE;
/* Enter program mode */
if (last_fw_state == PD692X0_FW_BROKEN) {
const char *msg = "ENTR";
const char *c;
c = msg;
do {
ret = i2c_master_send(client, c, 1);
if (ret < 0)
return FW_UPLOAD_ERR_RW_ERROR;
if (*(c + 1))
usleep_range(10000, 20000);
} while (*(++c));
} else {
struct pd692x0_msg msg, buf;
msg = pd692x0_msg_template_list[PD692X0_MSG_DOWNLOAD_CMD];
ret = pd692x0_sendrecv_msg(priv, &msg, &buf);
if (ret < 0) {
dev_err(&client->dev,
"Failed to enter programming mode (%pe)\n",
ERR_PTR(ret));
return FW_UPLOAD_ERR_RW_ERROR;
}
}
ret = pd692x0_fw_recv_resp(client, 100, "TPE\r\n", sizeof("TPE\r\n") - 1);
if (ret)
goto err_out;
if (priv->cancel_request) {
ret = FW_UPLOAD_ERR_CANCELED;
goto err_out;
}
return FW_UPLOAD_ERR_NONE;
err_out:
pd692x0_fw_reset(priv->client);
priv->fw_state = last_fw_state;
return ret;
}
static enum fw_upload_err pd692x0_fw_write(struct fw_upload *fwl,
const u8 *data, u32 offset,
u32 size, u32 *written)
{
struct pd692x0_priv *priv = fwl->dd_handle;
char line[PD692X0_FW_LINE_MAX_SZ];
const struct i2c_client *client;
int ret, i;
char cmd;
client = priv->client;
priv->fw_state = PD692X0_FW_WRITE;
/* Erase */
cmd = 'E';
ret = i2c_master_send(client, &cmd, 1);
if (ret < 0) {
dev_err(&client->dev,
"Failed to boot programming mode (%pe)\n",
ERR_PTR(ret));
return FW_UPLOAD_ERR_RW_ERROR;
}
ret = pd692x0_fw_recv_resp(client, 100, "TOE\r\n", sizeof("TOE\r\n") - 1);
if (ret)
return ret;
ret = pd692x0_fw_recv_resp(client, 5000, "TE\r\n", sizeof("TE\r\n") - 1);
if (ret)
dev_warn(&client->dev,
"Failed to erase internal memory, however still try to write Firmware\n");
ret = pd692x0_fw_recv_resp(client, 100, "TPE\r\n", sizeof("TPE\r\n") - 1);
if (ret)
dev_warn(&client->dev,
"Failed to erase internal memory, however still try to write Firmware\n");
if (priv->cancel_request)
return FW_UPLOAD_ERR_CANCELED;
/* Program */
cmd = 'P';
ret = i2c_master_send(client, &cmd, sizeof(char));
if (ret < 0) {
dev_err(&client->dev,
"Failed to boot programming mode (%pe)\n",
ERR_PTR(ret));
return ret;
}
ret = pd692x0_fw_recv_resp(client, 100, "TOP\r\n", sizeof("TOP\r\n") - 1);
if (ret)
return ret;
i = 0;
while (i < size) {
ret = pd692x0_fw_get_next_line(data, line, size - i);
if (ret < 0) {
ret = FW_UPLOAD_ERR_FW_INVALID;
goto err;
}
i += ret;
data += ret;
if (line[0] == 'S' && line[1] == '0') {
continue;
} else if (line[0] == 'S' && line[1] == '7') {
ret = pd692x0_fw_write_line(client, line, true);
if (ret)
goto err;
} else {
ret = pd692x0_fw_write_line(client, line, false);
if (ret)
goto err;
}
if (priv->cancel_request) {
ret = FW_UPLOAD_ERR_CANCELED;
goto err;
}
}
*written = i;
msleep(400);
return FW_UPLOAD_ERR_NONE;
err:
strscpy_pad(line, "S7\r\n", sizeof(line));
pd692x0_fw_write_line(client, line, true);
return ret;
}
static enum fw_upload_err pd692x0_fw_poll_complete(struct fw_upload *fwl)
{
struct pd692x0_priv *priv = fwl->dd_handle;
const struct i2c_client *client = priv->client;
struct pd692x0_msg_ver ver;
int ret;
priv->fw_state = PD692X0_FW_COMPLETE;
ret = pd692x0_fw_reset(client);
if (ret)
return ret;
ver = pd692x0_get_sw_version(priv);
if (ver.maj_sw_ver < PD692X0_FW_MAJ_VER) {
dev_err(&client->dev,
"Too old firmware version. Please update it\n");
priv->fw_state = PD692X0_FW_NEED_UPDATE;
return FW_UPLOAD_ERR_FW_INVALID;
}
ret = pd692x0_setup_pi_matrix(&priv->pcdev);
if (ret < 0) {
dev_err(&client->dev, "Error configuring ports matrix (%pe)\n",
ERR_PTR(ret));
priv->fw_state = PD692X0_FW_NEED_UPDATE;
return FW_UPLOAD_ERR_HW_ERROR;
}
priv->fw_state = PD692X0_FW_OK;
return FW_UPLOAD_ERR_NONE;
}
static void pd692x0_fw_cancel(struct fw_upload *fwl)
{
struct pd692x0_priv *priv = fwl->dd_handle;
priv->cancel_request = true;
}
static void pd692x0_fw_cleanup(struct fw_upload *fwl)
{
struct pd692x0_priv *priv = fwl->dd_handle;
switch (priv->fw_state) {
case PD692X0_FW_WRITE:
pd692x0_fw_reset(priv->client);
fallthrough;
case PD692X0_FW_COMPLETE:
priv->fw_state = PD692X0_FW_BROKEN;
break;
default:
break;
}
}
static const struct fw_upload_ops pd692x0_fw_ops = {
.prepare = pd692x0_fw_prepare,
.write = pd692x0_fw_write,
.poll_complete = pd692x0_fw_poll_complete,
.cancel = pd692x0_fw_cancel,
.cleanup = pd692x0_fw_cleanup,
};
static int pd692x0_i2c_probe(struct i2c_client *client)
{
struct pd692x0_msg msg, buf = {0}, zero = {0};
struct device *dev = &client->dev;
struct pd692x0_msg_ver ver;
struct pd692x0_priv *priv;
struct fw_upload *fwl;
int ret;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(dev, "i2c check functionality failed\n");
return -ENXIO;
}
priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
priv->client = client;
i2c_set_clientdata(client, priv);
ret = i2c_master_recv(client, (u8 *)&buf, sizeof(buf));
if (ret != sizeof(buf)) {
dev_err(dev, "Failed to get device status\n");
return -EIO;
}
/* Probe has been already run and the status dumped */
if (!memcmp(&buf, &zero, sizeof(buf))) {
/* Ask again the controller status */
msg = pd692x0_msg_template_list[PD692X0_MSG_GET_SYS_STATUS];
ret = pd692x0_sendrecv_msg(priv, &msg, &buf);
if (ret < 0) {
dev_err(dev, "Failed to get device status\n");
return ret;
}
}
if (buf.key != 0x03 || buf.sub[0] & 0x01) {
dev_err(dev, "PSE controller error\n");
return -EIO;
}
if (buf.sub[0] & 0x02) {
dev_err(dev, "PSE firmware error. Please update it.\n");
priv->fw_state = PD692X0_FW_BROKEN;
} else {
ver = pd692x0_get_sw_version(priv);
dev_info(&client->dev, "Software version %d.%02d.%d.%d\n",
ver.prod, ver.maj_sw_ver, ver.min_sw_ver,
ver.pa_sw_ver);
if (ver.maj_sw_ver < PD692X0_FW_MAJ_VER) {
dev_err(dev, "Too old firmware version. Please update it\n");
priv->fw_state = PD692X0_FW_NEED_UPDATE;
} else {
priv->fw_state = PD692X0_FW_OK;
}
}
priv->np = dev->of_node;
priv->pcdev.nr_lines = PD692X0_MAX_PIS;
priv->pcdev.owner = THIS_MODULE;
priv->pcdev.ops = &pd692x0_ops;
priv->pcdev.dev = dev;
priv->pcdev.types = ETHTOOL_PSE_C33;
ret = devm_pse_controller_register(dev, &priv->pcdev);
if (ret)
return dev_err_probe(dev, ret,
"failed to register PSE controller\n");
fwl = firmware_upload_register(THIS_MODULE, dev, dev_name(dev),
&pd692x0_fw_ops, priv);
if (IS_ERR(fwl))
return dev_err_probe(dev, PTR_ERR(fwl),
"failed to register to the Firmware Upload API\n");
priv->fwl = fwl;
return 0;
}
static void pd692x0_i2c_remove(struct i2c_client *client)
{
struct pd692x0_priv *priv = i2c_get_clientdata(client);
firmware_upload_unregister(priv->fwl);
}
static const struct i2c_device_id pd692x0_id[] = {
{ PD692X0_PSE_NAME, 0 },
{ },
};
MODULE_DEVICE_TABLE(i2c, pd692x0_id);
static const struct of_device_id pd692x0_of_match[] = {
{ .compatible = "microchip,pd69200", },
{ .compatible = "microchip,pd69210", },
{ .compatible = "microchip,pd69220", },
{ },
};
MODULE_DEVICE_TABLE(of, pd692x0_of_match);
static struct i2c_driver pd692x0_driver = {
.probe = pd692x0_i2c_probe,
.remove = pd692x0_i2c_remove,
.id_table = pd692x0_id,
.driver = {
.name = PD692X0_PSE_NAME,
.of_match_table = pd692x0_of_match,
},
};
module_i2c_driver(pd692x0_driver);
MODULE_AUTHOR("Kory Maincent <kory.maincent@bootlin.com>");
MODULE_DESCRIPTION("Microchip PD692x0 PoE PSE Controller driver");
MODULE_LICENSE("GPL");
drivers/net/pse-pd/pse_core.c
View file @ 33d21bd1
......@@ -8,6 +8,8 @@
#include <linux/device.h>
#include <linux/of.h>
#include <linux/pse-pd/pse.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
static DEFINE_MUTEX(pse_list_mutex);
static LIST_HEAD(pse_controller_list);
......@@ -16,49 +18,303 @@ static LIST_HEAD(pse_controller_list);
* struct pse_control - a PSE control
* @pcdev: a pointer to the PSE controller device
* this PSE control belongs to
* @ps: PSE PI supply of the PSE control
* @list: list entry for the pcdev's PSE controller list
* @id: ID of the PSE line in the PSE controller device
* @refcnt: Number of gets of this pse_control
*/
struct pse_control {
struct pse_controller_dev *pcdev;
struct regulator *ps;
struct list_head list;
unsigned int id;
struct kref refcnt;
};
static int of_load_single_pse_pi_pairset(struct device_node *node,
struct pse_pi *pi,
int pairset_num)
{
struct device_node *pairset_np;
const char *name;
int ret;
ret = of_property_read_string_index(node, "pairset-names",
pairset_num, &name);
if (ret)
return ret;
if (!strcmp(name, "alternative-a")) {
pi->pairset[pairset_num].pinout = ALTERNATIVE_A;
} else if (!strcmp(name, "alternative-b")) {
pi->pairset[pairset_num].pinout = ALTERNATIVE_B;
} else {
pr_err("pse: wrong pairset-names value %s (%pOF)\n",
name, node);
return -EINVAL;
}
pairset_np = of_parse_phandle(node, "pairsets", pairset_num);
if (!pairset_np)
return -ENODEV;
pi->pairset[pairset_num].np = pairset_np;
return 0;
}
/**
* of_pse_zero_xlate - dummy function for controllers with one only control
* @pcdev: a pointer to the PSE controller device
* @pse_spec: PSE line specifier as found in the device tree
* of_load_pse_pi_pairsets - load PSE PI pairsets pinout and polarity
* @node: a pointer of the device node
* @pi: a pointer of the PSE PI to fill
* @npairsets: the number of pairsets (1 or 2) used by the PI
*
* This static translation function is used by default if of_xlate in
* :c:type:`pse_controller_dev` is not set. It is useful for all PSE
* controllers with #pse-cells = <0>.
* Return: 0 on success and failure value on error
*/
static int of_pse_zero_xlate(struct pse_controller_dev *pcdev,
const struct of_phandle_args *pse_spec)
static int of_load_pse_pi_pairsets(struct device_node *node,
struct pse_pi *pi,
int npairsets)
{
return 0;
int i, ret;
ret = of_property_count_strings(node, "pairset-names");
if (ret != npairsets) {
pr_err("pse: amount of pairsets and pairset-names is not equal %d != %d (%pOF)\n",
npairsets, ret, node);
return -EINVAL;
}
for (i = 0; i < npairsets; i++) {
ret = of_load_single_pse_pi_pairset(node, pi, i);
if (ret)
goto out;
}
if (npairsets == 2 &&
pi->pairset[0].pinout == pi->pairset[1].pinout) {
pr_err("pse: two PI pairsets can not have identical pinout (%pOF)",
node);
ret = -EINVAL;
}
out:
/* If an error appears, release all the pairset device node kref */
if (ret) {
of_node_put(pi->pairset[0].np);
pi->pairset[0].np = NULL;
of_node_put(pi->pairset[1].np);
pi->pairset[1].np = NULL;
}
return ret;
}
static void pse_release_pis(struct pse_controller_dev *pcdev)
{
int i;
for (i = 0; i <= pcdev->nr_lines; i++) {
of_node_put(pcdev->pi[i].pairset[0].np);
of_node_put(pcdev->pi[i].pairset[1].np);
of_node_put(pcdev->pi[i].np);
}
kfree(pcdev->pi);
}
/**
* of_pse_simple_xlate - translate pse_spec to the PSE line number
* of_load_pse_pis - load all the PSE PIs
* @pcdev: a pointer to the PSE controller device
* @pse_spec: PSE line specifier as found in the device tree
*
* This static translation function is used by default if of_xlate in
* :c:type:`pse_controller_dev` is not set. It is useful for all PSE
* controllers with 1:1 mapping, where PSE lines can be indexed by number
* without gaps.
* Return: 0 on success and failure value on error
*/
static int of_pse_simple_xlate(struct pse_controller_dev *pcdev,
const struct of_phandle_args *pse_spec)
static int of_load_pse_pis(struct pse_controller_dev *pcdev)
{
if (pse_spec->args[0] >= pcdev->nr_lines)
return -EINVAL;
struct device_node *np = pcdev->dev->of_node;
struct device_node *node, *pis;
int ret;
return pse_spec->args[0];
if (!np)
return -ENODEV;
pcdev->pi = kcalloc(pcdev->nr_lines, sizeof(*pcdev->pi), GFP_KERNEL);
if (!pcdev->pi)
return -ENOMEM;
pis = of_get_child_by_name(np, "pse-pis");
if (!pis) {
/* no description of PSE PIs */
pcdev->no_of_pse_pi = true;
return 0;
}
for_each_child_of_node(pis, node) {
struct pse_pi pi = {0};
u32 id;
if (!of_node_name_eq(node, "pse-pi"))
continue;
ret = of_property_read_u32(node, "reg", &id);
if (ret) {
dev_err(pcdev->dev,
"can't get reg property for node '%pOF'",
node);
goto out;
}
if (id >= pcdev->nr_lines) {
dev_err(pcdev->dev,
"reg value (%u) is out of range (%u) (%pOF)\n",
id, pcdev->nr_lines, node);
ret = -EINVAL;
goto out;
}
if (pcdev->pi[id].np) {
dev_err(pcdev->dev,
"other node with same reg value was already registered. %pOF : %pOF\n",
pcdev->pi[id].np, node);
ret = -EINVAL;
goto out;
}
ret = of_count_phandle_with_args(node, "pairsets", NULL);
/* npairsets is limited to value one or two */
if (ret == 1 || ret == 2) {
ret = of_load_pse_pi_pairsets(node, &pi, ret);
if (ret)
goto out;
} else if (ret != ENOENT) {
dev_err(pcdev->dev,
"error: wrong number of pairsets. Should be 1 or 2, got %d (%pOF)\n",
ret, node);
ret = -EINVAL;
goto out;
}
of_node_get(node);
pi.np = node;
memcpy(&pcdev->pi[id], &pi, sizeof(pi));
}
of_node_put(pis);
return 0;
out:
pse_release_pis(pcdev);
of_node_put(node);
of_node_put(pis);
return ret;
}
static int pse_pi_is_enabled(struct regulator_dev *rdev)
{
struct pse_controller_dev *pcdev = rdev_get_drvdata(rdev);
const struct pse_controller_ops *ops;
int id, ret;
ops = pcdev->ops;
if (!ops->pi_is_enabled)
return -EOPNOTSUPP;
id = rdev_get_id(rdev);
mutex_lock(&pcdev->lock);
ret = ops->pi_is_enabled(pcdev, id);
mutex_unlock(&pcdev->lock);
return ret;
}
static int pse_pi_enable(struct regulator_dev *rdev)
{
struct pse_controller_dev *pcdev = rdev_get_drvdata(rdev);
const struct pse_controller_ops *ops;
int id, ret;
ops = pcdev->ops;
if (!ops->pi_enable)
return -EOPNOTSUPP;
id = rdev_get_id(rdev);
mutex_lock(&pcdev->lock);
ret = ops->pi_enable(pcdev, id);
if (!ret)
pcdev->pi[id].admin_state_enabled = 1;
mutex_unlock(&pcdev->lock);
return ret;
}
static int pse_pi_disable(struct regulator_dev *rdev)
{
struct pse_controller_dev *pcdev = rdev_get_drvdata(rdev);
const struct pse_controller_ops *ops;
int id, ret;
ops = pcdev->ops;
if (!ops->pi_disable)
return -EOPNOTSUPP;
id = rdev_get_id(rdev);
mutex_lock(&pcdev->lock);
ret = ops->pi_disable(pcdev, id);
if (!ret)
pcdev->pi[id].admin_state_enabled = 0;
mutex_unlock(&pcdev->lock);
return ret;
}
static const struct regulator_ops pse_pi_ops = {
.is_enabled = pse_pi_is_enabled,
.enable = pse_pi_enable,
.disable = pse_pi_disable,
};
static int
devm_pse_pi_regulator_register(struct pse_controller_dev *pcdev,
char *name, int id)
{
struct regulator_init_data *rinit_data;
struct regulator_config rconfig = {0};
struct regulator_desc *rdesc;
struct regulator_dev *rdev;
rinit_data = devm_kzalloc(pcdev->dev, sizeof(*rinit_data),
GFP_KERNEL);
if (!rinit_data)
return -ENOMEM;
rdesc = devm_kzalloc(pcdev->dev, sizeof(*rdesc), GFP_KERNEL);
if (!rdesc)
return -ENOMEM;
/* Regulator descriptor id have to be the same as its associated
* PSE PI id for the well functioning of the PSE controls.
*/
rdesc->id = id;
rdesc->name = name;
rdesc->type = REGULATOR_CURRENT;
rdesc->ops = &pse_pi_ops;
rdesc->owner = pcdev->owner;
rinit_data->constraints.valid_ops_mask = REGULATOR_CHANGE_STATUS;
rinit_data->supply_regulator = "vpwr";
rconfig.dev = pcdev->dev;
rconfig.driver_data = pcdev;
rconfig.init_data = rinit_data;
rdev = devm_regulator_register(pcdev->dev, rdesc, &rconfig);
if (IS_ERR(rdev)) {
dev_err_probe(pcdev->dev, PTR_ERR(rdev),
"Failed to register regulator\n");
return PTR_ERR(rdev);
}
pcdev->pi[id].rdev = rdev;
return 0;
}
/**
......@@ -67,16 +323,50 @@ static int of_pse_simple_xlate(struct pse_controller_dev *pcdev,
*/
int pse_controller_register(struct pse_controller_dev *pcdev)
{
if (!pcdev->of_xlate) {
if (pcdev->of_pse_n_cells == 0)
pcdev->of_xlate = of_pse_zero_xlate;
else if (pcdev->of_pse_n_cells == 1)
pcdev->of_xlate = of_pse_simple_xlate;
}
size_t reg_name_len;
int ret, i;
mutex_init(&pcdev->lock);
INIT_LIST_HEAD(&pcdev->pse_control_head);
if (!pcdev->nr_lines)
pcdev->nr_lines = 1;
ret = of_load_pse_pis(pcdev);
if (ret)
return ret;
if (pcdev->ops->setup_pi_matrix) {
ret = pcdev->ops->setup_pi_matrix(pcdev);
if (ret)
return ret;
}
/* Each regulator name len is pcdev dev name + 7 char +
* int max digit number (10) + 1
*/
reg_name_len = strlen(dev_name(pcdev->dev)) + 18;
/* Register PI regulators */
for (i = 0; i < pcdev->nr_lines; i++) {
char *reg_name;
/* Do not register regulator for PIs not described */
if (!pcdev->no_of_pse_pi && !pcdev->pi[i].np)
continue;
reg_name = devm_kzalloc(pcdev->dev, reg_name_len, GFP_KERNEL);
if (!reg_name)
return -ENOMEM;
snprintf(reg_name, reg_name_len, "pse-%s_pi%d",
dev_name(pcdev->dev), i);
ret = devm_pse_pi_regulator_register(pcdev, reg_name, i);
if (ret)
return ret;
}
mutex_lock(&pse_list_mutex);
list_add(&pcdev->list, &pse_controller_list);
mutex_unlock(&pse_list_mutex);
......@@ -91,6 +381,7 @@ EXPORT_SYMBOL_GPL(pse_controller_register);
*/
void pse_controller_unregister(struct pse_controller_dev *pcdev)
{
pse_release_pis(pcdev);
mutex_lock(&pse_list_mutex);
list_del(&pcdev->list);
mutex_unlock(&pse_list_mutex);
......@@ -144,6 +435,10 @@ static void __pse_control_release(struct kref *kref)
lockdep_assert_held(&pse_list_mutex);
if (psec->pcdev->pi[psec->id].admin_state_enabled)
regulator_disable(psec->ps);
devm_regulator_put(psec->ps);
module_put(psec->pcdev->owner);
list_del(&psec->list);
......@@ -176,6 +471,7 @@ static struct pse_control *
pse_control_get_internal(struct pse_controller_dev *pcdev, unsigned int index)
{
struct pse_control *psec;
int ret;
lockdep_assert_held(&pse_list_mutex);
......@@ -191,20 +487,82 @@ pse_control_get_internal(struct pse_controller_dev *pcdev, unsigned int index)
return ERR_PTR(-ENOMEM);
if (!try_module_get(pcdev->owner)) {
kfree(psec);
return ERR_PTR(-ENODEV);
ret = -ENODEV;
goto free_psec;
}
psec->ps = devm_regulator_get_exclusive(pcdev->dev,
rdev_get_name(pcdev->pi[index].rdev));
if (IS_ERR(psec->ps)) {
ret = PTR_ERR(psec->ps);
goto put_module;
}
ret = regulator_is_enabled(psec->ps);
if (ret < 0)
goto regulator_put;
pcdev->pi[index].admin_state_enabled = ret;
psec->pcdev = pcdev;
list_add(&psec->list, &pcdev->pse_control_head);
psec->id = index;
kref_init(&psec->refcnt);
return psec;
regulator_put:
devm_regulator_put(psec->ps);
put_module:
module_put(pcdev->owner);
free_psec:
kfree(psec);
return ERR_PTR(ret);
}
/**
* of_pse_match_pi - Find the PSE PI id matching the device node phandle
* @pcdev: a pointer to the PSE controller device
* @np: a pointer to the device node
*
* Return: id of the PSE PI, -EINVAL if not found
*/
static int of_pse_match_pi(struct pse_controller_dev *pcdev,
struct device_node *np)
{
int i;
for (i = 0; i <= pcdev->nr_lines; i++) {
if (pcdev->pi[i].np == np)
return i;
}
return -EINVAL;
}
/**
* psec_id_xlate - translate pse_spec to the PSE line number according
* to the number of pse-cells in case of no pse_pi node
* @pcdev: a pointer to the PSE controller device
* @pse_spec: PSE line specifier as found in the device tree
*
* Return: 0 if #pse-cells = <0>. Return PSE line number otherwise.
*/
static int psec_id_xlate(struct pse_controller_dev *pcdev,
const struct of_phandle_args *pse_spec)
{
if (!pcdev->of_pse_n_cells)
return 0;
if (pcdev->of_pse_n_cells > 1 ||
pse_spec->args[0] >= pcdev->nr_lines)
return -EINVAL;
return pse_spec->args[0];
}
struct pse_control *
of_pse_control_get(struct device_node *node)
struct pse_control *of_pse_control_get(struct device_node *node)
{
struct pse_controller_dev *r, *pcdev;
struct of_phandle_args args;
......@@ -222,7 +580,14 @@ of_pse_control_get(struct device_node *node)
mutex_lock(&pse_list_mutex);
pcdev = NULL;
list_for_each_entry(r, &pse_controller_list, list) {
if (args.np == r->dev->of_node) {
if (!r->no_of_pse_pi) {
ret = of_pse_match_pi(r, args.np);
if (ret >= 0) {
pcdev = r;
psec_id = ret;
break;
}
} else if (args.np == r->dev->of_node) {
pcdev = r;
break;
}
......@@ -238,11 +603,13 @@ of_pse_control_get(struct device_node *node)
goto out;
}
psec_id = pcdev->of_xlate(pcdev, &args);
if (pcdev->no_of_pse_pi) {
psec_id = psec_id_xlate(pcdev, &args);
if (psec_id < 0) {
psec = ERR_PTR(psec_id);
goto out;
}
}
/* pse_list_mutex also protects the pcdev's pse_control list */
psec = pse_control_get_internal(pcdev, psec_id);
......@@ -284,6 +651,54 @@ int pse_ethtool_get_status(struct pse_control *psec,
}
EXPORT_SYMBOL_GPL(pse_ethtool_get_status);
static int pse_ethtool_c33_set_config(struct pse_control *psec,
const struct pse_control_config *config)
{
int err = 0;
/* Look at admin_state_enabled status to not call regulator_enable
* or regulator_disable twice creating a regulator counter mismatch
*/
switch (config->c33_admin_control) {
case ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED:
if (!psec->pcdev->pi[psec->id].admin_state_enabled)
err = regulator_enable(psec->ps);
break;
case ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED:
if (psec->pcdev->pi[psec->id].admin_state_enabled)
err = regulator_disable(psec->ps);
break;
default:
err = -EOPNOTSUPP;
}
return err;
}
static int pse_ethtool_podl_set_config(struct pse_control *psec,
const struct pse_control_config *config)
{
int err = 0;
/* Look at admin_state_enabled status to not call regulator_enable
* or regulator_disable twice creating a regulator counter mismatch
*/
switch (config->podl_admin_control) {
case ETHTOOL_PODL_PSE_ADMIN_STATE_ENABLED:
if (!psec->pcdev->pi[psec->id].admin_state_enabled)
err = regulator_enable(psec->ps);
break;
case ETHTOOL_PODL_PSE_ADMIN_STATE_DISABLED:
if (psec->pcdev->pi[psec->id].admin_state_enabled)
err = regulator_disable(psec->ps);
break;
default:
err = -EOPNOTSUPP;
}
return err;
}
/**
* pse_ethtool_set_config - set PSE control configuration
* @psec: PSE control pointer
......@@ -294,21 +709,29 @@ int pse_ethtool_set_config(struct pse_control *psec,
struct netlink_ext_ack *extack,
const struct pse_control_config *config)
{
const struct pse_controller_ops *ops;
int err;
int err = 0;
ops = psec->pcdev->ops;
if (!ops->ethtool_set_config) {
NL_SET_ERR_MSG(extack,
"PSE driver does not configuration");
return -EOPNOTSUPP;
if (pse_has_c33(psec)) {
err = pse_ethtool_c33_set_config(psec, config);
if (err)
return err;
}
mutex_lock(&psec->pcdev->lock);
err = ops->ethtool_set_config(psec->pcdev, psec->id, extack, config);
mutex_unlock(&psec->pcdev->lock);
if (pse_has_podl(psec))
err = pse_ethtool_podl_set_config(psec, config);
return err;
}
EXPORT_SYMBOL_GPL(pse_ethtool_set_config);
bool pse_has_podl(struct pse_control *psec)
{
return psec->pcdev->types & ETHTOOL_PSE_PODL;
}
EXPORT_SYMBOL_GPL(pse_has_podl);
bool pse_has_c33(struct pse_control *psec)
{
return psec->pcdev->types & ETHTOOL_PSE_C33;
}
EXPORT_SYMBOL_GPL(pse_has_c33);
drivers/net/pse-pd/pse_regulator.c
View file @ 33d21bd1
......@@ -24,37 +24,41 @@ static struct pse_reg_priv *to_pse_reg(struct pse_controller_dev *pcdev)
}
static int
pse_reg_ethtool_set_config(struct pse_controller_dev *pcdev, unsigned long id,
struct netlink_ext_ack *extack,
const struct pse_control_config *config)
pse_reg_pi_enable(struct pse_controller_dev *pcdev, int id)
{
struct pse_reg_priv *priv = to_pse_reg(pcdev);
int ret;
if (priv->admin_state == config->podl_admin_control)
ret = regulator_enable(priv->ps);
if (ret)
return ret;
priv->admin_state = ETHTOOL_PODL_PSE_ADMIN_STATE_ENABLED;
return 0;
}
switch (config->podl_admin_control) {
case ETHTOOL_PODL_PSE_ADMIN_STATE_ENABLED:
ret = regulator_enable(priv->ps);
break;
case ETHTOOL_PODL_PSE_ADMIN_STATE_DISABLED:
ret = regulator_disable(priv->ps);
break;
default:
dev_err(pcdev->dev, "Unknown admin state %i\n",
config->podl_admin_control);
ret = -ENOTSUPP;
}
static int
pse_reg_pi_disable(struct pse_controller_dev *pcdev, int id)
{
struct pse_reg_priv *priv = to_pse_reg(pcdev);
int ret;
ret = regulator_disable(priv->ps);
if (ret)
return ret;
priv->admin_state = config->podl_admin_control;
priv->admin_state = ETHTOOL_PODL_PSE_ADMIN_STATE_DISABLED;
return 0;
}
static int
pse_reg_pi_is_enabled(struct pse_controller_dev *pcdev, int id)
{
struct pse_reg_priv *priv = to_pse_reg(pcdev);
return regulator_is_enabled(priv->ps);
}
static int
pse_reg_ethtool_get_status(struct pse_controller_dev *pcdev, unsigned long id,
struct netlink_ext_ack *extack,
......@@ -80,7 +84,9 @@ pse_reg_ethtool_get_status(struct pse_controller_dev *pcdev, unsigned long id,
static const struct pse_controller_ops pse_reg_ops = {
.ethtool_get_status = pse_reg_ethtool_get_status,
.ethtool_set_config = pse_reg_ethtool_set_config,
.pi_enable = pse_reg_pi_enable,
.pi_is_enabled = pse_reg_pi_is_enabled,
.pi_disable = pse_reg_pi_disable,
};
static int
......@@ -116,6 +122,7 @@ pse_reg_probe(struct platform_device *pdev)
priv->pcdev.owner = THIS_MODULE;
priv->pcdev.ops = &pse_reg_ops;
priv->pcdev.dev = dev;
priv->pcdev.types = ETHTOOL_PSE_PODL;
ret = devm_pse_controller_register(dev, &priv->pcdev);
if (ret) {
dev_err(dev, "failed to register PSE controller (%pe)\n",
......
drivers/net/pse-pd/tps23881.c 0 → 100644
View file @ 33d21bd1
// SPDX-License-Identifier: GPL-2.0-only
/*
* Driver for the TI TPS23881 PoE PSE Controller driver (I2C bus)
*
* Copyright (c) 2023 Bootlin, Kory Maincent <kory.maincent@bootlin.com>
*/
#include <linux/delay.h>
#include <linux/firmware.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/pse-pd/pse.h>
#define TPS23881_MAX_CHANS 8
#define TPS23881_REG_PW_STATUS 0x10
#define TPS23881_REG_OP_MODE 0x12
#define TPS23881_OP_MODE_SEMIAUTO 0xaaaa
#define TPS23881_REG_DIS_EN 0x13
#define TPS23881_REG_DET_CLA_EN 0x14
#define TPS23881_REG_GEN_MASK 0x17
#define TPS23881_REG_NBITACC BIT(5)
#define TPS23881_REG_PW_EN 0x19
#define TPS23881_REG_PORT_MAP 0x26
#define TPS23881_REG_PORT_POWER 0x29
#define TPS23881_REG_POEPLUS 0x40
#define TPS23881_REG_TPON BIT(0)
#define TPS23881_REG_FWREV 0x41
#define TPS23881_REG_DEVID 0x43
#define TPS23881_REG_SRAM_CTRL 0x60
#define TPS23881_REG_SRAM_DATA 0x61
struct tps23881_port_desc {
u8 chan[2];
bool is_4p;
};
struct tps23881_priv {
struct i2c_client *client;
struct pse_controller_dev pcdev;
struct device_node *np;
struct tps23881_port_desc port[TPS23881_MAX_CHANS];
};
static struct tps23881_priv *to_tps23881_priv(struct pse_controller_dev *pcdev)
{
return container_of(pcdev, struct tps23881_priv, pcdev);
}
static int tps23881_pi_enable(struct pse_controller_dev *pcdev, int id)
{
struct tps23881_priv *priv = to_tps23881_priv(pcdev);
struct i2c_client *client = priv->client;
u8 chan;
u16 val;
int ret;
if (id >= TPS23881_MAX_CHANS)
return -ERANGE;
ret = i2c_smbus_read_word_data(client, TPS23881_REG_PW_STATUS);
if (ret < 0)
return ret;
chan = priv->port[id].chan[0];
if (chan < 4)
val = (u16)(ret | BIT(chan));
else
val = (u16)(ret | BIT(chan + 4));
if (priv->port[id].is_4p) {
chan = priv->port[id].chan[1];
if (chan < 4)
val |= BIT(chan);
else
val |= BIT(chan + 4);
}
ret = i2c_smbus_write_word_data(client, TPS23881_REG_PW_EN, val);
if (ret)
return ret;
return 0;
}
static int tps23881_pi_disable(struct pse_controller_dev *pcdev, int id)
{
struct tps23881_priv *priv = to_tps23881_priv(pcdev);
struct i2c_client *client = priv->client;
u8 chan;
u16 val;
int ret;
if (id >= TPS23881_MAX_CHANS)
return -ERANGE;
ret = i2c_smbus_read_word_data(client, TPS23881_REG_PW_STATUS);
if (ret < 0)
return ret;
chan = priv->port[id].chan[0];
if (chan < 4)
val = (u16)(ret | BIT(chan + 4));
else
val = (u16)(ret | BIT(chan + 8));
if (priv->port[id].is_4p) {
chan = priv->port[id].chan[1];
if (chan < 4)
val |= BIT(chan + 4);
else
val |= BIT(chan + 8);
}
ret = i2c_smbus_write_word_data(client, TPS23881_REG_PW_EN, val);
if (ret)
return ret;
return 0;
}
static int tps23881_pi_is_enabled(struct pse_controller_dev *pcdev, int id)
{
struct tps23881_priv *priv = to_tps23881_priv(pcdev);
struct i2c_client *client = priv->client;
bool enabled;
u8 chan;
int ret;
ret = i2c_smbus_read_word_data(client, TPS23881_REG_PW_STATUS);
if (ret < 0)
return ret;
chan = priv->port[id].chan[0];
if (chan < 4)
enabled = ret & BIT(chan);
else
enabled = ret & BIT(chan + 4);
if (priv->port[id].is_4p) {
chan = priv->port[id].chan[1];
if (chan < 4)
enabled &= !!(ret & BIT(chan));
else
enabled &= !!(ret & BIT(chan + 4));
}
/* Return enabled status only if both channel are on this state */
return enabled;
}
static int tps23881_ethtool_get_status(struct pse_controller_dev *pcdev,
unsigned long id,
struct netlink_ext_ack *extack,
struct pse_control_status *status)
{
struct tps23881_priv *priv = to_tps23881_priv(pcdev);
struct i2c_client *client = priv->client;
bool enabled, delivering;
u8 chan;
int ret;
ret = i2c_smbus_read_word_data(client, TPS23881_REG_PW_STATUS);
if (ret < 0)
return ret;
chan = priv->port[id].chan[0];
if (chan < 4) {
enabled = ret & BIT(chan);
delivering = ret & BIT(chan + 4);
} else {
enabled = ret & BIT(chan + 4);
delivering = ret & BIT(chan + 8);
}
if (priv->port[id].is_4p) {
chan = priv->port[id].chan[1];
if (chan < 4) {
enabled &= !!(ret & BIT(chan));
delivering &= !!(ret & BIT(chan + 4));
} else {
enabled &= !!(ret & BIT(chan + 4));
delivering &= !!(ret & BIT(chan + 8));
}
}
/* Return delivering status only if both channel are on this state */
if (delivering)
status->c33_pw_status = ETHTOOL_C33_PSE_PW_D_STATUS_DELIVERING;
else
status->c33_pw_status = ETHTOOL_C33_PSE_PW_D_STATUS_DISABLED;
/* Return enabled status only if both channel are on this state */
if (enabled)
status->c33_admin_state = ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED;
else
status->c33_admin_state = ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED;
return 0;
}
/* Parse managers subnode into a array of device node */
static int
tps23881_get_of_channels(struct tps23881_priv *priv,
struct device_node *chan_node[TPS23881_MAX_CHANS])
{
struct device_node *channels_node, *node;
int i, ret;
if (!priv->np)
return -EINVAL;
channels_node = of_find_node_by_name(priv->np, "channels");
if (!channels_node)
return -EINVAL;
for_each_child_of_node(channels_node, node) {
u32 chan_id;
if (!of_node_name_eq(node, "channel"))
continue;
ret = of_property_read_u32(node, "reg", &chan_id);
if (ret) {
ret = -EINVAL;
goto out;
}
if (chan_id >= TPS23881_MAX_CHANS || chan_node[chan_id]) {
dev_err(&priv->client->dev,
"wrong number of port (%d)\n", chan_id);
ret = -EINVAL;
goto out;
}
of_node_get(node);
chan_node[chan_id] = node;
}
of_node_put(channels_node);
return 0;
out:
for (i = 0; i < TPS23881_MAX_CHANS; i++) {
of_node_put(chan_node[i]);
chan_node[i] = NULL;
}
of_node_put(node);
of_node_put(channels_node);
return ret;
}
struct tps23881_port_matrix {
u8 pi_id;
u8 lgcl_chan[2];
u8 hw_chan[2];
bool is_4p;
bool exist;
};
static int
tps23881_match_channel(const struct pse_pi_pairset *pairset,
struct device_node *chan_node[TPS23881_MAX_CHANS])
{
int i;
/* Look on every channels */
for (i = 0; i < TPS23881_MAX_CHANS; i++) {
if (pairset->np == chan_node[i])
return i;
}
return -ENODEV;
}
static bool
tps23881_is_chan_free(struct tps23881_port_matrix port_matrix[TPS23881_MAX_CHANS],
int chan)
{
int i;
for (i = 0; i < TPS23881_MAX_CHANS; i++) {
if (port_matrix[i].exist &&
(port_matrix[i].hw_chan[0] == chan ||
port_matrix[i].hw_chan[1] == chan))
return false;
}
return true;
}
/* Fill port matrix with the matching channels */
static int
tps23881_match_port_matrix(struct pse_pi *pi, int pi_id,
struct device_node *chan_node[TPS23881_MAX_CHANS],
struct tps23881_port_matrix port_matrix[TPS23881_MAX_CHANS])
{
int ret;
if (!pi->pairset[0].np)
return 0;
ret = tps23881_match_channel(&pi->pairset[0], chan_node);
if (ret < 0)
return ret;
if (!tps23881_is_chan_free(port_matrix, ret)) {
pr_err("tps23881: channel %d already used\n", ret);
return -ENODEV;
}
port_matrix[pi_id].hw_chan[0] = ret;
port_matrix[pi_id].exist = true;
if (!pi->pairset[1].np)
return 0;
ret = tps23881_match_channel(&pi->pairset[1], chan_node);
if (ret < 0)
return ret;
if (!tps23881_is_chan_free(port_matrix, ret)) {
pr_err("tps23881: channel %d already used\n", ret);
return -ENODEV;
}
if (port_matrix[pi_id].hw_chan[0] / 4 != ret / 4) {
pr_err("tps23881: 4-pair PSE can only be set within the same 4 ports group");
return -ENODEV;
}
port_matrix[pi_id].hw_chan[1] = ret;
port_matrix[pi_id].is_4p = true;
return 0;
}
static int
tps23881_get_unused_chan(struct tps23881_port_matrix port_matrix[TPS23881_MAX_CHANS],
int port_cnt)
{
bool used;
int i, j;
for (i = 0; i < TPS23881_MAX_CHANS; i++) {
used = false;
for (j = 0; j < port_cnt; j++) {
if (port_matrix[j].hw_chan[0] == i) {
used = true;
break;
}
if (port_matrix[j].is_4p &&
port_matrix[j].hw_chan[1] == i) {
used = true;
break;
}
}
if (!used)
return i;
}
return -ENODEV;
}
/* Sort the port matrix to following particular hardware ports matrix
* specification of the tps23881. The device has two 4-ports groups and
* each 4-pair powered device has to be configured to use two consecutive
* logical channel in each 4 ports group (1 and 2 or 3 and 4). Also the
* hardware matrix has to be fully configured even with unused chan to be
* valid.
*/
static int
tps23881_sort_port_matrix(struct tps23881_port_matrix port_matrix[TPS23881_MAX_CHANS])
{
struct tps23881_port_matrix tmp_port_matrix[TPS23881_MAX_CHANS] = {0};
int i, ret, port_cnt = 0, cnt_4ch_grp1 = 0, cnt_4ch_grp2 = 4;
/* Configure 4p port matrix */
for (i = 0; i < TPS23881_MAX_CHANS; i++) {
int *cnt;
if (!port_matrix[i].exist || !port_matrix[i].is_4p)
continue;
if (port_matrix[i].hw_chan[0] < 4)
cnt = &cnt_4ch_grp1;
else
cnt = &cnt_4ch_grp2;
tmp_port_matrix[port_cnt].exist = true;
tmp_port_matrix[port_cnt].is_4p = true;
tmp_port_matrix[port_cnt].pi_id = i;
tmp_port_matrix[port_cnt].hw_chan[0] = port_matrix[i].hw_chan[0];
tmp_port_matrix[port_cnt].hw_chan[1] = port_matrix[i].hw_chan[1];
/* 4-pair ports have to be configured with consecutive
* logical channels 0 and 1, 2 and 3.
*/
tmp_port_matrix[port_cnt].lgcl_chan[0] = (*cnt)++;
tmp_port_matrix[port_cnt].lgcl_chan[1] = (*cnt)++;
port_cnt++;
}
/* Configure 2p port matrix */
for (i = 0; i < TPS23881_MAX_CHANS; i++) {
int *cnt;
if (!port_matrix[i].exist || port_matrix[i].is_4p)
continue;
if (port_matrix[i].hw_chan[0] < 4)
cnt = &cnt_4ch_grp1;
else
cnt = &cnt_4ch_grp2;
tmp_port_matrix[port_cnt].exist = true;
tmp_port_matrix[port_cnt].pi_id = i;
tmp_port_matrix[port_cnt].lgcl_chan[0] = (*cnt)++;
tmp_port_matrix[port_cnt].hw_chan[0] = port_matrix[i].hw_chan[0];
port_cnt++;
}
/* Complete the rest of the first 4 port group matrix even if
* channels are unused
*/
while (cnt_4ch_grp1 < 4) {
ret = tps23881_get_unused_chan(tmp_port_matrix, port_cnt);
if (ret < 0) {
pr_err("tps23881: port matrix issue, no chan available\n");
return ret;
}
if (port_cnt >= TPS23881_MAX_CHANS) {
pr_err("tps23881: wrong number of channels\n");
return -ENODEV;
}
tmp_port_matrix[port_cnt].lgcl_chan[0] = cnt_4ch_grp1;
tmp_port_matrix[port_cnt].hw_chan[0] = ret;
cnt_4ch_grp1++;
port_cnt++;
}
/* Complete the rest of the second 4 port group matrix even if
* channels are unused
*/
while (cnt_4ch_grp2 < 8) {
ret = tps23881_get_unused_chan(tmp_port_matrix, port_cnt);
if (ret < 0) {
pr_err("tps23881: port matrix issue, no chan available\n");
return -ENODEV;
}
if (port_cnt >= TPS23881_MAX_CHANS) {
pr_err("tps23881: wrong number of channels\n");
return -ENODEV;
}
tmp_port_matrix[port_cnt].lgcl_chan[0] = cnt_4ch_grp2;
tmp_port_matrix[port_cnt].hw_chan[0] = ret;
cnt_4ch_grp2++;
port_cnt++;
}
memcpy(port_matrix, tmp_port_matrix, sizeof(tmp_port_matrix));
return port_cnt;
}
/* Write port matrix to the hardware port matrix and the software port
* matrix.
*/
static int
tps23881_write_port_matrix(struct tps23881_priv *priv,
struct tps23881_port_matrix port_matrix[TPS23881_MAX_CHANS],
int port_cnt)
{
struct i2c_client *client = priv->client;
u8 pi_id, lgcl_chan, hw_chan;
u16 val = 0;
int i, ret;
for (i = 0; i < port_cnt; i++) {
pi_id = port_matrix[i].pi_id;
lgcl_chan = port_matrix[i].lgcl_chan[0];
hw_chan = port_matrix[i].hw_chan[0] % 4;
/* Set software port matrix for existing ports */
if (port_matrix[i].exist)
priv->port[pi_id].chan[0] = lgcl_chan;
/* Set hardware port matrix for all ports */
val |= hw_chan << (lgcl_chan * 2);
if (!port_matrix[i].is_4p)
continue;
lgcl_chan = port_matrix[i].lgcl_chan[1];
hw_chan = port_matrix[i].hw_chan[1] % 4;
/* Set software port matrix for existing ports */
if (port_matrix[i].exist) {
priv->port[pi_id].is_4p = true;
priv->port[pi_id].chan[1] = lgcl_chan;
}
/* Set hardware port matrix for all ports */
val |= hw_chan << (lgcl_chan * 2);
}
/* Write hardware ports matrix */
ret = i2c_smbus_write_word_data(client, TPS23881_REG_PORT_MAP, val);
if (ret)
return ret;
return 0;
}
static int
tps23881_set_ports_conf(struct tps23881_priv *priv,
struct tps23881_port_matrix port_matrix[TPS23881_MAX_CHANS])
{
struct i2c_client *client = priv->client;
int i, ret;
u16 val;
/* Set operating mode */
ret = i2c_smbus_write_word_data(client, TPS23881_REG_OP_MODE,
TPS23881_OP_MODE_SEMIAUTO);
if (ret)
return ret;
/* Disable DC disconnect */
ret = i2c_smbus_write_word_data(client, TPS23881_REG_DIS_EN, 0x0);
if (ret)
return ret;
/* Set port power allocation */
val = 0;
for (i = 0; i < TPS23881_MAX_CHANS; i++) {
if (!port_matrix[i].exist)
continue;
if (port_matrix[i].is_4p)
val |= 0xf << ((port_matrix[i].lgcl_chan[0] / 2) * 4);
else
val |= 0x3 << ((port_matrix[i].lgcl_chan[0] / 2) * 4);
}
ret = i2c_smbus_write_word_data(client, TPS23881_REG_PORT_POWER, val);
if (ret)
return ret;
/* Enable detection and classification */
val = 0;
for (i = 0; i < TPS23881_MAX_CHANS; i++) {
if (!port_matrix[i].exist)
continue;
val |= BIT(port_matrix[i].lgcl_chan[0]) |
BIT(port_matrix[i].lgcl_chan[0] + 4);
if (port_matrix[i].is_4p)
val |= BIT(port_matrix[i].lgcl_chan[1]) |
BIT(port_matrix[i].lgcl_chan[1] + 4);
}
ret = i2c_smbus_write_word_data(client, TPS23881_REG_DET_CLA_EN, val);
if (ret)
return ret;
return 0;
}
static int
tps23881_set_ports_matrix(struct tps23881_priv *priv,
struct device_node *chan_node[TPS23881_MAX_CHANS])
{
struct tps23881_port_matrix port_matrix[TPS23881_MAX_CHANS] = {0};
int i, ret;
/* Update with values for every PSE PIs */
for (i = 0; i < TPS23881_MAX_CHANS; i++) {
ret = tps23881_match_port_matrix(&priv->pcdev.pi[i], i,
chan_node, port_matrix);
if (ret)
return ret;
}
ret = tps23881_sort_port_matrix(port_matrix);
if (ret < 0)
return ret;
ret = tps23881_write_port_matrix(priv, port_matrix, ret);
if (ret)
return ret;
ret = tps23881_set_ports_conf(priv, port_matrix);
if (ret)
return ret;
return 0;
}
static int tps23881_setup_pi_matrix(struct pse_controller_dev *pcdev)
{
struct device_node *chan_node[TPS23881_MAX_CHANS] = {NULL};
struct tps23881_priv *priv = to_tps23881_priv(pcdev);
int ret, i;
ret = tps23881_get_of_channels(priv, chan_node);
if (ret < 0) {
dev_warn(&priv->client->dev,
"Unable to parse port-matrix, default matrix will be used\n");
return 0;
}
ret = tps23881_set_ports_matrix(priv, chan_node);
for (i = 0; i < TPS23881_MAX_CHANS; i++)
of_node_put(chan_node[i]);
return ret;
}
static const struct pse_controller_ops tps23881_ops = {
.setup_pi_matrix = tps23881_setup_pi_matrix,
.pi_enable = tps23881_pi_enable,
.pi_disable = tps23881_pi_disable,
.pi_is_enabled = tps23881_pi_is_enabled,
.ethtool_get_status = tps23881_ethtool_get_status,
};
static const char fw_parity_name[] = "ti/tps23881/tps23881-parity-14.bin";
static const char fw_sram_name[] = "ti/tps23881/tps23881-sram-14.bin";
struct tps23881_fw_conf {
u8 reg;
u8 val;
};
static const struct tps23881_fw_conf tps23881_fw_parity_conf[] = {
{.reg = 0x60, .val = 0x01},
{.reg = 0x62, .val = 0x00},
{.reg = 0x63, .val = 0x80},
{.reg = 0x60, .val = 0xC4},
{.reg = 0x1D, .val = 0xBC},
{.reg = 0xD7, .val = 0x02},
{.reg = 0x91, .val = 0x00},
{.reg = 0x90, .val = 0x00},
{.reg = 0xD7, .val = 0x00},
{.reg = 0x1D, .val = 0x00},
{ /* sentinel */ }
};
static const struct tps23881_fw_conf tps23881_fw_sram_conf[] = {
{.reg = 0x60, .val = 0xC5},
{.reg = 0x62, .val = 0x00},
{.reg = 0x63, .val = 0x80},
{.reg = 0x60, .val = 0xC0},
{.reg = 0x1D, .val = 0xBC},
{.reg = 0xD7, .val = 0x02},
{.reg = 0x91, .val = 0x00},
{.reg = 0x90, .val = 0x00},
{.reg = 0xD7, .val = 0x00},
{.reg = 0x1D, .val = 0x00},
{ /* sentinel */ }
};
static int tps23881_flash_sram_fw_part(struct i2c_client *client,
const char *fw_name,
const struct tps23881_fw_conf *fw_conf)
{
const struct firmware *fw = NULL;
int i, ret;
ret = request_firmware(&fw, fw_name, &client->dev);
if (ret)
return ret;
dev_dbg(&client->dev, "Flashing %s\n", fw_name);
/* Prepare device for RAM download */
while (fw_conf->reg) {
ret = i2c_smbus_write_byte_data(client, fw_conf->reg,
fw_conf->val);
if (ret)
goto out;
fw_conf++;
}
/* Flash the firmware file */
for (i = 0; i < fw->size; i++) {
ret = i2c_smbus_write_byte_data(client,
TPS23881_REG_SRAM_DATA,
fw->data[i]);
if (ret)
goto out;
}
out:
release_firmware(fw);
return ret;
}
static int tps23881_flash_sram_fw(struct i2c_client *client)
{
int ret;
ret = tps23881_flash_sram_fw_part(client, fw_parity_name,
tps23881_fw_parity_conf);
if (ret)
return ret;
ret = tps23881_flash_sram_fw_part(client, fw_sram_name,
tps23881_fw_sram_conf);
if (ret)
return ret;
ret = i2c_smbus_write_byte_data(client, TPS23881_REG_SRAM_CTRL, 0x18);
if (ret)
return ret;
mdelay(12);
return 0;
}
static int tps23881_i2c_probe(struct i2c_client *client)
{
struct device *dev = &client->dev;
struct tps23881_priv *priv;
int ret;
u8 val;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(dev, "i2c check functionality failed\n");
return -ENXIO;
}
priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
ret = i2c_smbus_read_byte_data(client, TPS23881_REG_DEVID);
if (ret < 0)
return ret;
if (ret != 0x22) {
dev_err(dev, "Wrong device ID\n");
return -ENXIO;
}
ret = tps23881_flash_sram_fw(client);
if (ret < 0)
return ret;
ret = i2c_smbus_read_byte_data(client, TPS23881_REG_FWREV);
if (ret < 0)
return ret;
dev_info(&client->dev, "Firmware revision 0x%x\n", ret);
/* Set configuration B, 16 bit access on a single device address */
ret = i2c_smbus_read_byte_data(client, TPS23881_REG_GEN_MASK);
if (ret < 0)
return ret;
val = ret | TPS23881_REG_NBITACC;
ret = i2c_smbus_write_byte_data(client, TPS23881_REG_GEN_MASK, val);
if (ret)
return ret;
priv->client = client;
i2c_set_clientdata(client, priv);
priv->np = dev->of_node;
priv->pcdev.owner = THIS_MODULE;
priv->pcdev.ops = &tps23881_ops;
priv->pcdev.dev = dev;
priv->pcdev.types = ETHTOOL_PSE_C33;
priv->pcdev.nr_lines = TPS23881_MAX_CHANS;
ret = devm_pse_controller_register(dev, &priv->pcdev);
if (ret) {
return dev_err_probe(dev, ret,
"failed to register PSE controller\n");
}
return ret;
}
static const struct i2c_device_id tps23881_id[] = {
{ "tps23881", 0 },
{ },
};
MODULE_DEVICE_TABLE(i2c, tps23881_id);
static const struct of_device_id tps23881_of_match[] = {
{ .compatible = "ti,tps23881", },
{ },
};
MODULE_DEVICE_TABLE(of, tps23881_of_match);
static struct i2c_driver tps23881_driver = {
.probe = tps23881_i2c_probe,
.id_table = tps23881_id,
.driver = {
.name = "tps23881",
.of_match_table = tps23881_of_match,
},
};
module_i2c_driver(tps23881_driver);
MODULE_AUTHOR("Kory Maincent <kory.maincent@bootlin.com>");
MODULE_DESCRIPTION("TI TPS23881 PoE PSE Controller driver");
MODULE_LICENSE("GPL");
include/linux/pse-pd/pse.h
View file @ 33d21bd1
......@@ -17,9 +17,12 @@ struct pse_controller_dev;
*
* @podl_admin_control: set PoDL PSE admin control as described in
* IEEE 802.3-2018 30.15.1.2.1 acPoDLPSEAdminControl
* @c33_admin_control: set PSE admin control as described in
* IEEE 802.3-2022 30.9.1.2.1 acPSEAdminControl
*/
struct pse_control_config {
enum ethtool_podl_pse_admin_state podl_admin_control;
enum ethtool_c33_pse_admin_state c33_admin_control;
};
/**
......@@ -29,25 +32,36 @@ struct pse_control_config {
* functions. IEEE 802.3-2018 30.15.1.1.2 aPoDLPSEAdminState
* @podl_pw_status: power detection status of the PoDL PSE.
* IEEE 802.3-2018 30.15.1.1.3 aPoDLPSEPowerDetectionStatus:
* @c33_admin_state: operational state of the PSE
* functions. IEEE 802.3-2022 30.9.1.1.2 aPSEAdminState
* @c33_pw_status: power detection status of the PSE.
* IEEE 802.3-2022 30.9.1.1.5 aPSEPowerDetectionStatus:
*/
struct pse_control_status {
enum ethtool_podl_pse_admin_state podl_admin_state;
enum ethtool_podl_pse_pw_d_status podl_pw_status;
enum ethtool_c33_pse_admin_state c33_admin_state;
enum ethtool_c33_pse_pw_d_status c33_pw_status;
};
/**
* struct pse_controller_ops - PSE controller driver callbacks
*
* @ethtool_get_status: get PSE control status for ethtool interface
* @ethtool_set_config: set PSE control configuration over ethtool interface
* @setup_pi_matrix: setup PI matrix of the PSE controller
* @pi_is_enabled: Return 1 if the PSE PI is enabled, 0 if not.
* May also return negative errno.
* @pi_enable: Configure the PSE PI as enabled.
* @pi_disable: Configure the PSE PI as disabled.
*/
struct pse_controller_ops {
int (*ethtool_get_status)(struct pse_controller_dev *pcdev,
unsigned long id, struct netlink_ext_ack *extack,
struct pse_control_status *status);
int (*ethtool_set_config)(struct pse_controller_dev *pcdev,
unsigned long id, struct netlink_ext_ack *extack,
const struct pse_control_config *config);
int (*setup_pi_matrix)(struct pse_controller_dev *pcdev);
int (*pi_is_enabled)(struct pse_controller_dev *pcdev, int id);
int (*pi_enable)(struct pse_controller_dev *pcdev, int id);
int (*pi_disable)(struct pse_controller_dev *pcdev, int id);
};
struct module;
......@@ -55,6 +69,40 @@ struct device_node;
struct of_phandle_args;
struct pse_control;
/* PSE PI pairset pinout can either be Alternative A or Alternative B */
enum pse_pi_pairset_pinout {
ALTERNATIVE_A,
ALTERNATIVE_B,
};
/**
* struct pse_pi_pairset - PSE PI pairset entity describing the pinout
* alternative ant its phandle
*
* @pinout: description of the pinout alternative
* @np: device node pointer describing the pairset phandle
*/
struct pse_pi_pairset {
enum pse_pi_pairset_pinout pinout;
struct device_node *np;
};
/**
* struct pse_pi - PSE PI (Power Interface) entity as described in
* IEEE 802.3-2022 145.2.4
*
* @pairset: table of the PSE PI pinout alternative for the two pairset
* @np: device node pointer of the PSE PI node
* @rdev: regulator represented by the PSE PI
* @admin_state_enabled: PI enabled state
*/
struct pse_pi {
struct pse_pi_pairset pairset[2];
struct device_node *np;
struct regulator_dev *rdev;
bool admin_state_enabled;
};
/**
* struct pse_controller_dev - PSE controller entity that might
* provide multiple PSE controls
......@@ -64,10 +112,11 @@ struct pse_control;
* @pse_control_head: head of internal list of requested PSE controls
* @dev: corresponding driver model device struct
* @of_pse_n_cells: number of cells in PSE line specifiers
* @of_xlate: translation function to translate from specifier as found in the
* device tree to id as given to the PSE control ops
* @nr_lines: number of PSE controls in this controller device
* @lock: Mutex for serialization access to the PSE controller
* @types: types of the PSE controller
* @pi: table of PSE PIs described in this controller device
* @no_of_pse_pi: flag set if the pse_pis devicetree node is not used
*/
struct pse_controller_dev {
const struct pse_controller_ops *ops;
......@@ -76,10 +125,11 @@ struct pse_controller_dev {
struct list_head pse_control_head;
struct device *dev;
int of_pse_n_cells;
int (*of_xlate)(struct pse_controller_dev *pcdev,
const struct of_phandle_args *pse_spec);
unsigned int nr_lines;
struct mutex lock;
enum ethtool_pse_types types;
struct pse_pi *pi;
bool no_of_pse_pi;
};
#if IS_ENABLED(CONFIG_PSE_CONTROLLER)
......@@ -99,6 +149,9 @@ int pse_ethtool_set_config(struct pse_control *psec,
struct netlink_ext_ack *extack,
const struct pse_control_config *config);
bool pse_has_podl(struct pse_control *psec);
bool pse_has_c33(struct pse_control *psec);
#else
static inline struct pse_control *of_pse_control_get(struct device_node *node)
......@@ -124,6 +177,16 @@ static inline int pse_ethtool_set_config(struct pse_control *psec,
return -ENOTSUPP;
}
static inline bool pse_has_podl(struct pse_control *psec)
{
return false;
}
static inline bool pse_has_c33(struct pse_control *psec)
{
return false;
}
#endif
#endif
include/uapi/linux/ethtool.h
View file @ 33d21bd1
......@@ -752,6 +752,61 @@ enum ethtool_module_power_mode {
ETHTOOL_MODULE_POWER_MODE_HIGH,
};
/**
* enum ethtool_pse_types - Types of PSE controller.
* @ETHTOOL_PSE_UNKNOWN: Type of PSE controller is unknown
* @ETHTOOL_PSE_PODL: PSE controller which support PoDL
* @ETHTOOL_PSE_C33: PSE controller which support Clause 33 (PoE)
*/
enum ethtool_pse_types {
ETHTOOL_PSE_UNKNOWN = 1 << 0,
ETHTOOL_PSE_PODL = 1 << 1,
ETHTOOL_PSE_C33 = 1 << 2,
};
/**
* enum ethtool_c33_pse_admin_state - operational state of the PoDL PSE
* functions. IEEE 802.3-2022 30.9.1.1.2 aPSEAdminState
* @ETHTOOL_C33_PSE_ADMIN_STATE_UNKNOWN: state of PSE functions is unknown
* @ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED: PSE functions are disabled
* @ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED: PSE functions are enabled
*/
enum ethtool_c33_pse_admin_state {
ETHTOOL_C33_PSE_ADMIN_STATE_UNKNOWN = 1,
ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED,
ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED,
};
/**
* enum ethtool_c33_pse_pw_d_status - power detection status of the PSE.
* IEEE 802.3-2022 30.9.1.1.3 aPoDLPSEPowerDetectionStatus:
* @ETHTOOL_C33_PSE_PW_D_STATUS_UNKNOWN: PSE status is unknown
* @ETHTOOL_C33_PSE_PW_D_STATUS_DISABLED: The enumeration "disabled"
* indicates that the PSE State diagram is in the state DISABLED.
* @ETHTOOL_C33_PSE_PW_D_STATUS_SEARCHING: The enumeration "searching"
* indicates the PSE State diagram is in a state other than those
* listed.
* @ETHTOOL_C33_PSE_PW_D_STATUS_DELIVERING: The enumeration
* "deliveringPower" indicates that the PSE State diagram is in the
* state POWER_ON.
* @ETHTOOL_C33_PSE_PW_D_STATUS_TEST: The enumeration "test" indicates that
* the PSE State diagram is in the state TEST_MODE.
* @ETHTOOL_C33_PSE_PW_D_STATUS_FAULT: The enumeration "fault" indicates that
* the PSE State diagram is in the state TEST_ERROR.
* @ETHTOOL_C33_PSE_PW_D_STATUS_OTHERFAULT: The enumeration "otherFault"
* indicates that the PSE State diagram is in the state IDLE due to
* the variable error_condition = true.
*/
enum ethtool_c33_pse_pw_d_status {
ETHTOOL_C33_PSE_PW_D_STATUS_UNKNOWN = 1,
ETHTOOL_C33_PSE_PW_D_STATUS_DISABLED,
ETHTOOL_C33_PSE_PW_D_STATUS_SEARCHING,
ETHTOOL_C33_PSE_PW_D_STATUS_DELIVERING,
ETHTOOL_C33_PSE_PW_D_STATUS_TEST,
ETHTOOL_C33_PSE_PW_D_STATUS_FAULT,
ETHTOOL_C33_PSE_PW_D_STATUS_OTHERFAULT,
};
/**
* enum ethtool_podl_pse_admin_state - operational state of the PoDL PSE
* functions. IEEE 802.3-2018 30.15.1.1.2 aPoDLPSEAdminState
......
include/uapi/linux/ethtool_netlink.h
View file @ 33d21bd1
......@@ -913,6 +913,9 @@ enum {
ETHTOOL_A_PODL_PSE_ADMIN_STATE, /* u32 */
ETHTOOL_A_PODL_PSE_ADMIN_CONTROL, /* u32 */
ETHTOOL_A_PODL_PSE_PW_D_STATUS, /* u32 */
ETHTOOL_A_C33_PSE_ADMIN_STATE, /* u32 */
ETHTOOL_A_C33_PSE_ADMIN_CONTROL, /* u32 */
ETHTOOL_A_C33_PSE_PW_D_STATUS, /* u32 */
/* add new constants above here */
__ETHTOOL_A_PSE_CNT,
......
net/ethtool/pse-pd.c
View file @ 33d21bd1
......@@ -82,6 +82,10 @@ static int pse_reply_size(const struct ethnl_req_info *req_base,
len += nla_total_size(sizeof(u32)); /* _PODL_PSE_ADMIN_STATE */
if (st->podl_pw_status > 0)
len += nla_total_size(sizeof(u32)); /* _PODL_PSE_PW_D_STATUS */
if (st->c33_admin_state > 0)
len += nla_total_size(sizeof(u32)); /* _C33_PSE_ADMIN_STATE */
if (st->c33_pw_status > 0)
len += nla_total_size(sizeof(u32)); /* _C33_PSE_PW_D_STATUS */
return len;
}
......@@ -103,6 +107,16 @@ static int pse_fill_reply(struct sk_buff *skb,
st->podl_pw_status))
return -EMSGSIZE;
if (st->c33_admin_state > 0 &&
nla_put_u32(skb, ETHTOOL_A_C33_PSE_ADMIN_STATE,
st->c33_admin_state))
return -EMSGSIZE;
if (st->c33_pw_status > 0 &&
nla_put_u32(skb, ETHTOOL_A_C33_PSE_PW_D_STATUS,
st->c33_pw_status))
return -EMSGSIZE;
return 0;
}
......@@ -113,25 +127,18 @@ const struct nla_policy ethnl_pse_set_policy[ETHTOOL_A_PSE_MAX + 1] = {
[ETHTOOL_A_PODL_PSE_ADMIN_CONTROL] =
NLA_POLICY_RANGE(NLA_U32, ETHTOOL_PODL_PSE_ADMIN_STATE_DISABLED,
ETHTOOL_PODL_PSE_ADMIN_STATE_ENABLED),
[ETHTOOL_A_C33_PSE_ADMIN_CONTROL] =
NLA_POLICY_RANGE(NLA_U32, ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED,
ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED),
};
static int
ethnl_set_pse_validate(struct ethnl_req_info *req_info, struct genl_info *info)
{
return !!info->attrs[ETHTOOL_A_PODL_PSE_ADMIN_CONTROL];
}
static int
ethnl_set_pse(struct ethnl_req_info *req_info, struct genl_info *info)
{
struct net_device *dev = req_info->dev;
struct pse_control_config config = {};
struct nlattr **tb = info->attrs;
struct phy_device *phydev;
/* this values are already validated by the ethnl_pse_set_policy */
config.podl_admin_control = nla_get_u32(tb[ETHTOOL_A_PODL_PSE_ADMIN_CONTROL]);
phydev = dev->phydev;
if (!phydev) {
NL_SET_ERR_MSG(info->extack, "No PHY is attached");
......@@ -143,6 +150,39 @@ ethnl_set_pse(struct ethnl_req_info *req_info, struct genl_info *info)
return -EOPNOTSUPP;
}
if (tb[ETHTOOL_A_PODL_PSE_ADMIN_CONTROL] &&
!pse_has_podl(phydev->psec)) {
NL_SET_ERR_MSG_ATTR(info->extack,
tb[ETHTOOL_A_PODL_PSE_ADMIN_CONTROL],
"setting PoDL PSE admin control not supported");
return -EOPNOTSUPP;
}
if (tb[ETHTOOL_A_C33_PSE_ADMIN_CONTROL] &&
!pse_has_c33(phydev->psec)) {
NL_SET_ERR_MSG_ATTR(info->extack,
tb[ETHTOOL_A_C33_PSE_ADMIN_CONTROL],
"setting C33 PSE admin control not supported");
return -EOPNOTSUPP;
}
return 1;
}
static int
ethnl_set_pse(struct ethnl_req_info *req_info, struct genl_info *info)
{
struct net_device *dev = req_info->dev;
struct pse_control_config config = {};
struct nlattr **tb = info->attrs;
struct phy_device *phydev;
phydev = dev->phydev;
/* These values are already validated by the ethnl_pse_set_policy */
if (pse_has_podl(phydev->psec))
config.podl_admin_control = nla_get_u32(tb[ETHTOOL_A_PODL_PSE_ADMIN_CONTROL]);
if (pse_has_c33(phydev->psec))
config.c33_admin_control = nla_get_u32(tb[ETHTOOL_A_C33_PSE_ADMIN_CONTROL]);
/* Return errno directly - PSE has no notification */
return pse_ethtool_set_config(phydev->psec, info->extack, &config);
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7