# Copyright (c) 2018 STMicroelectronics
# SPDX-License-Identifier: Apache-2.0

properties:
    drdy-gpios:
      type: phandle-array
      required: false
      description: |
        DRDY pin

        This pin defaults to active high when produced by the sensor.
        The property value should ensure the flags properly describe
        the signal that is presented to the driver.

    drdy-int:
      type: int
      required: false
      default: 1
      enum:
        - 1 # drdy is generated from INT1
        - 2 # drdy is generated from INT2
      description: Select DRDY pin number (1 or 2).

        This number represents which of the two interrupt pins
        (INT1 or INT2) the drdy line is attached to. This property is not
        mandatory and if not present it defaults to 1 which is the
        configuration at power-up.

    range:
      type: int
      required: false
      default: 2
      description: Range in g. Default is power-up configuration.
      enum:
        - 16 # 16g (1.952 mg/LSB)
        -  8 #  8g (0.976 mg/LSB)
        -  4 #  4g (0.488 mg/LSB)
        -  2 #  2g (0.244 mg/LSB)

    power-mode:
      type: int
      required: false
      default: 0
      description: Specify the sensor power mode. Default is power-up configuration.
      enum:
        - 0 # Low Power M1
        - 1 # Low Power M2
        - 2 # Low Power M3
        - 3 # Low Power M4
        - 4 # High Performance

    # tap and tap-tap configuration section
    # All default values are selected to match the power-up values.
    # tap and tap-tap events can be generated on INT1 only.

    tap-mode:
      type: int
      required: false
      default: 0
      description: Tap mode. Default is power-up configuration.
      enum:
        - 0 # Only Single Tap
        - 1 # Single and Double Tap

    tap-threshold:
      type: array
      required: false
      default: [0, 0, 0]
      description: |
        Tap X/Y/Z axes threshold. Default is power-up configuration.
        (X/Y/Z values range from 0x00 to 0x1F)

        Thresholds to start the tap-event detection procedure on the X/Y/Z axes.
        Threshold values for each axis are unsigned 5-bit corresponding
        to a 2g acceleration full-scale range. A threshold value equal to zero
        corresponds to disable the tap detection on that axis.

        For example, if you want to set the threshold for X to 12, for Z to 14
        and want to disable tap detection on Y, you should specify in Device Tree

            tap-threshold = <12>, <0>, <14>

        which is equivalent to X = 12 * 2g/32 = 750mg and Z = 14 * 2g/32 = 875mg.

    tap-shock:
      type: int
      required: false
      default: 0x0
      description: |
        Tap shock value. Default is power-up configuration.
        (values range from 0x0 to 0x3)
        This register represents the maximum time of an over-threshold signal
        detection to be recognized as a tap event. Where 0 equals 4*1/ODR and
        1LSB = 8*1/ODR.

    tap-latency:
      type: int
      required: false
      default: 0x0
      description: |
        Tap latency. Default is power-up configuration.
        (values range from 0x0 to 0xF)
        When double-tap recognition is enabled, this register expresses the
        maximum time between two successive detected taps to determine a
        double-tap event. Where 0 equals 16*1/ODR and 1LSB = 32*1/ODR.

    tap-quiet:
      type: int
      required: false
      default: 0x0
      description: |
        Expected quiet time after a tap detection. Default is power-up configuration.
        (values range from 0x0 to 0x3)
        This register represents the time after the first detected tap in which
        there must not be any overthreshold event. Where 0 equals 2*1/ODR
        and 1LSB = 4*1/ODR.
