# SPDX-License-Identifier: GPL-2.0
%YAML 1.2
---
$id: http://devicetree.org/schemas/power/supply/maxim,max17040.yaml#
$schema: http://devicetree.org/meta-schemas/core.yaml#

title: Maxim 17040 fuel gauge series

maintainers:
  - Sebastian Reichel <sre@kernel.org>

allOf:
  - $ref: power-supply.yaml#

properties:
  compatible:
    enum:
      - maxim,max17040
      - maxim,max17041
      - maxim,max17043
      - maxim,max17044
      - maxim,max17048
      - maxim,max17049
      - maxim,max17058
      - maxim,max17059
      - maxim,max77836-battery

  reg:
    maxItems: 1

  maxim,alert-low-soc-level:
    $ref: /schemas/types.yaml#/definitions/uint32
    minimum: 1
    maximum: 32
    description: |
      The alert threshold that sets the state of charge level (%) where an interrupt is generated.
      If skipped the power up default value of 4 (%) will be used.

  maxim,double-soc:
    type: boolean
    description: |
      Certain devices return double the capacity.
      Specify this to divide the reported value in 2 and thus normalize it.
      SoC == State of Charge == Capacity.

  maxim,rcomp:
    $ref: /schemas/types.yaml#/definitions/uint8-array
    minItems: 1
    maxItems: 2
    description: |
      A value to compensate readings for various battery chemistries and operating temperatures.
      max17040,41 have 2 byte rcomp, default to 0x97 0x00.
      All other devices have one byte rcomp, default to 0x97.

  interrupts:
    maxItems: 1

  io-channels:
    items:
      - description: battery temperature

  io-channel-names:
    items:
      - const: temp

  wakeup-source:
    type: boolean
    description: |
      Use this property to use alert low SoC level interrupt as wake up source.

required:
  - compatible
  - reg

unevaluatedProperties: false

examples:
  - |
    i2c {
      #address-cells = <1>;
      #size-cells = <0>;

      battery@36 {
        compatible = "maxim,max17048";
        reg = <0x36>;
        maxim,rcomp = /bits/ 8 <0x56>;
        maxim,alert-low-soc-level = <10>;
        maxim,double-soc;
      };
    };
  - |
    #include <dt-bindings/interrupt-controller/irq.h>
    i2c {
      #address-cells = <1>;
      #size-cells = <0>;

      battery@36 {
        compatible = "maxim,max77836-battery";
        reg = <0x36>;
        maxim,alert-low-soc-level = <10>;
        interrupt-parent = <&gpio7>;
        interrupts = <2 IRQ_TYPE_LEVEL_LOW>;
        wakeup-source;
      };
    };
  - |
    #include <dt-bindings/interrupt-controller/irq.h>
    i2c {
      #address-cells = <1>;
      #size-cells = <0>;

      fuel-gauge@36 {
        compatible = "maxim,max17043";
        reg = <0x36>;

        interrupt-parent = <&gpio>;
        interrupts = <144 IRQ_TYPE_EDGE_FALLING>;

        monitored-battery = <&battery>;
        power-supplies = <&charger>;

        io-channels = <&adc 8>;
        io-channel-names = "temp";

        maxim,alert-low-soc-level = <10>;
        wakeup-source;
      };
    };
