From patchwork Fri Mar 14 09:04:59 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?THUgVGFuZyAo5rGk55KQKQ==?= X-Patchwork-Id: 14016502 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 81305C282EC for ; Fri, 14 Mar 2025 09:10:11 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:MIME-Version: Content-Transfer-Encoding:Content-Type:In-Reply-To:References:Message-ID:Date :Subject:CC:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=AeXdRY6suBDzBVtJPXEJ1izyY1NjEbGM8aV2aKYtoNk=; b=vLYL5eDJ/13w194SSzgLxskc3t 8IAq8vvdRHhBiMEDTD4drq+JTyFCFT3quAWKBOkL0n6zxHpzPkU4uiFyylSfX7mf2moHpiSAu9wBp +t7TYcUatRLiDcrPg5uvWy7oSVpbSMmjGNVZzHMv/OnOyHbm/MY+CDsd9joJ59USWKEYecXHUaQjg xCVtAexDfP8fJHmYtNY5+xcoW6SYN6qPcXpVepOvGtW7FCa2TjaNti4RTvYZIeTfVhE36IoZBKSfd D8LK1ysB/BFWdOb6cYqCOM2sHPMC9GBKGlB8PobUjfYpjVMx/07TOOGCLyxmYWbH8msBGlsCubUJ1 tdvFJI9A==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1tt13E-0000000Dcgi-1ZjL; Fri, 14 Mar 2025 09:09:56 +0000 Received: from mailgw02.mediatek.com ([216.200.240.185]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1tt0yc-0000000DbzL-1Vzk; Fri, 14 Mar 2025 09:05:11 +0000 X-UUID: 6c16c4ae00b311f0a1e849db4cc18d44-20250314 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=MIME-Version:Content-Transfer-Encoding:Content-Type:In-Reply-To:References:Message-ID:Date:Subject:CC:To:From; bh=AeXdRY6suBDzBVtJPXEJ1izyY1NjEbGM8aV2aKYtoNk=; b=oSGLqHa+gvxPVB0CnULj+9AOGfvrqInQP1xcm1pnUG0YXh79ogBTEqQ6uTeujzQ9m1YuYb1dgUpmHUJquC0SYPZ9zC7l1FlMkhp06+MLPnalZ4O2Om7KJpX7yLijyH1fSvNjZEY5aA/90GJBolK65kHGXP9O0GBu7XgeKRSm6jo=; X-CID-P-RULE: Release_Ham X-CID-O-INFO: VERSION:1.2.1,REQID:1d4da75d-3acc-47d9-84f9-08f1dae27830,IP:0,UR L:0,TC:0,Content:0,EDM:0,RT:0,SF:0,FILE:0,BULK:0,RULE:Release_Ham,ACTION:r elease,TS:0 X-CID-META: VersionHash:0ef645f,CLOUDID:2ca556c6-16da-468a-87f7-8ca8d6b3b9f7,B ulkID:nil,BulkQuantity:0,Recheck:0,SF:80|81|82|83|102,TC:nil,Content:0|52, EDM:-3,IP:nil,URL:0,File:nil,RT:nil,Bulk:nil,QS:nil,BEC:nil,COL:0,OSI:0,OS A:0,AV:0,LES:1,SPR:NO,DKR:0,DKP:0,BRR:0,BRE:0,ARC:0 X-CID-BVR: 1,FCT|NGT X-CID-BAS: 1,FCT|NGT,0,_ X-CID-FACTOR: TF_CID_SPAM_SNR X-UUID: 6c16c4ae00b311f0a1e849db4cc18d44-20250314 Received: from mtkmbs11n2.mediatek.inc [(172.21.101.187)] by mailgw02.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLSv1.2 ECDHE-RSA-AES256-GCM-SHA384 256/256) with ESMTP id 1110940188; Fri, 14 Mar 2025 02:05:06 -0700 Received: from mtkmbs10n2.mediatek.inc (172.21.101.183) by MTKMBS14N2.mediatek.inc (172.21.101.76) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1258.28; Fri, 14 Mar 2025 17:05:03 +0800 Received: from APC01-PSA-obe.outbound.protection.outlook.com (172.21.101.237) by mtkmbs10n2.mediatek.inc (172.21.101.183) with Microsoft SMTP Server id 15.2.1258.28 via Frontend Transport; Fri, 14 Mar 2025 17:05:03 +0800 ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=TW3hQYv2chDyOow32oAGJ0bLxKSYOHMlsZlyPmq7RFelM13LuYRdpwyLtRd64ZlZHKnvfLcrHZdJc15vj4egUH08buocL4YLElUVB4k0tjHzLIKOk2/iskU0NdW3AWG2Z0PWlc1iEYKlCqZX5FgcvZt4OAFppxpUGmOyqb/MmDbsXODqwq+qMlW7UOVQv1cgh7rnCqiNZc4NqCkruKdsqytvLuXP3GlYjSP7zUVptBThNdqsJ7kG8SQTZomiEo0cZwy7wMLoPbx/hOwN8LxXVE/tBJfSHhfpNikFdHb+Uuhm26kavTM4LZCyGGR7mQn2cxhCOTrt6ZLgw3dhdbat8g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=AeXdRY6suBDzBVtJPXEJ1izyY1NjEbGM8aV2aKYtoNk=; b=XxQS6OlAT9pu8xTSOkh8IJJNcdtP7UM1XEhEVwUf9dHOg/oDYy4VpLclLj+Sjt27+xgYxGgk3WSD7KcB9DqWwdtYWZLdKnoTHihMq1kcw1ymNualm1qKyI81CnKfBb8GnPGZDd4KJjg9LpzSJYH65+TuvGNCTVAOdWGV3nlhUvCH/vRghrU5ED1jJ+D1uPSkQYmrJwb1GXsfv8+DLrlnY6XomCtAw070OLJdqgrAb+RkqFaH77h1sglJ5R6uLFimBVRUOPSisy45sMkrkGqWYwbAQHY85TlHn5OT3mmZuvJ9FYRuma7AJ1hsZaWjztNqFFscaFl8cXVulq+4FgxogQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=mediatek.com; dmarc=pass action=none header.from=mediatek.com; dkim=pass header.d=mediatek.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=mediateko365.onmicrosoft.com; s=selector2-mediateko365-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=AeXdRY6suBDzBVtJPXEJ1izyY1NjEbGM8aV2aKYtoNk=; b=jTfXNL/9hYQN/6FXjv//cv4o72P4UoQUY/n05ft0BtZED90J1f9T2pyx4ehvWlRK4OfdThbFHopsdzsdvHcnMmhMJNVW8B5HcdkoCqb+Nl7JjB97/hF2O+mvzSNEURQlds3vyPvp6aLHD7ntTlyeg8cg27qQfpj1bmaLYjqfta8= Received: from SEZPR03MB6891.apcprd03.prod.outlook.com (2603:1096:101:a2::5) by TYSPR03MB8506.apcprd03.prod.outlook.com (2603:1096:405:5f::11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.8511.27; Fri, 14 Mar 2025 09:04:59 +0000 Received: from SEZPR03MB6891.apcprd03.prod.outlook.com ([fe80::579a:f8c2:b6e5:c2b9]) by SEZPR03MB6891.apcprd03.prod.outlook.com ([fe80::579a:f8c2:b6e5:c2b9%2]) with mapi id 15.20.8511.026; Fri, 14 Mar 2025 09:04:59 +0000 From: =?utf-8?b?THUgVGFuZyAo5rGk55KQKQ==?= To: =?utf-8?b?THUgVGFuZyAo5rGk55KQKQ==?= , "Jonathan Cameron" , Lars-Peter Clausen , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Dmitry Torokhov , Lee Jones , Matthias Brugger , "AngeloGioacchino Del Regno" , Sean Wang , Linus Walleij , "Liam Girdwood" , Mark Brown , Stephen Boyd , =?utf-8?b?Q2hlbiBaaG9uZyAo6ZKf6L6wKQ==?= , =?utf-8?b?U2VuIENodSAo5YKo5qOuKQ==?= CC: "linux-iio@vger.kernel.org" , "devicetree@vger.kernel.org" , "linux-kernel@vger.kernel.org" , "linux-input@vger.kernel.org" , "linux-arm-kernel@lists.infradead.org" , "linux-mediatek@lists.infradead.org" , "linux-gpio@vger.kernel.org" , Project_Global_Chrome_Upstream_Group Subject: =?utf-8?q?=E5=9B=9E=E5=A4=8D=3A_=5BPATCH_1/5=5D_pmic=3A_mediatek=3A?= =?utf-8?q?_Add_pmic_auxadc_driver?= Thread-Topic: [PATCH 1/5] pmic: mediatek: Add pmic auxadc driver Thread-Index: AQHblLaJXX9H/Syj+U6AeRYOMKgksbNyVtZQ Date: Fri, 14 Mar 2025 09:04:59 +0000 Message-ID: References: <20250314073307.25092-1-Lu.Tang@mediatek.com> <20250314073307.25092-2-Lu.Tang@mediatek.com> In-Reply-To: <20250314073307.25092-2-Lu.Tang@mediatek.com> Accept-Language: zh-CN, en-US Content-Language: zh-CN X-MS-Has-Attach: X-MS-TNEF-Correlator: x-dg-ref: PG1ldGE+PGF0IG5tPSJib2R5LnR4dCIgcD0iYzpcdXNlcnNcbXRrMjQ5NjdcYXBwZGF0YVxyb2FtaW5nXDA5ZDg0OWI2LTMyZDMtNGE0MC04NWVlLTZiODRiYTI5ZTM1Ylxtc2dzXG1zZy02NWM5NTBmNy0wMGIzLTExZjAtYTlmNy1kOGJiYzEyN2VkNjJcYW1lLXRlc3RcNjVjOTUwZjktMDBiMy0xMWYwLWE5ZjctZDhiYmMxMjdlZDYyYm9keS50eHQiIHN6PSIzOTU2MCIgdD0iMTMzODY0MTY2OTcwMDQ4ODUxIiBoPSJ4c3RVVFdQRHNtWEZZVUNHb2YwMEJ1ak5qb0U9IiBpZD0iIiBibD0iMCIgYm89IjEiLz48L21ldGE+ x-dg-rorf: true authentication-results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=mediatek.com; x-ms-publictraffictype: Email x-ms-traffictypediagnostic: SEZPR03MB6891:EE_|TYSPR03MB8506:EE_ x-ms-office365-filtering-correlation-id: c3659482-2d49-432a-2c6f-08dd62d74c18 x-ld-processed: a7687ede-7a6b-4ef6-bace-642f677fbe31,ExtAddr x-ms-exchange-senderadcheck: 1 x-ms-exchange-antispam-relay: 0 x-microsoft-antispam: BCL:0;ARA:13230040|7416014|376014|366016|1800799024|921020|38070700018; x-microsoft-antispam-message-info: =?utf-8?q?PVFcQJGNN3s7pur25fumvIG++cdbuUc?= =?utf-8?q?4/ESBM8tJXrozonghosOdiAAvjLXweBMiYFTf8OWa/w5q61mk8zq2eSueu60Fzib2?= =?utf-8?q?felhdD7rOXCJmAOjtCAekmQj9Q61UapB1U9UHbghEqfVGIvyoXpHPkfEwU4C670OE?= =?utf-8?q?B3XyIgD+QdT9z63+AWVWNhmuNLjiZlxOuRFX7VijsO8ivSqofKlIV7hEN04MrShuP?= =?utf-8?q?yFc1Xs8HsynishfKq50oSwv2hqTGbxXhm6VoM9EFcCNiq/Rpr2W08RGnd75bY1/Jh?= =?utf-8?q?wOKzaeRueft7XqotSK82d8X3z3pBU92v6wM71WFkM4xgtxPFxKYApPbsQpqEVvfM7?= =?utf-8?q?eXWeKu1RP1YqFMRK9/RGce80NE95KxRmRPNNKq2+p+Zm9J5jVDImXTxjDh0U2LZoL?= =?utf-8?q?D9gB3OkfSUgJ2vyTr1Ug5zJu4D5flETnmHQMjoqC14cRPBx9O8M6Y27IkbybG9Y4X?= =?utf-8?q?6LNipPxfGY8gC8N4Ptm6Soh4nhkvKuz+AYo+dfwxdKyqrvExLpZ8eOwlXnvWc1mKj?= =?utf-8?q?oF8S86jn7BdfNFOGH2JeMVseqayK11JtnrghUlaSSGn5l60XbmHV4u5iRBmR4elm0?= =?utf-8?q?RLUNcvTeaSjv2888vVPn4vkKaEIO7oMZ+yUam34Pc5fxHbRIS5LKy5q5bGdDmzfBF?= =?utf-8?q?6yTpoIv/73qkKBrOzgYCC2sy1pYvt4ii2G08TVgTfGsoHgLj/RR+Hv9ASKnpA7Haa?= =?utf-8?q?B/x4vcf2TKnspQkv9QdEzJSJt4taLVMUTD74clJ1+2a1+KtndeYUsEhYaC6u7xIJq?= =?utf-8?q?eBCDfIdGK0ZqyWchpRT3OPDJRg34cV6WNNR4ZqBT2gY/m6MJxqfnYlI2A4xE6iPB6?= =?utf-8?q?DZfKJ+5/3WUgntuc7LiVmWpAriPHZ2UtzQdaVaC2djduehfu+X5xYKc4B7qvK7jN+?= =?utf-8?q?W50XDdH2ZFUk2DtrSMCZu7NtVWJDKeDCBPaxtaoAa6pIq6mWVDjidFBSAbRCA6uqB?= =?utf-8?q?wexDC0bL6WTxh0TDwG2k8LHPtY6+HwKhiB/zWHNYZ6hlv8A8ZFNbg1/tKRO9mhHYd?= =?utf-8?q?W3E0K+bIr6nXj1S7uXgRf9whIDFcSjtrSDBfFpg44pKRIY1t+Z5CZNkyDLfs9PS+Y?= =?utf-8?q?kDIU66XaYE+CAjIlhD4vAEHTm/+mIBbujlPSfIR+y2wF6Gg1pmudYvaLlfYSBsRd0?= =?utf-8?q?lXGpXYwXk4sh/klah93NpXpdBEWN5HqMvi1Zz6bAa/B9ZXhhZfjoVfaDGch9PQ0OA?= =?utf-8?q?e7cU6R/b2rg3ZscA6yUwyAbGz+FIlC7p290DAKB5Dlq6DPgLhXMN+Jo+xLSFE9KvY?= =?utf-8?q?WJFGGwdLV6ioqwVDHjl/FwIVDuPcuZTRpcZ/3gXatVwD2xp0eJ3FuTJX86e/2eeEQ?= =?utf-8?q?5g9pAWltoaZbrZBia5LywujCa3enCfv4uX8HoQrNAnbDcOc5W9tW3SSmo1SdImgaM?= =?utf-8?q?LcMzZlRFMwiFQMY8kARZ6d7Mm2gu/TRSw=3D=3D?= x-forefront-antispam-report: CIP:255.255.255.255;CTRY:;LANG:zh-cn;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:SEZPR03MB6891.apcprd03.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230040)(7416014)(376014)(366016)(1800799024)(921020)(38070700018);DIR:OUT;SFP:1101; x-ms-exchange-antispam-messagedata-chunkcount: 1 x-ms-exchange-antispam-messagedata-0: =?utf-8?q?5nxYEWakxvjKFf1mVbnDFtf6DG1S?= =?utf-8?q?QGSon1JXtTZvOxgC/jD7L1RXt4d3bVVapQBdMZGLTXYw33ky0Y6JCzTAZNSuWD8vG?= =?utf-8?q?NNzkpXu1HzEDIhCPrWK8WO1dk6skX7bVN2ogkhcqg84ddGxEz9YPuVP3M5k1aoyYY?= =?utf-8?q?zOPDu3dvLubYz/WUI8BfS3tqpQXEo4y/3ag1l96ULos/V8EpOIyrmM2tQfdv2or4U?= =?utf-8?q?gUm6bwD68mqf6PPLlDo4igLLTPkqFlHKjEIxjBY+czUd1p6916vlZFLpiXOP/URVP?= =?utf-8?q?9EM5adnCh92kQdjK7xfFmQJ3QCuXFPLRm58T065q0SmQU0DcmhRS4UI5qKm7L4PAT?= =?utf-8?q?PK1yNVY0wHi4ckPNZ5Bg4jZXEpAtNvz25QHQR9uKLUWAra3yswHKpOGy1T9LQOpiK?= =?utf-8?q?xws6pAWB0HbW/f/ON5T68GzqNh/1RQze07oMFoVNhd8Mbgg7NXumlzKmNzJwMspwp?= =?utf-8?q?OXvKxe2ZnpD+J9/eoScF8CahDW1otimOVq7+WRBfkHrgwOk0rpyR68X0+RkAaC4Qn?= =?utf-8?q?iLNMKKT620JJPybh9872pSxA1qRvylKhz9zJAq3/9ui65u9v1Jz/kWYX0sZTiWja4?= =?utf-8?q?7+pV9lQHue4Wb7xYLbXGurAIpzaaQyCMXk4apz6Il5ZQhkAQ0cMUeZ0+lrc+JdcxA?= =?utf-8?q?o+Le0rW2tJIEgXqRZOIv5DFMHhdS35q5FTLHbzihqTH5x17mYl4erEzOC7TypL1Fo?= =?utf-8?q?4CSrgK1nNO/9NM6Xd2Ob6hw1wFdf+4h36D7Ml8w00UbmxgmZUhB+qBrlfido/++Z4?= =?utf-8?q?qNqatWY9QpHv7qJLJR9VxbKqbD/vUDsUD0Ss6e9En9cqgSwpjNZfmU92aDO5/MGY+?= =?utf-8?q?nmQ8KncR1czmCQZuWyauncETCdXnn+ILZCIrIsjhm15DJaOGi3TL8lhuodZfTmA6G?= =?utf-8?q?vXhxjxjMYg76goDMYSM/XqpjTtGQ8CYOvcgFrriJIdNgH0BkcNq2r2R0RxxasReZa?= =?utf-8?q?sJecjBk5zZ9zXsbgGYOSgI7jjZJG8Vz8RjkrOyo5I+i8NxpPQYjkRvO3ajUfFDtqJ?= =?utf-8?q?JtlBm6vBKcz7dTTN5kOiYLnVXQUBCPkGcbAEWbAH6B4ZAkmbRBicXgTY7sYk9nZuM?= =?utf-8?q?azvvk+wwQMA/p34TJCIB7YnnnaQ4/Bw9F+ZPRZRc307RWx8RCztrHcR0Mjl6qNIDr?= =?utf-8?q?10eJudwfdfq8VUqPFzMJaoeoH2I/8l9zNH1sQo2/Kfw2vDqo5FDfAF7pru2ijivYG?= =?utf-8?q?9GtT3A12/4h17ZnVaRpxTjYsXuR1JoYCBYq5Qe9MLDblKn0uDNA7T9IPep/eLupiZ?= =?utf-8?q?s37T3wmoMuvizTxP+MUVJ4jmfIR8Wq20IpsWTvpZqWbFlbd7E3sx3+RGTUbCHxF33?= =?utf-8?q?Fttk0UeyTcOxLwR3/caUpfn0aXQAMUvljpILhYER20SoDJRop+EztADgXvEj3ZRt4?= =?utf-8?q?JfdvwXQK4xRdHE6rHT5ID2LX3QoKK5PXHlvM0Ys6ZfxQ8MIYtopC4q6Y4iB2V3XHz?= =?utf-8?q?2Ty6GHCIB/Tsfg6ZgAOAa8RRvFDcydFfjwjzt/xbqMAl+OoiKPTnw6cc=3D?= MIME-Version: 1.0 X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-AuthSource: SEZPR03MB6891.apcprd03.prod.outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: c3659482-2d49-432a-2c6f-08dd62d74c18 X-MS-Exchange-CrossTenant-originalarrivaltime: 14 Mar 2025 09:04:59.0163 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: a7687ede-7a6b-4ef6-bace-642f677fbe31 X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: 8b9BGcAMxwEG/InOa5yKKTDBEI3Lmb+/MHGRoQgVgtwpvFd3brSAfKIpx+VIXphcLeW2vYJ4x49Yye4nFskWdw== X-MS-Exchange-Transport-CrossTenantHeadersStamped: TYSPR03MB8506 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250314_020510_417375_890012E6 X-CRM114-Status: GOOD ( 10.92 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Update email address -----邮件原件----- 发件人: Lu.Tang 发送时间: 2025年3月14日 15:32 收件人: Jonathan Cameron ; Lars-Peter Clausen ; Rob Herring ; Krzysztof Kozlowski ; Conor Dooley ; Dmitry Torokhov ; Lee Jones ; Matthias Brugger ; AngeloGioacchino Del Regno ; Sean Wang ; Linus Walleij ; Liam Girdwood ; Mark Brown ; Stephen Boyd ; Chen Zhong (钟辰) ; Sen Chu 抄送: linux-iio@vger.kernel.org; devicetree@vger.kernel.org; linux-kernel@vger.kernel.org; linux-input@vger.kernel.org; linux-arm-kernel@lists.infradead.org; linux-mediatek@lists.infradead.org; linux-gpio@vger.kernel.org; Project_Global_Chrome_Upstream_Group ; Lu Tang (汤璐) 主题: [PATCH 1/5] pmic: mediatek: Add pmic auxadc driver From: "Lu.Tang" Add pmic mt6363 and mt6373 auxadc driver Signed-off-by: Lu Tang --- drivers/iio/adc/Kconfig | 10 + drivers/iio/adc/Makefile | 1 + drivers/iio/adc/mtk-spmi-pmic-adc.c | 576 ++++++++++++++++++++++++++++ 3 files changed, 587 insertions(+) create mode 100644 drivers/iio/adc/mtk-spmi-pmic-adc.c diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig index 27413516216c..7c4b5f8f7209 100644 --- a/drivers/iio/adc/Kconfig +++ b/drivers/iio/adc/Kconfig @@ -1039,6 +1039,16 @@ config MEDIATEK_MT6577_AUXADC This driver can also be built as a module. If so, the module will be called mt6577_auxadc. +config MEDIATEK_SPMI_PMIC_ADC + tristate "MediaTek SPMI PMIC ADC Support" + depends on MFD_MTK_SPMI_PMIC + help + Say yes here to enable support for MediaTek SPMI PMIC ADC. + The driver supports multiple channels read. + + This driver can also be built as a module. If so, the module will be + called mtk-spmi-pmic-adc. + config MEN_Z188_ADC tristate "MEN 16z188 ADC IP Core support" depends on MCB diff --git a/drivers/iio/adc/Makefile b/drivers/iio/adc/Makefile index 9f26d5eca822..b3224abea040 100644 --- a/drivers/iio/adc/Makefile +++ b/drivers/iio/adc/Makefile @@ -91,6 +91,7 @@ obj-$(CONFIG_MEDIATEK_MT6359_AUXADC) += mt6359-auxadc.o obj-$(CONFIG_MEDIATEK_MT6360_ADC) += mt6360-adc.o obj-$(CONFIG_MEDIATEK_MT6370_ADC) += mt6370-adc.o obj-$(CONFIG_MEDIATEK_MT6577_AUXADC) += mt6577_auxadc.o +obj-$(CONFIG_MEDIATEK_SPMI_PMIC_ADC) += mtk-spmi-pmic-adc.o obj-$(CONFIG_MEN_Z188_ADC) += men_z188_adc.o obj-$(CONFIG_MESON_SARADC) += meson_saradc.o obj-$(CONFIG_MP2629_ADC) += mp2629_adc.o diff --git a/drivers/iio/adc/mtk-spmi-pmic-adc.c b/drivers/iio/adc/mtk-spmi-pmic-adc.c new file mode 100644 index 000000000000..61e062bc8cf5 --- /dev/null +++ b/drivers/iio/adc/mtk-spmi-pmic-adc.c @@ -0,0 +1,576 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2024 MediaTek Inc. + */ + +#include +#include +#include +#include +#include +#include #include + #include #include + #include #include +#include #include +#include #include +#include + +#include + +#define AUXADC_RDY_BIT BIT(15) + +#define AUXADC_DEF_R_RATIO 1 +#define AUXADC_DEF_AVG_NUM 32 + +#define AUXADC_AVG_TIME_US 10 +#define AUXADC_POLL_DELAY_US 100 +#define AUXADC_TIMEOUT_US 32000 +#define VOLT_FULL 1840 + +#define IMP_VOLT_FULL 18400 +#define IMIX_R_MIN_MOHM 100 +#define IMIX_R_CALI_CNT 2 + +#define EXT_THR_PURES_SHIFT 3 +#define EXT_THR_SEL_MASK 0x1F + +#define DT_CHANNEL_CONVERT(val) ((val) & 0xFF) +#define DT_PURES_CONVERT(val) (((val) & 0xFF00) >> 8) + +struct pmic_adc_device { + struct device *dev; + struct regmap *regmap; + struct mutex lock; + struct iio_chan_spec *iio_chans; + unsigned int nchannels; + const struct auxadc_info *info; + struct regulator *isink_load; + int imix_r; + int imp_curr; + int pre_uisoc; +}; + +static struct pmic_adc_device *imix_r_dev; + +/* + * @ch_name: HW channel name + * @res: ADC resolution + * @r_ratio: resistance ratio, represented by r_ratio[0] / r_ratio[1] + * @avg_num: sampling times of AUXADC measurements then average it + * @regs: request and data output registers for this channel + */ +struct auxadc_channels { + enum iio_chan_type type; + long info_mask; + /* AUXADC channel attribute */ + const char *ch_name; + unsigned char res; + unsigned char r_ratio[2]; + unsigned short avg_num; + const struct auxadc_regs *regs; +}; + +#define AUXADC_CHANNEL(_ch_name, _res) \ + [AUXADC_##_ch_name] = { \ + .type = IIO_VOLTAGE, \ + .info_mask = BIT(IIO_CHAN_INFO_RAW) | \ + BIT(IIO_CHAN_INFO_PROCESSED), \ + .ch_name = __stringify(_ch_name), \ + .res = _res, \ + } + +/* + * The array represents all possible AUXADC channels found + * in the supported PMICs. + */ +static struct auxadc_channels auxadc_chans[] = { + AUXADC_CHANNEL(BATADC, 15), + AUXADC_CHANNEL(VCDT, 12), + AUXADC_CHANNEL(BAT_TEMP, 12), + AUXADC_CHANNEL(CHIP_TEMP, 12), + AUXADC_CHANNEL(VCORE_TEMP, 12), + AUXADC_CHANNEL(VPROC_TEMP, 12), + AUXADC_CHANNEL(VGPU_TEMP, 12), + AUXADC_CHANNEL(ACCDET, 12), + AUXADC_CHANNEL(HPOFS_CAL, 15), + AUXADC_CHANNEL(VTREF, 12), + AUXADC_CHANNEL(VBIF, 12), + AUXADC_CHANNEL(IMP, 15), + [AUXADC_IMIX_R] = { + .type = IIO_RESISTANCE, + .info_mask = BIT(IIO_CHAN_INFO_RAW), + .ch_name = "IMIX_R", + }, + AUXADC_CHANNEL(VSYSSNS, 15), + AUXADC_CHANNEL(VIN1, 15), + AUXADC_CHANNEL(VIN2, 15), + AUXADC_CHANNEL(VIN3, 15), + AUXADC_CHANNEL(VIN4, 15), + AUXADC_CHANNEL(VIN5, 15), + AUXADC_CHANNEL(VIN6, 15), + AUXADC_CHANNEL(VIN7, 15), +}; + +struct auxadc_regs { + unsigned int enable_reg; + unsigned int enable_mask; + unsigned int ready_reg; + unsigned int ready_mask; + unsigned int value_reg; + unsigned int ext_thr_sel; + u8 src_sel; +}; + +#define AUXADC_REG(_ch_name, _chip, _enable_reg, _enable_mask, _value_reg) \ + [AUXADC_##_ch_name] = { \ + .enable_reg = _chip##_##_enable_reg, \ + .enable_mask = _enable_mask, \ + .ready_reg = _chip##_##_value_reg, \ + .ready_mask = AUXADC_RDY_BIT, \ + .value_reg = _chip##_##_value_reg, \ + } \ + +#define TIA_ADC_REG(_src_sel, _chip) \ + [AUXADC_VIN##_src_sel] = { \ + .enable_reg = _chip##_AUXADC_RQST1, \ + .enable_mask = BIT(4), \ + .ready_reg = _chip##_AUXADC_ADC_CH12_L, \ + .ready_mask = AUXADC_RDY_BIT, \ + .value_reg = _chip##_AUXADC_ADC_CH12_L, \ + .ext_thr_sel = _chip##_SDMADC_CON0, \ + .src_sel = _src_sel, \ + } \ + +static const struct auxadc_regs mt6363_auxadc_regs_tbl[] = { + AUXADC_REG(BATADC, MT6363, AUXADC_RQST0, BIT(0), AUXADC_ADC0_L), + AUXADC_REG(BAT_TEMP, MT6363, AUXADC_RQST0, BIT(3), AUXADC_ADC3_L), + AUXADC_REG(CHIP_TEMP, MT6363, AUXADC_RQST0, BIT(4), AUXADC_ADC4_L), + AUXADC_REG(VCORE_TEMP, MT6363, AUXADC_RQST3, BIT(0), AUXADC_ADC38_L), + AUXADC_REG(VPROC_TEMP, MT6363, AUXADC_RQST3, BIT(1), AUXADC_ADC39_L), + AUXADC_REG(VGPU_TEMP, MT6363, AUXADC_RQST3, BIT(2), AUXADC_ADC40_L), + AUXADC_REG(VTREF, MT6363, AUXADC_RQST1, BIT(3), AUXADC_ADC11_L), + [AUXADC_IMP] = { + .enable_reg = MT6363_AUXADC_IMP0, + .enable_mask = BIT(0), + .ready_reg = MT6363_AUXADC_IMP1, + .ready_mask = BIT(7), + .value_reg = MT6363_AUXADC_ADC42_L, + }, + AUXADC_REG(VSYSSNS, MT6363, AUXADC_RQST1, BIT(6), AUXADC_ADC_CH14_L), + TIA_ADC_REG(1, MT6363), + TIA_ADC_REG(2, MT6363), + TIA_ADC_REG(3, MT6363), + TIA_ADC_REG(4, MT6363), + TIA_ADC_REG(5, MT6363), + TIA_ADC_REG(6, MT6363), + TIA_ADC_REG(7, MT6363), +}; + +static const struct auxadc_regs mt6373_auxadc_regs_tbl[] = { + AUXADC_REG(CHIP_TEMP, MT6373, AUXADC_RQST0, BIT(4), AUXADC_ADC4_L), + AUXADC_REG(VCORE_TEMP, MT6373, AUXADC_RQST3, BIT(0), AUXADC_ADC38_L), + AUXADC_REG(VPROC_TEMP, MT6373, AUXADC_RQST3, BIT(1), AUXADC_ADC39_L), + AUXADC_REG(VGPU_TEMP, MT6373, AUXADC_RQST3, BIT(2), AUXADC_ADC40_L), + TIA_ADC_REG(1, MT6373), + TIA_ADC_REG(2, MT6373), + TIA_ADC_REG(3, MT6373), + TIA_ADC_REG(4, MT6373), + TIA_ADC_REG(5, MT6373), +}; + +struct auxadc_info { + const struct auxadc_regs *regs_tbl; +}; + +static const struct auxadc_info mt6363_info = { + .regs_tbl = mt6363_auxadc_regs_tbl, +}; + +static const struct auxadc_info mt6373_info = { + .regs_tbl = mt6373_auxadc_regs_tbl, +}; + +#define regmap_bulk_read_poll_timeout(map, addr, val, val_count, cond, +sleep_us, timeout_us) \ ({ \ + u64 __timeout_us = (timeout_us); \ + unsigned long __sleep_us = (sleep_us); \ + ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \ + int __ret; \ + might_sleep_if(__sleep_us); \ + for (;;) { \ + __ret = regmap_bulk_read((map), (addr), (u8 *) &(val), val_count); \ + if (__ret) \ + break; \ + if (cond) \ + break; \ + if ((__timeout_us) && \ + ktime_compare(ktime_get(), __timeout) > 0) { \ + __ret = regmap_bulk_read((map), (addr), (u8 *) &(val), val_count); \ + break; \ + } \ + if (__sleep_us) \ + usleep_range((__sleep_us >> 2) + 1, __sleep_us); \ + } \ + __ret ?: ((cond) ? 0 : -ETIMEDOUT); \ +}) + +/* + * @adc_dev: pointer to the struct pmic_adc_device + * @auxadc_chan: pointer to the struct auxadc_channels, it represents specific + auxadc channel + * @val: pointer to output value + */ +static int get_auxadc_out(struct pmic_adc_device *adc_dev, + int channel, int channel2, int *val) { + int ret; + u16 buf = 0; + const struct auxadc_channels *auxadc_chan = &auxadc_chans[channel]; + + if (!auxadc_chan->regs) + return -EINVAL; + + if (auxadc_chan->regs->ext_thr_sel) { + buf = (channel2 << EXT_THR_PURES_SHIFT) + | auxadc_chan->regs->src_sel; + ret = regmap_update_bits(adc_dev->regmap, + auxadc_chan->regs->ext_thr_sel, + EXT_THR_SEL_MASK, buf); + if (ret < 0) + return ret; + } + regmap_write(adc_dev->regmap, + auxadc_chan->regs->enable_reg, + auxadc_chan->regs->enable_mask); + usleep_range(auxadc_chan->avg_num * AUXADC_AVG_TIME_US, + (auxadc_chan->avg_num + 1) * AUXADC_AVG_TIME_US); + + ret = regmap_bulk_read_poll_timeout(adc_dev->regmap, + auxadc_chan->regs->value_reg, + buf, 2, + (buf & AUXADC_RDY_BIT), + AUXADC_POLL_DELAY_US, + AUXADC_TIMEOUT_US); + *val = buf & (BIT(auxadc_chan->res) - 1); + if (ret) + dev_err(adc_dev->dev, "%s ret error code:%d!\n", +auxadc_chan->ch_name, ret); + + /* set PURES to OPEN after measuring done */ + if (auxadc_chan->regs->ext_thr_sel) { + buf = (ADC_PURES_OPEN << EXT_THR_PURES_SHIFT) + | auxadc_chan->regs->src_sel; + ret = regmap_update_bits(adc_dev->regmap, + auxadc_chan->regs->ext_thr_sel, + EXT_THR_SEL_MASK, buf); + } + + return ret; +} + +static int gauge_get_imp_ibat(void) +{ + struct power_supply *psy; + union power_supply_propval prop; + int ret; + + psy = power_supply_get_by_name("mtk-gauge"); + if (!psy) + return 0; + + ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_CURRENT_NOW, &prop); + if (ret) + return ret; + + power_supply_put(psy); + return prop.intval; +} + +static int get_imp_out(struct pmic_adc_device *adc_dev, int *val) { + int ret; + unsigned int buf = 0; + const struct auxadc_channels *auxadc_chan = &auxadc_chans[AUXADC_IMP]; + + if (!auxadc_chan->regs) + return -EINVAL; + + regmap_write(adc_dev->regmap, + auxadc_chan->regs->enable_reg, + auxadc_chan->regs->enable_mask); + ret = regmap_read_poll_timeout(adc_dev->regmap, auxadc_chan->regs->ready_reg, + buf, buf & auxadc_chan->regs->ready_mask, + AUXADC_POLL_DELAY_US, + AUXADC_TIMEOUT_US); + if (ret) { + dev_err(adc_dev->dev, "%s %s ret error code:%d!\n", + __func__, auxadc_chan->ch_name, ret); + return ret; + } + + ret = regmap_bulk_read(adc_dev->regmap, auxadc_chan->regs->value_reg, (u8 *) &buf, 2); + if (ret) + return ret; + *val = buf & (BIT(auxadc_chan->res) - 1); + adc_dev->imp_curr = gauge_get_imp_ibat(); + + regmap_write(adc_dev->regmap, + auxadc_chan->regs->enable_reg, 0); + + return 0; +} + +static int pmic_adc_read_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int *val, int *val2, long mask) { + struct pmic_adc_device *adc_dev = iio_priv(indio_dev); + const struct auxadc_channels *auxadc_chan; + int auxadc_out = 0; + int ret = 0; + + mutex_lock(&adc_dev->lock); + switch (chan->channel) { + case AUXADC_IMP: + ret = get_imp_out(adc_dev, &auxadc_out); + break; + case AUXADC_IMIX_R: + auxadc_out = adc_dev->imix_r; + break; + default: + ret = get_auxadc_out(adc_dev, + chan->channel, chan->channel2, + &auxadc_out); + break; + } + mutex_unlock(&adc_dev->lock); + + if (ret && ret != -ETIMEDOUT) + return ret; + + switch (mask) { + case IIO_CHAN_INFO_PROCESSED: + auxadc_chan = &auxadc_chans[chan->channel]; + *val = auxadc_out * auxadc_chan->r_ratio[0] * VOLT_FULL; + *val = (*val / auxadc_chan->r_ratio[1]) >> auxadc_chan->res; + ret = IIO_VAL_INT; + break; + case IIO_CHAN_INFO_RAW: + *val = auxadc_out; + ret = IIO_VAL_INT; + break; + default: + return -EINVAL; + } + if (chan->channel == AUXADC_IMP) { + *val2 = adc_dev->imp_curr; + ret = IIO_VAL_INT_MULTIPLE; + } + + return ret; +} + +static int pmic_adc_fwnode_xlate(struct iio_dev *indio_dev, + const struct fwnode_reference_args *iiospec) { + int i; + int channel = DT_CHANNEL_CONVERT(iiospec->args[0]); + int channel2 = DT_PURES_CONVERT(iiospec->args[0]); + + for (i = 0; i < indio_dev->num_channels; i++) { + if (indio_dev->channels[i].channel == channel && + indio_dev->channels[i].channel2 == channel2) + return i; + } + + return -EINVAL; +} + +static const struct iio_info pmic_adc_info = { + .read_raw = &pmic_adc_read_raw, + .fwnode_xlate = &pmic_adc_fwnode_xlate, }; + +static int auxadc_init_imix_r(struct pmic_adc_device *adc_dev, + struct device_node *imix_r_node) { + unsigned int val = 0; + int ret; + + if (!adc_dev) + return -EINVAL; + + adc_dev->isink_load = devm_regulator_get_exclusive(adc_dev->dev, "isink_load"); + if (IS_ERR(adc_dev->isink_load)) { + dev_err(adc_dev->dev, "Failed to get isink_load regulator, ret=%d\n", + (int)PTR_ERR(adc_dev->isink_load)); + return PTR_ERR(adc_dev->isink_load); + } + + imix_r_dev = adc_dev; + if (imix_r_dev->imix_r) + return 0; + + ret = of_property_read_u32(imix_r_node, "val", &val); + if (ret) + dev_notice(imix_r_dev->dev, "no imix_r, ret=%d\n", ret); + imix_r_dev->imix_r = (int)val; + imix_r_dev->pre_uisoc = 101; + return 0; +} + +static int auxadc_get_data_from_dt(struct pmic_adc_device *adc_dev, + struct iio_chan_spec *iio_chan, + struct device_node *node) +{ + struct auxadc_channels *auxadc_chan; + unsigned int channel = 0; + unsigned int value = 0; + unsigned int val_arr[2] = {0}; + int ret; + + ret = of_property_read_u32(node, "channel", &channel); + if (ret) { + dev_err(adc_dev->dev, "invalid channel in node:%s\n", + node->name); + return ret; + } + if (channel > AUXADC_CHAN_MAX) { + dev_err(adc_dev->dev, "invalid channel number %d in node:%s\n", + channel, node->name); + return -EINVAL; + } + if (channel >= ARRAY_SIZE(auxadc_chans)) { + dev_err(adc_dev->dev, "channel number %d in node:%s not exists\n", + channel, node->name); + return -EINVAL; + } + iio_chan->channel = channel; + iio_chan->datasheet_name = auxadc_chans[channel].ch_name; + iio_chan->info_mask_separate = auxadc_chans[channel].info_mask; + iio_chan->type = auxadc_chans[channel].type; + iio_chan->extend_name = node->name; + ret = of_property_read_u32(node, "pures", &value); + if (!ret) + iio_chan->channel2 = value; + + if (channel == AUXADC_IMIX_R) + return auxadc_init_imix_r(adc_dev, node); + + auxadc_chan = &auxadc_chans[channel]; + auxadc_chan->regs = &adc_dev->info->regs_tbl[channel]; + + ret = of_property_read_u32_array(node, "resistance-ratio", val_arr, 2); + if (!ret) { + auxadc_chan->r_ratio[0] = val_arr[0]; + auxadc_chan->r_ratio[1] = val_arr[1]; + } else { + auxadc_chan->r_ratio[0] = AUXADC_DEF_R_RATIO; + auxadc_chan->r_ratio[1] = 1; + } + + ret = of_property_read_u32(node, "avg-num", &value); + if (!ret) + auxadc_chan->avg_num = value; + else + auxadc_chan->avg_num = AUXADC_DEF_AVG_NUM; + + return 0; +} + +static int auxadc_parse_dt(struct pmic_adc_device *adc_dev, + struct device_node *node) +{ + struct iio_chan_spec *iio_chan; + struct device_node *child; + unsigned int index = 0; + int ret; + + adc_dev->nchannels = of_get_available_child_count(node); + if (!adc_dev->nchannels) + return -EINVAL; + + adc_dev->iio_chans = devm_kcalloc(adc_dev->dev, adc_dev->nchannels, + sizeof(*adc_dev->iio_chans), GFP_KERNEL); + if (!adc_dev->iio_chans) + return -ENOMEM; + iio_chan = adc_dev->iio_chans; + + for_each_available_child_of_node(node, child) { + ret = auxadc_get_data_from_dt(adc_dev, iio_chan, child); + if (ret < 0) { + of_node_put(child); + return ret; + } + iio_chan->indexed = 1; + iio_chan->address = index++; + iio_chan++; + } + + return 0; +} + +static int pmic_adc_probe(struct platform_device *pdev) { + struct device_node *node = pdev->dev.of_node; + struct pmic_adc_device *adc_dev; + struct iio_dev *indio_dev; + int ret; + + indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*adc_dev)); + if (!indio_dev) + return -ENOMEM; + + adc_dev = iio_priv(indio_dev); + adc_dev->dev = &pdev->dev; + adc_dev->regmap = dev_get_regmap(pdev->dev.parent, NULL); + mutex_init(&adc_dev->lock); + adc_dev->info = of_device_get_match_data(&pdev->dev); + + ret = auxadc_parse_dt(adc_dev, node); + if (ret) { + dev_notice(&pdev->dev, "auxadc_parse_dt fail, ret=%d\n", ret); + return ret; + } + + indio_dev->dev.parent = &pdev->dev; + indio_dev->name = dev_name(&pdev->dev); + indio_dev->info = &pmic_adc_info; + indio_dev->modes = INDIO_DIRECT_MODE; + indio_dev->channels = adc_dev->iio_chans; + indio_dev->num_channels = adc_dev->nchannels; + + ret = devm_iio_device_register(&pdev->dev, indio_dev); + if (ret < 0) { + dev_notice(&pdev->dev, "failed to register iio device!\n"); + return ret; + } + + dev_dbg(&pdev->dev, "probe done\n"); + + return 0; +} + +static const struct of_device_id pmic_adc_of_match[] = { + { .compatible = "mediatek,mt6363-auxadc", .data = &mt6363_info, }, + { .compatible = "mediatek,mt6373-auxadc", .data = &mt6373_info, }, + { } +}; +MODULE_DEVICE_TABLE(of, pmic_adc_of_match); + +static struct platform_driver pmic_adc_driver = { + .driver = { + .name = "mtk-spmi-pmic-adc", + .of_match_table = pmic_adc_of_match, + }, + .probe = pmic_adc_probe, +}; +module_platform_driver(pmic_adc_driver); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Lu Tang "); +MODULE_DESCRIPTION("MediaTek SPMI PMIC ADC Driver"); -- 2.46.0