dpll: Core improvements and ice E825-C SyncE support
Subsystems (10)
Ivan Vecera
maintainercover dpll: Core improvements and ice E825-C SyncE support
This series introduces Synchronous Ethernet (SyncE) support for the Intel E825-C Ethernet controller. Unlike previous generations where DPLL connections were implicitly assumed, the E825-C architecture relies on the platform firmware to describe the physical connections between the network controller and external DPLLs (such as the ZL3073x).
To accommodate this, the series extends the DPLL subsystem to support firmware node (fwnode) associations, asynchronous discovery via notifiers, and dynamic pin management. Additionally, a significant refactor of the DPLL reference counting logic is included to ensure robustness and debuggability.
DPLL Core Extensions:
* Firmware Node Support: Pins can now be registered with an associated struct fwnode_handle. This allows consumer drivers to lookup pins based on device properties (dpll-pins).
* Asynchronous Notifiers: A raw notifier chain is added to the DPLL core. This allows the network driver (ice driver in this series) to subscribe to events and react when the platform DPLL driver registers the parent pins, resolving probe ordering dependencies.
* Dynamic Indexing: Drivers can now request DPLL_PIN_IDX_UNSPEC to have the core automatically allocate a unique pin index, simplifying driver implementation for virtual or non-indexed pins.
Reference Counting & Debugging:
* Refactor: The reference counting logic in the core is consolidated. Internal list management helpers now automatically handle hold/put operations, removing fragile open-coded logic in the registration paths.
* Duplicate Checks: The core now strictly rejects duplicate registration attempts for the same pin/device context.
* Reference Tracking: A new Kconfig option DPLL_REFCNT_TRACKER is added (using the kernel's REF_TRACKER infrastructure). This allows developers to instrument and debug reference leaks by recording stack traces for every get/put operation.
Driver Updates:
* zl3073x: Updated to register pins with their firmware nodes and support the 'mux' pin type.
* ice: Implements the E825-C specific hardware configuration for SyncE (CGU registers). It utilizes the new notifier and fwnode APIs to dynamically discover and attach to the platform DPLLs.
Patch Summary:
* Patch 1-3:
DT pin consumer schema and helper functions for finding DPLL pins via fwnode.
* Patch 4:
Updates zl3073x to register pins with fwnode.
* Patch 5-6:
Adds notifiers and dynamic pin index allocation to DPLL core.
* Patch 7:
Adds 'mux' pin type support to zl3073x.
* Patch 8-9:
Refactors DPLL core refcounting and adds duplicate registration checks.
* Patch 10-11:
Adds REF_TRACKER infrastructure and updates existing drivers to support it.
* Patch 12:
Implements the E825-C SyncE logic in the ice driver using the new infrastructure.
Arkadiusz Kubalewski (1):
ice: dpll: Support E825-C SyncE and dynamic pin discovery
Ivan Vecera (10):
dt-bindings: dpll: add common dpll-pin-consumer schema
dpll: Allow associating dpll pin with a firmware node
dpll: Add helpers to find DPLL pin fwnode
dpll: zl3073x: Associate pin with fwnode handle
dpll: Support dynamic pin index allocation
dpll: zl3073x: Add support for mux pin type
dpll: Enhance and consolidate reference counting logic
dpll: Prevent duplicate registrations
dpll: Add reference count tracking support
drivers: Add support for DPLL reference count tracking
Petr Oros (1):
dpll: Add notifier chain for dpll events
.../bindings/dpll/dpll-pin-consumer.yaml | 30 + drivers/dpll/Kconfig | 15 + drivers/dpll/dpll_core.c | 320 +++++++- drivers/dpll/dpll_core.h | 11 + drivers/dpll/dpll_netlink.c | 6 + drivers/dpll/zl3073x/dpll.c | 15 +- drivers/dpll/zl3073x/dpll.h | 2 + drivers/dpll/zl3073x/prop.c | 2 + drivers/net/ethernet/intel/ice/ice_dpll.c | 728 +++++++++++++++--- drivers/net/ethernet/intel/ice/ice_dpll.h | 29 + drivers/net/ethernet/intel/ice/ice_lib.c | 3 + drivers/net/ethernet/intel/ice/ice_ptp.c | 29 + drivers/net/ethernet/intel/ice/ice_ptp_hw.c | 9 +- drivers/net/ethernet/intel/ice/ice_tspll.c | 217 ++++++ drivers/net/ethernet/intel/ice/ice_tspll.h | 13 +- drivers/net/ethernet/intel/ice/ice_type.h | 6 + .../net/ethernet/mellanox/mlx5/core/dpll.c | 16 +- drivers/ptp/ptp_ocp.c | 18 +- include/linux/dpll.h | 74 +- 19 files changed, 1385 insertions(+), 158 deletions(-) create mode 100644 Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml
Signature · 1 line
2.52.0
Ivan Vecera
maintainerPATCH 1/12 dt-bindings: dpll: add common dpll-pin-consumer schema
Introduce a common schema for DPLL pin consumers. Devices such as Ethernet controllers and PHYs may require connections to DPLL pins for Synchronous Ethernet (SyncE) or other frequency synchronization tasks.
Defining these properties in a shared schema ensures consistency across different device types that consume DPLL resources.
--- .../bindings/dpll/dpll-pin-consumer.yaml | 30 +++++++++++++++++++ MAINTAINERS | 1 + 2 files changed, 31 insertions(+) create mode 100644 Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +30 -0
@@ -0,0 +1,30 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/dpll/dpll-pin-consumer.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: DPLL Pin Consumer + +maintainers: + - Ivan Vecera <[email protected]> + +description: | + Common properties for devices that require connection to DPLL (Digital Phase + Locked Loop) pins for frequency synchronization (e.g. SyncE). + +properties: + dpll-pins: + $ref: /schemas/types.yaml#/definitions/phandle-array + description: + List of phandles to the DPLL pin nodes connected to this device. + + dpll-pin-names: + $ref: /schemas/types.yaml#/definitions/string-array + description: + Names for the DPLL pins defined in 'dpll-pins', in the same order. + +dependencies: + dpll-pin-names: [ dpll-pins ] + +additionalProperties: true
MAINTAINERS +1 -0
@@ -7648,6 +7648,7 @@ M: Jiri Pirko <[email protected]> L: [email protected] S: Supported F: Documentation/devicetree/bindings/dpll/dpll-device.yaml +F: Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml F: Documentation/devicetree/bindings/dpll/dpll-pin.yaml F: Documentation/driver-api/dpll.rst F: drivers/dpll/
Signature · 1 line
2.52.0
Re: [PATCH net-next 01/12] dt-bindings: dpll: add common dpll-pin-consumer schema
Quoted 21 lines · Ivan Vecera
Introduce a common schema for DPLL pin consumers. Devices such as Ethernet controllers and PHYs may require connections to DPLL pins for Synchronous Ethernet (SyncE) or other frequency synchronization tasks.
Defining these properties in a shared schema ensures consistency across different device types that consume DPLL resources.
Signed-off-by Ivan Vecera <[email protected]>--- .../bindings/dpll/dpll-pin-consumer.yaml | 30 +++++++++++++++++++ MAINTAINERS | 1 + 2 files changed, 31 insertions(+) create mode 100644 Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yamlDocumentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +1
-0@@ -0,0 +1,30 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml line 11
Quoted 10 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +10
-0+%YAML 1.2 +--- +$id: http://devicetree.org/schemas/dpll/dpll-pin-consumer.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: DPLL Pin Consumer + +maintainers: + - Ivan Vecera <[email protected]> +
You miss select. Without it this binding is no-op.
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml line 12
Quoted 1 line
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +1
-0+description: |
Drop |
Quoted 6 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +6
-0+ Common properties for devices that require connection to DPLL (Digital Phase + Locked Loop) pins for frequency synchronization (e.g. SyncE). + +properties: + dpll-pins: + $ref: /schemas/types.yaml#/definitions/phandle-array
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml line 28
Quoted 10 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +10
-0+ description: + List of phandles to the DPLL pin nodes connected to this device. + + dpll-pin-names: + $ref: /schemas/types.yaml#/definitions/string-array + description: + Names for the DPLL pins defined in 'dpll-pins', in the same order. + +dependencies: + dpll-pin-names: [ dpll-pins ]
Binding should go to dtschema. See also commit 3282a891060aace02e3eed4789739768060cea32 in dtschema or other examples how to add new provider/consumer properties.
Best regards,
Krzysztof
Ivan Vecera
maintainerRe: [Intel-wired-lan] [PATCH net-next 01/12] dt-bindings: dpll: add common dpll-pin-consumer schema
Quoted 26 lines · Krzysztof Kozlowski
Quoted 25 lines · Ivan Vecera
Introduce a common schema for DPLL pin consumers. Devices such as Ethernet controllers and PHYs may require connections to DPLL pins for Synchronous Ethernet (SyncE) or other frequency synchronization tasks.
Defining these properties in a shared schema ensures consistency across different device types that consume DPLL resources.
Signed-off-by Ivan Vecera <[email protected]>--- .../bindings/dpll/dpll-pin-consumer.yaml | 30 +++++++++++++++++++ MAINTAINERS | 1 + 2 files changed, 31 insertions(+)create mode 100644
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yamlDocumentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +5
-0@@ -0,0 +1,30 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/dpll/dpll-pin-consumer.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml#
Quoted 8 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml line 11
Quoted 6 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +6
-0+ +title: DPLL Pin Consumer + +maintainers: + - Ivan Vecera <[email protected]> +You miss select. Without it this binding is no-op.
Will fix.
Quoted 3 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml line 12
Quoted 1 line
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +1
-0+description: |Drop |
Will do.
Quoted 12 lines
Quoted 12 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +12
-0+ Common properties for devices that require connection to DPLL (Digital Phase + Locked Loop) pins for frequency synchronization (e.g. SyncE). + +properties: + dpll-pins: + $ref: /schemas/types.yaml#/definitions/phandle-array + description: + List of phandles to the DPLL pin nodes connected to this device. + + dpll-pin-names: + $ref: /schemas/types.yaml#/definitions/string-array + description:
Quoted 8 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml line 28
Quoted 4 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +4
-0+ Names for the DPLL pins defined in 'dpll-pins', in the same order. + +dependencies: + dpll-pin-names: [ dpll-pins ]Binding should go to dtschema. See also commit
3282a891060aace02e3eed4789739768060cea32in dtschema or other examples how to add new provider/consumer properties.
Will do.
Thanks for advice...
Ivan
Ivan Vecera
maintainerRe: [Intel-wired-lan] [PATCH net-next 01/12] dt-bindings: dpll: add common dpll-pin-consumer schema
Quoted 38 lines · Ivan Vecera
Quoted 26 lines · Krzysztof Kozlowski
Quoted 25 lines · Ivan Vecera
Introduce a common schema for DPLL pin consumers. Devices such as Ethernet controllers and PHYs may require connections to DPLL pins for Synchronous Ethernet (SyncE) or other frequency synchronization tasks.
Defining these properties in a shared schema ensures consistency across different device types that consume DPLL resources.
Signed-off-by Ivan Vecera <[email protected]>---
.../bindings/dpll/dpll-pin-consumer.yaml | 30 +++++++++++++++++++ MAINTAINERS | 1 +2 files changed, 31 insertions(+)create mode 100644
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yamlDocumentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +5
-0@@ -0,0 +1,30 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/dpll/dpll-pin-consumer.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml#Quoted 8 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml line 11
Quoted 6 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +6
-0+ +title: DPLL Pin Consumer + +maintainers: + - Ivan Vecera <[email protected]> +You miss select. Without it this binding is no-op.
Quoted 30 lines
Will fix.
Quoted 3 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml line 12
Quoted 1 line
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +1
-0+description: |Drop |
Will do.
Quoted 22 lines
Quoted 15 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +1
-0+ Common properties for devices that require connection to DPLL(Digital Phase
+ Locked Loop) pins for frequency synchronization (e.g. SyncE).Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +11
-0+ +properties: + dpll-pins: + $ref: /schemas/types.yaml#/definitions/phandle-array + description: + List of phandles to the DPLL pin nodes connected to this device. + + dpll-pin-names: + $ref: /schemas/types.yaml#/definitions/string-array + description: + Names for the DPLL pins defined in 'dpll-pins', in the sameorder.
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml line 28
Quoted 3 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +3
-0+ +dependencies: + dpll-pin-names: [ dpll-pins ]Binding should go to dtschema. See also commit
3282a891060aace02e3eed4789739768060cea32in dtschema or other examples how to add new provider/consumer properties.
Quick questions... if the dpll pin consumer properties schema should go to dtschema...
1) Should I remove this patch from this series? So this schema won't be a part of kernel
2) dtschema does not contain dpll-device and dpll-pin schemas now, I expect they should be added as well... or? I'm asking because there is also e.g. hwlock-consumer.yaml in dtschema but no hwlock
Thanks,
Ivan
Quoted 6 lines
Will do.
Thanks for advice...
Ivan
Re: [Intel-wired-lan] [PATCH net-next 01/12] dt-bindings: dpll: add common dpll-pin-consumer schema
Quoted 23 lines · Ivan Vecera
Quoted 14 lines
Quoted 14 lines
Quoted 14 lines
+ Common properties for devices that require connection to DPLL (Digital Phase
+ Locked Loop) pins for frequency synchronization (e.g. SyncE).Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +11
-0+ +properties: + dpll-pins: + $ref: /schemas/types.yaml#/definitions/phandle-array + description: + List of phandles to the DPLL pin nodes connected to this device. + + dpll-pin-names: + $ref: /schemas/types.yaml#/definitions/string-array + description: + Names for the DPLL pins defined in 'dpll-pins', in the sameQuoted 8 lines
Quoted 8 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml line 28
Quoted 4 lines
order.
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +3
-0+ +dependencies: + dpll-pin-names: [ dpll-pins ]Binding should go to dtschema. See also commit
3282a891060aace02e3eed4789739768060cea32in dtschema or other examples how to add new provider/consumer properties.
Quoted 5 lines
Quick questions... if the dpll pin consumer properties schema should go to dtschema...
1) Should I remove this patch from this series? So this schema won't be a part of kernel
Yes.
Quoted 1 line
2) dtschema does not contain dpll-device and dpll-pin schemas now, I
The provider, so the #foo-cells should be in dtschema as well.
Quoted 2 lines
expect they should be added as well... or? I'm asking because there is also e.g.
hwlock-consumer.yamlin dtschema but no hwlock
hwlock-cells are missing, probably due to licensing.
Best regards,
Krzysztof
Ivan Vecera
maintainerRe: [Intel-wired-lan] [PATCH net-next 01/12] dt-bindings: dpll: add common dpll-pin-consumer schema
Quoted 24 lines · Krzysztof Kozlowski
Quoted 23 lines · Ivan Vecera
Quoted 22 lines
Quoted 22 lines
Quoted 15 lines
+ Common properties for devices that require connection to DPLL (Digital Phase
+ Locked Loop) pins for frequency synchronization (e.g. SyncE).Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +11
-0+ +properties: + dpll-pins: + $ref: /schemas/types.yaml#/definitions/phandle-array + description: + List of phandles to the DPLL pin nodes connected to this device. + + dpll-pin-names: + $ref: /schemas/types.yaml#/definitions/string-array + description: + Names for the DPLL pins defined in 'dpll-pins', in the sameorder.
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml line 28
Quoted 3 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +3
-0+ +dependencies: + dpll-pin-names: [ dpll-pins ]Binding should go to dtschema. See also commit
3282a891060aace02e3eed4789739768060cea32in dtschema or other examples how to add new provider/consumer properties.
Quoted 7 lines
Quoted 5 lines
Quick questions... if the dpll pin consumer properties schema should go to dtschema...
1) Should I remove this patch from this series? So this schema won't be a part of kernel
Yes.
OK, will remove this patch from the series and create PR against dtschema and ...
Quoted 3 lines
Quoted 1 line
2) dtschema does not contain dpll-device and dpll-pin schemas now, I
The provider, so the #foo-cells should be in dtschema as well.
... include dpll.yaml and dpll-pin.yaml as well.
Quoted 4 lines
Quoted 2 lines
expect they should be added as well... or? I'm asking because there is also e.g.
hwlock-consumer.yamlin dtschema but no hwlockhwlock-cells are missing, probably due to licensing.
and I will also include '#dpll-pin-cells', as we cannot theoretically rule out its usage in the future.
Thanks,
Ivan
Ivan Vecera
maintainerRe: [Intel-wired-lan] [PATCH net-next 01/12] dt-bindings: dpll: add common dpll-pin-consumer schema
Quoted 36 lines · Ivan Vecera
Quoted 25 lines · Krzysztof Kozlowski
Quoted 24 lines · Ivan Vecera
Quoted 23 lines
Quoted 23 lines
Quoted 16 lines
+ Common properties for devices that require connection to DPLL (Digital Phase
+ Locked Loop) pins for frequency synchronization (e.g. SyncE).Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +6
-0+ +properties: + dpll-pins: + $ref: /schemas/types.yaml#/definitions/phandle-array + description: + List of phandles to the DPLL pin nodes connected to thisdevice.
+
+ dpll-pin-names:
+ $ref: /schemas/types.yaml#/definitions/string-array + description:
+ Names for the DPLL pins defined in 'dpll-pins', in the same order.Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml line 28
Quoted 3 lines
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +3
-0+ +dependencies: + dpll-pin-names: [ dpll-pins ]Binding should go to dtschema. See also commit
3282a891060aace02e3eed4789739768060cea32in dtschema or other examples how to add new provider/consumer properties.Quoted 7 lines
Quoted 5 lines
Quick questions... if the dpll pin consumer properties schema should go to dtschema...
1) Should I remove this patch from this series? So this schema won't be a part of kernel
Yes.
Quoted 8 lines
OK, will remove this patch from the series and create PR against dtschema and ...
Quoted 3 lines
Quoted 1 line
2) dtschema does not contain dpll-device and dpll-pin schemas now, I
The provider, so the #foo-cells should be in dtschema as well.
... include
dpll.yamlanddpll-pin.yamlas well.
Well, after dtschema investigation, I should make a PR with dpll-pin-consumer.yaml and dpll-pin-producer.yaml.
Correct?
Thanks,
Ivan
Ivan Vecera
maintainerRe: [PATCH net-next 01/12] dt-bindings: dpll: add common dpll-pin-consumer schema
In reply to Ivan VeceraQuoted 55 lines · Ivan Vecera
Introduce a common schema for DPLL pin consumers. Devices such as Ethernet controllers and PHYs may require connections to DPLL pins for Synchronous Ethernet (SyncE) or other frequency synchronization tasks.
Defining these properties in a shared schema ensures consistency across different device types that consume DPLL resources.
Signed-off-by Ivan Vecera <[email protected]>--- .../bindings/dpll/dpll-pin-consumer.yaml | 30 +++++++++++++++++++ MAINTAINERS | 1 + 2 files changed, 31 insertions(+)create mode 100644
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yamlDocumentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +30
-0@@ -0,0 +1,30 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/dpll/dpll-pin-consumer.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: DPLL Pin Consumer + +maintainers: + - Ivan Vecera <[email protected]> + +description: | + Common properties for devices that require connection to DPLL (Digital Phase + Locked Loop) pins for frequency synchronization (e.g. SyncE). + +properties: + dpll-pins: + $ref: /schemas/types.yaml#/definitions/phandle-array + description: + List of phandles to the DPLL pin nodes connected to this device. + + dpll-pin-names: + $ref: /schemas/types.yaml#/definitions/string-array + description: + Names for the DPLL pins defined in 'dpll-pins', in the same order. + +dependencies: + dpll-pin-names: [ dpll-pins ] + +additionalProperties: trueMAINTAINERS +0
-0
MAINTAINERS M: Jiri Pirko <[email protected]> · line 7654
Quoted 7 lines
MAINTAINERS +1
-0@@ -7648,6 +7648,7 @@ M: Jiri Pirko <[email protected]> L: [email protected] S: Supported F: Documentation/devicetree/bindings/dpll/dpll-device.yaml +F: Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml F: Documentation/devicetree/bindings/dpll/dpll-pin.yaml F: Documentation/driver-api/dpll.rst F: drivers/dpll/
Based on private discussion with Andrew Lunn (thanks a lot), this is wrong approach. Referencing directly dpll-pin nodes and using their phandles in consumers is at least unusual.
The right approach should be referencing dpll-device and use cells to specify the dpll pin that is used.
Also Krzysztof mentioned there are missing update of supplier_bindings in drivers/of/property.c to ensure that proper dev_links between producer and consumer are created.
I will send a v2 of this patch-set with addressed another issues found by patchwork bot and including the DT schema (this patch) to review if it is ok.
Thanks,
Ivan
Rob Herring
maintainerRe: [PATCH net-next 01/12] dt-bindings: dpll: add common dpll-pin-consumer schema
Quoted 69 lines · Ivan Vecera
Quoted 55 lines · Ivan Vecera
Introduce a common schema for DPLL pin consumers. Devices such as Ethernet controllers and PHYs may require connections to DPLL pins for Synchronous Ethernet (SyncE) or other frequency synchronization tasks.
Defining these properties in a shared schema ensures consistency across different device types that consume DPLL resources.
Signed-off-by Ivan Vecera <[email protected]>--- .../bindings/dpll/dpll-pin-consumer.yaml | 30 +++++++++++++++++++ MAINTAINERS | 1 + 2 files changed, 31 insertions(+)create mode 100644
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yamlDocumentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +30
-0@@ -0,0 +1,30 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/dpll/dpll-pin-consumer.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: DPLL Pin Consumer + +maintainers: + - Ivan Vecera <[email protected]> + +description: | + Common properties for devices that require connection to DPLL (Digital Phase + Locked Loop) pins for frequency synchronization (e.g. SyncE). + +properties: + dpll-pins: + $ref: /schemas/types.yaml#/definitions/phandle-array + description: + List of phandles to the DPLL pin nodes connected to this device. + + dpll-pin-names: + $ref: /schemas/types.yaml#/definitions/string-array + description: + Names for the DPLL pins defined in 'dpll-pins', in the same order. + +dependencies: + dpll-pin-names: [ dpll-pins ] + +additionalProperties: trueMAINTAINERS +0
-0MAINTAINERS M: Jiri Pirko <[email protected]> · line 7654
Quoted 7 lines
MAINTAINERS +1
-0@@ -7648,6 +7648,7 @@ M: Jiri Pirko <[email protected]> L: [email protected] S: Supported F: Documentation/devicetree/bindings/dpll/dpll-device.yaml +F: Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml F: Documentation/devicetree/bindings/dpll/dpll-pin.yaml F: Documentation/driver-api/dpll.rst F: drivers/dpll/Based on private discussion with Andrew Lunn (thanks a lot), this is wrong approach. Referencing directly dpll-pin nodes and using their phandles in consumers is at least unusual.
Quoted 2 lines
The right approach should be referencing dpll-device and use cells to specify the dpll pin that is used.
You only need a cells property if you expect the number of cells to vary by provider.
However, the DPLL device just appears to be a clock provider and consumer, so why not just use the clock binding here? Also, there is no rule that using foo binding means you have to use foo subsystem in the kernel.
Rob
Ivan Vecera
maintainerRe: [PATCH net-next 01/12] dt-bindings: dpll: add common dpll-pin-consumer schema
Quoted 73 lines · Rob Herring
Quoted 69 lines · Ivan Vecera
Quoted 55 lines · Ivan Vecera
Introduce a common schema for DPLL pin consumers. Devices such as Ethernet controllers and PHYs may require connections to DPLL pins for Synchronous Ethernet (SyncE) or other frequency synchronization tasks.
Defining these properties in a shared schema ensures consistency across different device types that consume DPLL resources.
Signed-off-by Ivan Vecera <[email protected]>--- .../bindings/dpll/dpll-pin-consumer.yaml | 30 +++++++++++++++++++ MAINTAINERS | 1 + 2 files changed, 31 insertions(+)create mode 100644
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yamlDocumentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +30
-0@@ -0,0 +1,30 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/dpll/dpll-pin-consumer.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: DPLL Pin Consumer + +maintainers: + - Ivan Vecera <[email protected]> + +description: | + Common properties for devices that require connection to DPLL (Digital Phase + Locked Loop) pins for frequency synchronization (e.g. SyncE). + +properties: + dpll-pins: + $ref: /schemas/types.yaml#/definitions/phandle-array + description: + List of phandles to the DPLL pin nodes connected to this device. + + dpll-pin-names: + $ref: /schemas/types.yaml#/definitions/string-array + description: + Names for the DPLL pins defined in 'dpll-pins', in the same order. + +dependencies: + dpll-pin-names: [ dpll-pins ] + +additionalProperties: trueMAINTAINERS +0
-0MAINTAINERS M: Jiri Pirko <[email protected]> · line 7654
Quoted 7 lines
MAINTAINERS +1
-0@@ -7648,6 +7648,7 @@ M: Jiri Pirko <[email protected]> L: [email protected] S: Supported F: Documentation/devicetree/bindings/dpll/dpll-device.yaml +F: Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml F: Documentation/devicetree/bindings/dpll/dpll-pin.yaml F: Documentation/driver-api/dpll.rst F: drivers/dpll/Based on private discussion with Andrew Lunn (thanks a lot), this is wrong approach. Referencing directly dpll-pin nodes and using their phandles in consumers is at least unusual.
Quoted 2 lines
The right approach should be referencing dpll-device and use cells to specify the dpll pin that is used.
Quoted 7 lines
You only need a cells property if you expect the number of cells to vary by provider.
However, the DPLL device just appears to be a clock provider and consumer, so why not just use the clock binding here? Also, there is no rule that using foo binding means you have to use foo subsystem in the kernel.
Hmm, do you mean something like this example?
&dpll0 {
...
#clock-cells = <2>; /* 1st pin index, 2nd pin type (input/output) */
input-pins {
pin@2 {
reg = <2>;
...
};
pin@4 {
reg = <4>;
...
};
};
output-pins {
pin@3 {
reg = <3>;
};
};
};
&phy0 {
...
clock-names = "rclk0", "rclk1", "synce_ref";
clocks = <&dpll0 2 DPLL_INPUT>,
<&dpll0 4 DPLL_INPUT>,
<&dpll0 3 DPLL_OUTPUT>;
...
};And in this case the helpers in the patch 3 would use 'clock-names' & 'clocks' properties?
If so... Excuse, I submitted v2 of this patch-set prior to seeing your email. Please be assured I did not intend to ignore your feedback.
Thanks,
Ivan
Rob Herring
maintainerRe: [PATCH net-next 01/12] dt-bindings: dpll: add common dpll-pin-consumer schema
Quoted 105 lines · Ivan Vecera
Quoted 73 lines · Rob Herring
Quoted 69 lines · Ivan Vecera
Quoted 55 lines · Ivan Vecera
Introduce a common schema for DPLL pin consumers. Devices such as Ethernet controllers and PHYs may require connections to DPLL pins for Synchronous Ethernet (SyncE) or other frequency synchronization tasks.
Defining these properties in a shared schema ensures consistency across different device types that consume DPLL resources.
Signed-off-by Ivan Vecera <[email protected]>--- .../bindings/dpll/dpll-pin-consumer.yaml | 30 +++++++++++++++++++ MAINTAINERS | 1 + 2 files changed, 31 insertions(+)create mode 100644
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yamlDocumentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +30
-0@@ -0,0 +1,30 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/dpll/dpll-pin-consumer.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: DPLL Pin Consumer + +maintainers: + - Ivan Vecera <[email protected]> + +description: | + Common properties for devices that require connection to DPLL (Digital Phase + Locked Loop) pins for frequency synchronization (e.g. SyncE). + +properties: + dpll-pins: + $ref: /schemas/types.yaml#/definitions/phandle-array + description: + List of phandles to the DPLL pin nodes connected to this device. + + dpll-pin-names: + $ref: /schemas/types.yaml#/definitions/string-array + description: + Names for the DPLL pins defined in 'dpll-pins', in the same order. + +dependencies: + dpll-pin-names: [ dpll-pins ] + +additionalProperties: trueMAINTAINERS +0
-0MAINTAINERS M: Jiri Pirko <[email protected]> · line 7654
Quoted 7 lines
MAINTAINERS +1
-0@@ -7648,6 +7648,7 @@ M: Jiri Pirko <[email protected]> L: [email protected] S: Supported F: Documentation/devicetree/bindings/dpll/dpll-device.yaml +F: Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml F: Documentation/devicetree/bindings/dpll/dpll-pin.yaml F: Documentation/driver-api/dpll.rst F: drivers/dpll/Based on private discussion with Andrew Lunn (thanks a lot), this is wrong approach. Referencing directly dpll-pin nodes and using their phandles in consumers is at least unusual.
Quoted 2 lines
The right approach should be referencing dpll-device and use cells to specify the dpll pin that is used.
Quoted 7 lines
You only need a cells property if you expect the number of cells to vary by provider.
However, the DPLL device just appears to be a clock provider and consumer, so why not just use the clock binding here? Also, there is no rule that using foo binding means you have to use foo subsystem in the kernel.
Hmm, do you mean something like this example?
&dpll0 { ... #clock-cells = <2>; /* 1st pin index, 2nd pin type (input/output) */ input-pins { pin@2 { reg = <2>; ... }; pin@4 { reg = <4>; ... }; }; output-pins { pin@3 { reg = <3>; }; }; };
Quoted 8 lines
&phy0 {
...
clock-names = "rclk0", "rclk1", "synce_ref";
clocks = <&dpll0 2 DPLL_INPUT>,
<&dpll0 4 DPLL_INPUT>,
<&dpll0 3 DPLL_OUTPUT>;
...
};No, clock providers are always the clock outputs, and clock consumers are the clock inputs. So something like this:
&dpll0 {
...
#clock-cells = <1>; /* 1st pin index */
// clocks index corresponds to input pins on dpll0 */
clocks = <&phy0 0>, <&phy0 1>, <&phy1 0>, <&phy1 1>
};
&phy0 {
...
#clock-cells = <1>;
clocks = <&dpll0 3>;
...
};Rob
Ivan Vecera
maintainerRe: [PATCH net-next 01/12] dt-bindings: dpll: add common dpll-pin-consumer schema
Quoted 118 lines · Rob Herring
Quoted 105 lines · Ivan Vecera
Quoted 73 lines · Rob Herring
Quoted 69 lines · Ivan Vecera
Quoted 55 lines · Ivan Vecera
Introduce a common schema for DPLL pin consumers. Devices such as Ethernet controllers and PHYs may require connections to DPLL pins for Synchronous Ethernet (SyncE) or other frequency synchronization tasks.
Defining these properties in a shared schema ensures consistency across different device types that consume DPLL resources.
Signed-off-by Ivan Vecera <[email protected]>--- .../bindings/dpll/dpll-pin-consumer.yaml | 30 +++++++++++++++++++ MAINTAINERS | 1 + 2 files changed, 31 insertions(+)create mode 100644
Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yamlDocumentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml new file +30
-0@@ -0,0 +1,30 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/dpll/dpll-pin-consumer.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: DPLL Pin Consumer + +maintainers: + - Ivan Vecera <[email protected]> + +description: | + Common properties for devices that require connection to DPLL (Digital Phase + Locked Loop) pins for frequency synchronization (e.g. SyncE). + +properties: + dpll-pins: + $ref: /schemas/types.yaml#/definitions/phandle-array + description: + List of phandles to the DPLL pin nodes connected to this device. + + dpll-pin-names: + $ref: /schemas/types.yaml#/definitions/string-array + description: + Names for the DPLL pins defined in 'dpll-pins', in the same order. + +dependencies: + dpll-pin-names: [ dpll-pins ] + +additionalProperties: trueMAINTAINERS +0
-0MAINTAINERS M: Jiri Pirko <[email protected]> · line 7654
Quoted 7 lines
MAINTAINERS +1
-0@@ -7648,6 +7648,7 @@ M: Jiri Pirko <[email protected]> L: [email protected] S: Supported F: Documentation/devicetree/bindings/dpll/dpll-device.yaml +F: Documentation/devicetree/bindings/dpll/dpll-pin-consumer.yaml F: Documentation/devicetree/bindings/dpll/dpll-pin.yaml F: Documentation/driver-api/dpll.rst F: drivers/dpll/Based on private discussion with Andrew Lunn (thanks a lot), this is wrong approach. Referencing directly dpll-pin nodes and using their phandles in consumers is at least unusual.
Quoted 2 lines
The right approach should be referencing dpll-device and use cells to specify the dpll pin that is used.
Quoted 7 lines
You only need a cells property if you expect the number of cells to vary by provider.
However, the DPLL device just appears to be a clock provider and consumer, so why not just use the clock binding here? Also, there is no rule that using foo binding means you have to use foo subsystem in the kernel.
Hmm, do you mean something like this example?
&dpll0 { ... #clock-cells = <2>; /* 1st pin index, 2nd pin type (input/output) */ input-pins { pin@2 { reg = <2>; ... }; pin@4 { reg = <4>; ... }; }; output-pins { pin@3 { reg = <3>; }; }; };Quoted 8 lines
&phy0 { ... clock-names = "rclk0", "rclk1", "synce_ref"; clocks = <&dpll0 2 DPLL_INPUT>, <&dpll0 4 DPLL_INPUT>, <&dpll0 3 DPLL_OUTPUT>; ... };No, clock providers are always the clock outputs, and clock consumers are the clock inputs. So something like this:
Quoted 13 lines
&dpll0 {
...
#clock-cells = <1>; /* 1st pin index */
// clocks index corresponds to input pins on dpll0 */
clocks = <&phy0 0>, <&phy0 1>, <&phy1 0>, <&phy1 1>
};
&phy0 {
...
#clock-cells = <1>;
clocks = <&dpll0 3>;
...
};Fully understand now... will modify the patch-set accordingly. Thanks for the advises.
Ivan
Ivan Vecera
maintainerPATCH 2/12 dpll: Allow associating dpll pin with a firmware node
In reply to Ivan VeceraExtend the DPLL core to support associating a DPLL pin with a firmware node. This association is required to allow other subsystems (such as network drivers) to locate and request specific DPLL pins defined in the Device Tree or ACPI.
* Add a .fwnode field to the struct dpll_pin
* Introduce dpll_pin_fwnode_set() helper to allow the provider driver to associate a pin with a fwnode after the pin has been allocated
* Introduce fwnode_dpll_pin_find() helper to allow consumers to search for a registered DPLL pin using its associated fwnode handle
* Ensure the fwnode reference is properly released in dpll_pin_put()
---
Changes:
RFC v2:
- dpll_pin_fwnode_set() helper to set firmware node without touching dpll_pin_get()
--- drivers/dpll/dpll_core.c | 49 ++++++++++++++++++++++++++++++++++++++++ drivers/dpll/dpll_core.h | 2 ++ include/linux/dpll.h | 11 +++++++++ 3 files changed, 62 insertions(+)
drivers/dpll/dpll_core.c +49 -0
@@ -10,6 +10,7 @@#include <linux/device.h> #include <linux/err.h> +#include <linux/property.h> #include <linux/slab.h> #include <linux/string.h>
@@ -599,12 +600,60 @@ void dpll_pin_put(struct dpll_pin *pin)xa_destroy (&pin->parent_refs);xa_destroy (&pin->ref_sync_pins);dpll_pin_prop_free (&pin->prop); +fwnode_handle_put (pin->fwnode);kfree_rcu (pin, rcu); }mutex_unlock (&dpll_lock); }EXPORT_SYMBOL_GPL (dpll_pin_put); +/** +* dpll_pin_fwnode_set - set dpll pin firmware node reference +* @pin: pointer to a dpll pin +* @fwnode: firmware node handle +* +* Set firmware node handle for the given dpll pin. +*/ +void dpll_pin_fwnode_set (struct dpll_pin *pin,struct fwnode_handle *fwnode) +{ +mutex_lock (&dpll_lock); +fwnode_handle_put (pin->fwnode);/* Drop fwnode previously set */ + pin->fwnode =fwnode_handle_get (fwnode); +mutex_unlock (&dpll_lock); +} +EXPORT_SYMBOL_GPL (dpll_pin_fwnode_set); + +/** +* fwnode_dpll_pin_find - find dpll pin by firmware node reference +* @fwnode: reference to firmware node +* +* Get existing object of a pin that is associated with given firmware node +* reference. +* +* Context: Acquires a lock (dpll_lock) +* Return: +* * valid dpll_pin struct pointer if succeeded +* * ERR_PTR(X) - error +*/ +struct dpll_pin *fwnode_dpll_pin_find (struct fwnode_handle *fwnode) +{ +struct dpll_pin *pin, *ret =NULL ; +unsigned long index; + +mutex_lock (&dpll_lock); +xa_for_each (&dpll_pin_xa, index, pin) { +if (pin->fwnode == fwnode) { + ret = pin; +refcount_inc (&ret->refcount); +break ; + } + } +mutex_unlock (&dpll_lock); + +return ret; +} +EXPORT_SYMBOL_GPL (fwnode_dpll_pin_find); +static int __dpll_pin_register (struct dpll_device *dpll,struct dpll_pin *pin,const struct dpll_pin_ops *ops,void *priv,void *cookie)
drivers/dpll/dpll_core.h +2 -0
@@ -42,6 +42,7 @@ struct dpll_device {* @pin_idx: index of a pin given by dev driver * @clock_id: clock_id of creator * @module: module of creator +* @fwnode: optional reference to firmware node * @dpll_refs: hold referencees to dplls pin was registered with * @parent_refs: hold references to parent pins pin was registered with * @ref_sync_pins: hold references to pins for Reference SYNC feature
@@ -54,6 +55,7 @@ struct dpll_pin {u32 pin_idx;u64 clock_id;struct module *module; +struct fwnode_handle *fwnode;struct xarray dpll_refs;struct xarray parent_refs;struct xarray ref_sync_pins;
include/linux/dpll.h +11 -0
@@ -16,6 +16,7 @@struct dpll_device ;struct dpll_pin ;struct dpll_pin_esync ; +struct fwnode_handle ;struct dpll_device_ops { int (*mode_get)(const struct dpll_device *dpll, void *dpll_priv,
@@ -173,6 +174,8 @@ void dpll_netdev_pin_clear(struct net_device *dev);size_t dpll_netdev_pin_handle_size (const struct net_device *dev);int dpll_netdev_add_pin_handle (struct sk_buff *msg,const struct net_device *dev); + +struct dpll_pin *fwnode_dpll_pin_find (struct fwnode_handle *fwnode);#else static inline void dpll_netdev_pin_set (struct net_device *dev,struct dpll_pin *dpll_pin) { }
@@ -188,6 +191,12 @@ dpll_netdev_add_pin_handle(struct sk_buff *msg, const struct net_device *dev) {return 0 ; } + +static inline struct dpll_pin * +fwnode_dpll_pin_find (struct fwnode_handle *fwnode) +{ +return NULL ; +}#endif struct dpll_device *
@@ -213,6 +222,8 @@ void dpll_pin_unregister(struct dpll_device *dpll, struct dpll_pin *pin,void dpll_pin_put (struct dpll_pin *pin); +void dpll_pin_fwnode_set (struct dpll_pin *pin,struct fwnode_handle *fwnode); +int dpll_pin_on_pin_register (struct dpll_pin *parent,struct dpll_pin *pin,const struct dpll_pin_ops *ops,void *priv);
Signature · 1 line
2.52.0
Re: [PATCH net-next 02/12] dpll: Allow associating dpll pin with a firmware node
Quoted 12 lines · Ivan Vecera
Extend the DPLL core to support associating a DPLL pin with a firmware node. This association is required to allow other subsystems (such as network drivers) to locate and request specific DPLL pins defined in the Device Tree or ACPI.
* Add a .fwnode field to the struct
dpll_pin
* Introducedpll_pin_fwnode_set()helper to allow the provider driver to associate a pin with a fwnode after the pin has been allocated
* Introducefwnode_dpll_pin_find()helper to allow consumers to search for a registered DPLL pin using its associated fwnode handle
* Ensure the fwnode reference is properly released indpll_pin_put()
Quoted 6 lines
Signed-off-by Ivan Vecera <[email protected]>---
Changes:
RFC v2:
-dpll_pin_fwnode_set()helper to set firmware node without touchingdpll_pin_get()
Ivan Vecera
maintainerPATCH 3/12 dpll: Add helpers to find DPLL pin fwnode
In reply to Ivan VeceraAdd helper functions to the DPLL core to retrieve a DPLL pin's firmware node handle based on the "dpll-pins" and "dpll-pin-names" properties.
* fwnode_dpll_pin_node_get(): matches the given name against the "dpll-pin-names" property to find the correct index, then retrieves the reference from "dpll-pins".
* device_dpll_pin_node_get(): a wrapper around the fwnode helper for convenience when using a struct device.
These helpers simplify the process for consumer drivers (such as Ethernet controllers or PHYs) to look up their associated DPLL pins defined in the DT or ACPI, which can then be passed to the DPLL subsystem to acquire the pin object.
--- drivers/dpll/dpll_core.c | 20 ++++++++++++++++++++ include/linux/dpll.h | 15 +++++++++++++++ 2 files changed, 35 insertions(+)
drivers/dpll/dpll_core.c +20 -0
@@ -654,6 +654,26 @@ struct dpll_pin *fwnode_dpll_pin_find(struct fwnode_handle *fwnode) }EXPORT_SYMBOL_GPL (fwnode_dpll_pin_find); +/** +* fwnode_dpll_pin_node_get - get dpll pin node from given fw node and pin name +* @fwnode: firmware node that uses the dpll pin +* @name: dpll pin name from dpll-pin-names property +* +* Return: ERR_PTR() on error or a valid firmware node handle on success. +*/ +struct fwnode_handle *fwnode_dpll_pin_node_get (struct fwnode_handle *fwnode, +const char *name) +{ +int index =0 ; + +if (name) + index =fwnode_property_match_string (fwnode,"dpll-pin-names" , + name); + +return fwnode_find_reference (fwnode,"dpll-pins" , index); +} +EXPORT_SYMBOL_GPL (fwnode_dpll_pin_node_get); +static int __dpll_pin_register (struct dpll_device *dpll,struct dpll_pin *pin,const struct dpll_pin_ops *ops,void *priv,void *cookie)
include/linux/dpll.h +15 -0
@@ -11,6 +11,7 @@#include <linux/device.h> #include <linux/netlink.h> #include <linux/netdevice.h> +#include <linux/property.h> #include <linux/rtnetlink.h> struct dpll_device ;
@@ -176,6 +177,8 @@ int dpll_netdev_add_pin_handle(struct sk_buff *msg, const struct net_device *dev);struct dpll_pin *fwnode_dpll_pin_find (struct fwnode_handle *fwnode); +struct fwnode_handle *fwnode_dpll_pin_node_get (struct fwnode_handle *fwnode, +const char *name);#else static inline void dpll_netdev_pin_set (struct net_device *dev,struct dpll_pin *dpll_pin) { }
@@ -197,8 +200,20 @@ fwnode_dpll_pin_find(struct fwnode_handle *fwnode) {return NULL ; } + +static inline struct fwnode_handle * +fwnode_dpll_pin_node_get (struct fwnode_handle *fwnode,const char *name) +{ +return NULL ; +}#endif +static inline struct fwnode_handle * +device_dpll_pin_node_get (struct device *dev,const char *name) +{ +return fwnode_dpll_pin_node_get (dev_fwnode (dev), name); +} +struct dpll_device *dpll_device_get (u64 clock_id,u32 dev_driver_id,struct module *module);
Signature · 1 line
2.52.0
Re: [PATCH net-next 03/12] dpll: Add helpers to find DPLL pin fwnode
Quoted 14 lines · Ivan Vecera
Add helper functions to the DPLL core to retrieve a DPLL pin's firmware node handle based on the "dpll-pins" and "dpll-pin-names" properties.
*
fwnode_dpll_pin_node_get(): matches the given name against the "dpll-pin-names" property to find the correct index, then retrieves the reference from "dpll-pins".
*device_dpll_pin_node_get(): a wrapper around the fwnode helper for convenience when using astruct device.These helpers simplify the process for consumer drivers (such as Ethernet controllers or PHYs) to look up their associated DPLL pins defined in the DT or ACPI, which can then be passed to the DPLL subsystem to acquire the pin object.
Quoted 6 lines
Signed-off-by Ivan Vecera <[email protected]>--- drivers/dpll/dpll_core.c | 20 ++++++++++++++++++++ include/linux/dpll.h | 15 +++++++++++++++ 2 files changed, 35 insertions(+)
I don't see cells defined in your binding. Neither updated property.c.
Best regards,
Krzysztof
Ivan Vecera
maintainerRe: [PATCH net-next 03/12] dpll: Add helpers to find DPLL pin fwnode
Quoted 15 lines · Krzysztof Kozlowski
Quoted 14 lines · Ivan Vecera
Add helper functions to the DPLL core to retrieve a DPLL pin's firmware node handle based on the "dpll-pins" and "dpll-pin-names" properties.
*
fwnode_dpll_pin_node_get(): matches the given name against the "dpll-pin-names" property to find the correct index, then retrieves the reference from "dpll-pins".
*device_dpll_pin_node_get(): a wrapper around the fwnode helper for convenience when using astruct device.These helpers simplify the process for consumer drivers (such as Ethernet controllers or PHYs) to look up their associated DPLL pins defined in the DT or ACPI, which can then be passed to the DPLL subsystem to acquire the pin object.
Quoted 9 lines
Quoted 6 lines
Signed-off-by Ivan Vecera <[email protected]>--- drivers/dpll/dpll_core.c | 20 ++++++++++++++++++++ include/linux/dpll.h | 15 +++++++++++++++ 2 files changed, 35 insertions(+)I don't see cells defined in your binding. Neither updated
property.c.
WDYM by property.c ?
Thanks,
Ivan
Re: [PATCH net-next 03/12] dpll: Add helpers to find DPLL pin fwnode
Quoted 25 lines · Ivan Vecera
Quoted 22 lines · Krzysztof Kozlowski
Quoted 20 lines · Ivan Vecera
Add helper functions to the DPLL core to retrieve a DPLL pin's firmware node handle based on the "dpll-pins" and "dpll-pin-names" properties.
*
fwnode_dpll_pin_node_get(): matches the given name against the "dpll-pin-names" property to find the correct index, then retrieves the reference from "dpll-pins".
*device_dpll_pin_node_get(): a wrapper around the fwnode helper for convenience when using astruct device.These helpers simplify the process for consumer drivers (such as Ethernet controllers or PHYs) to look up their associated DPLL pins defined in the DT or ACPI, which can then be passed to the DPLL subsystem to acquire the pin object.
Signed-off-by Ivan Vecera <[email protected]>--- drivers/dpll/dpll_core.c | 20 ++++++++++++++++++++ include/linux/dpll.h | 15 +++++++++++++++ 2 files changed, 35 insertions(+)
Quoted 3 lines
Quoted 2 lines
I don't see cells defined in your binding. Neither updated
property.c.WDYM by
property.c?
Each standardized phandle reliationship is supposed to be reflected with device links (at least of now... maybe it already changed after this LPC?)
Best regards,
Krzysztof
Ivan Vecera
maintainerRe: [PATCH net-next 03/12] dpll: Add helpers to find DPLL pin fwnode
Quoted 26 lines · Krzysztof Kozlowski
Quoted 25 lines · Ivan Vecera
Quoted 22 lines · Krzysztof Kozlowski
Quoted 20 lines · Ivan Vecera
Add helper functions to the DPLL core to retrieve a DPLL pin's firmware node handle based on the "dpll-pins" and "dpll-pin-names" properties.
*
fwnode_dpll_pin_node_get(): matches the given name against the "dpll-pin-names" property to find the correct index, then retrieves the reference from "dpll-pins".
*device_dpll_pin_node_get(): a wrapper around the fwnode helper for convenience when using astruct device.These helpers simplify the process for consumer drivers (such as Ethernet controllers or PHYs) to look up their associated DPLL pins defined in the DT or ACPI, which can then be passed to the DPLL subsystem to acquire the pin object.
Signed-off-by Ivan Vecera <[email protected]>--- drivers/dpll/dpll_core.c | 20 ++++++++++++++++++++ include/linux/dpll.h | 15 +++++++++++++++ 2 files changed, 35 insertions(+)
Quoted 6 lines
Quoted 3 lines
Quoted 2 lines
I don't see cells defined in your binding. Neither updated
property.c.WDYM by
property.c?Each standardized phandle reliationship is supposed to be reflected with device links (at least of now... maybe it already changed after this LPC?)
Do you mean 'supplier_bindings' in drivers/of/property.c ?
Thanks,
Ivan
Ivan Vecera
maintainerRe: [PATCH net-next 03/12] dpll: Add helpers to find DPLL pin fwnode
In reply to Krzysztof KozlowskiQuoted 15 lines · Krzysztof Kozlowski
Quoted 14 lines · Ivan Vecera
Add helper functions to the DPLL core to retrieve a DPLL pin's firmware node handle based on the "dpll-pins" and "dpll-pin-names" properties.
*
fwnode_dpll_pin_node_get(): matches the given name against the "dpll-pin-names" property to find the correct index, then retrieves the reference from "dpll-pins".
*device_dpll_pin_node_get(): a wrapper around the fwnode helper for convenience when using astruct device.These helpers simplify the process for consumer drivers (such as Ethernet controllers or PHYs) to look up their associated DPLL pins defined in the DT or ACPI, which can then be passed to the DPLL subsystem to acquire the pin object.
Quoted 8 lines
Quoted 6 lines
Signed-off-by Ivan Vecera <[email protected]>--- drivers/dpll/dpll_core.c | 20 ++++++++++++++++++++ include/linux/dpll.h | 15 +++++++++++++++ 2 files changed, 35 insertions(+)I don't see cells defined in your binding. Neither updated
property.c.
And if the cells are not required? I mean that dpll-names only specifies array of phandles without parameters...
e.g.
dpll-pin-names = "abc", "def";
dpll-pins = <&dpll_pin_abc>, <&dpll_pin_def>;
Should '#dpll-pin-cells' be defined as constantly equal to 0?
Thanks,
Ivan
Quoted 4 lines
Best regards,
Krzysztof
Re: [PATCH net-next 03/12] dpll: Add helpers to find DPLL pin fwnode
Quoted 27 lines · Ivan Vecera
Quoted 15 lines · Krzysztof Kozlowski
Quoted 14 lines · Ivan Vecera
Add helper functions to the DPLL core to retrieve a DPLL pin's firmware node handle based on the "dpll-pins" and "dpll-pin-names" properties.
*
fwnode_dpll_pin_node_get(): matches the given name against the "dpll-pin-names" property to find the correct index, then retrieves the reference from "dpll-pins".
*device_dpll_pin_node_get(): a wrapper around the fwnode helper for convenience when using astruct device.These helpers simplify the process for consumer drivers (such as Ethernet controllers or PHYs) to look up their associated DPLL pins defined in the DT or ACPI, which can then be passed to the DPLL subsystem to acquire the pin object.
Quoted 8 lines
Quoted 6 lines
Signed-off-by Ivan Vecera <[email protected]>--- drivers/dpll/dpll_core.c | 20 ++++++++++++++++++++ include/linux/dpll.h | 15 +++++++++++++++ 2 files changed, 35 insertions(+)I don't see cells defined in your binding. Neither updated
property.c.
Quoted 8 lines
And if the cells are not required? I mean that dpll-names only specifies array of phandles without parameters...
e.g.
dpll-pin-names = "abc", "def";
dpll-pins = <&dpll_pin_abc>, <&dpll_pin_def>;Should '#dpll-pin-cells' be defined as constantly equal to 0?
I don't understand how can you guarantee for every possible future device to have always cells=0. If that's the case then indeed you do not need cells, but this needs explanation. You are designing now entire ABI, so you must design it fully, not just "works for me now".
Lack of complete DTS - nothing here, nothing in the changelog - is IMO reason to NAK this patchset completely, also for reason me guessing the entire design instead of seeing the big picture.
Best regards,
Krzysztof
Ivan Vecera
maintainerRe: [PATCH net-next 03/12] dpll: Add helpers to find DPLL pin fwnode
Quoted 35 lines · Krzysztof Kozlowski
Quoted 34 lines · Ivan Vecera
Quoted 15 lines · Krzysztof Kozlowski
Quoted 14 lines · Ivan Vecera
Add helper functions to the DPLL core to retrieve a DPLL pin's firmware node handle based on the "dpll-pins" and "dpll-pin-names" properties.
*
fwnode_dpll_pin_node_get(): matches the given name against the "dpll-pin-names" property to find the correct index, then retrieves the reference from "dpll-pins".
*device_dpll_pin_node_get(): a wrapper around the fwnode helper for convenience when using astruct device.These helpers simplify the process for consumer drivers (such as Ethernet controllers or PHYs) to look up their associated DPLL pins defined in the DT or ACPI, which can then be passed to the DPLL subsystem to acquire the pin object.
Quoted 8 lines
Quoted 6 lines
Signed-off-by Ivan Vecera <[email protected]>--- drivers/dpll/dpll_core.c | 20 ++++++++++++++++++++ include/linux/dpll.h | 15 +++++++++++++++ 2 files changed, 35 insertions(+)I don't see cells defined in your binding. Neither updated
property.c.And if the cells are not required? I mean that dpll-names only specifies array of phandles without parameters...
e.g.
dpll-pin-names = "abc", "def";
dpll-pins = <&dpll_pin_abc>, <&dpll_pin_def>;
Quoted 6 lines
Quoted 1 line
Should '#dpll-pin-cells' be defined as constantly equal to 0?
I don't understand how can you guarantee for every possible future device to have always cells=0. If that's the case then indeed you do not need cells, but this needs explanation. You are designing now entire ABI, so you must design it fully, not just "works for me now".
Get it, you are right... Theoretically is possible that number of cells will be > 0.
Will add '#dpll-pin-cells'
Thanks,
Ivan
Ivan Vecera
maintainerPATCH 4/12 dpll: zl3073x: Associate pin with fwnode handle
In reply to Ivan VeceraAssociate the registered DPLL pin with its firmware node by calling dpll_pin_fwnode_set().
This links the created pin object to its corresponding DT/ACPI node in the DPLL core. Consequently, this enables consumer drivers (such as network drivers) to locate and request this specific pin using the fwnode_dpll_pin_find() helper.
--- drivers/dpll/zl3073x/dpll.c | 1 + 1 file changed, 1 insertion(+)
drivers/dpll/zl3073x/dpll.c +1 -0
@@ -1373,6 +1373,7 @@ zl3073x_dpll_pin_register(struct zl3073x_dpll_pin *pin, u32 index) rc =PTR_ERR (pin->dpll_pin); goto err_pin_get; } +dpll_pin_fwnode_set (pin->dpll_pin, props->fwnode);if (zl3073x_dpll_is_input_pin (pin)) ops = &zl3073x_dpll_input_pin_ops;
Signature · 1 line
2.52.0
Ivan Vecera
maintainerPATCH 5/12 dpll: Add notifier chain for dpll events
In reply to Ivan VeceraFrom: Petr Oros <[email protected]>
Currently, the DPLL subsystem reports events (creation, deletion, changes) to userspace via Netlink. However, there is no mechanism for other kernel components to be notified of these events directly.
Add a raw notifier chain to the DPLL core protected by dpll_lock. This allows other kernel subsystems or drivers to register callbacks and receive notifications when DPLL devices or pins are created, deleted, or modified.
Define the following:
- Registration helpers: {,un}register_dpll_notifier()
- Event types: DPLL_DEVICE_CREATED, DPLL_PIN_CREATED, etc.
- Context structures: dpll_{device,pin}_notifier_info to pass relevant data to the listeners.
The notification chain is invoked alongside the existing Netlink event generation to ensure in-kernel listeners are kept in sync with the subsystem state.
--- drivers/dpll/dpll_core.c | 57 +++++++++++++++++++++++++++++++++++++ drivers/dpll/dpll_core.h | 4 +++ drivers/dpll/dpll_netlink.c | 6 ++++ include/linux/dpll.h | 29 +++++++++++++++++++ 4 files changed, 96 insertions(+)
drivers/dpll/dpll_core.c +57 -0
@@ -23,6 +23,8 @@ DEFINE_MUTEX(dpll_lock);DEFINE_XARRAY_FLAGS (dpll_device_xa,XA_FLAGS_ALLOC );DEFINE_XARRAY_FLAGS (dpll_pin_xa,XA_FLAGS_ALLOC ); +static RAW_NOTIFIER_HEAD (dpll_notifier_chain); +static u32 dpll_device_xa_id;static u32 dpll_pin_xa_id;
@@ -46,6 +48,39 @@ struct dpll_pin_registration {void *cookie; }; +static int call_dpll_notifiers (unsigned long action,void *info) +{ +lockdep_assert_held (&dpll_lock); +return raw_notifier_call_chain (&dpll_notifier_chain, action, info); +} + +void dpll_device_notify (struct dpll_device *dpll,unsigned long action) +{ +struct dpll_device_notifier_info info = { + .dpll = dpll, + .id = dpll->id, + .idx = dpll->device_idx, + .clock_id = dpll->clock_id, + .type = dpll->type, + }; + +call_dpll_notifiers (action, &info); +} + +void dpll_pin_notify (struct dpll_pin *pin,unsigned long action) +{ +struct dpll_pin_notifier_info info = { + .pin = pin, + .id = pin->id, + .idx = pin->pin_idx, + .clock_id = pin->clock_id, + .fwnode = pin->fwnode, + .prop = &pin->prop, + }; + +call_dpll_notifiers (action, &info); +} +struct dpll_device *dpll_device_get_by_id (int id) {if (xa_get_mark (&dpll_device_xa, id,DPLL_REGISTERED ))
@@ -543,6 +578,28 @@ void dpll_netdev_pin_clear(struct net_device *dev) }EXPORT_SYMBOL (dpll_netdev_pin_clear); +int register_dpll_notifier (struct notifier_block *nb) +{ +int ret; + +mutex_lock (&dpll_lock); + ret =raw_notifier_chain_register (&dpll_notifier_chain, nb); +mutex_unlock (&dpll_lock); +return ret; +} +EXPORT_SYMBOL_GPL (register_dpll_notifier); + +int unregister_dpll_notifier (struct notifier_block *nb) +{ +int ret; + +mutex_lock (&dpll_lock); + ret =raw_notifier_chain_unregister (&dpll_notifier_chain, nb); +mutex_unlock (&dpll_lock); +return ret; +} +EXPORT_SYMBOL_GPL (unregister_dpll_notifier); +/** * dpll_pin_get - find existing or create new dpll pin * @clock_id: clock_id of creator
drivers/dpll/dpll_core.h +4 -0
@@ -91,4 +91,8 @@ struct dpll_pin_ref *dpll_xa_ref_dpll_first(struct xarray *xa_refs);extern struct xarray dpll_device_xa;extern struct xarray dpll_pin_xa;extern struct mutex dpll_lock; + +void dpll_device_notify (struct dpll_device *dpll,unsigned long action); +void dpll_pin_notify (struct dpll_pin *pin,unsigned long action); +#endif
drivers/dpll/dpll_netlink.c +6 -0
@@ -742,17 +742,20 @@ dpll_device_event_send(enum dpll_cmd event, struct dpll_device *dpll)int dpll_device_create_ntf (struct dpll_device *dpll) { +dpll_device_notify (dpll,DPLL_DEVICE_CREATED );return dpll_device_event_send (DPLL_CMD_DEVICE_CREATE_NTF , dpll); }int dpll_device_delete_ntf (struct dpll_device *dpll) { +dpll_device_notify (dpll,DPLL_DEVICE_DELETED );return dpll_device_event_send (DPLL_CMD_DEVICE_DELETE_NTF , dpll); }static int __dpll_device_change_ntf (struct dpll_device *dpll) { +dpll_device_notify (dpll,DPLL_DEVICE_CHANGED );return dpll_device_event_send (DPLL_CMD_DEVICE_CHANGE_NTF , dpll); }
@@ -810,16 +813,19 @@ dpll_pin_event_send(enum dpll_cmd event, struct dpll_pin *pin)int dpll_pin_create_ntf (struct dpll_pin *pin) { +dpll_pin_notify (pin,DPLL_PIN_CREATED );return dpll_pin_event_send (DPLL_CMD_PIN_CREATE_NTF , pin); }int dpll_pin_delete_ntf (struct dpll_pin *pin) { +dpll_pin_notify (pin,DPLL_PIN_DELETED );return dpll_pin_event_send (DPLL_CMD_PIN_DELETE_NTF , pin); }int __dpll_pin_change_ntf (struct dpll_pin *pin) { +dpll_pin_notify (pin,DPLL_PIN_CHANGED );return dpll_pin_event_send (DPLL_CMD_PIN_CHANGE_NTF , pin); }
include/linux/dpll.h +29 -0
@@ -11,6 +11,7 @@#include <linux/device.h> #include <linux/netlink.h> #include <linux/netdevice.h> +#include <linux/notifier.h> #include <linux/property.h> #include <linux/rtnetlink.h>
@@ -168,6 +169,30 @@ struct dpll_pin_properties {u32 phase_gran; }; +#define DPLL_DEVICE_CREATED 1 +#define DPLL_DEVICE_DELETED 2 +#define DPLL_DEVICE_CHANGED 3 +#define DPLL_PIN_CREATED 4 +#define DPLL_PIN_DELETED 5 +#define DPLL_PIN_CHANGED 6 + +struct dpll_device_notifier_info { +struct dpll_device *dpll; +u32 id; +u32 idx; +u64 clock_id; +enum dpll_type type; +}; + +struct dpll_pin_notifier_info { +struct dpll_pin *pin; +u32 id; +u32 idx; +u64 clock_id; +const struct fwnode_handle *fwnode; +const struct dpll_pin_properties *prop; +}; +#if IS_ENABLED (CONFIG_DPLL )void dpll_netdev_pin_set (struct net_device *dev,struct dpll_pin *dpll_pin);void dpll_netdev_pin_clear (struct net_device *dev);
@@ -252,4 +277,8 @@ int dpll_device_change_ntf(struct dpll_device *dpll);int dpll_pin_change_ntf (struct dpll_pin *pin); +int register_dpll_notifier (struct notifier_block *nb); + +int unregister_dpll_notifier (struct notifier_block *nb); +#endif
Signature · 1 line
2.52.0
Re: [PATCH net-next 05/12] dpll: Add notifier chain for dpll events
Quoted 17 lines · Ivan Vecera
From: Petr Oros <[email protected]>
Currently, the DPLL subsystem reports events (creation, deletion, changes) to userspace via Netlink. However, there is no mechanism for other kernel components to be notified of these events directly.
Add a raw notifier chain to the DPLL core protected by
dpll_lock. This allows other kernel subsystems or drivers to register callbacks and receive notifications when DPLL devices or pins are created, deleted, or modified.Define the following:
- Registration helpers: {,un}register_dpll_notifier()
- Event types:DPLL_DEVICE_CREATED,DPLL_PIN_CREATED, etc.
- Context structures: dpll_{device,pin}_notifier_info to pass relevant data to the listeners.
Quoted 7 lines
The notification chain is invoked alongside the existing Netlink event generation to ensure in-kernel listeners are kept in sync with the subsystem state.
Co-developed-by Ivan Vecera <[email protected]>Signed-off-by Ivan Vecera <[email protected]>Signed-off-by Petr Oros <[email protected]>
LGTM, Thanks!
Ivan Vecera
maintainerPATCH 6/12 dpll: Support dynamic pin index allocation
In reply to Ivan VeceraAllow drivers to register DPLL pins without manually specifying a pin index.
Currently, drivers must provide a unique pin index when calling dpll_pin_get(). This works well for hardware-mapped pins but creates friction for drivers handling virtual pins or those without a strict hardware indexing scheme.
Introduce DPLL_PIN_IDX_UNSPEC (U32_MAX). When a driver passes this value as the pin index:
1. The core allocates a unique index using an IDA
2. The allocated index is mapped to a range starting above INT_MAX
This separation ensures that dynamically allocated indices never collide with standard driver-provided hardware indices, which are assumed to be within the 0 to INT_MAX range. The index is automatically freed when the pin is released in dpll_pin_put().
--- drivers/dpll/dpll_core.c | 48 ++++++++++++++++++++++++++++++++++++++-- include/linux/dpll.h | 2 ++ 2 files changed, 48 insertions(+), 2 deletions(-)
drivers/dpll/dpll_core.c +46 -2
@@ -10,6 +10,7 @@#include <linux/device.h> #include <linux/err.h> +#include <linux/idr.h> #include <linux/property.h> #include <linux/slab.h> #include <linux/string.h>
@@ -24,6 +25,7 @@ DEFINE_XARRAY_FLAGS(dpll_device_xa, XA_FLAGS_ALLOC);DEFINE_XARRAY_FLAGS (dpll_pin_xa,XA_FLAGS_ALLOC );static RAW_NOTIFIER_HEAD (dpll_notifier_chain); +static DEFINE_IDA (dpll_pin_idx_ida);static u32 dpll_device_xa_id;static u32 dpll_pin_xa_id;
@@ -468,6 +470,36 @@ void dpll_device_unregister(struct dpll_device *dpll, }EXPORT_SYMBOL_GPL (dpll_device_unregister); +static int dpll_pin_idx_alloc (u32 *pin_idx) +{ +int ret; + +if (!pin_idx) +return -EINVAL ; + +/* Alloc unique number from IDA. Number belongs to <0, INT_MAX> range */ + ret =ida_alloc (&dpll_pin_idx_ida,GFP_KERNEL ); +if (ret <0 ) +return ret; + +/* Map the value to dynamic pin index range <INT_MAX+1, U32_MAX> */ + *pin_idx = (u32 )ret +INT_MAX +1 ; + +return 0 ; +} + +static void dpll_pin_idx_free (u32 pin_idx) +{ +if (pin_idx <=INT_MAX ) +return ;/* Not a dynamic pin index */ + +/* Map the index value from dynamic pin index range to IDA range and +* free it. +*/ + pin_idx -=INT_MAX +1 ; +ida_free (&dpll_pin_idx_ida, pin_idx); +} +static void dpll_pin_prop_free (struct dpll_pin_properties *prop) {kfree (prop->package_label);
@@ -525,9 +557,18 @@ dpll_pin_alloc(u64 clock_id, u32 pin_idx, struct module *module,struct dpll_pin *pin;int ret; +if (pin_idx ==DPLL_PIN_IDX_UNSPEC ) { + ret =dpll_pin_idx_alloc (&pin_idx); +if (ret) +return ERR_PTR (ret); + }else if (pin_idx >INT_MAX ) { +return ERR_PTR (-EINVAL ); + } pin =kzalloc (sizeof (*pin),GFP_KERNEL ); -if (!pin) -return ERR_PTR (-ENOMEM ); +if (!pin) { + ret = -ENOMEM ; + goto err_pin_alloc; + } pin->pin_idx = pin_idx; pin->clock_id = clock_id; pin->module = module;
@@ -555,6 +596,8 @@ dpll_pin_alloc(u64 clock_id, u32 pin_idx, struct module *module,dpll_pin_prop_free (&pin->prop); err_pin_prop:kfree (pin); +err_pin_alloc: +dpll_pin_idx_free (pin_idx);return ERR_PTR (ret); }
@@ -658,6 +701,7 @@ void dpll_pin_put(struct dpll_pin *pin)xa_destroy (&pin->ref_sync_pins);dpll_pin_prop_free (&pin->prop);fwnode_handle_put (pin->fwnode); +dpll_pin_idx_free (pin->pin_idx);kfree_rcu (pin, rcu); }mutex_unlock (&dpll_lock);
include/linux/dpll.h +2 -0
@@ -250,6 +250,8 @@ int dpll_device_register(struct dpll_device *dpll, enum dpll_type type,void dpll_device_unregister (struct dpll_device *dpll,const struct dpll_device_ops *ops,void *priv); +#define DPLL_PIN_IDX_UNSPEC U32_MAX +struct dpll_pin *dpll_pin_get (u64 clock_id,u32 dev_driver_id,struct module *module,const struct dpll_pin_properties *prop);
Signature · 1 line
2.52.0
kernel test robot
build botRe: [Intel-wired-lan] [PATCH net-next 06/12] dpll: Support dynamic pin index allocation
kernel test robot noticed the following build warnings:
Hi Ivan,
kernel test robot noticed the following build warnings:
[auto build test WARNING on net-next/main]
url: https://github.com/intel-lab-lkp/linux/commits/Ivan-Vecera/dt-bindings-dpll-add-common-dpll-pin-consumer-schema/20260109-022618 base: net-next/main patch link: https://lore.kernel.org/r/20260108182318.20935-7-ivecera%40redhat.com patch subject: [Intel-wired-lan] [PATCH net-next 06/12] dpll: Support dynamic pin index allocation config: x86_64-rhel-9.4 (https://download.01.org/0day-ci/archive/20260110/[email protected]/config) compiler: gcc-14 (Debian 14.2.0-19) 14.2.0 reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260110/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All warnings (new ones prefixed by >>):
drivers/dpll/dpll_core.c: In function 'dpll_pin_idx_free':
>> drivers/dpll/dpll_core.c:499:28: warning: integer overflow in expression of type 'int' results in '-2147483648' [-Woverflow]
499 | pin_idx -= INT_MAX + 1;
| ^vim +499 drivers/dpll/dpll_core.c
490
491 static void dpll_pin_idx_free(u32 pin_idx)
492 {
493 if (pin_idx <= INT_MAX)
494 return; /* Not a dynamic pin index */
495
496 /* Map the index value from dynamic pin index range to IDA range and
497 * free it.
498 */
> 499 pin_idx -= INT_MAX + 1;
500 ida_free(&dpll_pin_idx_ida, pin_idx);
501 }
502
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
kernel test robot
build botRe: [Intel-wired-lan] [PATCH net-next 06/12] dpll: Support dynamic pin index allocation
In reply to Ivan Vecerakernel test robot noticed the following build warnings:
Hi Ivan,
kernel test robot noticed the following build warnings:
[auto build test WARNING on net-next/main]
url: https://github.com/intel-lab-lkp/linux/commits/Ivan-Vecera/dt-bindings-dpll-add-common-dpll-pin-consumer-schema/20260109-022618 base: net-next/main patch link: https://lore.kernel.org/r/20260108182318.20935-7-ivecera%40redhat.com patch subject: [Intel-wired-lan] [PATCH net-next 06/12] dpll: Support dynamic pin index allocation config: m68k-allmodconfig (https://download.01.org/0day-ci/archive/20260112/[email protected]/config) compiler: m68k-linux-gcc (GCC) 15.2.0 reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260112/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All warnings (new ones prefixed by >>):
drivers/dpll/dpll_core.c: In function 'dpll_pin_idx_free':
>> drivers/dpll/dpll_core.c:499:28: warning: integer overflow in expression of type 'int' results in '-2147483648' [-Woverflow]
499 | pin_idx -= INT_MAX + 1;
| ^vim +499 drivers/dpll/dpll_core.c
490
491 static void dpll_pin_idx_free(u32 pin_idx)
492 {
493 if (pin_idx <= INT_MAX)
494 return; /* Not a dynamic pin index */
495
496 /* Map the index value from dynamic pin index range to IDA range and
497 * free it.
498 */
> 499 pin_idx -= INT_MAX + 1;
500 ida_free(&dpll_pin_idx_ida, pin_idx);
501 }
502
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
Ivan Vecera
maintainerRe: [Intel-wired-lan] [PATCH net-next 06/12] dpll: Support dynamic pin index allocation
Quoted 29 lines · kernel test robot
Hi Ivan,
kernel test robot noticed the following build warnings:
[auto build test WARNING on net-next/main]
url: https://github.com/intel-lab-lkp/linux/commits/Ivan-Vecera/dt-bindings-dpll-add-common-dpll-pin-consumer-schema/20260109-022618 base: net-next/main patch link: https://lore.kernel.org/r/20260108182318.20935-7-ivecera%40redhat.com patch subject: [Intel-wired-lan] [PATCH net-next 06/12] dpll: Support dynamic pin index allocation config: m68k-allmodconfig (https://download.01.org/0day-ci/archive/20260112/[email protected]/config) compiler: m68k-linux-gcc (GCC) 15.2.0 reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260112/[email protected]/reproduce)If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/All warnings (new ones prefixed by >>):
drivers/dpll/dpll_core.c: In function 'dpll_pin_idx_free':Quoted 1 line
Quoted 1 line
drivers/dpll/dpll_core.c:499:28: warning: integer overflow in expression of type 'int' results in '-2147483648' [-Woverflow]499 | pin_idx -= INT_MAX + 1; | ^vim +499
drivers/dpll/dpll_core.c
Quoted 10 lines
490 491 static void dpll_pin_idx_free(u32 pin_idx) 492 { 493 if (pin_idx <= INT_MAX) 494 return; /* Not a dynamic pin index */ 495 496 /* Map the index value from dynamic pin index range to IDA range and 497 * free it. 498 */Quoted 1 line
499
pin_idx-=INT_MAX+ 1;
'pin_idx -= (u32)INT_MAX + 1' should be here..
Will fix.
I.
Quoted 4 lines
500 ida_free(&dpll_pin_idx_ida, pin_idx);
501 }
502 kernel test robot
build botRe: [Intel-wired-lan] [PATCH net-next 06/12] dpll: Support dynamic pin index allocation
In reply to Ivan Vecerakernel test robot noticed the following build warnings:
Hi Ivan,
kernel test robot noticed the following build warnings:
[auto build test WARNING on net-next/main]
url: https://github.com/intel-lab-lkp/linux/commits/Ivan-Vecera/dt-bindings-dpll-add-common-dpll-pin-consumer-schema/20260109-022618 base: net-next/main patch link: https://lore.kernel.org/r/20260108182318.20935-7-ivecera%40redhat.com patch subject: [Intel-wired-lan] [PATCH net-next 06/12] dpll: Support dynamic pin index allocation config: hexagon-allmodconfig (https://download.01.org/0day-ci/archive/20260113/[email protected]/config) compiler: clang version 17.0.6 (https://github.com/llvm/llvm-project 6009708b4367171ccdbf4b5905cb6a803753fe18) reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260113/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All warnings (new ones prefixed by >>):
>> drivers/dpll/dpll_core.c:499:21: warning: overflow in expression; result is -2147483648 with type 'int' [-Winteger-overflow]
499 | pin_idx -= INT_MAX + 1;
| ^1 warning generated.
vim +/int +499 drivers/dpll/dpll_core.c
490
491 static void dpll_pin_idx_free(u32 pin_idx)
492 {
493 if (pin_idx <= INT_MAX)
494 return; /* Not a dynamic pin index */
495
496 /* Map the index value from dynamic pin index range to IDA range and
497 * free it.
498 */
> 499 pin_idx -= INT_MAX + 1;
500 ida_free(&dpll_pin_idx_ida, pin_idx);
501 }
502
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
Ivan Vecera
maintainerPATCH 7/12 dpll: zl3073x: Add support for mux pin type
In reply to Ivan VeceraAdd parsing for the "mux" string in the 'connection-type' pin property mapping it to DPLL_PIN_TYPE_MUX.
Recognizing this type in the driver allows these pins to be taken as parent pins for pin-on-pin pins coming from different modules (e.g. network drivers).
--- drivers/dpll/zl3073x/prop.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/dpll/zl3073x/prop.c +2 -0
@@ -249,6 +249,8 @@ struct zl3073x_pin_props *zl3073x_pin_props_get(struct zl3073x_dev *zldev, props->dpll_props.type =DPLL_PIN_TYPE_INT_OSCILLATOR ; else if (!strcmp(type, "synce")) props->dpll_props.type =DPLL_PIN_TYPE_SYNCE_ETH_PORT ; + else if (!strcmp(type, "mux")) + props->dpll_props.type =DPLL_PIN_TYPE_MUX ; else dev_warn(zldev->dev, "Unknown or unsupported pin type '%s'\n",
Signature · 1 line
2.52.0
Ivan Vecera
maintainerPATCH 8/12 dpll: Enhance and consolidate reference counting logic
In reply to Ivan VeceraRefactor the reference counting mechanism for DPLL devices and pins to improve consistency and prevent potential lifetime issues.
Introduce internal helpers __dpll_{device,pin}_{hold,put}() to centralize reference management.
Update the internal XArray reference helpers (dpll_xa_ref_*) to automatically grab a reference to the target object when it is added to a list, and release it when removed. This ensures that objects linked internally (e.g., pins referenced by parent pins) are properly kept alive without relying on the caller to manually manage the count.
Consequently, remove the now redundant manual refcount_inc/dec calls in dpll_pin_on_pin_{,un}register()`, as ownership is now correctly handled by the dpll_xa_ref_* functions.
Additionally, ensure that dpll_device_{,un}register()` takes/releases a reference to the device, ensuring the device object remains valid for the duration of its registration.
--- drivers/dpll/dpll_core.c | 74 +++++++++++++++++++++++++++------------- 1 file changed, 50 insertions(+), 24 deletions(-)
drivers/dpll/dpll_core.c +50 -24
@@ -83,6 +83,45 @@ void dpll_pin_notify(struct dpll_pin *pin, unsigned long action)call_dpll_notifiers (action, &info); } +static void __dpll_device_hold (struct dpll_device *dpll) +{ +refcount_inc (&dpll->refcount); +} + +static void __dpll_device_put (struct dpll_device *dpll) +{ +if (refcount_dec_and_test (&dpll->refcount)) { +ASSERT_DPLL_NOT_REGISTERED (dpll); +WARN_ON_ONCE (!xa_empty (&dpll->pin_refs)); +xa_destroy (&dpll->pin_refs); +xa_erase (&dpll_device_xa, dpll->id); +WARN_ON (!list_empty (&dpll->registration_list)); +kfree (dpll); + } +} + +static void __dpll_pin_hold (struct dpll_pin *pin) +{ +refcount_inc (&pin->refcount); +} + +static void dpll_pin_idx_free (u32 pin_idx); +static void dpll_pin_prop_free (struct dpll_pin_properties *prop); + +static void __dpll_pin_put (struct dpll_pin *pin) +{ +if (refcount_dec_and_test (&pin->refcount)) { +xa_erase (&dpll_pin_xa, pin->id); +xa_destroy (&pin->dpll_refs); +xa_destroy (&pin->parent_refs); +xa_destroy (&pin->ref_sync_pins); +dpll_pin_prop_free (&pin->prop); +fwnode_handle_put (pin->fwnode); +dpll_pin_idx_free (pin->pin_idx); +kfree_rcu (pin, rcu); + } +} +struct dpll_device *dpll_device_get_by_id (int id) {if (xa_get_mark (&dpll_device_xa, id,DPLL_REGISTERED ))
@@ -154,6 +193,7 @@ dpll_xa_ref_pin_add(struct xarray *xa_pins, struct dpll_pin *pin, reg->ops = ops; reg->priv = priv; reg->cookie = cookie; +__dpll_pin_hold (pin);if (ref_exists)refcount_inc (&ref->refcount);list_add_tail (®->list, &ref->registration_list);
@@ -176,6 +216,7 @@ static int dpll_xa_ref_pin_del(struct xarray *xa_pins, struct dpll_pin *pin,if (WARN_ON (!reg))return -EINVAL ;list_del (®->list); +__dpll_pin_put (pin);kfree (reg);if (refcount_dec_and_test (&ref->refcount)) {xa_erase (xa_pins, i);
@@ -235,6 +276,7 @@ dpll_xa_ref_dpll_add(struct xarray *xa_dplls, struct dpll_device *dpll, reg->ops = ops; reg->priv = priv; reg->cookie = cookie; +__dpll_device_hold (dpll);if (ref_exists)refcount_inc (&ref->refcount);list_add_tail (®->list, &ref->registration_list);
@@ -257,6 +299,7 @@ dpll_xa_ref_dpll_del(struct xarray *xa_dplls, struct dpll_device *dpll,if (WARN_ON (!reg))return ;list_del (®->list); +__dpll_device_put (dpll);kfree (reg);if (refcount_dec_and_test (&ref->refcount)) {xa_erase (xa_dplls, i);
@@ -327,8 +370,8 @@ dpll_device_get(u64 clock_id, u32 device_idx, struct module *module)if (dpll->clock_id == clock_id && dpll->device_idx == device_idx && dpll->module == module) { +__dpll_device_hold (dpll); ret = dpll; -refcount_inc (&ret->refcount);break ; } }
@@ -351,14 +394,7 @@ EXPORT_SYMBOL_GPL(dpll_device_get);void dpll_device_put (struct dpll_device *dpll) {mutex_lock (&dpll_lock); -if (refcount_dec_and_test (&dpll->refcount)) { -ASSERT_DPLL_NOT_REGISTERED (dpll); -WARN_ON_ONCE (!xa_empty (&dpll->pin_refs)); -xa_destroy (&dpll->pin_refs); -xa_erase (&dpll_device_xa, dpll->id); -WARN_ON (!list_empty (&dpll->registration_list)); -kfree (dpll); - } +__dpll_device_put (dpll);mutex_unlock (&dpll_lock); }EXPORT_SYMBOL_GPL (dpll_device_put);
@@ -420,6 +456,7 @@ int dpll_device_register(struct dpll_device *dpll, enum dpll_type type, reg->ops = ops; reg->priv = priv; dpll->type = type; +__dpll_device_hold (dpll); first_registration =list_empty (&dpll->registration_list);list_add_tail (®->list, &dpll->registration_list);if (!first_registration) {
@@ -459,6 +496,7 @@ void dpll_device_unregister(struct dpll_device *dpll,return ; }list_del (®->list); +__dpll_device_put (dpll);kfree (reg);if (!list_empty (&dpll->registration_list)) {
@@ -670,8 +708,8 @@ dpll_pin_get(u64 clock_id, u32 pin_idx, struct module *module,if (pos->clock_id == clock_id && pos->pin_idx == pin_idx && pos->module == module) { +__dpll_pin_hold (pos); ret = pos; -refcount_inc (&ret->refcount);break ; } }
@@ -694,16 +732,7 @@ EXPORT_SYMBOL_GPL(dpll_pin_get);void dpll_pin_put (struct dpll_pin *pin) {mutex_lock (&dpll_lock); -if (refcount_dec_and_test (&pin->refcount)) { -xa_erase (&dpll_pin_xa, pin->id); -xa_destroy (&pin->dpll_refs); -xa_destroy (&pin->parent_refs); -xa_destroy (&pin->ref_sync_pins); -dpll_pin_prop_free (&pin->prop); -fwnode_handle_put (pin->fwnode); -dpll_pin_idx_free (pin->pin_idx); -kfree_rcu (pin, rcu); - } +__dpll_pin_put (pin);mutex_unlock (&dpll_lock); }EXPORT_SYMBOL_GPL (dpll_pin_put);
@@ -744,8 +773,8 @@ struct dpll_pin *fwnode_dpll_pin_find(struct fwnode_handle *fwnode)mutex_lock (&dpll_lock);xa_for_each (&dpll_pin_xa, index, pin) {if (pin->fwnode == fwnode) { +__dpll_pin_hold (pin); ret = pin; -refcount_inc (&ret->refcount);break ; } }
@@ -917,7 +946,6 @@ int dpll_pin_on_pin_register(struct dpll_pin *parent, struct dpll_pin *pin, ret =dpll_xa_ref_pin_add (&pin->parent_refs, parent, ops, priv, pin);if (ret) goto unlock; -refcount_inc (&pin->refcount);xa_for_each (&parent->dpll_refs, i, ref) { ret =__dpll_pin_register (ref->dpll, pin, ops, priv, parent);if (ret) {
@@ -937,7 +965,6 @@ int dpll_pin_on_pin_register(struct dpll_pin *parent, struct dpll_pin *pin, parent);dpll_pin_delete_ntf (pin); } -refcount_dec (&pin->refcount);dpll_xa_ref_pin_del (&pin->parent_refs, parent, ops, priv, pin); unlock:mutex_unlock (&dpll_lock);
@@ -964,7 +991,6 @@ void dpll_pin_on_pin_unregister(struct dpll_pin *parent, struct dpll_pin *pin,mutex_lock (&dpll_lock);dpll_pin_delete_ntf (pin);dpll_xa_ref_pin_del (&pin->parent_refs, parent, ops, priv, pin); -refcount_dec (&pin->refcount);xa_for_each (&pin->dpll_refs, i, ref)__dpll_pin_unregister (ref->dpll, pin, ops, priv, parent);mutex_unlock (&dpll_lock);
Signature · 1 line
2.52.0
Ivan Vecera
maintainerPATCH 9/12 dpll: Prevent duplicate registrations
In reply to Ivan VeceraModify the internal registration helpers dpll_xa_ref_{dpll,pin}_add() to reject duplicate registration attempts.
Previously, if a caller attempted to register the same pin multiple times (with the same ops, priv, and cookie) on the same device, the core silently increments the reference count and return success. This behavior is incorrect because if the caller makes these duplicate registrations then for the first one dpll_pin_registration is allocated and for others the associated dpll_pin_ref.refcount is incremented. During the first unregistration the associated dpll_pin_registration is freed and for others WARN is fired.
Fix this by updating the logic to return -EEXIST if a matching registration is found to enforce a strict "register once" policy.
--- drivers/dpll/dpll_core.c | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)
drivers/dpll/dpll_core.c +4 -8
@@ -160,10 +160,8 @@ dpll_xa_ref_pin_add(struct xarray *xa_pins, struct dpll_pin *pin,if (ref->pin != pin)continue ; reg =dpll_pin_registration_find (ref, ops, priv, cookie); -if (reg) { -refcount_inc (&ref->refcount); -return 0 ; - } +if (reg) +return -EEXIST ; ref_exists = true;break ; }
@@ -243,10 +241,8 @@ dpll_xa_ref_dpll_add(struct xarray *xa_dplls, struct dpll_device *dpll,if (ref->dpll != dpll)continue ; reg =dpll_pin_registration_find (ref, ops, priv, cookie); -if (reg) { -refcount_inc (&ref->refcount); -return 0 ; - } +if (reg) +return -EEXIST ; ref_exists = true;break ; }
Signature · 1 line
2.52.0
Ivan Vecera
maintainerPATCH 10/12 dpll: Add reference count tracking support
In reply to Ivan VeceraAdd support for the REF_TRACKER infrastructure to the DPLL subsystem.
When enabled, this allows developers to track and debug reference counting leaks or imbalances for dpll_device and dpll_pin objects. It records stack traces for every get/put operation and exposes this information via debugfs at:
/sys/kernel/debug/ref_tracker/dpll_device_* /sys/kernel/debug/ref_tracker/dpll_pin_*
The following API changes are made to support this:
1. dpll_device_get() / dpll_device_put() now accept a 'dpll_tracker *' (which is a typedef to 'struct ref_tracker *' when enabled, or an empty struct otherwise).
2. dpll_pin_get() / dpll_pin_put() and fwnode_dpll_pin_find() similarly accept the tracker argument.
3. Internal registration structures now hold a tracker to associate the reference held by the registration with the specific owner.
All existing in-tree drivers (ice, mlx5, ptp_ocp, zl3073x) are updated to pass NULL for the new tracker argument, maintaining current behavior while enabling future debugging capabilities.
---
Changes:
RFC v2:
- added missing documentation for tracker parameters
--- drivers/dpll/Kconfig | 15 +++ drivers/dpll/dpll_core.c | 98 ++++++++++++++----- drivers/dpll/dpll_core.h | 5 + drivers/dpll/zl3073x/dpll.c | 12 +-- drivers/net/ethernet/intel/ice/ice_dpll.c | 14 +-- .../net/ethernet/mellanox/mlx5/core/dpll.c | 13 +-- drivers/ptp/ptp_ocp.c | 15 +-- include/linux/dpll.h | 19 +++- 8 files changed, 138 insertions(+), 53 deletions(-)
drivers/dpll/Kconfig +15 -0
@@ -8,6 +8,21 @@ menu "DPLL device support" config DPLL bool +config DPLL_REFCNT_TRACKER + bool "DPLL reference count tracking" + depends on DPLL + select REF_TRACKER + help + Enable reference count tracking for DPLL devices and pins. + This helps debugging reference leaks and use-after-free bugs + by recording stack traces for each get/put operation. + + The tracking information is exposed via debugfs at: + /sys/kernel/debug/ref_tracker/dpll_device_* + /sys/kernel/debug/ref_tracker/dpll_pin_* + + If unsure, say N. + source "drivers/dpll/zl3073x/Kconfig" endmenu
drivers/dpll/dpll_core.c +76 -22
283 lines not on this page · raw message
drivers/dpll/dpll_core.h +5 -0
@@ -10,6 +10,7 @@#include <linux/dpll.h> #include <linux/list.h> #include <linux/refcount.h> +#include <linux/ref_tracker.h> #include "dpll_nl.h" #define DPLL_REGISTERED XA_MARK_1
@@ -23,6 +24,7 @@* @type: type of a dpll * @pin_refs: stores pins registered within a dpll * @refcount: refcount +* @refcnt_tracker: ref_tracker directory for debugging reference leaks * @registration_list: list of registered ops and priv data of dpll owners **/ struct dpll_device {
@@ -33,6 +35,7 @@ struct dpll_device {enum dpll_type type;struct xarray pin_refs;refcount_t refcount; +struct ref_tracker_dir refcnt_tracker;struct list_head registration_list; };
@@ -48,6 +51,7 @@ struct dpll_device {* @ref_sync_pins: hold references to pins for Reference SYNC feature * @prop: pin properties copied from the registerer * @refcount: refcount +* @refcnt_tracker: ref_tracker directory for debugging reference leaks * @rcu: rcu_head for kfree_rcu() **/ struct dpll_pin {
@@ -61,6 +65,7 @@ struct dpll_pin {struct xarray ref_sync_pins;struct dpll_pin_properties prop;refcount_t refcount; +struct ref_tracker_dir refcnt_tracker;struct rcu_head rcu; };
drivers/dpll/zl3073x/dpll.c +6 -6
@@ -1368,7 +1368,7 @@ zl3073x_dpll_pin_register(struct zl3073x_dpll_pin *pin, u32 index)/* Create or get existing DPLL pin */ pin->dpll_pin =dpll_pin_get (zldpll->dev->clock_id, index,THIS_MODULE , - &props->dpll_props); + &props->dpll_props,NULL );if (IS_ERR (pin->dpll_pin)) { rc =PTR_ERR (pin->dpll_pin); goto err_pin_get;
@@ -1391,7 +1391,7 @@ zl3073x_dpll_pin_register(struct zl3073x_dpll_pin *pin, u32 index)return 0 ; err_register: -dpll_pin_put (pin->dpll_pin); +dpll_pin_put (pin->dpll_pin,NULL ); err_prio_get: pin->dpll_pin =NULL ; err_pin_get:
@@ -1422,7 +1422,7 @@ zl3073x_dpll_pin_unregister(struct zl3073x_dpll_pin *pin)/* Unregister the pin */ dpll_pin_unregister (zldpll->dpll_dev, pin->dpll_pin, ops, pin); -dpll_pin_put (pin->dpll_pin); +dpll_pin_put (pin->dpll_pin,NULL ); pin->dpll_pin =NULL ; }
@@ -1596,7 +1596,7 @@ zl3073x_dpll_device_register(struct zl3073x_dpll *zldpll) dpll_mode_refsel); zldpll->dpll_dev =dpll_device_get (zldev->clock_id, zldpll->id, -THIS_MODULE ); +THIS_MODULE ,NULL );if (IS_ERR (zldpll->dpll_dev)) { rc =PTR_ERR (zldpll->dpll_dev); zldpll->dpll_dev =NULL ;
@@ -1608,7 +1608,7 @@ zl3073x_dpll_device_register(struct zl3073x_dpll *zldpll)zl3073x_prop_dpll_type_get (zldev, zldpll->id), &zl3073x_dpll_device_ops, zldpll);if (rc) { -dpll_device_put (zldpll->dpll_dev); +dpll_device_put (zldpll->dpll_dev,NULL ); zldpll->dpll_dev =NULL ; }
@@ -1631,7 +1631,7 @@ zl3073x_dpll_device_unregister(struct zl3073x_dpll *zldpll)dpll_device_unregister (zldpll->dpll_dev, &zl3073x_dpll_device_ops, zldpll); -dpll_device_put (zldpll->dpll_dev); +dpll_device_put (zldpll->dpll_dev,NULL ); zldpll->dpll_dev =NULL ; }
drivers/net/ethernet/intel/ice/ice_dpll.c +7 -7
@@ -2814,7 +2814,7 @@ static void ice_dpll_release_pins(struct ice_dpll_pin *pins, int count)int i;for (i =0 ; i < count; i++) -dpll_pin_put (pins[i].pin); +dpll_pin_put (pins[i].pin,NULL ); }/**
@@ -2840,7 +2840,7 @@ ice_dpll_get_pins(struct ice_pf *pf, struct ice_dpll_pin *pins,for (i =0 ; i < count; i++) { pins[i].pin =dpll_pin_get (clock_id, i + start_idx,THIS_MODULE , - &pins[i].prop); + &pins[i].prop,NULL );if (IS_ERR (pins[i].pin)) { ret =PTR_ERR (pins[i].pin); goto release_pins;
@@ -2851,7 +2851,7 @@ ice_dpll_get_pins(struct ice_pf *pf, struct ice_dpll_pin *pins, release_pins:while (--i >=0 ) -dpll_pin_put (pins[i].pin); +dpll_pin_put (pins[i].pin,NULL );return ret; }
@@ -3037,7 +3037,7 @@ static void ice_dpll_deinit_rclk_pin(struct ice_pf *pf)if (WARN_ON_ONCE (!vsi || !vsi->netdev))return ;dpll_netdev_pin_clear (vsi->netdev); -dpll_pin_put (rclk->pin); +dpll_pin_put (rclk->pin,NULL ); }/**
@@ -3247,7 +3247,7 @@ ice_dpll_deinit_dpll(struct ice_pf *pf, struct ice_dpll *d, bool cgu) {if (cgu)dpll_device_unregister (d->dpll, d->ops, d); -dpll_device_put (d->dpll); +dpll_device_put (d->dpll,NULL ); }/**
@@ -3271,7 +3271,7 @@ ice_dpll_init_dpll(struct ice_pf *pf, struct ice_dpll *d, bool cgu,u64 clock_id = pf->dplls.clock_id;int ret; - d->dpll =dpll_device_get (clock_id, d->dpll_idx,THIS_MODULE ); + d->dpll =dpll_device_get (clock_id, d->dpll_idx,THIS_MODULE ,NULL );if (IS_ERR (d->dpll)) { ret =PTR_ERR (d->dpll); dev_err(ice_pf_to_dev(pf),
@@ -3287,7 +3287,7 @@ ice_dpll_init_dpll(struct ice_pf *pf, struct ice_dpll *d, bool cgu,ice_dpll_update_state (pf, d, true); ret =dpll_device_register (d->dpll, type, ops, d);if (ret) { -dpll_device_put (d->dpll); +dpll_device_put (d->dpll,NULL );return ret; } d->ops = ops;
drivers/net/ethernet/mellanox/mlx5/core/dpll.c +7 -6
@@ -438,7 +438,7 @@ static int mlx5_dpll_probe(struct auxiliary_device *adev,auxiliary_set_drvdata (adev, mdpll);/* Multiple mdev instances might share one DPLL device. */ - mdpll->dpll =dpll_device_get (clock_id,0 ,THIS_MODULE ); + mdpll->dpll =dpll_device_get (clock_id,0 ,THIS_MODULE ,NULL );if (IS_ERR (mdpll->dpll)) { err =PTR_ERR (mdpll->dpll); goto err_free_mdpll;
@@ -451,7 +451,8 @@ static int mlx5_dpll_probe(struct auxiliary_device *adev,/* Multiple mdev instances might share one DPLL pin. */ mdpll->dpll_pin =dpll_pin_get (clock_id,mlx5_get_dev_index (mdev), -THIS_MODULE , &mlx5_dpll_pin_properties); +THIS_MODULE , &mlx5_dpll_pin_properties, +NULL );if (IS_ERR (mdpll->dpll_pin)) { err =PTR_ERR (mdpll->dpll_pin); goto err_unregister_dpll_device;
@@ -479,11 +480,11 @@ static int mlx5_dpll_probe(struct auxiliary_device *adev,dpll_pin_unregister (mdpll->dpll, mdpll->dpll_pin, &mlx5_dpll_pins_ops, mdpll); err_put_dpll_pin: -dpll_pin_put (mdpll->dpll_pin); +dpll_pin_put (mdpll->dpll_pin,NULL ); err_unregister_dpll_device:dpll_device_unregister (mdpll->dpll, &mlx5_dpll_device_ops, mdpll); err_put_dpll_device: -dpll_device_put (mdpll->dpll); +dpll_device_put (mdpll->dpll,NULL ); err_free_mdpll:kfree (mdpll);return err;
@@ -499,9 +500,9 @@ static void mlx5_dpll_remove(struct auxiliary_device *adev)destroy_workqueue (mdpll->wq);dpll_pin_unregister (mdpll->dpll, mdpll->dpll_pin, &mlx5_dpll_pins_ops, mdpll); -dpll_pin_put (mdpll->dpll_pin); +dpll_pin_put (mdpll->dpll_pin,NULL );dpll_device_unregister (mdpll->dpll, &mlx5_dpll_device_ops, mdpll); -dpll_device_put (mdpll->dpll); +dpll_device_put (mdpll->dpll,NULL );kfree (mdpll); mlx5_dpll_synce_status_set(mdev,
drivers/ptp/ptp_ocp.c +8 -7
@@ -4788,7 +4788,7 @@ ptp_ocp_probe(struct pci_dev *pdev, const struct pci_device_id *id)devlink_register (devlink); clkid =pci_get_dsn (pdev); - bp->dpll =dpll_device_get (clkid,0 ,THIS_MODULE ); + bp->dpll =dpll_device_get (clkid,0 ,THIS_MODULE ,NULL );if (IS_ERR (bp->dpll)) { err =PTR_ERR (bp->dpll);dev_err (&pdev->dev,"dpll_device_alloc failed\n" );
@@ -4800,7 +4800,8 @@ ptp_ocp_probe(struct pci_dev *pdev, const struct pci_device_id *id) goto out;for (i =0 ; i <OCP_SMA_NUM ; i++) { - bp->sma[i].dpll_pin =dpll_pin_get (clkid, i,THIS_MODULE , &bp->sma[i].dpll_prop); + bp->sma[i].dpll_pin =dpll_pin_get (clkid, i,THIS_MODULE , + &bp->sma[i].dpll_prop,NULL );if (IS_ERR (bp->sma[i].dpll_pin)) { err =PTR_ERR (bp->sma[i].dpll_pin); goto out_dpll;
@@ -4809,7 +4810,7 @@ ptp_ocp_probe(struct pci_dev *pdev, const struct pci_device_id *id) err =dpll_pin_register (bp->dpll, bp->sma[i].dpll_pin, &dpll_pins_ops, &bp->sma[i]);if (err) { -dpll_pin_put (bp->sma[i].dpll_pin); +dpll_pin_put (bp->sma[i].dpll_pin,NULL ); goto out_dpll; } }
@@ -4819,9 +4820,9 @@ ptp_ocp_probe(struct pci_dev *pdev, const struct pci_device_id *id) out_dpll:while (i--) {dpll_pin_unregister (bp->dpll, bp->sma[i].dpll_pin, &dpll_pins_ops, &bp->sma[i]); -dpll_pin_put (bp->sma[i].dpll_pin); +dpll_pin_put (bp->sma[i].dpll_pin,NULL ); } -dpll_device_put (bp->dpll); +dpll_device_put (bp->dpll,NULL ); out:ptp_ocp_detach (bp); out_disable:
@@ -4842,11 +4843,11 @@ ptp_ocp_remove(struct pci_dev *pdev)for (i =0 ; i <OCP_SMA_NUM ; i++) {if (bp->sma[i].dpll_pin) {dpll_pin_unregister (bp->dpll, bp->sma[i].dpll_pin, &dpll_pins_ops, &bp->sma[i]); -dpll_pin_put (bp->sma[i].dpll_pin); +dpll_pin_put (bp->sma[i].dpll_pin,NULL ); } }dpll_device_unregister (bp->dpll, &dpll_ops, bp); -dpll_device_put (bp->dpll); +dpll_device_put (bp->dpll,NULL );devlink_unregister (devlink);ptp_ocp_detach (bp);pci_disable_device (pdev);
include/linux/dpll.h +14 -5
@@ -19,6 +19,7 @@ struct dpll_device;struct dpll_pin ;struct dpll_pin_esync ;struct fwnode_handle ; +struct ref_tracker ;struct dpll_device_ops { int (*mode_get)(const struct dpll_device *dpll, void *dpll_priv,
@@ -169,6 +170,12 @@ struct dpll_pin_properties {u32 phase_gran; }; +#ifdef CONFIG_DPLL_REFCNT_TRACKER +typedef struct ref_tracker *dpll_tracker ; +#else +typedef struct {}dpll_tracker ; +#endif +#define DPLL_DEVICE_CREATED 1#define DPLL_DEVICE_DELETED 2#define DPLL_DEVICE_CHANGED 3
@@ -201,7 +208,8 @@ size_t dpll_netdev_pin_handle_size(const struct net_device *dev);int dpll_netdev_add_pin_handle (struct sk_buff *msg,const struct net_device *dev); -struct dpll_pin *fwnode_dpll_pin_find (struct fwnode_handle *fwnode); +struct dpll_pin *fwnode_dpll_pin_find (struct fwnode_handle *fwnode, +dpll_tracker *tracker);struct fwnode_handle *fwnode_dpll_pin_node_get (struct fwnode_handle *fwnode,const char *name);#else
@@ -240,9 +248,10 @@ device_dpll_pin_node_get(struct device *dev, const char *name) }struct dpll_device * -dpll_device_get (u64 clock_id,u32 dev_driver_id,struct module *module); +dpll_device_get (u64 clock_id,u32 dev_driver_id,struct module *module, +dpll_tracker *tracker); -void dpll_device_put (struct dpll_device *dpll); +void dpll_device_put (struct dpll_device *dpll,dpll_tracker *tracker);int dpll_device_register (struct dpll_device *dpll,enum dpll_type type,const struct dpll_device_ops *ops,void *priv);
@@ -254,7 +263,7 @@ void dpll_device_unregister(struct dpll_device *dpll,struct dpll_pin *dpll_pin_get (u64 clock_id,u32 dev_driver_id,struct module *module, -const struct dpll_pin_properties *prop); +const struct dpll_pin_properties *prop,dpll_tracker *tracker);int dpll_pin_register (struct dpll_device *dpll,struct dpll_pin *pin,const struct dpll_pin_ops *ops,void *priv);
@@ -262,7 +271,7 @@ int dpll_pin_register(struct dpll_device *dpll, struct dpll_pin *pin,void dpll_pin_unregister (struct dpll_device *dpll,struct dpll_pin *pin,const struct dpll_pin_ops *ops,void *priv); -void dpll_pin_put (struct dpll_pin *pin); +void dpll_pin_put (struct dpll_pin *pin,dpll_tracker *tracker);void dpll_pin_fwnode_set (struct dpll_pin *pin,struct fwnode_handle *fwnode);
Signature · 1 line
2.52.0
kernel test robot
build botRe: [Intel-wired-lan] [PATCH net-next 10/12] dpll: Add reference count tracking support
kernel test robot noticed the following build errors:
Hi Ivan,
kernel test robot noticed the following build errors:
[auto build test ERROR on net-next/main]
url: https://github.com/intel-lab-lkp/linux/commits/Ivan-Vecera/dt-bindings-dpll-add-common-dpll-pin-consumer-schema/20260109-022618 base: net-next/main patch link: https://lore.kernel.org/r/20260108182318.20935-11-ivecera%40redhat.com patch subject: [Intel-wired-lan] [PATCH net-next 10/12] dpll: Add reference count tracking support config: m68k-allmodconfig (https://download.01.org/0day-ci/archive/20260112/[email protected]/config) compiler: m68k-linux-gcc (GCC) 15.2.0 reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260112/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All errors (new ones prefixed by >>):
lib/ref_tracker.c: In function 'ref_tracker_alloc':
>> lib/ref_tracker.c:277:22: error: implicit declaration of function 'stack_trace_save'; did you mean 'stack_depot_save'? [-Wimplicit-function-declaration]
277 | nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 1);
| ^~~~~~~~~~~~~~~~
| stack_depot_saveKconfig warnings: (for reference only)
WARNING: unmet direct dependencies detected for REF_TRACKER Depends on [n]: STACKTRACE_SUPPORT
Selected by [y]:
- DPLL_REFCNT_TRACKER [=y] && DPLL [=y]
vim +277 lib/ref_tracker.c
4e66934eaadc83b Eric Dumazet 2021-12-04 252
4e66934eaadc83b Eric Dumazet 2021-12-04 253 int ref_tracker_alloc(struct ref_tracker_dir *dir,
4e66934eaadc83b Eric Dumazet 2021-12-04 254 struct ref_tracker **trackerp,
4e66934eaadc83b Eric Dumazet 2021-12-04 255 gfp_t gfp)
4e66934eaadc83b Eric Dumazet 2021-12-04 256 {
4e66934eaadc83b Eric Dumazet 2021-12-04 257 unsigned long entries[REF_TRACKER_STACK_ENTRIES];
4e66934eaadc83b Eric Dumazet 2021-12-04 258 struct ref_tracker *tracker;
4e66934eaadc83b Eric Dumazet 2021-12-04 259 unsigned int nr_entries;
acd8f0e5d72741b Andrzej Hajda 2023-06-02 260 gfp_t gfp_mask = gfp | __GFP_NOWARN;
4e66934eaadc83b Eric Dumazet 2021-12-04 261 unsigned long flags;
4e66934eaadc83b Eric Dumazet 2021-12-04 262
e3ececfe668facd Eric Dumazet 2022-02-04 263 WARN_ON_ONCE(dir->dead);
e3ececfe668facd Eric Dumazet 2022-02-04 264
8fd5522f44dcd7f Eric Dumazet 2022-02-04 265 if (!trackerp) {
8fd5522f44dcd7f Eric Dumazet 2022-02-04 266 refcount_inc(&dir->no_tracker);
8fd5522f44dcd7f Eric Dumazet 2022-02-04 267 return 0;
8fd5522f44dcd7f Eric Dumazet 2022-02-04 268 }
c12837d1bb31032 Eric Dumazet 2022-01-12 269 if (gfp & __GFP_DIRECT_RECLAIM)
c12837d1bb31032 Eric Dumazet 2022-01-12 270 gfp_mask |= __GFP_NOFAIL;
c12837d1bb31032 Eric Dumazet 2022-01-12 271 *trackerp = tracker = kzalloc(sizeof(*tracker), gfp_mask);
4e66934eaadc83b Eric Dumazet 2021-12-04 272 if (unlikely(!tracker)) {
4e66934eaadc83b Eric Dumazet 2021-12-04 273 pr_err_once("memory allocation failure, unreliable refcount tracker.\n");
4e66934eaadc83b Eric Dumazet 2021-12-04 274 refcount_inc(&dir->untracked);
4e66934eaadc83b Eric Dumazet 2021-12-04 275 return -ENOMEM;
4e66934eaadc83b Eric Dumazet 2021-12-04 276 }
4e66934eaadc83b Eric Dumazet 2021-12-04 @277 nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 1);
4e66934eaadc83b Eric Dumazet 2021-12-04 278 tracker->alloc_stack_handle = stack_depot_save(entries, nr_entries, gfp);
4e66934eaadc83b Eric Dumazet 2021-12-04 279
4e66934eaadc83b Eric Dumazet 2021-12-04 280 spin_lock_irqsave(&dir->lock, flags);
4e66934eaadc83b Eric Dumazet 2021-12-04 281 list_add(&tracker->head, &dir->list);
4e66934eaadc83b Eric Dumazet 2021-12-04 282 spin_unlock_irqrestore(&dir->lock, flags);
4e66934eaadc83b Eric Dumazet 2021-12-04 283 return 0;
4e66934eaadc83b Eric Dumazet 2021-12-04 284 }
4e66934eaadc83b Eric Dumazet 2021-12-04 285 EXPORT_SYMBOL_GPL(ref_tracker_alloc);
4e66934eaadc83b Eric Dumazet 2021-12-04 286 Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
Ivan Vecera
maintainerPATCH 11/12 drivers: Add support for DPLL reference count tracking
In reply to Ivan VeceraUpdate existing DPLL drivers to utilize the DPLL reference count tracking infrastructure.
Add dpll_tracker fields to the drivers' internal device and pin structures. Pass pointers to these trackers when calling dpll_device_get/put() and dpll_pin_get/put().
This allows developers to inspect the specific references held by this driver via debugfs when CONFIG_DPLL_REFCNT_TRACKER is enabled, aiding in the debugging of resource leaks.
--- drivers/dpll/zl3073x/dpll.c | 14 ++++++++------ drivers/dpll/zl3073x/dpll.h | 2 ++ drivers/net/ethernet/intel/ice/ice_dpll.c | 15 ++++++++------- drivers/net/ethernet/intel/ice/ice_dpll.h | 4 ++++ drivers/net/ethernet/mellanox/mlx5/core/dpll.c | 15 +++++++++------ drivers/ptp/ptp_ocp.c | 17 ++++++++++------- 6 files changed, 41 insertions(+), 26 deletions(-)
drivers/dpll/zl3073x/dpll.c +8 -6
@@ -29,6 +29,7 @@* @list: this DPLL pin list entry * @dpll: DPLL the pin is registered to * @dpll_pin: pointer to registered dpll_pin +* @tracker: tracking object for the acquired reference * @label: package label * @dir: pin direction * @id: pin id
@@ -44,6 +45,7 @@ struct zl3073x_dpll_pin {struct list_head list;struct zl3073x_dpll *dpll;struct dpll_pin *dpll_pin; +dpll_tracker tracker;char label[8 ];enum dpll_pin_direction dir;u8 id;
@@ -1368,7 +1370,7 @@ zl3073x_dpll_pin_register(struct zl3073x_dpll_pin *pin, u32 index)/* Create or get existing DPLL pin */ pin->dpll_pin =dpll_pin_get (zldpll->dev->clock_id, index,THIS_MODULE , - &props->dpll_props,NULL ); + &props->dpll_props, &pin->tracker);if (IS_ERR (pin->dpll_pin)) { rc =PTR_ERR (pin->dpll_pin); goto err_pin_get;
@@ -1391,7 +1393,7 @@ zl3073x_dpll_pin_register(struct zl3073x_dpll_pin *pin, u32 index)return 0 ; err_register: -dpll_pin_put (pin->dpll_pin,NULL ); +dpll_pin_put (pin->dpll_pin, &pin->tracker); err_prio_get: pin->dpll_pin =NULL ; err_pin_get:
@@ -1422,7 +1424,7 @@ zl3073x_dpll_pin_unregister(struct zl3073x_dpll_pin *pin)/* Unregister the pin */ dpll_pin_unregister (zldpll->dpll_dev, pin->dpll_pin, ops, pin); -dpll_pin_put (pin->dpll_pin,NULL ); +dpll_pin_put (pin->dpll_pin, &pin->tracker); pin->dpll_pin =NULL ; }
@@ -1596,7 +1598,7 @@ zl3073x_dpll_device_register(struct zl3073x_dpll *zldpll) dpll_mode_refsel); zldpll->dpll_dev =dpll_device_get (zldev->clock_id, zldpll->id, -THIS_MODULE ,NULL ); +THIS_MODULE , &zldpll->tracker);if (IS_ERR (zldpll->dpll_dev)) { rc =PTR_ERR (zldpll->dpll_dev); zldpll->dpll_dev =NULL ;
@@ -1608,7 +1610,7 @@ zl3073x_dpll_device_register(struct zl3073x_dpll *zldpll)zl3073x_prop_dpll_type_get (zldev, zldpll->id), &zl3073x_dpll_device_ops, zldpll);if (rc) { -dpll_device_put (zldpll->dpll_dev,NULL ); +dpll_device_put (zldpll->dpll_dev, &zldpll->tracker); zldpll->dpll_dev =NULL ; }
@@ -1631,7 +1633,7 @@ zl3073x_dpll_device_unregister(struct zl3073x_dpll *zldpll)dpll_device_unregister (zldpll->dpll_dev, &zl3073x_dpll_device_ops, zldpll); -dpll_device_put (zldpll->dpll_dev,NULL ); +dpll_device_put (zldpll->dpll_dev, &zldpll->tracker); zldpll->dpll_dev =NULL ; }
drivers/dpll/zl3073x/dpll.h +2 -0
@@ -18,6 +18,7 @@* @check_count: periodic check counter * @phase_monitor: is phase offset monitor enabled * @dpll_dev: pointer to registered DPLL device +* @tracker: tracking object for the acquired reference * @lock_status: last saved DPLL lock status * @pins: list of pins * @change_work: device change notification work
@@ -31,6 +32,7 @@ struct zl3073x_dpll {u8 check_count;bool phase_monitor;struct dpll_device *dpll_dev; +dpll_tracker tracker;enum dpll_lock_status lock_status;struct list_head pins;struct work_struct change_work;
drivers/net/ethernet/intel/ice/ice_dpll.c +8 -7
@@ -2814,7 +2814,7 @@ static void ice_dpll_release_pins(struct ice_dpll_pin *pins, int count)int i;for (i =0 ; i < count; i++) -dpll_pin_put (pins[i].pin,NULL ); +dpll_pin_put (pins[i].pin, &pins[i].tracker); }/**
@@ -2840,7 +2840,7 @@ ice_dpll_get_pins(struct ice_pf *pf, struct ice_dpll_pin *pins,for (i =0 ; i < count; i++) { pins[i].pin =dpll_pin_get (clock_id, i + start_idx,THIS_MODULE , - &pins[i].prop,NULL ); + &pins[i].prop, &pins[i].tracker);if (IS_ERR (pins[i].pin)) { ret =PTR_ERR (pins[i].pin); goto release_pins;
@@ -2851,7 +2851,7 @@ ice_dpll_get_pins(struct ice_pf *pf, struct ice_dpll_pin *pins, release_pins:while (--i >=0 ) -dpll_pin_put (pins[i].pin,NULL ); +dpll_pin_put (pins[i].pin, &pins[i].tracker);return ret; }
@@ -3037,7 +3037,7 @@ static void ice_dpll_deinit_rclk_pin(struct ice_pf *pf)if (WARN_ON_ONCE (!vsi || !vsi->netdev))return ;dpll_netdev_pin_clear (vsi->netdev); -dpll_pin_put (rclk->pin,NULL ); +dpll_pin_put (rclk->pin, &rclk->tracker); }/**
@@ -3247,7 +3247,7 @@ ice_dpll_deinit_dpll(struct ice_pf *pf, struct ice_dpll *d, bool cgu) {if (cgu)dpll_device_unregister (d->dpll, d->ops, d); -dpll_device_put (d->dpll,NULL ); +dpll_device_put (d->dpll, &d->tracker); }/**
@@ -3271,7 +3271,8 @@ ice_dpll_init_dpll(struct ice_pf *pf, struct ice_dpll *d, bool cgu,u64 clock_id = pf->dplls.clock_id;int ret; - d->dpll =dpll_device_get (clock_id, d->dpll_idx,THIS_MODULE ,NULL ); + d->dpll =dpll_device_get (clock_id, d->dpll_idx,THIS_MODULE , + &d->tracker);if (IS_ERR (d->dpll)) { ret =PTR_ERR (d->dpll); dev_err(ice_pf_to_dev(pf),
@@ -3287,7 +3288,7 @@ ice_dpll_init_dpll(struct ice_pf *pf, struct ice_dpll *d, bool cgu,ice_dpll_update_state (pf, d, true); ret =dpll_device_register (d->dpll, type, ops, d);if (ret) { -dpll_device_put (d->dpll,NULL ); +dpll_device_put (d->dpll, &d->tracker);return ret; } d->ops = ops;
drivers/net/ethernet/intel/ice/ice_dpll.h +4 -0
@@ -23,6 +23,7 @@ enum ice_dpll_pin_sw {/** ice_dpll_pin - store info about pins * @pin: dpll pin structure * @pf: pointer to pf, which has registered the dpll_pin +* @tracker: reference count tracker * @idx: ice pin private idx * @num_parents: hols number of parent pins * @parent_idx: hold indexes of parent pins
@@ -37,6 +38,7 @@ enum ice_dpll_pin_sw {struct ice_dpll_pin {struct dpll_pin *pin;struct ice_pf *pf; +dpll_tracker tracker;u8 idx;u8 num_parents;u8 parent_idx[ICE_DPLL_RCLK_NUM_MAX ];
@@ -58,6 +60,7 @@ struct ice_dpll_pin {/** ice_dpll - store info required for DPLL control * @dpll: pointer to dpll dev * @pf: pointer to pf, which has registered the dpll_device +* @tracker: reference count tracker * @dpll_idx: index of dpll on the NIC * @input_idx: currently selected input index * @prev_input_idx: previously selected input index
@@ -76,6 +79,7 @@ struct ice_dpll_pin {struct ice_dpll {struct dpll_device *dpll;struct ice_pf *pf; +dpll_tracker tracker;u8 dpll_idx;u8 input_idx;u8 prev_input_idx;
drivers/net/ethernet/mellanox/mlx5/core/dpll.c +9 -6
@@ -9,7 +9,9 @@*/ struct mlx5_dpll {struct dpll_device *dpll; +dpll_tracker dpll_tracker;struct dpll_pin *dpll_pin; +dpll_tracker pin_tracker;struct mlx5_core_dev *mdev;struct workqueue_struct *wq;struct delayed_work work;
@@ -438,7 +440,8 @@ static int mlx5_dpll_probe(struct auxiliary_device *adev,auxiliary_set_drvdata (adev, mdpll);/* Multiple mdev instances might share one DPLL device. */ - mdpll->dpll =dpll_device_get (clock_id,0 ,THIS_MODULE ,NULL ); + mdpll->dpll =dpll_device_get (clock_id,0 ,THIS_MODULE , + &mdpll->dpll_tracker);if (IS_ERR (mdpll->dpll)) { err =PTR_ERR (mdpll->dpll); goto err_free_mdpll;
@@ -452,7 +455,7 @@ static int mlx5_dpll_probe(struct auxiliary_device *adev,/* Multiple mdev instances might share one DPLL pin. */ mdpll->dpll_pin =dpll_pin_get (clock_id,mlx5_get_dev_index (mdev),THIS_MODULE , &mlx5_dpll_pin_properties, -NULL ); + &mdpll->pin_tracker);if (IS_ERR (mdpll->dpll_pin)) { err =PTR_ERR (mdpll->dpll_pin); goto err_unregister_dpll_device;
@@ -480,11 +483,11 @@ static int mlx5_dpll_probe(struct auxiliary_device *adev,dpll_pin_unregister (mdpll->dpll, mdpll->dpll_pin, &mlx5_dpll_pins_ops, mdpll); err_put_dpll_pin: -dpll_pin_put (mdpll->dpll_pin,NULL ); +dpll_pin_put (mdpll->dpll_pin, &mdpll->pin_tracker); err_unregister_dpll_device:dpll_device_unregister (mdpll->dpll, &mlx5_dpll_device_ops, mdpll); err_put_dpll_device: -dpll_device_put (mdpll->dpll,NULL ); +dpll_device_put (mdpll->dpll, &mdpll->dpll_tracker); err_free_mdpll:kfree (mdpll);return err;
@@ -500,9 +503,9 @@ static void mlx5_dpll_remove(struct auxiliary_device *adev)destroy_workqueue (mdpll->wq);dpll_pin_unregister (mdpll->dpll, mdpll->dpll_pin, &mlx5_dpll_pins_ops, mdpll); -dpll_pin_put (mdpll->dpll_pin,NULL ); +dpll_pin_put (mdpll->dpll_pin, &mdpll->pin_tracker);dpll_device_unregister (mdpll->dpll, &mlx5_dpll_device_ops, mdpll); -dpll_device_put (mdpll->dpll,NULL ); +dpll_device_put (mdpll->dpll, &mdpll->dpll_tracker);kfree (mdpll); mlx5_dpll_synce_status_set(mdev,
drivers/ptp/ptp_ocp.c +10 -7
@@ -285,6 +285,7 @@ struct ptp_ocp_sma_connector {u8 default_fcn;struct dpll_pin *dpll_pin;struct dpll_pin_properties dpll_prop; +dpll_tracker tracker; };struct ocp_attr_group {
@@ -383,6 +384,7 @@ struct ptp_ocp {struct ptp_ocp_sma_connector sma[OCP_SMA_NUM ];const struct ocp_sma_op *sma_op;struct dpll_device *dpll; +dpll_tracker tracker;int signals_nr;int freq_in_nr; };
@@ -4788,7 +4790,7 @@ ptp_ocp_probe(struct pci_dev *pdev, const struct pci_device_id *id)devlink_register (devlink); clkid =pci_get_dsn (pdev); - bp->dpll =dpll_device_get (clkid,0 ,THIS_MODULE ,NULL ); + bp->dpll =dpll_device_get (clkid,0 ,THIS_MODULE , &bp->tracker);if (IS_ERR (bp->dpll)) { err =PTR_ERR (bp->dpll);dev_err (&pdev->dev,"dpll_device_alloc failed\n" );
@@ -4801,7 +4803,8 @@ ptp_ocp_probe(struct pci_dev *pdev, const struct pci_device_id *id)for (i =0 ; i <OCP_SMA_NUM ; i++) { bp->sma[i].dpll_pin =dpll_pin_get (clkid, i,THIS_MODULE , - &bp->sma[i].dpll_prop,NULL ); + &bp->sma[i].dpll_prop, + &bp->sma[i].tracker);if (IS_ERR (bp->sma[i].dpll_pin)) { err =PTR_ERR (bp->sma[i].dpll_pin); goto out_dpll;
@@ -4810,7 +4813,7 @@ ptp_ocp_probe(struct pci_dev *pdev, const struct pci_device_id *id) err =dpll_pin_register (bp->dpll, bp->sma[i].dpll_pin, &dpll_pins_ops, &bp->sma[i]);if (err) { -dpll_pin_put (bp->sma[i].dpll_pin,NULL ); +dpll_pin_put (bp->sma[i].dpll_pin, &bp->sma[i].tracker); goto out_dpll; } }
@@ -4820,9 +4823,9 @@ ptp_ocp_probe(struct pci_dev *pdev, const struct pci_device_id *id) out_dpll:while (i--) {dpll_pin_unregister (bp->dpll, bp->sma[i].dpll_pin, &dpll_pins_ops, &bp->sma[i]); -dpll_pin_put (bp->sma[i].dpll_pin,NULL ); +dpll_pin_put (bp->sma[i].dpll_pin, &bp->sma[i].tracker); } -dpll_device_put (bp->dpll,NULL ); +dpll_device_put (bp->dpll, &bp->tracker); out:ptp_ocp_detach (bp); out_disable:
@@ -4843,11 +4846,11 @@ ptp_ocp_remove(struct pci_dev *pdev)for (i =0 ; i <OCP_SMA_NUM ; i++) {if (bp->sma[i].dpll_pin) {dpll_pin_unregister (bp->dpll, bp->sma[i].dpll_pin, &dpll_pins_ops, &bp->sma[i]); -dpll_pin_put (bp->sma[i].dpll_pin,NULL ); +dpll_pin_put (bp->sma[i].dpll_pin, &bp->sma[i].tracker); } }dpll_device_unregister (bp->dpll, &dpll_ops, bp); -dpll_device_put (bp->dpll,NULL ); +dpll_device_put (bp->dpll, &bp->tracker);devlink_unregister (devlink);ptp_ocp_detach (bp);pci_disable_device (pdev);
Signature · 1 line
2.52.0
Ivan Vecera
maintainerPATCH 12/12 ice: dpll: Support E825-C SyncE and dynamic pin discovery
In reply to Ivan VeceraFrom: Arkadiusz Kubalewski <[email protected]>
Add DPLL support for the Intel E825-C Ethernet controller. Unlike previous generations (E810), the E825-C connects to the platform's DPLL subsystem via MUX pins defined in the system firmware (Device Tree/ACPI).
Implement the following mechanisms to support this architecture:
1. Dynamic Pin Discovery: Use the fwnode_dpll_pin_find() helper to locate the parent MUX pins defined in the firmware.
2. Asynchronous Registration: Since the platform DPLL driver may probe independently of the network driver, utilize the DPLL notifier chain (register_dpll_notifier). The driver listens for DPLL_PIN_CREATED events to detect when the parent MUX pins become available, then registers its own Recovered Clock (RCLK) pins as children of those parents.
3. Hardware Configuration: Implement the specific register access logic for E825-C CGU (Clock Generation Unit) registers (R10, R11). This includes configuring the bypass MUXes and clock dividers required to drive SyncE signals.
4. Split Initialization: Refactor ice_dpll_init() to separate the static initialization path of E810 from the dynamic, firmware-driven path required for E825-C.
--- drivers/net/ethernet/intel/ice/ice_dpll.c | 715 +++++++++++++++++--- drivers/net/ethernet/intel/ice/ice_dpll.h | 25 + drivers/net/ethernet/intel/ice/ice_lib.c | 3 + drivers/net/ethernet/intel/ice/ice_ptp.c | 29 + drivers/net/ethernet/intel/ice/ice_ptp_hw.c | 9 +- drivers/net/ethernet/intel/ice/ice_tspll.c | 217 ++++++ drivers/net/ethernet/intel/ice/ice_tspll.h | 13 +- drivers/net/ethernet/intel/ice/ice_type.h | 6 + 8 files changed, 925 insertions(+), 92 deletions(-)
drivers/net/ethernet/intel/ice/ice_dpll.c +625 -90
@@ -5,6 +5,7 @@#include "ice_lib.h" #include "ice_trace.h" #include <linux/dpll.h> +#include <linux/property.h> #define ICE_CGU_STATE_ACQ_ERR_THRESHOLD 50#define ICE_DPLL_PIN_IDX_INVALID 0xff
@@ -528,6 +529,92 @@ ice_dpll_pin_disable(struct ice_hw *hw, struct ice_dpll_pin *pin,return ret; } +/** +* ice_dpll_pin_store_state - updates the state of pin in SW bookkeeping +* @pin: pointer to a pin +* @parent: parent pin index +* @state: pin state (connected or disconnected) +*/ +static void +ice_dpll_pin_store_state (struct ice_dpll_pin *pin,int parent,bool state) +{ + pin->state[parent] = state ?DPLL_PIN_STATE_CONNECTED : +DPLL_PIN_STATE_DISCONNECTED ; +} + +/** +* ice_dpll_rclk_update_e825c - updates the state of rclk pin on e825c device +* @pf: private board struct +* @pin: pointer to a pin +* +* Update struct holding pin states info, states are separate for each parent +* +* Context: Called under pf->dplls.lock +* Return: +* * 0 - OK +* * negative - error +*/ +static int ice_dpll_rclk_update_e825c (struct ice_pf *pf, +struct ice_dpll_pin *pin) +{ +u8 rclk_bits; +int err; +u32 reg; + +if (pf->dplls.rclk.num_parents >ICE_SYNCE_CLK_NUM ) +return -EINVAL ; + + err =ice_read_cgu_reg (&pf->hw,ICE_CGU_R10 , ®); +if (err) +return err; + + rclk_bits =FIELD_GET (ICE_CGU_R10_SYNCE_S_REF_CLK , reg); +ice_dpll_pin_store_state (pin,ICE_SYNCE_CLK0 , rclk_bits == + (pf->ptp.port.port_num +ICE_CGU_BYPASS_MUX_OFFSET_E825C )); + + err =ice_read_cgu_reg (&pf->hw,ICE_CGU_R11 , ®); +if (err) +return err; + + rclk_bits =FIELD_GET (ICE_CGU_R11_SYNCE_S_BYP_CLK , reg); +ice_dpll_pin_store_state (pin,ICE_SYNCE_CLK1 , rclk_bits == + (pf->ptp.port.port_num +ICE_CGU_BYPASS_MUX_OFFSET_E825C )); + +return 0 ; +} + +/** +* ice_dpll_rclk_update - updates the state of rclk pin on a device +* @pf: private board struct +* @pin: pointer to a pin +* @port_num: port number +* +* Update struct holding pin states info, states are separate for each parent +* +* Context: Called under pf->dplls.lock +* Return: +* * 0 - OK +* * negative - error +*/ +static int ice_dpll_rclk_update (struct ice_pf *pf,struct ice_dpll_pin *pin, +u8 port_num) +{ +int ret; + +for (u8 parent =0 ; parent < pf->dplls.rclk.num_parents; parent++) { + ret =ice_aq_get_phy_rec_clk_out (&pf->hw, &parent, &port_num, + &pin->flags[parent],NULL ); +if (ret) +return ret; + +ice_dpll_pin_store_state (pin, parent, +ICE_AQC_GET_PHY_REC_CLK_OUT_OUT_EN & + pin->flags[parent]); + } + +return 0 ; +} +/** * ice_dpll_sw_pins_update - update status of all SW pins * @pf: private board struct
@@ -668,22 +755,14 @@ ice_dpll_pin_state_update(struct ice_pf *pf, struct ice_dpll_pin *pin, }break ;case ICE_DPLL_PIN_TYPE_RCLK_INPUT : -for (parent =0 ; parent < pf->dplls.rclk.num_parents; - parent++) { -u8 p = parent; - - ret =ice_aq_get_phy_rec_clk_out (&pf->hw, &p, - &port_num, - &pin->flags[parent], -NULL ); +if (pf->hw.mac_type ==ICE_MAC_GENERIC_3K_E825 ) { + ret =ice_dpll_rclk_update_e825c (pf, pin); +if (ret) + goto err; + }else { + ret =ice_dpll_rclk_update (pf, pin, port_num);if (ret) goto err; -if (ICE_AQC_GET_PHY_REC_CLK_OUT_OUT_EN & - pin->flags[parent]) - pin->state[parent] =DPLL_PIN_STATE_CONNECTED ; -else - pin->state[parent] = -DPLL_PIN_STATE_DISCONNECTED ; }break ;case ICE_DPLL_PIN_TYPE_SOFTWARE :
@@ -1842,6 +1921,40 @@ ice_dpll_phase_offset_get(const struct dpll_pin *pin, void *pin_priv,return 0 ; } +/** +* ice_dpll_synce_update_e825c - setting PHY recovered clock pins on e825c +* @hw: Pointer to the HW struct +* @ena: true if enable, false in disable +* @port_num: port number +* @output: output pin, we have two in E825C +* +* DPLL subsystem callback. Set proper signals to recover clock from port. +* +* Context: Called under pf->dplls.lock +* Return: +* * 0 - success +* * negative - error +*/ +static int ice_dpll_synce_update_e825c (struct ice_hw *hw,bool ena, +u32 port_num,enum ice_synce_clk output) +{ +int err; + +/* configure the mux to deliver proper signal to DPLL from the MUX */ + err =ice_tspll_cfg_bypass_mux_e825c (hw, ena, port_num, output); +if (err) +return err; + + err =ice_tspll_cfg_synce_ethdiv_e825c (hw, output); +if (err) +return err; + +dev_dbg (ice_hw_to_dev (hw),"CLK_SYNCE%u recovered clock: pin %s\n" , + output,str_enabled_disabled (ena)); + +return 0 ; +} +/** * ice_dpll_output_esync_set - callback for setting embedded sync * @pin: pointer to a pin
@@ -2263,6 +2376,28 @@ ice_dpll_sw_input_ref_sync_get(const struct dpll_pin *pin, void *pin_priv, state, extack); } +static int +ice_dpll_pin_get_parent_num (struct ice_dpll_pin *pin, +const struct dpll_pin *parent) +{ +int i; + +for (i =0 ; i < pin->num_parents; i++) +if (pin->pf->dplls.inputs[pin->parent_idx[i]].pin == parent) +return i; + +return -ENOENT ; +} + +static int +ice_dpll_pin_get_parent_idx (struct ice_dpll_pin *pin, +const struct dpll_pin *parent) +{ +int num =ice_dpll_pin_get_parent_num (pin, parent); + +return num <0 ? num : pin->parent_idx[num]; +} +/** * ice_dpll_rclk_state_on_pin_set - set a state on rclk pin * @pin: pointer to a pin
@@ -2286,35 +2421,44 @@ ice_dpll_rclk_state_on_pin_set(const struct dpll_pin *pin, void *pin_priv,enum dpll_pin_state state, struct netlink_ext_ack *extack) { - struct ice_dpll_pin *p = pin_priv, *parent = parent_pin_priv; bool enable = state == DPLL_PIN_STATE_CONNECTED; +struct ice_dpll_pin *p = pin_priv;struct ice_pf *pf = p->pf; +struct ice_hw *hw;int ret = -EINVAL ; -u32 hw_idx; +int hw_idx; + + hw = &pf->hw;if (ice_dpll_is_reset (pf, extack))return -EBUSY ;mutex_lock (&pf->dplls.lock); - hw_idx = parent->idx - pf->dplls.base_rclk_idx; -if (hw_idx >= pf->dplls.num_inputs) + hw_idx =ice_dpll_pin_get_parent_idx (p, parent_pin); +if (hw_idx <0 ) goto unlock;if ((enable && p->state[hw_idx] ==DPLL_PIN_STATE_CONNECTED ) || (!enable && p->state[hw_idx] ==DPLL_PIN_STATE_DISCONNECTED )) {NL_SET_ERR_MSG_FMT (extack,"pin:%u state:%u on parent:%u already set" , - p->idx, state, parent->idx); + p->idx, state, +ice_dpll_pin_get_parent_num (p, parent_pin)); goto unlock; } - ret =ice_aq_set_phy_rec_clk_out (&pf->hw, hw_idx, enable, - &p->freq); + + ret = hw->mac_type ==ICE_MAC_GENERIC_3K_E825 ? +ice_dpll_synce_update_e825c (hw, enable, + pf->ptp.port.port_num, + (enum ice_synce_clk )hw_idx) : +ice_aq_set_phy_rec_clk_out (hw, hw_idx, enable, &p->freq);if (ret)NL_SET_ERR_MSG_FMT (extack,"err:%d %s failed to set pin state:%u for pin:%u on parent:%u" , ret, -libie_aq_str (pf->hw.adminq.sq_last_status), - state, p->idx, parent->idx); +libie_aq_str (hw->adminq.sq_last_status), + state, p->idx, +ice_dpll_pin_get_parent_num (p, parent_pin)); unlock:mutex_unlock (&pf->dplls.lock);
@@ -2344,17 +2488,17 @@ ice_dpll_rclk_state_on_pin_get(const struct dpll_pin *pin, void *pin_priv,enum dpll_pin_state *state, struct netlink_ext_ack *extack) { - struct ice_dpll_pin *p = pin_priv, *parent = parent_pin_priv; + struct ice_dpll_pin *p = pin_priv;struct ice_pf *pf = p->pf;int ret = -EINVAL ; -u32 hw_idx; +int hw_idx;if (ice_dpll_is_reset (pf, extack))return -EBUSY ;mutex_lock (&pf->dplls.lock); - hw_idx = parent->idx - pf->dplls.base_rclk_idx; -if (hw_idx >= pf->dplls.num_inputs) + hw_idx =ice_dpll_pin_get_parent_idx (p, parent_pin); +if (hw_idx <0 ) goto unlock; ret = ice_dpll_pin_state_update(pf, p, ICE_DPLL_PIN_TYPE_RCLK_INPUT,
@@ -2814,7 +2958,8 @@ static void ice_dpll_release_pins(struct ice_dpll_pin *pins, int count)int i;for (i =0 ; i < count; i++) -dpll_pin_put (pins[i].pin, &pins[i].tracker); +if (!IS_ERR_OR_NULL (pins[i].pin)) +dpll_pin_put (pins[i].pin, &pins[i].tracker); }/**
@@ -2836,10 +2981,14 @@ static int ice_dpll_get_pins(struct ice_pf *pf, struct ice_dpll_pin *pins, int start_idx, int count, u64 clock_id) { + u32 pin_index;int i, ret;for (i =0 ; i < count; i++) { - pins[i].pin =dpll_pin_get (clock_id, i + start_idx,THIS_MODULE , + pin_index = start_idx; +if (start_idx !=DPLL_PIN_IDX_UNSPEC ) + pin_index += i; + pins[i].pin =dpll_pin_get (clock_id, pin_index,THIS_MODULE , &pins[i].prop, &pins[i].tracker);if (IS_ERR (pins[i].pin)) { ret =PTR_ERR (pins[i].pin);
@@ -2944,6 +3093,7 @@ ice_dpll_register_pins(struct dpll_device *dpll, struct ice_dpll_pin *pins,/** * ice_dpll_deinit_direct_pins - deinitialize direct pins +* @pf: board private structure * @cgu: if cgu is present and controlled by this NIC * @pins: pointer to pins array * @count: number of pins
@@ -2955,7 +3105,8 @@ ice_dpll_register_pins(struct dpll_device *dpll, struct ice_dpll_pin *pins,* Release pins resources to the dpll subsystem. */ static void -ice_dpll_deinit_direct_pins (bool cgu,struct ice_dpll_pin *pins,int count, +ice_dpll_deinit_direct_pins (struct ice_pf *pf,bool cgu, +struct ice_dpll_pin *pins,int count,const struct dpll_pin_ops *ops,struct dpll_device *first,struct dpll_device *second)
@@ -3024,14 +3175,14 @@ static void ice_dpll_deinit_rclk_pin(struct ice_pf *pf) {struct ice_dpll_pin *rclk = &pf->dplls.rclk;struct ice_vsi *vsi =ice_get_main_vsi (pf); -struct dpll_pin *parent; +struct ice_dpll_pin *parent;int i;for (i =0 ; i < rclk->num_parents; i++) { - parent = pf->dplls.inputs[rclk->parent_idx[i]].pin; -if (!parent) + parent = &pf->dplls.inputs[rclk->parent_idx[i]]; +if (IS_ERR_OR_NULL (parent->pin))continue ; -dpll_pin_on_pin_unregister (parent, rclk->pin, +dpll_pin_on_pin_unregister (parent->pin, rclk->pin, &ice_dpll_rclk_ops, rclk); }if (WARN_ON_ONCE (!vsi || !vsi->netdev))
@@ -3040,60 +3191,209 @@ static void ice_dpll_deinit_rclk_pin(struct ice_pf *pf)dpll_pin_put (rclk->pin, &rclk->tracker); } +static bool ice_dpll_is_fwnode_pin (struct ice_dpll_pin *pin) +{ +return !IS_ERR_OR_NULL (pin->fwnode); +} + +static void ice_dpll_pin_notify_work (struct work_struct *work) +{ +struct ice_dpll_pin_work *w =container_of (work, + struct ice_dpll_pin_work, + work); +struct ice_dpll_pin *pin, *parent = w->pin; +struct ice_pf *pf = parent->pf; +int ret; + +switch (w->action) { +case DPLL_PIN_CREATED : +if (!IS_ERR_OR_NULL (parent->pin)) { +/* We have already our pin registered */ + goto out; + } + +/* Grab reference on fwnode pin */ + parent->pin =fwnode_dpll_pin_find (parent->fwnode, + &parent->tracker); +if (IS_ERR_OR_NULL (parent->pin)) { +dev_err (ice_pf_to_dev (pf), +"Cannot get fwnode pin reference\n" ); + goto out; + } + +/* Register rclk pin */ + pin = &pf->dplls.rclk; + ret =dpll_pin_on_pin_register (parent->pin, pin->pin, + &ice_dpll_rclk_ops, pin); +if (ret) { +dev_err (ice_pf_to_dev (pf), +"Failed to register pin: %pe\n" ,ERR_PTR (ret)); +dpll_pin_put (parent->pin, &parent->tracker); + parent->pin =NULL ; + goto out; + } +break ; +case DPLL_PIN_DELETED : +if (IS_ERR_OR_NULL (parent->pin)) { +/* We have already our pin unregistered */ + goto out; + } + +/* Register rclk pin */ + pin = &pf->dplls.rclk; +dpll_pin_on_pin_unregister (parent->pin, pin->pin, + &ice_dpll_rclk_ops, pin); + +/* Drop fwnode pin reference */ +dpll_pin_put (parent->pin, &parent->tracker); + parent->pin =NULL ; +break ; +default : +break ; + } +out: +kfree (w); +} + +static int ice_dpll_pin_notify (struct notifier_block *nb,unsigned long action, +void *data) +{ + struct ice_dpll_pin *pin = container_of(nb, struct ice_dpll_pin, nb); +struct dpll_pin_notifier_info *info = data; +struct ice_dpll_pin_work *work; + +if (action !=DPLL_PIN_CREATED && action !=DPLL_PIN_DELETED ) +return NOTIFY_DONE ; + +/* Check if the reported pin is this one */ +if (pin->fwnode != info->fwnode) +return NOTIFY_DONE ;/* Not this pin */ + + work =kzalloc (sizeof (*work),GFP_KERNEL ); +if (!work) +return NOTIFY_DONE ; + +INIT_WORK (&work->work, ice_dpll_pin_notify_work); + work->action = action; + work->pin = pin; + +queue_work (pin->pf->dplls.wq, &work->work); + +return NOTIFY_OK ; +} +/** -* ice_dpll_init_rclk_pins - initialize recovered clock pin +* ice_dpll_init_pin_common - initialize pin * @pf: board private structure * @pin: pin to register * @start_idx: on which index shall allocation start in dpll subsystem * @ops: callback ops registered with the pins * -* Allocate resource for recovered clock pin in dpll subsystem. Register the -* pin with the parents it has in the info. Register pin with the pf's main vsi -* netdev. +* Allocate resource for given pin in dpll subsystem. Register the pin with +* the parents it has in the info. * * Return: * * 0 - success * * negative - registration failure reason */ static int -ice_dpll_init_rclk_pins (struct ice_pf *pf,struct ice_dpll_pin *pin, -int start_idx,const struct dpll_pin_ops *ops) +ice_dpll_init_pin_common (struct ice_pf *pf,struct ice_dpll_pin *pin, +int start_idx,const struct dpll_pin_ops *ops) { -struct ice_vsi *vsi =ice_get_main_vsi (pf); -struct dpll_pin *parent; +struct ice_dpll_pin *parent;int ret, i; -if (WARN_ON ((!vsi || !vsi->netdev))) -return -EINVAL ; - ret =ice_dpll_get_pins (pf, pin, start_idx,ICE_DPLL_RCLK_NUM_PER_PF , - pf->dplls.clock_id); + ret =ice_dpll_get_pins (pf, pin, start_idx,1 , pf->dplls.clock_id);if (ret)return ret; -for (i =0 ; i < pf->dplls.rclk.num_parents; i++) { - parent = pf->dplls.inputs[pf->dplls.rclk.parent_idx[i]].pin; -if (!parent) { - ret = -ENODEV ; - goto unregister_pins; + +for (i =0 ; i < pin->num_parents; i++) { + parent = &pf->dplls.inputs[pin->parent_idx[i]]; +if (IS_ERR_OR_NULL (parent->pin)) { +if (!ice_dpll_is_fwnode_pin (parent)) { + ret = -ENODEV ; + goto unregister_pins; + } + parent->pin =fwnode_dpll_pin_find (parent->fwnode, + &parent->tracker); +if (IS_ERR_OR_NULL (parent->pin)) { +dev_info (ice_pf_to_dev (pf), +"Mux pin not registered yet\n" ); +continue ; + } } - ret =dpll_pin_on_pin_register (parent, pf->dplls.rclk.pin, - ops, &pf->dplls.rclk); + ret =dpll_pin_on_pin_register (parent->pin, pin->pin, ops, pin);if (ret) goto unregister_pins; } -dpll_netdev_pin_set (vsi->netdev, pf->dplls.rclk.pin);return 0 ; unregister_pins:while (i) { - parent = pf->dplls.inputs[pf->dplls.rclk.parent_idx[--i]].pin; -dpll_pin_on_pin_unregister (parent, pf->dplls.rclk.pin, - &ice_dpll_rclk_ops, &pf->dplls.rclk); + parent = &pf->dplls.inputs[pin->parent_idx[--i]]; +if (IS_ERR_OR_NULL (parent->pin)) +continue ; +dpll_pin_on_pin_unregister (parent->pin, pin->pin, ops, pin); } -ice_dpll_release_pins (pin,ICE_DPLL_RCLK_NUM_PER_PF ); +ice_dpll_release_pins (pin,1 ); +return ret; } +/** +* ice_dpll_init_rclk_pin - initialize recovered clock pin +* @pf: board private structure +* @start_idx: on which index shall allocation start in dpll subsystem +* @ops: callback ops registered with the pins +* +* Allocate resource for recovered clock pin in dpll subsystem. Register the +* pin with the parents it has in the info. +* +* Return: +* * 0 - success +* * negative - registration failure reason +*/ +static int +ice_dpll_init_rclk_pin (struct ice_pf *pf,int start_idx, +const struct dpll_pin_ops *ops) +{ +struct ice_vsi *vsi =ice_get_main_vsi (pf); +int ret; + + ret =ice_dpll_init_pin_common (pf, &pf->dplls.rclk, start_idx, ops); +if (ret) +return ret; + +dpll_netdev_pin_set (vsi->netdev, pf->dplls.rclk.pin); + +return 0 ; +} + +static void +ice_dpll_deinit_fwnode_pin (struct ice_dpll_pin *pin) +{ +unregister_dpll_notifier (&pin->nb); +flush_workqueue (pin->pf->dplls.wq); +if (!IS_ERR_OR_NULL (pin->pin)) { +dpll_pin_put (pin->pin, &pin->tracker); + pin->pin =NULL ; + } +fwnode_handle_put (pin->fwnode); + pin->fwnode =NULL ; +} + +static void +ice_dpll_deinit_fwnode_pins (struct ice_pf *pf,struct ice_dpll_pin *pins, +int start_idx) +{ +int i; + +for (i =0 ; i < pf->dplls.rclk.num_parents; i++) +ice_dpll_deinit_fwnode_pin (&pins[start_idx + i]); +destroy_workqueue (pf->dplls.wq); +} +/** * ice_dpll_deinit_pins - deinitialize direct pins * @pf: board private structure
@@ -3113,6 +3413,8 @@ static void ice_dpll_deinit_pins(struct ice_pf *pf, bool cgu)struct ice_dpll *dp = &d->pps;ice_dpll_deinit_rclk_pin (pf); +if (pf->hw.mac_type ==ICE_MAC_GENERIC_3K_E825 ) +ice_dpll_deinit_fwnode_pins (pf, pf->dplls.inputs,0 );if (cgu) {ice_dpll_unregister_pins (dp->dpll, inputs, &ice_dpll_input_ops, num_inputs);
@@ -3127,12 +3429,12 @@ static void ice_dpll_deinit_pins(struct ice_pf *pf, bool cgu) &ice_dpll_output_ops, num_outputs);ice_dpll_release_pins (outputs, num_outputs);if (!pf->dplls.generic) { -ice_dpll_deinit_direct_pins (cgu, pf->dplls.ufl, +ice_dpll_deinit_direct_pins (pf, cgu, pf->dplls.ufl,ICE_DPLL_PIN_SW_NUM , &ice_dpll_pin_ufl_ops, pf->dplls.pps.dpll, pf->dplls.eec.dpll); - ice_dpll_deinit_direct_pins(cgu, pf->dplls.sma, + ice_dpll_deinit_direct_pins(pf, cgu, pf->dplls.sma, ICE_DPLL_PIN_SW_NUM, &ice_dpll_pin_sma_ops, pf->dplls.pps.dpll,
@@ -3141,6 +3443,120 @@ static void ice_dpll_deinit_pins(struct ice_pf *pf, bool cgu) } } +static int +ice_dpll_init_fwnode_pin (struct ice_dpll_pin *pin,const char *name) +{ +struct ice_pf *pf = pin->pf; +int ret; + + pin->fwnode =fwnode_dpll_pin_node_get (dev_fwnode (&pf->pdev->dev), + name); +if (IS_ERR (pin->fwnode)) { +dev_err (ice_pf_to_dev (pf), +"Failed to find %s firmware node: %pe\n" , name, + pin->fwnode); + pin->fwnode =NULL ; +return -ENODEV ; + } + +dev_dbg (ice_pf_to_dev (pf),"Found fwnode node for %s\n" , name); + + pin->pin =fwnode_dpll_pin_find (pin->fwnode, &pin->tracker); +if (IS_ERR_OR_NULL (pin->pin)) { +dev_info (ice_pf_to_dev (pf), +"DPLL pin for %pfwp not registered yet\n" , + pin->fwnode); + pin->pin =NULL ; + } + + pin->nb.notifier_call = ice_dpll_pin_notify; + ret =register_dpll_notifier (&pin->nb); +if (ret) { +dev_err (ice_pf_to_dev (pf), +"Failed to subscribe for DPLL notifications\n" ); + +if (!IS_ERR_OR_NULL (pin->pin)) { +dpll_pin_put (pin->pin, &pin->tracker); + pin->pin =NULL ; + } +fwnode_handle_put (pin->fwnode); + pin->fwnode =NULL ; + +return ret; + } + +return ret; +} + +/** +* ice_dpll_init_fwnode_pins - initialize pins from device tree +* @pf: board private structure +* @pins: pointer to pins array +* @start_idx: starting index for pins +* @count: number of pins to initialize +* +* Initialize input pins for E825 RCLK support. The parent pins (rclk0, rclk1) +* are expected to be defined in the device tree (ACPI). This function allocates +* them in the dpll subsystem and stores their indices for later registration +* with the rclk pin. +* +* Return: +* * 0 - success +* * negative - initialization failure reason +*/ +static int +ice_dpll_init_fwnode_pins (struct ice_pf *pf,struct ice_dpll_pin *pins, +int start_idx) +{ +char pin_name[8 ]; +int i, ret; + + pf->dplls.wq =create_singlethread_workqueue ("ice_dpll_wq" ); +if (!pf->dplls.wq) +return -ENOMEM ; + +for (i =0 ; i < pf->dplls.rclk.num_parents; i++) { + pins[start_idx + i].pf = pf; +snprintf (pin_name,sizeof (pin_name),"rclk%u" , i); + ret =ice_dpll_init_fwnode_pin (&pins[start_idx + i], pin_name); +if (ret) + goto error; + } + +return 0 ; +error: +while (i--) +ice_dpll_deinit_fwnode_pin (&pins[start_idx + i]); + +destroy_workqueue (pf->dplls.wq); + +return ret; +} + +/** +* ice_dpll_init_pins_e825 - init pins and register pins with a dplls +* @pf: board private structure +* @cgu: if cgu is present and controlled by this NIC +* +* Initialize directly connected pf's pins within pf's dplls in a Linux dpll +* subsystem. +* +* Return: +* * 0 - success +* * negative - initialization failure reason +*/ +static int ice_dpll_init_pins_e825 (struct ice_pf *pf) +{ +int ret; + + ret =ice_dpll_init_fwnode_pins (pf, pf->dplls.inputs,0 ); +if (ret) +return ret; + +return ice_dpll_init_rclk_pin (pf,DPLL_PIN_IDX_UNSPEC , + &ice_dpll_rclk_ops); +} +/** * ice_dpll_init_pins - init pins and register pins with a dplls * @pf: board private structure
@@ -3155,21 +3571,24 @@ static void ice_dpll_deinit_pins(struct ice_pf *pf, bool cgu)*/ static int ice_dpll_init_pins (struct ice_pf *pf,bool cgu) { +const struct dpll_pin_ops *output_ops; +const struct dpll_pin_ops *input_ops;int ret, count; + input_ops = &ice_dpll_input_ops; + output_ops = &ice_dpll_output_ops; + ret =ice_dpll_init_direct_pins (pf, cgu, pf->dplls.inputs,0 , - pf->dplls.num_inputs, - &ice_dpll_input_ops, - pf->dplls.eec.dpll, pf->dplls.pps.dpll); + pf->dplls.num_inputs, input_ops, + pf->dplls.eec.dpll, + pf->dplls.pps.dpll);if (ret)return ret; count = pf->dplls.num_inputs;if (cgu) { ret =ice_dpll_init_direct_pins (pf, cgu, pf->dplls.outputs, - count, - pf->dplls.num_outputs, - &ice_dpll_output_ops, - pf->dplls.eec.dpll, + count, pf->dplls.num_outputs, + output_ops, pf->dplls.eec.dpll, pf->dplls.pps.dpll);if (ret) goto deinit_inputs;
@@ -3205,30 +3624,30 @@ static int ice_dpll_init_pins(struct ice_pf *pf, bool cgu) }else { count += pf->dplls.num_outputs +2 *ICE_DPLL_PIN_SW_NUM ; } - ret =ice_dpll_init_rclk_pins (pf, &pf->dplls.rclk, count + pf->hw.pf_id, - &ice_dpll_rclk_ops); + + ret =ice_dpll_init_rclk_pin (pf, count + pf->ptp.port.port_num, + &ice_dpll_rclk_ops);if (ret) goto deinit_ufl;return 0 ; deinit_ufl: -ice_dpll_deinit_direct_pins (cgu, pf->dplls.ufl, -ICE_DPLL_PIN_SW_NUM , - &ice_dpll_pin_ufl_ops, - pf->dplls.pps.dpll, pf->dplls.eec.dpll); +ice_dpll_deinit_direct_pins (pf, cgu, pf->dplls.ufl,ICE_DPLL_PIN_SW_NUM , + &ice_dpll_pin_ufl_ops, pf->dplls.pps.dpll, + pf->dplls.eec.dpll); deinit_sma: -ice_dpll_deinit_direct_pins (cgu, pf->dplls.sma, -ICE_DPLL_PIN_SW_NUM , - &ice_dpll_pin_sma_ops, - pf->dplls.pps.dpll, pf->dplls.eec.dpll); +ice_dpll_deinit_direct_pins (pf, cgu, pf->dplls.sma,ICE_DPLL_PIN_SW_NUM , + &ice_dpll_pin_sma_ops, pf->dplls.pps.dpll, + pf->dplls.eec.dpll); deinit_outputs: -ice_dpll_deinit_direct_pins (cgu, pf->dplls.outputs, +ice_dpll_deinit_direct_pins (pf, cgu, pf->dplls.outputs, pf->dplls.num_outputs, - &ice_dpll_output_ops, pf->dplls.pps.dpll, + output_ops, pf->dplls.pps.dpll, pf->dplls.eec.dpll); deinit_inputs: -ice_dpll_deinit_direct_pins (cgu, pf->dplls.inputs, pf->dplls.num_inputs, - &ice_dpll_input_ops, pf->dplls.pps.dpll, +ice_dpll_deinit_direct_pins (pf, cgu, pf->dplls.inputs, + pf->dplls.num_inputs, + input_ops, pf->dplls.pps.dpll, pf->dplls.eec.dpll);return ret; }
@@ -3239,8 +3658,8 @@ static int ice_dpll_init_pins(struct ice_pf *pf, bool cgu)* @d: pointer to ice_dpll * @cgu: if cgu is present and controlled by this NIC * -* If cgu is owned unregister the dpll from dpll subsystem. -* Release resources of dpll device from dpll subsystem. +* If cgu is owned, unregister the DPL from DPLL subsystem. +* Release resources of DPLL device from DPLL subsystem. */ static void ice_dpll_deinit_dpll (struct ice_pf *pf,struct ice_dpll *d,bool cgu)
@@ -3257,8 +3676,8 @@ ice_dpll_deinit_dpll(struct ice_pf *pf, struct ice_dpll *d, bool cgu)* @cgu: if cgu is present and controlled by this NIC * @type: type of dpll being initialized * -* Allocate dpll instance for this board in dpll subsystem, if cgu is controlled -* by this NIC, register dpll with the callback ops. +* Allocate DPLL instance for this board in dpll subsystem, if cgu is controlled +* by this NIC, register DPLL with the callback ops. * * Return: * * 0 - success
@@ -3289,6 +3708,7 @@ ice_dpll_init_dpll(struct ice_pf *pf, struct ice_dpll *d, bool cgu, ret =dpll_device_register (d->dpll, type, ops, d);if (ret) {dpll_device_put (d->dpll, &d->tracker); + d->dpll =NULL ;return ret; } d->ops = ops;
@@ -3506,6 +3926,26 @@ ice_dpll_init_info_direct_pins(struct ice_pf *pf,return ret; } +/** +* ice_dpll_init_info_pin_on_pin_e825c - initializes rclk pin information +* @pf: board private structure +* +* Init information for rclk pin, cache them in pf->dplls.rclk. +* +* Return: +* * 0 - success +*/ +static int ice_dpll_init_info_pin_on_pin_e825c (struct ice_pf *pf) +{ +struct ice_dpll_pin *rclk_pin = &pf->dplls.rclk; + + rclk_pin->prop.type =DPLL_PIN_TYPE_SYNCE_ETH_PORT ; + rclk_pin->prop.capabilities |=DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE ; + rclk_pin->pf = pf; + +return 0 ; +} +/** * ice_dpll_init_info_rclk_pin - initializes rclk pin information * @pf: board private structure
@@ -3632,7 +4072,10 @@ ice_dpll_init_pins_info(struct ice_pf *pf, enum ice_dpll_pin_type pin_type)case ICE_DPLL_PIN_TYPE_OUTPUT :return ice_dpll_init_info_direct_pins (pf, pin_type);case ICE_DPLL_PIN_TYPE_RCLK_INPUT : -return ice_dpll_init_info_rclk_pin (pf); +if (pf->hw.mac_type ==ICE_MAC_GENERIC_3K_E825 ) +return ice_dpll_init_info_pin_on_pin_e825c (pf); +else +return ice_dpll_init_info_rclk_pin (pf);case ICE_DPLL_PIN_TYPE_SOFTWARE :return ice_dpll_init_info_sw_pins (pf);default :
@@ -3654,6 +4097,50 @@ static void ice_dpll_deinit_info(struct ice_pf *pf)kfree (pf->dplls.pps.input_prio); } +/** +* ice_dpll_init_info_e825c - prepare pf's dpll information structure for e825c +* device +* @pf: board private structure +* +* Acquire (from HW) and set basic DPLL information (on pf->dplls struct). +* +* Return: +* * 0 - success +* * negative - init failure reason +*/ +static int ice_dpll_init_info_e825c (struct ice_pf *pf) +{ +struct ice_dplls *d = &pf->dplls; +int ret =0 ; +int i; + + d->clock_id =ice_generate_clock_id (pf); + d->num_inputs =ICE_SYNCE_CLK_NUM ; + + d->inputs =kcalloc (d->num_inputs,sizeof (*d->inputs),GFP_KERNEL ); +if (!d->inputs) +return -ENOMEM ; + + ret =ice_get_cgu_rclk_pin_info (&pf->hw, &d->base_rclk_idx, + &pf->dplls.rclk.num_parents); +if (ret) + goto deinit_info; + +for (i =0 ; i < pf->dplls.rclk.num_parents; i++) + pf->dplls.rclk.parent_idx[i] = d->base_rclk_idx + i; + + ret =ice_dpll_init_pins_info (pf,ICE_DPLL_PIN_TYPE_RCLK_INPUT ); +if (ret) + goto deinit_info; +dev_dbg (ice_pf_to_dev (pf), +"%s - success, inputs: %u, outputs: %u, rclk-parents: %u\n" , + __func__, d->num_inputs, d->num_outputs, d->rclk.num_parents); +return 0 ; +deinit_info: +ice_dpll_deinit_info (pf); +return ret; +} +/** * ice_dpll_init_info - prepare pf's dpll information structure * @pf: board private structure
@@ -3773,14 +4260,16 @@ void ice_dpll_deinit(struct ice_pf *pf)ice_dpll_deinit_worker (pf);ice_dpll_deinit_pins (pf, cgu); -ice_dpll_deinit_dpll (pf, &pf->dplls.pps, cgu); -ice_dpll_deinit_dpll (pf, &pf->dplls.eec, cgu); +if (!IS_ERR_OR_NULL (pf->dplls.pps.dpll)) +ice_dpll_deinit_dpll (pf, &pf->dplls.pps, cgu); +if (!IS_ERR_OR_NULL (pf->dplls.eec.dpll)) +ice_dpll_deinit_dpll (pf, &pf->dplls.eec, cgu);ice_dpll_deinit_info (pf);mutex_destroy (&pf->dplls.lock); }/** -* ice_dpll_init - initialize support for dpll subsystem +* ice_dpll_init_e825 - initialize support for dpll subsystem * @pf: board private structure * * Set up the device dplls, register them and pins connected within Linux dpll
@@ -3789,7 +4278,41 @@ void ice_dpll_deinit(struct ice_pf *pf)* * Context: Initializes pf->dplls.lock mutex. */ -void ice_dpll_init (struct ice_pf *pf) +static void ice_dpll_init_e825 (struct ice_pf *pf) +{ +struct ice_dplls *d = &pf->dplls; +int err; + +mutex_init (&d->lock); + + err =ice_dpll_init_info_e825c (pf); +if (err) + goto err_exit; + err =ice_dpll_init_pins_e825 (pf); +if (err) + goto deinit_info; +set_bit (ICE_FLAG_DPLL , pf->flags); + +return ; + +deinit_info: +ice_dpll_deinit_info (pf); +err_exit: +mutex_destroy (&d->lock); +dev_warn (ice_pf_to_dev (pf),"DPLLs init failure err:%d\n" , err); +} + +/** +* ice_dpll_init_e810 - initialize support for dpll subsystem +* @pf: board private structure +* +* Set up the device dplls, register them and pins connected within Linux dpll +* subsystem. Allow userspace to obtain state of DPLL and handling of DPLL +* configuration requests. +* +* Context: Initializes pf->dplls.lock mutex. +*/ +static void ice_dpll_init_e810 (struct ice_pf *pf) {bool cgu =ice_is_feature_supported (pf,ICE_F_CGU );struct ice_dplls *d = &pf->dplls;
@@ -3829,3 +4352,15 @@ void ice_dpll_init(struct ice_pf *pf)mutex_destroy (&d->lock);dev_warn (ice_pf_to_dev (pf),"DPLLs init failure err:%d\n" , err); } + +void ice_dpll_init (struct ice_pf *pf) +{ +switch (pf->hw.mac_type) { +case ICE_MAC_GENERIC_3K_E825 : +ice_dpll_init_e825 (pf); +break ; +default : +ice_dpll_init_e810 (pf); +break ; + } +}
drivers/net/ethernet/intel/ice/ice_dpll.h +25 -0
@@ -20,6 +20,12 @@ enum ice_dpll_pin_sw { ICE_DPLL_PIN_SW_NUM }; +struct ice_dpll_pin_work { +struct work_struct work; +unsigned long action; +struct ice_dpll_pin *pin; +}; +/** ice_dpll_pin - store info about pins * @pin: dpll pin structure * @pf: pointer to pf, which has registered the dpll_pin
@@ -39,6 +45,8 @@ struct ice_dpll_pin {struct dpll_pin *pin;struct ice_pf *pf;dpll_tracker tracker; +struct fwnode_handle *fwnode; +struct notifier_block nb;u8 idx;u8 num_parents;u8 parent_idx[ICE_DPLL_RCLK_NUM_MAX ];
@@ -118,6 +126,7 @@ struct ice_dpll {struct ice_dplls {struct kthread_worker *kworker;struct kthread_delayed_work work; +struct workqueue_struct *wq;struct mutex lock;struct ice_dpll eec;struct ice_dpll pps;
@@ -147,3 +156,19 @@ static inline void ice_dpll_deinit(struct ice_pf *pf) { }#endif #endif + +#define ICE_CGU_R10 0x28 +#define ICE_CGU_R10_SYNCE_CLKO_SEL GENMASK(8, 5) +#define ICE_CGU_R10_SYNCE_CLKODIV_M1 GENMASK(13, 9) +#define ICE_CGU_R10_SYNCE_CLKODIV_LOAD BIT(14) +#define ICE_CGU_R10_SYNCE_DCK_RST BIT(15) +#define ICE_CGU_R10_SYNCE_ETHCLKO_SEL GENMASK(18, 16) +#define ICE_CGU_R10_SYNCE_ETHDIV_M1 GENMASK(23, 19) +#define ICE_CGU_R10_SYNCE_ETHDIV_LOAD BIT(24) +#define ICE_CGU_R10_SYNCE_DCK2_RST BIT(25) +#define ICE_CGU_R10_SYNCE_S_REF_CLK GENMASK(31, 27) + +#define ICE_CGU_R11 0x2C +#define ICE_CGU_R11_SYNCE_S_BYP_CLK GENMASK(6, 1) + +#define ICE_CGU_BYPASS_MUX_OFFSET_E825C 3
drivers/net/ethernet/intel/ice/ice_lib.c +3 -0
@@ -3946,6 +3946,9 @@ void ice_init_feature_support(struct ice_pf *pf)break ; } +if (pf->hw.mac_type ==ICE_MAC_GENERIC_3K_E825 ) +ice_set_feature_support (pf,ICE_F_PHY_RCLK ); +if (pf->hw.mac_type ==ICE_MAC_E830 ) {ice_set_feature_support (pf,ICE_F_MBX_LIMIT );ice_set_feature_support (pf,ICE_F_GCS );
drivers/net/ethernet/intel/ice/ice_ptp.c +29 -0
@@ -1341,6 +1341,35 @@ void ice_ptp_link_change(struct ice_pf *pf, bool linkup)if (pf->hw.reset_ongoing)return ; +if (hw->mac_type ==ICE_MAC_GENERIC_3K_E825 ) { +int pin, err; + +mutex_lock (&pf->dplls.lock); +for (pin =0 ; pin <ICE_SYNCE_CLK_NUM ; pin++) { +enum ice_synce_clk clk_pin; +bool active; +u8 port_num; + + port_num = ptp_port->port_num; + clk_pin = (enum ice_synce_clk )pin; + err =ice_tspll_bypass_mux_active_e825c (hw, + port_num, + &active, + clk_pin); +if (WARN_ON_ONCE (err)) { +mutex_unlock (&pf->dplls.lock); +return ; + } + + err =ice_tspll_cfg_synce_ethdiv_e825c (hw, clk_pin); +if (active &&WARN_ON_ONCE (err)) { +mutex_unlock (&pf->dplls.lock); +return ; + } + } +mutex_unlock (&pf->dplls.lock); + } +switch (hw->mac_type) {case ICE_MAC_E810 :case ICE_MAC_E830 :
drivers/net/ethernet/intel/ice/ice_ptp_hw.c +8 -1
@@ -5903,7 +5903,14 @@ int ice_get_cgu_rclk_pin_info(struct ice_hw *hw, u8 *base_idx, u8 *pin_num) *base_idx =SI_REF1P ; else ret = -ENODEV ; - +break ; +case ICE_DEV_ID_E825C_BACKPLANE : +case ICE_DEV_ID_E825C_QSFP : +case ICE_DEV_ID_E825C_SFP : +case ICE_DEV_ID_E825C_SGMII : + *pin_num =ICE_SYNCE_CLK_NUM ; + *base_idx =0 ; + ret =0 ;break ;default : ret = -ENODEV ;
drivers/net/ethernet/intel/ice/ice_tspll.c +217 -0
220 lines not on this page · raw message
drivers/net/ethernet/intel/ice/ice_tspll.h +12 -1
@@ -21,11 +21,22 @@ struct ice_tspll_params_e82x { u32 frac_n_div; }; +#define ICE_CGU_NET_REF_CLK0 0x0 +#define ICE_CGU_REF_CLK_BYP0 0x5 +#define ICE_CGU_REF_CLK_BYP0_DIV 0x0 +#define ICE_CGU_REF_CLK_BYP1 0x4 +#define ICE_CGU_REF_CLK_BYP1_DIV 0x1 +#define ICE_TSPLL_CK_REFCLKFREQ_E825 0x1F#define ICE_TSPLL_NDIVRATIO_E825 5#define ICE_TSPLL_FBDIV_INTGR_E825 256int ice_tspll_cfg_pps_out_e825c (struct ice_hw *hw,bool enable);int ice_tspll_init (struct ice_hw *hw); - +int ice_tspll_bypass_mux_active_e825c (struct ice_hw *hw,u8 port,bool *active, +enum ice_synce_clk output); +int ice_tspll_cfg_bypass_mux_e825c (struct ice_hw *hw,bool ena,u32 port_num, +enum ice_synce_clk output); +int ice_tspll_cfg_synce_ethdiv_e825c (struct ice_hw *hw, +enum ice_synce_clk output);#endif /* _ICE_TSPLL_H_ */
drivers/net/ethernet/intel/ice/ice_type.h +6 -0
@@ -349,6 +349,12 @@ enum ice_clk_src {NUM_ICE_CLK_SRC }; +enum ice_synce_clk { +ICE_SYNCE_CLK0 , +ICE_SYNCE_CLK1 , +ICE_SYNCE_CLK_NUM +}; +struct ice_ts_func_info {/* Function specific info */ enum ice_tspll_freq time_ref;
Signature · 1 line
2.52.0
RE: [Intel-wired-lan] [PATCH net-next 12/12] ice: dpll: Support E825-C SyncE and dynamic pin discovery
Quoted 81 lines
-----Original Message-----
From: Intel-wired-lan <[email protected]> On Behalf Of Ivan Vecera
Sent: Thursday, January 8, 2026 7:23 PM
To: [email protected]
Cc: Eric Dumazet <[email protected]>; Nguyen, Anthony L <[email protected]>; Rob Herring <[email protected]>; Leon Romanovsky <[email protected]>; Andrew Lunn <[email protected]>; [email protected]; Kitszel, Przemyslaw <[email protected]>; Kubalewski, Arkadiusz <[email protected]>; [email protected]; Jakub Kicinski <[email protected]>; Paolo Abeni <[email protected]>; [email protected]; Conor Dooley <[email protected]>; Jiri Pirko <[email protected]>; Richard Cochran <[email protected]>; Prathosh Satish <[email protected]>; Vadim Fedorenko <[email protected]>; Mark Bloch <[email protected]>; linux- [email protected]; Tariq Toukan <[email protected]>; Lobakin, Aleksander <[email protected]>; Jonathan Lemon <[email protected]>; Krzysztof Kozlowski <[email protected]>; Saeed Mahameed <[email protected]>; David S. Miller <[email protected]>
Subject: [Intel-wired-lan] [PATCH net-next 12/12] ice: dpll: Support E825-C SyncE and dynamic pin discoveryFrom: Arkadiusz Kubalewski <[email protected]>
Add DPLL support for the Intel E825-C Ethernet controller. Unlike previous generations (E810), the E825-C connects to the platform's DPLL subsystem via MUX pins defined in the system firmware (Device Tree/ACPI).
Implement the following mechanisms to support this architecture:
1. Dynamic Pin Discovery: Use the
fwnode_dpll_pin_find()helper to locate the parent MUX pins defined in the firmware.2. Asynchronous Registration: Since the platform DPLL driver may probe independently of the network driver, utilize the DPLL notifier
chain
(register_dpll_notifier). The driver listens forDPLL_PIN_CREATEDevents to detect when the parent MUX pins become available, then registers its own Recovered Clock (RCLK) pins as children of those parents.3. Hardware Configuration: Implement the specific register access logic
for E825-C CGU (Clock Generation Unit) registers (R10, R11). This includes configuring the bypass MUXes and clock dividers required
to
drive SyncE signals.4. Split Initialization: Refactor
ice_dpll_init()to separate the static initialization path of E810 from the dynamic, firmware-
driven
path required for E825-C.Co-developed-by Ivan Vecera <[email protected]>Signed-off-by Ivan Vecera <[email protected]>Co-developed-by Grzegorz Nitka <[email protected]>Signed-off-by Grzegorz Nitka <[email protected]>Signed-off-by Arkadiusz Kubalewski <[email protected]>--- drivers/net/ethernet/intel/ice/ice_dpll.c | 715 +++++++++++++++++-- - drivers/net/ethernet/intel/ice/ice_dpll.h | 25 + drivers/net/ethernet/intel/ice/ice_lib.c | 3 + drivers/net/ethernet/intel/ice/ice_ptp.c | 29 + drivers/net/ethernet/intel/ice/ice_ptp_hw.c | 9 +- drivers/net/ethernet/intel/ice/ice_tspll.c | 217 ++++++ drivers/net/ethernet/intel/ice/ice_tspll.h | 13 +- drivers/net/ethernet/intel/ice/ice_type.h | 6 + 8 files changed, 925 insertions(+), 92 deletions(-)drivers/net/ethernet/intel/ice/ice_dpll.c +0
-0@@ -5,6 +5,7 @@
...
Quoted 5 lines
+/**
+ *ice_dpll_init_fwnode_pins- initialize pins from device tree
+ * @pf: board private structure
+ * @pins: pointer to pins array
+ * @start_idx: starting index for pins
Quoted 8 lines
+ * @count: number of pins to initialize
+ *
+ * Initialize input pins for E825 RCLK support. The parent pins (rclk0,
+rclk1)
+ * are expected to be defined in the device tree (ACPI). This function
+allocates
Device Tree and ACPI are different firmware interfaces, aren't they? Writing "device tree (ACPI)" can mislead readers about where the fwnode-backed discovery is expected to come from.
The code looks good for me.
Quoted 3 lines
+ * them in the dpll subsystem and stores their indices for later +registration
+ * with the rclk pin.
...
Quoted 2 lines
--
2.52.0
Ivan Vecera
maintainerRe: [Intel-wired-lan] [PATCH net-next 12/12] ice: dpll: Support E825-C SyncE and dynamic pin discovery
Quoted 84 lines · Aleksandr
Quoted 81 lines
-----Original Message-----
From: Intel-wired-lan <[email protected]> On Behalf Of Ivan Vecera
Sent: Thursday, January 8, 2026 7:23 PM
To: [email protected]
Cc: Eric Dumazet <[email protected]>; Nguyen, Anthony L <[email protected]>; Rob Herring <[email protected]>; Leon Romanovsky <[email protected]>; Andrew Lunn <[email protected]>; [email protected]; Kitszel, Przemyslaw <[email protected]>; Kubalewski, Arkadiusz <[email protected]>; [email protected]; Jakub Kicinski <[email protected]>; Paolo Abeni <[email protected]>; [email protected]; Conor Dooley <[email protected]>; Jiri Pirko <[email protected]>; Richard Cochran <[email protected]>; Prathosh Satish <[email protected]>; Vadim Fedorenko <[email protected]>; Mark Bloch <[email protected]>; linux- [email protected]; Tariq Toukan <[email protected]>; Lobakin, Aleksander <[email protected]>; Jonathan Lemon <[email protected]>; Krzysztof Kozlowski <[email protected]>; Saeed Mahameed <[email protected]>; David S. Miller <[email protected]>
Subject: [Intel-wired-lan] [PATCH net-next 12/12] ice: dpll: Support E825-C SyncE and dynamic pin discoveryFrom: Arkadiusz Kubalewski <[email protected]>
Add DPLL support for the Intel E825-C Ethernet controller. Unlike previous generations (E810), the E825-C connects to the platform's DPLL subsystem via MUX pins defined in the system firmware (Device Tree/ACPI).
Implement the following mechanisms to support this architecture:
1. Dynamic Pin Discovery: Use the
fwnode_dpll_pin_find()helper to locate the parent MUX pins defined in the firmware.2. Asynchronous Registration: Since the platform DPLL driver may probe independently of the network driver, utilize the DPLL notifier
chain
(register_dpll_notifier). The driver listens forDPLL_PIN_CREATEDevents to detect when the parent MUX pins become available, then registers its own Recovered Clock (RCLK) pins as children of those parents.3. Hardware Configuration: Implement the specific register access logic
for E825-C CGU (Clock Generation Unit) registers (R10, R11). This includes configuring the bypass MUXes and clock dividers required
to
drive SyncE signals.4. Split Initialization: Refactor
ice_dpll_init()to separate the static initialization path of E810 from the dynamic, firmware-
driven
path required for E825-C.Co-developed-by Ivan Vecera <[email protected]>Signed-off-by Ivan Vecera <[email protected]>Co-developed-by Grzegorz Nitka <[email protected]>Signed-off-by Grzegorz Nitka <[email protected]>Signed-off-by Arkadiusz Kubalewski <[email protected]>--- drivers/net/ethernet/intel/ice/ice_dpll.c | 715 +++++++++++++++++-- - drivers/net/ethernet/intel/ice/ice_dpll.h | 25 + drivers/net/ethernet/intel/ice/ice_lib.c | 3 + drivers/net/ethernet/intel/ice/ice_ptp.c | 29 + drivers/net/ethernet/intel/ice/ice_ptp_hw.c | 9 +- drivers/net/ethernet/intel/ice/ice_tspll.c | 217 ++++++ drivers/net/ethernet/intel/ice/ice_tspll.h | 13 +- drivers/net/ethernet/intel/ice/ice_type.h | 6 + 8 files changed, 925 insertions(+), 92 deletions(-)drivers/net/ethernet/intel/ice/ice_dpll.c +0
-0@@ -5,6 +5,7 @@...
Quoted 16 lines
Quoted 5 lines
+/**
+ *ice_dpll_init_fwnode_pins- initialize pins from device tree
+ * @pf: board private structure
+ * @pins: pointer to pins array
+ * @start_idx: starting index for pinsQuoted 8 lines
+ * @count: number of pins to initialize
+ *
+ * Initialize input pins for E825 RCLK support. The parent pins (rclk0,
+rclk1)
+ * are expected to be defined in the device tree (ACPI). This function
+allocatesDevice Tree and ACPI are different firmware interfaces, aren't they? Writing "device tree (ACPI)" can mislead readers about where the fwnode-backed discovery is expected to come from.
Will fix.
Quoted 2 lines
The code looks good for me.
Reviewed-by Aleksandr Loktionov <[email protected]>
Thank you, Alex.
Ivan