From patchwork Mon Aug 16 22:19:55 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Caleb Connolly X-Patchwork-Id: 497724 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER, INCLUDES_PATCH, MAILING_LIST_MULTI, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 78B30C4320A for ; Mon, 16 Aug 2021 22:20:09 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 5B8BF600CD for ; Mon, 16 Aug 2021 22:20:09 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232508AbhHPWUk (ORCPT ); Mon, 16 Aug 2021 18:20:40 -0400 Received: from mail-4322.protonmail.ch ([185.70.43.22]:42823 "EHLO mail-4322.protonmail.ch" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232463AbhHPWUk (ORCPT ); Mon, 16 Aug 2021 18:20:40 -0400 Date: Mon, 16 Aug 2021 22:19:55 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=connolly.tech; s=protonmail; t=1629152405; bh=rCtwdyQ4TU4smQaew58PJe2JjxbPI0PPi/WFS8+bOIc=; h=Date:To:From:Cc:Reply-To:Subject:In-Reply-To:References:From; b=ckvxcX6viMLgOgvmFbL3jWFufqvQdfp7mha6+6DTpt48vh2cgJrsTPrrciKU2830V oO5JbHs98ytwkDnBf7nh9HvmDrvYWUazgJBOKZfqDCl40emknY0WYI8BmnCzauGYVE v9ZB6vIvvqs1zaMSrKZp4h2oOdPxkofNnhsQfChA= To: Caleb Connolly From: Caleb Connolly Cc: Andy Gross , Bjorn Andersson , Dmitry Torokhov , Rob Herring , linux-arm-msm@vger.kernel.org, linux-input@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, ~postmarketos/upstreaming@lists.sr.ht, Jami Kettunen , Joel Selvaraj Reply-To: Caleb Connolly Subject: [PATCH v3 1/6] dt-bindings: input: add Qualcomm SPMI haptics driver Message-ID: <20210816221931.1998187-2-caleb@connolly.tech> In-Reply-To: <20210816221931.1998187-1-caleb@connolly.tech> References: <20210816221931.1998187-1-caleb@connolly.tech> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org Add bindings for qcom PMIC SPMI haptics driver. Signed-off-by: Caleb Connolly --- .../bindings/input/qcom,spmi-haptics.yaml | 128 ++++++++++++++++++ include/dt-bindings/input/qcom,spmi-haptics.h | 32 +++++ 2 files changed, 160 insertions(+) create mode 100644 Documentation/devicetree/bindings/input/qcom,spmi-haptics.yaml create mode 100644 include/dt-bindings/input/qcom,spmi-haptics.h -- 2.32.0 diff --git a/Documentation/devicetree/bindings/input/qcom,spmi-haptics.yaml b/Documentation/devicetree/bindings/input/qcom,spmi-haptics.yaml new file mode 100644 index 000000000000..21e1fba98ae1 --- /dev/null +++ b/Documentation/devicetree/bindings/input/qcom,spmi-haptics.yaml @@ -0,0 +1,128 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +# Copyright 2020 Unisoc Inc. +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/input/qcom,spmi-haptics.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Qualcomm Technologies Inc PMI8998 spmi haptics + +maintainers: + - Caleb Connolly + +description: | + Qualcomm SPMI haptics is a peripheral on some QTI PMICs. It supports linear resonant + actuators and eccentric rotating mass type haptics commonly found in mobile devices. + It supports multiple sources of wave data such as an internal buffer, direct play + (from kernel or userspace) as well as an audio mode. + +properties: + compatible: + items: + - enum: + - qcom,pmi8998-haptics + - qcom,pmi8996-haptics + - qcom,pmi8941-haptics + - const: qcom,spmi-haptics + + reg: + maxItems: 1 + + interrupts: + items: + - description: short circuit interrupt + - description: play interrupt + + interrupt-names: + items: + - const: short + - const: play + + qcom,actuator-type: + description: | + The type of actuator attached to the hardware. + Allowed values are, + 0 - HAP_TYPE_LRA + 1 - HAP_TYPE_ERM + $ref: /schemas/types.yaml#/definitions/uint32 + enum: [ 0, 1 ] + default: 0 + + qcom,wave-shape: + description: | + Selects the wave shape to use. + Allowed values are, + 0 - HAP_WAVE_SINE + 1 - HAP_WAVE_SQUARE + $ref: /schemas/types.yaml#/definitions/uint32 + enum: [ 0, 1 ] + default: 0 + + qcom,play-mode: + description: | + Selects the play mode to use. + Allowed values are, + 0 - HAP_PLAY_DIRECT + 1 - HAP_PLAY_BUFFER + 2 - HAP_PLAY_AUDIO + 3 - HAP_PLAY_PWM + $ref: /schemas/types.yaml#/definitions/uint32 + enum: [ 0, 1, 2, 3 ] + default: 2 + + qcom,wave-play-rate-us: + description: | + Wave play rate in microseconds, 1/f where f + is the resonant frequency of the actuator. + minimum: 0 + maximum: 20475 + + qcom,brake-pattern: + minItems: 4 + maxItems: 4 + description: | + The brake pattern is an array of amplitudes + used to brake the haptics. Allowed values are, + 0 - 0V + 1 - Vmax/4 + 2 - Vmax/2 + 3 - Vmax + $ref: /schemas/types.yaml#/definitions/uint32-array + default: [0x3, 0x3, 0x2, 0x1] + items: + enum: [ 0, 1, 2, 3 ] + +required: + - compatible + - reg + - interrupts + - qcom,wave-play-rate-us + +additionalProperties: false + +examples: + - | + #include + #include + #include + + pmic@3 { + compatible = "qcom,pmi8998", "qcom,spmi-pmic"; + reg = <0x3 SPMI_USID>; + #address-cells = <1>; + #size-cells = <0>; + + pmi8998_haptics: haptics@c000 { + compatible = "qcom,pmi8998-haptics", "qcom,spmi-haptics"; + reg = <0xc000>; + + interrupts = <0x3 0xc0 0x0 IRQ_TYPE_EDGE_BOTH>, + <0x3 0xc0 0x1 IRQ_TYPE_EDGE_BOTH>; + interrupt-names = "short", "play"; + + qcom,wave-shape = ; + qcom,wave-play-rate-us = <4255>; + qcom,play-mode = ; + qcom,brake-pattern = <0x3 0x3 0x2 0x1>; + }; + }; diff --git a/include/dt-bindings/input/qcom,spmi-haptics.h b/include/dt-bindings/input/qcom,spmi-haptics.h new file mode 100644 index 000000000000..b3b9478b3217 --- /dev/null +++ b/include/dt-bindings/input/qcom,spmi-haptics.h @@ -0,0 +1,32 @@ +/* SPDX-License-Identifier: (GPL-2.0+ OR BSD-2-Clause) */ +/* + * This header provides constants for QCOM SPMI haptics hardware configuration. + */ + +#ifndef _DT_BINDINGS_QCOM_PMIC_SPMI_HAPTICS_ +#define _DT_BINDINGS_QCOM_PMIC_SPMI_HAPTICS_ + +// Actuator types +#define HAP_TYPE_LRA 0 +#define HAP_TYPE_ERM 1 + +// LRA Wave type +#define HAP_WAVE_SINE 0 +#define HAP_WAVE_SQUARE 1 + +// Play modes +#define HAP_PLAY_DIRECT 0 +#define HAP_PLAY_BUFFER 1 +#define HAP_PLAY_AUDIO 2 +#define HAP_PLAY_PWM 3 + +#define HAP_PLAY_MAX HAP_PLAY_PWM + +// Auto resonance type +#define HAP_AUTO_RES_NONE 0 +#define HAP_AUTO_RES_ZXD 1 +#define HAP_AUTO_RES_QWD 2 +#define HAP_AUTO_RES_MAX_QWD 3 +#define HAP_AUTO_RES_ZXD_EOP 4 + +#endif /* _DT_BINDINGS_QCOM_PMIC_SPMI_HAPTICS_ */ From patchwork Mon Aug 16 22:20:00 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Caleb Connolly X-Patchwork-Id: 497670 Delivered-To: patch@linaro.org Received: by 2002:a02:6f15:0:0:0:0:0 with SMTP id x21csp507810jab; Mon, 16 Aug 2021 15:20:12 -0700 (PDT) X-Google-Smtp-Source: ABdhPJykbzQz6mz4lEbyCbBxmMUWrvjzkJr+IKpaPlYtoDktMvTzWsaf1UWhFTjunV7yWp2KrU9X X-Received: by 2002:a02:970d:: with SMTP id x13mr80062jai.57.1629152412507; Mon, 16 Aug 2021 15:20:12 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1629152412; cv=none; d=google.com; s=arc-20160816; b=LlHVjK6xA21Xc6DR7LUpzdPwVGHnjO+qDY8H/i6hehr0nlX4Xc6A8VuAi6i4FelP/W 2F6nJ5g8x/FZqwtOD1pQeMFHftFpHlpxeLtTa8qFVDzSnEFohPfeDxwM3M709P2Ntieg bG2Ap4j2fIOQsSX+Ifwk2k5TetFPJiaUbh5OBWIUQlha7qDgBXYrC/Xxb9cpTCFpyQSx Kh4YgbwdDYPpl59iFA7cLLkwHogWibKX3SLxW4ovlkgB/ZeD9C6odU49MLz5ocxe/A1w stwOidi9tli+IjXfcNv3ZF4X02dp7k3B/HZEGAS09B5fGw1UCRKYjbrUDAiw0OLpZ3nV BcNg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:subject:reply-to:cc:from:to :dkim-signature:date; bh=fU7cwPzcfzymF98KCOg4r+/PTg1bljYUdSJQF3ohE/Y=; b=0/iafXln8Q2wPStfaw2vNilCQDkGtYpMBA74g4Kc/KCvJ9TYH5lq8r+/2K5AJUTH9X P5jFDtEZdb/FC8gYjuB0rn1VaGXN68hSONwG8bxtWA5TIikn8dmz7WFwSl4lXRssCtIy E+UpG9hM+VoJhx5hs4B+prGlYcBAr0uzoNKL936ZwrjTW6qekLASlXvE5SBGAN8A3WJW kX9rtHB7tt2BEKQS+6L5uXsRnKSuLQ6tMb4+W5EPHD4MHIMAgv8jR9KvgT9ALXRZ3ldL IK6JbLFiCODOjlqQIBvATI6OJwmqbFRPKPiNMFDb6SnsgeRBcDNnmMsdTCqTHLc0Io8b M68Q== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@connolly.tech header.s=protonmail header.b=jPEOEiVm; spf=pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=devicetree-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=connolly.tech Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id y17si486548iov.62.2021.08.16.15.20.12; Mon, 16 Aug 2021 15:20:12 -0700 (PDT) Received-SPF: pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@connolly.tech header.s=protonmail header.b=jPEOEiVm; spf=pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=devicetree-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=connolly.tech Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233918AbhHPWUn (ORCPT + 7 others); Mon, 16 Aug 2021 18:20:43 -0400 Received: from mail-0201.mail-europe.com ([51.77.79.158]:49816 "EHLO mail-0201.mail-europe.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232335AbhHPWUm (ORCPT ); Mon, 16 Aug 2021 18:20:42 -0400 Date: Mon, 16 Aug 2021 22:20:00 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=connolly.tech; s=protonmail; t=1629152405; bh=fU7cwPzcfzymF98KCOg4r+/PTg1bljYUdSJQF3ohE/Y=; h=Date:To:From:Cc:Reply-To:Subject:In-Reply-To:References:From; b=jPEOEiVmc+F3tC9tVB6TczYyCFley4+y/Q9JtpXGD4cI2blPjx+EX2hhxb+rbcC4f abivrflUcVp9DyxRiidneCzfPfggbDOIdNFDUU07LLFzti8A0wEXRtAhRJh7SS/Xn6 SIYjyfnnpOPOtq1sVEEnsyFpyIMa1k3SQIxY6ZhM= To: Caleb Connolly From: Caleb Connolly Cc: Andy Gross , Bjorn Andersson , Dmitry Torokhov , Rob Herring , linux-arm-msm@vger.kernel.org, linux-input@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, ~postmarketos/upstreaming@lists.sr.ht, Jami Kettunen , Joel Selvaraj Reply-To: Caleb Connolly Subject: [PATCH v3 2/6] input: add Qualcomm SPMI haptics driver Message-ID: <20210816221931.1998187-3-caleb@connolly.tech> In-Reply-To: <20210816221931.1998187-1-caleb@connolly.tech> References: <20210816221931.1998187-1-caleb@connolly.tech> MIME-Version: 1.0 X-Spam-Status: No, score=-1.2 required=10.0 tests=ALL_TRUSTED,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF shortcircuit=no autolearn=disabled version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on mailout.protonmail.ch Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org Add support for the haptics found in pmi8998 and related PMICs. Based on the ff-memless interface. Currently this driver provides a partial implementation of hardware features. This driver only supports LRAs (Linear Resonant Actuators) in the "buffer" mode with a single wave pattern. Signed-off-by: Caleb Connolly --- drivers/input/misc/Kconfig | 12 + drivers/input/misc/Makefile | 1 + drivers/input/misc/qcom-spmi-haptics.c | 981 +++++++++++++++++++++++++ 3 files changed, 994 insertions(+) create mode 100644 drivers/input/misc/qcom-spmi-haptics.c -- 2.32.0 Reported-by: kernel test robot diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig index 498cde376981..de422aeb8e5f 100644 --- a/drivers/input/misc/Kconfig +++ b/drivers/input/misc/Kconfig @@ -186,6 +186,18 @@ config INPUT_PMIC8XXX_PWRKEY To compile this driver as a module, choose M here: the module will be called pmic8xxx-pwrkey. +config INPUT_QCOM_SPMI_HAPTICS + tristate "Qualcomm SPMI HAPTICS" + depends on ARCH_QCOM + depends on SPMI + select INPUT_FF_MEMLESS + help + This option enables support for the haptics found in pmi8998 and + related PMICs. Based on the ff-memless interface. + + To compile this driver as module, choose M here: the + module will be called qcom_spmi_haptics. + config INPUT_SPARCSPKR tristate "SPARC Speaker support" depends on PCI && SPARC64 diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile index f593beed7e05..bf5579f335d5 100644 --- a/drivers/input/misc/Makefile +++ b/drivers/input/misc/Makefile @@ -65,6 +65,7 @@ obj-$(CONFIG_INPUT_PMIC8XXX_PWRKEY) += pmic8xxx-pwrkey.o obj-$(CONFIG_INPUT_POWERMATE) += powermate.o obj-$(CONFIG_INPUT_PWM_BEEPER) += pwm-beeper.o obj-$(CONFIG_INPUT_PWM_VIBRA) += pwm-vibra.o +obj-$(CONFIG_INPUT_QCOM_SPMI_HAPTICS) += qcom-spmi-haptics.o obj-$(CONFIG_INPUT_RAVE_SP_PWRBUTTON) += rave-sp-pwrbutton.o obj-$(CONFIG_INPUT_RB532_BUTTON) += rb532_button.o obj-$(CONFIG_INPUT_REGULATOR_HAPTIC) += regulator-haptic.o diff --git a/drivers/input/misc/qcom-spmi-haptics.c b/drivers/input/misc/qcom-spmi-haptics.c new file mode 100644 index 000000000000..aad8a0be6792 --- /dev/null +++ b/drivers/input/misc/qcom-spmi-haptics.c @@ -0,0 +1,981 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2021, Caleb Connolly + * Qualcomm QPMI haptics driver for pmi8998 and related PMICs. + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define HAP_STATUS_1_REG 0x0A +#define HAP_BUSY_BIT BIT(1) +#define SC_FLAG_BIT BIT(3) +#define AUTO_RES_ERROR_BIT BIT(4) + +#define HAP_LRA_AUTO_RES_LO_REG 0x0B +#define HAP_LRA_AUTO_RES_HI_REG 0x0C + +#define HAP_EN_CTL_REG 0x46 +#define HAP_EN_BIT BIT(7) + +#define HAP_EN_CTL2_REG 0x48 +#define BRAKE_EN_BIT BIT(0) + +#define HAP_AUTO_RES_CTRL_REG 0x4B +#define AUTO_RES_EN_BIT BIT(7) +#define AUTO_RES_ERR_RECOVERY_BIT BIT(3) +#define AUTO_RES_EN_FLAG_BIT BIT(0) + +#define HAP_CFG1_REG 0x4C +#define HAP_ACT_TYPE_MASK BIT(0) + +#define HAP_CFG2_REG 0x4D +#define HAP_LRA_RES_TYPE_MASK BIT(0) + +#define HAP_SEL_REG 0x4E +#define HAP_WF_SOURCE_MASK GENMASK(5, 4) +#define HAP_WF_SOURCE_SHIFT 4 + +#define HAP_LRA_AUTO_RES_REG 0x4F +#define LRA_AUTO_RES_MODE_MASK GENMASK(6, 4) +#define LRA_AUTO_RES_MODE_SHIFT 4 +#define LRA_HIGH_Z_MASK GENMASK(3, 2) +#define LRA_HIGH_Z_SHIFT 2 +#define LRA_RES_CAL_MASK GENMASK(1, 0) +#define HAP_RES_CAL_PERIOD_MIN 4 +#define HAP_RES_CAL_PERIOD_MAX 32 + +#define HAP_VMAX_CFG_REG 0x51 +#define HAP_VMAX_OVD_BIT BIT(6) +#define HAP_VMAX_MASK GENMASK(5, 1) +#define HAP_VMAX_SHIFT 1 + +#define HAP_ILIM_CFG_REG 0x52 +#define HAP_ILIM_SEL_MASK BIT(0) +#define HAP_ILIM_400_MA 0 +#define HAP_ILIM_800_MA 1 + +#define HAP_SC_DEB_REG 0x53 +#define HAP_SC_DEB_MASK GENMASK(2, 0) +#define HAP_SC_DEB_CYCLES_MIN 0 +#define HAP_DEF_SC_DEB_CYCLES 8 +#define HAP_SC_DEB_CYCLES_MAX 32 + +#define HAP_RATE_CFG1_REG 0x54 +#define HAP_RATE_CFG1_MASK GENMASK(7, 0) +#define HAP_RATE_CFG2_SHIFT 8 // As CFG2 is the most significant byte + +#define HAP_RATE_CFG2_REG 0x55 +#define HAP_RATE_CFG2_MASK GENMASK(3, 0) + +#define HAP_SC_CLR_REG 0x59 +#define SC_CLR_BIT BIT(0) + +#define HAP_BRAKE_REG 0x5C +#define HAP_BRAKE_PAT_MASK 0x3 + +#define HAP_WF_REPEAT_REG 0x5E +#define WF_REPEAT_MASK GENMASK(6, 4) +#define WF_REPEAT_SHIFT 4 +#define WF_REPEAT_MIN 1 +#define WF_REPEAT_MAX 128 +#define WF_S_REPEAT_MASK GENMASK(1, 0) +#define WF_S_REPEAT_MIN 1 +#define WF_S_REPEAT_MAX 8 + +#define HAP_WF_S1_REG 0x60 +#define HAP_WF_SIGN_BIT BIT(7) +#define HAP_WF_OVD_BIT BIT(6) +#define HAP_WF_SAMP_MAX GENMASK(5, 1) +#define HAP_WF_SAMPLE_LEN 8 + +#define HAP_PLAY_REG 0x70 +#define HAP_PLAY_BIT BIT(7) +#define HAP_PAUSE_BIT BIT(0) + +#define HAP_SEC_ACCESS_REG 0xD0 +#define HAP_SEC_ACCESS_UNLOCK 0xA5 + +#define HAP_TEST2_REG 0xE3 + + +#define HAP_VMAX_MIN_MV 116 +#define HAP_VMAX_MAX_MV 3596 +#define HAP_VMAX_MAX_MV_STRONG 3596 + +#define HAP_WAVE_PLAY_RATE_MIN_US 0 +#define HAP_WAVE_PLAY_RATE_MAX_US 20475 +#define HAP_WAVE_PLAY_TIME_MAX_MS 15000 + +#define AUTO_RES_ERR_POLL_TIME_NS (20 * NSEC_PER_MSEC) +#define HAPTICS_BACK_EMF_DELAY_US 20000 + +#define HAP_BRAKE_PAT_LEN 4 +#define HAP_WAVE_SAMP_LEN 8 +#define NUM_WF_SET 4 +#define HAP_WAVE_SAMP_SET_LEN (HAP_WAVE_SAMP_LEN * NUM_WF_SET) +#define HAP_RATE_CFG_STEP_US 5 + +#define SC_MAX_COUNT 5 +#define SC_COUNT_RST_DELAY_US 1000000 + +enum hap_play_control { + HAP_STOP, + HAP_PAUSE, + HAP_PLAY, +}; + +/** + * struct spmi_haptics - struct for spmi haptics data. + * + * @dev: Our device parent. + * @regmap: Register map for the hardware block. + * @input_dev: The input device used to receive events. + * @work: Work struct to play effects. + * @base: Base address of the regmap. + * @active: Atomic value used to track if haptics are currently playing. + * @play_irq: Fired to load the next wave pattern. + * @sc_irq: Short circuit irq. + * @last_sc_time: Time since the short circuit IRQ last fired. + * @sc_count: Number of times the short circuit IRQ has fired in this interval. + * @actuator_type: The type of actuator in use. + * @wave_shape: The shape of the waves to use (sine or square). + * @play_mode: The play mode to use (direct, buffer, pwm, audio). + * @magnitude: The strength we should be playing at. + * @vmax: Max voltage to use when playing. + * @current_limit: The current limit for this hardware (400mA or 800mA). + * @play_wave_rate: The wave rate to use for this hardware. + * @wave_samp: The array of wave samples to write for buffer mode. + * @brake_pat: The pattern to apply when braking. + * @play_lock: Lock to be held when updating the hardware state. + */ +struct spmi_haptics { + struct device *dev; + struct regmap *regmap; + struct input_dev *haptics_input_dev; + struct work_struct work; + u32 base; + + atomic_t active; + + int play_irq; + int sc_irq; + ktime_t last_sc_time; + u8 sc_count; + + u8 actuator_type; + u8 wave_shape; + u8 play_mode; + int magnitude; + u32 vmax; + u32 current_limit; + u32 play_wave_rate; + + u32 wave_samp[HAP_WAVE_SAMP_SET_LEN]; + u8 brake_pat[HAP_BRAKE_PAT_LEN]; + + struct mutex play_lock; +}; + +static inline bool is_secure_addr(u16 addr) +{ + return (addr & 0xFF) > 0xD0; +} + +static int spmi_haptics_read(struct spmi_haptics *haptics, + u16 addr, u8 *val, int len) +{ + int ret; + + ret = regmap_bulk_read(haptics->regmap, addr, val, len); + if (ret < 0) + dev_err(haptics->dev, "Error reading address: 0x%x, ret %d\n", addr, ret); + + return ret; +} + +static int spmi_haptics_write(struct spmi_haptics *haptics, + u16 addr, u8 *val, int len) +{ + int ret, i; + + if (is_secure_addr(addr)) { + for (i = 0; i < len; i++) { + dev_dbg(haptics->dev, "%s: unlocking for addr: 0x%x, val: 0x%x", __func__, + addr, val[i]); + ret = regmap_write(haptics->regmap, + haptics->base + HAP_SEC_ACCESS_REG, HAP_SEC_ACCESS_UNLOCK); + if (ret < 0) { + dev_err(haptics->dev, "Error writing unlock code, ret %d\n", + ret); + return ret; + } + + ret = regmap_write(haptics->regmap, addr + i, val[i]); + if (ret < 0) { + dev_err(haptics->dev, "Error writing address 0x%x, ret %d\n", + addr + i, ret); + return ret; + } + } + } else { + if (len > 1) + ret = regmap_bulk_write(haptics->regmap, addr, val, len); + else + ret = regmap_write(haptics->regmap, addr, *val); + } + + if (ret < 0) + dev_err(haptics->dev, "%s: Error writing address: 0x%x, ret %d\n", + __func__, addr, ret); + + return ret; +} + +static int spmi_haptics_write_masked(struct spmi_haptics *haptics, + u16 addr, u8 mask, u8 val) +{ + int ret; + + if (is_secure_addr(addr)) { + ret = regmap_write(haptics->regmap, + haptics->base + HAP_SEC_ACCESS_REG, HAP_SEC_ACCESS_UNLOCK); + if (ret < 0) { + dev_err(haptics->dev, "Error writing unlock code - ret %d\n", ret); + return ret; + } + } + + ret = regmap_update_bits(haptics->regmap, addr, mask, val); + if (ret < 0) + dev_err(haptics->dev, "Error writing address: 0x%x - ret %d\n", addr, ret); + + return ret; +} + +static bool is_haptics_idle(struct spmi_haptics *haptics) +{ + int ret; + u8 val; + + if (haptics->play_mode == HAP_PLAY_DIRECT || + haptics->play_mode == HAP_PLAY_PWM) + return true; + + ret = spmi_haptics_read(haptics, haptics->base + HAP_STATUS_1_REG, &val, 1); + if (ret < 0 || (val & HAP_BUSY_BIT)) + return false; + + return true; +} + +static int spmi_haptics_module_enable(struct spmi_haptics *haptics, bool enable) +{ + u8 val; + + dev_dbg(haptics->dev, "Setting module enable: %d", enable); + + val = enable ? HAP_EN_BIT : 0; + return spmi_haptics_write(haptics, haptics->base + HAP_EN_CTL_REG, &val, 1); +} + +static int spmi_haptics_write_vmax(struct spmi_haptics *haptics) +{ + u8 val = 0; + u32 vmax_mv = haptics->vmax; + + vmax_mv = clamp_t(u32, vmax_mv, HAP_VMAX_MIN_MV, HAP_VMAX_MAX_MV); + + dev_dbg(haptics->dev, "Setting vmax to: %d", vmax_mv); + + val = DIV_ROUND_CLOSEST(vmax_mv, HAP_VMAX_MIN_MV); + val = FIELD_PREP(HAP_VMAX_MASK, val); + + // TODO: pm660 can enable overdrive here + + return spmi_haptics_write_masked(haptics, haptics->base + HAP_VMAX_CFG_REG, + HAP_VMAX_MASK | HAP_WF_OVD_BIT, val); +} + +static int spmi_haptics_write_current_limit(struct spmi_haptics *haptics) +{ + haptics->current_limit = clamp_t(u32, haptics->current_limit, + HAP_ILIM_400_MA, HAP_ILIM_800_MA); + + dev_dbg(haptics->dev, "Setting current_limit to: 0x%x", haptics->current_limit); + + return spmi_haptics_write_masked(haptics, haptics->base + HAP_ILIM_CFG_REG, + HAP_ILIM_SEL_MASK, haptics->current_limit); +} + +static int spmi_haptics_write_play_mode(struct spmi_haptics *haptics) +{ + u8 val = 0; + + if (!is_haptics_idle(haptics)) + return -EBUSY; + + dev_dbg(haptics->dev, "Setting play_mode to: 0x%x", haptics->play_mode); + + val = FIELD_PREP(HAP_WF_SOURCE_MASK, haptics->play_mode); + return spmi_haptics_write_masked(haptics, haptics->base + HAP_SEL_REG, + HAP_WF_SOURCE_MASK, val); + +} + +static int spmi_haptics_write_play_rate(struct spmi_haptics *haptics, u16 play_rate) +{ + u8 val[2]; + + dev_dbg(haptics->dev, "Setting play_rate to: %d", play_rate); + + val[0] = FIELD_PREP(HAP_RATE_CFG1_MASK, play_rate); + val[1] = FIELD_PREP(HAP_RATE_CFG2_MASK, play_rate >> HAP_RATE_CFG2_SHIFT); + return spmi_haptics_write(haptics, haptics->base + HAP_RATE_CFG1_REG, val, 2); +} + +/* + * spmi_haptics_set_auto_res() - Auto resonance + * allows the haptics to automatically adjust the + * speed of the oscillation in order to maintain + * the resonant frequency. + */ +static int spmi_haptics_set_auto_res(struct spmi_haptics *haptics, bool enable) +{ + u8 val; + + // LRAs are the only type to support auto res + if (haptics->actuator_type != HAP_TYPE_LRA) + return 0; + + val = enable ? AUTO_RES_EN_BIT : 0; + + return spmi_haptics_write_masked(haptics, haptics->base + HAP_TEST2_REG, + AUTO_RES_EN_BIT, val); +} + +static int spmi_haptics_write_brake(struct spmi_haptics *haptics) +{ + int ret, i; + u8 val; + + dev_dbg(haptics->dev, "Configuring brake pattern"); + + ret = spmi_haptics_write_masked(haptics, haptics->base + HAP_EN_CTL2_REG, + BRAKE_EN_BIT, 1); + if (ret < 0) + return ret; + + for (i = HAP_BRAKE_PAT_LEN - 1, val = 0; i >= 0; i--) { + u8 p = haptics->brake_pat[i] & HAP_BRAKE_PAT_MASK; + + val |= p << (i * 2); + } + + return spmi_haptics_write(haptics, haptics->base + HAP_BRAKE_REG, &val, 1); +} + +static int spmi_haptics_write_buffer_config(struct spmi_haptics *haptics) +{ + u8 buf[HAP_WAVE_SAMP_LEN]; + int i; + + dev_dbg(haptics->dev, "Writing buffer config"); + + for (i = 0; i < HAP_WAVE_SAMP_LEN; i++) + buf[i] = haptics->wave_samp[i]; + + return spmi_haptics_write(haptics, haptics->base + HAP_WF_S1_REG, buf, + HAP_WAVE_SAMP_LEN); +} + +/* + * spmi_haptics_write_wave_repeat() - write wave repeat values. + */ +static int spmi_haptics_write_wave_repeat(struct spmi_haptics *haptics) +{ + u8 val, mask; + + /* The number of times to repeat each wave */ + mask = WF_REPEAT_MASK | WF_S_REPEAT_MASK; + val = FIELD_PREP(WF_REPEAT_MASK, 0) | + FIELD_PREP(WF_S_REPEAT_MASK, 0); + + return spmi_haptics_write_masked(haptics, haptics->base + HAP_WF_REPEAT_REG, + mask, val); +} + +static int spmi_haptics_write_play_control(struct spmi_haptics *haptics, + enum hap_play_control ctrl) +{ + u8 val; + + switch (ctrl) { + case HAP_STOP: + val = 0; + break; + case HAP_PAUSE: + val = HAP_PAUSE_BIT; + break; + case HAP_PLAY: + val = HAP_PLAY_BIT; + break; + default: + return 0; + } + + dev_dbg(haptics->dev, "haptics play ctrl: %d\n", ctrl); + return spmi_haptics_write(haptics, haptics->base + HAP_PLAY_REG, &val, 1); +} + +/* + * This IRQ is fired to tell us to load the next wave sample set. + * As we only currently support a single sample set, it's unused. + */ +static irqreturn_t spmi_haptics_play_irq_handler(int irq, void *data) +{ + struct spmi_haptics *haptics = data; + + dev_dbg(haptics->dev, "play_irq triggered"); + + return IRQ_HANDLED; +} + +/* + * Fires every ~50ms whilst the haptics are active. + * If the SC_FLAG_BIT is set then that means there isn't a short circuit + * and we just need to clear the IRQ to indicate that the device should + * keep vibrating. + * + * Otherwise, it means a short circuit situation has occurred. + */ +static irqreturn_t spmi_haptics_sc_irq_handler(int irq, void *data) +{ + struct spmi_haptics *haptics = data; + int ret; + u8 val; + s64 sc_delta_time_us; + ktime_t temp; + + ret = spmi_haptics_read(haptics, haptics->base + HAP_STATUS_1_REG, &val, 1); + if (ret < 0) + return IRQ_HANDLED; + + if (!(val & SC_FLAG_BIT)) { + haptics->sc_count = 0; + return IRQ_HANDLED; + } + + temp = ktime_get(); + sc_delta_time_us = ktime_us_delta(temp, haptics->last_sc_time); + haptics->last_sc_time = temp; + + if (sc_delta_time_us > SC_COUNT_RST_DELAY_US) + haptics->sc_count = 0; + else + haptics->sc_count++; + + // Clear the interrupt flag + val = SC_CLR_BIT; + ret = spmi_haptics_write(haptics, haptics->base + HAP_SC_CLR_REG, &val, 1); + if (ret < 0) + return IRQ_HANDLED; + + if (haptics->sc_count > SC_MAX_COUNT) { + dev_crit(haptics->dev, "Short circuit persists, disabling haptics\n"); + ret = spmi_haptics_module_enable(haptics, false); + if (ret < 0) + dev_err(haptics->dev, "Error disabling module, rc=%d\n", ret); + } + + return IRQ_HANDLED; +} + + +/** + * spmi_haptics_init() - Initialise haptics hardware for use + * @haptics: haptics device + * Returns: 0 on success, < 0 on error + */ +static int spmi_haptics_init(struct spmi_haptics *haptics) +{ + int ret; + u8 val, mask; + u16 play_rate; + + ret = spmi_haptics_write_masked(haptics, haptics->base + HAP_CFG1_REG, + HAP_ACT_TYPE_MASK, haptics->actuator_type); + if (ret < 0) + return ret; + + /* + * Configure auto resonance + * see spmi_haptics_lra_auto_res_config downstream + * This is greatly simplified. + */ + val = FIELD_PREP(LRA_RES_CAL_MASK, ilog2(32 / HAP_RES_CAL_PERIOD_MIN)) | + FIELD_PREP(LRA_AUTO_RES_MODE_MASK, HAP_AUTO_RES_ZXD_EOP) | + FIELD_PREP(LRA_HIGH_Z_MASK, 1); + + mask = LRA_AUTO_RES_MODE_MASK | LRA_HIGH_Z_MASK | LRA_RES_CAL_MASK; + + ret = spmi_haptics_write_masked(haptics, haptics->base + HAP_LRA_AUTO_RES_REG, + mask, val); + + /* Configure the PLAY MODE register */ + ret = spmi_haptics_write_play_mode(haptics); + if (ret < 0) + return ret; + + ret = spmi_haptics_write_vmax(haptics); + if (ret < 0) + return ret; + + /* Configure the ILIM register */ + ret = spmi_haptics_write_current_limit(haptics); + if (ret < 0) + return ret; + + // Configure the debounce for short-circuit detection. + ret = spmi_haptics_write_masked(haptics, haptics->base + HAP_SC_DEB_REG, + HAP_SC_DEB_MASK, HAP_SC_DEB_CYCLES_MAX); + if (ret < 0) + return ret; + + // write the wave shape + ret = spmi_haptics_write_masked(haptics, haptics->base + HAP_CFG2_REG, + HAP_LRA_RES_TYPE_MASK, haptics->wave_shape); + if (ret < 0) + return ret; + + play_rate = haptics->play_wave_rate / HAP_RATE_CFG_STEP_US; + + /* + * Configure RATE_CFG1 and RATE_CFG2 registers. + * Note: For ERM these registers act as play rate and + * for LRA these represent resonance period + */ + ret = spmi_haptics_write_play_rate(haptics, play_rate); + if (ret < 0) + return ret; + + ret = spmi_haptics_write_brake(haptics); + if (ret < 0) + return ret; + + if (haptics->play_mode == HAP_PLAY_BUFFER) { + ret = spmi_haptics_write_wave_repeat(haptics); + if (ret < 0) + return ret; + + ret = spmi_haptics_write_buffer_config(haptics); + if (ret < 0) + return ret; + } + + if (haptics->play_irq >= 0) { + dev_dbg(haptics->dev, "%s: Requesting play IRQ, irq: %d", __func__, + haptics->play_irq); + ret = devm_request_threaded_irq(haptics->dev, haptics->play_irq, + NULL, spmi_haptics_play_irq_handler, IRQF_ONESHOT, + "haptics_play_irq", haptics); + + if (ret < 0) { + dev_err(haptics->dev, "Unable to request play IRQ ret=%d\n", ret); + return ret; + } + + /* use play_irq only for buffer mode */ + if (haptics->play_mode != HAP_PLAY_BUFFER) + disable_irq(haptics->play_irq); + } + + if (haptics->sc_irq >= 0) { + dev_dbg(haptics->dev, "%s: Requesting play IRQ, irq: %d", __func__, + haptics->play_irq); + ret = devm_request_threaded_irq(haptics->dev, haptics->sc_irq, + NULL, spmi_haptics_sc_irq_handler, IRQF_ONESHOT, + "haptics_sc_irq", haptics); + + if (ret < 0) { + dev_err(haptics->dev, "Unable to request sc IRQ ret=%d\n", ret); + return ret; + } + } + + return 0; +} + +/** + * spmi_haptics_enable - handler to start/stop vibration + * @haptics: pointer to haptics struct + * @enable: state to set + * Returns: 0 on success, < 0 on failure + */ +static int spmi_haptics_enable(struct spmi_haptics *haptics) +{ + int ret; + + mutex_lock(&haptics->play_lock); + if (haptics->sc_count > SC_MAX_COUNT) { + dev_err(haptics->dev, "Can't play while in short circuit"); + ret = -1; + goto out; + } + ret = spmi_haptics_set_auto_res(haptics, false); + if (ret < 0) { + dev_err(haptics->dev, "Error disabling auto_res, ret=%d\n", ret); + goto out; + } + + ret = spmi_haptics_module_enable(haptics, true); + if (ret < 0) { + dev_err(haptics->dev, "Error enabling module, ret=%d\n", ret); + goto out; + } + + ret = spmi_haptics_write_play_control(haptics, HAP_PLAY); + if (ret < 0) { + dev_err(haptics->dev, "Error enabling play, ret=%d\n", ret); + goto out; + } + + ret = spmi_haptics_set_auto_res(haptics, true); + if (ret < 0) { + dev_err(haptics->dev, "Error enabling auto_res, ret=%d\n", ret); + goto out; + } + +out: + mutex_unlock(&haptics->play_lock); + return ret; +} + +/** + * spmi_haptics_enable - handler to start/stop vibration + * @haptics: pointer to haptics struct + * @enable: state to set + * Returns: 0 on success, < 0 on failure + */ +static int spmi_haptics_disable(struct spmi_haptics *haptics) +{ + int ret; + + mutex_lock(&haptics->play_lock); + + ret = spmi_haptics_write_play_control(haptics, HAP_STOP); + if (ret < 0) { + dev_err(haptics->dev, "Error disabling play, ret=%d\n", ret); + goto out; + } + + ret = spmi_haptics_module_enable(haptics, false); + if (ret < 0) { + dev_err(haptics->dev, "Error disabling module, ret=%d\n", ret); + goto out; + } + +out: + mutex_unlock(&haptics->play_lock); + return ret; +} + +/* + * Threaded function to update the haptics state. + */ +static void spmi_haptics_work(struct work_struct *work) +{ + struct spmi_haptics *haptics = container_of(work, struct spmi_haptics, work); + + int ret; + bool enable; + + enable = atomic_read(&haptics->active); + dev_dbg(haptics->dev, "%s: state: %d\n", __func__, enable); + + if (enable) + ret = spmi_haptics_enable(haptics); + else + ret = spmi_haptics_disable(haptics); + if (ret < 0) + dev_err(haptics->dev, "Error setting haptics, ret=%d", ret); +} + +/** + * spmi_haptics_close - callback for input device close + * @dev: input device pointer + * + * Turns off the vibrator. + */ +static void spmi_haptics_close(struct input_dev *dev) +{ + struct spmi_haptics *haptics = input_get_drvdata(dev); + + cancel_work_sync(&haptics->work); + if (atomic_read(&haptics->active)) { + atomic_set(&haptics->active, 0); + schedule_work(&haptics->work); + } +} + +/** + * spmi_haptics_play_effect - play haptics effects + * @dev: input device pointer + * @data: data of effect + * @effect: effect to play + */ +static int spmi_haptics_play_effect(struct input_dev *dev, void *data, + struct ff_effect *effect) +{ + struct spmi_haptics *haptics = input_get_drvdata(dev); + + dev_dbg(haptics->dev, "%s: Rumbling with strong: %d and weak: %d", __func__, + effect->u.rumble.strong_magnitude, effect->u.rumble.weak_magnitude); + + haptics->magnitude = effect->u.rumble.strong_magnitude >> 8; + if (!haptics->magnitude) + haptics->magnitude = effect->u.rumble.weak_magnitude >> 10; + + if (!haptics->magnitude) { + atomic_set(&haptics->active, 0); + goto end; + } + + atomic_set(&haptics->active, 1); + + haptics->vmax = ((HAP_VMAX_MAX_MV - HAP_VMAX_MIN_MV) * haptics->magnitude) / 100 + + HAP_VMAX_MIN_MV; + + dev_dbg(haptics->dev, "%s: magnitude: %d, vmax: %d", __func__, + haptics->magnitude, haptics->vmax); + + spmi_haptics_write_vmax(haptics); + +end: + schedule_work(&haptics->work); + + return 0; +} + +static int spmi_haptics_probe(struct platform_device *pdev) +{ + struct spmi_haptics *haptics; + struct device_node *node; + struct input_dev *input_dev; + int ret; + u32 val; + int i; + + haptics = devm_kzalloc(&pdev->dev, sizeof(*haptics), GFP_KERNEL); + if (!haptics) + return -ENOMEM; + + haptics->regmap = dev_get_regmap(pdev->dev.parent, NULL); + if (!haptics->regmap) + return -ENODEV; + + node = pdev->dev.of_node; + + haptics->dev = &pdev->dev; + + ret = of_property_read_u32(node, "reg", &haptics->base); + if (ret < 0) { + dev_err(haptics->dev, "Couldn't find reg in node = %s ret = %d\n", + node->full_name, ret); + return ret; + } + + haptics->play_irq = platform_get_irq_byname(pdev, "play"); + if (haptics->play_irq < 0) { + dev_err(&pdev->dev, "Unable to get play irq\n"); + ret = haptics->play_irq; + goto register_fail; + } + + haptics->sc_irq = platform_get_irq_byname(pdev, "short"); + if (haptics->sc_irq < 0) { + dev_err(&pdev->dev, "Unable to get sc irq\n"); + ret = haptics->sc_irq; + goto register_fail; + } + + // We only support LRAs for now + haptics->actuator_type = HAP_TYPE_LRA; + ret = of_property_read_u32(node, "qcom,actuator-type", &val); + if (!ret) { + if (val != HAP_TYPE_LRA) { + dev_err(&pdev->dev, "qcom,actuator-type (%d) isn't supported\n", val); + ret = -EINVAL; + goto register_fail; + } + haptics->actuator_type = val; + } + + // Only buffer mode is currently supported + haptics->play_mode = HAP_PLAY_BUFFER; + ret = of_property_read_u32(node, "qcom,play-mode", &val); + if (!ret) { + if (val != HAP_PLAY_BUFFER) { + dev_err(&pdev->dev, "qcom,play-mode (%d) isn't supported\n", val); + ret = -EINVAL; + goto register_fail; + } + haptics->play_mode = val; + } + + ret = of_property_read_u32(node, "qcom,wave-play-rate-us", &val); + if (!ret) { + haptics->play_wave_rate = val; + } else if (ret != -EINVAL) { + dev_err(haptics->dev, "Unable to read play rate ret=%d\n", ret); + goto register_fail; + } + + haptics->play_wave_rate = + clamp_t(u32, haptics->play_wave_rate, + HAP_WAVE_PLAY_RATE_MIN_US, HAP_WAVE_PLAY_RATE_MAX_US); + + haptics->wave_shape = HAP_WAVE_SINE; + ret = of_property_read_u32(node, "qcom,wave-shape", &val); + if (!ret) { + if (val != HAP_WAVE_SINE && val != HAP_WAVE_SQUARE) { + dev_err(&pdev->dev, "qcom,wave-shape is invalid: %d\n", val); + ret = -EINVAL; + goto register_fail; + } + haptics->wave_shape = val; + } + + haptics->brake_pat[0] = 0x3; + haptics->brake_pat[1] = 0x3; + haptics->brake_pat[2] = 0x2; + haptics->brake_pat[3] = 0x1; + + ret = of_property_read_u8_array(node, "qcom,brake-pattern", haptics->brake_pat, 4); + if (ret < 0 && ret != -EINVAL) { + dev_err(&pdev->dev, "qcom,brake-pattern is invalid, ret = %d\n", ret); + goto register_fail; + } + + haptics->current_limit = HAP_ILIM_400_MA; + + for (i = 0; i < HAP_WAVE_SAMP_LEN; i++) + haptics->wave_samp[i] = HAP_WF_SAMP_MAX; + + ret = spmi_haptics_init(haptics); + if (ret < 0) { + dev_err(&pdev->dev, "Error initialising haptics, ret=%d\n", + ret); + goto register_fail; + } + + platform_set_drvdata(pdev, haptics); + + input_dev = devm_input_allocate_device(&pdev->dev); + if (!input_dev) + return -ENOMEM; + + INIT_WORK(&haptics->work, spmi_haptics_work); + haptics->haptics_input_dev = input_dev; + + input_dev->name = "spmi_haptics"; + input_dev->id.version = 1; + input_dev->close = spmi_haptics_close; + input_set_drvdata(input_dev, haptics); + // Figure out how to make this FF_PERIODIC + input_set_capability(haptics->haptics_input_dev, EV_FF, FF_RUMBLE); + + ret = input_ff_create_memless(input_dev, NULL, + spmi_haptics_play_effect); + if (ret) { + dev_err(&pdev->dev, + "couldn't register vibrator as FF device\n"); + goto register_fail; + } + + ret = input_register_device(input_dev); + if (ret) { + dev_err(&pdev->dev, "couldn't register input device\n"); + goto register_fail; + } + + return 0; + +register_fail: + cancel_work_sync(&haptics->work); + mutex_destroy(&haptics->play_lock); + + return ret; +} + +static int __maybe_unused spmi_haptics_suspend(struct device *dev) +{ + struct spmi_haptics *haptics = dev_get_drvdata(dev); + + cancel_work_sync(&haptics->work); + spmi_haptics_disable(haptics); + + return 0; +} + +static SIMPLE_DEV_PM_OPS(spmi_haptics_pm_ops, spmi_haptics_suspend, NULL); + +static int spmi_haptics_remove(struct platform_device *pdev) +{ + struct spmi_haptics *haptics = dev_get_drvdata(&pdev->dev); + + cancel_work_sync(&haptics->work); + mutex_destroy(&haptics->play_lock); + input_unregister_device(haptics->haptics_input_dev); + + return 0; +} + +static void spmi_haptics_shutdown(struct platform_device *pdev) +{ + struct spmi_haptics *haptics = dev_get_drvdata(&pdev->dev); + + cancel_work_sync(&haptics->work); + + spmi_haptics_disable(haptics); +} + +static const struct of_device_id spmi_haptics_match_table[] = { + { .compatible = "qcom,spmi-haptics" }, + { } +}; +MODULE_DEVICE_TABLE(of, spmi_haptics_match_table); + +static struct platform_driver spmi_haptics_driver = { + .probe = spmi_haptics_probe, + .remove = spmi_haptics_remove, + .shutdown = spmi_haptics_shutdown, + .driver = { + .name = "spmi-haptics", + .pm = &spmi_haptics_pm_ops, + .of_match_table = spmi_haptics_match_table, + }, +}; +module_platform_driver(spmi_haptics_driver); + +MODULE_DESCRIPTION("spmi haptics driver using ff-memless framework"); +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR("Caleb Connolly "); From patchwork Mon Aug 16 22:20:04 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Caleb Connolly X-Patchwork-Id: 497671 Delivered-To: patch@linaro.org Received: by 2002:a02:6f15:0:0:0:0:0 with SMTP id x21csp507824jab; Mon, 16 Aug 2021 15:20:14 -0700 (PDT) X-Google-Smtp-Source: ABdhPJw8bbtdZK6vCX/H3ehvGmhJnvf6hycanZ8DYkK9WkMU3tzH6EZNlQdfNPWxlHAunGNgzjMv X-Received: by 2002:a05:6638:2284:: with SMTP id y4mr80787jas.75.1629152414340; Mon, 16 Aug 2021 15:20:14 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1629152414; cv=none; d=google.com; s=arc-20160816; b=JB308LKsgT7af4ESB4YcfeEH9d1uiGOzIrdJ4ZiU/F1T7bY1T2e+BVOiROqkyGkqsK 4cI5aoQo2lGxvViLOyNxplRAZvN1ZSHZMy2VE0/gCNEjTyxy0uwDOUN5hrxWJe3xXJow dQcR4UMm+y1xeDr5ONqwzgiIWKO73pXf0G/bCtxEBcQusZ9M56pIzJDFAKWeOpuoihrd XMSCKDFS8jkCK9L1dyWiyt6dNEtUJKC4xiOP1EiOI01E/TZSf/c1I1bbDGbUvh/U87w4 mFrc9ekO4VccqdEAE/Pl3RbJz7E+k3tR3BxGxJU62fMimeqgvf/V3+CZEWWV1mtnMEa4 JO1g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:subject:reply-to:cc:from:to :dkim-signature:date; bh=p1oSGV8HrzznM4YBBdgwJJ/jRo6ZHhOka5byBtAFy64=; b=pZWO1DF2OoiacwYSgsMaaZQtEAMbKTkpArw5SSVUIWwaupr5/oGv1C+I2W5G+cA67G /LSx8OCp6tCbZe8kGE0i8Ukxa8EcHDeeddOYGJprhciDr1pVm1Ou8Lhpp5Eb6T5sn0OO ClHE6Lo6pYaKBcgEqdOzQ58aQfCS/38wo0/VtzmLja2lsepQjtVJBrhguqwbgT8tcRee Cd3LKOtBUZUobPiCJ3/Kr7t1vZRSgaw1c6h8Kp8CD9fkLMOiLPE20BxHWiLVs50imuHk nF3LEYSg2PeJgyYCz3z6dIuatDyFgUoE+lSLuTwXMeRzQY87BfEYHxRJtpm0IzlIBEEB X4iw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@connolly.tech header.s=protonmail header.b=evHaJSuz; spf=pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=devicetree-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=connolly.tech Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id y17si486548iov.62.2021.08.16.15.20.14; Mon, 16 Aug 2021 15:20:14 -0700 (PDT) Received-SPF: pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@connolly.tech header.s=protonmail header.b=evHaJSuz; spf=pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=devicetree-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=connolly.tech Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234074AbhHPWUo (ORCPT + 7 others); Mon, 16 Aug 2021 18:20:44 -0400 Received: from mail1.protonmail.ch ([185.70.40.18]:14948 "EHLO mail1.protonmail.ch" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233876AbhHPWUn (ORCPT ); Mon, 16 Aug 2021 18:20:43 -0400 Date: Mon, 16 Aug 2021 22:20:04 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=connolly.tech; s=protonmail; t=1629152410; bh=p1oSGV8HrzznM4YBBdgwJJ/jRo6ZHhOka5byBtAFy64=; h=Date:To:From:Cc:Reply-To:Subject:In-Reply-To:References:From; b=evHaJSuzLFtyGKtjbjC/IxiOSkMcDSHas0asVilyQNtjKwL9TPHUIQ8PmRNi3W9pB 1h0MEcyP/jp8P5wStdSBiH/F7kZsULchN0oq8jL7IZfrBMYKvOrTyGaJzxFM6ryaA+ UD5nh8h2lkatCnZcHhAoCHAD2ylHreu4LFmxFXWw= To: Caleb Connolly From: Caleb Connolly Cc: Andy Gross , Bjorn Andersson , Dmitry Torokhov , Rob Herring , linux-arm-msm@vger.kernel.org, linux-input@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, ~postmarketos/upstreaming@lists.sr.ht, Jami Kettunen , Joel Selvaraj Reply-To: Caleb Connolly Subject: [PATCH v3 3/6] arm64: dts: qcom: pmi8998: introduce spmi haptics Message-ID: <20210816221931.1998187-4-caleb@connolly.tech> In-Reply-To: <20210816221931.1998187-1-caleb@connolly.tech> References: <20210816221931.1998187-1-caleb@connolly.tech> MIME-Version: 1.0 X-Spam-Status: No, score=-1.2 required=10.0 tests=ALL_TRUSTED,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF shortcircuit=no autolearn=disabled version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on mailout.protonmail.ch Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org Add bindings for Qualcomm SPMI haptics on platforms using pmi8998. Signed-off-by: Caleb Connolly --- arch/arm64/boot/dts/qcom/pmi8998.dtsi | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) -- 2.32.0 diff --git a/arch/arm64/boot/dts/qcom/pmi8998.dtsi b/arch/arm64/boot/dts/qcom/pmi8998.dtsi index d230c510d4b7..5412cb3af0ae 100644 --- a/arch/arm64/boot/dts/qcom/pmi8998.dtsi +++ b/arch/arm64/boot/dts/qcom/pmi8998.dtsi @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-2.0 +#include #include #include @@ -41,5 +42,20 @@ lab: lab { interrupt-names = "sc-err", "ocp"; }; }; + + pmi8998_haptics: haptics@c000 { + compatible = "qcom,pmi8998-haptics", "qcom,spmi-haptics"; + reg = <0xc000>; + + interrupts = <0x3 0xc0 0x0 IRQ_TYPE_EDGE_BOTH>, + <0x3 0xc0 0x1 IRQ_TYPE_EDGE_BOTH>; + interrupt-names = "short", "play"; + + qcom,wave-shape = ; + qcom,play-mode = ; + qcom,brake-pattern = <0x3 0x3 0x2 0x1>; + + status = "disabled"; + }; }; }; From patchwork Mon Aug 16 22:20:13 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Caleb Connolly X-Patchwork-Id: 497722 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER, INCLUDES_PATCH, MAILING_LIST_MULTI, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7A09DC4320E for ; Mon, 16 Aug 2021 22:20:26 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 5EBC660E76 for ; Mon, 16 Aug 2021 22:20:26 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234092AbhHPWU5 (ORCPT ); Mon, 16 Aug 2021 18:20:57 -0400 Received: from mail2.protonmail.ch ([185.70.40.22]:54440 "EHLO mail2.protonmail.ch" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234149AbhHPWUu (ORCPT ); Mon, 16 Aug 2021 18:20:50 -0400 Date: Mon, 16 Aug 2021 22:20:13 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=connolly.tech; s=protonmail; t=1629152417; bh=/kJzNtX9uX5VLvPNqLVdpy1Sm9tQvwqR3FoaD4TJ8QU=; h=Date:To:From:Cc:Reply-To:Subject:In-Reply-To:References:From; b=ZdeEBvRais7p0tmielk5t2PZI0oQbOTQEv/8ab2nZebCxCRQ38Q+NhuGJ1T1yOad0 +1x/yPm/o0DuFVUMOB7Lcx1EDo+3HdqCD9UtBFwGS4QC5HA1Dwbfy7ZOUbYJRccuut VT8fESeTBTdHDilhujYdLnym/XsWsbTgUD/1eV2k= To: Caleb Connolly From: Caleb Connolly Cc: Andy Gross , Bjorn Andersson , Dmitry Torokhov , Rob Herring , linux-arm-msm@vger.kernel.org, linux-input@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, ~postmarketos/upstreaming@lists.sr.ht, Jami Kettunen , Joel Selvaraj Reply-To: Caleb Connolly Subject: [PATCH v3 5/6] arm64: dts: qcom: sdm845-xiaomi-beryllium: add haptics Message-ID: <20210816221931.1998187-6-caleb@connolly.tech> In-Reply-To: <20210816221931.1998187-1-caleb@connolly.tech> References: <20210816221931.1998187-1-caleb@connolly.tech> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org From: Joel Selvaraj Enable the pmi8998 SPMI haptics driver and configure the play rate for the hardware. Signed-off-by: Joel Selvaraj Signed-off-by: Caleb Connolly --- arch/arm64/boot/dts/qcom/sdm845-xiaomi-beryllium.dts | 5 +++++ 1 file changed, 5 insertions(+) -- 2.32.0 diff --git a/arch/arm64/boot/dts/qcom/sdm845-xiaomi-beryllium.dts b/arch/arm64/boot/dts/qcom/sdm845-xiaomi-beryllium.dts index c60c8c640e17..b6ce5d0f4966 100644 --- a/arch/arm64/boot/dts/qcom/sdm845-xiaomi-beryllium.dts +++ b/arch/arm64/boot/dts/qcom/sdm845-xiaomi-beryllium.dts @@ -335,6 +335,11 @@ dai@2 { }; }; +&pmi8998_haptics { + status = "okay"; + qcom,wave-play-rate-us = <4878>; +}; + &qupv3_id_0 { status = "okay"; };