From patchwork Thu Dec 19 16:21:18 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Dubois-Briand X-Patchwork-Id: 852187 Received: from relay3-d.mail.gandi.net (relay3-d.mail.gandi.net [217.70.183.195]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 65E17225A2C; Thu, 19 Dec 2024 16:21:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.195 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625319; cv=none; b=frfWQlUue/BQlBRp+HuubraCSn6/XTPSudwb9NyMD+yBBNGs+kYUr6bwH+c4sGbo9XLIK2u354eAK5+befjOEYQ1659+vsBYSk7z/crj2NqmojMN/DaYW1naQrNy143j8MVi+0VqiLCr5/8XfycpfEr2THt4THdRUF+KPvGVSno= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625319; c=relaxed/simple; bh=KWh36d+ljikVIIPs4N2J6PrSLdnhSOVvwQo9gjfU3sc=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=bXRs89yLnp5/hBvoArjStuVHAmH6rxCAIIG0AwUOm/NFkweCsrmGy/5tmRAMWos3RdAgCIst7nmtyyVmxbQYPwo9680IyqlozH2b3VLHDpnwKLD7lHZao79asGPawfG7QOyrfWkjfeE1gZg5wHDelf54hJD9BtLuT0LvJn+Gers= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=XGbyQAfn; arc=none smtp.client-ip=217.70.183.195 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="XGbyQAfn" Received: by mail.gandi.net (Postfix) with ESMTPSA id 737936000D; Thu, 19 Dec 2024 16:21:48 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1734625309; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=CAwdN6gi/D4quCoE23KgD7Buo4fvppT/guEfYAfj/VU=; b=XGbyQAfnl1Jvk32RYw/qh9EJfcsgDdw62ckrUaLXEPHhsU6djqxONqQ7rKZinvxdItFpwf +l4KGLX1WYkcL2rhIqLj23G45Prp8GPZK8Mg6xUAjAwyFq8d0D6bfJa4ZkCMVWQrHo/DDS g74OyXM5lyNAjuejIqftzccETH0ikSoe6iIPzCLqOabYXLvaOiaQy5ePZtRlxHLUbAjBin uWPzRB21A5VvInR6oYYj1fsiCxToPKVVyyfPjG4yFPjfzIiwsPVGsOE4XU/Ay6B0wlFnPL fZHQOxWDjjzR0j2FeXszy8pO0dMDlHA2tVSYOrrx3DmqdT+SHvUrGGGSd6K6oQ== From: Mathieu Dubois-Briand Date: Thu, 19 Dec 2024 17:21:18 +0100 Subject: [PATCH 1/8] dt-bindings: Add MAX7360 MFD device Precedence: bulk X-Mailing-List: linux-input@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20241219-mdb-max7360-support-v1-1-8e8317584121@bootlin.com> References: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> In-Reply-To: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> To: Lee Jones , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Kamel Bouhara , Linus Walleij , Bartosz Golaszewski , Dmitry Torokhov , =?utf-8?q?Uwe_Kleine-K=C3=B6n?= =?utf-8?q?ig?= Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-input@vger.kernel.org, linux-pwm@vger.kernel.org, =?utf-8?q?Gr=C3=A9gory_Clement?= , Thomas Petazzoni , Mathieu Dubois-Briand X-Mailer: b4 0.14.1 X-Developer-Signature: v=1; a=ed25519-sha256; t=1734625307; l=1890; i=mathieu.dubois-briand@bootlin.com; s=20241219; h=from:subject:message-id; bh=KWh36d+ljikVIIPs4N2J6PrSLdnhSOVvwQo9gjfU3sc=; b=Kstdw8fe9mjoFyo+Ucpn/uZbYYjQz58viHgIWfyK/52Sn0+K4+lMfonwYPIQrkYYlt2PNHUji Kr7eTl+ziutAQrYqcL/YXTOLXVO3mDJ43KHQ0A/DWxbsOhoFrOzIftC X-Developer-Key: i=mathieu.dubois-briand@bootlin.com; a=ed25519; pk=1PVTmzPXfKvDwcPUzG0aqdGoKZJA3b9s+3DqRlm0Lww= X-GND-Sasl: mathieu.dubois-briand@bootlin.com Add device tree bindings for Maxim Integrated MAX7360 MFD device with support for keypad, rotary, gpios and pwm functionalities. Signed-off-by: Mathieu Dubois-Briand --- Documentation/devicetree/bindings/mfd/max7360.yaml | 56 ++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/Documentation/devicetree/bindings/mfd/max7360.yaml b/Documentation/devicetree/bindings/mfd/max7360.yaml new file mode 100644 index 000000000000..49dd437fd313 --- /dev/null +++ b/Documentation/devicetree/bindings/mfd/max7360.yaml @@ -0,0 +1,56 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/mfd/max7360.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Maxim MAX7360 Keypad, Rotary encoder, PWM and GPIO controller + +maintainers: + - Kamel Bouhara + - Mathieu Dubois-Briand + +description: | + Maxim MAX7360 MFD device, with following functions: + - keypad controller + - rotary controller + - GPIO and GPO controller + - PWM controller + + https://www.analog.com/en/products/max7360.html + +properties: + compatible: + enum: + - maxim,max7360 + + reg: + maxItems: 1 + + interrupts: + description: The interrupt line the device is connected to. + maxItems: 1 + +required: + - compatible + - reg + - interrupts + +unevaluatedProperties: false + +examples: + - | + #include + + i2c { + #address-cells = <1>; + #size-cells = <0>; + + max7360@38 { + compatible = "maxim,max7360"; + reg = <0x38>; + + interrupt-parent = <&gpio1>; + interrupts = <23 IRQ_TYPE_LEVEL_LOW>; + }; + }; From patchwork Thu Dec 19 16:21:19 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Dubois-Briand X-Patchwork-Id: 852605 Received: from relay3-d.mail.gandi.net (relay3-d.mail.gandi.net [217.70.183.195]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 76685226172; Thu, 19 Dec 2024 16:21:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.195 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625320; cv=none; b=bZ0pBv2OhBvW8rLTsuvIl0gbdWfxIZhzXJzDg3/nMgAOR//4ug7eKm8dTzV5rsXAWpQHUbwkWiDP8SKxvKZQQMCwejFk9mduYdxnGnEJFmTmOmi5XlkCeIsILul2C3MlTvq8bfkQ8+YaSnPEv15jpxxP0luzM27x/sFegUgTmm4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625320; c=relaxed/simple; bh=Qs1lXdR3k4hh5hqJDPaLH7psb2FueYZC74dIRlcG+8Q=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=KzMbVXt/fb1nGCMj/d6ARVkrqX9lPng5tY5hpf+tHdpsALqpLkfpXd/1SEnkh0aKH2RkaHckXxT1ie1NUYdN+dDx4rrjIu2XpXT4f0nc2NTFDxcr07rWISyc/tAbA4uZW2T5WUbF0w340syWp+QLKxGBiPhRavDnNyRbaOu7h78= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=DciEccms; arc=none smtp.client-ip=217.70.183.195 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="DciEccms" Received: by mail.gandi.net (Postfix) with ESMTPSA id 418FC60009; Thu, 19 Dec 2024 16:21:49 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1734625310; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=h31lyABGlYGYdph3DUXih1SNot88N+ffTqw66rva9/s=; b=DciEccms/7F/3YzSdPpzpcuxkpEfz0t2W4m9Y7mx4CT2YPYwzHnktZzNXfBjNz21CWGz/u LQ2CtQtXFcdXgrSXgdOHJRV9sgEplUCE/5o8FNTMvIpXRPDLfy+F6G2ihnrk11EelUpn6O f9C0IyVFPYYEbEtet0uA2FOcwEN/vMX/97RCiG8SgVUpG2M9PurtZcPomwe/iMHCvxUp6x wwxa0XPKBoageV6zMe1VcHzY1o6qrUSobHpf7fFY1an/ZKRwyTM6evGNCAbJ8Xj5O1uihE zU7Icj+c98YK1GIlKSXnhuRYXFLm2+fPUsiD0nLHnOCedRBtoF2rEiEHhJJAQg== From: Mathieu Dubois-Briand Date: Thu, 19 Dec 2024 17:21:19 +0100 Subject: [PATCH 2/8] dt-bindings: Add MAX7360 subdevices Precedence: bulk X-Mailing-List: linux-input@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20241219-mdb-max7360-support-v1-2-8e8317584121@bootlin.com> References: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> In-Reply-To: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> To: Lee Jones , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Kamel Bouhara , Linus Walleij , Bartosz Golaszewski , Dmitry Torokhov , =?utf-8?q?Uwe_Kleine-K=C3=B6n?= =?utf-8?q?ig?= Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-input@vger.kernel.org, linux-pwm@vger.kernel.org, =?utf-8?q?Gr=C3=A9gory_Clement?= , Thomas Petazzoni , Mathieu Dubois-Briand X-Mailer: b4 0.14.1 X-Developer-Signature: v=1; a=ed25519-sha256; t=1734625307; l=7491; i=mathieu.dubois-briand@bootlin.com; s=20241219; h=from:subject:message-id; bh=Qs1lXdR3k4hh5hqJDPaLH7psb2FueYZC74dIRlcG+8Q=; b=tSuhYavHF7GT3CZ1THiMbRIustPw4CMj9MIV/4fHTCqcjTqobpVHSEJWUoGMUNQLZBXd5vi6l gRNCp945UCFBxthmnr2hvx2idlWCBo1iWzBWB6eYF27BwEg48u/clSL X-Developer-Key: i=mathieu.dubois-briand@bootlin.com; a=ed25519; pk=1PVTmzPXfKvDwcPUzG0aqdGoKZJA3b9s+3DqRlm0Lww= X-GND-Sasl: mathieu.dubois-briand@bootlin.com Add device tree bindings for Maxim Integrated MAX7360 MFD functions: keypad, rotary, gpios and pwm. Signed-off-by: Mathieu Dubois-Briand --- .../devicetree/bindings/gpio/max7360-gpio.yaml | 96 ++++++++++++++++++++++ .../devicetree/bindings/input/max7360-keypad.yaml | 67 +++++++++++++++ .../devicetree/bindings/input/max7360-rotary.yaml | 52 ++++++++++++ .../devicetree/bindings/pwm/max7360-pwm.yaml | 35 ++++++++ 4 files changed, 250 insertions(+) diff --git a/Documentation/devicetree/bindings/gpio/max7360-gpio.yaml b/Documentation/devicetree/bindings/gpio/max7360-gpio.yaml new file mode 100644 index 000000000000..3c006dc0380b --- /dev/null +++ b/Documentation/devicetree/bindings/gpio/max7360-gpio.yaml @@ -0,0 +1,96 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/gpio/max7360-gpio.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Maxim MAX7360 GPIO controller + +maintainers: + - Kamel Bouhara + - Mathieu Dubois-Briand + +description: | + Maxim MAX7360 GPIO controller, in MAX7360 MFD + https://www.analog.com/en/products/max7360.html + +properties: + compatible: + enum: + - maxim,max7360-gpio + - maxim,max7360-gpo + + gpio-controller: true + + "#gpio-cells": + const: 2 + + ngpios: + minimum: 0 + maximum: 8 + + interrupt-controller: true + + "#interrupt-cells": + const: 2 + + interrupts: + description: The interrupt line the device is connected to. + maxItems: 1 + + constant-current-disable: + $ref: /schemas/types.yaml#/definitions/uint32 + description: Bit field, each bit disables constant-current output of the + associated GPIO. + + +required: + - compatible + - gpio-controller + - ngpios + +if: + properties: + compatible: + contains: + enum: + - maxim,max7360-gpio +then: + required: + - interrupt-controller + - interrupts +else: + properties: + interrupt-controller: false + interrupts: false + constant-current-disable: false + + ngpios: + maximum: 6 + +additionalProperties: false + +examples: + - | + #include + + max7360_gpo: max7360_gpo { + compatible = "maxim,max7360-gpo"; + gpio-controller; + #gpio-cells = <0x2>; + ngpios = <4>; + }; + + max7360_gpio: max7360_gpio { + compatible = "maxim,max7360-gpio"; + + gpio-controller; + #gpio-cells = <0x2>; + ngpios = <8>; + constant-current-disable = <0x06>; + + interrupt-controller; + #interrupt-cells = <0x2>; + interrupt-parent = <&gpio1>; + interrupts = <23 IRQ_TYPE_LEVEL_LOW>; + }; diff --git a/Documentation/devicetree/bindings/input/max7360-keypad.yaml b/Documentation/devicetree/bindings/input/max7360-keypad.yaml new file mode 100644 index 000000000000..8bc3c841465b --- /dev/null +++ b/Documentation/devicetree/bindings/input/max7360-keypad.yaml @@ -0,0 +1,67 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/input/max7360-keypad.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Maxim MAX7360 Keypad Controller + +maintainers: + - Mathieu Dubois-Briand + +description: | + Maxim MAX7360 Keypad Controller, in MAX7360 MFD + https://www.analog.com/en/products/max7360.html + +allOf: + - $ref: matrix-keymap.yaml# + - $ref: input.yaml# + +properties: + compatible: + enum: + - maxim,max7360-keypad + + interrupts: + description: The interrupt line the device is connected to. + maxItems: 1 + + debounce-delay-ms: + description: Debounce delay in ms + minimum: 9 + maximum: 40 + default: 9 + + linux,input-no-autorepeat: + description: If present, the keys will not autorepeat when pressed + +required: + - compatible + - interrupts + - linux,keymap + +unevaluatedProperties: false + +examples: + - | + #include + #include + + max7360_keypad { + compatible = "maxim,max7360-keypad"; + + keypad,num-rows = <8>; + keypad,num-columns = <4>; + + linux,keymap = < + MATRIX_KEY(0x00, 0x00, KEY_F5) + MATRIX_KEY(0x01, 0x00, KEY_F4) + MATRIX_KEY(0x02, 0x01, KEY_F6) + >; + + interrupt-parent = <&gpio1>; + interrupts = <23 IRQ_TYPE_LEVEL_LOW>; + + debounce-delay-ms = <10>; + linux,input-no-autorepeat; + }; diff --git a/Documentation/devicetree/bindings/input/max7360-rotary.yaml b/Documentation/devicetree/bindings/input/max7360-rotary.yaml new file mode 100644 index 000000000000..19afa8344249 --- /dev/null +++ b/Documentation/devicetree/bindings/input/max7360-rotary.yaml @@ -0,0 +1,52 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/input/max7360-rotary.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Maxim MAX7360 Rotary Encoder + +maintainers: + - Mathieu Dubois-Briand + +description: | + Maxim MAX7360 Rotary Encoder, in MAX7360 MFD + https://www.analog.com/en/products/max7360.html + +properties: + compatible: + enum: + - maxim,max7360-rotary + + interrupts: + description: The interrupt line the device is connected to. + maxItems: 1 + + debounce-delay-ms: + description: Debounce delay in ms + minimum: 0 + maximum: 15 + default: 0 + + linux,axis: + description: The input subsystem axis to map to this rotary encoder. + +required: + - compatible + - interrupts + +additionalProperties: false + +examples: + - | + #include + + max7360_rotary: max7360_rotary { + compatible = "maxim,max7360-rotary"; + + debounce-delay-ms = <2>; + linux,axis = <0>; /* REL_X */ + + interrupt-parent = <&gpio1>; + interrupts = <23 IRQ_TYPE_LEVEL_LOW>; + }; diff --git a/Documentation/devicetree/bindings/pwm/max7360-pwm.yaml b/Documentation/devicetree/bindings/pwm/max7360-pwm.yaml new file mode 100644 index 000000000000..68d48969e542 --- /dev/null +++ b/Documentation/devicetree/bindings/pwm/max7360-pwm.yaml @@ -0,0 +1,35 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/pwm/max7360-pwm.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Maxim MAX7360 PWM controller + +maintainers: + - Kamel Bouhara + +description: | + Maxim MAX7360 PWM controller, in MAX7360 MFD + https://www.analog.com/en/products/max7360.html + +properties: + compatible: + enum: + - maxim,max7360-pwm + + "#pwm-cells": + const: 2 + + +required: + - compatible + +additionalProperties: false + +examples: + - | + max7360_pwm: max7360_pwm { + compatible = "maxim,max7360-pwm"; + #pwm-cells = <2>; + }; From patchwork Thu Dec 19 16:21:20 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Dubois-Briand X-Patchwork-Id: 852604 Received: from relay3-d.mail.gandi.net (relay3-d.mail.gandi.net [217.70.183.195]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 60D0B22654A; Thu, 19 Dec 2024 16:21:58 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.195 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625321; cv=none; b=T4bHTohuKQhgHAXTYF42zkdrD0tue7AC63H+V8grdgtOAF5ZXMZHJyx73syGqgeEfnmRCkMOiiVDC4uTW2JxkuCwCLmiLvuooiGATwgGtS4CrkoOHlXzdsL2nRrCIYcjuPtjqh0ODB22HxXKyW/vMM+qyrMIMQI7WbBRZotYmig= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625321; c=relaxed/simple; bh=PybKAU+3vbndizy2H1sa0Lwsq0GbIx6ABnD6dcyNxWQ=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Y6/eghu4LNOjAzGGqZxJ6UbsMmfmN8t93Xb2UNmLAjblVhKi17+JM4TFei8Uf1r9S2RqDIhLvLFdacuFr9HcEpxwEozZ9U5cJUhdMlE+t/4ON13YM6Fe9BicwoYd5wVja6UiE70rCFXLTJMzedo7eN7QznwrIv81XoZz5O8wIvU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=VnR/ugfn; arc=none smtp.client-ip=217.70.183.195 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="VnR/ugfn" Received: by mail.gandi.net (Postfix) with ESMTPSA id 17CC860003; Thu, 19 Dec 2024 16:21:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1734625310; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=wfUnDdooPof7eT/RduRzy7XQjBZM7wassZexFE60gSM=; b=VnR/ugfn6rN534C0YR0r/IHcaaSBv/jjSiB9bRIs59IeKXwhQL1jLpFNXB6bpeN+t6QyoJ x3DIv/8mqQaP0145EOE76Nq+GCT6SjIft5r6F91veMA5BpaRGkW4+ceBjEZGIE5wGuJrIe wceRxdKeFl8AbiGOgBf5daiiWtJri+JIq7EZ8idY9WbocJRZ6uSTHghecWlSSTfl8GYV6h qqECafGYc4tZz3utgf11ZWyXrOQuk0Br5ghqbt5Dnjc2w+LV4x4x/7yCj7csRUQcM22o/1 bA1qW9KkMFAoMHdo5cWRWY5mzWqSyPcKkUzXBAPzRU37d3Yw7hPKhD/kL/305g== From: mathieu.dubois-briand@bootlin.com Date: Thu, 19 Dec 2024 17:21:20 +0100 Subject: [PATCH 3/8] mfd: Add max7360 support Precedence: bulk X-Mailing-List: linux-input@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20241219-mdb-max7360-support-v1-3-8e8317584121@bootlin.com> References: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> In-Reply-To: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> To: Lee Jones , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Kamel Bouhara , Linus Walleij , Bartosz Golaszewski , Dmitry Torokhov , =?utf-8?q?Uwe_Kleine-K=C3=B6n?= =?utf-8?q?ig?= Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-input@vger.kernel.org, linux-pwm@vger.kernel.org, =?utf-8?q?Gr=C3=A9gory_Clement?= , Thomas Petazzoni , Mathieu Dubois-Briand X-Mailer: b4 0.14.1 X-Developer-Signature: v=1; a=ed25519-sha256; t=1734625307; l=13201; i=mathieu.dubois-briand@bootlin.com; s=20241219; h=from:subject:message-id; bh=doolHWPKXd7dXbLUCc0fkQ10pFTbxLhiIJPiEIXe1XE=; b=CUq0LgiAqO+36IuT9iQg8SzXZfxk5jm07J1sTSeTg1KF54oSIEoeNsvm53AhLWCA1rQxTIxx9 sIKnzWw++8nBJ0vzGvMR/vZN9A+l82N8KLZTq1ydmbEoeJbmktp6rpr X-Developer-Key: i=mathieu.dubois-briand@bootlin.com; a=ed25519; pk=1PVTmzPXfKvDwcPUzG0aqdGoKZJA3b9s+3DqRlm0Lww= X-GND-Sasl: mathieu.dubois-briand@bootlin.com From: Kamel Bouhara Add core driver to support MAX7360 i2c chip, multi function device with keypad, gpio, pwm, gpo and rotary encoder submodules. Signed-off-by: Kamel Bouhara Co-developed-by: Mathieu Dubois-Briand Signed-off-by: Mathieu Dubois-Briand --- drivers/mfd/Kconfig | 12 ++ drivers/mfd/Makefile | 1 + drivers/mfd/max7360.c | 302 ++++++++++++++++++++++++++++++++++++++++++++ include/linux/mfd/max7360.h | 103 +++++++++++++++ 4 files changed, 418 insertions(+) diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig index ae23b317a64e..c1ddda480922 100644 --- a/drivers/mfd/Kconfig +++ b/drivers/mfd/Kconfig @@ -2414,5 +2414,17 @@ config MFD_RSMU_SPI Additional drivers must be enabled in order to use the functionality of the device. +config MFD_MAX7360 + tristate "Maxim MAX7360 Support" + depends on I2C + select MFD_CORE + select REGMAP_I2C + select REGMAP_IRQ + help + Say yes here to add support for Maxim MAX7360. + This driver provides common support for accessing + the device; additional drivers must be enabled in + order to use the functionality of the device. + endmenu endif diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile index e057d6d6faef..6cd55504106d 100644 --- a/drivers/mfd/Makefile +++ b/drivers/mfd/Makefile @@ -163,6 +163,7 @@ obj-$(CONFIG_MFD_DA9063) += da9063.o obj-$(CONFIG_MFD_DA9150) += da9150-core.o obj-$(CONFIG_MFD_MAX14577) += max14577.o +obj-$(CONFIG_MFD_MAX7360) += max7360.o obj-$(CONFIG_MFD_MAX77541) += max77541.o obj-$(CONFIG_MFD_MAX77620) += max77620.o obj-$(CONFIG_MFD_MAX77650) += max77650.o diff --git a/drivers/mfd/max7360.c b/drivers/mfd/max7360.c new file mode 100644 index 000000000000..c53b42f00a9d --- /dev/null +++ b/drivers/mfd/max7360.c @@ -0,0 +1,302 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Maxim MAX7360 Core Driver + * + * Copyright (C) 2024 Kamel Bouhara + * Author: Kamel Bouhara + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +static DEFINE_SPINLOCK(request_lock); + +struct max7360_mfd { + struct regmap *regmap; + unsigned int requested_ports; + struct device *dev; +}; + +#define GPO_COMPATIBLE "maxim,max7360-gpo" +#define KEYPAD_COMPATIBLE "maxim,max7360-keypad" + +static const struct mfd_cell max7360_cells[] = { + { + .name = "max7360-pwm", + .of_compatible = "maxim,max7360-pwm", + }, + { + .name = "max7360-gpo", + .of_compatible = GPO_COMPATIBLE, + }, + { + .name = "max7360-gpio", + .of_compatible = "maxim,max7360-gpio", + }, + { + .name = "max7360-keypad", + .of_compatible = KEYPAD_COMPATIBLE, + }, + { + .name = "max7360-rotary", + .of_compatible = "maxim,max7360-rotary", + }, +}; + +const struct regmap_range max7360_volatile_ranges[] = { + { + .range_min = MAX7360_REG_KEYFIFO, + .range_max = MAX7360_REG_KEYFIFO, + }, { + .range_min = 0x48, + .range_max = 0x4a, + }, +}; + +static const struct regmap_access_table max7360_volatile_table = { + .yes_ranges = max7360_volatile_ranges, + .n_yes_ranges = ARRAY_SIZE(max7360_volatile_ranges), +}; + +static const struct regmap_config max7360_regmap_config = { + .reg_bits = 8, + .val_bits = 8, + .max_register = 0xff, + .volatile_table = &max7360_volatile_table, + .cache_type = REGCACHE_RBTREE, +}; + +static int max7360_set_gpos_count(struct max7360_mfd *max7360_mfd) +{ + /* + * Max7360 COL0 to COL7 pins can be used either as keypad columns, + * general purpose output or a mix of both. + * Get the number of pins requested by the corresponding drivers, ensure + * they are compatible with each others and apply the corresponding + * configuration. + */ + struct device_node *np; + u32 gpos = 0; + u32 columns = 0; + unsigned int val; + int ret; + + np = of_get_compatible_child(max7360_mfd->dev->of_node, GPO_COMPATIBLE); + if (np) { + ret = of_property_read_u32(np, "ngpios", &gpos); + if (ret < 0) { + dev_err(max7360_mfd->dev, "Failed to read gpos count\n"); + return ret; + } + } + + np = of_get_compatible_child(max7360_mfd->dev->of_node, + KEYPAD_COMPATIBLE); + if (np) { + ret = of_property_read_u32(np, "keypad,num-columns", &columns); + if (ret < 0) { + dev_err(max7360_mfd->dev, "Failed to read columns count\n"); + return ret; + } + } + + if (gpos > MAX7360_MAX_GPO || + (gpos + columns > MAX7360_MAX_KEY_COLS)) { + dev_err(max7360_mfd->dev, + "Incompatible gpos and columns count (%u, %u)\n", + gpos, columns); + return -EINVAL; + } + + /* + * MAX7360_REG_DEBOUNCE contains configuration both for keypad debounce + * timings and gpos/keypad columns repartition. Only the later is + * modified here. + */ + val = FIELD_PREP(MAX7360_PORTS, gpos); + ret = regmap_write_bits(max7360_mfd->regmap, MAX7360_REG_DEBOUNCE, + MAX7360_PORTS, val); + if (ret) { + dev_err(max7360_mfd->dev, + "Failed to write max7360 columns/gpos configuration"); + return ret; + } + + return 0; +} + +int max7360_port_pin_request(struct device *dev, unsigned int pin, bool request) +{ + struct i2c_client *client; + struct max7360_mfd *max7360_mfd; + unsigned long flags; + int ret = 0; + + client = to_i2c_client(dev); + max7360_mfd = i2c_get_clientdata(client); + + spin_lock_irqsave(&request_lock, flags); + if (request) { + if (max7360_mfd->requested_ports & BIT(pin)) + ret = -EBUSY; + else + max7360_mfd->requested_ports |= BIT(pin); + } else { + max7360_mfd->requested_ports &= ~BIT(pin); + } + spin_unlock_irqrestore(&request_lock, flags); + + return ret; +} +EXPORT_SYMBOL_GPL(max7360_port_pin_request); + +static int max7360_mask_irqs(struct max7360_mfd *max7360_mfd) +{ + unsigned int i; + unsigned int val; + int ret; + + /* + * GPIO/PWM interrupts are not masked on reset: mask the during probe, + * avoiding repeated spurious interrupts if the corresponding drivers + * are not present. + */ + for (i = 0; i < MAX7360_PORT_PWM_COUNT; i++) { + ret = regmap_write_bits(max7360_mfd->regmap, + MAX7360_REG_PWMCFG + i, + MAX7360_PORT_CFG_INTERRUPT_MASK, + MAX7360_PORT_CFG_INTERRUPT_MASK); + if (ret) { + dev_err(max7360_mfd->dev, + "failed to write max7360 port configuration"); + return ret; + } + } + + /* Read gpio in register, to ack any pending IRQ. + */ + ret = regmap_read(max7360_mfd->regmap, MAX7360_REG_GPIOIN, &val); + if (ret) { + dev_err(max7360_mfd->dev, "Failed to read gpio values: %d\n", + ret); + return ret; + } + + return 0; +} + +static int max7360_reset(struct max7360_mfd *max7360_mfd) +{ + int err; + + /* + * Set back the default values. + * We do not use GPIO reset function here, as it does not work reliably. + */ + err = regmap_write(max7360_mfd->regmap, MAX7360_REG_GPIODEB, 0x00); + if (err) { + dev_err(max7360_mfd->dev, "Failed to set configuration\n"); + return err; + } + + err = regmap_write(max7360_mfd->regmap, MAX7360_REG_GPIOCURR, MAX7360_REG_GPIOCURR_FIXED); + if (err) { + dev_err(max7360_mfd->dev, "Failed to set configuration\n"); + return err; + } + + err = regmap_write(max7360_mfd->regmap, MAX7360_REG_GPIOOUTM, 0x00); + if (err) { + dev_err(max7360_mfd->dev, "Failed to set configuration\n"); + return err; + } + + err = regmap_write(max7360_mfd->regmap, MAX7360_REG_PWMCOM, 0x00); + if (err) { + dev_err(max7360_mfd->dev, "Failed to set configuration\n"); + return err; + } + + err = regmap_write(max7360_mfd->regmap, MAX7360_REG_SLEEP, 0); + if (err) { + dev_err(max7360_mfd->dev, "Failed to set configuration\n"); + return err; + } + + return 0; +} + +static int max7360_probe(struct i2c_client *client) +{ + struct device *dev = &client->dev; + struct regmap *regmap; + struct max7360_mfd *max7360_mfd; + int err; + + regmap = devm_regmap_init_i2c(client, &max7360_regmap_config); + if (IS_ERR(regmap)) + return dev_err_probe(dev, PTR_ERR(regmap), + "Failed to initialise regmap\n"); + + max7360_mfd = devm_kzalloc(dev, sizeof(*max7360_mfd), GFP_KERNEL); + if (!max7360_mfd) + return -ENOMEM; + + max7360_mfd->regmap = regmap; + max7360_mfd->dev = dev; + i2c_set_clientdata(client, max7360_mfd); + + err = max7360_reset(max7360_mfd); + if (err) + return dev_err_probe(dev, err, "Failed to reset device\n"); + + err = max7360_set_gpos_count(max7360_mfd); + if (err) + return dev_err_probe(dev, err, "Failed to set GPOS pin count\n"); + + /* + * Get the device out of shutdown mode. + */ + err = regmap_write_bits(regmap, MAX7360_REG_GPIOCFG, + MAX7360_GPIO_CFG_GPIO_EN, + MAX7360_GPIO_CFG_GPIO_EN); + if (err) + return dev_err_probe(dev, err, "Failed to set device out of shutdown\n"); + + err = max7360_mask_irqs(max7360_mfd); + if (err) + return dev_err_probe(dev, err, "could not mask interrupts\n"); + + err = devm_mfd_add_devices(dev, PLATFORM_DEVID_NONE, + max7360_cells, ARRAY_SIZE(max7360_cells), + NULL, 0, NULL); + if (err) + return dev_err_probe(dev, err, "Failed to register child devices\n"); + + return 0; +} + +static const struct of_device_id max7360_dt_match[] = { + { .compatible = "maxim,max7360" }, + {}, +}; +MODULE_DEVICE_TABLE(of, max7360_dt_match); + +static struct i2c_driver max7360_driver = { + .driver = { + .name = "max7360", + .of_match_table = max7360_dt_match, + }, + .probe = max7360_probe, +}; +module_i2c_driver(max7360_driver); + +MODULE_DESCRIPTION("Maxim MAX7360 MFD core driver"); +MODULE_AUTHOR("Kamel Bouhara "); +MODULE_LICENSE("GPL"); diff --git a/include/linux/mfd/max7360.h b/include/linux/mfd/max7360.h new file mode 100644 index 000000000000..2b77110acd80 --- /dev/null +++ b/include/linux/mfd/max7360.h @@ -0,0 +1,103 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef __LINUX_MFD_MAX7360_H +#define __LINUX_MFD_MAX7360_H +#include +#include + +#define MAX7360_MAX_KEY_ROWS 8 +#define MAX7360_MAX_KEY_COLS 8 +#define MAX7360_MAX_KEY_NUM (MAX7360_MAX_KEY_ROWS * MAX7360_MAX_KEY_COLS) +#define MAX7360_ROW_SHIFT 3 + +#define MAX7360_MAX_GPIO 8 +#define MAX7360_MAX_GPO 6 +#define MAX7360_PORT_PWM_COUNT 8 +#define MAX7360_PORT_RTR_PIN (MAX7360_PORT_PWM_COUNT - 1) +/* + * MAX7360 registers + */ +#define MAX7360_REG_KEYFIFO 0x00 +#define MAX7360_REG_CONFIG 0x01 +#define MAX7360_REG_DEBOUNCE 0x02 +#define MAX7360_REG_INTERRUPT 0x03 +#define MAX7360_REG_PORTS 0x04 +#define MAX7360_REG_KEYREP 0x05 +#define MAX7360_REG_SLEEP 0x06 + +/* + * MAX7360 registers + */ +#define MAX7360_REG_GPIOCFG 0x40 +#define MAX7360_REG_GPIOCTRL 0x41 +#define MAX7360_REG_GPIODEB 0x42 +#define MAX7360_REG_GPIOCURR 0x43 +#define MAX7360_REG_GPIOOUTM 0x44 +#define MAX7360_REG_PWMCOM 0x45 +#define MAX7360_REG_RTRCFG 0x46 +#define MAX7360_REG_GPIOIN 0x49 +#define MAX7360_REG_RTR_CNT 0x4A +#define MAX7360_REG_PWMBASE 0x50 +#define MAX7360_REG_PWMCFG 0x58 + +#define MAX7360_REG_PORTCFGBASE 0x58 + +/* + * Configuration register bits + */ +#define MAX7360_FIFO_EMPTY 0x3f +#define MAX7360_FIFO_OVERFLOW 0x7f +#define MAX7360_FIFO_RELEASE BIT(6) +#define MAX7360_FIFO_COL GENMASK(5, 3) +#define MAX7360_FIFO_ROW GENMASK(2, 0) + +#define MAX7360_CFG_SLEEP BIT(7) +#define MAX7360_CFG_INTERRUPT BIT(5) +#define MAX7360_CFG_KEY_RELEASE BIT(3) +#define MAX7360_CFG_WAKEUP BIT(1) +#define MAX7360_CFG_TIMEOUT BIT(0) + +#define MAX7360_DEBOUNCE GENMASK(4, 0) +#define MAX7360_DEBOUNCE_MIN 9 +#define MAX7360_DEBOUNCE_MAX 40 +#define MAX7360_PORTS GENMASK(8, 5) + +#define MAX7360_INTERRUPT_TIME_MASK GENMASK(4, 0) +#define MAX7360_INTERRUPT_FIFO_MASK GENMASK(7, 5) + +#define MAX7360_PORT_CFG_INTERRUPT_MASK BIT(7) +#define MAX7360_PORT_CFG_INTERRUPT_EDGES BIT(6) + +#define MAX7360_REG_GPIOCURR_FIXED 0xC0 + +/* + * Autosleep register values (ms) + */ +#define MAX7360_AUTOSLEEP_8192 0x01 +#define MAX7360_AUTOSLEEP_4096 0x02 +#define MAX7360_AUTOSLEEP_2048 0x03 +#define MAX7360_AUTOSLEEP_1024 0x04 +#define MAX7360_AUTOSLEEP_512 0x05 +#define MAX7360_AUTOSLEEP_256 0x06 + +#define MAX7360_GPIO_CFG_RTR_EN BIT(7) +#define MAX7360_GPIO_CFG_GPIO_EN BIT(4) +#define MAX7360_GPIO_CFG_GPIO_RST BIT(3) + +#define MAX7360_ROT_DEBOUNCE GENMASK(3, 0) +#define MAX7360_ROT_DEBOUNCE_MIN 0 +#define MAX7360_ROT_DEBOUNCE_MAX 15 +#define MAX7360_ROT_INTCNT GENMASK(6, 4) +#define MAX7360_ROT_INTCNT_DLY BIT(7) + +#define MAX7360_INT_INTI 0 +#define MAX7360_INT_INTK 1 + +#define MAX7360_INT_GPIO 0 +#define MAX7360_INT_KEYPAD 1 +#define MAX7360_INT_ROTARY 2 + +#define MAX7360_NR_INTERNAL_IRQS 3 + +int max7360_port_pin_request(struct device *dev, unsigned int pin, bool request); + +#endif From patchwork Thu Dec 19 16:21:21 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Dubois-Briand X-Patchwork-Id: 852186 Received: from relay3-d.mail.gandi.net (relay3-d.mail.gandi.net [217.70.183.195]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 62C0E226551; Thu, 19 Dec 2024 16:21:58 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.195 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625321; cv=none; b=ULd1ZQQSczXtc3JZvQQAaiCktDh+sPmJqfcOEIbv2xg4nxWRzelq98JqqE802nI9MG56Pv4nXv/5mLRyWpPAPns92mlt555H8udxfDVzoUs+20ZgAYuhomq7BMXFY7C1Rhlv0eo9vWR94mrWjJH4jvrqpennbsgiccIpPUwQAYk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625321; c=relaxed/simple; bh=j/ZH98b7v/Dl8/WqhzlTaqw670w2ll3yf24VM/OuYrs=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Cq/mYr6vo15iqCikoKtLqnO1u1rJBJYqY1rn7MnzeoHsCgexlDJXv4MogOLQDFEISIuNY7VAsmh4XMB5BURW7E/u6zQekuXMYncI3e92YQSxfzUWIOYulxPP95dj/NNl/NQSJQy85zEOicfvJr2kwNdY7VQH12kGdUZ4GQYBp9c= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=ZlxOxTOY; arc=none smtp.client-ip=217.70.183.195 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="ZlxOxTOY" Received: by mail.gandi.net (Postfix) with ESMTPSA id D2B296000A; Thu, 19 Dec 2024 16:21:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1734625311; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=75o1demuGRTQhL28lBh4mm+iaPhJKlrwWjt0l8twc0g=; b=ZlxOxTOYBJ+kW5qF1ZulXGR+GdkMf6iBqgKZxrjeW3NP71CR0QIowqF3EBQLuQrzvdz41R ZjfOpJvLxc9Yut/4z+Uq4yonsD2NizlRBbTBX9lOHBxb5XYiCqVRRSAcjcOqPYZLHKK3cR OI4n7oHea/hpqm3k8ZOr/YNv6Li3fPwzH+cskSGHwdWSEv0feSHKysbCqwIw40/Wt55Qgr PSmjWYMmeose2sC3k4mdY1WBcUTDyAHGEaj2hXoqsyJw9PH9p0/kGR+AsNrSwlEgwnKBty zToqi0lgAuLJ9/uME2t19vCBHlJeTJvutlxU0ts/GzliTQGpdimy+EuXI9ZqSg== From: mathieu.dubois-briand@bootlin.com Date: Thu, 19 Dec 2024 17:21:21 +0100 Subject: [PATCH 4/8] pwm: max7360: Add MAX7360 PWM support Precedence: bulk X-Mailing-List: linux-input@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20241219-mdb-max7360-support-v1-4-8e8317584121@bootlin.com> References: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> In-Reply-To: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> To: Lee Jones , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Kamel Bouhara , Linus Walleij , Bartosz Golaszewski , Dmitry Torokhov , =?utf-8?q?Uwe_Kleine-K=C3=B6n?= =?utf-8?q?ig?= Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-input@vger.kernel.org, linux-pwm@vger.kernel.org, =?utf-8?q?Gr=C3=A9gory_Clement?= , Thomas Petazzoni , Mathieu Dubois-Briand X-Mailer: b4 0.14.1 X-Developer-Signature: v=1; a=ed25519-sha256; t=1734625307; l=6535; i=mathieu.dubois-briand@bootlin.com; s=20241219; h=from:subject:message-id; bh=5JoN1j4Oackj65AqCNXP+34lE11Fh2kGLi9vl055Ecg=; b=Zbj0Zy9H9aJSPuFT5R3WeTcyln/ZpWn2Z8yyN8UBytSU7vsh4LqFLWN4h0ocIeQrhW2n63lOz 0duXmoXK0kGDLR19nMQlRMnmsSjHs6K2vhwpU+cW06ZhlwljE08gux/ X-Developer-Key: i=mathieu.dubois-briand@bootlin.com; a=ed25519; pk=1PVTmzPXfKvDwcPUzG0aqdGoKZJA3b9s+3DqRlm0Lww= X-GND-Sasl: mathieu.dubois-briand@bootlin.com From: Kamel Bouhara Add driver for Maxim Integrated MAX7360 PWM controller, supporting up to 8 independent PWM outputs. Signed-off-by: Kamel Bouhara Signed-off-by: Mathieu Dubois-Briand --- drivers/pwm/Kconfig | 11 +++ drivers/pwm/Makefile | 1 + drivers/pwm/pwm-max7360.c | 173 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 185 insertions(+) diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig index 0915c1e7df16..399dc3f76e92 100644 --- a/drivers/pwm/Kconfig +++ b/drivers/pwm/Kconfig @@ -745,4 +745,15 @@ config PWM_XILINX To compile this driver as a module, choose M here: the module will be called pwm-xilinx. +config PWM_MAX7360 + tristate "MAX7360 PWMs" + depends on MFD_MAX7360 + depends on OF_GPIO + help + PWM driver for Maxim Integrated MAX7360 multifunction device, with + support for up to 8 PWM outputs. + + To compile this driver as a module, choose M here: the module + will be called pwm-max7360. + endif diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile index 9081e0c0e9e0..ae8908ffc892 100644 --- a/drivers/pwm/Makefile +++ b/drivers/pwm/Makefile @@ -36,6 +36,7 @@ obj-$(CONFIG_PWM_LPC32XX) += pwm-lpc32xx.o obj-$(CONFIG_PWM_LPSS) += pwm-lpss.o obj-$(CONFIG_PWM_LPSS_PCI) += pwm-lpss-pci.o obj-$(CONFIG_PWM_LPSS_PLATFORM) += pwm-lpss-platform.o +obj-$(CONFIG_PWM_MAX7360) += pwm-max7360.o obj-$(CONFIG_PWM_MESON) += pwm-meson.o obj-$(CONFIG_PWM_MEDIATEK) += pwm-mediatek.o obj-$(CONFIG_PWM_MICROCHIP_CORE) += pwm-microchip-core.o diff --git a/drivers/pwm/pwm-max7360.c b/drivers/pwm/pwm-max7360.c new file mode 100644 index 000000000000..b1cde3e86864 --- /dev/null +++ b/drivers/pwm/pwm-max7360.c @@ -0,0 +1,173 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright 2024 Bootlin + * + * Author: Kamel BOUHARA + */ +#include +#include +#include +#include +#include +#include +#include +#include + +#define MAX7360_NUM_PWMS 8 +#define MAX7360_PWM_MAX_RES 256 +#define MAX7360_PWM_PERIOD_NS 2000000 /* 500 Hz */ +#define MAX7360_PWM_COMMON_PWN BIT(5) +#define MAX7360_PWM_CTRL_ENABLE(n) BIT(n) +#define MAX7360_PWM_PORT(n) BIT(n) + +struct max7360_pwm { + struct device *dev; + struct regmap *regmap; +}; + +static inline struct max7360_pwm *to_max7360_pwm(struct pwm_chip *chip) +{ + return pwmchip_get_drvdata(chip); +} + +static int max7360_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm) +{ + struct max7360_pwm *max7360_pwm; + int ret; + + max7360_pwm = to_max7360_pwm(chip); + ret = max7360_port_pin_request(max7360_pwm->dev->parent, pwm->hwpwm, + true); + if (ret) { + dev_err(&chip->dev, "failed to request pwm-%d\n", pwm->hwpwm); + return ret; + } + + ret = regmap_write_bits(max7360_pwm->regmap, + MAX7360_REG_PWMCFG + pwm->hwpwm, + MAX7360_PWM_COMMON_PWN, + 0); + if (ret) { + dev_err(&chip->dev, "failed to write pwm-%d cfg register, error %d\n", + pwm->hwpwm, ret); + return ret; + } + + ret = regmap_write_bits(max7360_pwm->regmap, MAX7360_REG_PORTS, + MAX7360_PWM_PORT(pwm->hwpwm), + MAX7360_PWM_PORT(pwm->hwpwm)); + if (ret) { + dev_err(&chip->dev, "failed to write pwm-%d ports register, error %d\n", + pwm->hwpwm, ret); + return ret; + } + + return 0; +} + +static void max7360_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm) +{ + struct max7360_pwm *max7360_pwm; + int ret; + + max7360_pwm = to_max7360_pwm(chip); + ret = regmap_write_bits(max7360_pwm->regmap, MAX7360_REG_GPIOCTRL, + MAX7360_PWM_CTRL_ENABLE(pwm->hwpwm), + 0); + if (ret) + dev_err(&chip->dev, "failed to enable pwm-%d , error %d\n", + pwm->hwpwm, ret); + + max7360_port_pin_request(max7360_pwm->dev->parent, pwm->hwpwm, + false); +} + +static int max7360_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, + const struct pwm_state *state) +{ + struct max7360_pwm *max7360_pwm; + u64 duty_steps = state->duty_cycle * MAX7360_PWM_MAX_RES; + int ret; + + if (state->polarity != PWM_POLARITY_NORMAL) + return -EINVAL; + + max7360_pwm = to_max7360_pwm(chip); + ret = regmap_write_bits(max7360_pwm->regmap, MAX7360_REG_GPIOCTRL, + MAX7360_PWM_CTRL_ENABLE(pwm->hwpwm), + MAX7360_PWM_CTRL_ENABLE(pwm->hwpwm)); + if (ret) { + dev_err(&chip->dev, "failed to enable pwm-%d , error %d\n", + pwm->hwpwm, ret); + return ret; + } + + do_div(duty_steps, MAX7360_PWM_PERIOD_NS); + + ret = regmap_write(max7360_pwm->regmap, MAX7360_REG_PWMBASE + pwm->hwpwm, + duty_steps >= 255 ? 255 : duty_steps); + if (ret) { + dev_err(&chip->dev, + "failed to apply pwm duty_cycle %llu on pwm-%d, error %d\n", + duty_steps, pwm->hwpwm, ret); + return ret; + } + + return 0; +} + +static const struct pwm_ops max7360_pwm_ops = { + .request = max7360_pwm_request, + .free = max7360_pwm_free, + .apply = max7360_pwm_apply, +}; + +static int max7360_pwm_probe(struct platform_device *pdev) +{ + struct max7360_pwm *max7360_pwm; + struct pwm_chip *chip; + + if (!pdev->dev.parent) { + dev_err(&pdev->dev, "no parent device\n"); + return -ENODEV; + } + + chip = devm_pwmchip_alloc(&pdev->dev, MAX7360_NUM_PWMS, + sizeof(*max7360_pwm)); + if (IS_ERR(chip)) + return PTR_ERR(chip); + chip->ops = &max7360_pwm_ops; + + max7360_pwm = to_max7360_pwm(chip); + max7360_pwm->dev = &pdev->dev; + + max7360_pwm->regmap = dev_get_regmap(pdev->dev.parent, NULL); + if (!max7360_pwm->regmap) { + dev_err(&pdev->dev, "could not get parent regmap\n"); + return -ENODEV; + } + + return devm_pwmchip_add(&pdev->dev, chip); +} + +#ifdef CONFIG_OF +static const struct of_device_id max7360_pwm_of_match[] = { + { .compatible = "maxim,max7360-pwm", }, + { } +}; +MODULE_DEVICE_TABLE(of, max7360_pwm_of_match); +#endif + +static struct platform_driver max7360_pwm_driver = { + .driver = { + .name = "max7360-pwm", + .of_match_table = of_match_ptr(max7360_pwm_of_match), + }, + .probe = max7360_pwm_probe, +}; +module_platform_driver(max7360_pwm_driver); + +MODULE_DESCRIPTION("MAX7360 PWM driver"); +MODULE_AUTHOR("Kamel BOUHARA "); +MODULE_ALIAS("platform:max7360-pwm"); +MODULE_LICENSE("GPL"); From patchwork Thu Dec 19 16:21:22 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Dubois-Briand X-Patchwork-Id: 852185 Received: from relay3-d.mail.gandi.net (relay3-d.mail.gandi.net [217.70.183.195]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4F9A9227BA2; Thu, 19 Dec 2024 16:21:58 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.195 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625322; cv=none; b=mvYxvMQDG8JHOjOZLm4B4UMyGveukJO6+2zMFNsvaD9qB17kUcelnwpvl7MVj5Z0kgUssz8B1mILVJyzIP0j4Vo9n0MD6H6or1DMSRPgccf1JQxIDrG1miGTZ/00f/3qWtc+DgA3AVpkJgdhhXi9nRrOhZEksDY8fHLgcCREEoI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625322; c=relaxed/simple; bh=NQr7/1y24/6ZrgZrS9yQ2+wyOm54wiGNzE3BDv357xA=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=EdDTwsdxv2fys+YXmyBW7ToXHXiIGfIDnKV2jBibdOe2mv6W963g4nCfk3qvcdFEOMyakgr2guB93XYY2fPL52/0kW1Oy/ppTqX4+MNl/LMA2id7FHvI4aMAos8qUZ1cSYiRT9SzZ1A+KphB+nCl3uk9Z4D13OhegkKigx+3lxE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=aGjNkYUl; arc=none smtp.client-ip=217.70.183.195 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="aGjNkYUl" Received: by mail.gandi.net (Postfix) with ESMTPSA id A082A60005; Thu, 19 Dec 2024 16:21:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1734625312; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=1LgXtiy0zJLPwlHgnZ7h6nhFoa+nJgmDbvvx+PKxYGM=; b=aGjNkYUl/FbCyStSadVWJFPGCq0HVL9BL5uLriXl/LT4ezpXVDK6HGZ+9u/NsDuFZ1YInP xYu2NyfBPg7SUhcVLcaf5fY2yDCWMAYvjZtpZnILQl/UAGsDFuYyJ5//T+X8ed5CEbE0BM A/s6JZFkAFclzTmyb+ywh30SWrNh5lWeQMW6arUdWk73tz7amrKOGmj+TbmlRfkKfTnRpU e6xOFAVGcPvoTmwFx6rqw+QCtTrzNKqFKbyMvDUae2vYbt0MrerUPNP7K8dpb6hlu50TLv njdPHwEamwd7aOSDvz6Zxd4VfyYz4VUCvwkPMCy7up0QQjsJbgJZ9lOH17DdNw== From: Mathieu Dubois-Briand Date: Thu, 19 Dec 2024 17:21:22 +0100 Subject: [PATCH 5/8] gpio: max7360: Add MAX7360 gpio support Precedence: bulk X-Mailing-List: linux-input@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20241219-mdb-max7360-support-v1-5-8e8317584121@bootlin.com> References: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> In-Reply-To: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> To: Lee Jones , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Kamel Bouhara , Linus Walleij , Bartosz Golaszewski , Dmitry Torokhov , =?utf-8?q?Uwe_Kleine-K=C3=B6n?= =?utf-8?q?ig?= Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-input@vger.kernel.org, linux-pwm@vger.kernel.org, =?utf-8?q?Gr=C3=A9gory_Clement?= , Thomas Petazzoni , Mathieu Dubois-Briand X-Mailer: b4 0.14.1 X-Developer-Signature: v=1; a=ed25519-sha256; t=1734625307; l=15098; i=mathieu.dubois-briand@bootlin.com; s=20241219; h=from:subject:message-id; bh=NQr7/1y24/6ZrgZrS9yQ2+wyOm54wiGNzE3BDv357xA=; b=k80OscpqWfwgoWX4xfpoBZ3iA2GTvMPI1N/LduZJfhga0Fe9dsMlUEQyYoHGRmBQXuHx7wunG ezPyVUWQjtuCPxBbMAndQp7mgDtyHsmUTwTz26HhZTYH20wbJysuTBU X-Developer-Key: i=mathieu.dubois-briand@bootlin.com; a=ed25519; pk=1PVTmzPXfKvDwcPUzG0aqdGoKZJA3b9s+3DqRlm0Lww= X-GND-Sasl: mathieu.dubois-briand@bootlin.com Add driver for Maxim Integrated MAX7360 GPIO/GPO controller. Two sets of GPIOs are provided by the device: - Up to 8 GPIOs, shared with the PWM and rotary encoder functionalities. These GPIOs also provide interrupts on input changes. - Up to 6 GPOs, on unused keypad columns pins. Co-developed-by: Kamel Bouhara Signed-off-by: Kamel Bouhara Signed-off-by: Mathieu Dubois-Briand --- drivers/gpio/Kconfig | 11 ++ drivers/gpio/Makefile | 1 + drivers/gpio/gpio-max7360.c | 453 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 465 insertions(+) diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index 93ee3aa092f8..efe07e21c442 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -1444,6 +1444,17 @@ config GPIO_MADERA help Support for GPIOs on Cirrus Logic Madera class codecs. +config GPIO_MAX7360 + tristate "MAX7360 GPIO support" + depends on MFD_MAX7360 + depends on OF_GPIO + help + Allows to use MAX7360 I/O Expander PWM lines as GPIO and keypad COL + lines as GPO. + + This driver can also be built as a module. If so, the module will be + called gpio-max7360. + config GPIO_MAX77620 tristate "GPIO support for PMIC MAX77620 and MAX20024" depends on MFD_MAX77620 diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile index af3ba4d81b58..581341b3e3e4 100644 --- a/drivers/gpio/Makefile +++ b/drivers/gpio/Makefile @@ -100,6 +100,7 @@ obj-$(CONFIG_GPIO_MAX7300) += gpio-max7300.o obj-$(CONFIG_GPIO_MAX7301) += gpio-max7301.o obj-$(CONFIG_GPIO_MAX730X) += gpio-max730x.o obj-$(CONFIG_GPIO_MAX732X) += gpio-max732x.o +obj-$(CONFIG_GPIO_MAX7360) += gpio-max7360.o obj-$(CONFIG_GPIO_MAX77620) += gpio-max77620.o obj-$(CONFIG_GPIO_MAX77650) += gpio-max77650.o obj-$(CONFIG_GPIO_MB86S7X) += gpio-mb86s7x.o diff --git a/drivers/gpio/gpio-max7360.c b/drivers/gpio/gpio-max7360.c new file mode 100644 index 000000000000..0e587aa53cf8 --- /dev/null +++ b/drivers/gpio/gpio-max7360.c @@ -0,0 +1,453 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright 2024 Bootlin + * + * Author: Kamel BOUHARA + * Author: Mathieu Dubois-Briand + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define MAX7360_GPIO_PORT 1 +#define MAX7360_GPIO_COL 2 + +struct max7360_gpio { + struct gpio_chip chip; + struct device *dev; + struct regmap *regmap; + int gpio_function; + + /* + * Interrupts handling data: only used when gpio_function is + * MAX7360_GPIO_PORT. + */ + u8 masked_interrupts; + u8 in_values; + unsigned int irq_types[MAX7360_MAX_GPIO]; +}; + +static void max7360_gpio_set_value(struct gpio_chip *gc, + unsigned int pin, int state) +{ + struct max7360_gpio *max7360_gpio = gpiochip_get_data(gc); + unsigned int val; + int ret; + + if (max7360_gpio->gpio_function == MAX7360_GPIO_COL) { + int off = MAX7360_MAX_GPIO - (gc->ngpio - pin); + + ret = regmap_write_bits(max7360_gpio->regmap, MAX7360_REG_PORTS, + BIT(off), state ? BIT(off) : 0); + } else { + ret = regmap_write(max7360_gpio->regmap, + MAX7360_REG_PWMBASE + pin, state ? 0xFF : 0); + } + + if (ret) + dev_err(max7360_gpio->dev, + "failed to set value %d on gpio-%d", val, pin); +} + +static int max7360_gpio_get_value(struct gpio_chip *gc, unsigned int pin) +{ + struct max7360_gpio *max7360_gpio = gpiochip_get_data(gc); + unsigned int val; + int off; + int ret; + + if (max7360_gpio->gpio_function == MAX7360_GPIO_COL) { + off = MAX7360_MAX_GPIO - (gc->ngpio - pin); + + ret = regmap_read(max7360_gpio->regmap, MAX7360_REG_PORTS, &val); + } else { + off = pin; + ret = regmap_read(max7360_gpio->regmap, MAX7360_REG_GPIOIN, &val); + } + + if (ret) { + dev_err(max7360_gpio->dev, "failed to read gpio-%d", pin); + return ret; + } + + return !!(val & BIT(off)); +} + +static int max7360_gpio_get_direction(struct gpio_chip *gc, unsigned int pin) +{ + struct max7360_gpio *max7360_gpio = gpiochip_get_data(gc); + unsigned int val; + int ret; + + if (max7360_gpio->gpio_function == MAX7360_GPIO_COL) + return GPIO_LINE_DIRECTION_OUT; + + ret = regmap_read(max7360_gpio->regmap, MAX7360_REG_GPIOCTRL, &val); + if (ret) { + dev_err(max7360_gpio->dev, "failed to read gpio-%d direction", + pin); + return ret; + } + + if (val & BIT(pin)) + return GPIO_LINE_DIRECTION_OUT; + + return GPIO_LINE_DIRECTION_IN; +} + +static int max7360_gpio_direction_input(struct gpio_chip *gc, unsigned int pin) +{ + struct max7360_gpio *max7360_gpio = gpiochip_get_data(gc); + int ret; + + if (max7360_gpio->gpio_function == MAX7360_GPIO_COL) + return -EIO; + + ret = regmap_write_bits(max7360_gpio->regmap, MAX7360_REG_GPIOCTRL, + BIT(pin), 0); + if (ret) { + dev_err(max7360_gpio->dev, "failed to set gpio-%d direction", + pin); + return ret; + } + + return 0; +} + +static int max7360_gpio_direction_output(struct gpio_chip *gc, unsigned int pin, + int state) +{ + struct max7360_gpio *max7360_gpio = gpiochip_get_data(gc); + int ret; + + if (max7360_gpio->gpio_function == MAX7360_GPIO_PORT) { + ret = regmap_write_bits(max7360_gpio->regmap, + MAX7360_REG_GPIOCTRL, BIT(pin), + BIT(pin)); + if (ret) { + dev_err(max7360_gpio->dev, + "failed to set gpio-%d direction", pin); + return ret; + } + } + + max7360_gpio_set_value(gc, pin, state); + + return 0; +} + +static int max7360_gpio_request(struct gpio_chip *gc, unsigned int pin) +{ + struct max7360_gpio *max7360_gpio = gpiochip_get_data(gc); + + /* + * GPOs on COL pins (keypad columns) can always be requested: this + * driver has full access to them, up to the number set in chip.ngpio. + * GPIOs on PORT pins are shared with the PWM and rotary encoder + * drivers: they have to be requested from the MFD driver. + */ + if (max7360_gpio->gpio_function == MAX7360_GPIO_COL) + return 0; + + return max7360_port_pin_request(max7360_gpio->dev->parent, pin, true); +} + +static void max7360_gpio_free(struct gpio_chip *gc, unsigned int pin) +{ + struct max7360_gpio *max7360_gpio = gpiochip_get_data(gc); + + if (max7360_gpio->gpio_function == MAX7360_GPIO_COL) + return; + + max7360_port_pin_request(max7360_gpio->dev->parent, pin, false); +} + +static struct gpio_chip max7360_gpio_chip = { + .label = "max7360", + .request = max7360_gpio_request, + .free = max7360_gpio_free, + .get_direction = max7360_gpio_get_direction, + .direction_input = max7360_gpio_direction_input, + .direction_output = max7360_gpio_direction_output, + .get = max7360_gpio_get_value, + .set = max7360_gpio_set_value, + .base = -1, + .can_sleep = true, +}; + +static irqreturn_t max7360_gpio_irq(int irq, void *data) +{ + struct max7360_gpio *max7360_gpio = data; + unsigned long pending; + unsigned int gpio_irq; + unsigned int type; + unsigned int count = 0; + int val; + int irqn; + int ret; + + ret = regmap_read(max7360_gpio->regmap, MAX7360_REG_GPIOIN, &val); + if (ret) { + dev_err(max7360_gpio->dev, "Failed to read gpio values: %d\n", + ret); + return IRQ_NONE; + } + + /* MAX7360 generates interrupts but does not report which pins changed: + * compare the pin value with the value they had in previous interrupt + * and report interrupt if the change match the set IRQ type. + */ + pending = val ^ max7360_gpio->in_values; + for_each_set_bit(irqn, &pending, max7360_gpio->chip.ngpio) { + type = max7360_gpio->irq_types[irqn]; + if (max7360_gpio->masked_interrupts & BIT(irqn)) + continue; + if ((val & BIT(irqn)) && type == IRQ_TYPE_EDGE_FALLING) + continue; + if (!(val & BIT(irqn)) && type == IRQ_TYPE_EDGE_RISING) + continue; + gpio_irq = irq_find_mapping(max7360_gpio->chip.irq.domain, irqn); + handle_nested_irq(gpio_irq); + count++; + } + + max7360_gpio->in_values = val; + + if (count == 0) + return IRQ_NONE; + + return IRQ_HANDLED; +} + +static void max7360_gpio_irq_unmask(struct irq_data *data) +{ + struct max7360_gpio *max7360_gpio; + unsigned int pin = irqd_to_hwirq(data); + unsigned int val; + int ret; + + max7360_gpio = gpiochip_get_data(irq_data_get_irq_chip_data(data)); + + /* Read current pin value, so we know if the pin changed in the next + * interrupt. + * No lock should be needed regarding the interrupt handler: as long as + * the corresponding bit has not been cleared in masked_interrupts, this + * gpio is ignored. + */ + ret = regmap_read(max7360_gpio->regmap, MAX7360_REG_GPIOIN, &val); + if (ret) + dev_err(max7360_gpio->dev, "Failed to read gpio values: %d\n", + ret); + + max7360_gpio->in_values &= ~BIT(pin); + max7360_gpio->in_values |= val & BIT(pin); + + ret = regmap_write_bits(max7360_gpio->regmap, MAX7360_REG_PWMCFG + pin, + MAX7360_PORT_CFG_INTERRUPT_MASK, 0); + + if (ret) + dev_err(max7360_gpio->dev, "failed to unmask gpio-%d", pin); + + max7360_gpio->masked_interrupts &= ~BIT(pin); +} + +static void max7360_gpio_irq_mask(struct irq_data *data) +{ + struct max7360_gpio *max7360_gpio; + unsigned int pin = irqd_to_hwirq(data); + int ret; + + max7360_gpio = gpiochip_get_data(irq_data_get_irq_chip_data(data)); + + max7360_gpio->masked_interrupts |= BIT(pin); + + ret = regmap_write_bits(max7360_gpio->regmap, MAX7360_REG_PWMCFG + pin, + MAX7360_PORT_CFG_INTERRUPT_MASK, + MAX7360_PORT_CFG_INTERRUPT_MASK); + + if (ret) + dev_err(max7360_gpio->dev, "failed to mask gpio-%d", pin); +} + +static void max7360_gpio_irq_enable(struct irq_data *data) +{ + max7360_gpio_irq_unmask(data); +} + +static void max7360_gpio_irq_disable(struct irq_data *data) +{ + max7360_gpio_irq_mask(data); +} + +static int max7360_gpio_irq_set_type(struct irq_data *data, + unsigned int flow_type) +{ + struct max7360_gpio *max7360_gpio; + unsigned int pin; + unsigned int val; + int ret; + + pin = irqd_to_hwirq(data); + max7360_gpio = gpiochip_get_data(irq_data_get_irq_chip_data(data)); + + switch (flow_type) { + case IRQ_TYPE_EDGE_RISING: + val = 0; + break; + case IRQ_TYPE_EDGE_FALLING: + case IRQ_TYPE_EDGE_BOTH: + val = MAX7360_PORT_CFG_INTERRUPT_EDGES; + break; + default: + return -EINVAL; + } + ret = regmap_write_bits(max7360_gpio->regmap, MAX7360_REG_PWMCFG + pin, + MAX7360_PORT_CFG_INTERRUPT_EDGES, val); + + if (ret) + dev_err(max7360_gpio->dev, "failed to unmask gpio-%d", pin); + + max7360_gpio->irq_types[pin] = flow_type; + + return 0; +} + +static const struct irq_chip max7360_gpio_irqchip = { + .name = "max7360", + .irq_enable = max7360_gpio_irq_enable, + .irq_disable = max7360_gpio_irq_disable, + .irq_mask = max7360_gpio_irq_mask, + .irq_unmask = max7360_gpio_irq_unmask, + .irq_set_type = max7360_gpio_irq_set_type, + .flags = IRQCHIP_IMMUTABLE, + GPIOCHIP_IRQ_RESOURCE_HELPERS, +}; + +static int max7360_gpio_probe(struct platform_device *pdev) +{ + struct max7360_gpio *max7360_gpio; + unsigned int ngpios; + unsigned int outconf; + struct gpio_irq_chip *girq; + unsigned long flags; + int irq; + int ret; + + if (!pdev->dev.parent) { + dev_err(&pdev->dev, "no parent device\n"); + return -ENODEV; + } + + max7360_gpio = devm_kzalloc(&pdev->dev, sizeof(struct max7360_gpio), + GFP_KERNEL); + if (!max7360_gpio) + return -ENOMEM; + + if (of_property_read_u32(pdev->dev.of_node, "ngpios", &ngpios)) { + dev_err(&pdev->dev, "Missing ngpios OF property\n"); + return -ENODEV; + } + + max7360_gpio->regmap = dev_get_regmap(pdev->dev.parent, NULL); + if (!max7360_gpio->regmap) { + dev_err(&pdev->dev, "could not get parent regmap\n"); + return -ENODEV; + } + + max7360_gpio->dev = &pdev->dev; + max7360_gpio->chip = max7360_gpio_chip; + max7360_gpio->chip.ngpio = ngpios; + max7360_gpio->chip.parent = &pdev->dev; + max7360_gpio->chip.base = -1; + max7360_gpio->gpio_function = (int)device_get_match_data(&pdev->dev); + + dev_dbg(&pdev->dev, "gpio count: %d\n", max7360_gpio->chip.ngpio); + + if (max7360_gpio->gpio_function == MAX7360_GPIO_PORT) { + /* Port GPIOs: set output mode configuration (constant-current + * or not). + * This property is optional. + */ + outconf = 0; + ret = of_property_read_u32(pdev->dev.of_node, + "constant-current-disable", &outconf); + if (ret && (ret != -EINVAL)) { + dev_err(&pdev->dev, + "Failed to read constant-current-disable OF property\n"); + return -ENODEV; + } + + regmap_write(max7360_gpio->regmap, MAX7360_REG_GPIOOUTM, outconf); + } + + if (max7360_gpio->gpio_function == MAX7360_GPIO_PORT && + of_property_read_bool(pdev->dev.of_node, "interrupt-controller")) { + /* Port GPIOs: declare IRQ chip, if configuration was provided. + */ + irq = platform_get_irq(pdev, 0); + if (irq < 0) + return dev_err_probe(&pdev->dev, irq, + "Failed to get IRQ"); + + flags = IRQF_TRIGGER_LOW | IRQF_ONESHOT | IRQF_SHARED; + ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, + max7360_gpio_irq, flags, + "max7360-gpio", max7360_gpio); + if (ret) + return dev_err_probe(&pdev->dev, ret, + "Failed to register interrupt: %d\n", + ret); + + girq = &max7360_gpio->chip.irq; + gpio_irq_chip_set_chip(girq, &max7360_gpio_irqchip); + girq->parent_handler = NULL; + girq->num_parents = 0; + girq->parents = NULL; + girq->threaded = true; + girq->default_type = IRQ_TYPE_NONE; + girq->handler = handle_simple_irq; + } + + ret = devm_gpiochip_add_data(&pdev->dev, &max7360_gpio->chip, max7360_gpio); + if (ret) { + dev_err(&pdev->dev, "unable to add gpiochip: %d\n", ret); + return ret; + } + + return 0; +} + +static const struct of_device_id max7360_gpio_of_match[] = { + { + .compatible = "maxim,max7360-gpo", + .data = (void *)MAX7360_GPIO_COL + }, { + .compatible = "maxim,max7360-gpio", + .data = (void *)MAX7360_GPIO_PORT + }, { + } +}; +MODULE_DEVICE_TABLE(of, max7360_gpio_of_match); + +static struct platform_driver max7360_gpio_driver = { + .driver = { + .name = "max7360-gpio", + .of_match_table = of_match_ptr(max7360_gpio_of_match), + }, + .probe = max7360_gpio_probe, +}; +module_platform_driver(max7360_gpio_driver); + +MODULE_DESCRIPTION("MAX7360 GPIO driver"); +MODULE_AUTHOR("Kamel BOUHARA "); +MODULE_AUTHOR("Mathieu Dubois-Briand "); +MODULE_ALIAS("platform:max7360-gpio"); +MODULE_LICENSE("GPL"); From patchwork Thu Dec 19 16:21:23 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Dubois-Briand X-Patchwork-Id: 852603 Received: from relay3-d.mail.gandi.net (relay3-d.mail.gandi.net [217.70.183.195]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4E657228381; Thu, 19 Dec 2024 16:21:59 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.195 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625323; cv=none; b=fv328ixsI88iaiejFviV8ZKae9nE/vGdp+sQv2+thqlpjHKYLmFtdmp51cszhsY+gEQFXibONJFqKdZ/ZAg1iWaMw5m6cQHkwqQmp8otFTOBokKGgZBZF15PUgiclkjM/xYDkc2/QFYV9hJH4zUbT6G8tYr0T3DNXMCLEO68JHM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625323; c=relaxed/simple; bh=NKKK6m3TELHnW2cRSo1Kk+Wj76SXFUJ2uWnoCjAZsFY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=P0fN0QPHPL2psuZKsv9/UJQAMUH1xshOjaTNFczT7A0Jb8YamAiudJFd+qepPn4Cx5sUgB2GegG5Hhb1IT7MgEfqeuEU6YH2usiXlSbjz78DfkcXUjv6+xu0or3R2yiUWK/QwGas6gG5i4dmVbWwkCZBz1Jo7SNVLZemn75hwZ4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=oSZPluGl; arc=none smtp.client-ip=217.70.183.195 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="oSZPluGl" Received: by mail.gandi.net (Postfix) with ESMTPSA id 8D78860006; Thu, 19 Dec 2024 16:21:52 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1734625313; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=N5XRZr3gsIuLzCYmmgqzJoRUGlzpyX2inEBWBRXtQkk=; b=oSZPluGlYajSX6Rc9a6dCYLRuNR/Fv1qtQgRa0Zg+szhf9S9WLeE8s7zlBLVOeQTAIR+mK vI1yl8wNbevHG8bhiELkrDmrn1n3/ExbZHT95CgnbtMod6kpdCqZBu+jtL+ARLnlWs1FWG 2aEsAMmMItGO2THmYt0n+3+t5v5SF5gNi+m78FG8t5prGnA2Cb1eOQ5/DaIxENoosF4urv Iek3IvILqEHxHuynH/DXUvldxFuwxjiPmM8q14CepOfUXgFe7CWl81OApVeILZUg/0XA1G TpBixykAsgD+56xaaTDFRXnlo66LJnelpQ41HAj0ftZ3nV5XHeoZW/ytWro+ng== From: Mathieu Dubois-Briand Date: Thu, 19 Dec 2024 17:21:23 +0100 Subject: [PATCH 6/8] input: keyboard: Add support for MAX7360 keypad Precedence: bulk X-Mailing-List: linux-input@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20241219-mdb-max7360-support-v1-6-8e8317584121@bootlin.com> References: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> In-Reply-To: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> To: Lee Jones , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Kamel Bouhara , Linus Walleij , Bartosz Golaszewski , Dmitry Torokhov , =?utf-8?q?Uwe_Kleine-K=C3=B6n?= =?utf-8?q?ig?= Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-input@vger.kernel.org, linux-pwm@vger.kernel.org, =?utf-8?q?Gr=C3=A9gory_Clement?= , Thomas Petazzoni , Mathieu Dubois-Briand X-Mailer: b4 0.14.1 X-Developer-Signature: v=1; a=ed25519-sha256; t=1734625307; l=10712; i=mathieu.dubois-briand@bootlin.com; s=20241219; h=from:subject:message-id; bh=NKKK6m3TELHnW2cRSo1Kk+Wj76SXFUJ2uWnoCjAZsFY=; b=MIoi6JqektC3LUFRkKSZy4fwOY7p7XcJXe3y1wg59QwGkLbCr7h/OU7KQ8EE98YK12HqF4qyO GBlimW0tJa2B7i4mrkjjDRKWLd1BOqQHGOYJ5Dfiu7lBcEvdWUCD+HW X-Developer-Key: i=mathieu.dubois-briand@bootlin.com; a=ed25519; pk=1PVTmzPXfKvDwcPUzG0aqdGoKZJA3b9s+3DqRlm0Lww= X-GND-Sasl: mathieu.dubois-briand@bootlin.com Add driver for Maxim Integrated MAX7360 keypad controller, providing support for up to 64 keys, with a matrix of 8 columns and 8 rows. Signed-off-by: Mathieu Dubois-Briand --- drivers/input/keyboard/Kconfig | 12 ++ drivers/input/keyboard/Makefile | 1 + drivers/input/keyboard/max7360-keypad.c | 297 ++++++++++++++++++++++++++++++++ 3 files changed, 310 insertions(+) diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig index 721ab69e84ac..bba029f65cfa 100644 --- a/drivers/input/keyboard/Kconfig +++ b/drivers/input/keyboard/Kconfig @@ -421,6 +421,18 @@ config KEYBOARD_MAX7359 To compile this driver as a module, choose M here: the module will be called max7359_keypad. +config KEYBOARD_MAX7360 + tristate "Maxim MAX7360 Key Switch Controller" + select INPUT_MATRIXKMAP + depends on I2C + depends on MFD_MAX7360 + help + If you say yes here you get support for the keypad controller on the + Maxim MAX7360 I/O Expander. + + To compile this driver as a module, choose M here: the + module will be called max7360_keypad. + config KEYBOARD_MPR121 tristate "Freescale MPR121 Touchkey" depends on I2C diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile index 1e0721c30709..b49d32d4003d 100644 --- a/drivers/input/keyboard/Makefile +++ b/drivers/input/keyboard/Makefile @@ -42,6 +42,7 @@ obj-$(CONFIG_KEYBOARD_LPC32XX) += lpc32xx-keys.o obj-$(CONFIG_KEYBOARD_MAPLE) += maple_keyb.o obj-$(CONFIG_KEYBOARD_MATRIX) += matrix_keypad.o obj-$(CONFIG_KEYBOARD_MAX7359) += max7359_keypad.o +obj-$(CONFIG_KEYBOARD_MAX7360) += max7360-keypad.o obj-$(CONFIG_KEYBOARD_MPR121) += mpr121_touchkey.o obj-$(CONFIG_KEYBOARD_MT6779) += mt6779-keypad.o obj-$(CONFIG_KEYBOARD_MTK_PMIC) += mtk-pmic-keys.o diff --git a/drivers/input/keyboard/max7360-keypad.c b/drivers/input/keyboard/max7360-keypad.c new file mode 100644 index 000000000000..fbc51c89dba1 --- /dev/null +++ b/drivers/input/keyboard/max7360-keypad.c @@ -0,0 +1,297 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright 2024 Bootlin + * + * Author: Mathieu Dubois-Briand + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct max7360_keypad { + struct input_dev *input; + unsigned int rows; + unsigned int cols; + unsigned int debounce_ms; + int irq; + bool no_autorepeat; + struct regmap *regmap; + unsigned short keycodes[MAX7360_MAX_KEY_ROWS * MAX7360_MAX_KEY_COLS]; +}; + +static irqreturn_t max7360_keypad_irq(int irq, void *data) +{ + struct max7360_keypad *max7360_keypad = data; + unsigned int val; + unsigned int row, col; + unsigned int release; + unsigned int code; + int ret; + + ret = regmap_read(max7360_keypad->regmap, MAX7360_REG_KEYFIFO, &val); + if (!ret && val == MAX7360_FIFO_OVERFLOW) { + /* FIFO overflow: ignore it and get next event. */ + dev_err(&max7360_keypad->input->dev, "max7360 FIFO overflow"); + ret = regmap_read(max7360_keypad->regmap, MAX7360_REG_KEYFIFO, + &val); + } + if (ret) { + dev_err(&max7360_keypad->input->dev, + "Failed to read max7360 FIFO"); + return ret; + } + + if (val == MAX7360_FIFO_EMPTY) { + dev_dbg(&max7360_keypad->input->dev, + "Got a spurious interrupt"); + + return IRQ_NONE; + } + + row = FIELD_GET(MAX7360_FIFO_ROW, val); + col = FIELD_GET(MAX7360_FIFO_COL, val); + release = val & MAX7360_FIFO_RELEASE; + + code = MATRIX_SCAN_CODE(row, col, MAX7360_ROW_SHIFT); + + dev_dbg(&max7360_keypad->input->dev, + "key[%d:%d] %s\n", row, col, release ? "release" : "press"); + + input_event(max7360_keypad->input, EV_MSC, MSC_SCAN, code); + input_report_key(max7360_keypad->input, max7360_keypad->keycodes[code], + !release); + input_sync(max7360_keypad->input); + + return IRQ_HANDLED; +} + +static int max7360_keypad_open(struct input_dev *pdev) +{ + struct max7360_keypad *max7360_keypad = input_get_drvdata(pdev); + int ret; + + /* + * Somebody is using the device: get out of sleep. + */ + ret = regmap_write_bits(max7360_keypad->regmap, MAX7360_REG_CONFIG, + MAX7360_CFG_SLEEP, MAX7360_CFG_SLEEP); + if (ret) { + dev_err(&max7360_keypad->input->dev, + "Failed to write max7360 configuration"); + return ret; + } + + return 0; +} + +static void max7360_keypad_close(struct input_dev *pdev) +{ + struct max7360_keypad *max7360_keypad = input_get_drvdata(pdev); + int ret; + + /* + * Nobody is using the device anymore: go to sleep. + */ + ret = regmap_write_bits(max7360_keypad->regmap, MAX7360_REG_CONFIG, + MAX7360_CFG_SLEEP, ~MAX7360_CFG_SLEEP); + if (ret) { + dev_err(&max7360_keypad->input->dev, + "Failed to write max7360 configuration"); + } +} + +static int max7360_keypad_hw_init(struct max7360_keypad *max7360_keypad) +{ + unsigned int val; + int ret; + + val = max7360_keypad->debounce_ms - MAX7360_DEBOUNCE_MIN; + ret = regmap_write_bits(max7360_keypad->regmap, MAX7360_REG_DEBOUNCE, + MAX7360_DEBOUNCE, + FIELD_PREP(MAX7360_DEBOUNCE, val)); + if (ret) { + dev_err(&max7360_keypad->input->dev, + "Failed to write max7360 debounce configuration"); + return ret; + } + + ret = regmap_write_bits(max7360_keypad->regmap, MAX7360_REG_INTERRUPT, + MAX7360_INTERRUPT_TIME_MASK, + FIELD_PREP(MAX7360_INTERRUPT_TIME_MASK, 1)); + if (ret) { + dev_err(&max7360_keypad->input->dev, + "Failed to write max7360 keypad interrupt configuration"); + return ret; + } + + return 0; +} + +static int max7360_keypad_parse_dt(struct platform_device *pdev, + struct max7360_keypad *max7360_keypad) +{ + bool no_autorepeat; + int ret; + + ret = matrix_keypad_parse_properties(&pdev->dev, &max7360_keypad->rows, + &max7360_keypad->cols); + if (ret) + return ret; + + if (!max7360_keypad->rows || !max7360_keypad->cols || + max7360_keypad->rows > MAX7360_MAX_KEY_ROWS || + max7360_keypad->cols > MAX7360_MAX_KEY_COLS) { + dev_err(&pdev->dev, + "Invalid number of columns or rows (%ux%u)\n", + max7360_keypad->cols, max7360_keypad->rows); + return -EINVAL; + } + + max7360_keypad->regmap = dev_get_regmap(pdev->dev.parent, NULL); + if (!max7360_keypad->regmap) { + dev_err(&pdev->dev, "Could not get parent regmap\n"); + return -ENODEV; + } + + no_autorepeat = of_property_read_bool(pdev->dev.of_node, + "linux,input-no-autorepeat"); + max7360_keypad->no_autorepeat = no_autorepeat; + + max7360_keypad->debounce_ms = MAX7360_DEBOUNCE_MIN; + ret = of_property_read_u32(pdev->dev.of_node, "debounce-delay-ms", + &max7360_keypad->debounce_ms); + if (ret == -EINVAL) { + dev_info(&pdev->dev, "Using default debounce-delay-ms: %u\n", + max7360_keypad->debounce_ms); + } else if (ret < 0) { + dev_err(&pdev->dev, "Failed to read debounce-delay-ms property\n"); + return ret; + } else if (max7360_keypad->debounce_ms < MAX7360_DEBOUNCE_MIN || + max7360_keypad->debounce_ms > MAX7360_DEBOUNCE_MAX) { + dev_err(&pdev->dev, + "Invalid debounce-delay-ms: %u, should be between %u and %u.\n", + max7360_keypad->debounce_ms, MAX7360_DEBOUNCE_MIN, + MAX7360_DEBOUNCE_MAX); + return -EINVAL; + } + + return 0; +} + +static int max7360_keypad_probe(struct platform_device *pdev) +{ + struct max7360_keypad *max7360_keypad; + struct input_dev *input; + unsigned long flags; + int irq; + int ret; + + if (!pdev->dev.parent) + return dev_err_probe(&pdev->dev, -ENODEV, "No parent device\n"); + + irq = platform_get_irq(pdev, 0); + if (irq < 0) + return irq; + + max7360_keypad = devm_kzalloc(&pdev->dev, sizeof(*max7360_keypad), + GFP_KERNEL); + if (!max7360_keypad) + return -ENOMEM; + + ret = max7360_keypad_parse_dt(pdev, max7360_keypad); + if (ret) + return ret; + + input = devm_input_allocate_device(&pdev->dev); + if (!input) + return dev_err_probe(&pdev->dev, -ENOMEM, + "Failed to allocate input device\n"); + + max7360_keypad->input = input; + + input->id.bustype = BUS_I2C; + input->name = pdev->name; + input->dev.parent = &pdev->dev; + + input->open = max7360_keypad_open; + input->close = max7360_keypad_close; + + ret = matrix_keypad_build_keymap(NULL, NULL, + MAX7360_MAX_KEY_ROWS, + MAX7360_MAX_KEY_COLS, + max7360_keypad->keycodes, input); + if (ret) + return dev_err_probe(&pdev->dev, ret, + "Failed to build keymap\n"); + + input_set_capability(input, EV_MSC, MSC_SCAN); + if (!max7360_keypad->no_autorepeat) + __set_bit(EV_REP, input->evbit); + + input_set_drvdata(input, max7360_keypad); + + flags = IRQF_TRIGGER_LOW | IRQF_ONESHOT | IRQF_SHARED; + ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, + max7360_keypad_irq, flags, + "max7360-keypad", max7360_keypad); + if (ret) + return dev_err_probe(&pdev->dev, ret, + "Failed to register interrupt: %d\n", ret); + + ret = input_register_device(input); + if (ret) + return dev_err_probe(&pdev->dev, ret, + "Could not register input device: %d\n", + ret); + + platform_set_drvdata(pdev, max7360_keypad); + + device_init_wakeup(&pdev->dev, true); + ret = dev_pm_set_wake_irq(&pdev->dev, irq); + if (ret) + dev_warn(&pdev->dev, "Failed to set up wakeup irq: %d\n", ret); + + ret = max7360_keypad_hw_init(max7360_keypad); + if (ret) + return dev_err_probe(&pdev->dev, ret, + "Failed to initialize max7360 keypad\n"); + + return 0; +} + +static void max7360_keypad_remove(struct platform_device *pdev) +{ + dev_pm_clear_wake_irq(&pdev->dev); +} + +#ifdef CONFIG_OF +static const struct of_device_id max7360_keypad_of_match[] = { + { .compatible = "maxim,max7360-keypad", }, + { } +}; +MODULE_DEVICE_TABLE(of, max7360_keypad_of_match); +#endif + +static struct platform_driver max7360_keypad_driver = { + .driver = { + .name = "max7360-keypad", + .of_match_table = of_match_ptr(max7360_keypad_of_match), + }, + .probe = max7360_keypad_probe, + .remove = max7360_keypad_remove, +}; +module_platform_driver(max7360_keypad_driver); + +MODULE_DESCRIPTION("MAX7360 Keypad driver"); +MODULE_AUTHOR("Mathieu Dubois-Briand "); +MODULE_ALIAS("platform:max7360-keypad"); +MODULE_LICENSE("GPL"); From patchwork Thu Dec 19 16:21:24 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Dubois-Briand X-Patchwork-Id: 852188 Received: from relay3-d.mail.gandi.net (relay3-d.mail.gandi.net [217.70.183.195]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A6797225A3B; Thu, 19 Dec 2024 16:21:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.195 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625318; cv=none; b=LKR90gQ0CkuU7j+SFKcVeLtmGv1GQYf3thMyaM3QKVVjgUSbxNPRclMEN69rmS2n6B48ZHLeHUF0/ERiBhj/amiWpSdqKQftquJTFwrGuk9LwlEMZYNPrxtM5wrVbc6c9WOFFBByXD0KwDab/WgjPGF6hkulRVAUPa/79BiXaFI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625318; c=relaxed/simple; bh=Ta7vb/V0DhN1/JHsKMkimtBE8CZReTmidY/SpxNgg60=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=uOfbvPydfZCR5tP088hJTRz590Xp1UQmTi66HdRjM9z/UeHgwC/fns8GGLcYc8f/jwfA0N8OPW/E3t434kceMX8OQF3KPmT7kYM2s1N/d5ya72x6bt3k/yGSBzLXYscYrS9uynp0h7Q0Uh/uDqvDcwyAIO4W0N/9lU8RqmZl4QQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=RReh+d8p; arc=none smtp.client-ip=217.70.183.195 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="RReh+d8p" Received: by mail.gandi.net (Postfix) with ESMTPSA id 5B39160004; Thu, 19 Dec 2024 16:21:53 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1734625314; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=iWTiQ4bFE5jcx5Vary3HT4Q6Fn51GDhhYR6OTUrReEU=; b=RReh+d8pnzr8yCxvj2nvZQUeAEl05QQcUkgTqLIkQ/hhmqeuLKMKyLytjli3LLWCh3tzX6 /+h2qv2gfCYXuT4Z2fc9OWgSS9jontUAd5MqZnMTnHR/Zgxff1dCDeyWpoL9qCDV6rbntZ 8G2Sj4/KRoDCL/dh3WUeQMTNPjxWo/aosA5NWKqVHhfeAkOXZwnA9tm7CECNXaBchjJsI8 cM5cQTvImlCNpmXz0WH88AcwSq3K9OYXmqh3j2w1lcLURZWO7LwaalcI5sNfHJLvrAJF3S m4lfrdDZeT/sk3Ech/IcHmRQkF218u2MrdbsrKNI1Hkm0Yos5XDzmtk/NJmfCQ== From: Mathieu Dubois-Briand Date: Thu, 19 Dec 2024 17:21:24 +0100 Subject: [PATCH 7/8] input: misc: Add support for MAX7360 rotary Precedence: bulk X-Mailing-List: linux-input@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20241219-mdb-max7360-support-v1-7-8e8317584121@bootlin.com> References: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> In-Reply-To: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> To: Lee Jones , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Kamel Bouhara , Linus Walleij , Bartosz Golaszewski , Dmitry Torokhov , =?utf-8?q?Uwe_Kleine-K=C3=B6n?= =?utf-8?q?ig?= Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-input@vger.kernel.org, linux-pwm@vger.kernel.org, =?utf-8?q?Gr=C3=A9gory_Clement?= , Thomas Petazzoni , Mathieu Dubois-Briand X-Mailer: b4 0.14.1 X-Developer-Signature: v=1; a=ed25519-sha256; t=1734625307; l=7493; i=mathieu.dubois-briand@bootlin.com; s=20241219; h=from:subject:message-id; bh=Ta7vb/V0DhN1/JHsKMkimtBE8CZReTmidY/SpxNgg60=; b=9dkD6i4KuZTuaj9s1YkPJHKNApOeLtrgZL09Dr10g4eiWELiFnTl7x7itPDXbd1n13ePyYwUy h+xu8nvZ6ulDP1ae85AcMIbLc+NmLJr7TndCJRoVttw+MdsF6uwtHqo X-Developer-Key: i=mathieu.dubois-briand@bootlin.com; a=ed25519; pk=1PVTmzPXfKvDwcPUzG0aqdGoKZJA3b9s+3DqRlm0Lww= X-GND-Sasl: mathieu.dubois-briand@bootlin.com Add driver for Maxim Integrated MAX7360 rotary encoder controller, supporting a single rotary switch. Signed-off-by: Mathieu Dubois-Briand --- drivers/input/misc/Kconfig | 11 ++ drivers/input/misc/Makefile | 1 + drivers/input/misc/max7360-rotary.c | 194 ++++++++++++++++++++++++++++++++++++ 3 files changed, 206 insertions(+) diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig index 6a852c76331b..8430aaf08c04 100644 --- a/drivers/input/misc/Kconfig +++ b/drivers/input/misc/Kconfig @@ -230,6 +230,17 @@ config INPUT_M68K_BEEP tristate "M68k Beeper support" depends on M68K +config INPUT_MAX7360_ROTARY + tristate "Maxim MAX7360 Rotary Encoder" + depends on I2C + depends on MFD_MAX7360 + help + If you say yes here you get support for the rotary encoder on the + Maxim MAX7360 I/O Expander. + + To compile this driver as a module, choose M here: the + module will be called max7360_rotary. + config INPUT_MAX77650_ONKEY tristate "Maxim MAX77650 ONKEY support" depends on MFD_MAX77650 diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile index 4f7f736831ba..0ed447543e43 100644 --- a/drivers/input/misc/Makefile +++ b/drivers/input/misc/Makefile @@ -51,6 +51,7 @@ obj-$(CONFIG_INPUT_IQS7222) += iqs7222.o obj-$(CONFIG_INPUT_KEYSPAN_REMOTE) += keyspan_remote.o obj-$(CONFIG_INPUT_KXTJ9) += kxtj9.o obj-$(CONFIG_INPUT_M68K_BEEP) += m68kspkr.o +obj-$(CONFIG_INPUT_MAX7360_ROTARY) += max7360-rotary.o obj-$(CONFIG_INPUT_MAX77650_ONKEY) += max77650-onkey.o obj-$(CONFIG_INPUT_MAX77693_HAPTIC) += max77693-haptic.o obj-$(CONFIG_INPUT_MAX8925_ONKEY) += max8925_onkey.o diff --git a/drivers/input/misc/max7360-rotary.c b/drivers/input/misc/max7360-rotary.c new file mode 100644 index 000000000000..c6c7deb309c2 --- /dev/null +++ b/drivers/input/misc/max7360-rotary.c @@ -0,0 +1,194 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright 2024 Bootlin + * + * Author: Mathieu Dubois-Briand + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct max7360_rotary { + u32 axis; + struct input_dev *input; + unsigned int debounce_ms; + struct regmap *regmap; +}; + +static irqreturn_t max7360_rotary_irq(int irq, void *data) +{ + struct max7360_rotary *max7360_rotary = data; + int val; + int ret; + + ret = regmap_read(max7360_rotary->regmap, MAX7360_REG_RTR_CNT, &val); + if (ret < 0) { + dev_err(&max7360_rotary->input->dev, + "Failed to read rotary counter"); + return IRQ_NONE; + } + + if (val == 0) { + dev_dbg(&max7360_rotary->input->dev, + "Got a spurious interrupt"); + + return IRQ_NONE; + } + + input_report_rel(max7360_rotary->input, max7360_rotary->axis, + (int8_t)val); + input_sync(max7360_rotary->input); + + return IRQ_HANDLED; +} + +static int max7360_rotary_hw_init(struct max7360_rotary *max7360_rotary) +{ + int val; + int ret; + + ret = regmap_write_bits(max7360_rotary->regmap, MAX7360_REG_GPIOCFG, + MAX7360_GPIO_CFG_RTR_EN, + MAX7360_GPIO_CFG_RTR_EN); + if (ret) { + dev_err(&max7360_rotary->input->dev, + "Failed to enable max7360 rotary encoder"); + return ret; + } + + val = FIELD_PREP(MAX7360_ROT_DEBOUNCE, max7360_rotary->debounce_ms) | + FIELD_PREP(MAX7360_ROT_INTCNT, 1) | MAX7360_ROT_INTCNT_DLY; + ret = regmap_write(max7360_rotary->regmap, MAX7360_REG_RTRCFG, val); + if (ret) { + dev_err(&max7360_rotary->input->dev, + "Failed to set max7360 rotary encoder configuration"); + return ret; + } + + return 0; +} + +static int max7360_rotary_probe(struct platform_device *pdev) +{ + struct max7360_rotary *max7360_rotary; + struct input_dev *input; + unsigned long flags; + int irq; + int ret; + + if (!pdev->dev.parent) + return dev_err_probe(&pdev->dev, -ENODEV, "No parent device\n"); + + ret = max7360_port_pin_request(pdev->dev.parent, MAX7360_PORT_RTR_PIN, + true); + if (ret) + dev_err_probe(&pdev->dev, ret, + "Could not request rotary pin\n"); + + irq = platform_get_irq(pdev, 0); + if (irq < 0) + return irq; + + max7360_rotary = devm_kzalloc(&pdev->dev, sizeof(*max7360_rotary), + GFP_KERNEL); + if (!max7360_rotary) + return -ENOMEM; + + max7360_rotary->regmap = dev_get_regmap(pdev->dev.parent, NULL); + if (!max7360_rotary->regmap) + dev_err_probe(&pdev->dev, -ENODEV, + "Could not get parent regmap\n"); + + device_property_read_u32(&pdev->dev, "linux,axis", + &max7360_rotary->axis); + device_property_read_u32(&pdev->dev, "debounce-delay-ms", + &max7360_rotary->debounce_ms); + if (max7360_rotary->debounce_ms > MAX7360_ROT_DEBOUNCE_MAX) + return dev_err_probe(&pdev->dev, -EINVAL, + "Invalid debounce timing: %u\n", + max7360_rotary->debounce_ms); + + input = devm_input_allocate_device(&pdev->dev); + if (!input) + return dev_err_probe(&pdev->dev, -ENOMEM, + "Failed to allocate input device\n"); + + max7360_rotary->input = input; + + input->id.bustype = BUS_I2C; + input->name = pdev->name; + input->dev.parent = &pdev->dev; + + input_set_capability(input, EV_REL, max7360_rotary->axis); + input_set_drvdata(input, max7360_rotary); + + flags = IRQF_TRIGGER_LOW | IRQF_ONESHOT | IRQF_SHARED; + ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, + max7360_rotary_irq, flags, + "max7360-rotary", max7360_rotary); + if (ret) + return dev_err_probe(&pdev->dev, ret, + "Failed to register interrupt: %d\n", ret); + + ret = input_register_device(input); + if (ret) + return dev_err_probe(&pdev->dev, ret, + "Could not register input device: %d\n", + ret); + + platform_set_drvdata(pdev, max7360_rotary); + + device_init_wakeup(&pdev->dev, true); + ret = dev_pm_set_wake_irq(&pdev->dev, irq); + if (ret) + dev_warn(&pdev->dev, "Failed to set up wakeup irq: %d\n", ret); + + ret = max7360_rotary_hw_init(max7360_rotary); + if (ret) + return dev_err_probe(&pdev->dev, ret, + "Failed to initialize max7360 rotary\n"); + + return 0; +} + +static void max7360_rotary_remove(struct platform_device *pdev) +{ + dev_pm_clear_wake_irq(&pdev->dev); + + /* + * Free the MAX7360_PORT_RTR_PIN pin, so it can be requested later by + * this driver, the MAX7360 GPIO driver or the MAX7360 PWM driver. + */ + max7360_port_pin_request(pdev->dev.parent, MAX7360_PORT_RTR_PIN, false); +} + +#ifdef CONFIG_OF +static const struct of_device_id max7360_rotary_of_match[] = { + { .compatible = "maxim,max7360-rotary", }, + { } +}; +MODULE_DEVICE_TABLE(of, max7360_rotary_of_match); +#endif + +static struct platform_driver max7360_rotary_driver = { + .driver = { + .name = "max7360-rotary", + .of_match_table = of_match_ptr(max7360_rotary_of_match), + }, + .probe = max7360_rotary_probe, + .remove = max7360_rotary_remove, +}; +module_platform_driver(max7360_rotary_driver); + +MODULE_DESCRIPTION("MAX7360 Rotary driver"); +MODULE_AUTHOR("Mathieu Dubois-Briand "); +MODULE_ALIAS("platform:max7360-rotary"); +MODULE_LICENSE("GPL"); From patchwork Thu Dec 19 16:21:25 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Dubois-Briand X-Patchwork-Id: 852606 Received: from relay3-d.mail.gandi.net (relay3-d.mail.gandi.net [217.70.183.195]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 65E7A22616F; Thu, 19 Dec 2024 16:21:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.195 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625318; cv=none; b=F2VpgwI8UOSd18JXHjNKawkdlYWKhxB6F05fmZimGZ4HeC9iUBdGdmIMjvznrTYh3EZCK6TomJWz1Db4NSekjsb/HVzYuzgkNM+Kz88IWl4zKSBtHkTok9up2rVFehQMv+x9OI9goe34qBBHSykz05uJ3X40SAdrkt07eE5D2YU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734625318; c=relaxed/simple; bh=MMa1aWrpC+Hhbb5vbJvmx5OLBFFy4Ju1nNEWOoDy1s0=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=kvPZPQ7VIDbW6jN1dsDl1ximME9NFZ5qHGXjukoybUCBpO4vVW22cOcCktk6LKlVHK3d0zX2N0pWFjdQGnpQ0LyeRmIVaeVspxwfDNQSoN9vo1Z1/jR/nvAvBuJggPIEXVfOqsAXonbmBZBizQXcXkBmBVO4YR0mcguMKUN8TW4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=IYvEwIrr; arc=none smtp.client-ip=217.70.183.195 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="IYvEwIrr" Received: by mail.gandi.net (Postfix) with ESMTPSA id 21D5760012; Thu, 19 Dec 2024 16:21:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1734625314; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=m5ZGJQUU63vFd9YFgXUTncUS1ermsqmNadQRrooj508=; b=IYvEwIrr1nm8nr0nts6jaOChHC8gDWyyW8FNiEJ6EXYxNBVqwxRMLryLTC2SThG4LFjw/R /PQizCekvhUcIDfCo8TZ//7H1IzV7CIy1dAzNgeuw73DEJpZ769gD8NcUFI6Ov0Q0oIkY4 rXxB0/TMu7S+gSJs6O5PsHKWgCfwmw3yeo1JLprCbZeRcOasBTqJ9/nf+mW0+tyZeFdUC8 3pJ4QhjnhjhnjJVn1UEFt356Kyg5rzA1H4U7nV0CKVt2R8mFs5XuY4ythJtvpwz7GY2lDf miDtaKgWa4jZ3uPGOS9HIIRmJ8gwQGj2vwftmEp6uJKqVk1/XtfRZFHIVdnl2A== From: Mathieu Dubois-Briand Date: Thu, 19 Dec 2024 17:21:25 +0100 Subject: [PATCH 8/8] MAINTAINERS: Add entry on MAX7360 driver Precedence: bulk X-Mailing-List: linux-input@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20241219-mdb-max7360-support-v1-8-8e8317584121@bootlin.com> References: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> In-Reply-To: <20241219-mdb-max7360-support-v1-0-8e8317584121@bootlin.com> To: Lee Jones , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Kamel Bouhara , Linus Walleij , Bartosz Golaszewski , Dmitry Torokhov , =?utf-8?q?Uwe_Kleine-K=C3=B6n?= =?utf-8?q?ig?= Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-input@vger.kernel.org, linux-pwm@vger.kernel.org, =?utf-8?q?Gr=C3=A9gory_Clement?= , Thomas Petazzoni , Mathieu Dubois-Briand X-Mailer: b4 0.14.1 X-Developer-Signature: v=1; a=ed25519-sha256; t=1734625307; l=1024; i=mathieu.dubois-briand@bootlin.com; s=20241219; h=from:subject:message-id; bh=MMa1aWrpC+Hhbb5vbJvmx5OLBFFy4Ju1nNEWOoDy1s0=; b=gJY9TqsxOErNI5KgRO1RC6t1fWCzwGBuuTSDUM7w5JJ+7zQdNKlWEvEBaOdF6oNgYAA9/2gjA Z5c0nJDYA8DDVL6elxigwvZ2oULzCD8E85p8oXOcv/QiR/BhSxW8ZQH X-Developer-Key: i=mathieu.dubois-briand@bootlin.com; a=ed25519; pk=1PVTmzPXfKvDwcPUzG0aqdGoKZJA3b9s+3DqRlm0Lww= X-GND-Sasl: mathieu.dubois-briand@bootlin.com Add myself as maintainer of Maxim MAX7360 driver and device-tree bindings. Signed-off-by: Mathieu Dubois-Briand --- MAINTAINERS | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index baf0eeb9a355..6e9b8caebb38 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -14132,6 +14132,18 @@ L: linux-iio@vger.kernel.org S: Maintained F: drivers/iio/temperature/max30208.c +MAXIM MAX7360 KEYPAD LED MFD DRIVER +M: Mathieu Dubois-Briand +S: Maintained +F: Documentation/devicetree/bindings/*/max7360-*.yaml +F: Documentation/devicetree/bindings/mfd/max7360.yaml +F: drivers/gpio/gpio-max7360.c +F: drivers/input/keyboard/max7360-keypad.c +F: drivers/input/misc/max7360-rotary.c +F: drivers/mfd/max7360.c +F: drivers/pwm/pwm-max7360.c +F: include/linux/mfd/max7360.h + MAXIM MAX77650 PMIC MFD DRIVER M: Bartosz Golaszewski L: linux-kernel@vger.kernel.org