From nobody Fri Oct 3 13:23:47 2025 Received: from mail-pl1-f174.google.com (mail-pl1-f174.google.com [209.85.214.174]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EA9D42D9EF9; Sat, 30 Aug 2025 18:43:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.174 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1756579398; cv=none; b=c1aI/kpZc3LrTt5QBS8ZVyOHN1i/bE1BCJU0LK+wqnHXbN+c9KFAZ34Rrab1XLmCTMc+TggWFmz5V/Wh/P6elkjz+qPHFs7LBYbScBLSCaOOFxkCr+2xLgkIb0LmC7j43UUYx58AGeH7qWz29XlF+3H30TIV0d/6aktScyrdLo8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1756579398; c=relaxed/simple; bh=oVbXo+WlMRVlhb0eRpFRU7JepS0fcP7SScAWqWR1jf8=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=H36qUCEGSZ6SPgcFq7BwajNFdkDJreX2IgsecVpRzoJPnr0XX0KDncMassAFnEsOkDHoTGPZpmIcFAyxn6JhN2mKo/0i9bOGKSHxPA5v5fvrDU+81TmdOTj0muHTAsQE4WMuaewimBDq0qQ91pcllR942D+yI/Ll0a73RuJyc4A= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=b7acQcqM; arc=none smtp.client-ip=209.85.214.174 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="b7acQcqM" Received: by mail-pl1-f174.google.com with SMTP id d9443c01a7336-2445826fd9dso37165215ad.3; Sat, 30 Aug 2025 11:43:16 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1756579396; x=1757184196; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=zk13z4Oe3MH+BwozPqkdTJOMupLgkm8t2078zZl5Y1c=; b=b7acQcqMFYo9Tb5LW4ToJu5R2cTiqkFHB/uqeW+J5NxeiiZ9xT6LmKlneBkOpGRJPr DqIF9+uFPGyQADQfeLmpS2Kdk7qhcSP3mpIdf5WaIcU19evtNRtw6H6pUfx5TQp640zu IJCIPCJC8yVO6UA18vfwKsRpWeDI5R2etPwrCKC5bUW6zDGfDJbS6oBxEoAv60kIwIcV syUDwJqLvQiHLApCu+71H/2sGFJHdQ7Hzsg2pcxcDHFApH3f1dBhs++/ZAjTfZDL1YmQ W3DgkB7mz51MGBrV8iFZyQ4XL3gU55A8IkRXmsCAP8wlRoxeDOTUy3NZPjBeDWI4mThz mxuw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1756579396; x=1757184196; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=zk13z4Oe3MH+BwozPqkdTJOMupLgkm8t2078zZl5Y1c=; b=H6LdRG6A4joWciTfnMg+1i5XSUF65SANMFDOi/nDO4UPgTboRnlAlqXxFwkHqzTnyp fYsrcoRmHzbfVRw3fz39Ushs0ZcobRWEeqJDQmNi5VPdzEnXX6PrMKo8rxBPL/wWE4gg MwP5xMum/30ELMYzZf0KiAA/zmYSEaqLZRTIZ9hL+pi69sErpsc0L5EOr+67TQxqr/Ym XP9n14uASj35QlbJEfIH+2jsD/oMm/0KHWfev7u+5e2IB7FgET/yXOZ4YsiRAqvcPDPq qu6ByX0zVXgwm6wU2/TeI0yolgS5QZHkUPzT8+XjaLRNz4VSBkr9EgfFmFFxo8NjGj1O t6BQ== X-Forwarded-Encrypted: i=1; AJvYcCVrWTsF4OD8jPLx6vJKbGcstEBrmdvACIq+WZGZeRH9SAr0AZnaMfLUX46sspVnjGTPnOLZhA9u3Ap6@vger.kernel.org, AJvYcCXXh3+yZT+nz2dM9Co3Ma4igdGEFn9WkZE5HVmp2nFtxf5VohMpEX9dh6Z6RAxDfCNDoNyBeyvC7y1e5Us5@vger.kernel.org X-Gm-Message-State: AOJu0YxoXHeYNwvSCG1/793Pw5HxSnjXZmDvAyMQEhDMVC1DXeexczHl klD8MX2NbwYbKh4dUPT9m+7560LKJA9zhQS4rpihwVWohJAAkShbvdQF X-Gm-Gg: ASbGncuspDtPcZs/rBGpMfDJYI6DkuZzy7RNkJbDRi2GiCsWZi/ukpPWd92fXJVLfv8 hyWD3lVb9vsjmrAUiAJvRQWRxqGGWSTcGK9bE1FxnH8z6clfN02Y6YmnCHzprn/AoAmUjvMlf+7 vth1GBR+B9qnKcodtSBBuQ8iC8OI69tNhQJy5PqMbMyKdVNuNfe4UIy9NTAQKYa8TE29dohG5DE uWZb3EVzIJPzDZh0zEmMtnqVoI6QJEQe1xfMcYfqg69Uumv1cwghBLTn8AwLVEMYslR4z3GIvFg CdJADouGrRuWeEX0luF/SejrIao5FySBWVWNbx5stmy3rLZWchQPlXvlVQtvZEQlkzyZhG4Bknk Jq7hXzeI6uF7TOBhBT1ml4Z6gh5R8pBzIvDNl0w== X-Google-Smtp-Source: AGHT+IHiAEKzjNZ893PL+wikbfz76WmuOnADXgWPN/rVP9WwwZX/uNaqkN6hmqwjlZCMidnBEi0GKw== X-Received: by 2002:a17:903:32c9:b0:245:fa00:6e25 with SMTP id d9443c01a7336-24944a9bebdmr38079485ad.28.1756579396315; Sat, 30 Aug 2025 11:43:16 -0700 (PDT) Received: from [192.168.1.19] ([122.177.240.86]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2490658999fsm56821665ad.112.2025.08.30.11.43.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 30 Aug 2025 11:43:15 -0700 (PDT) From: Bharadwaj Raju Date: Sun, 31 Aug 2025 00:12:45 +0530 Subject: [PATCH 1/5] dt-bindings: iio: imu: Add ICM-20948 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250831-icm20948-v1-1-1fe560a38de4@gmail.com> References: <20250831-icm20948-v1-0-1fe560a38de4@gmail.com> In-Reply-To: <20250831-icm20948-v1-0-1fe560a38de4@gmail.com> To: Jonathan Cameron , David Lechner , =?utf-8?q?Nuno_S=C3=A1?= , Andy Shevchenko , Rob Herring , Krzysztof Kozlowski , Conor Dooley Cc: linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, shuah@kernel.org, linux-kernel-mentees@lists.linux.dev, Bharadwaj Raju X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1756579380; l=1510; i=bharadwaj.raju777@gmail.com; s=20250830; h=from:subject:message-id; bh=oVbXo+WlMRVlhb0eRpFRU7JepS0fcP7SScAWqWR1jf8=; b=cK6T2sOCnhY+6oWzEJ29uRSw2k4Ip7H30NUZdkO1uKtolKDKWb1JA+B5ESNnIftxn5E/mXNLF yAZf5y3MDa0C/bTJ/mgzQvpNozNyUeurGMUf0YjbhPVzx0NYKEeSxlz X-Developer-Key: i=bharadwaj.raju777@gmail.com; a=ed25519; pk=s+pP76EgUCC/7pyu4E6Q5AizWQ1T6hUf1jUWrQRl040= Document device-tree bindings for the InvenSense ICM-20948 device. Signed-off-by: Bharadwaj Raju --- .../bindings/iio/imu/invensense,icm20948.yaml | 36 ++++++++++++++++++= ++++ 1 file changed, 36 insertions(+) diff --git a/Documentation/devicetree/bindings/iio/imu/invensense,icm20948.= yaml b/Documentation/devicetree/bindings/iio/imu/invensense,icm20948.yaml new file mode 100644 index 0000000000000000000000000000000000000000..00c8210a0285972f8084137c69a= 4618a1f674485 --- /dev/null +++ b/Documentation/devicetree/bindings/iio/imu/invensense,icm20948.yaml @@ -0,0 +1,36 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/iio/imu/invensense,icm20948.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: InvenSense ICM-20948 Inertial Measurement Unit + +maintainers: + - Bharadwaj Raju + +description: | + 9-axis motion-tracking device that combines a 3-axis gyroscope, 3-axis + accelerometer, and a 3-axis magnetometer. + + https://invensense.tdk.com/wp-content/uploads/2024/03/DS-000189-ICM-2094= 8-v1.6.pdf + +properties: + compatible: + enum: + - invensense,icm20948 + + reg: + maxItems: 1 + +examples: + - | + i2c { + #address-cells =3D <1>; + #size-cells =3D <0>; + + icm20948 { + compatible =3D "invensense,icm20948"; + reg =3D <0x69>; + } + } --=20 2.51.0 From nobody Fri Oct 3 13:23:47 2025 Received: from mail-pg1-f171.google.com (mail-pg1-f171.google.com [209.85.215.171]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 405492DBF6E; Sat, 30 Aug 2025 18:43:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.171 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1756579405; cv=none; b=Ex+aYD5Cyn5K9mvNcItryrToLy9gHMY/QJ+6pkZTxyoMYob60x9TcZicCeFvmTvG0VKU9fG4RPEDxwi1MoLLlgG6PzADbZ7dVKYn7hywfN1N+vmRl49ukycCPhMQ6xqshNuKzWwuUewrkTOatthwM7cJNl7qqvwpTcV+oXbn+DI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1756579405; c=relaxed/simple; bh=2BQki3rOQvZSSbICEdQ41lJZWBOC1qWNjLJixqk7BPY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=myPELA/vE2W2bx9gmYVQToLil8VvcjJweUhA2onstxOAlCEFCfSbofmf3gbY3gOh4YBFCbZeQNbXZqQV3ne1N7K/WBUSNwYL306ktay8Vdq8XpTdbQVk/sSnb/tRVn4s6AH8eomyGUltPkwlbeVI/JCUnVc0vgpaYZKClRMBQ4A= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=bo263YhJ; arc=none smtp.client-ip=209.85.215.171 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="bo263YhJ" Received: by mail-pg1-f171.google.com with SMTP id 41be03b00d2f7-b4df220483fso754384a12.2; Sat, 30 Aug 2025 11:43:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1756579401; x=1757184201; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=sYn8yD0BD7KBURI/1KwhOSv9mwPsTskduF2no0+ubVQ=; b=bo263YhJMjWNNpsggxzrcTTuHg06nwAilMlzm1gryBdoLcYv/Y2RFlTrYlJtbHeQRw v9awCAlICy1Gu0oE2TibOXkE2sEqmYbFNFxv2uEIVhFIcphMZ/8Ug9X0m0nTgB/3nc4d LWnRS9uglCLV7gGxHzN1qwLLDmLFd7kEv6gi3soG0DQJ9Ia82jkW7I6Uz79R+o1/nnmx 7lvyp/EbWnRB96yQP0YVDFIonKQlvQWRe4EM8xEZlVchdeiAWI2E2wdD1L/x1gNUWlPI K8ryJ3F7osF2OoUnobaDu+Q8Q9ZwepJPMc48qdRudaJ3fFyAgXZa7DRJXTXAq8tHb8Ya 01ag== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1756579401; x=1757184201; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=sYn8yD0BD7KBURI/1KwhOSv9mwPsTskduF2no0+ubVQ=; b=iNiQqL3UuVR+i/Zq6KoGsNWeJeMTFgqtFQLMrZ6EKvL1lU0D+Hl70dBcGAGsr2LMRe 2uoH9TFE9Akm9bpUgp1PJ/Y/sLvVHqHaxfaXh0otDyWJl+HT2GDQs+X6kX5Corb8Au/B 5gijmuelQSFevoByPGVwROXBJtqQMWm4cG+UhV8fd0PoG/6X12l5T3zaUH3/e5YI3TiO hiFfoki16EnoOnURbBm33dQgGDaedGzhChRxOWJ1HMnxcsoTEKo6iGnqrXvXspYQU8wY kutylXSPuw8oT1pIC4n6+zB7Rs/mQ4rzqWZBQSqMoNgkRjNFrgh0S1fzTblm0tow25wK vyxw== X-Forwarded-Encrypted: i=1; AJvYcCWPqkzRAMe+0cSFKLlhkM8af4HyJqXp4Bzf+XJCNQDXnC2niQ1rRjZPaaAP9/n/HF1a8EjAReMAF5NAX6Yb@vger.kernel.org, AJvYcCXkQ1Fy/KDAYULH7s1jZ8AwbDlSgxgkJuBtXow9t/HxEktPrd3RgDQLHH1doJA6uG7tRQKwhaPCjDXX@vger.kernel.org X-Gm-Message-State: AOJu0Yy5FWhP1xGuSwqlMfGDEMjEDdHqJhcFYT5nuiQLLH5SRQWzqu6P umOM9faEe3v6wuHiBolrIkeaXvqKoUoTTvh64gwOoDawM/0PqXOIx1fy X-Gm-Gg: ASbGncsT6yj9ozMTCdmW4RXiXSW4/vtx8bndlVsFiikSyCiFr1c8p/XCMP3VPsXrux2 HbCgbC8amw84np+kVn/b2zh3+ur8jEVxsnKOKkIIeVBWGSou+phcgBA+4ItrEoPpTANJUqtAIH+ +k3N/e1t+5FpaMCofBhAwl4Smfe/uA6/pKnk1BQSA5cj8a2K3gESRdIXCim45aSKO4ehsJsG3Y+ M7qu/zqKuH1OpMpPfZwy5xVyUckWkQre5Rtn5hk8G4GSZ7xWFmBwchNj+k5BQUBKwqcZLIjyJSr lVnHIW7DGR0pqSJkBQPL4+X5TxJiqT81s7md7NohVtGYIHUGdv8nERciJmnqsKw6FmSPRpufwX4 JknagGVd9X05kazQqOIX6QXfULclZs3C/YwJkCQ== X-Google-Smtp-Source: AGHT+IF2RiISKjH88j+9XDvLxOnJgFclY1F4bSMS27yUB5LyojfMcA1dqZ9K8n7Et/oH1Q+N6LP4XQ== X-Received: by 2002:a17:902:f68f:b0:246:2e9:da9e with SMTP id d9443c01a7336-2494485bb9bmr42532885ad.6.1756579401386; Sat, 30 Aug 2025 11:43:21 -0700 (PDT) Received: from [192.168.1.19] ([122.177.240.86]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2490658999fsm56821665ad.112.2025.08.30.11.43.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 30 Aug 2025 11:43:21 -0700 (PDT) From: Bharadwaj Raju Date: Sun, 31 Aug 2025 00:12:46 +0530 Subject: [PATCH 2/5] iio: imu: add inv_icm20948 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250831-icm20948-v1-2-1fe560a38de4@gmail.com> References: <20250831-icm20948-v1-0-1fe560a38de4@gmail.com> In-Reply-To: <20250831-icm20948-v1-0-1fe560a38de4@gmail.com> To: Jonathan Cameron , David Lechner , =?utf-8?q?Nuno_S=C3=A1?= , Andy Shevchenko , Rob Herring , Krzysztof Kozlowski , Conor Dooley Cc: linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, shuah@kernel.org, linux-kernel-mentees@lists.linux.dev, Bharadwaj Raju X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1756579380; l=13258; i=bharadwaj.raju777@gmail.com; s=20250830; h=from:subject:message-id; bh=2BQki3rOQvZSSbICEdQ41lJZWBOC1qWNjLJixqk7BPY=; b=5MZZHCT9HMAIpD2HFFAgin3vhl3D6hSjQm+GOzEVg7V7Q5b5zWUcJJtHKhPIJT3n5FKT/6OxK vNiWqyvDf1dCpsTQZfJ9SXwSeH/UmnLcwazYtJ/Q7HNINDo2xs2YKD6 X-Developer-Key: i=bharadwaj.raju777@gmail.com; a=ed25519; pk=s+pP76EgUCC/7pyu4E6Q5AizWQ1T6hUf1jUWrQRl040= Core parts of the new ICM20948 driver. Add register definitions, probing, setup, and an IIO device for reading the onboard temperature sensor. Signed-off-by: Bharadwaj Raju --- drivers/iio/imu/Kconfig | 1 + drivers/iio/imu/Makefile | 1 + drivers/iio/imu/inv_icm20948/Kconfig | 17 ++++ drivers/iio/imu/inv_icm20948/Makefile | 8 ++ drivers/iio/imu/inv_icm20948/inv_icm20948.h | 47 +++++++++ drivers/iio/imu/inv_icm20948/inv_icm20948_core.c | 122 +++++++++++++++++++= ++++ drivers/iio/imu/inv_icm20948/inv_icm20948_i2c.c | 48 +++++++++ drivers/iio/imu/inv_icm20948/inv_icm20948_temp.c | 108 ++++++++++++++++++++ 8 files changed, 352 insertions(+) diff --git a/drivers/iio/imu/Kconfig b/drivers/iio/imu/Kconfig index 15612f0f189b5114deb414ef840339678abdc562..d59e5b0087398cfbd2719ca914f= d147ab067155f 100644 --- a/drivers/iio/imu/Kconfig +++ b/drivers/iio/imu/Kconfig @@ -109,6 +109,7 @@ config KMX61 be called kmx61. =20 source "drivers/iio/imu/inv_icm42600/Kconfig" +source "drivers/iio/imu/inv_icm20948/Kconfig" source "drivers/iio/imu/inv_mpu6050/Kconfig" =20 config SMI240 diff --git a/drivers/iio/imu/Makefile b/drivers/iio/imu/Makefile index e901aea498d37e5897e8b71268356a19eac2cb59..79e49bae59038c1ca1d54a64cf4= 9b6ca5f57cb0b 100644 --- a/drivers/iio/imu/Makefile +++ b/drivers/iio/imu/Makefile @@ -25,6 +25,7 @@ obj-$(CONFIG_FXOS8700_I2C) +=3D fxos8700_i2c.o obj-$(CONFIG_FXOS8700_SPI) +=3D fxos8700_spi.o =20 obj-y +=3D inv_icm42600/ +obj-y +=3D inv_icm20948/ obj-y +=3D inv_mpu6050/ =20 obj-$(CONFIG_KMX61) +=3D kmx61.o diff --git a/drivers/iio/imu/inv_icm20948/Kconfig b/drivers/iio/imu/inv_icm= 20948/Kconfig new file mode 100644 index 0000000000000000000000000000000000000000..79ffbe273e71f27ec33fffa0286= eafd7dd11aa29 --- /dev/null +++ b/drivers/iio/imu/inv_icm20948/Kconfig @@ -0,0 +1,17 @@ +# SPDX-License-Identifier: GPL-2.0-or-later + +config INV_ICM20948 + tristate + +config INV_ICM20948_I2C + tristate "InvenSense ICM-20948 I2C driver" + depends on I2C + select INV_ICM20948 + select REGMAP_I2C + help + This driver supports the InvenSense ICM-20948 motion tracking + device over I2C. + + This driver can be built as a module. The module will be called + inv-icm20948-i2c. + diff --git a/drivers/iio/imu/inv_icm20948/Makefile b/drivers/iio/imu/inv_ic= m20948/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..c508c2dc3eee2c32be20067e3e0= 868a203d8aa1a --- /dev/null +++ b/drivers/iio/imu/inv_icm20948/Makefile @@ -0,0 +1,8 @@ +# SPDX-License-Identifier: GPL-2.0-or-later + +obj-$(CONFIG_INV_ICM20948) +=3D inv-icm20948.o +inv-icm20948-y +=3D inv_icm20948_core.o +inv-icm20948-y +=3D inv_icm20948_temp.o + +obj-$(CONFIG_INV_ICM20948_I2C) +=3D inv-icm20948-i2c.o +inv-icm20948-i2c-y +=3D inv_icm20948_i2c.o diff --git a/drivers/iio/imu/inv_icm20948/inv_icm20948.h b/drivers/iio/imu/= inv_icm20948/inv_icm20948.h new file mode 100644 index 0000000000000000000000000000000000000000..f9830645fbe96fd02eef7c54d1e= 5908647d5a0fe --- /dev/null +++ b/drivers/iio/imu/inv_icm20948/inv_icm20948.h @@ -0,0 +1,47 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2025 Bharadwaj Raju + */ + +#ifndef INV_ICM20948_H_ +#define INV_ICM20948_H_ + +#include +#include +#include +#include +#include +#include +#include + +/* accel takes 20ms, gyro takes 35ms to wake from full-chip sleep */ +#define INV_ICM20948_SLEEP_WAKEUP_MS 35 + +#define INV_ICM20948_REG_BANK_SEL 0x7F +#define INV_ICM20948_BANK_SEL_MASK GENMASK(5, 4) + +#define INV_ICM20948_REG_WHOAMI 0x0000 +#define INV_ICM20948_WHOAMI 0xEA + +#define INV_ICM20948_REG_FIFO_RW 0x0072 + +#define INV_ICM20948_REG_PWR_MGMT_1 0x0006 +#define INV_ICM20948_PWR_MGMT_1_DEV_RESET BIT(7) +#define INV_ICM20948_PWR_MGMT_1_SLEEP BIT(6) + +#define INV_ICM20948_REG_TEMP_DATA 0x0039 + +extern const struct regmap_config inv_icm20948_regmap_config; + +struct inv_icm20948_state { + struct device *dev; + struct regmap *regmap; + struct iio_dev *temp_dev; + struct mutex lock; +}; + +extern int inv_icm20948_core_probe(struct regmap *regmap); + +struct iio_dev *inv_icm20948_temp_init(struct inv_icm20948_state *state); + +#endif diff --git a/drivers/iio/imu/inv_icm20948/inv_icm20948_core.c b/drivers/iio= /imu/inv_icm20948/inv_icm20948_core.c new file mode 100644 index 0000000000000000000000000000000000000000..ee9e4159cffa261f0326b146a4b= 3df2cbfbd7697 --- /dev/null +++ b/drivers/iio/imu/inv_icm20948/inv_icm20948_core.c @@ -0,0 +1,122 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Copyright (C) 2025 Bharadwaj Raju + */ + +#include "inv_icm20948.h" + +static const struct regmap_range_cfg inv_icm20948_regmap_ranges[] =3D { + { + .name =3D "user banks", + .range_min =3D 0x0000, + .range_max =3D 0x3FFF, + .selector_reg =3D INV_ICM20948_REG_BANK_SEL, + .selector_mask =3D INV_ICM20948_BANK_SEL_MASK, + .window_start =3D 0, + .window_len =3D 0x1000, + }, +}; + +static const struct regmap_range inv_icm20948_regmap_volatile_yes_ranges[]= =3D { + /* WHOAMI */ + regmap_reg_range(0x0000, 0x0000), + /* PWR_MGMT_1 */ + regmap_reg_range(0x0006, 0x0006), + /* I2C and INT status */ + regmap_reg_range(0x0017, 0x001C), + /* Sensor readouts */ + regmap_reg_range(0x0028, 0x0052), + /* FIFO count and data */ + regmap_reg_range(0x0070, 0x0072), + /* Data ready status */ + regmap_reg_range(0x0074, 0x0074), + /* GYRO_CONFIG_1 */ + regmap_reg_range(0x2001, 0x2001), + /* I2C SLV4 data in */ + regmap_reg_range(0x307F, 0x307F), +}; + +static const struct regmap_access_table inv_icm20948_regmap_volatile_acces= ses =3D { + .yes_ranges =3D inv_icm20948_regmap_volatile_yes_ranges, + .n_yes_ranges =3D ARRAY_SIZE(inv_icm20948_regmap_volatile_yes_ranges), +}; + +static const struct regmap_range inv_icm20948_rd_noinc_no_ranges[] =3D { + regmap_reg_range(0x0000, INV_ICM20948_REG_FIFO_RW - 1), + regmap_reg_range(INV_ICM20948_REG_FIFO_RW + 1, 0x3FFF), +}; + +static const struct regmap_access_table inv_icm20948_regmap_rd_noinc_table= =3D { + .no_ranges =3D inv_icm20948_rd_noinc_no_ranges, + .n_no_ranges =3D ARRAY_SIZE(inv_icm20948_rd_noinc_no_ranges), +}; + +const struct regmap_config inv_icm20948_regmap_config =3D { + .name =3D "inv_icm20948", + .reg_bits =3D 8, + .val_bits =3D 8, + .max_register =3D 0x3FFF, + .ranges =3D inv_icm20948_regmap_ranges, + .num_ranges =3D ARRAY_SIZE(inv_icm20948_regmap_ranges), + .volatile_table =3D &inv_icm20948_regmap_volatile_accesses, + .rd_noinc_table =3D &inv_icm20948_regmap_rd_noinc_table, + .cache_type =3D REGCACHE_MAPLE, +}; +EXPORT_SYMBOL_NS_GPL(inv_icm20948_regmap_config, "IIO_ICM20948"); + +static int inv_icm20948_setup(struct inv_icm20948_state *state) +{ + guard(mutex)(&state->lock); + + int reported_whoami; + int ret =3D regmap_read(state->regmap, INV_ICM20948_REG_WHOAMI, + &reported_whoami); + if (ret) + return ret; + if (reported_whoami !=3D INV_ICM20948_WHOAMI) { + dev_err(state->dev, "invalid whoami %d, expected %d\n", + reported_whoami, INV_ICM20948_WHOAMI); + return -ENODEV; + } + + ret =3D regmap_write_bits(state->regmap, INV_ICM20948_REG_PWR_MGMT_1, + INV_ICM20948_PWR_MGMT_1_DEV_RESET, + INV_ICM20948_PWR_MGMT_1_DEV_RESET); + if (ret) + return ret; + msleep(INV_ICM20948_SLEEP_WAKEUP_MS); + + ret =3D regmap_write_bits(state->regmap, INV_ICM20948_REG_PWR_MGMT_1, + INV_ICM20948_PWR_MGMT_1_SLEEP, 0); + if (ret) + return ret; + msleep(INV_ICM20948_SLEEP_WAKEUP_MS); + + state->temp_dev =3D inv_icm20948_temp_init(state); + if (IS_ERR(state->temp_dev)) + return PTR_ERR(state->temp_dev); + + return 0; +} + +int inv_icm20948_core_probe(struct regmap *regmap) +{ + struct device *dev =3D regmap_get_device(regmap); + + struct inv_icm20948_state *state; + + state =3D devm_kzalloc(dev, sizeof(*state), GFP_KERNEL); + if (!state) + return -ENOMEM; + + state->regmap =3D regmap; + state->dev =3D dev; + + mutex_init(&state->lock); + + return inv_icm20948_setup(state); +} + +MODULE_AUTHOR("Bharadwaj Raju "); +MODULE_DESCRIPTION("InvenSense ICM-20948 device driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/iio/imu/inv_icm20948/inv_icm20948_i2c.c b/drivers/iio/= imu/inv_icm20948/inv_icm20948_i2c.c new file mode 100644 index 0000000000000000000000000000000000000000..cf04d82e014a2497592c9a15bbd= e6e36f431dd56 --- /dev/null +++ b/drivers/iio/imu/inv_icm20948/inv_icm20948_i2c.c @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Copyright (C) 2025 Bharadwaj Raju + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "inv_icm20948.h" + +static int inv_icm20948_probe(struct i2c_client *client) +{ + struct regmap *regmap =3D + devm_regmap_init_i2c(client, &inv_icm20948_regmap_config); + if (IS_ERR(regmap)) + return PTR_ERR(regmap); + + return inv_icm20948_core_probe(regmap); +} + +static const struct i2c_device_id inv_icm20948_id[] =3D { { "icm20948" }, = {} }; +MODULE_DEVICE_TABLE(i2c, inv_icm20948_id); + +static const struct of_device_id inv_icm20948_of_matches[] =3D { + { .compatible =3D "invensense,icm20948" }, + {} +}; +MODULE_DEVICE_TABLE(of, inv_icm20948_of_matches); + +static struct i2c_driver inv_icm20948_driver =3D { + .driver =3D { + .name =3D "icm20948", + .of_match_table =3D inv_icm20948_of_matches, + }, + .probe =3D inv_icm20948_probe, + .id_table =3D inv_icm20948_id, +}; +module_i2c_driver(inv_icm20948_driver); + +MODULE_AUTHOR("Bharadwaj Raju "); +MODULE_DESCRIPTION("InvenSense ICM-20948 device driver (I2C)"); +MODULE_LICENSE("GPL"); +MODULE_IMPORT_NS("IIO_ICM20948"); diff --git a/drivers/iio/imu/inv_icm20948/inv_icm20948_temp.c b/drivers/iio= /imu/inv_icm20948/inv_icm20948_temp.c new file mode 100644 index 0000000000000000000000000000000000000000..916053740cc5acda0316c76504d= 4086eff5ec7f0 --- /dev/null +++ b/drivers/iio/imu/inv_icm20948/inv_icm20948_temp.c @@ -0,0 +1,108 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Copyright (C) 2025 Bharadwaj Raju + */ + +#include + +#include + +#include "inv_icm20948.h" + +static const struct iio_chan_spec + inv_icm20948_temp_chan =3D { .type =3D IIO_TEMP, + .info_mask_separate =3D + BIT(IIO_CHAN_INFO_RAW) | + BIT(IIO_CHAN_INFO_OFFSET) | + BIT(IIO_CHAN_INFO_SCALE), + .scan_index =3D 0, + .scan_type =3D { + .sign =3D 's', + .realbits =3D 16, + } }; + +static int inv_icm20948_temp_read_sensor(struct inv_icm20948_state *state, + s16 *temp) +{ + guard(mutex)(&state->lock); + + __be16 raw; + int ret =3D regmap_bulk_read(state->regmap, INV_ICM20948_REG_TEMP_DATA, + &raw, sizeof(raw)); + if (ret) + return ret; + + *temp =3D __be16_to_cpu(raw); + + return 0; +} + +static int inv_icm20948_temp_read_raw(struct iio_dev *temp_dev, + struct iio_chan_spec const *chan, + int *val, int *val2, long mask) +{ + struct inv_icm20948_state *state =3D iio_device_get_drvdata(temp_dev); + + switch (mask) { + case IIO_CHAN_INFO_RAW: + if (!iio_device_claim_direct(temp_dev)) + return -EBUSY; + s16 temp; + int ret =3D inv_icm20948_temp_read_sensor(state, &temp); + + if (ret) + return ret; + iio_device_release_direct(temp_dev); + *val =3D temp; + return IIO_VAL_INT; + /* + * Sensitivity =3D 333.87 + * RoomTempOff =3D 21 + * T_degC =3D ((T_raw - RoomTempOff) / Sensitivity) + RoomTempOff + * T_degC =3D ((T_raw - 21) / 333.87) + 21 + * T_milliDegC =3D 1000 * (((T_raw - 21) / 333.87) + 21) + * T_milliDegC =3D (1000 / 333.87) * (T_raw - 21 + (21 * 333.87)) + * T_milliDegC =3D (T_raw + 6990.27) * 2.995177 + + * scale =3D 2.995177 + * offset =3D 6990.27 + */ + case IIO_CHAN_INFO_SCALE: + *val =3D 2; + *val2 =3D 995177; + return IIO_VAL_INT_PLUS_MICRO; + case IIO_CHAN_INFO_OFFSET: + *val =3D 6990; + *val2 =3D 270000; + return IIO_VAL_INT_PLUS_MICRO; + default: + return -EINVAL; + } +} + +static const struct iio_info inv_icm20948_temp_info =3D { + .read_raw =3D inv_icm20948_temp_read_raw, +}; + +struct iio_dev *inv_icm20948_temp_init(struct inv_icm20948_state *state) +{ + struct iio_dev *temp_dev =3D devm_iio_device_alloc(state->dev, 0); + + if (!temp_dev) + return ERR_PTR(-ENOMEM); + + iio_device_set_drvdata(temp_dev, state); + + temp_dev->name =3D "icm20948-temp"; + temp_dev->info =3D &inv_icm20948_temp_info; + temp_dev->modes =3D INDIO_DIRECT_MODE; + temp_dev->channels =3D &inv_icm20948_temp_chan; + temp_dev->num_channels =3D 1; + + int ret =3D devm_iio_device_register(state->dev, temp_dev); + + if (ret) + return ERR_PTR(ret); + + return temp_dev; +} --=20 2.51.0 From nobody Fri Oct 3 13:23:47 2025 Received: from mail-pg1-f182.google.com (mail-pg1-f182.google.com [209.85.215.182]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id F11DD2DCBE2; Sat, 30 Aug 2025 18:43:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.182 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1756579409; cv=none; b=sggnzHSGx7xu+fJRe3RIwmGCkNdd4AqMxEAlTHD6sz6e4E+C8lMFKV3/CtYFGWipGhEmBahlYGQIU+vqHtH0mtD76QtaIxys5jwFKYi9+Hn1cO9aq4SVp6vgQmD60YMDm6NMrlIAgfug0dgpMA6UTeCbfLX5qHE0lUT5o7TnmN0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1756579409; c=relaxed/simple; bh=K7rF2bt3HkEHRZ3fBUFmWsLziT5AfBMIgTUQVX8HyuY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=VyPBeiZ4J7CWvUBI4CZEmPnqcp/H6Lw65cNwklr9FSJ1hPAgyzjljyo7f1X1gVlWsL9jSgKHSTsC4X55rToDjbBoRSWQQnfhGAGGC1GDHwHpweRy1MooWP5ephiY4Y2RGO9Pz+HYMmqHOdFxcQYKrx8sytAnhdd4SRkQTAw9g7k= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=A0RmojyJ; arc=none smtp.client-ip=209.85.215.182 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="A0RmojyJ" Received: by mail-pg1-f182.google.com with SMTP id 41be03b00d2f7-b4d1e7d5036so1068870a12.1; Sat, 30 Aug 2025 11:43:27 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1756579407; x=1757184207; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=Vj1yS9O+gUXgXX+X1gAHTGjRed1btcU//114VX10TmI=; b=A0RmojyJySPNQD09ClOeWzc4zdQ4LQJI9V+n6GkvfckbhJqrc0HdJ377nqj8Xh96Pw qO9d1lQJTXLgyBvffqCsEeyRT4e4RO6nYVCyrhJOMGpawaIBegj15oXky0qUTNXDH70G QRZLEgvrp9s0qyW/pZWzIqxwFEsfV1a/cg8EtwME/kiYlW8+PeqHPG4J1k4BrIYYLmTZ DhJwlbnc71WIxaXZxJ3cj0wnySwbNOJmobKwbRkz/ogvDKdFoQLmFheuEOgSZeNo36GC b5w5BjWhkugq0H3bMg1QT2WmrhkGK9YYlcsrfYbk8jh6u6zgLCJtmp1xb/myt/5wPXCu LZGA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1756579407; x=1757184207; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=Vj1yS9O+gUXgXX+X1gAHTGjRed1btcU//114VX10TmI=; b=XUWNYnZDqVJlEoU2O5KKBvFhCIax7itveRAMP1WvQVcA9ltFhBMhSV7oVJI2qK1x1Z rJoZzf1s4Gh3PCWTKB3XAqRlwoh9jlmHIY+XMpqGdNjg+Gt/1uTAf7CnMmY2Eg1TjYzV s15esoDL7XPN9QthYGGWO3vWAbyTa0CV3dHGAYJRUIpNeYTvw7VLy53oC2/J4JgFgUav SlyNJKzUTH2wi0PCfd/avwD/cVfuvrwteXTbejzhcQQ2h/+aiPd9YBcwpRbSz3JHZNCx D+BpO7H6wznBKFkMDIpzdfOb0oZaKfqXUpEP55afwVQoL/ak936S9hQtiM/RXS4dgDpz yZfg== X-Forwarded-Encrypted: i=1; AJvYcCWpk+IhZT29SXSMqOO72ypuBVJKqVjY+GBXOhhutloy7qjZunSk5tpnME8Tcypq8J8pj4sa+TrC8572LPO0@vger.kernel.org, AJvYcCXHulKOAELTgTvrW6q8H2j6tkVMTnvLHpijGFRkdk9Xzs2U+Tyg7RHoGTThalYWlSQW6RFJjsqdmy/E@vger.kernel.org X-Gm-Message-State: AOJu0YwYFTJfOzzER8rUrxHZVVrjZpF/zKycuNOgri9jcDoDaL4w/LsE ZlHgf949TgHgE45Pm6+f1vNpfhuKesrsDMmT8xSsb2xqHBorYhSCU9JkT7tICzPu X-Gm-Gg: ASbGncu3YX+H1ADiFjn+yiMSnPDUDyvxKKyWiVfFnc9AFJrXEPRQDpbboMPI0nIO0kb ermp6sCI/bdF6ZWMtWROpLQvqB5lXC08+0TkfJPbov/cbzAq5Jg4hvbU9qNXURGWrx1DDZtS/sM L92U/xn4P6SEW8s42BFT/Z23ix/PR+GpX9mn9zuM1oJVk4fJv4v/8svunZ09AZCnmrRQ5bSd2oh 5danVA4zXUFDNR1u0pX6ho7iSF7J58x4ik78nfV52+lxgeG8AyYEvoodqTc0KdkYOhYYXRJ/Okz h9FWvd+i3UydYVIEr1nII5R8d16DDA7Zo2ZGCkKEuxKulayTWZxwJQHJeK9bd+CpJLn+My3y+87 ukGNA5djltzVNRaVlgHhBpGj+wMqcwuVcJe7Qfw== X-Google-Smtp-Source: AGHT+IF3nKo2sqdBFb1VHTQ9UzNuttzGo/loyuiI3iilXsdQTk+0+TVLZktGEQ0//Aw9xC6ceTlNmQ== X-Received: by 2002:a17:902:f549:b0:249:19b0:d3d4 with SMTP id d9443c01a7336-24944b63e3amr41398435ad.52.1756579407179; Sat, 30 Aug 2025 11:43:27 -0700 (PDT) Received: from [192.168.1.19] ([122.177.240.86]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2490658999fsm56821665ad.112.2025.08.30.11.43.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 30 Aug 2025 11:43:26 -0700 (PDT) From: Bharadwaj Raju Date: Sun, 31 Aug 2025 00:12:47 +0530 Subject: [PATCH 3/5] iio: imu: icm20948: add support for gyroscope Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250831-icm20948-v1-3-1fe560a38de4@gmail.com> References: <20250831-icm20948-v1-0-1fe560a38de4@gmail.com> In-Reply-To: <20250831-icm20948-v1-0-1fe560a38de4@gmail.com> To: Jonathan Cameron , David Lechner , =?utf-8?q?Nuno_S=C3=A1?= , Andy Shevchenko , Rob Herring , Krzysztof Kozlowski , Conor Dooley Cc: linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, shuah@kernel.org, linux-kernel-mentees@lists.linux.dev, Bharadwaj Raju X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1756579380; l=16670; i=bharadwaj.raju777@gmail.com; s=20250830; h=from:subject:message-id; bh=K7rF2bt3HkEHRZ3fBUFmWsLziT5AfBMIgTUQVX8HyuY=; b=A8nODpJCVi3yyJfBagvDCloX0wUl4046Av67JL5Is8u/vwO+wsVwSXRTFNZzCAAKNgmyh99MH IvMyrMHW68NB+EZjHVqZhzYcjnPJdkQKfL+5nV38MPtyzX1X+7wLZd8 X-Developer-Key: i=bharadwaj.raju777@gmail.com; a=ed25519; pk=s+pP76EgUCC/7pyu4E6Q5AizWQ1T6hUf1jUWrQRl040= Add support for reading the gyroscope, which is exposed as another IIO device under the icm20948 driver. For now, the only configuration supported is changing the full-scale range. Signed-off-by: Bharadwaj Raju --- drivers/iio/imu/inv_icm20948/Makefile | 1 + drivers/iio/imu/inv_icm20948/inv_icm20948.h | 78 ++++-- drivers/iio/imu/inv_icm20948/inv_icm20948_core.c | 55 ++-- drivers/iio/imu/inv_icm20948/inv_icm20948_gyro.c | 343 +++++++++++++++++++= ++++ 4 files changed, 432 insertions(+), 45 deletions(-) diff --git a/drivers/iio/imu/inv_icm20948/Makefile b/drivers/iio/imu/inv_ic= m20948/Makefile index c508c2dc3eee2c32be20067e3e0868a203d8aa1a..88a37be159e1d6f575da1c070c8= 4ac94cd963020 100644 --- a/drivers/iio/imu/inv_icm20948/Makefile +++ b/drivers/iio/imu/inv_icm20948/Makefile @@ -3,6 +3,7 @@ obj-$(CONFIG_INV_ICM20948) +=3D inv-icm20948.o inv-icm20948-y +=3D inv_icm20948_core.o inv-icm20948-y +=3D inv_icm20948_temp.o +inv-icm20948-y +=3D inv_icm20948_gyro.o =20 obj-$(CONFIG_INV_ICM20948_I2C) +=3D inv-icm20948-i2c.o inv-icm20948-i2c-y +=3D inv_icm20948_i2c.o diff --git a/drivers/iio/imu/inv_icm20948/inv_icm20948.h b/drivers/iio/imu/= inv_icm20948/inv_icm20948.h index f9830645fbe96fd02eef7c54d1e5908647d5a0fe..ca2513114378cdcba5bc315fc94= cd61f930b4dfa 100644 --- a/drivers/iio/imu/inv_icm20948/inv_icm20948.h +++ b/drivers/iio/imu/inv_icm20948/inv_icm20948.h @@ -3,45 +3,83 @@ * Copyright (C) 2025 Bharadwaj Raju */ =20 -#ifndef INV_ICM20948_H_ -#define INV_ICM20948_H_ + #ifndef INV_ICM20948_H_ + #define INV_ICM20948_H_ =20 -#include -#include -#include -#include -#include -#include -#include + #include + #include + #include + #include + #include + #include + #include =20 /* accel takes 20ms, gyro takes 35ms to wake from full-chip sleep */ -#define INV_ICM20948_SLEEP_WAKEUP_MS 35 + #define INV_ICM20948_SLEEP_WAKEUP_MS 35 =20 -#define INV_ICM20948_REG_BANK_SEL 0x7F -#define INV_ICM20948_BANK_SEL_MASK GENMASK(5, 4) + #define INV_ICM20948_REG_BANK_SEL 0x7F + #define INV_ICM20948_BANK_SEL_MASK GENMASK(5, 4) =20 -#define INV_ICM20948_REG_WHOAMI 0x0000 -#define INV_ICM20948_WHOAMI 0xEA + #define INV_ICM20948_REG_WHOAMI 0x0000 + #define INV_ICM20948_WHOAMI 0xEA =20 -#define INV_ICM20948_REG_FIFO_RW 0x0072 + #define INV_ICM20948_REG_FIFO_RW 0x0072 =20 -#define INV_ICM20948_REG_PWR_MGMT_1 0x0006 -#define INV_ICM20948_PWR_MGMT_1_DEV_RESET BIT(7) -#define INV_ICM20948_PWR_MGMT_1_SLEEP BIT(6) + #define INV_ICM20948_REG_PWR_MGMT_1 0x0006 + #define INV_ICM20948_PWR_MGMT_1_DEV_RESET BIT(7) + #define INV_ICM20948_PWR_MGMT_1_SLEEP BIT(6) =20 -#define INV_ICM20948_REG_TEMP_DATA 0x0039 + #define INV_ICM20948_REG_TEMP_DATA 0x0039 + + #define INV_ICM20948_REG_GYRO_DATA_X 0x0033 + #define INV_ICM20948_REG_GYRO_DATA_Y 0x0035 + #define INV_ICM20948_REG_GYRO_DATA_Z 0x0037 + + #define INV_ICM20948_REG_GYRO_CONFIG_1 0x2001 + #define INV_ICM20948_GYRO_CONFIG_ENABLE_DLPF BIT(0) + #define INV_ICM20948_GYRO_CONFIG_FULLSCALE GENMASK(2, 1) + #define INV_ICM20948_GYRO_CONFIG_DLP_CONFIG GENMASK(5, 3) + + #define INV_ICM20948_REG_GYRO_USER_OFFSET_X 0x2003 + #define INV_ICM20948_REG_GYRO_USER_OFFSET_Y 0x2005 + #define INV_ICM20948_REG_GYRO_USER_OFFSET_Z 0x2007 =20 extern const struct regmap_config inv_icm20948_regmap_config; =20 +enum inv_icm20948_gyro_fs { + INV_ICM20948_GYRO_FS_250 =3D 0, + INV_ICM20948_GYRO_FS_500 =3D 1, + INV_ICM20948_GYRO_FS_1000 =3D 2, + INV_ICM20948_GYRO_FS_2000 =3D 3, +}; + +enum inv_icm20948_gyro_avg { + INV_ICM20948_GYRO_AVG_1X =3D 0, + INV_ICM20948_GYRO_AVG_2X =3D 1, + INV_ICM20948_GYRO_AVG_4X =3D 2, + INV_ICM20948_GYRO_AVG_8X =3D 3, + INV_ICM20948_GYRO_AVG_16X =3D 4, + INV_ICM20948_GYRO_AVG_32X =3D 5, + INV_ICM20948_GYRO_AVG_64X =3D 6, + INV_ICM20948_GYRO_AVG_128X =3D 7, +}; + +struct inv_icm20948_gyro_config { + int fsr; +}; + struct inv_icm20948_state { struct device *dev; struct regmap *regmap; struct iio_dev *temp_dev; + struct iio_dev *gyro_dev; + struct inv_icm20948_gyro_config *gyro_conf; struct mutex lock; }; =20 extern int inv_icm20948_core_probe(struct regmap *regmap); =20 struct iio_dev *inv_icm20948_temp_init(struct inv_icm20948_state *state); +struct iio_dev *inv_icm20948_gyro_init(struct inv_icm20948_state *state); =20 -#endif + #endif diff --git a/drivers/iio/imu/inv_icm20948/inv_icm20948_core.c b/drivers/iio= /imu/inv_icm20948/inv_icm20948_core.c index ee9e4159cffa261f0326b146a4b3df2cbfbd7697..eb4f940de7013bf4ddeb69b6380= a60fbde49964a 100644 --- a/drivers/iio/imu/inv_icm20948/inv_icm20948_core.c +++ b/drivers/iio/imu/inv_icm20948/inv_icm20948_core.c @@ -3,7 +3,7 @@ * Copyright (C) 2025 Bharadwaj Raju */ =20 -#include "inv_icm20948.h" + #include "inv_icm20948.h" =20 static const struct regmap_range_cfg inv_icm20948_regmap_ranges[] =3D { { @@ -66,36 +66,41 @@ EXPORT_SYMBOL_NS_GPL(inv_icm20948_regmap_config, "IIO_I= CM20948"); =20 static int inv_icm20948_setup(struct inv_icm20948_state *state) { - guard(mutex)(&state->lock); - - int reported_whoami; - int ret =3D regmap_read(state->regmap, INV_ICM20948_REG_WHOAMI, - &reported_whoami); - if (ret) - return ret; - if (reported_whoami !=3D INV_ICM20948_WHOAMI) { - dev_err(state->dev, "invalid whoami %d, expected %d\n", - reported_whoami, INV_ICM20948_WHOAMI); - return -ENODEV; + scoped_guard(mutex, &state->lock) { + int reported_whoami; + int ret =3D regmap_read(state->regmap, INV_ICM20948_REG_WHOAMI, + &reported_whoami); + if (ret) + return ret; + if (reported_whoami !=3D INV_ICM20948_WHOAMI) { + dev_err(state->dev, "invalid whoami %d, expected %d\n", + reported_whoami, INV_ICM20948_WHOAMI); + return -ENODEV; + } + + ret =3D regmap_write_bits(state->regmap, INV_ICM20948_REG_PWR_MGMT_1, + INV_ICM20948_PWR_MGMT_1_DEV_RESET, + INV_ICM20948_PWR_MGMT_1_DEV_RESET); + if (ret) + return ret; + msleep(INV_ICM20948_SLEEP_WAKEUP_MS); + + ret =3D regmap_write_bits(state->regmap, INV_ICM20948_REG_PWR_MGMT_1, + INV_ICM20948_PWR_MGMT_1_SLEEP, 0); + if (ret) + return ret; + + msleep(INV_ICM20948_SLEEP_WAKEUP_MS); } =20 - ret =3D regmap_write_bits(state->regmap, INV_ICM20948_REG_PWR_MGMT_1, - INV_ICM20948_PWR_MGMT_1_DEV_RESET, - INV_ICM20948_PWR_MGMT_1_DEV_RESET); - if (ret) - return ret; - msleep(INV_ICM20948_SLEEP_WAKEUP_MS); - - ret =3D regmap_write_bits(state->regmap, INV_ICM20948_REG_PWR_MGMT_1, - INV_ICM20948_PWR_MGMT_1_SLEEP, 0); - if (ret) - return ret; - msleep(INV_ICM20948_SLEEP_WAKEUP_MS); - state->temp_dev =3D inv_icm20948_temp_init(state); if (IS_ERR(state->temp_dev)) return PTR_ERR(state->temp_dev); =20 + state->gyro_dev =3D inv_icm20948_gyro_init(state); + if (IS_ERR(state->gyro_dev)) + return PTR_ERR(state->gyro_dev); + return 0; } =20 diff --git a/drivers/iio/imu/inv_icm20948/inv_icm20948_gyro.c b/drivers/iio= /imu/inv_icm20948/inv_icm20948_gyro.c new file mode 100644 index 0000000000000000000000000000000000000000..2d4d598eb21c8ce98d4ee3c7250= 4554ab49ea596 --- /dev/null +++ b/drivers/iio/imu/inv_icm20948/inv_icm20948_gyro.c @@ -0,0 +1,343 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Copyright (C) 2025 Bharadwaj Raju + */ + +#include + +#include + +#include "inv_icm20948.h" + +/* IIO int + nano format */ +static const int inv_icm20948_gyro_scale[] =3D { + /* 250 dps =3D=3D 0.000133158 rad/s per LSB */ + [2 * INV_ICM20948_GYRO_FS_250] =3D 0, + [2 * INV_ICM20948_GYRO_FS_250 + 1] =3D 133158, + /* 500 dps =3D=3D 0.000266316 rad/s per LSB */ + [2 * INV_ICM20948_GYRO_FS_500] =3D 0, + [2 * INV_ICM20948_GYRO_FS_500 + 1] =3D 266316, + /* 1000 dps =3D=3D 0.000532632 rad/s per LSB */ + [2 * INV_ICM20948_GYRO_FS_1000] =3D 0, + [2 * INV_ICM20948_GYRO_FS_1000 + 1] =3D 532632, + /* 2000 dps =3D=3D 0.001065264 rad/s per LSB */ + [2 * INV_ICM20948_GYRO_FS_1000] =3D 0, + [2 * INV_ICM20948_GYRO_FS_1000 + 1] =3D 1065264, +}; + +/* Calibration bias, IIO range format int + nano */ +/* raw value -2**15 to +2**15, 0.0305 dps per LSB step */ +static const int inv_icm20948_gyro_calibbias_range[] =3D { + -17, 443239423, /* min */ + 0, 532325, /* step */ + +17, 443239423, /* max */ +}; + +#define INV_ICM20948_GYRO_CHAN(_dir) \ + { \ + .type =3D IIO_ANGL_VEL, \ + .modified =3D 1, \ + .channel2 =3D IIO_MOD_##_dir, \ + .info_mask_separate =3D \ + BIT(IIO_CHAN_INFO_RAW) | \ + BIT(IIO_CHAN_INFO_CALIBBIAS), \ + .info_mask_shared_by_type =3D \ + BIT(IIO_CHAN_INFO_SCALE), \ + .info_mask_shared_by_type_available =3D \ + BIT(IIO_CHAN_INFO_SCALE) | \ + BIT(IIO_CHAN_INFO_CALIBBIAS), \ + .info_mask_shared_by_all =3D \ + BIT(IIO_CHAN_INFO_SAMP_FREQ), \ + .info_mask_shared_by_all_available =3D \ + BIT(IIO_CHAN_INFO_SAMP_FREQ), \ + .scan_index =3D INV_ICM20948_GYRO_SCAN_##_dir, \ + .scan_type =3D { \ + .sign =3D 's', \ + .realbits =3D 16, \ + .endianness =3D IIO_BE, \ + }, \ + } + +enum inv_icm20948_gyro_scan { + INV_ICM20948_GYRO_SCAN_X, + INV_ICM20948_GYRO_SCAN_Y, + INV_ICM20948_GYRO_SCAN_Z, +}; + +static const struct iio_chan_spec inv_icm20948_gyro_channels[] =3D { + INV_ICM20948_GYRO_CHAN(X), + INV_ICM20948_GYRO_CHAN(Y), + INV_ICM20948_GYRO_CHAN(Z), +}; + +static int inv_icm20948_gyro_apply_config(struct inv_icm20948_state *state) +{ + guard(mutex)(&state->lock); + + return regmap_write_bits(state->regmap, INV_ICM20948_REG_GYRO_CONFIG_1, + INV_ICM20948_GYRO_CONFIG_FULLSCALE, + state->gyro_conf->fsr << 1); +} + +static int inv_icm20948_gyro_read_sensor(struct inv_icm20948_state *state, + struct iio_chan_spec const *chan, + s16 *val) +{ + unsigned int reg; + + switch (chan->channel2) { + case IIO_MOD_X: + reg =3D INV_ICM20948_REG_GYRO_DATA_X; + break; + case IIO_MOD_Y: + reg =3D INV_ICM20948_REG_GYRO_DATA_Y; + break; + case IIO_MOD_Z: + reg =3D INV_ICM20948_REG_GYRO_DATA_Z; + break; + default: + return -EINVAL; + } + + __be16 raw; + int ret =3D regmap_bulk_read(state->regmap, reg, &raw, sizeof(raw)); + + if (ret) + return ret; + + *val =3D (s16)be16_to_cpu(raw); + + return 0; +} + +static int inv_icm20948_gyro_read_calibbias(struct inv_icm20948_state *sta= te, + struct iio_chan_spec const *chan, + int *val, int *val2) +{ + guard(mutex)(&state->lock); + + unsigned int reg; + + switch (chan->channel2) { + case IIO_MOD_X: + reg =3D INV_ICM20948_REG_GYRO_USER_OFFSET_X; + break; + case IIO_MOD_Y: + reg =3D INV_ICM20948_REG_GYRO_USER_OFFSET_Y; + break; + case IIO_MOD_Z: + reg =3D INV_ICM20948_REG_GYRO_USER_OFFSET_Z; + break; + default: + return -EINVAL; + } + + __be16 offset_raw; + int ret =3D regmap_bulk_read(state->regmap, reg, &offset_raw, + sizeof(offset_raw)); + + if (ret) + return ret; + int offset =3D be16_to_cpu(offset_raw); + + /* step size =3D 0.0305 dps/LSB =3D> +/- 999.24 dps over 16-bit range */ + /* offset * 0.0305 * Pi * 10**9 (for nano) / 180 */ + /* offset * 95818575.93448868 / 180 */ + /* offset * 95818576 / 180 */ + s64 val64 =3D (s64)offset * 95818576; + /* for rounding, add or subtract divisor/2 */ + if (val64 >=3D 0) + val64 +=3D 180 / 2; + else + val64 -=3D 180 / 2; + + s64 bias =3D div_s64(val64, 180); + + *val =3D bias / 1000000000L; + *val2 =3D bias % 1000000000L; + + return IIO_VAL_INT_PLUS_NANO; +} + +static int inv_icm20948_gyro_read_raw(struct iio_dev *gyro_dev, + struct iio_chan_spec const *chan, + int *val, int *val2, long mask) +{ + struct inv_icm20948_state *state =3D iio_device_get_drvdata(gyro_dev); + + if (chan->type !=3D IIO_ANGL_VEL) + return -EINVAL; + + switch (mask) { + case IIO_CHAN_INFO_RAW: + if (!iio_device_claim_direct(gyro_dev)) + return -EBUSY; + s16 raw; + int ret =3D inv_icm20948_gyro_read_sensor(state, chan, &raw); + + iio_device_release_direct(gyro_dev); + if (ret) + return ret; + *val =3D raw; + return IIO_VAL_INT; + case IIO_CHAN_INFO_SCALE: + *val =3D 0; + *val2 =3D inv_icm20948_gyro_scale[2 * state->gyro_conf->fsr + 1]; + return IIO_VAL_INT_PLUS_NANO; + case IIO_CHAN_INFO_CALIBBIAS: + return inv_icm20948_gyro_read_calibbias(state, chan, val, val2); + default: + return -EINVAL; + } +} + +static int inv_icm20948_gyro_write_scale(struct inv_icm20948_state *state, + int val, int val2) +{ + /* all supported scales are < 1.0 and > 0.0 */ + if (val !=3D 0) + return -EINVAL; + + int idx; + + for (idx =3D 0; idx < ARRAY_SIZE(inv_icm20948_gyro_scale); idx +=3D 2) { + if (val2 =3D=3D inv_icm20948_gyro_scale[idx + 1]) + break; + } + + if (idx >=3D ARRAY_SIZE(inv_icm20948_gyro_scale)) + return -EINVAL; + + state->gyro_conf->fsr =3D idx / 2; + return inv_icm20948_gyro_apply_config(state); +} + +static int inv_icm20948_write_calibbias(struct inv_icm20948_state *state, + struct iio_chan_spec const *chan, + int val, int val2) +{ + guard(mutex)(&state->lock); + + unsigned int reg; + + switch (chan->channel2) { + case IIO_MOD_X: + reg =3D INV_ICM20948_REG_GYRO_USER_OFFSET_X; + break; + case IIO_MOD_Y: + reg =3D INV_ICM20948_REG_GYRO_USER_OFFSET_Y; + break; + case IIO_MOD_Z: + reg =3D INV_ICM20948_REG_GYRO_USER_OFFSET_Z; + break; + default: + return -EINVAL; + } + + s64 bias =3D (s64)val * 100000000L + val2; + s64 val64 =3D bias * 180; + + if (val64 >=3D 0) + val64 -=3D 180 / 2; + else + val64 +=3D 180 / 2; + + s64 offset64 =3D div_s64(val64, 95818576L); + s16 offset =3D clamp(offset64, (s64)S16_MIN, (s64)S16_MAX); + __be16 offset_write =3D cpu_to_be16(offset); + + return regmap_bulk_write(state->regmap, reg, &offset_write, + sizeof(offset_write)); +} + +static int inv_icm20948_gyro_write_raw(struct iio_dev *gyro_dev, + struct iio_chan_spec const *chan, + int val, int val2, long mask) +{ + struct inv_icm20948_state *state =3D iio_device_get_drvdata(gyro_dev); + + int ret; + + if (chan->type !=3D IIO_ANGL_VEL) + return -EINVAL; + + switch (mask) { + case IIO_CHAN_INFO_SCALE: + if (!iio_device_claim_direct(gyro_dev)) + return -EBUSY; + ret =3D inv_icm20948_gyro_write_scale(state, val, val2); + iio_device_release_direct(gyro_dev); + return ret; + case IIO_CHAN_INFO_CALIBBIAS: + if (!iio_device_claim_direct(gyro_dev)) + return -EBUSY; + ret =3D inv_icm20948_write_calibbias(state, chan, val, val2); + iio_device_release_direct(gyro_dev); + return ret; + default: + return -EINVAL; + } +} + +static int inv_icm20948_gyro_read_avail(struct iio_dev *gyro_dev, + struct iio_chan_spec const *chan, + const int **vals, int *type, + int *length, long mask) +{ + if (chan->type !=3D IIO_ANGL_VEL) + return -EINVAL; + + switch (mask) { + case IIO_CHAN_INFO_SCALE: + *vals =3D inv_icm20948_gyro_scale; + *type =3D IIO_VAL_INT_PLUS_NANO; + *length =3D ARRAY_SIZE(inv_icm20948_gyro_scale); + return IIO_AVAIL_LIST; + case IIO_CHAN_INFO_CALIBBIAS: + *vals =3D inv_icm20948_gyro_calibbias_range; + *type =3D IIO_VAL_INT_PLUS_NANO; + *length =3D ARRAY_SIZE(inv_icm20948_gyro_calibbias_range); + return IIO_AVAIL_RANGE; + default: + return -EINVAL; + } +} + +static const struct iio_info inv_icm20948_gyro_info =3D { + .read_raw =3D inv_icm20948_gyro_read_raw, + .write_raw =3D inv_icm20948_gyro_write_raw, + .read_avail =3D inv_icm20948_gyro_read_avail, +}; + +struct iio_dev *inv_icm20948_gyro_init(struct inv_icm20948_state *state) +{ + struct iio_dev *gyro_dev =3D devm_iio_device_alloc(state->dev, 0); + + if (!gyro_dev) + return ERR_PTR(-ENOMEM); + + iio_device_set_drvdata(gyro_dev, state); + + gyro_dev->name =3D "icm20948-gyro"; + gyro_dev->info =3D &inv_icm20948_gyro_info; + gyro_dev->modes =3D INDIO_DIRECT_MODE; + gyro_dev->channels =3D inv_icm20948_gyro_channels; + gyro_dev->num_channels =3D ARRAY_SIZE(inv_icm20948_gyro_channels); + + int ret =3D devm_iio_device_register(state->dev, gyro_dev); + + if (ret) + return ERR_PTR(ret); + + state->gyro_conf =3D + devm_kzalloc(state->dev, sizeof(*state->gyro_conf), GFP_KERNEL); + if (!state->gyro_conf) + return ERR_PTR(-ENOMEM); + + state->gyro_conf->fsr =3D INV_ICM20948_GYRO_FS_250; + ret =3D inv_icm20948_gyro_apply_config(state); + if (ret) + return ERR_PTR(ret); + + return gyro_dev; +} --=20 2.51.0 From nobody Fri Oct 3 13:23:47 2025 Received: from mail-pg1-f181.google.com (mail-pg1-f181.google.com [209.85.215.181]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 741552DCF50; Sat, 30 Aug 2025 18:43:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.181 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1756579413; cv=none; b=Twc716xUbg2df3mPIRjfbshKwwLhx49G7jF+wWPzraAzC/hX4/W8QK7LORalQnZd22nxbcDfUcD4NT4R9N1EOemwowr4nfpkmlmashgtdHh0jGH8YqNJkLq9a2LrkTAEQyVeLDnkvF+6Ww9yGpM7ldwGLaKlQ8AAQlcwstxwKME= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1756579413; c=relaxed/simple; bh=S+oKo2tgTYiLtkAAs/iP4uzBUDKP2L0uoFWdETTsrIo=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=lOHGgeoFLu2+gdKk12Zc8lD+VXD++qTwkTntaxFCocZFuVN4EMcomsz0gRv+AbDmfoPobaQZFE0mtXBIJ09OIHuFY3lN9HpDGmny4x5hiH6mOoePtr83jzPMVhiJoByl6NUtK7jcUQJcJC2eUj5N9aMems0m9uEwixsjVhcy8QE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=RROIBbWH; arc=none smtp.client-ip=209.85.215.181 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="RROIBbWH" Received: by mail-pg1-f181.google.com with SMTP id 41be03b00d2f7-b4c8bee055cso1932910a12.2; Sat, 30 Aug 2025 11:43:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1756579412; x=1757184212; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=KZOnwZekOaDbGKj3yK05lCuGyy6Vu2QerK6bAmRqEcs=; b=RROIBbWHD8WVR+u9WPTvPVpROyis+niqiZmjvk1J/CzWb0/FXzZQoB7q0BodVJw/a3 7hlBmtaeILbWB+UaZ+6l7jYxD+AihUNtmOA0GrinZ2XrLTrGm0A3cIwAaPRwD9cGRCrd cVGt3+LrhhcEMxk828eClf7IUl+YE7zY8ZESInxV/UXu+10L3Ao74PfZhU8XNB9PwDIk P58sw5bqielQyHjq5ta1tZjOjBB5shzGK8p+PhJbQDqPcb3QgSqRYL4c7HsjaPqo8IM7 3SbVLtBqfC1n8jGPhfD/aATCuAm4Y/15T+ZJ1WZAne6qDdKLrG4J5J01bXo0LBAHd6jM aG1A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1756579412; x=1757184212; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=KZOnwZekOaDbGKj3yK05lCuGyy6Vu2QerK6bAmRqEcs=; b=Tg0s3ynjGmMgW62HY7pATuK43MIxKU20cDwRdOj8frYS48WDjDf/AcfpSIoUgjgPta Tx96neMkyR3lYKvPxJKLTDmW9JimPV7As9LfVBPx2wlaCi6loTxAsz6a6nP6IQhe9PJm d2lLrr04UE2WbKF1kzh+7k1Gf24h/7hj09AwKVvs56uBTRXipnf08AcoPlgqtFPtF73k TS1wkSsHBklRV0suW6OfHBP5DUj/R5itJYX5JaA2nO+I4iVByGuGd1lZnJmYmDN6NrPB 9PK0UG58NeaOxl5roNWK3rwmUyzDi56Y0iczTZ2S3EAy5bBL3F6PU1Ti6K8C1Hm6ub7d 0N1g== X-Forwarded-Encrypted: i=1; AJvYcCWOhxd4lb/WfER96eiVsCXvNgn2Vnv9bVHzZojnjBf6e1SWT96zm+snHbHATtCnb58QgUxmo2/hWyTCv1I3@vger.kernel.org, AJvYcCXYaevbHiLfTlKcU0jVQgNlD4Ep6r4p9rqXAVzg4DLG8bleMG3PedO4aF+G20zjQSrShV6U3Ei2Debn@vger.kernel.org X-Gm-Message-State: AOJu0Yw7X23z0k4IHIaeSXlRGdFdrDxA2oa/0q9U3wfAnJJvAI/TLRXp gCTsD03fnvYjqdZgk+vznOl2fGKPAbxlR3u8O5X5IdKPtwqhjoEia4Q3 X-Gm-Gg: ASbGnctPtfFK6WNnewjFStc+3gqoScxa8N/HkYT2iKimg/BA/ALP3DUlYRikCWYinPB FfC9vC50Izw/DawVZr5gpHWyEdaSypFrLg8JeHmdUFCE1GFDNPzRAmGnStcKWKxiDOcWUZv8ZCH zYPDaY+K0OeBL9TrT8tNubOom/7f9Q/ehc1vbNed3QpnaYQo6t/rp93HLaxTW58iRP1wM1rZngo BVjk+tFYQRrimLi0RBvxtHEd061E+AQtQwrwJfguMVbkH2yxbAJU6rrGHKhLv3+vNunyWAWhf2V 5sLpGCX5SO6vtV3py/poBbn6i5v+RiHRXWfZzeSPjfqNMokIigUzFBLiBj2/iqjDY2HgL/1aa1f im87pDnsx7m7VdnQxy80KDAjMnxmJtfevaVuSQM/gv4cBKV4U X-Google-Smtp-Source: AGHT+IHYGOm5+YbIns6Gdfpp1RfTrqSBfQ1d0sSMr46tzjRBEaCKJ+Lss28VIdCdoXY0y+NbqqF78Q== X-Received: by 2002:a17:903:2302:b0:24a:a724:717f with SMTP id d9443c01a7336-24aa7247fd3mr7687955ad.47.1756579411724; Sat, 30 Aug 2025 11:43:31 -0700 (PDT) Received: from [192.168.1.19] ([122.177.240.86]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2490658999fsm56821665ad.112.2025.08.30.11.43.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 30 Aug 2025 11:43:31 -0700 (PDT) From: Bharadwaj Raju Date: Sun, 31 Aug 2025 00:12:48 +0530 Subject: [PATCH 4/5] MAINTAINERS: add entry for inv_icm20948 driver Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250831-icm20948-v1-4-1fe560a38de4@gmail.com> References: <20250831-icm20948-v1-0-1fe560a38de4@gmail.com> In-Reply-To: <20250831-icm20948-v1-0-1fe560a38de4@gmail.com> To: Jonathan Cameron , David Lechner , =?utf-8?q?Nuno_S=C3=A1?= , Andy Shevchenko , Rob Herring , Krzysztof Kozlowski , Conor Dooley Cc: linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, shuah@kernel.org, linux-kernel-mentees@lists.linux.dev, Bharadwaj Raju X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1756579380; l=899; i=bharadwaj.raju777@gmail.com; s=20250830; h=from:subject:message-id; bh=S+oKo2tgTYiLtkAAs/iP4uzBUDKP2L0uoFWdETTsrIo=; b=6z849XXWAt7R7rAf/Yg/X3SR9rpCOP6A4q9xnBBV8HCU9Hnwm+pGJNaXiAK1ltmo7PYZD+5a0 wTwk6br0iv1DUfwZl6UqcHQf9G7tzzNloftBTO/ert414NRKjoMKtgl X-Developer-Key: i=bharadwaj.raju777@gmail.com; a=ed25519; pk=s+pP76EgUCC/7pyu4E6Q5AizWQ1T6hUf1jUWrQRl040= Add MAINTAINERS entry for the InvenSense ICM-20948 driver in IIO. Signed-off-by: Bharadwaj Raju --- MAINTAINERS | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index fe168477caa45799dfe07de2f54de6d6a1ce0615..930c80c1cc40a4cfb4bf270e1ab= 7680b88d97ff3 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -12783,6 +12783,13 @@ S: Maintained F: Documentation/devicetree/bindings/media/i2c/isil,isl79987.yaml F: drivers/media/i2c/isl7998x.c =20 +INVENSENSE ICM-20948 IMU DRIVER +M: Bharadwaj Raju +L: linux-iio@vger.kernel.org +S: Maintained +F: Documentation/devicetree/bindings/iio/imu/invensense,icm20948.yaml +F: drivers/iio/imu/inv_icm20948/ + INVENSENSE ICM-426xx IMU DRIVER M: Jean-Baptiste Maneyrol L: linux-iio@vger.kernel.org --=20 2.51.0 From nobody Fri Oct 3 13:23:47 2025 Received: from mail-pl1-f181.google.com (mail-pl1-f181.google.com [209.85.214.181]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 751CF2DCBE2; Sat, 30 Aug 2025 18:43:37 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.181 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1756579419; cv=none; b=RyzwJliwzVQYkFw2/K/0ItFqIfljvKAqSLWxwYcD0ZPpzYNomFH5YTFJCJBbCr43h57R/sZ9KgcZDMFP+LIErwdjP6pDHkDJlmvFU9Z5p3PxINDfTNnrEbPEcN1MZbEs3ZuKWPkmO7/AR3QYRrnIAYlf1Ie1PTVUb+zzVPGC118= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1756579419; c=relaxed/simple; bh=YtIGNLXaQcmkc4Bi2x5bHdVSJylHl4+GAVTUbZPrAjo=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=rSmxxkcKvzH4i4o9WlaBFwR6x8L1NJzLWPRlS64y9Cm8mgcfJRIJ3vnNMma7+a+K5iNDsg24FDsRl7Z6rGlj03vgSnlYOxwNh0wKawU96TsAv5VxtAMAzR/H+PXCdZhtBhozySbBvl0TjU1WUrvAE1+yFDCnu2uR1uA+Qle0xAs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=I5OItFOn; arc=none smtp.client-ip=209.85.214.181 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="I5OItFOn" Received: by mail-pl1-f181.google.com with SMTP id d9443c01a7336-248c7f955a2so28199715ad.2; Sat, 30 Aug 2025 11:43:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1756579417; x=1757184217; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=LPo8Q3Bu4jk8j+Uw+RLNhPXNNzhpQ7JonMOG41K09VA=; b=I5OItFOng0mL1Vb/IePpYM+3PBjnK/JxtwOVLEYMKrj9CQXUk8oQOEfVD9mIYwU0hJ HABNatyGQcWZZnmuZCde7dfY63+JILHZ5hXJfg9MGpsFsM3wPOI15VQzilqhT7xEILhw t51dxwcnG0ysgdAZlJf1gLR2MlXoNzHg2ad+Eoe6ghMwfMHlhoPpr/9Hp6GVCS9Ly4Rx cPvFLuN9JYQFMGUl7uPQV2WerpaE1XmjwnA1qpIkSABSXGMJ8urFhcRAmIVcs80ZNT3E qlGjtn2iVuziv1PwN1D8yXgqYkVSywnIAyc6am/9ZjS+Ckf3ESqOU1MV5UsFZ02pVLMA lEzA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1756579417; x=1757184217; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=LPo8Q3Bu4jk8j+Uw+RLNhPXNNzhpQ7JonMOG41K09VA=; b=LYPYfpz9O8inNEj1O21MaY53k3YOafUu7X9cn8UnYG3x4HVmZn/WcU8zgsDPdKq40E P6S8i///YFHR+z8SB87/qKL0uCgkW+sZrtBk/riMjjnBU9mmfhnHipeqpm0tLian4HrP wdVRSh3lF1DeYSuuw6N5BYm9ORNFn1KrpJww4ySUiRX7oBu8K1F4YE4NbK9jqCxkWGfR RSyn5cJNtIWFaF3JlkHn57ToTOaKH9a2pDAlJiBwESpqG1SSIF4Y1z6eTfog5BDCv/0k 6B/CTcK1g86Kd1G2J/KDyiHp/DIGxH/8beiSZztuXldswOT8IX3A1UUNSfr2RIv6GuHv f3xQ== X-Forwarded-Encrypted: i=1; AJvYcCVh7QYJ0hZfVXHZq1gohYjbbLu4HVBwRePpoRj5CDbtoCcqM2tPPxeyi4UlnpRPn88xr/dFC+LDO3p8hQNW@vger.kernel.org, AJvYcCVtgQh0nnfs706cXr5D88gXFGu6/m4yJLwUnU4ozr6EVY31h/OIi43B3H+RChr9hJ48Kb5n8ql3cfuV@vger.kernel.org X-Gm-Message-State: AOJu0YzevKM7tvLZjz592+mqHNDjKxPYYBqqqrXN55YeILMCvHZ5B942 W9Wey3VGH4jw/7GK/1qGiAE/07B3ARai3BWusc/U+kTlGAeP37h1/Te8 X-Gm-Gg: ASbGncuUMilKnV1e5rv1mGROeMtuJ8cdIpYObOwRFBb8rsVB/sIc9LLt7oixm+kD7A5 DbLsApkWSxP11oac2ulvQj5EFE/YOKaOK7ZBugA5Az0j8LcP4mUwQm8cqoGvvcxAl0E36mxTzJt 6R1toqvBA2BZNzFfZkAXYm6L1FWaAvDnqSIQOD7QOJxUJHgeIzGhfml6m/YfTSZ2RwcF4MEGq5N PEC6Kr+YL0x68uUO0ovI+WvgdCHFATBa1Ejd0bwUeAzwty65bKnFUMsqz9nOx/StKLfNx2ANpUy Qm6sK5P+7GZ2Vhv/BqeU2iJovAftsLgALFRbU0Pf/yihPyyUKL6fFs3hjJSwBHlbnaaOEDIc+lu 3DjcVYtMDMsJZ34hthN0TMQ35k3x1IMMBgQiLrgOiFV0oFECFokupUsBxEhU= X-Google-Smtp-Source: AGHT+IGatw6wqMSc9flLFH26sU9wlID4+2HyjBNw0BsJSxIrSeTya3p2EMyW+F3Cs0eWgDVkPaYYkg== X-Received: by 2002:a17:903:380f:b0:246:de71:1839 with SMTP id d9443c01a7336-24944b64760mr36733385ad.50.1756579416680; Sat, 30 Aug 2025 11:43:36 -0700 (PDT) Received: from [192.168.1.19] ([122.177.240.86]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2490658999fsm56821665ad.112.2025.08.30.11.43.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 30 Aug 2025 11:43:36 -0700 (PDT) From: Bharadwaj Raju Date: Sun, 31 Aug 2025 00:12:49 +0530 Subject: [PATCH 5/5] iio: imu: icm20948: add runtime power management support Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250831-icm20948-v1-5-1fe560a38de4@gmail.com> References: <20250831-icm20948-v1-0-1fe560a38de4@gmail.com> In-Reply-To: <20250831-icm20948-v1-0-1fe560a38de4@gmail.com> To: Jonathan Cameron , David Lechner , =?utf-8?q?Nuno_S=C3=A1?= , Andy Shevchenko , Rob Herring , Krzysztof Kozlowski , Conor Dooley Cc: linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, shuah@kernel.org, linux-kernel-mentees@lists.linux.dev, Bharadwaj Raju X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1756579380; l=9361; i=bharadwaj.raju777@gmail.com; s=20250830; h=from:subject:message-id; bh=YtIGNLXaQcmkc4Bi2x5bHdVSJylHl4+GAVTUbZPrAjo=; b=yj+v3a5GPXh26ZZOPJo4IfImx0oV3vCZhKBkPDgy5xpF0Plr/GhZS5aIqV+ZZKLqyYJX4fxKW eIrvJwehusNCpooAon7s0K1Ky2slKs4/K9XoxSmWZJBacQ5iOCXG3b7 X-Developer-Key: i=bharadwaj.raju777@gmail.com; a=ed25519; pk=s+pP76EgUCC/7pyu4E6Q5AizWQ1T6hUf1jUWrQRl040= Implement runtime power management support for the ICM20948 sensor. The device autosuspends after 2 seconds of idle time. Signed-off-by: Bharadwaj Raju --- drivers/iio/imu/inv_icm20948/Makefile | 1 + drivers/iio/imu/inv_icm20948/inv_icm20948.h | 7 +++ drivers/iio/imu/inv_icm20948/inv_icm20948_core.c | 3 +- drivers/iio/imu/inv_icm20948/inv_icm20948_gyro.c | 28 ++++++--- drivers/iio/imu/inv_icm20948/inv_icm20948_power.c | 73 +++++++++++++++++++= ++++ drivers/iio/imu/inv_icm20948/inv_icm20948_temp.c | 15 +++-- 6 files changed, 114 insertions(+), 13 deletions(-) diff --git a/drivers/iio/imu/inv_icm20948/Makefile b/drivers/iio/imu/inv_ic= m20948/Makefile index 88a37be159e1d6f575da1c070c84ac94cd963020..0a17ad1c003e6a93f3431f7a998= e56cdf975d245 100644 --- a/drivers/iio/imu/inv_icm20948/Makefile +++ b/drivers/iio/imu/inv_icm20948/Makefile @@ -4,6 +4,7 @@ obj-$(CONFIG_INV_ICM20948) +=3D inv-icm20948.o inv-icm20948-y +=3D inv_icm20948_core.o inv-icm20948-y +=3D inv_icm20948_temp.o inv-icm20948-y +=3D inv_icm20948_gyro.o +inv-icm20948-y +=3D inv_icm20948_power.o =20 obj-$(CONFIG_INV_ICM20948_I2C) +=3D inv-icm20948-i2c.o inv-icm20948-i2c-y +=3D inv_icm20948_i2c.o diff --git a/drivers/iio/imu/inv_icm20948/inv_icm20948.h b/drivers/iio/imu/= inv_icm20948/inv_icm20948.h index ca2513114378cdcba5bc315fc94cd61f930b4dfa..194dcccabc2162334779b285320= 187c7ff1f5236 100644 --- a/drivers/iio/imu/inv_icm20948/inv_icm20948.h +++ b/drivers/iio/imu/inv_icm20948/inv_icm20948.h @@ -13,10 +13,13 @@ #include #include #include + #include =20 /* accel takes 20ms, gyro takes 35ms to wake from full-chip sleep */ #define INV_ICM20948_SLEEP_WAKEUP_MS 35 =20 + #define INV_ICM20948_SUSPEND_DELAY_MS 2000 + #define INV_ICM20948_REG_BANK_SEL 0x7F #define INV_ICM20948_BANK_SEL_MASK GENMASK(5, 4) =20 @@ -46,6 +49,8 @@ =20 extern const struct regmap_config inv_icm20948_regmap_config; =20 +extern const struct dev_pm_ops inv_icm20948_pm_ops; + enum inv_icm20948_gyro_fs { INV_ICM20948_GYRO_FS_250 =3D 0, INV_ICM20948_GYRO_FS_500 =3D 1, @@ -82,4 +87,6 @@ extern int inv_icm20948_core_probe(struct regmap *regmap); struct iio_dev *inv_icm20948_temp_init(struct inv_icm20948_state *state); struct iio_dev *inv_icm20948_gyro_init(struct inv_icm20948_state *state); =20 +int inv_icm20948_pm_setup(struct inv_icm20948_state *state); + #endif diff --git a/drivers/iio/imu/inv_icm20948/inv_icm20948_core.c b/drivers/iio= /imu/inv_icm20948/inv_icm20948_core.c index eb4f940de7013bf4ddeb69b6380a60fbde49964a..e6e670d96e40c3663e55d1545b5= 2f609603a02ed 100644 --- a/drivers/iio/imu/inv_icm20948/inv_icm20948_core.c +++ b/drivers/iio/imu/inv_icm20948/inv_icm20948_core.c @@ -101,7 +101,7 @@ static int inv_icm20948_setup(struct inv_icm20948_state= *state) if (IS_ERR(state->gyro_dev)) return PTR_ERR(state->gyro_dev); =20 - return 0; + return inv_icm20948_pm_setup(state); } =20 int inv_icm20948_core_probe(struct regmap *regmap) @@ -113,6 +113,7 @@ int inv_icm20948_core_probe(struct regmap *regmap) state =3D devm_kzalloc(dev, sizeof(*state), GFP_KERNEL); if (!state) return -ENOMEM; + dev_set_drvdata(dev, state); =20 state->regmap =3D regmap; state->dev =3D dev; diff --git a/drivers/iio/imu/inv_icm20948/inv_icm20948_gyro.c b/drivers/iio= /imu/inv_icm20948/inv_icm20948_gyro.c index 2d4d598eb21c8ce98d4ee3c72504554ab49ea596..9cefb47a46b1a323202aa84f0de= 647d7b7b89728 100644 --- a/drivers/iio/imu/inv_icm20948/inv_icm20948_gyro.c +++ b/drivers/iio/imu/inv_icm20948/inv_icm20948_gyro.c @@ -73,10 +73,14 @@ static const struct iio_chan_spec inv_icm20948_gyro_cha= nnels[] =3D { static int inv_icm20948_gyro_apply_config(struct inv_icm20948_state *state) { guard(mutex)(&state->lock); + pm_runtime_get_sync(state->dev); =20 - return regmap_write_bits(state->regmap, INV_ICM20948_REG_GYRO_CONFIG_1, + int ret =3D regmap_write_bits(state->regmap, INV_ICM20948_REG_GYRO_CONFIG= _1, INV_ICM20948_GYRO_CONFIG_FULLSCALE, state->gyro_conf->fsr << 1); + + pm_runtime_put_autosuspend(state->dev); + return ret; } =20 static int inv_icm20948_gyro_read_sensor(struct inv_icm20948_state *state, @@ -99,23 +103,25 @@ static int inv_icm20948_gyro_read_sensor(struct inv_ic= m20948_state *state, return -EINVAL; } =20 + pm_runtime_get_sync(state->dev); + __be16 raw; int ret =3D regmap_bulk_read(state->regmap, reg, &raw, sizeof(raw)); =20 if (ret) - return ret; + goto out; =20 *val =3D (s16)be16_to_cpu(raw); =20 - return 0; +out: + pm_runtime_put_autosuspend(state->dev); + return ret; } =20 static int inv_icm20948_gyro_read_calibbias(struct inv_icm20948_state *sta= te, struct iio_chan_spec const *chan, int *val, int *val2) { - guard(mutex)(&state->lock); - unsigned int reg; =20 switch (chan->channel2) { @@ -133,8 +139,11 @@ static int inv_icm20948_gyro_read_calibbias(struct inv= _icm20948_state *state, } =20 __be16 offset_raw; + + pm_runtime_get_sync(state->dev); int ret =3D regmap_bulk_read(state->regmap, reg, &offset_raw, sizeof(offset_raw)); + pm_runtime_put_autosuspend(state->dev); =20 if (ret) return ret; @@ -216,8 +225,6 @@ static int inv_icm20948_write_calibbias(struct inv_icm2= 0948_state *state, struct iio_chan_spec const *chan, int val, int val2) { - guard(mutex)(&state->lock); - unsigned int reg; =20 switch (chan->channel2) { @@ -246,8 +253,13 @@ static int inv_icm20948_write_calibbias(struct inv_icm= 20948_state *state, s16 offset =3D clamp(offset64, (s64)S16_MIN, (s64)S16_MAX); __be16 offset_write =3D cpu_to_be16(offset); =20 - return regmap_bulk_write(state->regmap, reg, &offset_write, + pm_runtime_get_sync(state->dev); + mutex_lock(&state->lock); + int ret =3D regmap_bulk_write(state->regmap, reg, &offset_write, sizeof(offset_write)); + mutex_unlock(&state->lock); + pm_runtime_put_autosuspend(state->dev); + return ret; } =20 static int inv_icm20948_gyro_write_raw(struct iio_dev *gyro_dev, diff --git a/drivers/iio/imu/inv_icm20948/inv_icm20948_power.c b/drivers/ii= o/imu/inv_icm20948/inv_icm20948_power.c new file mode 100644 index 0000000000000000000000000000000000000000..1281a5e5acb539cd3f91ca8ed8d= 52371f330b60a --- /dev/null +++ b/drivers/iio/imu/inv_icm20948/inv_icm20948_power.c @@ -0,0 +1,73 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Copyright (C) 2025 Bharadwaj Raju + */ + +#include "inv_icm20948.h" + +static int inv_icm20948_suspend(struct device *dev) +{ + if (pm_runtime_suspended(dev)) + return 0; + + struct inv_icm20948_state *state =3D dev_get_drvdata(dev); + + guard(mutex)(&state->lock); + + return regmap_write_bits(state->regmap, INV_ICM20948_REG_PWR_MGMT_1, + INV_ICM20948_PWR_MGMT_1_SLEEP, + INV_ICM20948_PWR_MGMT_1_SLEEP); +} + +static int inv_icm20948_resume(struct device *dev) +{ + struct inv_icm20948_state *state =3D dev_get_drvdata(dev); + + guard(mutex)(&state->lock); + + pm_runtime_disable(state->dev); + pm_runtime_set_active(state->dev); + pm_runtime_enable(state->dev); + + int ret =3D regmap_write_bits(state->regmap, INV_ICM20948_REG_PWR_MGMT_1, + INV_ICM20948_PWR_MGMT_1_SLEEP, 0); + if (ret) + return ret; + + msleep(INV_ICM20948_SLEEP_WAKEUP_MS); + + return 0; +} + +static void inv_icm20948_pm_disable(void *data) +{ + struct device *dev =3D data; + + pm_runtime_put_sync(dev); + pm_runtime_disable(dev); +} + +int inv_icm20948_pm_setup(struct inv_icm20948_state *state) +{ + struct device *dev =3D state->dev; + + guard(mutex)(&state->lock); + + int ret; + + ret =3D pm_runtime_set_active(dev); + if (ret) + return ret; + pm_runtime_get_noresume(dev); + pm_runtime_enable(dev); + pm_runtime_set_autosuspend_delay(dev, INV_ICM20948_SUSPEND_DELAY_MS); + pm_runtime_use_autosuspend(dev); + pm_runtime_put(dev); + + return devm_add_action_or_reset(dev, inv_icm20948_pm_disable, dev); +} + +EXPORT_NS_GPL_DEV_PM_OPS(inv_icm20948_pm_ops, IIO_ICM20948) =3D { + SYSTEM_SLEEP_PM_OPS(inv_icm20948_suspend, inv_icm20948_resume) + RUNTIME_PM_OPS(inv_icm20948_suspend, inv_icm20948_resume, NULL) +}; diff --git a/drivers/iio/imu/inv_icm20948/inv_icm20948_temp.c b/drivers/iio= /imu/inv_icm20948/inv_icm20948_temp.c index 916053740cc5acda0316c76504d4086eff5ec7f0..6e17b3719301d6d7f005d545587= f558fcadd2f40 100644 --- a/drivers/iio/imu/inv_icm20948/inv_icm20948_temp.c +++ b/drivers/iio/imu/inv_icm20948/inv_icm20948_temp.c @@ -24,17 +24,24 @@ static const struct iio_chan_spec static int inv_icm20948_temp_read_sensor(struct inv_icm20948_state *state, s16 *temp) { - guard(mutex)(&state->lock); + int ret; + + pm_runtime_get_sync(state->dev); + mutex_lock(&state->lock); =20 __be16 raw; - int ret =3D regmap_bulk_read(state->regmap, INV_ICM20948_REG_TEMP_DATA, + ret =3D regmap_bulk_read(state->regmap, INV_ICM20948_REG_TEMP_DATA, &raw, sizeof(raw)); if (ret) - return ret; + goto out; =20 *temp =3D __be16_to_cpu(raw); + ret =3D 0; =20 - return 0; +out: + mutex_unlock(&state->lock); + pm_runtime_put_autosuspend(state->dev); + return ret; } =20 static int inv_icm20948_temp_read_raw(struct iio_dev *temp_dev, --=20 2.51.0