From mboxrd@z Thu Jan 1 00:00:00 1970 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 49531ECAAA1 for ; Mon, 31 Oct 2022 14:04:34 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=mmkKB9srP/ZBjYvfMrh3N5/D1dzI685IH+IBIBXKG4k=; b=Ac0IxoDjHCRJKD QEeDiBuV1AczDzHBm/FV60W82mQb/5hOIf8S6OPS+nxVGvm4U4FNI5CE5IDDn5qI5F5mUKD9WKISP YpIrpEHPyUP9cgoWzFigpWPpcVwKzpQ4FSqcZJsVQQYvErYbfaB5gte2VFI0NgO2bnYhEZ7qVqV/Z fGxjZoDF/EF+BQ5+ngZHN8TydJHS2UKbuejmJDsWAvG0bMlCKL/tG6xvcYnUsjx9jdoH7bkZu7/JZ NArKiyVsax+ZhN4Am9njsgv6B/+Jl8dl7yv5aIza5OsQA8VqMw8+3JMvxW6r5ZgwGyl6RyOefNwIr xl1SqWWlANqV7c213KzA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1opVOq-00CCBS-2i; Mon, 31 Oct 2022 14:04:24 +0000 Received: from ams.source.kernel.org ([145.40.68.75]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1opVOn-00CCAp-S3 for linux-rockchip@lists.infradead.org; Mon, 31 Oct 2022 14:04:23 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id 19EA0B817C1; Mon, 31 Oct 2022 14:04:20 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 85DB9C433D6; Mon, 31 Oct 2022 14:04:15 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1667225058; bh=WT/oM6yMv3E1f0+FE6QN2kC+ntZ+v8NTJw+qVfDbUnE=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=QcychxhkkcHBfy/LJKCP01W9g4E9lDNEwrWVJGUidFeVCNDxpqTv97LyHMQq3w5V0 liq8R8Nvk1s1xeHjo+Eya/579axzTGJLk3EeHWg80wZUVbm0p6RcpOYmnRIS3ZH2HT nkNhTIosP+VKEDSOgJtG+tZEMUoPwYHebt3Z2ipF+jhyBkr0phzhLUqFJ5VXSUvH/y AtmvcsEpxmL9esO7sv5rAhwSXxtt3Ihg4ghmUpdjaqw2b0sHjm/8VQBaS+gD47w5dq yU59Xm9/uxrJZTp7vtxEhW62JXXYNy3HL5tF4KlpAbIlU8hCND33sw59He7M3DMtPG FXqNdcfEqnUOQ== Date: Mon, 31 Oct 2022 14:04:12 +0000 From: Lee Jones To: Sebastian Reichel Cc: Heiko Stuebner , Rob Herring , Krzysztof Kozlowski , Michael Turquette , Stephen Boyd , Linus Walleij , Mark Brown , Liam Girdwood , Alexandre Belloni , Alessandro Zummo , linux-rockchip@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, kernel@collabora.com Subject: Re: [PATCHv4 09/13] mfd: rk8xx: add rk806 support Message-ID: References: <20221020204251.108565-1-sebastian.reichel@collabora.com> <20221020204251.108565-10-sebastian.reichel@collabora.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20221020204251.108565-10-sebastian.reichel@collabora.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20221031_070422_221707_E9D98292 X-CRM114-Status: GOOD ( 27.78 ) X-BeenThere: linux-rockchip@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Upstream kernel work for Rockchip platforms List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+linux-rockchip=archiver.kernel.org@lists.infradead.org T24gVGh1LCAyMCBPY3QgMjAyMiwgU2ViYXN0aWFuIFJlaWNoZWwgd3JvdGU6Cgo+IEFkZCBzdXBw b3J0IGZvciBTUEkgY29ubmVjdGVkIHJrODA2LCB3aGljaCBpcyB1c2VkIGJ5IHRoZSBSSzM1ODgK PiBldmFsdWF0aW9uIGJvYXJkcy4gVGhlIFBNSUMgaXMgYWR2ZXJ0aXNlZCB0byBzdXBwb3J0IEky QyBhbmQgU1BJLAo+IGJ1dCB0aGUgZXZhbHVhdGlvbiBib2FyZHMgYWxsIHVzZSBTUEkuIFRodXMg b25seSBTUEkgc3VwcG9ydCBpcwo+IGFkZGVkIGhlcmUuCj4gCj4gU2lnbmVkLW9mZi1ieTogU2Vi YXN0aWFuIFJlaWNoZWwgPHNlYmFzdGlhbi5yZWljaGVsQGNvbGxhYm9yYS5jb20+Cj4gLS0tCgpD aGFuZ2UgbG9nPyAgV2hhdCBoYXBwZW5lZCBvdmVyIHRoZSBwcmV2aW91cyA0IGl0ZXJhdGlvbnM/ Cgo+ICBkcml2ZXJzL21mZC9LY29uZmlnICAgICAgIHwgIDE0ICsrCj4gIGRyaXZlcnMvbWZkL01h a2VmaWxlICAgICAgfCAgIDEgKwo+ICBkcml2ZXJzL21mZC9yazh4eC1jb3JlLmMgIHwgIDY3ICsr KysrKy0KPiAgZHJpdmVycy9tZmQvcms4eHgtc3BpLmMgICB8IDExNSArKysrKysrKysrKwo+ICBp bmNsdWRlL2xpbnV4L21mZC9yazgwOC5oIHwgNDA5ICsrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrCj4gIDUgZmlsZXMgY2hhbmdlZCwgNjA0IGluc2VydGlvbnMoKyksIDIgZGVs ZXRpb25zKC0pCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21mZC9yazh4eC1zcGkuYwoK Wy4uLl0KCj4gQEAgLTAsMCArMSwxMTUgQEAKPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IEdQTC0yLjAKPiArLyoKPiArICogUm9ja2NoaXAgUks4MDYgQ29yZSAoU1BJKSBkcml2ZXIKPiAr ICoKPiArICogQ29weXJpZ2h0IChjKSAyMDIxIFJvY2tjaGlwIEVsZWN0cm9uaWNzIENvLiwgTHRk Lgo+ICsgKgo+ICsgKiBBdXRob3I6IFh1IFNoZW5nZmVpIDx4c2ZAcm9jay1jaGlwcy5jb20+Cj4g KyAqLwo+ICsKPiArI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgo+ICsjaW5jbHVkZSA8bGlu dXgvbWZkL2NvcmUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L21mZC9yazgwOC5oPgo+ICsjaW5jbHVk ZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KPiArI2luY2x1 ZGUgPGxpbnV4L3NwaS9zcGkuaD4KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcmVnbWFwX3Jh bmdlIHJrODA2X3ZvbGF0aWxlX3Jhbmdlc1tdID0gewo+ICsJcmVnbWFwX3JlZ19yYW5nZShSSzgw Nl9QT1dFUl9FTjAsIFJLODA2X1BPV0VSX0VONSksCj4gKwlyZWdtYXBfcmVnX3JhbmdlKFJLODA2 X0RWU19TVEFSVF9DVFJMLCBSSzgwNl9JTlRfTVNLMSksCj4gK307Cj4gKwo+ICtzdGF0aWMgY29u c3Qgc3RydWN0IHJlZ21hcF9hY2Nlc3NfdGFibGUgcms4MDZfdm9sYXRpbGVfdGFibGUgPSB7Cj4g KwkueWVzX3JhbmdlcyA9IHJrODA2X3ZvbGF0aWxlX3JhbmdlcywKPiArCS5uX3llc19yYW5nZXMg PSBBUlJBWV9TSVpFKHJrODA2X3ZvbGF0aWxlX3JhbmdlcyksCj4gK307Cj4gKwo+ICtzdGF0aWMg Y29uc3Qgc3RydWN0IHJlZ21hcF9jb25maWcgcms4MDZfcmVnbWFwX2NvbmZpZ19zcGkgPSB7Cj4g KwkucmVnX2JpdHMgPSA4LAo+ICsJLnZhbF9iaXRzID0gOCwKPiArCS5jYWNoZV90eXBlID0gUkVH Q0FDSEVfUkJUUkVFLAo+ICsJLnZvbGF0aWxlX3RhYmxlID0gJnJrODA2X3ZvbGF0aWxlX3RhYmxl LAo+ICt9Owo+ICsKPiArc3RhdGljIGludCByazgwNl9zcGlfYnVzX3dyaXRlKHZvaWQgKmNvbnRl eHQsIGNvbnN0IHZvaWQgKnZkYXRhLCBzaXplX3QgY291bnQpCj4gK3sKPiArCXN0cnVjdCBkZXZp Y2UgKmRldiA9IGNvbnRleHQ7Cj4gKwlzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpID0gdG9fc3BpX2Rl dmljZShkZXYpOwo+ICsJY29uc3QgY2hhciAqZGF0YSA9IHZkYXRhOwo+ICsJY2hhciBidWZmZXJb NF0gPSB7IDAgfTsKPiArCj4gKwkvKiBpbXBsZW1lbnRhdGlvbiBjdXJyZW50bHkgb25seSBzdXBw b3J0cyBzaW5nbGUgd3JpdGUgKi8KPiArCWlmIChjb3VudCAhPSAyKQo+ICsJCXJldHVybiAtRUlO VkFMOwoKSXMgdGhpcyBhIEgvVyBsaW1pdGF0aW9uPwoKPiArCWJ1ZmZlclswXSA9IFJLODA2X0NN RF9XUklURSB8IChjb3VudCAtIDIpOwo+ICsJYnVmZmVyWzFdID0gZGF0YVswXTsgLyogcmVnaXN0 ZXIgYWRkcmVzcyAqLwoKWW91IGNhbiBtYWtlIHRoZXNlIGNsZWFyZXIgYnkgZGVmaW5pbmcgdGhl IGluZGV4ZXMuCgo+ICsJYnVmZmVyWzJdID0gUks4MDZfUkVHX0g7Cj4gKwlidWZmZXJbM10gPSBk YXRhWzFdOyAvKiByZWdpc3RlciB2YWx1ZSAqLwo+ICsKPiArCXJldHVybiBzcGlfd3JpdGUoc3Bp LCAmYnVmZmVyLCBzaXplb2YoYnVmZmVyKSk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgcms4MDZf c3BpX2J1c19yZWFkKHZvaWQgKmNvbnRleHQsIGNvbnN0IHZvaWQgKnZyZWcsIHNpemVfdCByZWdf c2l6ZSwKPiArCQkJICAgICAgdm9pZCAqdmFsLCBzaXplX3QgdmFsX3NpemUpCj4gK3sKPiArCXN0 cnVjdCBkZXZpY2UgKmRldiA9IGNvbnRleHQ7Cj4gKwlzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpID0g dG9fc3BpX2RldmljZShkZXYpOwo+ICsJY29uc3QgY2hhciAqcmVnID0gdnJlZzsKPiArCWNoYXIg dHhidWZbM10gPSB7IDAgfTsKPiArCj4gKwlpZiAocmVnX3NpemUgIT0gc2l6ZW9mKGNoYXIpIHx8 IHZhbF9zaXplIDwgMSkKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwl0eGJ1ZlswXSA9IFJL ODA2X0NNRF9SRUFEIHwgKHZhbF9zaXplIC0gMSk7Cj4gKwl0eGJ1ZlsxXSA9ICpyZWc7Cj4gKwl0 eGJ1ZlsyXSA9IFJLODA2X1JFR19IOwo+ICsKPiArCXJldHVybiBzcGlfd3JpdGVfdGhlbl9yZWFk KHNwaSwgdHhidWYsIHNpemVvZih0eGJ1ZiksIHZhbCwgdmFsX3NpemUpOwo+ICt9Cj4gKwo+ICtz dGF0aWMgY29uc3Qgc3RydWN0IHJlZ21hcF9idXMgcms4MDZfcmVnbWFwX2J1c19zcGkgPSB7Cj4g Kwkud3JpdGUgPSByazgwNl9zcGlfYnVzX3dyaXRlLAo+ICsJLnJlYWQgPSByazgwNl9zcGlfYnVz X3JlYWQsCj4gKwkucmVnX2Zvcm1hdF9lbmRpYW5fZGVmYXVsdCA9IFJFR01BUF9FTkRJQU5fTkFU SVZFLAo+ICsJLnZhbF9mb3JtYXRfZW5kaWFuX2RlZmF1bHQgPSBSRUdNQVBfRU5ESUFOX05BVElW RSwKPiArfTsKPiArCj4gK3N0YXRpYyBpbnQgcms4eHhfc3BpX3Byb2JlKHN0cnVjdCBzcGlfZGV2 aWNlICpzcGkpCj4gK3sKPiArCXN0cnVjdCByZWdtYXAgKnJlZ21hcDsKPiArCj4gKwlyZWdtYXAg PSBkZXZtX3JlZ21hcF9pbml0KCZzcGktPmRldiwgJnJrODA2X3JlZ21hcF9idXNfc3BpLAo+ICsJ CQkJICAmc3BpLT5kZXYsICZyazgwNl9yZWdtYXBfY29uZmlnX3NwaSk7Cj4gKwlpZiAoSVNfRVJS KHJlZ21hcCkpCj4gKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoJnNwaS0+ZGV2LCBQVFJfRVJSKHJl Z21hcCksCj4gKwkJCQkgICAgICJGYWlsZWQgdG8gaW5pdGlhbGl6ZSByZWdpc3RlciBtYXBcbiIp Owo+ICsKPiArCXJldHVybiByazh4eF9wcm9iZSgmc3BpLT5kZXYsIFJLODA2X0lELCBzcGktPmly cSwgcmVnbWFwKTsKPiArfQo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQg cms4eHhfc3BpX29mX21hdGNoW10gPSB7Cj4gKwl7IC5jb21wYXRpYmxlID0gInJvY2tjaGlwLHJr ODA2IiwgfSwKPiArCXsgfQo+ICt9Owo+ICtNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCByazh4eF9z cGlfb2ZfbWF0Y2gpOwo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBzcGlfZGV2aWNlX2lkIHJr OHh4X3NwaV9pZF90YWJsZVtdID0gewo+ICsJeyAicms4MDYiLCAwIH0sCj4gKwl7IH0KPiArfTsK PiArTU9EVUxFX0RFVklDRV9UQUJMRShzcGksIHJrOHh4X3NwaV9pZF90YWJsZSk7CgpBcmUgdGhl c2Ugc2ltcGxlIHRhYmxlcyByZXF1aXJlZCBmb3IgU1BJPwoKSXMgdGhlcmUgYW55dGhpbmcgYWtp biB0byBJMkMncyBwcm9iZV9uZXcgdGhhdCB5b3UgY291bGQgdXNlPwoKPiArc3RhdGljIHN0cnVj dCBzcGlfZHJpdmVyIHJrOHh4X3NwaV9kcml2ZXIgPSB7Cj4gKwkuZHJpdmVyCQk9IHsKPiArCQku bmFtZQk9ICJyazh4eC1zcGkiLAo+ICsJCS5vZl9tYXRjaF90YWJsZSA9IHJrOHh4X3NwaV9vZl9t YXRjaCwKPiArCX0sCj4gKwkucHJvYmUJCT0gcms4eHhfc3BpX3Byb2JlLAo+ICsJLmlkX3RhYmxl CT0gcms4eHhfc3BpX2lkX3RhYmxlLAo+ICt9Owo+ICttb2R1bGVfc3BpX2RyaXZlcihyazh4eF9z cGlfZHJpdmVyKTsKPiArCj4gK01PRFVMRV9BVVRIT1IoIlh1IFNoZW5nZmVpIDx4c2ZAcm9jay1j aGlwcy5jb20+Iik7Cj4gK01PRFVMRV9ERVNDUklQVElPTigiUks4eHggU1BJIFBNSUMgZHJpdmVy Iik7Cj4gK01PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9s aW51eC9tZmQvcms4MDguaCBiL2luY2x1ZGUvbGludXgvbWZkL3JrODA4LmgKPiBpbmRleCA0MTgz NDI3YTgwZmUuLjc4ZTE2N2E5MjQ4MyAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L21mZC9y azgwOC5oCj4gKysrIGIvaW5jbHVkZS9saW51eC9tZmQvcms4MDguaAoKWy4uLl0KCi0tIApMZWUg Sm9uZXMgW+adjueQvOaWr10KCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCkxpbnV4LXJvY2tjaGlwIG1haWxpbmcgbGlzdApMaW51eC1yb2NrY2hpcEBsaXN0 cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGlu Zm8vbGludXgtcm9ja2NoaXAK From mboxrd@z Thu Jan 1 00:00:00 1970 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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9B981ECAAA1 for ; Mon, 31 Oct 2022 14:04:25 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230045AbiJaOEX (ORCPT ); Mon, 31 Oct 2022 10:04:23 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53722 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230492AbiJaOEX (ORCPT ); Mon, 31 Oct 2022 10:04:23 -0400 Received: from ams.source.kernel.org (ams.source.kernel.org [145.40.68.75]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 93C9310573; Mon, 31 Oct 2022 07:04:21 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id 1F864B817C2; Mon, 31 Oct 2022 14:04:20 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 85DB9C433D6; Mon, 31 Oct 2022 14:04:15 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1667225058; bh=WT/oM6yMv3E1f0+FE6QN2kC+ntZ+v8NTJw+qVfDbUnE=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=QcychxhkkcHBfy/LJKCP01W9g4E9lDNEwrWVJGUidFeVCNDxpqTv97LyHMQq3w5V0 liq8R8Nvk1s1xeHjo+Eya/579axzTGJLk3EeHWg80wZUVbm0p6RcpOYmnRIS3ZH2HT nkNhTIosP+VKEDSOgJtG+tZEMUoPwYHebt3Z2ipF+jhyBkr0phzhLUqFJ5VXSUvH/y AtmvcsEpxmL9esO7sv5rAhwSXxtt3Ihg4ghmUpdjaqw2b0sHjm/8VQBaS+gD47w5dq yU59Xm9/uxrJZTp7vtxEhW62JXXYNy3HL5tF4KlpAbIlU8hCND33sw59He7M3DMtPG FXqNdcfEqnUOQ== Date: Mon, 31 Oct 2022 14:04:12 +0000 From: Lee Jones To: Sebastian Reichel Cc: Heiko Stuebner , Rob Herring , Krzysztof Kozlowski , Michael Turquette , Stephen Boyd , Linus Walleij , Mark Brown , Liam Girdwood , Alexandre Belloni , Alessandro Zummo , linux-rockchip@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, kernel@collabora.com Subject: Re: [PATCHv4 09/13] mfd: rk8xx: add rk806 support Message-ID: References: <20221020204251.108565-1-sebastian.reichel@collabora.com> <20221020204251.108565-10-sebastian.reichel@collabora.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20221020204251.108565-10-sebastian.reichel@collabora.com> Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org On Thu, 20 Oct 2022, Sebastian Reichel wrote: > Add support for SPI connected rk806, which is used by the RK3588 > evaluation boards. The PMIC is advertised to support I2C and SPI, > but the evaluation boards all use SPI. Thus only SPI support is > added here. > > Signed-off-by: Sebastian Reichel > --- Change log? What happened over the previous 4 iterations? > drivers/mfd/Kconfig | 14 ++ > drivers/mfd/Makefile | 1 + > drivers/mfd/rk8xx-core.c | 67 ++++++- > drivers/mfd/rk8xx-spi.c | 115 +++++++++++ > include/linux/mfd/rk808.h | 409 ++++++++++++++++++++++++++++++++++++++ > 5 files changed, 604 insertions(+), 2 deletions(-) > create mode 100644 drivers/mfd/rk8xx-spi.c [...] > @@ -0,0 +1,115 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Rockchip RK806 Core (SPI) driver > + * > + * Copyright (c) 2021 Rockchip Electronics Co., Ltd. > + * > + * Author: Xu Shengfei > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +static const struct regmap_range rk806_volatile_ranges[] = { > + regmap_reg_range(RK806_POWER_EN0, RK806_POWER_EN5), > + regmap_reg_range(RK806_DVS_START_CTRL, RK806_INT_MSK1), > +}; > + > +static const struct regmap_access_table rk806_volatile_table = { > + .yes_ranges = rk806_volatile_ranges, > + .n_yes_ranges = ARRAY_SIZE(rk806_volatile_ranges), > +}; > + > +static const struct regmap_config rk806_regmap_config_spi = { > + .reg_bits = 8, > + .val_bits = 8, > + .cache_type = REGCACHE_RBTREE, > + .volatile_table = &rk806_volatile_table, > +}; > + > +static int rk806_spi_bus_write(void *context, const void *vdata, size_t count) > +{ > + struct device *dev = context; > + struct spi_device *spi = to_spi_device(dev); > + const char *data = vdata; > + char buffer[4] = { 0 }; > + > + /* implementation currently only supports single write */ > + if (count != 2) > + return -EINVAL; Is this a H/W limitation? > + buffer[0] = RK806_CMD_WRITE | (count - 2); > + buffer[1] = data[0]; /* register address */ You can make these clearer by defining the indexes. > + buffer[2] = RK806_REG_H; > + buffer[3] = data[1]; /* register value */ > + > + return spi_write(spi, &buffer, sizeof(buffer)); > +} > + > +static int rk806_spi_bus_read(void *context, const void *vreg, size_t reg_size, > + void *val, size_t val_size) > +{ > + struct device *dev = context; > + struct spi_device *spi = to_spi_device(dev); > + const char *reg = vreg; > + char txbuf[3] = { 0 }; > + > + if (reg_size != sizeof(char) || val_size < 1) > + return -EINVAL; > + > + txbuf[0] = RK806_CMD_READ | (val_size - 1); > + txbuf[1] = *reg; > + txbuf[2] = RK806_REG_H; > + > + return spi_write_then_read(spi, txbuf, sizeof(txbuf), val, val_size); > +} > + > +static const struct regmap_bus rk806_regmap_bus_spi = { > + .write = rk806_spi_bus_write, > + .read = rk806_spi_bus_read, > + .reg_format_endian_default = REGMAP_ENDIAN_NATIVE, > + .val_format_endian_default = REGMAP_ENDIAN_NATIVE, > +}; > + > +static int rk8xx_spi_probe(struct spi_device *spi) > +{ > + struct regmap *regmap; > + > + regmap = devm_regmap_init(&spi->dev, &rk806_regmap_bus_spi, > + &spi->dev, &rk806_regmap_config_spi); > + if (IS_ERR(regmap)) > + return dev_err_probe(&spi->dev, PTR_ERR(regmap), > + "Failed to initialize register map\n"); > + > + return rk8xx_probe(&spi->dev, RK806_ID, spi->irq, regmap); > +} > + > +static const struct of_device_id rk8xx_spi_of_match[] = { > + { .compatible = "rockchip,rk806", }, > + { } > +}; > +MODULE_DEVICE_TABLE(of, rk8xx_spi_of_match); > + > +static const struct spi_device_id rk8xx_spi_id_table[] = { > + { "rk806", 0 }, > + { } > +}; > +MODULE_DEVICE_TABLE(spi, rk8xx_spi_id_table); Are these simple tables required for SPI? Is there anything akin to I2C's probe_new that you could use? > +static struct spi_driver rk8xx_spi_driver = { > + .driver = { > + .name = "rk8xx-spi", > + .of_match_table = rk8xx_spi_of_match, > + }, > + .probe = rk8xx_spi_probe, > + .id_table = rk8xx_spi_id_table, > +}; > +module_spi_driver(rk8xx_spi_driver); > + > +MODULE_AUTHOR("Xu Shengfei "); > +MODULE_DESCRIPTION("RK8xx SPI PMIC driver"); > +MODULE_LICENSE("GPL v2"); > diff --git a/include/linux/mfd/rk808.h b/include/linux/mfd/rk808.h > index 4183427a80fe..78e167a92483 100644 > --- a/include/linux/mfd/rk808.h > +++ b/include/linux/mfd/rk808.h [...] -- Lee Jones [李琼斯]