From nobody Mon Sep 28 17:48:33 2026 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 B0BEB38644F for ; Thu, 20 Aug 2026 05:06:41 +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=1787202403; cv=none; b=Z+8j/7zBnFhSLuql/ssxJvQs9QTXbJak4QAleEu20oOKWDp+0/b2VMmTUyoPtu3tpC/vyz7yCZTOYqBv8jnnnjTmhPVOnpj10XoOq5wTlR7w3NmWV0N3hIQlzGqhBP5UgsKMkiyPCSU8vtJ4ltiKk2f7hNZInajNmXV9s0tPbSw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787202403; c=relaxed/simple; bh=KkxZzMnZsUYISSTdErOkta5WRXqEbFAdRVIXpnFjHBo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=kL0gnwCxDv1T7zdISG60bNv5+Tfbw7FO5zSPeTw/RQHKryNqdEoa9nK7dQttezkYTy2biVZlaEnLMXGJwhCMhgtz0kcZfFtvoeT6neVkrmYuBHOvxwmawe3ouJIHOaXCrAXzupraDMkm//CUEYwyDNp7GiiXWjvf8xMIro8ZiQ8= 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=lF9OhIR0; 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="lF9OhIR0" Received: by mail-pl1-f174.google.com with SMTP id d9443c01a7336-2cc891373e0so21821975ad.2 for ; Wed, 19 Aug 2026 22:06:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1787202401; x=1787807201; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=Ehvq9I2NEQVnVUVkqXgo8ZVG0AJoS+1+bAWaF+/RoEk=; b=lF9OhIR05pc/wrf/QVX8xxNdO4nX59FwEDB7GuDD0LzL+A3ToGsIgeEuM+wPZ7+CrN Q5Wqi1kIhnA3HU+In+l0/35zw7mB2euY7O6TscAvs0hjuV7BnmGuhUYjATGrb6LvFgc/ HIDQQnp06acgUSwsLXc/aDztA45j1A+dXe+28z5ljgLJT0FkIoWJi+PwEPSo2jc1Dafk l/+/xviqVv7CjPpQPXmpD49+sZMOkgTRnO815p9438F41zH9wbSOZNO5w9EMz/FvMa1H oM8yrRd+CdKtCP98/00sUCyFMYkFtCFlIYNDUPD+WKkERu6kPdrQXjMiTLHWwWXPtOq5 WVoA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787202401; x=1787807201; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=Ehvq9I2NEQVnVUVkqXgo8ZVG0AJoS+1+bAWaF+/RoEk=; b=e+ZIaVZVnzsAK9uXTNQKwJhLKeRhlbM51kQZ2qzMSBDMlCUgXJy/Mq897mvsZCccld bnG0n1KPoIyWpckvzsa6uMSXDfCavHYM92VTwm2ObBg1Chb3ddszjVBju0Fpq+2RMVuP 0EOZ0tE31MOiVc92Qa8LACdlzaXSPPR4J5AzpQ6js/g+Jnu3n+yHtN2Cyc5WGZeZ866h YRHHzp9KIDPrcbl4f2m9VlBDcRHVKJXxgOby8np2GxQ95/E+F+2J6xe2zHMk02bq4WsB p7dO4FtTIOuM15RY95OIb2UsanVHPWSxG+9qMkoaOBB5RHckfkVOL71NP74vVbfuKIOd FaAg== X-Forwarded-Encrypted: i=1; AHgh+RpFr7AtBL4Px9vjfm3k+eMT/W0biOaAjXGv5YUj5GSWsnuHYatdwMfsUsztvTwK1CuDoMcadDt+zcmkGeY=@vger.kernel.org X-Gm-Message-State: AFuF++mXnEyDpCwHoN7umfzgeMxVDpMllH6arIAOW40NkAB/TL5SC8rd NGYPdhizhePBzC+W1TjijjcipanV3sqXqVgV4O7QIyQVeLTQ1aTqwRNu X-Gm-Gg: AR+sD10CYHAMnS8nrP9lc1a+9NiWz2VDTEp7DW1+PnkU5RCJYw7NYnjeeiB2Di+bIPN d8Iu/uicZHqEozYbEazg/d2zxfo9WT6YyxnLIikpp0E8hpMZlyy3qqopujcIhCFNe1Z4cZK0ees JeRlnJ17EMSiH4B/GgFkMS/qSM2SGcJUfWUg0zXNGmT1ADnkkY4XFkhUl0W5hpNhd20g1QXDwcm ldk721KI9FymwnJA6Ho+peffa1F9uBiocrg5sR1V70dphPg0oXBAgyL9Qh5Xq04AT+zyJzA/j1n VraQZaosmbQ6UdOVpXU7uBp1C8lE43LlDaFTi31l22DV6iRmIw1SIeh5bzHH9tU8gtb17nbHnBM frYMyIuw80NWWbdT8M6InWHzbJ7TwsZV0x5IUr7zB4Crp1NAZPraCT/sowHlVT1tV6r5YlXow88 9eDaghvdi1TYXKDvpXNaOzEHb/Hm+ozIjVRKFR8YBeMGiMM0B7DzwyidZGQCELXltXykVeUdqgp FeOQ2kUnugXHnEcYXUC3R1RBFCxVCk1+qjB4wA39U34hQrtWx6hb8N5oXKwVBHZnh75VeIzbxzl oF/Lx6nZaGo= X-Received: by 2002:a17:903:11c9:b0:2d0:8b28:517c with SMTP id d9443c01a7336-2d5fd5ff2e9mr175571935ad.3.1787202400875; Wed, 19 Aug 2026 22:06:40 -0700 (PDT) Received: from DESKTOP-G3E0OSP.localdomain ([112.172.255.242]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2d62d58a82dsm2040685ad.18.2026.08.19.22.06.37 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Aug 2026 22:06:40 -0700 (PDT) From: Jinseob Kim To: jic23@kernel.org, linux-iio@vger.kernel.org Cc: dlechner@baylibre.com, nuno.sa@analog.com, andy@kernel.org, linux-kernel@vger.kernel.org, rdunlap@infradead.org, joshua.crofts1@gmail.com, u.kleine-koenig@baylibre.com, julianbraha@gmail.com, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, grondon@gmail.com, devicetree@vger.kernel.org, corbet@lwn.net, skhan@linuxfoundation.org, linux-doc@vger.kernel.org Subject: [PATCH v8 1/5] dt-bindings: iio: add Open Sensor Fusion device Date: Thu, 20 Aug 2026 14:06:04 +0900 Message-ID: <20260820050608.5440-2-kimjinseob88@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260820050608.5440-1-kimjinseob88@gmail.com> References: <20260820050608.5440-1-kimjinseob88@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add a binding for the generic Open Sensor Fusion host interface. Open Sensor Fusion devices report capabilities and samples over an OSF protocol stream. Sensor channels are discovered at runtime from capability reports instead of being described individually in Device Tree. The protocol version is discovered at runtime from the OSF frame header. OSF GREEN is a product identity, and OSF0 is a wire-format magic value, so neither is used as the Linux compatible string. Reviewed-by: Conor Dooley Signed-off-by: Jinseob Kim --- .../bindings/iio/opensensorfusion,osf.yaml | 52 +++++++++++++++++++ .../devicetree/bindings/vendor-prefixes.yaml | 2 + MAINTAINERS | 6 +++ 3 files changed, 60 insertions(+) create mode 100644 Documentation/devicetree/bindings/iio/opensensorfusion,= osf.yaml diff --git a/Documentation/devicetree/bindings/iio/opensensorfusion,osf.yam= l b/Documentation/devicetree/bindings/iio/opensensorfusion,osf.yaml new file mode 100644 index 000000000000..3998390828cc --- /dev/null +++ b/Documentation/devicetree/bindings/iio/opensensorfusion,osf.yaml @@ -0,0 +1,52 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/iio/opensensorfusion,osf.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Open Sensor Fusion Sensor Aggregation Hub + +maintainers: + - Jinseob Kim + +description: | + This binding documents the generic Open Sensor Fusion host interface. Op= en + Sensor Fusion is a sensor aggregation hub. The hub exposes an OSF protoc= ol + data stream over its host interface and reports capabilities and samples= for + multiple sensor classes. The actual sensor channels are discovered at ru= ntime + from OSF capability reports instead of describing them in Device Tree. T= he + protocol version is discovered at runtime. + + Public project documentation is available at: + + https://github.com/opensensorfusion + + OSF0, protocol_major, and protocol_minor are wire-protocol details + exchanged in OSF frames. + +allOf: + - $ref: /schemas/serial/serial-peripheral-props.yaml# + +properties: + compatible: + const: opensensorfusion,osf + + vcc-supply: + description: + Regulator supplying power to the Open Sensor Fusion device. + +required: + - compatible + - vcc-supply + +unevaluatedProperties: false + +examples: + - | + serial { + sensor { + compatible =3D "opensensorfusion,osf"; + vcc-supply =3D <&vcc_sensor>; + }; + }; +... diff --git a/Documentation/devicetree/bindings/vendor-prefixes.yaml b/Docum= entation/devicetree/bindings/vendor-prefixes.yaml index f88e595f7077..d746aadb994f 100644 --- a/Documentation/devicetree/bindings/vendor-prefixes.yaml +++ b/Documentation/devicetree/bindings/vendor-prefixes.yaml @@ -1245,6 +1245,8 @@ patternProperties: description: OpenPandora GmbH "^openrisc,.*": description: OpenRISC.io + "^opensensorfusion,.*": + description: Open Sensor Fusion "^openwrt,.*": description: OpenWrt "^option,.*": diff --git a/MAINTAINERS b/MAINTAINERS index 3c5084fec202..17652ba6039d 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -20293,6 +20293,12 @@ F: Documentation/devicetree/ F: arch/*/boot/dts/ F: include/dt-bindings/ =20 +OPEN SENSOR FUSION +M: Jinseob Kim +S: Maintained +F: Documentation/devicetree/bindings/iio/opensensorfusion,osf.yaml +K: opensensorfusion + OPENCOMPUTE PTP CLOCK DRIVER M: Vadim Fedorenko L: netdev@vger.kernel.org --=20 2.43.0 From nobody Mon Sep 28 17:48:33 2026 Received: from mail-pl1-f179.google.com (mail-pl1-f179.google.com [209.85.214.179]) (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 76512353A7F for ; Thu, 20 Aug 2026 05:06:49 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.179 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787202410; cv=none; b=G+efKm6jhRwX18ulynqLPfuDkhOy2yw4pLb5uzEL1dGQwAkFLQsfk7oBcA9eEIajwldtCUBORWdxWONjl0QX5xfGtIKo2QrMsI/IIVdr2zEoB0UwjRlorHFUxgFLOFV3O3r91mwNZb4sUQamiVGRGnlGZRbFawhtQrVmJQFjzm8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787202410; c=relaxed/simple; bh=tppiwU0afVTqKAsxHD7NixQhO94yjKbGlSO7BWcNl38=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=BqzBiHgjS+Uh3WMRhpRgvoF9GH8OkE+DoW4SCa9VuiJJ9+XyBPW9JPnJCaNUFomuiNtV7G7d1IaQtic5cNWKyE2e2/jg4E/POxsbPelp/ELaoU1qfvbqr+0rtZyKhYf7Y/ukn9jWd8y4xFZY9/RckhPi9CQxwB+ZQMyMoFQlryk= 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=m5dv4fFy; arc=none smtp.client-ip=209.85.214.179 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="m5dv4fFy" Received: by mail-pl1-f179.google.com with SMTP id d9443c01a7336-2ce7d2adef4so23406375ad.3 for ; Wed, 19 Aug 2026 22:06:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1787202409; x=1787807209; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=TJsCOrmxkPDlt4vp4WrYe2lu9E0Ol0sMmnqsSnQvLkI=; b=m5dv4fFy9lXteWvmDVqOS39Yc6X7+tLaSZsT4Hk+kof39Sg9XdLAFs9l7ynPFVRL7L GKuMnHVMOT5EsHREzKuCUjamwlmkxkqofFNmvFylUmdT4Wjv/zWNfC+Aff+Dsnobu9rF uhyxpohHms3q2wG9SxK43abhiqm2tVact2+GVAt/KAUT5zbGQAtDF7PobWRC+Q66pebz ekriEmD7NuwRrgH077oskHlr1+5lTMJm4JJA0TvhZs4yM7gfCGgeioxtDDLeJ7qz507a NkfLbMzxvNXXENVI0knuV81rMk5D1bSDb8zw8bno+sA7+3uFB6xUkaDHkD/oV5xy2y0u ltmA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787202409; x=1787807209; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=TJsCOrmxkPDlt4vp4WrYe2lu9E0Ol0sMmnqsSnQvLkI=; b=b4t5RPeygUBog0M5hhmBsc9P3K6+k5ekP+lQIZGk1q078NIG2L02J4O9bQnuDsaj5a ujJxY/uyVT32ZlbqUf1CmTZM1Qbh/e+qijzdMzNthT1Js14SZVYSHnzW8UW8rWG/xJM1 qIcaf8z/iCdcXPtVuOyktwwlfBcBDNXCtSRfqIo7T/ES0RD+yJB+JefuvqL067gitpRk Kri70gGj3sSXgD/YEtCZk1cc+2vXE1sJ3V4L0oxjQ2SdEKzNglcvznR4oIUnKWo6+uy2 Slr2CA89VNB7NE/hJSSrhnszNyz2RXEwRcdSsMCcLwrgSWemR4msZPO+5VZJbp5Lu/um 84uw== X-Forwarded-Encrypted: i=1; AHgh+RrJ7XC3mrhJd5zOnXJ+/q9olIJt2hiMOwvciqw4HTP2gP9+URtuIVKf2E8nUa547Ql90iPzS2t0jyY9yxo=@vger.kernel.org X-Gm-Message-State: AFuF++kqgS5lewyHA6+9MS5A0DVyuSxlJBdKWPRqLFSE8EWtzVFBFyCp ZZhzHr8QZ0SGkWadXaOYQ1nmYl3suue1+lP7P9oYCGOwAuAOFMfi3+4g X-Gm-Gg: AR+sD12c/HWq/m9ffWdgc8z8WGnT+kuF8LDCbXk6kZUmcaJqEYb+Bc2iKF4FckZeYVJ wxdhCAtFnLAxBf5lh/b+V3hlreZcrCvMtF48lMTNM1x9QIVQ48/CKUXymEkU+7FjBcF9ztValex uG8WgJ9MMX2H4nQDsUX9qFJRcpDE3kzA3EtIDfV+aE4z7fSb9GDTCnlSEc8+HK/fQeStWAQPsZk eTHR0TrE/dp7+DGVcsSCONIpRPc+Ar9v30XfIVwYXJRuWaXZLQkAA2d/fFUb98RniiKQ0CPuYE2 xB8OiYha125DCR19V1TywE27bumv5Faqh5ELKom8bzVnYkHTg38HXmIrAFwa9hX1SpipkuoBJpQ ys7sqaayw8xxJENiGy4n1MJEaPDaQLE7PhqZPrrMOq6I9bgDeQizYc1137zqJ3W2+eXpXQPSVIq 4rOPQ3VAbsEPRLFlrK8e+II3EroPIzxmQ5JdegWJpHErzBZae2wXKzFKMXubzEbF2RaLM2r13we pen5IZg2zQOD9juWnX8/OAZYbyZ2mAztcn2F0SxSidZdG56fGv7A7N6fUT8Df0uHBN93BueDVq0 X-Received: by 2002:a17:903:350c:b0:2cc:aa36:c046 with SMTP id d9443c01a7336-2d601a8e888mr195631285ad.14.1787202408730; Wed, 19 Aug 2026 22:06:48 -0700 (PDT) Received: from DESKTOP-G3E0OSP.localdomain ([112.172.255.242]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2d62d58a82dsm2040685ad.18.2026.08.19.22.06.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Aug 2026 22:06:47 -0700 (PDT) From: Jinseob Kim To: jic23@kernel.org, linux-iio@vger.kernel.org Cc: dlechner@baylibre.com, nuno.sa@analog.com, andy@kernel.org, linux-kernel@vger.kernel.org, rdunlap@infradead.org, joshua.crofts1@gmail.com, u.kleine-koenig@baylibre.com, julianbraha@gmail.com, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, grondon@gmail.com, devicetree@vger.kernel.org, corbet@lwn.net, skhan@linuxfoundation.org, linux-doc@vger.kernel.org Subject: [PATCH v8 2/5] Documentation: iio: add Open Sensor Fusion driver overview Date: Thu, 20 Aug 2026 14:06:05 +0900 Message-ID: <20260820050608.5440-3-kimjinseob88@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260820050608.5440-1-kimjinseob88@gmail.com> References: <20260820050608.5440-1-kimjinseob88@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Document the Linux IIO mapping for Open Sensor Fusion devices. The overview explains that sensor channels are discovered at runtime from mandatory capability reports. It also documents that OSF0 is a wire-format detail and that protocol_major and protocol_minor carry protocol compatibility information. Tested-by: Randy Dunlap # docs build Signed-off-by: Jinseob Kim --- Documentation/iio/index.rst | 1 + Documentation/iio/open-sensor-fusion.rst | 72 ++++++++++++++++++++++++ MAINTAINERS | 1 + 3 files changed, 74 insertions(+) create mode 100644 Documentation/iio/open-sensor-fusion.rst diff --git a/Documentation/iio/index.rst b/Documentation/iio/index.rst index b02b879b053a..c2b7963348fd 100644 --- a/Documentation/iio/index.rst +++ b/Documentation/iio/index.rst @@ -40,4 +40,5 @@ Industrial I/O Kernel Drivers adxl345 bno055 ep93xx_adc + open-sensor-fusion opt4060 diff --git a/Documentation/iio/open-sensor-fusion.rst b/Documentation/iio/o= pen-sensor-fusion.rst new file mode 100644 index 000000000000..c28886f3b961 --- /dev/null +++ b/Documentation/iio/open-sensor-fusion.rst @@ -0,0 +1,72 @@ +.. SPDX-License-Identifier: GPL-2.0-only + +Open Sensor Fusion +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +Open Sensor Fusion is a sensor aggregation hub interface. The Linux IIO dr= iver +receives OSF protocol frames from an attached device and registers matchin= g IIO +devices for the sensor classes supported by the driver. The actual sensor +channels are discovered at runtime from mandatory OSF capability reports. + +This document is a driver-facing overview for the Linux IIO mapping. The f= ull +wire protocol, firmware behavior, and hardware model details belong in the= Open +Sensor Fusion project documentation. + +Device Model +------------ + +An OSF device sends binary frames from the device to the host. Devices usi= ng the +``opensensorfusion,osf`` compatible are expected to provide +``CAPABILITY_REPORT`` messages so the host can discover which sensor strea= ms are +available. Device Tree describes the attached OSF sensor aggregation hub; = it does +not enumerate the individual sensors discovered at runtime. + +The currently supported Linux subset exposes: + +* accelerometer samples as ``IIO_ACCEL`` X/Y/Z channels, +* gyroscope samples as ``IIO_ANGL_VEL`` X/Y/Z channels, +* magnetometer samples as ``IIO_MAGN`` X/Y/Z channels, and +* temperature samples as ``IIO_TEMP``. + +Protocol Scope +--------------- + +The driver supports OSF protocol major version 0 for the IIO receive path. +The current wire magic is ``OSF0``; that string is a wire-format detail an= d is +not the Linux driver identity. Device Tree keeps the generic +``opensensorfusion,osf`` compatible rather than naming a product such as O= SF +GREEN or a wire magic value. + +Protocol versioning is carried by the ``protocol_major`` and ``protocol_mi= nor`` +fields at fixed offsets in the OSF frame header. The driver currently +supports ``protocol_major`` 0. ``protocol_minor`` changes within major ver= sion +0 are intended to remain backward-compatible within the fixed header layou= t. +Incompatible wire-format changes require a new ``protocol_major``. A future +device that cannot expose compatible version discovery through that fixed +header layout would need a different Device Tree compatible. + +The Linux driver handles device-to-host frames for: + +* ``SENSOR_SAMPLE`` buffered and direct-mode sample data, +* ``CAPABILITY_REPORT`` based IIO device registration, and +* ``DEVICE_STATUS`` cache updates. + +Vendor-private message types are ignored. Command transport, calibration +control ABI, fusion output ABI, and runtime capability removal are outside= the +Linux IIO receive path. + +Timestamps +---------- + +OSF frames include a device-side ``timestamp_us`` field. Buffered IIO samp= les use +an IIO timestamp captured on the host when samples are pushed to IIO buffe= rs. +The driver does not correlate the device timestamp with the host IIO +clock. + +Compatibility Notes +------------------- + +The project protocol documentation should define the compatibility rules f= or +reserved fields, optional flags, and trailing extension data. Until those = rules +are finalized, the Linux decoder keeps conservative bounds checks around t= he +currently supported message layouts. diff --git a/MAINTAINERS b/MAINTAINERS index 17652ba6039d..9550cf1900bd 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -20297,6 +20297,7 @@ OPEN SENSOR FUSION M: Jinseob Kim S: Maintained F: Documentation/devicetree/bindings/iio/opensensorfusion,osf.yaml +F: Documentation/iio/open-sensor-fusion.rst K: opensensorfusion =20 OPENCOMPUTE PTP CLOCK DRIVER --=20 2.43.0 From nobody Mon Sep 28 17:48:33 2026 Received: from mail-pl1-f178.google.com (mail-pl1-f178.google.com [209.85.214.178]) (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 8062538A725 for ; Thu, 20 Aug 2026 05:06:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.178 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787202417; cv=none; b=dvDOSThziiZ6F5iCltdSIUTlVMf3FHhc+rGBD/MZiT9J6MU0g2S0Q91PTZ17EPfFxC58qah5MN4NYZ4ByKGC9V8fn9VCDepMCKPef/oYF7B42G58jxDt7rtRPFAAqHJ2lgma49vW2VO4y8pCLMS/uoKuLBMiqRUz0+4bXxMgUw4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787202417; c=relaxed/simple; bh=PHnj/dfT6vEy4oPbOkjS+nst7WLFJOcvRlYae8WjvZs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=p7zNorFSkOJCDXQ4SGER9vLJhJYLOt4ZUUHI8EhOhmtK4FtoDwZavzBsFiNt20gbnmUpWfXL8wuuDmuCA9/kZ8K5G/c1xzEWb/gV+6ORwdpNreSUR+yqLs5SQzMJzIBGbkz23M8//cT41vEqHAJETKwGr8bTg3rLq8tLbImqp7E= 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=sTzaZd42; arc=none smtp.client-ip=209.85.214.178 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="sTzaZd42" Received: by mail-pl1-f178.google.com with SMTP id d9443c01a7336-2caf228a910so11765945ad.2 for ; Wed, 19 Aug 2026 22:06:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1787202415; x=1787807215; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=RcY7gPI3vZpcX4ZcLMMx/Xe0zOqUh85eG6l6jt/xSzc=; b=sTzaZd427UYWI89l3o5IG27KEr+zTAXbJ+EKWlSq48b0z1NwC/LNDBdLr1M68Zf1i+ s3tgrJBt5XkctLvwZiRbYNH+8WxSh6mkYEDgo7DhAzXckShokT3A2g5lNbl89tFpTBKW kncKWpVNFbJdlRMBjyeN6RqOU3uKwRi2nQwMvJY8OxvROMtlAfVeTi9jsojzbaeBnRV3 cFDnp563mTyvou2Mij8HJJXRYoff7rGRtdkCCZj6BRMKxIfs3qQh1lnCFL4JgL6gc8D3 T6wcp9EXpudTCIwdqqbwedABEAeOcQNkWcu1XuTOfNUaYS9oGggpSCnrQQzzPelpyAMP KPiQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787202415; x=1787807215; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=RcY7gPI3vZpcX4ZcLMMx/Xe0zOqUh85eG6l6jt/xSzc=; b=HLmRObuOqtBD2ocNxhLKOvhg9+9ZEljdEvxPbkvGzmdAIjI4Ag9V7YayT9YLmgQzOJ HzQ6dOZ7eQeKhFStLw7sFv3fVCeHhf+29le4e62Ej5nSmtZddVl18LgvkFQWpRLKbNue lMjOhvd2/RNAmrGXlhzURNKkusEDoSPBHzRoEJTd/z6pWJnj8KO/K/9NByS7USwUMym5 7OHEp5SYdDu4u7n6yj2eaP3wCXkYLH0pszgXDQ5sb+uDFrlRfOEuIX1dYm/mYaH2oi2U 6D7Ge5jrgcz8AIbUWjZ/xsWFtHXx4TUKKSK1d/Gpz2enPxecDv5Bf9z7JUmyR7SFnvd4 DRfg== X-Forwarded-Encrypted: i=1; AHgh+RqTtHEg41iJ76+r9AWMt5E+8gFcclooXcCTHqKQOdUqSVMZFF9TYTAQ4TTDqQ80bLSTkxodA+/GfCLkim0=@vger.kernel.org X-Gm-Message-State: AOJu0YxhE5vwtKpbvsDYb6nP6pjSjxPtpezN2vcVRx51t3JrrVail/JG xUHSJeN+ZEAI1BJufdlF0BiV8eXYdxTtJurkpwDVqxFXj+jQ+6ztEuZ9m7JQBMeuf8M= X-Gm-Gg: AR+sD13+mP22rilLOY6f4hQqAcV1fKd1pC5k/Gbvqtpovx0y/xQFqiOqJOEB2+LdwSm 5XYd3sjj95QlrYndwPJes7CFDJyThvNHOteSoeF78QBGUM/5Tx3/9movSXOReZEVLC1MVDG1Y3B WMQ8optEod36r2K6A2w4hP+R5+EKM4RWRtmbFRH7dDulAGzq5XqM84gBTLsCmTMEqD01T8NFjEQ oJkaogxBdWsNLBohhwvEyVBIvPt9r4NoiI8U1Ey3w7EvwKiLFtrZI6T8TOkIoTQZDKck0YQVpfC q1MfDC8KKHsd/EDBgin/F0oaW9vt9Y40U8/dP+mTboT96Xjx8yec91lpo5/+fkCcwMKqoM/iChr chBL5hQDVoB3XLXd5a+h2mdhlfqSUCjG9VsRGIcNcmQ6kXOOEXHzu+452ae8iazFNopLXmLNoUJ iK7fIUQ8A8ActXxNmTqTM9z0ZK6jGndf8K+j2cHuuMazpToYWWFYv6uroeMK7wJLxziI45NTNGV iUmJjH5HnSTwGywCRE3PC6Xxw6bT/XeWjb3GLAgD130fszmii/nG8jzzSX0RbjLCMQlILLcuXQU X-Received: by 2002:a17:902:ebc7:b0:2ca:e565:7b15 with SMTP id d9443c01a7336-2d5fd73d03dmr180793855ad.10.1787202414654; Wed, 19 Aug 2026 22:06:54 -0700 (PDT) Received: from DESKTOP-G3E0OSP.localdomain ([112.172.255.242]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2d62d58a82dsm2040685ad.18.2026.08.19.22.06.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Aug 2026 22:06:53 -0700 (PDT) From: Jinseob Kim To: jic23@kernel.org, linux-iio@vger.kernel.org Cc: dlechner@baylibre.com, nuno.sa@analog.com, andy@kernel.org, linux-kernel@vger.kernel.org, rdunlap@infradead.org, joshua.crofts1@gmail.com, u.kleine-koenig@baylibre.com, julianbraha@gmail.com, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, grondon@gmail.com, devicetree@vger.kernel.org, corbet@lwn.net, skhan@linuxfoundation.org, linux-doc@vger.kernel.org Subject: [PATCH v8 3/5] iio: osf: add protocol decoding Date: Thu, 20 Aug 2026 14:06:06 +0900 Message-ID: <20260820050608.5440-4-kimjinseob88@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260820050608.5440-1-kimjinseob88@gmail.com> References: <20260820050608.5440-1-kimjinseob88@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add helpers for decoding Open Sensor Fusion frame headers and supported message payloads. The decoder validates framing, payload bounds and CRC before exposing decoded frame contents to the rest of the driver. Framing validation includes the OSF0 wire magic and fixed header length. Protocol version and reserved header fields are exposed to the core so authenticated-frame policy is handled after CRC validation. Capability entries are decoded structurally, including their flags and reserved fields. The core can then apply support policy without rejecting an entire report solely because it contains future entry values. Use explicit little-endian wire storage sizes and designated initializers for decoded output structures. Signed-off-by: Jinseob Kim --- MAINTAINERS | 1 + drivers/iio/opensensorfusion/osf_protocol.c | 224 ++++++++++++++++++++ drivers/iio/opensensorfusion/osf_protocol.h | 101 +++++++++ 3 files changed, 326 insertions(+) create mode 100644 drivers/iio/opensensorfusion/osf_protocol.c create mode 100644 drivers/iio/opensensorfusion/osf_protocol.h diff --git a/MAINTAINERS b/MAINTAINERS index 9550cf1900bd..76fa860a7b91 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -20298,6 +20298,7 @@ M: Jinseob Kim S: Maintained F: Documentation/devicetree/bindings/iio/opensensorfusion,osf.yaml F: Documentation/iio/open-sensor-fusion.rst +F: drivers/iio/opensensorfusion/osf_protocol.* K: opensensorfusion =20 OPENCOMPUTE PTP CLOCK DRIVER diff --git a/drivers/iio/opensensorfusion/osf_protocol.c b/drivers/iio/open= sensorfusion/osf_protocol.c new file mode 100644 index 000000000000..cd7b8587f737 --- /dev/null +++ b/drivers/iio/opensensorfusion/osf_protocol.c @@ -0,0 +1,224 @@ +// SPDX-License-Identifier: GPL-2.0-only + +#include +#include +#include +#include +#include + +#include "osf_protocol.h" + +#define OSF_CRC32_INIT GENMASK(31, 0) +#define OSF_CRC32_XOROUT GENMASK(31, 0) + +static bool osf_sensor_type_valid(u16 sensor_type) +{ + return sensor_type >=3D OSF_SENSOR_ACCELEROMETER && + sensor_type <=3D OSF_SENSOR_PROXIMITY; +} + +static u32 osf_crc32_ieee(const u8 *buf, size_t len) +{ + return crc32_le(OSF_CRC32_INIT, buf, len) ^ OSF_CRC32_XOROUT; +} + +int osf_protocol_decode_frame(const u8 *buf, size_t len, + struct osf_frame *frame, size_t *frame_len) +{ + u32 expected_crc; + u32 actual_crc; + u32 payload_len; + size_t total_len; + + if (!buf || !frame || !frame_len) + return -EINVAL; + + if (len < OSF_FRAME_MIN_LEN) + return -EMSGSIZE; + + if (get_unaligned_le32(buf) !=3D OSF_FRAME_MAGIC) + return -EPROTO; + + if (get_unaligned_le16(buf + 6) !=3D OSF_FRAME_HEADER_LEN) + return -EPROTO; + + payload_len =3D get_unaligned_le32(buf + 10); + if (payload_len > len - OSF_FRAME_MIN_LEN) + return -EMSGSIZE; + + total_len =3D OSF_FRAME_HEADER_LEN + payload_len + OSF_FRAME_CRC_LEN; + expected_crc =3D osf_crc32_ieee(buf, OSF_FRAME_HEADER_LEN + payload_len); + actual_crc =3D get_unaligned_le32(buf + OSF_FRAME_HEADER_LEN + payload_le= n); + + if (actual_crc !=3D expected_crc) + return -EBADMSG; + + frame->protocol_major =3D buf[4]; + frame->protocol_minor =3D buf[5]; + frame->message_type =3D get_unaligned_le16(buf + 8); + frame->payload_len =3D payload_len; + frame->sequence =3D get_unaligned_le64(buf + 14); + frame->timestamp_us =3D get_unaligned_le64(buf + 22); + frame->flags =3D get_unaligned_le32(buf + 30); + frame->reserved =3D get_unaligned_le32(buf + 34); + frame->payload =3D buf + OSF_FRAME_HEADER_LEN; + frame->crc =3D actual_crc; + *frame_len =3D total_len; + + return 0; +} + +int osf_protocol_decode_sensor_sample(const struct osf_frame *frame, + struct osf_sensor_sample *sample) +{ + u16 channel_count; + u16 sample_format; + u16 sensor_type; + size_t expected_len; + const u8 *payload; + + if (!frame || !sample || !frame->payload) + return -EINVAL; + + if (frame->message_type !=3D OSF_MSG_SENSOR_SAMPLE) + return -EPROTO; + + if (frame->payload_len < OSF_SENSOR_SAMPLE_BASE_LEN) + return -EMSGSIZE; + + payload =3D frame->payload; + sensor_type =3D get_unaligned_le16(payload); + channel_count =3D get_unaligned_le16(payload + 4); + sample_format =3D get_unaligned_le16(payload + 6); + + if (!osf_sensor_type_valid(sensor_type)) + return -EPROTO; + + if (!channel_count) + return -EPROTO; + + if (sample_format !=3D OSF_SAMPLE_FORMAT_S32) + return -EPROTO; + + if (get_unaligned_le32(payload + 12)) + return -EPROTO; + + expected_len =3D OSF_SENSOR_SAMPLE_BASE_LEN + channel_count * sizeof(__le= 32); + if (frame->payload_len !=3D expected_len) + return -EMSGSIZE; + + *sample =3D (struct osf_sensor_sample) { + .sensor_type =3D sensor_type, + .sensor_index =3D get_unaligned_le16(payload + 2), + .channel_count =3D channel_count, + .sample_format =3D sample_format, + .scale_nano =3D get_unaligned_le32(payload + 8), + .samples =3D payload + OSF_SENSOR_SAMPLE_BASE_LEN, + }; + + return 0; +} + +int osf_protocol_sensor_sample_value(const struct osf_sensor_sample *sampl= e, + u16 index, s32 *value) +{ + if (!sample || !sample->samples || !value) + return -EINVAL; + + if (index >=3D sample->channel_count) + return -ERANGE; + + /* Samples are little-endian two's-complement signed values. */ + *value =3D get_unaligned_le32(sample->samples + index * sizeof(__le32)); + + return 0; +} + +int osf_protocol_decode_device_status(const struct osf_frame *frame, + struct osf_device_status *status) +{ + const u8 *payload; + + if (!frame || !status || !frame->payload) + return -EINVAL; + + if (frame->message_type !=3D OSF_MSG_DEVICE_STATUS) + return -EPROTO; + + if (frame->payload_len !=3D OSF_DEVICE_STATUS_LEN) + return -EMSGSIZE; + + payload =3D frame->payload; + if (get_unaligned_le32(payload + 16)) + return -EPROTO; + + *status =3D (struct osf_device_status) { + .uptime_s =3D get_unaligned_le32(payload), + .status_flags =3D get_unaligned_le32(payload + 4), + .error_flags =3D get_unaligned_le32(payload + 8), + .dropped_frames =3D get_unaligned_le32(payload + 12), + }; + + return 0; +} + +int osf_protocol_decode_capability_report(const struct osf_frame *frame, + struct osf_capability_report *report) +{ + u16 capability_count; + size_t expected_len; + const u8 *payload; + + if (!frame || !report || !frame->payload) + return -EINVAL; + + if (frame->message_type !=3D OSF_MSG_CAPABILITY_REPORT) + return -EPROTO; + + if (frame->payload_len < OSF_CAP_REPORT_BASE_LEN) + return -EMSGSIZE; + + payload =3D frame->payload; + capability_count =3D get_unaligned_le16(payload); + + if (get_unaligned_le16(payload + 2)) + return -EPROTO; + + expected_len =3D OSF_CAP_REPORT_BASE_LEN + + capability_count * OSF_CAP_SENSOR_ENTRY_LEN; + if (frame->payload_len !=3D expected_len) + return -EMSGSIZE; + + *report =3D (struct osf_capability_report) { + .capability_count =3D capability_count, + .entries =3D payload + OSF_CAP_REPORT_BASE_LEN, + }; + + return 0; +} + +int osf_protocol_decode_capability_entry(const struct osf_capability_report + *report, u16 index, + struct osf_capability_entry *entry) +{ + const u8 *payload; + + if (!report || !report->entries || !entry) + return -EINVAL; + + if (index >=3D report->capability_count) + return -ERANGE; + + payload =3D report->entries + index * OSF_CAP_SENSOR_ENTRY_LEN; + *entry =3D (struct osf_capability_entry) { + .sensor_type =3D get_unaligned_le16(payload), + .sensor_index =3D get_unaligned_le16(payload + 2), + .channel_count =3D get_unaligned_le16(payload + 4), + .sample_format =3D get_unaligned_le16(payload + 6), + .scale_nano =3D get_unaligned_le32(payload + 8), + .flags =3D get_unaligned_le32(payload + 12), + .reserved =3D get_unaligned_le32(payload + 16), + }; + + return 0; +} diff --git a/drivers/iio/opensensorfusion/osf_protocol.h b/drivers/iio/open= sensorfusion/osf_protocol.h new file mode 100644 index 000000000000..2b616f2d5197 --- /dev/null +++ b/drivers/iio/opensensorfusion/osf_protocol.h @@ -0,0 +1,101 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef _OSF_PROTOCOL_H +#define _OSF_PROTOCOL_H + +#include +#include + +#define OSF_PROTOCOL_MAJOR 0 +#define OSF_PROTOCOL_MINOR 0 +#define OSF_FRAME_HEADER_LEN 38 +#define OSF_FRAME_CRC_LEN 4 +#define OSF_FRAME_MIN_LEN (OSF_FRAME_HEADER_LEN + OSF_FRAME_CRC_LEN) +#define OSF_FRAME_MAGIC 0x3046534f /* "OSF0", little-endian */ + +#define OSF_SENSOR_SAMPLE_BASE_LEN 16 +#define OSF_DEVICE_STATUS_LEN 20 +#define OSF_CAP_REPORT_BASE_LEN 4 +#define OSF_CAP_SENSOR_ENTRY_LEN 20 +#define OSF_CAPABILITY_FLAGS_MASK GENMASK(1, 0) + +enum osf_message_type { + OSF_MSG_SENSOR_SAMPLE =3D 0x0001, + OSF_MSG_DEVICE_STATUS =3D 0x0002, + OSF_MSG_CAPABILITY_REPORT =3D 0x0003, +}; + +enum osf_sensor_type { + OSF_SENSOR_ACCELEROMETER =3D 0x0001, + OSF_SENSOR_GYROSCOPE =3D 0x0002, + OSF_SENSOR_MAGNETOMETER =3D 0x0003, + OSF_SENSOR_BAROMETER =3D 0x0004, + OSF_SENSOR_TEMPERATURE =3D 0x0005, + OSF_SENSOR_HUMIDITY =3D 0x0006, + OSF_SENSOR_AMBIENT_LIGHT =3D 0x0007, + OSF_SENSOR_PROXIMITY =3D 0x0008, +}; + +enum osf_sample_format { + OSF_SAMPLE_FORMAT_S32 =3D 0x0001, +}; + +struct osf_frame { + u8 protocol_major; + u8 protocol_minor; + u16 message_type; + u32 payload_len; + u64 sequence; + u64 timestamp_us; + u32 flags; + u32 reserved; + /* payload points into the caller-owned frame buffer. */ + const u8 *payload; + u32 crc; +}; + +struct osf_sensor_sample { + u16 sensor_type; + u16 sensor_index; + u16 channel_count; + u16 sample_format; + u32 scale_nano; + const u8 *samples; +}; + +struct osf_device_status { + u32 uptime_s; + u32 status_flags; + u32 error_flags; + u32 dropped_frames; +}; + +struct osf_capability_report { + u16 capability_count; + const u8 *entries; +}; + +struct osf_capability_entry { + u16 sensor_type; + u16 sensor_index; + u16 channel_count; + u16 sample_format; + u32 scale_nano; + u32 flags; + u32 reserved; +}; + +int osf_protocol_decode_frame(const u8 *buf, size_t len, + struct osf_frame *frame, size_t *frame_len); +int osf_protocol_decode_sensor_sample(const struct osf_frame *frame, + struct osf_sensor_sample *sample); +int osf_protocol_decode_device_status(const struct osf_frame *frame, + struct osf_device_status *status); +int osf_protocol_decode_capability_report(const struct osf_frame *frame, + struct osf_capability_report *report); +int osf_protocol_decode_capability_entry(const struct osf_capability_report + *report, u16 index, + struct osf_capability_entry *entry); +int osf_protocol_sensor_sample_value(const struct osf_sensor_sample *sampl= e, + u16 index, s32 *value); + +#endif --=20 2.43.0 From nobody Mon Sep 28 17:48:33 2026 Received: from mail-pl1-f173.google.com (mail-pl1-f173.google.com [209.85.214.173]) (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 F3EB93876CE for ; Thu, 20 Aug 2026 05:07:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.173 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787202424; cv=none; b=hkQ0TfXVwtjWcah63IdfCYI4q8YWC7Nf4UUlBpkFU0wCZHihbzS/EizSUFmNHwb6AMikjzEOpuPb4BuzWOiS+PMBYUpX8o093Kiwtkxk3ye0A6kwQd6IzLWRfbdYo+mttopeFQqj9zUOxSCg8GIrBIADsJldqkzMtfu8Fgt5S04= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787202424; c=relaxed/simple; bh=ecSTldjYc0eR16zdrrb5tSVl+tYpovDnI51QRYeqz0k=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=soHwbGErujgL90RAlqhtDJMfnEDAAa+CqBSAUbKuK+vrgunS+SgDThx6QliYJrVWHRhY/5ldjuyRDgeqMbwSRzOY5FmFRVXlv5VpqnsemSYCnasI+sjJSH96A+xCuvT126NI0L2oBjv8JrldJ2JFCMLg+BImV4sx3BK8vhqU2uI= 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=TJ18RRSn; arc=none smtp.client-ip=209.85.214.173 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="TJ18RRSn" Received: by mail-pl1-f173.google.com with SMTP id d9443c01a7336-2cc7e86e7aeso19757475ad.2 for ; Wed, 19 Aug 2026 22:07:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1787202422; x=1787807222; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=QSDGHLGAZ9pEeCwkKi+EOe7Q+Big6asBd/SfdVgmiK8=; b=TJ18RRSnl335Zh6kZCRxVLC6NKN2pBk6IE+8DNx5+xP43Nu2RME8qGYP20IRYeG71E iVKAvAcr1ZGPQ7aAHzcBlK+f50p4x5AxJJcbQZGzxpp4sWn7Vm2/1X5qB+vzUv/0jgug 5AFuJg2s7QeNNQLpU6kqeCzZEFrBfIiG3IP4QQWFk4mN76cL+bpsMF18BUbat3fBfki9 Tasg8/j79DBocKth2V21tpC423ShyJIChWbQnSf+7HiXW6XQYCGnBX4Svl6Q4Wffi2UY edJGEdHkqVSzbyS1UulRjTd1acbx070rk0It8GqRD4uh47baVVra4KiEq42SlPfDNesH +LTA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787202422; x=1787807222; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=QSDGHLGAZ9pEeCwkKi+EOe7Q+Big6asBd/SfdVgmiK8=; b=OwhoVelaymrAkLf83P+1n17dXQKDm/s3EgHDX4zWrc0AwjpxknvLVn5hFNkax/7MeY b9wu1ttzWPfVztPhjw8Zzno9c91RmB8OwUbiIgQi5m3qfxJol2fFC+RZuIWjVwztCL0D aOsyUMSibjvqBsN22+qwPiFFpxDN6e296rVNpSpYpAgjJ+gnQexcOAPMzYi7LET5xsd0 CMdSSq7QviYgPRuxKGfmowr5bUMt6/le5Dojav9sz2wdH6PozU8BA5HfExyrCO9zaAwR 2D32JwGJYTDOyQe5rRQJJT2STVB+g6Ces9j8tlFKuZkwJiBkH1U2SW/Lj8cEbm00YUTu P0gQ== X-Forwarded-Encrypted: i=1; AHgh+RoMAdfadV9Y4Dj/bIm4sSsmltPAGsiu8jS4JH5yRdCKnJJiE5KTwVWKf9SVhqb2YfanWwEAlUhxun3YsZY=@vger.kernel.org X-Gm-Message-State: AFuF++kJrqaHpaPc/C9rXrzMAht/iS8tzF0ejOmcpKTah6wlwfoitqLh jIUX+dOlc7wuLb+hO0gY4mlZYhyPaBo0RGpEIsdGlHOkmYDNC6TUe9Nx X-Gm-Gg: AR+sD13duVZBV/H1jwnHYRMIY3bIOOdqNp2hWzPANolH3iqnl/wrSlGzSshZ82Iz0Fa viqWtLMkkKynj+3nKLE5PC3oasluHzmBSuInQh3geRybz3X7N4NqT8AzI4tvLOEHR1e2OamoXRr A8I0rIFANr1EE9l/9JkubIzOUReKDWV8t9U5/tbLJHdN2ikcaqM/TzuBc/98G0qdxU1/j3Izym1 upeSx79RtAiXJSO9nDgb82W+h4i4/3tE+EfFz/gqD+czNd0x0WOCwFI6/wn8X1NEoGvKsonswqL c81Q+o1Pp7Oj+wurjtpHCltHvBCPyfEjSGHkCmzK9ir9dCMYrx3AwTz4TBaXmvGdEuQnoLlaJy+ Sh7rYQVKVaWFi1SfSp7HGqo+Gi5JYAv+7YVH3b98+jtOZtuM3iAVDldu4lOG92kzTn/XIHq/vft 9C0mTYFGOWPS/SpvXmVIZ4+oYZpjY3qlXaEfb0ZrtBASarRt0zu+9Z5mrgR8Ek5qTKLlQ/tcat3 Yq/tRtQIpb+A2Wy8B89o4fIw08MlI6/dHtE4zuM6BLSPn/ad5pnLYvEAUiemBMCZFQKAYC834X4 X-Received: by 2002:a17:903:144b:b0:2c8:f34c:82c0 with SMTP id d9443c01a7336-2d5fd64499emr189066325ad.2.1787202422040; Wed, 19 Aug 2026 22:07:02 -0700 (PDT) Received: from DESKTOP-G3E0OSP.localdomain ([112.172.255.242]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2d62d58a82dsm2040685ad.18.2026.08.19.22.06.58 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Aug 2026 22:07:01 -0700 (PDT) From: Jinseob Kim To: jic23@kernel.org, linux-iio@vger.kernel.org Cc: dlechner@baylibre.com, nuno.sa@analog.com, andy@kernel.org, linux-kernel@vger.kernel.org, rdunlap@infradead.org, joshua.crofts1@gmail.com, u.kleine-koenig@baylibre.com, julianbraha@gmail.com, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, grondon@gmail.com, devicetree@vger.kernel.org, corbet@lwn.net, skhan@linuxfoundation.org, linux-doc@vger.kernel.org Subject: [PATCH v8 4/5] iio: osf: add authenticated stream parser Date: Thu, 20 Aug 2026 14:06:07 +0900 Message-ID: <20260820050608.5440-5-kimjinseob88@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260820050608.5440-1-kimjinseob88@gmail.com> References: <20260820050608.5440-1-kimjinseob88@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add a UART byte-stream parser for Open Sensor Fusion frames. The parser searches for the OSF0 wire magic, keeps partial frames buffered, checks header length and payload bounds, and passes complete candidate frames to a registered frame callback. Candidates rejected before authentication drop only the current head byte before resynchronizing, so a corrupted unauthenticated payload length cannot make the parser skip later valid frames. CRC-valid authenticated frames are consumed in full and classified as handled, ignored, or rejected. Use a direct callback member with an opaque context and keep explicit statistics for authenticated outcomes and framing failures. Signed-off-by: Jinseob Kim --- MAINTAINERS | 1 + drivers/iio/opensensorfusion/osf_stream.c | 231 ++++++++++++++++++++++ drivers/iio/opensensorfusion/osf_stream.h | 53 +++++ 3 files changed, 285 insertions(+) create mode 100644 drivers/iio/opensensorfusion/osf_stream.c create mode 100644 drivers/iio/opensensorfusion/osf_stream.h diff --git a/MAINTAINERS b/MAINTAINERS index 76fa860a7b91..093b569de12e 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -20299,6 +20299,7 @@ S: Maintained F: Documentation/devicetree/bindings/iio/opensensorfusion,osf.yaml F: Documentation/iio/open-sensor-fusion.rst F: drivers/iio/opensensorfusion/osf_protocol.* +F: drivers/iio/opensensorfusion/osf_stream.* K: opensensorfusion =20 OPENCOMPUTE PTP CLOCK DRIVER diff --git a/drivers/iio/opensensorfusion/osf_stream.c b/drivers/iio/opense= nsorfusion/osf_stream.c new file mode 100644 index 000000000000..7ce45e631648 --- /dev/null +++ b/drivers/iio/opensensorfusion/osf_stream.c @@ -0,0 +1,231 @@ +// SPDX-License-Identifier: GPL-2.0-only + +#include +#include +#include +#include +#include + +#include "osf_protocol.h" +#include "osf_stream.h" + +#define OSF_STREAM_MAGIC_LEN sizeof(__le32) +#define OSF_STREAM_MAX_PAYLOAD_LEN \ + (OSF_STREAM_MAX_FRAME_LEN - OSF_FRAME_HEADER_LEN - OSF_FRAME_CRC_LEN) + +static void osf_stream_discard(struct osf_stream *stream, size_t count) +{ + if (count >=3D stream->len) { + stream->len =3D 0; + return; + } + + memmove(stream->buf, stream->buf + count, stream->len - count); + stream->len -=3D count; +} + +static void osf_stream_drop_invalid_head(struct osf_stream *stream) +{ + osf_stream_discard(stream, 1); +} + +static bool osf_stream_magic_prefix_match(const u8 *buf, size_t len) +{ + for (size_t i =3D 0; i < len; i++) { + if (buf[i] !=3D (u8)(OSF_FRAME_MAGIC >> (i * 8))) + return false; + } + + return true; +} + +static size_t osf_stream_discard_to_magic(struct osf_stream *stream) +{ + size_t old_len =3D stream->len; + size_t keep_len; + + for (size_t i =3D 0; i + OSF_STREAM_MAGIC_LEN <=3D stream->len; i++) { + if (get_unaligned_le32(stream->buf + i) =3D=3D OSF_FRAME_MAGIC) { + if (i) + osf_stream_discard(stream, i); + return i; + } + } + + /* + * Keep a final 1-3 byte OSF_FRAME_MAGIC prefix so a magic split + * across receive_buf() calls can be completed by the next chunk. + */ + keep_len =3D min(stream->len, OSF_STREAM_MAGIC_LEN - 1); + while (keep_len) { + size_t offset =3D stream->len - keep_len; + + if (osf_stream_magic_prefix_match(stream->buf + offset, keep_len)) { + if (offset) + osf_stream_discard(stream, offset); + return offset; + } + keep_len--; + } + + stream->len =3D 0; + return old_len; +} + +static int osf_stream_process(struct osf_stream *stream) +{ + size_t discarded; + size_t frame_len; + u32 payload_len; + int frame_result; + int first_err =3D 0; + + while (stream->len) { + discarded =3D osf_stream_discard_to_magic(stream); + if (discarded) { + stream->stats.bad_magic_resyncs++; + stream->stats.dropped_bytes +=3D discarded; + if (!first_err) + first_err =3D -EPROTO; + } + + if (!stream->len) + break; + + if (stream->len < OSF_FRAME_HEADER_LEN) + break; + + if (get_unaligned_le16(stream->buf + 6) !=3D OSF_FRAME_HEADER_LEN) { + stream->stats.dropped_bytes++; + osf_stream_drop_invalid_head(stream); + if (!first_err) + first_err =3D -EPROTO; + continue; + } + + payload_len =3D get_unaligned_le32(stream->buf + 10); + if (payload_len > OSF_STREAM_MAX_PAYLOAD_LEN) { + stream->stats.dropped_bytes++; + osf_stream_drop_invalid_head(stream); + if (!first_err) + first_err =3D -EMSGSIZE; + continue; + } + + frame_len =3D OSF_FRAME_HEADER_LEN + payload_len + OSF_FRAME_CRC_LEN; + if (stream->len < frame_len) + break; + + frame_result =3D stream->receive_frame(stream->frame_context, + stream->buf, frame_len); + if (frame_result < 0) { + if (frame_result =3D=3D -EBADMSG) + stream->stats.bad_crc_frames++; + + /* + * Decoding failed before the frame was authenticated; + * payload_len is still untrusted. Drop only the current + * head and resynchronize. + */ + stream->stats.dropped_bytes++; + osf_stream_drop_invalid_head(stream); + if (!first_err) + first_err =3D frame_result; + continue; + } + + /* Count exactly one outcome for every authenticated frame. */ + stream->stats.authenticated_frames++; + switch (frame_result) { + case OSF_STREAM_FRAME_HANDLED: + stream->stats.handled_frames++; + break; + case OSF_STREAM_FRAME_IGNORED: + stream->stats.ignored_frames++; + break; + case OSF_STREAM_FRAME_REJECTED: + stream->stats.rejected_frames++; + break; + default: + /* + * Preserve the authenticated boundary without scanning the + * payload for another magic value. + */ + stream->stats.rejected_frames++; + if (!first_err) + first_err =3D -EPROTO; + break; + } + osf_stream_discard(stream, frame_len); + } + + return first_err; +} + +void osf_stream_init(struct osf_stream *stream, + int (*receive_frame)(void *context, const u8 *buf, + size_t len), + void *frame_context) +{ + if (!stream) + return; + + stream->receive_frame =3D receive_frame; + stream->frame_context =3D frame_context; + stream->len =3D 0; + memset(&stream->stats, 0, sizeof(stream->stats)); +} + +void osf_stream_reset(struct osf_stream *stream) +{ + if (!stream) + return; + + stream->len =3D 0; + memset(&stream->stats, 0, sizeof(stream->stats)); +} + +int osf_stream_receive_bytes(struct osf_stream *stream, + const u8 *buf, size_t len) +{ + size_t copy_len; + size_t space; + int first_err =3D 0; + int ret; + + if (!stream || !stream->receive_frame || (!buf && len)) + return -EINVAL; + + if (!len) + return osf_stream_process(stream); + + /* + * Continue processing this receive_buf() chunk after recoverable + * framing errors so later valid frames do not wait for another callback. + * first_err retains the first diagnostic return, while the serdev + * callback reports the full byte count consumed. Every authenticated + * callback result is consumed in full by osf_stream_process(). + */ + while (len) { + space =3D OSF_STREAM_MAX_FRAME_LEN - stream->len; + if (!space) { + stream->stats.dropped_bytes++; + osf_stream_discard(stream, 1); + if (!first_err) + first_err =3D -EMSGSIZE; + continue; + } + + copy_len =3D min(len, space); + memcpy(stream->buf + stream->len, buf, copy_len); + stream->len +=3D copy_len; + buf +=3D copy_len; + len -=3D copy_len; + + ret =3D osf_stream_process(stream); + if (ret && !first_err) + first_err =3D ret; + } + + return first_err; +} diff --git a/drivers/iio/opensensorfusion/osf_stream.h b/drivers/iio/opense= nsorfusion/osf_stream.h new file mode 100644 index 000000000000..c13f4e3af18f --- /dev/null +++ b/drivers/iio/opensensorfusion/osf_stream.h @@ -0,0 +1,53 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef _OSF_STREAM_H +#define _OSF_STREAM_H + +#include + +#define OSF_STREAM_MAX_FRAME_LEN 4096 + +/** + * enum osf_stream_frame_result - authenticated frame callback result + * @OSF_STREAM_FRAME_HANDLED: frame was processed successfully + * @OSF_STREAM_FRAME_IGNORED: frame was valid but unsupported or ignored + * @OSF_STREAM_FRAME_REJECTED: authenticated application processing failed + * + * A frame callback returns a negative errno only when a candidate could n= ot + * be authenticated and the parser may perform one-byte resynchronization. + * Every nonnegative result must be one of these values. Such a result mea= ns + * the CRC-valid frame boundary is trusted, so the parser must consume the + * full frame. + */ +enum osf_stream_frame_result { + OSF_STREAM_FRAME_HANDLED, + OSF_STREAM_FRAME_IGNORED, + OSF_STREAM_FRAME_REJECTED, +}; + +struct osf_stream_stats { + u64 authenticated_frames; + u64 handled_frames; + u64 ignored_frames; + u64 rejected_frames; + u64 bad_magic_resyncs; + u64 bad_crc_frames; + u64 dropped_bytes; +}; + +struct osf_stream { + int (*receive_frame)(void *context, const u8 *buf, size_t len); + void *frame_context; + u8 buf[OSF_STREAM_MAX_FRAME_LEN]; + size_t len; + struct osf_stream_stats stats; +}; + +void osf_stream_init(struct osf_stream *stream, + int (*receive_frame)(void *context, const u8 *buf, + size_t len), + void *frame_context); +void osf_stream_reset(struct osf_stream *stream); +int osf_stream_receive_bytes(struct osf_stream *stream, + const u8 *buf, size_t len); + +#endif --=20 2.43.0 From nobody Mon Sep 28 17:48:33 2026 Received: from mail-pl1-f177.google.com (mail-pl1-f177.google.com [209.85.214.177]) (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 86BF838B7A5 for ; Thu, 20 Aug 2026 05:07:07 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.177 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787202432; cv=none; b=buO72kSrO27Vcha2uXAnhQPhHJchB4RqvQmRWw1AIZKBJ0MXCmBPOQy6XSwuJ/SABkpL/YrPQvIwsjpxLKR2R8KacBnrArqvJ5PIXO+DGlQcjtSDTI5UDooD+lDV+qT5T2llNorclBl8Bdcl6yNxYstrdFtYQNer4QeVirfZ3yg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787202432; c=relaxed/simple; bh=O6dfj4jHRRyCekryhkXJW4cmw4TeKNwQJkZXXsAVvDs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=QRFOg2LZ2KY/kLOdF5MYcawLoekUfX/qD1BvPi7RV4NJU8s/XEGUsLIvNVkecVbFpZ79puwCzXBjviYzGRGeL/p3BHuhW6Zp0LBYNit/5+hM+mMtyZuN3Z/sBDsEr2kh0xoKm4sIeNULg4TNvZjJtuOsS6wye6VSN1iyrckpxHU= 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=Z5s70zV9; arc=none smtp.client-ip=209.85.214.177 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="Z5s70zV9" Received: by mail-pl1-f177.google.com with SMTP id d9443c01a7336-2caced6038eso5924055ad.0 for ; Wed, 19 Aug 2026 22:07:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1787202427; x=1787807227; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=KVpJHSxoiPG0ATViUZ3Q3SyRLlSa3yfZtvS25/l3T84=; b=Z5s70zV9CI/r2nadtWi9gHT7jcD1jax4lBIwQnkTHWtmuhUwcdY+t4IGJWlSu56up6 lyduDOZyMG6O9n8SPCmMZrM3CkFBMFf+JBjxXzuIt6z7faGB6AA4avsWQzo5nkdsmUtU RmfaVqJMCSzaedspi1t6VT9ie6a7NjThV+M/VqXvNREWEHBdrDWQ8e+5Lg2xJDAPUcJN Y45k77OFxIdvBQIoD1Stody3+HpSAadqLoPtEWKAUda/fpFYYoX9IB5dVcuAIMjykwSl roH3wbojLs/poGXfGHCmCxYJp35NV+hZOVtwBHGsHa4tus4Xm3Nvc/0kSnivwv/bTHhV P2Ew== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787202427; x=1787807227; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=KVpJHSxoiPG0ATViUZ3Q3SyRLlSa3yfZtvS25/l3T84=; b=Jov9UOAej3mr9B/P5I+aB/RIR/s5g5T9waNq2CTqLwjrSLwMdM9IvNnUhveUAN31sw C8nLujTwqaBLbl4NBwVO49tEZtjkoXx8+RwnHLNBYaj51whdz3NDoEDOYJ5UIrK/4n7T JZr06mwWYubv/IYYVYZ6wbClrHjs/J5wCpy48F9Fl1caUQe7t8cY5xkLoLlOPlSQnU9O VtBD1HjvbWUJ72swLzJ46LEorDilhSB8Gox8GaX9/YYqKAbZuN8I12H+ktzksvqs3Pix TFBiTrV8PfGNI5IE0/RhvLXuPpJr5Dpj0ixhfg4a24L1VJpfSzF63c+puXdwLiVeKz/b 98cA== X-Forwarded-Encrypted: i=1; AHgh+RqrDsEyOerRJIw2LuZXslMdEKbFLCnvYP2jBczMo7LFotgEftKnIzxqlwXuo/GvrvX+VGAp+XeveE6Us94=@vger.kernel.org X-Gm-Message-State: AOJu0YxH4TVDysY1aXbA6zdCs6S6AUrHVhJ3xt5KgafXi5TkzGJJX+Ui K/FkAvaXLfRXVqkfezqdH7Bi27uICQAmQaAHGkVSh7X8T58MMI7ZKOPp X-Gm-Gg: AR+sD10rW3V53bqmDFbhRXnWOky62YoCpcs70cOJpTI8M7JCBkixMET0N/BVvu2QkPD F4i7Wxs76ge8dbDl8LYEKfjywEDV5qBkZ7Y5LPaPBWcD37uz6++dPzYFzRmKi+0a5eIQaXk7+db +MTfPtdOct71Mqi76VKPHOvaJC2KjTqq+y+8kL7eKQKChPCAnXNp6RHC0L9S1NCvKBBLymy6zeR 5HXoEhJRXNrj/rXewqmR4dixxO2pYef7lVwWjwqb9gLq6izpgofMYpTk1CIeGcSawRi5KVp2Dv5 VaPJMkYgfP7MwgFtLSLjOmIzgfuHqV3Di3ncfTmKM7e56NXCCq39VKu0krDd8GCpHxCO1sgGKqN JArHKm1az+eja3FXJNeG7jPPmezsRjyoeO1IabyV2xRWeXthSLpAYXVz7FzMPOtqmi5aN9dz31I /s34j4yyHpfvhA6MX8JnwV688HmpgWRQ6xOYKSGD6BZZzRzFGyaWgCEle+KF3Ge8J2amRnw9mA3 dsBarfPCHBTb47w5LK5PiDPV5hQnO+hqqEop8r/Np2Fc9+CNFb03IvLAiSmD2+J8A3H/Uo90zA1 jEHVrf0SoEg= X-Received: by 2002:a17:902:f64a:b0:2cc:fa13:dcab with SMTP id d9443c01a7336-2d61a1748d0mr49127395ad.8.1787202426468; Wed, 19 Aug 2026 22:07:06 -0700 (PDT) Received: from DESKTOP-G3E0OSP.localdomain ([112.172.255.242]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2d62d58a82dsm2040685ad.18.2026.08.19.22.07.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Aug 2026 22:07:05 -0700 (PDT) From: Jinseob Kim To: jic23@kernel.org, linux-iio@vger.kernel.org Cc: dlechner@baylibre.com, nuno.sa@analog.com, andy@kernel.org, linux-kernel@vger.kernel.org, rdunlap@infradead.org, joshua.crofts1@gmail.com, u.kleine-koenig@baylibre.com, julianbraha@gmail.com, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, grondon@gmail.com, devicetree@vger.kernel.org, corbet@lwn.net, skhan@linuxfoundation.org, linux-doc@vger.kernel.org Subject: [PATCH v8 5/5] iio: osf: add UART IIO driver Date: Thu, 20 Aug 2026 14:06:08 +0900 Message-ID: <20260820050608.5440-6-kimjinseob88@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260820050608.5440-1-kimjinseob88@gmail.com> References: <20260820050608.5440-1-kimjinseob88@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add the Open Sensor Fusion serdev transport, driver core, and IIO registration path as one complete driver patch. The driver enables the required vcc regulator, receives OSF frames over UART, registers IIO devices from capability reports, supports direct raw reads from the latest sample cache, and pushes buffered samples into software kfifo buffers. Wire the stream parser frame callback to the OSF core, use final Kconfig and Makefile contents from the start, check iio_buffer_enabled() before pushing samples, and use zero-initialized scan storage with explicit timestamp alignment. Classify authenticated application outcomes as handled, ignored, or rejected so the parser consumes every CRC-valid frame in full. Decode capability entries structurally, skip unsupported entries individually, and register the supported entries from the same report. Allocate latest sample cache slots only for sensors with registered IIO devices. Deliver sensor samples to IIO before committing the latest-sample cache, so a frame rejected by the registered channel layout or buffer path cannot change direct-read state or the last accepted sequence. Add focused KUnit coverage for rejected, valid, ignored, and malformed sample paths and cache-slot exhaustion. Signed-off-by: Jinseob Kim --- MAINTAINERS | 3 +- drivers/iio/Kconfig | 1 + drivers/iio/Makefile | 1 + drivers/iio/opensensorfusion/Kconfig | 27 + drivers/iio/opensensorfusion/Makefile | 7 + drivers/iio/opensensorfusion/osf_core.c | 393 +++++++++++++++ drivers/iio/opensensorfusion/osf_core.h | 70 +++ drivers/iio/opensensorfusion/osf_core_test.c | 493 +++++++++++++++++++ drivers/iio/opensensorfusion/osf_iio.c | 304 ++++++++++++ drivers/iio/opensensorfusion/osf_iio.h | 22 + drivers/iio/opensensorfusion/osf_serdev.c | 124 +++++ 11 files changed, 1443 insertions(+), 2 deletions(-) create mode 100644 drivers/iio/opensensorfusion/Kconfig create mode 100644 drivers/iio/opensensorfusion/Makefile create mode 100644 drivers/iio/opensensorfusion/osf_core.c create mode 100644 drivers/iio/opensensorfusion/osf_core.h create mode 100644 drivers/iio/opensensorfusion/osf_core_test.c create mode 100644 drivers/iio/opensensorfusion/osf_iio.c create mode 100644 drivers/iio/opensensorfusion/osf_iio.h create mode 100644 drivers/iio/opensensorfusion/osf_serdev.c diff --git a/MAINTAINERS b/MAINTAINERS index 093b569de12e..ec1e86718015 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -20298,8 +20298,7 @@ M: Jinseob Kim S: Maintained F: Documentation/devicetree/bindings/iio/opensensorfusion,osf.yaml F: Documentation/iio/open-sensor-fusion.rst -F: drivers/iio/opensensorfusion/osf_protocol.* -F: drivers/iio/opensensorfusion/osf_stream.* +F: drivers/iio/opensensorfusion/ K: opensensorfusion =20 OPENCOMPUTE PTP CLOCK DRIVER diff --git a/drivers/iio/Kconfig b/drivers/iio/Kconfig index 652557a5b851..89bb5b65c761 100644 --- a/drivers/iio/Kconfig +++ b/drivers/iio/Kconfig @@ -102,6 +102,7 @@ source "drivers/iio/light/Kconfig" source "drivers/iio/magnetometer/Kconfig" source "drivers/iio/multiplexer/Kconfig" source "drivers/iio/orientation/Kconfig" +source "drivers/iio/opensensorfusion/Kconfig" source "drivers/iio/test/Kconfig" if IIO_TRIGGER source "drivers/iio/trigger/Kconfig" diff --git a/drivers/iio/Makefile b/drivers/iio/Makefile index f03a4100c800..a51c4446ee09 100644 --- a/drivers/iio/Makefile +++ b/drivers/iio/Makefile @@ -38,6 +38,7 @@ obj-y +=3D light/ obj-y +=3D magnetometer/ obj-y +=3D multiplexer/ obj-y +=3D orientation/ +obj-y +=3D opensensorfusion/ obj-y +=3D position/ obj-y +=3D potentiometer/ obj-y +=3D potentiostat/ diff --git a/drivers/iio/opensensorfusion/Kconfig b/drivers/iio/opensensorf= usion/Kconfig new file mode 100644 index 000000000000..b4a2cde9645e --- /dev/null +++ b/drivers/iio/opensensorfusion/Kconfig @@ -0,0 +1,27 @@ +# SPDX-License-Identifier: GPL-2.0-only + +config OPEN_SENSOR_FUSION + tristate "Open Sensor Fusion UART IIO driver" + depends on SERIAL_DEV_BUS + select CRC32 + select IIO_BUFFER + select IIO_KFIFO_BUF + help + Build the Open Sensor Fusion UART IIO driver. + + The driver receives OSF protocol frames over a serdev UART and + registers IIO devices for supported capability entries. It exposes + accelerometer, gyroscope, magnetometer, and temperature samples + through IIO direct reads and software buffers. + +config OPEN_SENSOR_FUSION_KUNIT_TEST + bool "KUnit tests for Open Sensor Fusion" if !KUNIT_ALL_TESTS + depends on OPEN_SENSOR_FUSION=3Dy && KUNIT=3Dy + default KUNIT_ALL_TESTS + help + Build focused unit tests for the Open Sensor Fusion core sample + acceptance, direct-read cache, and IIO buffer paths. The tests + exercise accepted, ignored, and rejected sample handling without + exposing additional production interfaces. + + If unsure, say N. diff --git a/drivers/iio/opensensorfusion/Makefile b/drivers/iio/opensensor= fusion/Makefile new file mode 100644 index 000000000000..c2f5ba065a62 --- /dev/null +++ b/drivers/iio/opensensorfusion/Makefile @@ -0,0 +1,7 @@ +# SPDX-License-Identifier: GPL-2.0-only + +obj-$(CONFIG_OPEN_SENSOR_FUSION) +=3D open-sensor-fusion.o + +open-sensor-fusion-y :=3D osf_core.o osf_iio.o osf_protocol.o osf_serdev.o= \ + osf_stream.o +open-sensor-fusion-$(CONFIG_OPEN_SENSOR_FUSION_KUNIT_TEST) +=3D osf_core_t= est.o diff --git a/drivers/iio/opensensorfusion/osf_core.c b/drivers/iio/opensens= orfusion/osf_core.c new file mode 100644 index 000000000000..1b8434afb873 --- /dev/null +++ b/drivers/iio/opensensorfusion/osf_core.c @@ -0,0 +1,393 @@ +// SPDX-License-Identifier: GPL-2.0-only + +#include +#include +#include +#include +#include + +#include "osf_core.h" +#include "osf_iio.h" +#include "osf_stream.h" + +#define OSF_RESERVED_MSG_FIRST 0x7f00 +#define OSF_RESERVED_MSG_LAST 0x7fff +#define OSF_VENDOR_PRIVATE_FIRST 0x8000 + +void osf_core_init(struct osf_device *osf, struct device *dev) +{ + *osf =3D (struct osf_device) { + .dev =3D dev, + }; + mutex_init(&osf->latest_lock); +} + +void osf_core_unregister_iio(struct osf_device *osf) +{ + for (unsigned int i =3D 0; i < osf->iio_dev_count; i++) + osf_iio_unregister_sensor(osf->iio_devs[i].indio_dev); + + osf->iio_dev_count =3D 0; +} + +static struct iio_dev *osf_core_find_iio_dev(struct osf_device *osf, + u16 sensor_type, u16 sensor_index) +{ + const struct osf_iio_binding *binding; + + for (unsigned int i =3D 0; i < osf->iio_dev_count; i++) { + binding =3D &osf->iio_devs[i]; + if (binding->sensor_type =3D=3D sensor_type && + binding->sensor_index =3D=3D sensor_index) + return binding->indio_dev; + } + + return NULL; +} + +static struct osf_latest_sample * +osf_core_find_latest_sample(struct osf_device *osf, u16 sensor_type, + u16 sensor_index) +{ + struct osf_latest_sample *latest; + + for (unsigned int i =3D 0; i < osf->latest_sample_count; i++) { + latest =3D &osf->latest_samples[i]; + if (latest->sensor_type =3D=3D sensor_type && + latest->sensor_index =3D=3D sensor_index) + return latest; + } + + if (osf->latest_sample_count >=3D OSF_MAX_CAPABILITIES) + return NULL; + + return &osf->latest_samples[osf->latest_sample_count++]; +} + +static bool +osf_core_capability_supported(const struct osf_capability_entry *entry) +{ + return osf_iio_sensor_supported(entry->sensor_type, + entry->channel_count) && + entry->sample_format =3D=3D OSF_SAMPLE_FORMAT_S32 && + !(entry->flags & ~OSF_CAPABILITY_FLAGS_MASK) && + !entry->reserved; +} + +static bool osf_core_capability_is_duplicate(const struct osf_capability_c= ache *cache, + u16 index) +{ + const struct osf_capability_entry *entry =3D &cache->entries[index]; + + for (u16 i =3D 0; i < index; i++) { + if (cache->entries[i].sensor_type =3D=3D entry->sensor_type && + cache->entries[i].sensor_index =3D=3D entry->sensor_index) + return true; + } + + return false; +} + +static int osf_core_register_capabilities(struct osf_device *osf, + const struct osf_capability_cache *cache) +{ + struct iio_dev *indio_dev; + int ret; + + for (u16 i =3D 0; i < cache->capability_count; i++) { + if (osf_core_capability_is_duplicate(cache, i)) + return -EEXIST; + } + + for (u16 i =3D 0; i < cache->capability_count; i++) { + ret =3D osf_iio_register_sensor(osf->dev, &cache->entries[i], + osf, &indio_dev); + if (ret) + goto err_unregister; + + osf->iio_devs[osf->iio_dev_count++] =3D (struct osf_iio_binding) { + .sensor_type =3D cache->entries[i].sensor_type, + .sensor_index =3D cache->entries[i].sensor_index, + .indio_dev =3D indio_dev, + }; + } + + return 0; + +err_unregister: + osf_core_unregister_iio(osf); + + return ret; +} + +static int osf_core_handle_sensor_sample(struct osf_device *osf, + const struct osf_frame *frame) +{ + struct osf_latest_sample *latest; + struct osf_sensor_sample sample; + struct iio_dev *indio_dev; + s32 values[OSF_MAX_SAMPLE_CHANNELS] =3D { }; + int ret; + + ret =3D osf_protocol_decode_sensor_sample(frame, &sample); + if (ret) { + dev_warn_ratelimited(osf->dev, + "rejecting malformed sensor sample: %d\n", + ret); + return ret; + } + + indio_dev =3D osf_core_find_iio_dev(osf, sample.sensor_type, + sample.sensor_index); + if (!indio_dev) { + dev_dbg_ratelimited(osf->dev, + "ignoring sample for unregistered sensor %#x:%u\n", + sample.sensor_type, sample.sensor_index); + return OSF_STREAM_FRAME_IGNORED; + } + + if (sample.channel_count > OSF_MAX_SAMPLE_CHANNELS) { + dev_warn_ratelimited(osf->dev, + "rejecting sensor sample with %u channels\n", + sample.channel_count); + return -E2BIG; + } + + for (u16 i =3D 0; i < sample.channel_count; i++) { + ret =3D osf_protocol_sensor_sample_value(&sample, i, &values[i]); + if (ret) { + dev_warn_ratelimited(osf->dev, + "rejecting malformed sample value: %d\n", + ret); + return ret; + } + } + + ret =3D osf_iio_push_sample(indio_dev, values, sample.channel_count); + if (ret) { + dev_err_ratelimited(osf->dev, + "failed to push sensor %#x:%u sample: %d\n", + sample.sensor_type, sample.sensor_index, ret); + return ret; + } + + scoped_guard(mutex, &osf->latest_lock) { + latest =3D osf_core_find_latest_sample(osf, sample.sensor_type, + sample.sensor_index); + if (!latest) { + dev_err_ratelimited(osf->dev, + "latest sample cache full for sensor %#x:%u\n", + sample.sensor_type, + sample.sensor_index); + return -ENOSPC; + } + + memcpy(latest->values, values, sizeof(values)); + latest->sensor_type =3D sample.sensor_type; + latest->sensor_index =3D sample.sensor_index; + latest->channel_count =3D sample.channel_count; + latest->sample_format =3D sample.sample_format; + latest->scale_nano =3D sample.scale_nano; + latest->sequence =3D frame->sequence; + latest->timestamp_us =3D frame->timestamp_us; + latest->valid =3D true; + osf->last_sequence =3D frame->sequence; + } + + return OSF_STREAM_FRAME_HANDLED; +} + +static int osf_core_handle_device_status(struct osf_device *osf, + const struct osf_frame *frame) +{ + struct osf_device_status status; + int ret; + + ret =3D osf_protocol_decode_device_status(frame, &status); + if (ret) { + dev_warn_ratelimited(osf->dev, + "rejecting malformed device status: %d\n", + ret); + return ret; + } + + osf->status_cache =3D (struct osf_status_cache) { + .uptime_s =3D status.uptime_s, + .status_flags =3D status.status_flags, + .error_flags =3D status.error_flags, + .dropped_frames =3D status.dropped_frames, + .sequence =3D frame->sequence, + .valid =3D true, + }; + osf->last_sequence =3D frame->sequence; + + return OSF_STREAM_FRAME_HANDLED; +} + +static int osf_core_handle_capability_report(struct osf_device *osf, + const struct osf_frame *frame) +{ + struct osf_capability_cache cache =3D { }; + struct osf_capability_report report; + int frame_result; + int ret; + + ret =3D osf_protocol_decode_capability_report(frame, &report); + if (ret) { + dev_warn_ratelimited(osf->dev, + "rejecting malformed capability report: %d\n", + ret); + return ret; + } + + if (osf->capability_cache.valid) { + dev_dbg_ratelimited(osf->dev, + "ignoring repeated capability report\n"); + osf->last_sequence =3D frame->sequence; + return OSF_STREAM_FRAME_IGNORED; + } + + for (u16 i =3D 0; i < report.capability_count; i++) { + struct osf_capability_entry entry; + + ret =3D osf_protocol_decode_capability_entry(&report, i, &entry); + if (ret) { + dev_warn_ratelimited(osf->dev, + "rejecting malformed capability entry: %d\n", + ret); + return ret; + } + + if (!osf_core_capability_supported(&entry)) + continue; + + if (cache.capability_count >=3D OSF_MAX_CAPABILITIES) { + dev_warn_ratelimited(osf->dev, + "too many supported capabilities\n"); + return -E2BIG; + } + + cache.entries[cache.capability_count++] =3D entry; + } + + cache.sequence =3D frame->sequence; + cache.valid =3D true; + + frame_result =3D OSF_STREAM_FRAME_IGNORED; + if (cache.capability_count) { + ret =3D osf_core_register_capabilities(osf, &cache); + if (ret) { + if (ret =3D=3D -EEXIST) + dev_warn_ratelimited(osf->dev, + "rejecting duplicate capability\n"); + else + dev_err_ratelimited(osf->dev, + "failed to register capabilities: %d\n", + ret); + return ret; + } + frame_result =3D OSF_STREAM_FRAME_HANDLED; + } else { + dev_dbg_ratelimited(osf->dev, + "ignoring report without supported capabilities\n"); + } + + osf->capability_cache =3D cache; + osf->last_sequence =3D frame->sequence; + + return frame_result; +} + +int osf_core_receive_frame(struct osf_device *osf, const u8 *buf, size_t l= en) +{ + struct osf_frame frame; + size_t frame_len; + int ret; + + ret =3D osf_protocol_decode_frame(buf, len, &frame, &frame_len); + if (ret) + return ret; + + if (frame_len !=3D len) + return -EMSGSIZE; + + if (frame.protocol_major !=3D OSF_PROTOCOL_MAJOR) { + dev_dbg_ratelimited(osf->dev, + "ignoring unsupported protocol major %u\n", + frame.protocol_major); + return OSF_STREAM_FRAME_IGNORED; + } + + if (frame.reserved) { + dev_dbg_ratelimited(osf->dev, + "ignoring frame with reserved field %#x\n", + frame.reserved); + return OSF_STREAM_FRAME_IGNORED; + } + + switch (frame.message_type) { + case OSF_MSG_SENSOR_SAMPLE: + ret =3D osf_core_handle_sensor_sample(osf, &frame); + break; + case OSF_MSG_DEVICE_STATUS: + ret =3D osf_core_handle_device_status(osf, &frame); + break; + case OSF_MSG_CAPABILITY_REPORT: + ret =3D osf_core_handle_capability_report(osf, &frame); + break; + default: + if (frame.message_type >=3D OSF_RESERVED_MSG_FIRST && + frame.message_type <=3D OSF_RESERVED_MSG_LAST) { + dev_dbg_ratelimited(osf->dev, + "ignoring reserved message type %#x\n", + frame.message_type); + return OSF_STREAM_FRAME_IGNORED; + } + if (frame.message_type >=3D OSF_VENDOR_PRIVATE_FIRST) { + dev_dbg_ratelimited(osf->dev, + "ignoring vendor message type %#x\n", + frame.message_type); + return OSF_STREAM_FRAME_IGNORED; + } + + dev_dbg_ratelimited(osf->dev, + "ignoring unsupported message type %#x\n", + frame.message_type); + return OSF_STREAM_FRAME_IGNORED; + } + + /* + * Handler failures are authenticated application rejections. Keep the + * trusted frame boundary and let the stream consume the complete frame. + */ + if (ret < 0) + return OSF_STREAM_FRAME_REJECTED; + + return ret; +} + +int osf_core_read_latest_sample(struct osf_device *osf, u16 sensor_type, + u16 sensor_index, u16 channel, + s32 *value) +{ + const struct osf_latest_sample *latest; + + if (!osf || !value) + return -EINVAL; + + guard(mutex)(&osf->latest_lock); + for (unsigned int i =3D 0; i < osf->latest_sample_count; i++) { + latest =3D &osf->latest_samples[i]; + if (latest->sensor_type !=3D sensor_type || + latest->sensor_index !=3D sensor_index) + continue; + + if (!latest->valid || channel >=3D latest->channel_count) + break; + + *value =3D latest->values[channel]; + return 0; + } + + return -ENODATA; +} diff --git a/drivers/iio/opensensorfusion/osf_core.h b/drivers/iio/opensens= orfusion/osf_core.h new file mode 100644 index 000000000000..5744a39cfd9d --- /dev/null +++ b/drivers/iio/opensensorfusion/osf_core.h @@ -0,0 +1,70 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef _OSF_CORE_H +#define _OSF_CORE_H + +#include +#include + +#include "osf_protocol.h" + +#define OSF_MAX_SAMPLE_CHANNELS 3 +#define OSF_MAX_CAPABILITIES 16 + +struct device; +struct iio_dev; + +struct osf_latest_sample { + u16 sensor_type; + u16 sensor_index; + u16 channel_count; + u16 sample_format; + u32 scale_nano; + s32 values[OSF_MAX_SAMPLE_CHANNELS]; + u64 sequence; + u64 timestamp_us; + bool valid; +}; + +struct osf_capability_cache { + u16 capability_count; + struct osf_capability_entry entries[OSF_MAX_CAPABILITIES]; + u64 sequence; + bool valid; +}; + +struct osf_status_cache { + u32 uptime_s; + u32 status_flags; + u32 error_flags; + u32 dropped_frames; + u64 sequence; + bool valid; +}; + +struct osf_iio_binding { + u16 sensor_type; + u16 sensor_index; + struct iio_dev *indio_dev; +}; + +struct osf_device { + struct device *dev; + /* Protects latest_samples and latest_sample_count. */ + struct mutex latest_lock; + struct osf_latest_sample latest_samples[OSF_MAX_CAPABILITIES]; + unsigned int latest_sample_count; + struct osf_capability_cache capability_cache; + struct osf_status_cache status_cache; + struct osf_iio_binding iio_devs[OSF_MAX_CAPABILITIES]; + unsigned int iio_dev_count; + u64 last_sequence; +}; + +void osf_core_init(struct osf_device *osf, struct device *dev); +void osf_core_unregister_iio(struct osf_device *osf); +int osf_core_receive_frame(struct osf_device *osf, const u8 *buf, size_t l= en); +int osf_core_read_latest_sample(struct osf_device *osf, u16 sensor_type, + u16 sensor_index, u16 channel, + s32 *value); + +#endif diff --git a/drivers/iio/opensensorfusion/osf_core_test.c b/drivers/iio/ope= nsensorfusion/osf_core_test.c new file mode 100644 index 000000000000..e59c0458f945 --- /dev/null +++ b/drivers/iio/opensensorfusion/osf_core_test.c @@ -0,0 +1,493 @@ +// SPDX-License-Identifier: GPL-2.0-only + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "osf_core.h" +#include "osf_protocol.h" +#include "osf_stream.h" + +#define OSF_TEST_SENSOR_INDEX 0 +#define OSF_TEST_UNSUPPORTED_INDEX 7 +#define OSF_TEST_SCALE_NANO 1000000 +#define OSF_TEST_FLOOD_COUNT (OSF_MAX_CAPABILITIES + 4) +#define OSF_TEST_MAX_PAYLOAD_LEN \ + (OSF_SENSOR_SAMPLE_BASE_LEN + OSF_MAX_SAMPLE_CHANNELS * sizeof(__le32)) +#define OSF_TEST_MAX_FRAME_LEN \ + (OSF_FRAME_HEADER_LEN + OSF_CAP_REPORT_BASE_LEN + \ + 2 * OSF_CAP_SENSOR_ENTRY_LEN + OSF_FRAME_CRC_LEN) + +struct osf_test_context { + struct osf_device osf; + struct device *dev; + struct iio_dev *indio_dev; + struct iio_buffer *buffer; + bool buffer_enabled; +}; + +struct osf_test_scan_3axis { + s32 values[3]; +}; + +static size_t osf_test_build_frame(u8 *buf, size_t buf_size, + u16 message_type, const u8 *payload, + u32 payload_len, u64 sequence) +{ + size_t frame_len =3D OSF_FRAME_HEADER_LEN + payload_len + + OSF_FRAME_CRC_LEN; + u32 crc; + + if (frame_len > buf_size) + return 0; + + memset(buf, 0, frame_len); + put_unaligned_le32(OSF_FRAME_MAGIC, buf); + buf[4] =3D OSF_PROTOCOL_MAJOR; + buf[5] =3D OSF_PROTOCOL_MINOR; + put_unaligned_le16(OSF_FRAME_HEADER_LEN, buf + 6); + put_unaligned_le16(message_type, buf + 8); + put_unaligned_le32(payload_len, buf + 10); + put_unaligned_le64(sequence, buf + 14); + put_unaligned_le64(sequence * 1000, buf + 22); + memcpy(buf + OSF_FRAME_HEADER_LEN, payload, payload_len); + + crc =3D crc32_le(~0U, buf, OSF_FRAME_HEADER_LEN + payload_len) ^ ~0U; + put_unaligned_le32(crc, buf + OSF_FRAME_HEADER_LEN + payload_len); + + return frame_len; +} + +static size_t osf_test_build_capability_frame(u8 *buf, size_t buf_size, + u64 sequence) +{ + u8 payload[OSF_CAP_REPORT_BASE_LEN + + 2 * OSF_CAP_SENSOR_ENTRY_LEN] =3D { }; + u8 *supported =3D payload + OSF_CAP_REPORT_BASE_LEN; + u8 *unsupported =3D supported + OSF_CAP_SENSOR_ENTRY_LEN; + + put_unaligned_le16(2, payload); + put_unaligned_le16(OSF_SENSOR_ACCELEROMETER, supported); + put_unaligned_le16(OSF_TEST_SENSOR_INDEX, supported + 2); + put_unaligned_le16(3, supported + 4); + put_unaligned_le16(OSF_SAMPLE_FORMAT_S32, supported + 6); + put_unaligned_le32(OSF_TEST_SCALE_NANO, supported + 8); + + put_unaligned_le16(OSF_SENSOR_BAROMETER, unsupported); + put_unaligned_le16(OSF_TEST_UNSUPPORTED_INDEX, unsupported + 2); + put_unaligned_le16(1, unsupported + 4); + put_unaligned_le16(OSF_SAMPLE_FORMAT_S32, unsupported + 6); + put_unaligned_le32(OSF_TEST_SCALE_NANO, unsupported + 8); + + return osf_test_build_frame(buf, buf_size, OSF_MSG_CAPABILITY_REPORT, + payload, sizeof(payload), sequence); +} + +static size_t osf_test_build_sample_frame(u8 *buf, size_t buf_size, + u16 sensor_type, u16 sensor_index, + u16 channel_count, u16 sample_format, + const s32 *values, u64 sequence) +{ + u8 payload[OSF_TEST_MAX_PAYLOAD_LEN] =3D { }; + u32 payload_len; + + if (!channel_count || channel_count > OSF_MAX_SAMPLE_CHANNELS) + return 0; + + put_unaligned_le16(sensor_type, payload); + put_unaligned_le16(sensor_index, payload + 2); + put_unaligned_le16(channel_count, payload + 4); + put_unaligned_le16(sample_format, payload + 6); + put_unaligned_le32(OSF_TEST_SCALE_NANO, payload + 8); + + for (u16 i =3D 0; i < channel_count; i++) + put_unaligned_le32(values[i], + payload + OSF_SENSOR_SAMPLE_BASE_LEN + + i * sizeof(__le32)); + + payload_len =3D OSF_SENSOR_SAMPLE_BASE_LEN + + channel_count * sizeof(__le32); + + return osf_test_build_frame(buf, buf_size, OSF_MSG_SENSOR_SAMPLE, + payload, payload_len, sequence); +} + +static size_t osf_test_build_truncated_sample_frame(u8 *buf, size_t buf_si= ze, + u64 sequence) +{ + u8 payload[OSF_SENSOR_SAMPLE_BASE_LEN + sizeof(__le32)] =3D { }; + + put_unaligned_le16(OSF_SENSOR_ACCELEROMETER, payload); + put_unaligned_le16(OSF_TEST_SENSOR_INDEX, payload + 2); + put_unaligned_le16(3, payload + 4); + put_unaligned_le16(OSF_SAMPLE_FORMAT_S32, payload + 6); + put_unaligned_le32(OSF_TEST_SCALE_NANO, payload + 8); + put_unaligned_le32(42, payload + OSF_SENSOR_SAMPLE_BASE_LEN); + + return osf_test_build_frame(buf, buf_size, OSF_MSG_SENSOR_SAMPLE, + payload, sizeof(payload), sequence); +} + +static int osf_test_submit_sample(struct osf_test_context *ctx, + u16 sensor_type, u16 sensor_index, + u16 channel_count, u16 sample_format, + const s32 *values, u64 sequence) +{ + u8 frame[OSF_TEST_MAX_FRAME_LEN]; + size_t frame_len; + + frame_len =3D osf_test_build_sample_frame(frame, sizeof(frame), + sensor_type, sensor_index, + channel_count, sample_format, + values, sequence); + if (!frame_len) + return -EINVAL; + + return osf_core_receive_frame(&ctx->osf, frame, frame_len); +} + +static int osf_test_read_raw(struct osf_test_context *ctx, + unsigned int channel, int *value) +{ + int value2 =3D 0; + + return ctx->indio_dev->info->read_raw(ctx->indio_dev, + &ctx->indio_dev->channels[channel], + value, &value2, + IIO_CHAN_INFO_RAW); +} + +static int osf_test_remove_scan(struct osf_test_context *ctx, + struct osf_test_scan_3axis *scan) +{ + return iio_pop_from_buffer(ctx->buffer, scan); +} + +static int osf_test_enable_buffer(struct osf_test_context *ctx) +{ + unsigned long *scan_mask; + int ret; + + scan_mask =3D (unsigned long *)ctx->buffer->scan_mask; + for (unsigned int i =3D 0; i < 3; i++) + bitmap_set(scan_mask, ctx->indio_dev->channels[i].scan_index, 1); + ret =3D iio_update_buffers(ctx->indio_dev, ctx->buffer, NULL); + if (!ret) + ctx->buffer_enabled =3D true; + + return ret; +} + +static void osf_test_cleanup(void *data) +{ + struct osf_test_context *ctx =3D data; + + if (ctx->buffer_enabled) { + iio_update_buffers(ctx->indio_dev, NULL, ctx->buffer); + ctx->buffer_enabled =3D false; + } + + osf_core_unregister_iio(&ctx->osf); +} + +static int osf_test_init(struct kunit *test) +{ + struct osf_test_context *ctx; + u8 frame[OSF_TEST_MAX_FRAME_LEN]; + size_t frame_len; + int ret; + + ctx =3D kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + + test->priv =3D ctx; + ctx->dev =3D kunit_device_register(test, "osf-core"); + if (IS_ERR(ctx->dev)) + return PTR_ERR(ctx->dev); + if (!ctx->dev) + return -ENOMEM; + + osf_core_init(&ctx->osf, ctx->dev); + ret =3D kunit_add_action_or_reset(test, osf_test_cleanup, ctx); + if (ret) + return ret; + + frame_len =3D osf_test_build_capability_frame(frame, sizeof(frame), 1); + if (!frame_len) + return -EINVAL; + + ret =3D osf_core_receive_frame(&ctx->osf, frame, frame_len); + if (ret !=3D OSF_STREAM_FRAME_HANDLED) + return ret < 0 ? ret : -EINVAL; + if (ctx->osf.iio_dev_count !=3D 1 || + ctx->osf.capability_cache.capability_count !=3D 1) + return -EINVAL; + + ctx->indio_dev =3D ctx->osf.iio_devs[0].indio_dev; + ctx->buffer =3D ctx->indio_dev->buffer; + if (!ctx->buffer) + return -EINVAL; + + return 0; +} + +static void osf_test_expect_direct_sample(struct kunit *test, + struct osf_test_context *ctx, + const s32 *expected) +{ + int value; + int ret; + + for (unsigned int i =3D 0; i < 3; i++) { + value =3D 0; + ret =3D osf_test_read_raw(ctx, i, &value); + KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT); + KUNIT_EXPECT_EQ(test, value, expected[i]); + } +} + +static void +osf_rejected_channel_count_preserves_latest_test(struct kunit *test) +{ + struct osf_test_context *ctx =3D test->priv; + const s32 baseline_values[] =3D { 11, 22, 33 }; + const s32 rejected_values[] =3D { -999 }; + struct osf_sensor_sample decoded_sample; + struct osf_latest_sample baseline; + struct osf_test_scan_3axis scan; + struct osf_frame decoded_frame; + u8 rejected_frame[OSF_TEST_MAX_FRAME_LEN]; + size_t decoded_len; + size_t frame_len; + u64 baseline_sequence; + int ret; + + KUNIT_ASSERT_EQ(test, osf_test_enable_buffer(ctx), 0); + KUNIT_ASSERT_TRUE(test, iio_buffer_enabled(ctx->indio_dev)); + + ret =3D osf_test_submit_sample(ctx, OSF_SENSOR_ACCELEROMETER, + OSF_TEST_SENSOR_INDEX, 3, + OSF_SAMPLE_FORMAT_S32, + baseline_values, 2); + KUNIT_ASSERT_EQ(test, ret, OSF_STREAM_FRAME_HANDLED); + KUNIT_ASSERT_EQ(test, ctx->osf.latest_sample_count, 1U); + osf_test_expect_direct_sample(test, ctx, baseline_values); + + KUNIT_ASSERT_EQ(test, osf_test_remove_scan(ctx, &scan), 0); + + baseline =3D ctx->osf.latest_samples[0]; + baseline_sequence =3D ctx->osf.last_sequence; + frame_len =3D osf_test_build_sample_frame(rejected_frame, + sizeof(rejected_frame), + OSF_SENSOR_ACCELEROMETER, + OSF_TEST_SENSOR_INDEX, 1, + OSF_SAMPLE_FORMAT_S32, + rejected_values, 3); + KUNIT_ASSERT_NE(test, frame_len, (size_t)0); + KUNIT_ASSERT_EQ(test, + osf_protocol_decode_frame(rejected_frame, frame_len, + &decoded_frame, &decoded_len), 0); + KUNIT_ASSERT_EQ(test, decoded_len, frame_len); + KUNIT_ASSERT_EQ(test, + osf_protocol_decode_sensor_sample(&decoded_frame, + &decoded_sample), 0); + KUNIT_ASSERT_EQ(test, decoded_sample.channel_count, (u16)1); + ret =3D osf_core_receive_frame(&ctx->osf, rejected_frame, frame_len); + KUNIT_ASSERT_EQ(test, ret, OSF_STREAM_FRAME_REJECTED); + KUNIT_EXPECT_EQ(test, ctx->osf.latest_sample_count, 1U); + KUNIT_EXPECT_MEMEQ(test, &ctx->osf.latest_samples[0], &baseline, + sizeof(baseline)); + KUNIT_EXPECT_EQ(test, ctx->osf.last_sequence, baseline_sequence); + osf_test_expect_direct_sample(test, ctx, baseline_values); + KUNIT_EXPECT_EQ(test, osf_test_remove_scan(ctx, &scan), -EBUSY); +} + +static void +osf_valid_sample_updates_direct_and_buffer_test(struct kunit *test) +{ + struct osf_test_context *ctx =3D test->priv; + const s32 baseline_values[] =3D { 1, 2, 3 }; + const s32 rejected_values[] =3D { -1 }; + const s32 valid_values[] =3D { 101, -202, 303 }; + struct osf_test_scan_3axis scan =3D { }; + int ret; + + KUNIT_ASSERT_EQ(test, osf_test_enable_buffer(ctx), 0); + + ret =3D osf_test_submit_sample(ctx, OSF_SENSOR_ACCELEROMETER, + OSF_TEST_SENSOR_INDEX, 3, + OSF_SAMPLE_FORMAT_S32, + baseline_values, 2); + KUNIT_ASSERT_EQ(test, ret, OSF_STREAM_FRAME_HANDLED); + KUNIT_ASSERT_EQ(test, osf_test_remove_scan(ctx, &scan), 0); + + ret =3D osf_test_submit_sample(ctx, OSF_SENSOR_ACCELEROMETER, + OSF_TEST_SENSOR_INDEX, 1, + OSF_SAMPLE_FORMAT_S32, + rejected_values, 3); + KUNIT_ASSERT_EQ(test, ret, OSF_STREAM_FRAME_REJECTED); + KUNIT_ASSERT_EQ(test, osf_test_remove_scan(ctx, &scan), -EBUSY); + + ret =3D osf_test_submit_sample(ctx, OSF_SENSOR_ACCELEROMETER, + OSF_TEST_SENSOR_INDEX, 3, + OSF_SAMPLE_FORMAT_S32, + valid_values, 4); + KUNIT_ASSERT_EQ(test, ret, OSF_STREAM_FRAME_HANDLED); + osf_test_expect_direct_sample(test, ctx, valid_values); + KUNIT_ASSERT_EQ(test, ctx->indio_dev->scan_bytes, (int)sizeof(scan)); + KUNIT_ASSERT_EQ(test, osf_test_remove_scan(ctx, &scan), 0); + KUNIT_EXPECT_EQ(test, scan.values[0], valid_values[0]); + KUNIT_EXPECT_EQ(test, scan.values[1], valid_values[1]); + KUNIT_EXPECT_EQ(test, scan.values[2], valid_values[2]); + KUNIT_EXPECT_EQ(test, osf_test_remove_scan(ctx, &scan), -EBUSY); +} + +static void osf_unregistered_sample_is_ignored_test(struct kunit *test) +{ + struct osf_test_context *ctx =3D test->priv; + const s32 baseline_values[] =3D { 10, 20, 30 }; + const s32 ignored_values[] =3D { -10, -20, -30 }; + struct osf_latest_sample baseline; + struct osf_test_scan_3axis scan; + s32 value; + int ret; + + KUNIT_ASSERT_EQ(test, osf_test_enable_buffer(ctx), 0); + ret =3D osf_test_submit_sample(ctx, OSF_SENSOR_ACCELEROMETER, + OSF_TEST_SENSOR_INDEX, 3, + OSF_SAMPLE_FORMAT_S32, + baseline_values, 2); + KUNIT_ASSERT_EQ(test, ret, OSF_STREAM_FRAME_HANDLED); + KUNIT_ASSERT_EQ(test, osf_test_remove_scan(ctx, &scan), 0); + baseline =3D ctx->osf.latest_samples[0]; + + ret =3D osf_test_submit_sample(ctx, OSF_SENSOR_ACCELEROMETER, + OSF_TEST_SENSOR_INDEX + 1, 3, + OSF_SAMPLE_FORMAT_S32, + ignored_values, 3); + KUNIT_ASSERT_EQ(test, ret, OSF_STREAM_FRAME_IGNORED); + KUNIT_EXPECT_EQ(test, ctx->osf.iio_dev_count, 1U); + KUNIT_EXPECT_EQ(test, ctx->osf.latest_sample_count, 1U); + KUNIT_EXPECT_MEMEQ(test, &ctx->osf.latest_samples[0], &baseline, + sizeof(baseline)); + osf_test_expect_direct_sample(test, ctx, baseline_values); + ret =3D osf_core_read_latest_sample(&ctx->osf, + OSF_SENSOR_ACCELEROMETER, + OSF_TEST_SENSOR_INDEX + 1, + 0, &value); + KUNIT_EXPECT_EQ(test, ret, -ENODATA); + KUNIT_EXPECT_EQ(test, osf_test_remove_scan(ctx, &scan), -EBUSY); +} + +static void +osf_unaccepted_samples_do_not_exhaust_cache_test(struct kunit *test) +{ + struct osf_test_context *ctx =3D test->priv; + const s32 three_values[] =3D { 7, 8, 9 }; + const s32 one_value[] =3D { 42 }; + struct osf_latest_sample empty_cache[OSF_MAX_CAPABILITIES]; + struct osf_sensor_sample decoded_sample; + struct osf_frame decoded_frame; + u8 malformed_frame[OSF_TEST_MAX_FRAME_LEN]; + size_t decoded_len; + size_t frame_len; + int value; + int ret; + + KUNIT_ASSERT_EQ(test, ctx->osf.latest_sample_count, 0U); + memcpy(empty_cache, ctx->osf.latest_samples, sizeof(empty_cache)); + + for (unsigned int i =3D 0; i < OSF_TEST_FLOOD_COUNT; i++) { + ret =3D osf_test_submit_sample(ctx, OSF_SENSOR_ACCELEROMETER, + OSF_TEST_SENSOR_INDEX + i + 1, + 3, OSF_SAMPLE_FORMAT_S32, + three_values, 100 + i); + KUNIT_ASSERT_EQ(test, ret, OSF_STREAM_FRAME_IGNORED); + } + KUNIT_ASSERT_EQ(test, ctx->osf.latest_sample_count, 0U); + + for (unsigned int i =3D 0; i < OSF_TEST_FLOOD_COUNT; i++) { + ret =3D osf_test_submit_sample(ctx, OSF_SENSOR_BAROMETER, + OSF_TEST_UNSUPPORTED_INDEX, 1, + OSF_SAMPLE_FORMAT_S32, + one_value, 200 + i); + KUNIT_ASSERT_EQ(test, ret, OSF_STREAM_FRAME_IGNORED); + } + KUNIT_ASSERT_EQ(test, ctx->osf.latest_sample_count, 0U); + + for (unsigned int i =3D 0; i < OSF_TEST_FLOOD_COUNT; i++) { + ret =3D osf_test_submit_sample(ctx, OSF_SENSOR_ACCELEROMETER, + OSF_TEST_SENSOR_INDEX, 1, + OSF_SAMPLE_FORMAT_S32, + one_value, 300 + i); + KUNIT_ASSERT_EQ(test, ret, OSF_STREAM_FRAME_REJECTED); + } + KUNIT_ASSERT_EQ(test, ctx->osf.latest_sample_count, 0U); + + frame_len =3D osf_test_build_truncated_sample_frame(malformed_frame, + sizeof(malformed_frame), 400); + KUNIT_ASSERT_NE(test, frame_len, (size_t)0); + KUNIT_ASSERT_EQ(test, + osf_protocol_decode_frame(malformed_frame, frame_len, + &decoded_frame, &decoded_len), 0); + KUNIT_ASSERT_EQ(test, decoded_len, frame_len); + KUNIT_ASSERT_EQ(test, + osf_protocol_decode_sensor_sample(&decoded_frame, + &decoded_sample), + -EMSGSIZE); + + for (unsigned int i =3D 0; i < OSF_TEST_FLOOD_COUNT; i++) { + ret =3D osf_core_receive_frame(&ctx->osf, malformed_frame, + frame_len); + KUNIT_ASSERT_EQ(test, ret, OSF_STREAM_FRAME_REJECTED); + } + KUNIT_ASSERT_EQ(test, ctx->osf.latest_sample_count, 0U); + + KUNIT_EXPECT_MEMEQ(test, ctx->osf.latest_samples, empty_cache, + sizeof(empty_cache)); + KUNIT_EXPECT_EQ(test, ctx->osf.last_sequence, (u64)1); + + ret =3D osf_test_submit_sample(ctx, OSF_SENSOR_ACCELEROMETER, + OSF_TEST_SENSOR_INDEX, 3, + OSF_SAMPLE_FORMAT_S32, + three_values, 500); + KUNIT_ASSERT_EQ(test, ret, OSF_STREAM_FRAME_HANDLED); + KUNIT_ASSERT_EQ(test, ctx->osf.latest_sample_count, 1U); + + for (unsigned int i =3D 0; i < 3; i++) { + value =3D 0; + ret =3D osf_test_read_raw(ctx, i, &value); + KUNIT_ASSERT_EQ(test, ret, IIO_VAL_INT); + KUNIT_EXPECT_EQ(test, value, three_values[i]); + } +} + +static struct kunit_case osf_core_test_cases[] =3D { + KUNIT_CASE(osf_rejected_channel_count_preserves_latest_test), + KUNIT_CASE(osf_valid_sample_updates_direct_and_buffer_test), + KUNIT_CASE(osf_unregistered_sample_is_ignored_test), + KUNIT_CASE(osf_unaccepted_samples_do_not_exhaust_cache_test), + { } +}; + +static struct kunit_suite osf_core_test_suite =3D { + .name =3D "osf-core", + .init =3D osf_test_init, + .test_cases =3D osf_core_test_cases, +}; + +kunit_test_suite(osf_core_test_suite); + +MODULE_LICENSE("GPL"); diff --git a/drivers/iio/opensensorfusion/osf_iio.c b/drivers/iio/opensenso= rfusion/osf_iio.c new file mode 100644 index 000000000000..56030b4d6a9f --- /dev/null +++ b/drivers/iio/opensensorfusion/osf_iio.c @@ -0,0 +1,304 @@ +// SPDX-License-Identifier: GPL-2.0-only + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "osf_core.h" +#include "osf_iio.h" + +struct osf_iio_sensor_spec { + u16 sensor_type; + u16 channel_count; + const char *name; + const struct iio_chan_spec *channels; + unsigned int num_channels; + const unsigned long *available_scan_masks; +}; + +struct osf_iio_state { + const struct osf_iio_sensor_spec *spec; + struct iio_buffer *buffer; + u32 scale_nano; + u16 sensor_index; + struct osf_device *osf; +}; + +struct osf_iio_scan_3axis { + s32 values[3]; + aligned_s64 timestamp; +}; + +struct osf_iio_scan_1axis { + s32 value; + aligned_s64 timestamp; +}; + +#define OSF_MOD_CHAN(_type, _mod, _idx) \ + { \ + .type =3D (_type), \ + .modified =3D 1, \ + .channel2 =3D (_mod), \ + .info_mask_separate =3D BIT(IIO_CHAN_INFO_RAW), \ + .info_mask_shared_by_type =3D BIT(IIO_CHAN_INFO_SCALE), \ + .scan_index =3D (_idx), \ + .scan_type =3D { \ + .sign =3D 's', \ + .realbits =3D 32, \ + .storagebits =3D 32, \ + .endianness =3D IIO_CPU, \ + }, \ + } + +#define OSF_CHAN(_type, _idx) \ + { \ + .type =3D (_type), \ + .info_mask_separate =3D BIT(IIO_CHAN_INFO_RAW), \ + .info_mask_shared_by_type =3D BIT(IIO_CHAN_INFO_SCALE), \ + .scan_index =3D (_idx), \ + .scan_type =3D { \ + .sign =3D 's', \ + .realbits =3D 32, \ + .storagebits =3D 32, \ + .endianness =3D IIO_CPU, \ + }, \ + } + +static const struct iio_chan_spec osf_accel_channels[] =3D { + OSF_MOD_CHAN(IIO_ACCEL, IIO_MOD_X, 0), + OSF_MOD_CHAN(IIO_ACCEL, IIO_MOD_Y, 1), + OSF_MOD_CHAN(IIO_ACCEL, IIO_MOD_Z, 2), + IIO_CHAN_SOFT_TIMESTAMP(3), +}; + +static const struct iio_chan_spec osf_gyro_channels[] =3D { + OSF_MOD_CHAN(IIO_ANGL_VEL, IIO_MOD_X, 0), + OSF_MOD_CHAN(IIO_ANGL_VEL, IIO_MOD_Y, 1), + OSF_MOD_CHAN(IIO_ANGL_VEL, IIO_MOD_Z, 2), + IIO_CHAN_SOFT_TIMESTAMP(3), +}; + +static const struct iio_chan_spec osf_mag_channels[] =3D { + OSF_MOD_CHAN(IIO_MAGN, IIO_MOD_X, 0), + OSF_MOD_CHAN(IIO_MAGN, IIO_MOD_Y, 1), + OSF_MOD_CHAN(IIO_MAGN, IIO_MOD_Z, 2), + IIO_CHAN_SOFT_TIMESTAMP(3), +}; + +static const struct iio_chan_spec osf_temp_channels[] =3D { + OSF_CHAN(IIO_TEMP, 0), + IIO_CHAN_SOFT_TIMESTAMP(1), +}; + +static const unsigned long osf_3axis_available_scan_masks[] =3D { + GENMASK(2, 0), + 0 +}; + +static const struct osf_iio_sensor_spec osf_iio_sensor_specs[] =3D { + { + .sensor_type =3D OSF_SENSOR_ACCELEROMETER, + .channel_count =3D 3, + .name =3D "osf-accel", + .channels =3D osf_accel_channels, + .num_channels =3D ARRAY_SIZE(osf_accel_channels), + .available_scan_masks =3D osf_3axis_available_scan_masks, + }, + { + .sensor_type =3D OSF_SENSOR_GYROSCOPE, + .channel_count =3D 3, + .name =3D "osf-gyro", + .channels =3D osf_gyro_channels, + .num_channels =3D ARRAY_SIZE(osf_gyro_channels), + .available_scan_masks =3D osf_3axis_available_scan_masks, + }, + { + .sensor_type =3D OSF_SENSOR_MAGNETOMETER, + .channel_count =3D 3, + .name =3D "osf-magn", + .channels =3D osf_mag_channels, + .num_channels =3D ARRAY_SIZE(osf_mag_channels), + .available_scan_masks =3D osf_3axis_available_scan_masks, + }, + { + .sensor_type =3D OSF_SENSOR_TEMPERATURE, + .channel_count =3D 1, + .name =3D "osf-temp", + .channels =3D osf_temp_channels, + .num_channels =3D ARRAY_SIZE(osf_temp_channels), + }, +}; + +static const struct osf_iio_sensor_spec * +osf_iio_find_sensor_spec(u16 sensor_type, u16 channel_count) +{ + for (unsigned int i =3D 0; i < ARRAY_SIZE(osf_iio_sensor_specs); i++) { + if (osf_iio_sensor_specs[i].sensor_type =3D=3D sensor_type && + osf_iio_sensor_specs[i].channel_count =3D=3D channel_count) + return &osf_iio_sensor_specs[i]; + } + + return NULL; +} + +bool osf_iio_sensor_supported(u16 sensor_type, u16 channel_count) +{ + if (osf_iio_find_sensor_spec(sensor_type, channel_count)) + return true; + + return false; +} + +const char *osf_iio_sensor_name(u16 sensor_type) +{ + for (unsigned int i =3D 0; i < ARRAY_SIZE(osf_iio_sensor_specs); i++) { + if (osf_iio_sensor_specs[i].sensor_type =3D=3D sensor_type) + return osf_iio_sensor_specs[i].name; + } + + return NULL; +} + +static int osf_iio_read_raw(struct iio_dev *indio_dev, + const struct iio_chan_spec *chan, int *val, + int *val2, long mask) +{ + struct osf_iio_state *state =3D iio_priv(indio_dev); + s32 raw; + int ret; + + switch (mask) { + case IIO_CHAN_INFO_RAW: + ret =3D osf_core_read_latest_sample(state->osf, + state->spec->sensor_type, + state->sensor_index, + chan->scan_index, &raw); + if (ret) + return ret; + + *val =3D raw; + return IIO_VAL_INT; + case IIO_CHAN_INFO_SCALE: + *val =3D state->scale_nano / NANO; + *val2 =3D state->scale_nano % NANO; + return IIO_VAL_INT_PLUS_NANO; + default: + return -EINVAL; + } +} + +static const struct iio_info osf_iio_info =3D { + .read_raw =3D osf_iio_read_raw, +}; + +int osf_iio_register_sensor(struct device *dev, + const struct osf_capability_entry *entry, + struct osf_device *osf, struct iio_dev **indio_dev) +{ + const struct osf_iio_sensor_spec *spec; + struct osf_iio_state *state; + struct iio_dev *iio_dev; + int ret; + + spec =3D osf_iio_find_sensor_spec(entry->sensor_type, + entry->channel_count); + if (!spec) + return -EOPNOTSUPP; + + if (entry->sample_format !=3D OSF_SAMPLE_FORMAT_S32 || + (entry->flags & ~OSF_CAPABILITY_FLAGS_MASK) || + entry->reserved) + return -EOPNOTSUPP; + + iio_dev =3D iio_device_alloc(dev, sizeof(*state)); + if (!iio_dev) + return -ENOMEM; + + state =3D iio_priv(iio_dev); + state->spec =3D spec; + state->scale_nano =3D entry->scale_nano; + state->sensor_index =3D entry->sensor_index; + state->osf =3D osf; + + iio_dev->name =3D spec->name; + iio_dev->info =3D &osf_iio_info; + iio_dev->modes =3D INDIO_DIRECT_MODE | INDIO_BUFFER_SOFTWARE; + iio_dev->channels =3D spec->channels; + iio_dev->num_channels =3D spec->num_channels; + iio_dev->available_scan_masks =3D spec->available_scan_masks; + + state->buffer =3D iio_kfifo_allocate(); + if (!state->buffer) { + ret =3D -ENOMEM; + goto err_free_iio; + } + + ret =3D iio_device_attach_buffer(iio_dev, state->buffer); + if (ret) + goto err_free_buffer; + + ret =3D iio_device_register(iio_dev); + if (ret) + goto err_free_buffer; + + *indio_dev =3D iio_dev; + + return 0; + +err_free_buffer: + iio_kfifo_free(state->buffer); +err_free_iio: + iio_device_free(iio_dev); + + return ret; +} + +void osf_iio_unregister_sensor(struct iio_dev *indio_dev) +{ + struct osf_iio_state *state =3D iio_priv(indio_dev); + + iio_device_unregister(indio_dev); + iio_kfifo_free(state->buffer); + iio_device_free(indio_dev); +} + +int osf_iio_push_sample(struct iio_dev *indio_dev, const s32 *values, + u16 channel_count) +{ + struct osf_iio_state *state =3D iio_priv(indio_dev); + s64 timestamp; + + if (channel_count !=3D state->spec->channel_count) + return -EPROTO; + + if (!iio_buffer_enabled(indio_dev)) + return 0; + + timestamp =3D iio_get_time_ns(indio_dev); + + switch (channel_count) { + case 1: { + struct osf_iio_scan_1axis scan =3D { }; + + scan.value =3D values[0]; + return iio_push_to_buffers_with_ts(indio_dev, &scan, + sizeof(scan), timestamp); + } + case 3: { + struct osf_iio_scan_3axis scan =3D { }; + + scan.values[0] =3D values[0]; + scan.values[1] =3D values[1]; + scan.values[2] =3D values[2]; + return iio_push_to_buffers_with_ts(indio_dev, &scan, + sizeof(scan), timestamp); + } + default: + return -EPROTO; + } +} diff --git a/drivers/iio/opensensorfusion/osf_iio.h b/drivers/iio/opensenso= rfusion/osf_iio.h new file mode 100644 index 000000000000..d0745167f8e0 --- /dev/null +++ b/drivers/iio/opensensorfusion/osf_iio.h @@ -0,0 +1,22 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef _OSF_IIO_H +#define _OSF_IIO_H + +#include + +#include "osf_protocol.h" + +struct device; +struct iio_dev; +struct osf_device; + +int osf_iio_register_sensor(struct device *dev, + const struct osf_capability_entry *entry, + struct osf_device *osf, struct iio_dev **indio_dev); +void osf_iio_unregister_sensor(struct iio_dev *indio_dev); +int osf_iio_push_sample(struct iio_dev *indio_dev, const s32 *values, + u16 channel_count); +bool osf_iio_sensor_supported(u16 sensor_type, u16 channel_count); +const char *osf_iio_sensor_name(u16 sensor_type); + +#endif diff --git a/drivers/iio/opensensorfusion/osf_serdev.c b/drivers/iio/opense= nsorfusion/osf_serdev.c new file mode 100644 index 000000000000..d21f2f27a6de --- /dev/null +++ b/drivers/iio/opensensorfusion/osf_serdev.c @@ -0,0 +1,124 @@ +// SPDX-License-Identifier: GPL-2.0-only + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "osf_core.h" +#include "osf_stream.h" + +#define OSF_SERDEV_BAUD 115200 + +struct osf_serdev { + struct serdev_device *serdev; + struct osf_device osf; + struct osf_stream stream; +}; + +static int osf_serdev_receive_frame(void *context, const u8 *buf, size_t l= en) +{ + struct osf_device *osf =3D context; + + return osf_core_receive_frame(osf, buf, len); +} + +static size_t osf_serdev_receive_buf(struct serdev_device *serdev, + const u8 *buf, size_t count) +{ + struct osf_serdev *osf_uart =3D serdev_device_get_drvdata(serdev); + const struct osf_stream_stats *stats; + u64 authenticated_before; + int ret; + + authenticated_before =3D osf_uart->stream.stats.authenticated_frames; + ret =3D osf_stream_receive_bytes(&osf_uart->stream, buf, count); + stats =3D &osf_uart->stream.stats; + + if (ret || stats->authenticated_frames !=3D authenticated_before) + dev_dbg_ratelimited(&serdev->dev, + "rx count=3D%zu authenticated=3D%llu handled=3D%llu ignored=3D%llu= rejected=3D%llu bad_magic=3D%llu bad_crc=3D%llu dropped=3D%llu ret=3D%d\n", + count, stats->authenticated_frames, + stats->handled_frames, stats->ignored_frames, + stats->rejected_frames, + stats->bad_magic_resyncs, + stats->bad_crc_frames, + stats->dropped_bytes, ret); + + return count; +} + +static const struct serdev_device_ops osf_serdev_ops =3D { + .receive_buf =3D osf_serdev_receive_buf, +}; + +static int osf_serdev_probe(struct serdev_device *serdev) +{ + struct device *dev =3D &serdev->dev; + struct osf_serdev *osf_uart; + unsigned int baudrate; + int ret; + + osf_uart =3D devm_kzalloc(dev, sizeof(*osf_uart), GFP_KERNEL); + if (!osf_uart) + return -ENOMEM; + + osf_uart->serdev =3D serdev; + osf_core_init(&osf_uart->osf, dev); + osf_stream_init(&osf_uart->stream, osf_serdev_receive_frame, + &osf_uart->osf); + + serdev_device_set_drvdata(serdev, osf_uart); + serdev_device_set_client_ops(serdev, &osf_serdev_ops); + + ret =3D devm_regulator_get_enable(dev, "vcc"); + if (ret) + return dev_err_probe(dev, ret, + "failed to enable vcc regulator\n"); + + ret =3D serdev_device_open(serdev); + if (ret) + return ret; + + baudrate =3D serdev_device_set_baudrate(serdev, OSF_SERDEV_BAUD); + if (baudrate !=3D OSF_SERDEV_BAUD) + dev_warn(dev, "requested %u baud, controller set %u\n", + OSF_SERDEV_BAUD, baudrate); + + serdev_device_set_flow_control(serdev, false); + + return 0; +} + +static void osf_serdev_remove(struct serdev_device *serdev) +{ + struct osf_serdev *osf_uart =3D serdev_device_get_drvdata(serdev); + + /* Stop the RX producer before unregistering IIO consumers. */ + serdev_device_close(serdev); + osf_stream_reset(&osf_uart->stream); + osf_core_unregister_iio(&osf_uart->osf); +} + +static const struct of_device_id osf_serdev_of_match[] =3D { + { .compatible =3D "opensensorfusion,osf" }, + { } +}; +MODULE_DEVICE_TABLE(of, osf_serdev_of_match); + +static struct serdev_device_driver osf_serdev_driver =3D { + .probe =3D osf_serdev_probe, + .remove =3D osf_serdev_remove, + .driver =3D { + .name =3D "open-sensor-fusion-uart", + .of_match_table =3D osf_serdev_of_match, + }, +}; +module_serdev_device_driver(osf_serdev_driver); + +MODULE_DESCRIPTION("Open Sensor Fusion IIO driver"); +MODULE_LICENSE("GPL"); --=20 2.43.0