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 4A19FC5321D for ; Mon, 26 Aug 2024 09:50:40 +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=WYlckQwVR9OoTy9ORFa9JUpX+Bb6X6WHnvM4TNUwuSg=; b=PU1Qr5J2vsn2Kf n7X68r9dUWJNLSaKtr/SHTvLI010BoatMV3s5Q4dYncgUXMRgPBN5Ls4x/+1Ve1W8PYUbzDbXLIB6 U5U7flE2I/WA99NqW98C+6KJnquCUZXLS8Xtq/ydN6U6TTqZqI1FuV+PE9J2iSu3fqmjaFcsPekeo 2e4SD29UsKm9eFoJttf7DG1GivC3TVf9GSSbyKY9F4vPEAAEOldjpCtLjnNi5nhqkRB3cRdCf2YCW CBZp4wYRmOFAnsQBrrVFrj07BYR2Wa81sGMgjsnDPooKodEBH7WC0VLvBWmovNP4IHGXTBEwMOUP5 Uk7zukTvl4yqf08jaJcA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1siWMr-00000006lmG-3Lc2; Mon, 26 Aug 2024 09:50:33 +0000 Received: from relay1-d.mail.gandi.net ([2001:4b98:dc4:8::221]) by bombadil.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1siWHs-00000006kAz-2eVI for linux-amlogic@lists.infradead.org; Mon, 26 Aug 2024 09:45:27 +0000 Received: by mail.gandi.net (Postfix) with ESMTPSA id 3FE78240005; Mon, 26 Aug 2024 09:45:20 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1724665520; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Cm7pTcmop+B8Zg+nbYiYBBLjbkVuEU6sN7SIS3TJIAQ=; b=jIr7X3ZsNbaWgwn/2FZVB/qWjVAkCNv627YiNOV9EtsFgJ8rbmPK83G6X0KIU1OgmkTBur QOGMoEcVVWOc3XLyLft0yKn1L6Xzrs9ZBtfLa9MCBT4MZ/N3+cNM/U4TUAzwXxYr/6v6+R wOYm6+42QY4/T1cVe9afQNPxJr1L32STAD0qG2QvZCEzfOAzajcaK9U3PX8wson2RfEtKj +DtDByZNvPGY1KibzpEPyiinuXufj2Af/DkPLu2QPDiNKcVe75KY88EAqM+eWezH968g7v 4FN/h768YMHUa+PUsP3MwlTSeqCJXw3wlrfDfiZJfwElYnd/jLyDKyixJ/KKjg== Date: Mon, 26 Aug 2024 11:45:19 +0200 From: Alexandre Belloni To: xianwei.zhao@amlogic.com Cc: Yiting Deng , Rob Herring , Krzysztof Kozlowski , Conor Dooley , linux-amlogic@lists.infradead.org, linux-rtc@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH 2/3] rtc: support for the Amlogic on-chip RTC Message-ID: <2024082609451907fd19e2@mail.local> References: <20240823-rtc-v1-0-6f70381da283@amlogic.com> <20240823-rtc-v1-2-6f70381da283@amlogic.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20240823-rtc-v1-2-6f70381da283@amlogic.com> X-GND-Sasl: alexandre.belloni@bootlin.com X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240826_024525_431446_38DDF8F3 X-CRM114-Status: GOOD ( 28.77 ) X-BeenThere: linux-amlogic@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-amlogic" Errors-To: linux-amlogic-bounces+linux-amlogic=archiver.kernel.org@lists.infradead.org T24gMjMvMDgvMjAyNCAxNzoxOTo0NSswODAwLCBYaWFud2VpIFpoYW8gdmlhIEI0IFJlbGF5IHdy b3RlOgo+IEZyb206IFlpdGluZyBEZW5nIDx5aXRpbmcuZGVuZ0BhbWxvZ2ljLmNvbT4KPiAKPiBT dXBwb3J0IGZvciB0aGUgb24tY2hpcCBSVEMgZm91bmQgaW4gc29tZSBvZiBBbWxvZ2ljJ3MgU29D cyBzdWNoIGFzIHRoZQo+IEExMTNMMiBhbmQgQTExM1gyLgo+IAo+IFNpZ25lZC1vZmYtYnk6IFlp dGluZyBEZW5nIDx5aXRpbmcuZGVuZ0BhbWxvZ2ljLmNvbT4KPiBTaWduZWQtb2ZmLWJ5OiBYaWFu d2VpIFpoYW8gPHhpYW53ZWkuemhhb0BhbWxvZ2ljLmNvbT4KPiAtLS0KPiAgZHJpdmVycy9ydGMv S2NvbmZpZyAgICAgICB8ICAxMiArCj4gIGRyaXZlcnMvcnRjL01ha2VmaWxlICAgICAgfCAgIDEg Kwo+ICBkcml2ZXJzL3J0Yy9ydGMtYW1sb2dpYy5jIHwgNTg5ICsrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysKCkFzIHBvaW50ZWQgb3V0LCB0aGlzIGlzIHRoZSB0 aGlyZCBhbWxvZ2ljIGRyaXZlciBzbyB0aGUgbmFtZSBvZiB0aGUgZmlsZQptdXN0IGJlIG1vcmUg c3BlY2lmaWMuCgo+ICtzdGF0aWMgdm9pZCBhbWxfc2V0X3RpbWUoc3RydWN0IGFtbF9ydGNfZGF0 YSAqcnRjLCB1MzIgdGltZV9zZWMpCgpJcyBpbmRpcmVjdGlvbiBuZWNlc3NhcnksIHRoaXMgZnVu Y3Rpb24gaXMgdXNlZCBvbmx5IG9uY2UKCj4gK3sKPiArCWlmIChydGMtPmNvbmZpZy0+Z3JheV9z dG9yZWQpCj4gKwkJdGltZV9zZWMgPSBiaW5hcnlfdG9fZ3JheSh0aW1lX3NlYyk7Cj4gKwlyZWdt YXBfd3JpdGUocnRjLT5tYXAsIFJUQ19DT1VOVEVSX1JFRywgdGltZV9zZWMpOwo+ICt9Cj4gKwo+ ICtzdGF0aWMgdTMyIGFtbF9yZWFkX3RpbWUoc3RydWN0IGFtbF9ydGNfZGF0YSAqcnRjKQpEaXR0 bwoKPiArewo+ICsJdTMyIHRpbWVfc2VjOwo+ICsKPiArCXJlZ21hcF9yZWFkKHJ0Yy0+bWFwLCBS VENfUkVBTF9USU1FLCAmdGltZV9zZWMpOwo+ICsJaWYgKHJ0Yy0+Y29uZmlnLT5ncmF5X3N0b3Jl ZCkKPiArCQl0aW1lX3NlYyA9IGdyYXlfdG9fYmluYXJ5KHRpbWVfc2VjKTsKPiArCXJldHVybiB0 aW1lX3NlYzsKPiArfQo+ICsKPiArc3RhdGljIHUzMiBhbWxfcmVhZF9hbGFybShzdHJ1Y3QgYW1s X3J0Y19kYXRhICpydGMpCkRpdHRvCgo+ICt7Cj4gKwl1MzIgYWxhcm1fc2VjOwo+ICsKPiArCXJl Z21hcF9yZWFkKHJ0Yy0+bWFwLCBSVENfQUxBUk0wX1JFRywgJmFsYXJtX3NlYyk7Cj4gKwlpZiAo cnRjLT5jb25maWctPmdyYXlfc3RvcmVkKQo+ICsJCWFsYXJtX3NlYyA9IGdyYXlfdG9fYmluYXJ5 KGFsYXJtX3NlYyk7Cj4gKwlyZXR1cm4gYWxhcm1fc2VjOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9p ZCBhbWxfc2V0X2FsYXJtKHN0cnVjdCBhbWxfcnRjX2RhdGEgKnJ0YywgdTMyIGFsYXJtX3NlYykK RGl0dG8KCj4gK3sKPiArCWlmIChydGMtPmNvbmZpZy0+Z3JheV9zdG9yZWQpCj4gKwkJYWxhcm1f c2VjID0gYmluYXJ5X3RvX2dyYXkoYWxhcm1fc2VjKTsKPiArCXJlZ21hcF93cml0ZShydGMtPm1h cCwgUlRDX0FMQVJNMF9SRUcsIGFsYXJtX3NlYyk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgYW1s X3J0Y19zZXRfYWxhcm0oc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcnRjX3drYWxybSAqYWxh cm0pCj4gK3sKPiArCXN0cnVjdCBhbWxfcnRjX2RhdGEgKnJ0YyA9IGRldl9nZXRfZHJ2ZGF0YShk ZXYpOwo+ICsJdGltZTY0X3QgYWxhcm1fc2VjOwo+ICsKPiArCWlmIChhbGFybS0+ZW5hYmxlZCkg ewoKV2h5IGFyZW4ndCB5b3Ugc2V0dGluZyB0aGUgYWxhcm0gd2hlbiBpdCBpcyBub3QgZW5hYmxl ZD8KCj4gKwkJcmVnbWFwX3VwZGF0ZV9iaXRzKHJ0Yy0+bWFwLCBSVENfQ1RSTCwKPiArCQkJCSAg IFJUQ19BTFJNMF9FTiwgUlRDX0FMUk0wX0VOKTsKPiArCQlyZWdtYXBfdXBkYXRlX2JpdHMocnRj LT5tYXAsIFJUQ19JTlRfTUFTSywKPiArCQkJCSAgIFJUQ19BTFJNMF9JUlFfTVNLLCAwKTsKPiAr Cj4gKwkJYWxhcm1fc2VjID0gcnRjX3RtX3RvX3RpbWU2NCgmYWxhcm0tPnRpbWUpOwo+ICsJCWlm IChhbGFybV9zZWMgPiBVMzJfTUFYKSB7CgpUaGlzIGlzIG5ldmVyIGdvaW5nIHRvIGhhcHBlbiwg dGhlIHRlc3QgYW5kIGVycm9yIG1lc3NhZ2UgYXJlIG5vdApuZWNlc3NhcnkuCgo+ICsJCQlkZXZf ZXJyKGRldiwgImFsYXJtIHZhbHVlIGludmFsaWQhXG4iKTsKPiArCQkJcmV0dXJuIC1FSU5WQUw7 Cj4gKwkJfQo+ICsJCWFtbF9zZXRfYWxhcm0ocnRjLCBhbGFybV9zZWMpOwo+ICsJfQo+ICsJZGV2 X2RiZyhkZXYsICIlczogYWxhcm0tPmVuYWJsZWQ9JWQgYWxhcm1fc2V0PSVsbGRzXG4iLCBfX2Z1 bmNfXywKPiArCQlhbGFybS0+ZW5hYmxlZCwgYWxhcm1fc2VjKTsKPiArCj4gKwlyZXR1cm4gMDsK PiArfQo+ICsKPiArc3RhdGljIGludCBhbWxfcnRjX3JlYWRfYWxhcm0oc3RydWN0IGRldmljZSAq ZGV2LCBzdHJ1Y3QgcnRjX3drYWxybSAqYWxhcm0pCj4gK3sKPiArCXN0cnVjdCBhbWxfcnRjX2Rh dGEgKnJ0YyA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsJdTMyIGFsYXJtX3NlYzsKPiArCXUz MiByZWdfdmFsOwo+ICsJaW50IGFsYXJtX2VuYWJsZSwgYWxhcm1fbWFzazsKPiArCj4gKwlhbGFy bV9zZWMgPSBhbWxfcmVhZF9hbGFybShydGMpOwo+ICsJcnRjX3RpbWU2NF90b190bShhbGFybV9z ZWMsICZhbGFybS0+dGltZSk7Cj4gKwo+ICsJcmVnbWFwX3JlYWQocnRjLT5tYXAsIFJUQ19DVFJM LCAmcmVnX3ZhbCk7Cj4gKwlhbGFybV9lbmFibGUgPSBGSUVMRF9HRVQoUlRDX0FMUk0wX0VOLCBy ZWdfdmFsKTsKPiArCj4gKwlyZWdtYXBfcmVhZChydGMtPm1hcCwgUlRDX0lOVF9NQVNLLCAmcmVn X3ZhbCk7Cj4gKwlhbGFybV9tYXNrID0gRklFTERfR0VUKFJUQ19BTFJNMF9JUlFfTVNLLCByZWdf dmFsKTsKPiArCj4gKwlhbGFybS0+ZW5hYmxlZCA9IChhbGFybV9lbmFibGUgJiYgIWFsYXJtX21h c2spID8gMSA6IDA7Cj4gKwlkZXZfZGJnKGRldiwgIiVzOiBhbGFybS0+ZW5hYmxlZD0lZCBhbGFy bT0ldXNcbiIsIF9fZnVuY19fLAo+ICsJCWFsYXJtLT5lbmFibGVkLCBhbGFybV9zZWMpOwo+ICsK PiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaXJxcmV0dXJuX3QgYW1sX3J0Y19oYW5k bGVyKGludCBpcnEsIHZvaWQgKmRhdGEpCj4gK3sKPiArCXN0cnVjdCBhbWxfcnRjX2RhdGEgKnJ0 YyA9IChzdHJ1Y3QgYW1sX3J0Y19kYXRhICopZGF0YTsKPiArCj4gKwlyZWdtYXBfd3JpdGUocnRj LT5tYXAsIFJUQ19BTEFSTTBfUkVHLCAwKTsKPiArCXJlZ21hcF91cGRhdGVfYml0cyhydGMtPm1h cCwgUlRDX0lOVF9DTFIsCj4gKwkJCSAgIFJUQ19BTFJNMF9JUlFfU1RBVFVTLCBSVENfQUxSTTBf SVJRX1NUQVRVUyk7CgpBcmUgeW91IHN1cmUgcmVnbWFwX3VwZGF0ZV9iaXRzIGlzIG5lY2Vzc2Fy eSBoZXJlPwoKPiArCj4gKwlydGNfdXBkYXRlX2lycShydGMtPnJ0Y19kZXYsIDEsIFJUQ19BRiB8 IFJUQ19JUlFGKTsKPiArCj4gKwlyZXR1cm4gSVJRX0hBTkRMRUQ7Cj4gK30KPiArCgoKPiArc3Rh dGljIGludCBhbWxfcnRjX2FkanVzdF9zZWMoc3RydWN0IGRldmljZSAqZGV2LCB1MzIgbWF0Y2hf Y291bnRlciwKPiArCQkJICAgICAgaW50IG9wcywgaW50IGVuYWJsZSkKPiArewo+ICsJc3RydWN0 IGFtbF9ydGNfZGF0YSAqcnRjID0gZGV2X2dldF9kcnZkYXRhKGRldi0+cGFyZW50KTsKPiArCXUz MiByZWdfdmFsOwo+ICsKPiArCWlmICghRklFTERfRklUKFJUQ19NQVRDSF9DT1VOVEVSLCBtYXRj aF9jb3VudGVyKSkgewo+ICsJCXByX2VycigiJXM6IGludmFsaWQgbWF0Y2hfY291bnRlclxuIiwg X19mdW5jX18pOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsKPiArCXJlZ192YWwgPSBG SUVMRF9QUkVQKFJUQ19TRUNfQURKVVNUX0NUUkwsIG9wcykKPiArCQkgIHwgRklFTERfUFJFUChS VENfTUFUQ0hfQ09VTlRFUiwgbWF0Y2hfY291bnRlcikKPiArCQkgIHwgRklFTERfUFJFUChSVENf QURKX1ZBTElELCBlbmFibGUpOwo+ICsJLyogU2V0IHNlY19hZGp1c3RfY3RybCwgbWF0Y2hfY291 bnRlciBhbmQgVmFsaWQgYWRqdXN0ICovCj4gKwlyZWdtYXBfd3JpdGUocnRjLT5tYXAsIFJUQ19T RUNfQURKVVNUX1JFRywgcmVnX3ZhbCk7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0 YXRpYyBpbnQgYW1sX3J0Y19zZXRfY2FsaWJyYXRpb24oc3RydWN0IGRldmljZSAqZGV2LCB1MzIg Y2FsaWJyYXRpb24pCj4gK3sKPiArCWludCBjYWxfb3BzLCBlbmFibGUsIG1hdGNoX2NvdW50ZXI7 Cj4gKwlpbnQgcmV0Owo+ICsKPiArCW1hdGNoX2NvdW50ZXIgPSBGSUVMRF9HRVQoUlRDX01BVENI X0NPVU5URVIsIGNhbGlicmF0aW9uKTsKPiArCWNhbF9vcHMgPSBGSUVMRF9HRVQoUlRDX1NFQ19B REpVU1RfQ1RSTCwgY2FsaWJyYXRpb24pOwo+ICsJZW5hYmxlID0gRklFTERfR0VUKFJUQ19BREpf VkFMSUQsIGNhbGlicmF0aW9uKTsKPiArCj4gKwlyZXQgPSBhbWxfcnRjX2FkanVzdF9zZWMoZGV2 LCBtYXRjaF9jb3VudGVyLCBjYWxfb3BzLCBlbmFibGUpOwo+ICsJZGV2X2RiZyhkZXYsICIlczog U3VjY2VzcyB0byBzdG9yZSBSVEMgY2FsaWJyYXRpb24gYXR0cmlidXRlXG4iLAo+ICsJCV9fZnVu Y19fKTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGFtbF9ydGNf Z2V0X2NhbGlicmF0aW9uKHN0cnVjdCBkZXZpY2UgKmRldiwgdTMyICpjYWxpYnJhdGlvbikKPiAr ewo+ICsJc3RydWN0IGFtbF9ydGNfZGF0YSAqcnRjID0gZGV2X2dldF9kcnZkYXRhKGRldi0+cGFy ZW50KTsKPiArCXUzMiByZWdfdmFsOwo+ICsKPiArCXJlZ21hcF9yZWFkKHJ0Yy0+bWFwLCBSVENf U0VDX0FESlVTVF9SRUcsICZyZWdfdmFsKTsKPiArCSpjYWxpYnJhdGlvbiA9IEZJRUxEX0dFVChS VENfU0VDX0FESlVTVF9DVFJMIHwgUlRDX01BVENIX0NPVU5URVIsIHJlZ192YWwpOwo+ICsJLyog QklUIGlzIG9ubHkgVUwgZGVmaW5lZO+8jGFuZCBHRU5NQVNLIGhhcyBubyB0eXBlLCBpdHMnIGRv bm90IHVzZWQgdG9nZXRoZXIgKi8KPiArCSpjYWxpYnJhdGlvbiB8PSBGSUVMRF9QUkVQKFJUQ19B REpfVkFMSUQsIEZJRUxEX0dFVChSVENfQURKX1ZBTElELCByZWdfdmFsKSk7Cj4gKwo+ICsJcmV0 dXJuIDA7Cj4gK30KPiArCj4gKy8qKgo+ICsgKiBUaGUgY2FsaWJyYXRpb24gdmFsdWUgdHJhbnNm ZXJyZWQgZnJvbSBidWYgdGFrZXMgYml0WzE4OjBdIHRvIHJlcHJlc2VudAo+ICsgKiBtYXRjaF9j b3VudGVyLCB3aGlsZSB0YWtlcyBiaXRbMjA6MTldIHRvIHJlcHJlc2VudCBzZWNfYWRqdXN0X2N0 cmwsIGJpdFsyM10KPiArICogdG8gcmVwcmVzZW50IGFkal92YWxpZC4gZW5hYmxlL2Rpc2FibGUg c2VjX2FkanVzdF9jdHJsIGFuZCBtYXRjaF9jb3VudGVyLgo+ICsgKiBAYnVmOiBTZXBhcmF0ZSBi dWYgdG8gbWF0Y2hfY291bnRlciwgc2VjX2FkanVzdF9jdHJsIGFuZCBhZGpfdmFsaWQKPiArICoJ IG1hdGNoX2NvdW50ZXI6IGJpdFsxODowXSwgdmFsdWUgaXMgMCB+IDB4N2ZmZgo+ICsgKgkgc2Vj X2FkanVzdF9jdHJsOiBiaXRbMjA6MTldLCB2YWx1ZSBpcyAwIH4gMi4gMyB0byBpbnNlcnQgYSBz ZWNvbmQgb25jZSBldmVyeQo+ICsgKgkgbWF0Y2hfY291bnRlcisxIHNlY29uZHMsIDIgdG8gc3dh bGxvdyBhIHNlY29uZCBvbmNlIGV2ZXJ5IG1hdGNoX2NvdW50ZXIrMSBzZWNvbmRzCj4gKyAqCSAw IG9yIDEgdG8gbm8gYWRqdXN0bWVudAo+ICsgKgkgYWRqX3ZhbGlkOiBiaXRbMjNdLCB2YWx1ZSBp cyAwIG9yIDEsIDAgdG8gZGlzYWJsZSBzZWNfYWRqdXN0X2N0cmwgYW5kCj4gKyAqCSBtYXRjaF9j b3VudGVyLCBhbmQgMSB0byBlbmFibGUgdGhlbS4KPiArICovCj4gK3N0YXRpYyBzc2l6ZV90IHJ0 Y19jYWxpYnJhdGlvbl9zdG9yZShzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gKwkJCQkgICAgIHN0cnVj dCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAo+ICsJCQkJICAgICBjb25zdCBjaGFyICpidWYsIHNp emVfdCBjb3VudCkKPiArewo+ICsJaW50IHJldHZhbDsKPiArCWludCBjYWxpYnJhdGlvbiA9IDA7 Cj4gKwo+ICsJaWYgKHNzY2FuZihidWYsICIgJWkgIiwgJmNhbGlicmF0aW9uKSAhPSAxKSB7Cj4g KwkJZGV2X2VycihkZXYsICJGYWlsZWQgdG8gc3RvcmUgUlRDIGNhbGlicmF0aW9uIGF0dHJpYnV0 ZVxuIik7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwlyZXR2YWwgPSBhbWxfcnRjX3Nl dF9jYWxpYnJhdGlvbihkZXYsIGNhbGlicmF0aW9uKTsKPiArCj4gKwlyZXR1cm4gcmV0dmFsID8g cmV0dmFsIDogY291bnQ7Cj4gK30KPiArCj4gK3N0YXRpYyBzc2l6ZV90IHJ0Y19jYWxpYnJhdGlv bl9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwKPiArCQkJCSAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJp YnV0ZSAqYXR0ciwgY2hhciAqYnVmKQo+ICt7Cj4gKwlpbnQgIHJldHZhbCA9IDA7Cj4gKwl1MzIg IGNhbGlicmF0aW9uID0gMDsKPiArCj4gKwlyZXR2YWwgPSBhbWxfcnRjX2dldF9jYWxpYnJhdGlv bihkZXYsICZjYWxpYnJhdGlvbik7Cj4gKwlpZiAocmV0dmFsIDwgMCkgewo+ICsJCWRldl9lcnIo ZGV2LCAiRmFpbGVkIHRvIHJlYWQgUlRDIGNhbGlicmF0aW9uIGF0dHJpYnV0ZVxuIik7Cj4gKwkJ c3ByaW50ZihidWYsICIwXG4iKTsKPiArCQlyZXR1cm4gcmV0dmFsOwo+ICsJfQo+ICsKPiArCXJl dHVybiBzcHJpbnRmKGJ1ZiwgIjB4JXhcbiIsIGNhbGlicmF0aW9uKTsKPiArfQo+ICtzdGF0aWMg REVWSUNFX0FUVFJfUlcocnRjX2NhbGlicmF0aW9uKTsKPiArCj4gK3N0YXRpYyBpbnQgcnRjX3Nl dF9kaXYyNTZfYWRqdXN0KHN0cnVjdCBkZXZpY2UgKmRldiwgdTMyICp2YWx1ZSkKPiArewo+ICsJ c3RydWN0IGFtbF9ydGNfZGF0YSAqcnRjID0gZGV2X2dldF9kcnZkYXRhKGRldi0+cGFyZW50KTsK PiArCXUzMiBkaXYyNTZfYWRqOwo+ICsKPiArCWRpdjI1Nl9hZGogPSBGSUVMRF9QUkVQKFJUQ19E SVYyNTZfQURKX0RTUiB8IFJUQ19ESVYyNTZfQURKX1ZBTCwgKnZhbHVlKTsKPiArCS8qCj4gKwkg KiBBT19SVENfU0VDX0FESlVTVF9SRUcgYml0IDI0IGluc2VydC9yZW1vdmUoMS8wKSBhIGRpdjI1 NiBjeWNsZSwKPiArCSAqIGJpdCAyNSB2YWxpZC9pbnZhbGlkKDEvMCkgZGl2MjU2X2Fkal92YWwK PiArCSAqLwo+ICsJcmVnbWFwX3dyaXRlX2JpdHMocnRjLT5tYXAsIFJUQ19TRUNfQURKVVNUX1JF RywKPiArCQkJICBSVENfRElWMjU2X0FESl9EU1IgfCBSVENfRElWMjU2X0FESl9WQUwsIGRpdjI1 Nl9hZGopOwo+ICsJLyogcnRjIG5lZWQgYWJvdXQgMzBtcyB0byBhZGp1c3QgaXRzIHRpbWUgYWZ0 ZXIgd3JpdHRlbiAqLwo+ICsJbWRlbGF5KDMwKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsK PiArc3RhdGljIGludCBydGNfZ2V0X2RpdjI1Nl9hZGp1c3Qoc3RydWN0IGRldmljZSAqZGV2LCB1 MzIgKnZhbHVlKQo+ICt7Cj4gKwlzdHJ1Y3QgYW1sX3J0Y19kYXRhICpydGMgPSBkZXZfZ2V0X2Ry dmRhdGEoZGV2LT5wYXJlbnQpOwo+ICsJdTMyIHJlZ192YWw7Cj4gKwo+ICsJcmVnbWFwX3JlYWQo cnRjLT5tYXAsIFJUQ19TRUNfQURKVVNUX1JFRywgJnJlZ192YWwpOwo+ICsJKnZhbHVlID0gRklF TERfR0VUKFJUQ19ESVYyNTZfQURKX0RTUiB8IFJUQ19ESVYyNTZfQURKX1ZBTCwgcmVnX3ZhbCk7 Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gKy8qKgo+ICsgKiBkaXYyNTYgYWRqdXN0IGZ1 bmN0aW9uIGlzIGNvbnRyb2xsZWQgdXNpbmcgYml0WzI0XSBhbmQgYml0WzI1XS4KPiArICogdHJh bnNmZXJyZWQgYnVmIHRha2VzIGJpdFswXSB0byByZXByZXNlbnQgZGl2MjU2IGFkaiB2YWwsIGJp dFsxXQo+ICsgKiB0byByZXByZXNlbnQgZGl2MjU2IGFkaiBlbmFibGUvZGlzYWJsZS4gZGl2MjU2 IGN5Y2xlIG1lYW5zIHRoYXQgYWRqdXN0Cj4gKyAqIDEvMzI3NjgvMjU2IG9uY2UgYnkgd3JpdHRl biBvbmNlLCBpdCdzIHZhbCBpcyBlcXVhbCB0byAxLzEyOHMKPiArICogQGJ1ZjogMzogZW5hYmxl IGRpdjI1NiBhZGp1c3QgYW5kIGluc2VydCBhIGRpdjI1NiBjeWNsZQo+ICsgKgkgMjogZW5hYmxl IGRpdjI1NiBhZGp1c3QgYW5kIHJlbW92ZSBhIGRpdjI1NiBjeWNsZQo+ICsgKgkgMSBvciAwOiBk aXNhYmxlIGRpdjI1NiBhZGp1c3QKPiArICovCj4gK3N0YXRpYyBzc2l6ZV90IHJ0Y19kaXYyNTZf YWRqdXN0X3N0b3JlKHN0cnVjdCBkZXZpY2UgKmRldiwKPiArCQkJCSAgICAgICBzdHJ1Y3QgZGV2 aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPiArCQkJCSAgICAgICBjb25zdCBjaGFyICpidWYsIHNpemVf dCBjb3VudCkKPiArewo+ICsJaW50IHJldHZhbDsKPiArCXUzMiB2YWx1ZSA9IDA7Cj4gKwo+ICsJ aWYgKHNzY2FuZihidWYsICIgJWkgIiwgJnZhbHVlKSAhPSAxKSB7Cj4gKwkJZGV2X2VycihkZXYs ICJGYWlsZWQgdG8gc3RvcmUgUlRDIGRpdjI1NiBhZGp1c3QgYXR0cmlidXRlXG4iKTsKPiArCQly ZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCXJldHZhbCA9IHJ0Y19zZXRfZGl2MjU2X2FkanVzdChk ZXYsICZ2YWx1ZSk7Cj4gKwo+ICsJcmV0dXJuIHJldHZhbCA/IHJldHZhbCA6IGNvdW50Owo+ICt9 Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCBydGNfZGl2MjU2X2FkanVzdF9zaG93KHN0cnVjdCBkZXZp Y2UgKmRldiwKPiArCQkJCSAgICAgIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFy ICpidWYpCj4gK3sKPiArCWludCByZXR2YWwgPSAwOwo+ICsJdTMyIHZhbHVlID0gMDsKPiArCj4g KwlyZXR2YWwgPSBydGNfZ2V0X2RpdjI1Nl9hZGp1c3QoZGV2LCAmdmFsdWUpOwo+ICsJaWYgKHJl dHZhbCA8IDApIHsKPiArCQlkZXZfZXJyKGRldiwgIkZhaWxlZCB0byByZWFkIFJUQyBkaXYyNTYg YWRqdXN0IGF0dHJpYnV0ZVxuIik7Cj4gKwkJc3ByaW50ZihidWYsICIwXG4iKTsKPiArCQlyZXR1 cm4gcmV0dmFsOwo+ICsJfQo+ICsKPiArCXJldHVybiBzcHJpbnRmKGJ1ZiwgIjB4JXhcbiIsIHZh bHVlKTsKPiArfQo+ICtzdGF0aWMgREVWSUNFX0FUVFJfUlcocnRjX2RpdjI1Nl9hZGp1c3QpOwo+ ICsKPiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKmFtbF9ydGNfYXR0cnNbXSA9IHsKPiArCSZk ZXZfYXR0cl9ydGNfY2FsaWJyYXRpb24uYXR0ciwKPiArCSZkZXZfYXR0cl9ydGNfZGl2MjU2X2Fk anVzdC5hdHRyLAo+ICsJTlVMTCwKPiArfTsKPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYXR0 cmlidXRlX2dyb3VwIGFtbF9ydGNfc3lzZnNfZmlsZXMgPSB7Cj4gKwkuYXR0cnMJPSBhbWxfcnRj X2F0dHJzLAo+ICt9Owo+ICsKCllvdSBtdXN0IHVzZSB0aGUgc3RhbmRhcmQgUlRDIEFQSSB0byBo YW5kbGUgY2FsaWJyYXRpb24sIHNlZQoucmVhZF9vZmZzZXQgYW5kIC5zZXRfb2Zmc2V0Cgo+ICtz dGF0aWMgdm9pZCBhbWxfcnRjX2luaXQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgYW1sX3J0 Y19kYXRhICpydGMpCj4gK3sKPiArCXUzMiByZWdfdmFsOwo+ICsJdTMyIHJ0Y19lbmFibGU7Cj4g Kwo+ICsJcmVnbWFwX3JlYWQocnRjLT5tYXAsIFJUQ19DVFJMLCAmcmVnX3ZhbCk7Cj4gKwlydGNf ZW5hYmxlID0gRklFTERfR0VUKFJUQ19FTkFCTEUsIHJlZ192YWwpOwo+ICsJaWYgKCFydGNfZW5h YmxlKSB7Cj4gKwkJaWYgKGNsa19nZXRfcmF0ZShydGMtPnNjbGspID09IE9TQ18yNE0pIHsKPiAr CQkJLyogc2VsZWN0IDI0TSBvc2NpbGxhdG9yICovCj4gKwkJCXJlZ21hcF91cGRhdGVfYml0cyhy dGMtPm1hcCwgUlRDX0NUUkwsIFJUQ19PU0NfU0VMLCBSVENfT1NDX1NFTCk7Cj4gKwo+ICsJCQkv Kgo+ICsJCQkgKiBTZXQgUlRDIG9zY2lsbGF0b3IgdG8gZnJlcV9vdXQgdG8gZnJlcV9pbi8oKE4w Kk0wK04xKk0xKS8oTTArTTEpKQo+ICsJCQkgKiBFbmFibGUgY2xvY2tfaW4gZ2F0ZSBvZiBvc2Np bGxhdG9yIDI0TUh6Cj4gKwkJCSAqIFNldCBOMCB0byA3MzMsIE4xIHRvIDczMgo+ICsJCQkgKi8K PiArCQkJcmVnX3ZhbCA9IEZJRUxEX1BSRVAoUlRDX09TQ0lOX0lOX0VOLCAxKQo+ICsJCQkJICB8 IEZJRUxEX1BSRVAoUlRDX09TQ0lOX09VVF9DRkcsIDEpCj4gKwkJCQkgIHwgRklFTERfUFJFUChS VENfT1NDSU5fT1VUX04wTTAsIFJUQ19PU0NJTl9PVVRfMzJLX04wKQo+ICsJCQkJICB8IEZJRUxE X1BSRVAoUlRDX09TQ0lOX09VVF9OMU0xLCBSVENfT1NDSU5fT1VUXzMyS19OMSk7Cj4gKwkJCXJl Z21hcF93cml0ZV9iaXRzKHJ0Yy0+bWFwLCBSVENfT1NDSU5fQ1RSTDAsIFJUQ19PU0NJTl9JTl9F Tgo+ICsJCQkJCSAgfCBSVENfT1NDSU5fT1VUX0NGRyB8IFJUQ19PU0NJTl9PVVRfTjBNMAo+ICsJ CQkJCSAgfCBSVENfT1NDSU5fT1VUX04xTTEsIHJlZ192YWwpOwo+ICsKPiArCQkJLyogU2V0IE0w IHRvIDIsIE0xIHRvIDMsIHNvIGZyZXFfb3V0ID0gMzI3NjggSHoqLwo+ICsJCQlyZWdfdmFsID0g RklFTERfUFJFUChSVENfT1NDSU5fT1VUX04wTTAsIFJUQ19PU0NJTl9PVVRfMzJLX00wKQo+ICsJ CQkJICB8IEZJRUxEX1BSRVAoUlRDX09TQ0lOX09VVF9OMU0xLCBSVENfT1NDSU5fT1VUXzMyS19N MSk7Cj4gKwkJCXJlZ21hcF93cml0ZV9iaXRzKHJ0Yy0+bWFwLCBSVENfT1NDSU5fQ1RSTDEsIFJU Q19PU0NJTl9PVVRfTjBNMAo+ICsJCQkJCSAgfCBSVENfT1NDSU5fT1VUX04xTTEsIHJlZ192YWwp Owo+ICsJCX0gZWxzZSB7Cj4gKwkJCS8qIHNlbGVjdCAzMksgb3NjaWxsYXRvciAqLwo+ICsJCQly ZWdtYXBfd3JpdGVfYml0cyhydGMtPm1hcCwgUlRDX0NUUkwsIFJUQ19PU0NfU0VMLCAwKTsKPiAr CQl9Cj4gKwkJLyogRW5hYmxlIFJUQyAqLwo+ICsJCXJlZ21hcF93cml0ZV9iaXRzKHJ0Yy0+bWFw LCBSVENfQ1RSTCwgUlRDX0VOQUJMRSwgUlRDX0VOQUJMRSk7CgoJCVRoaXMgbXVzdCBub3QgYmUg ZG9uZSBhdCBwcm9iZSB0aW1lLCBlbHNlIHlvdSBsb29zZSB0aGUKCQlpbXBvcnRhbnQgaW5mb3Jt YXRpb24gdGFodCB0aGUgdGltZSBoYXMgbmV2ZXIgYmVlbiBzZXQuIEluc3RlYWQsCgkJaXQgc2hv dWxkIG9ubHkgYmUgZW5hYmxlZCBvbiB0aGUgZmlyc3QgLnNldF90aW1lIGludm9jYXRpb24gZG8K CQl5b3UgY291bGQgbm93IGluIC5yZWFkX3RpbWUgdGhhdCB0aGUgdGltZSBpcyBjdXJyZW50bHkg aW52YWxpZC4KCj4gKwkJdXNsZWVwX3JhbmdlKDEwMCwgMjAwKTsKPiArCX0KPiArCXJlZ21hcF93 cml0ZV9iaXRzKHJ0Yy0+bWFwLCBSVENfSU5UX01BU0ssCj4gKwkJCSAgUlRDX0FMUk0wX0lSUV9N U0ssIFJUQ19BTFJNMF9JUlFfTVNLKTsKPiArCXJlZ21hcF93cml0ZV9iaXRzKHJ0Yy0+bWFwLCBS VENfQ1RSTCwgUlRDX0FMUk0wX0VOLCAwKTsKPiArfQo+ICsKCi0tIApBbGV4YW5kcmUgQmVsbG9u aSwgY28tb3duZXIgYW5kIENPTywgQm9vdGxpbgpFbWJlZGRlZCBMaW51eCBhbmQgS2VybmVsIGVu Z2luZWVyaW5nCmh0dHBzOi8vYm9vdGxpbi5jb20KCl9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFtbG9naWMgbWFpbGluZyBsaXN0CmxpbnV4LWFt bG9naWNAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWls bWFuL2xpc3RpbmZvL2xpbnV4LWFtbG9naWMK From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from relay1-d.mail.gandi.net (relay1-d.mail.gandi.net [217.70.183.193]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5046F335B5; Mon, 26 Aug 2024 09:45:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.193 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1724665525; cv=none; b=ERDmYh/hs9XfAuPKsS+DiU7jXp2H9X71sqnAJ6UASBpYyWs1VbLxmlqU3G3jMtTVRmB8n8jkSYr4dykjnRw8VGvQ0ER/RWLxd53P+vl84iJLmxGAUIRTUTVHNVNh1ep1tiJH1B6PbaMe+ZEcDF5ZQzCPEAftpBdgZwj5twRTJJ8= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1724665525; c=relaxed/simple; bh=PhNJCnEqWAf5tOQ3VBj/FIzLFFYPizMxoaqPArGK5Ts=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=GyE2hS6llbg/y2H0DQfWKnZIEhKPRo7nEcb5j9zWVx0Fed+LLKWfToGW7ie10uU2ptse8rKwSdrm7sSXiJuIbwU50a1eBSOxtgGWRWWQo0w49ldWp/vwSi+DtsJXcgmrIGShVeQrAuP6hGO1VD9TLe1jtI0BExozHq9kXgDQPiI= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=jIr7X3Zs; arc=none smtp.client-ip=217.70.183.193 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="jIr7X3Zs" Received: by mail.gandi.net (Postfix) with ESMTPSA id 3FE78240005; Mon, 26 Aug 2024 09:45:20 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1724665520; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Cm7pTcmop+B8Zg+nbYiYBBLjbkVuEU6sN7SIS3TJIAQ=; b=jIr7X3ZsNbaWgwn/2FZVB/qWjVAkCNv627YiNOV9EtsFgJ8rbmPK83G6X0KIU1OgmkTBur QOGMoEcVVWOc3XLyLft0yKn1L6Xzrs9ZBtfLa9MCBT4MZ/N3+cNM/U4TUAzwXxYr/6v6+R wOYm6+42QY4/T1cVe9afQNPxJr1L32STAD0qG2QvZCEzfOAzajcaK9U3PX8wson2RfEtKj +DtDByZNvPGY1KibzpEPyiinuXufj2Af/DkPLu2QPDiNKcVe75KY88EAqM+eWezH968g7v 4FN/h768YMHUa+PUsP3MwlTSeqCJXw3wlrfDfiZJfwElYnd/jLyDKyixJ/KKjg== Date: Mon, 26 Aug 2024 11:45:19 +0200 From: Alexandre Belloni To: xianwei.zhao@amlogic.com Cc: Yiting Deng , Rob Herring , Krzysztof Kozlowski , Conor Dooley , linux-amlogic@lists.infradead.org, linux-rtc@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH 2/3] rtc: support for the Amlogic on-chip RTC Message-ID: <2024082609451907fd19e2@mail.local> References: <20240823-rtc-v1-0-6f70381da283@amlogic.com> <20240823-rtc-v1-2-6f70381da283@amlogic.com> Precedence: bulk X-Mailing-List: linux-rtc@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20240823-rtc-v1-2-6f70381da283@amlogic.com> X-GND-Sasl: alexandre.belloni@bootlin.com On 23/08/2024 17:19:45+0800, Xianwei Zhao via B4 Relay wrote: > From: Yiting Deng > > Support for the on-chip RTC found in some of Amlogic's SoCs such as the > A113L2 and A113X2. > > Signed-off-by: Yiting Deng > Signed-off-by: Xianwei Zhao > --- > drivers/rtc/Kconfig | 12 + > drivers/rtc/Makefile | 1 + > drivers/rtc/rtc-amlogic.c | 589 ++++++++++++++++++++++++++++++++++++++++++++++ As pointed out, this is the third amlogic driver so the name of the file must be more specific. > +static void aml_set_time(struct aml_rtc_data *rtc, u32 time_sec) Is indirection necessary, this function is used only once > +{ > + if (rtc->config->gray_stored) > + time_sec = binary_to_gray(time_sec); > + regmap_write(rtc->map, RTC_COUNTER_REG, time_sec); > +} > + > +static u32 aml_read_time(struct aml_rtc_data *rtc) Ditto > +{ > + u32 time_sec; > + > + regmap_read(rtc->map, RTC_REAL_TIME, &time_sec); > + if (rtc->config->gray_stored) > + time_sec = gray_to_binary(time_sec); > + return time_sec; > +} > + > +static u32 aml_read_alarm(struct aml_rtc_data *rtc) Ditto > +{ > + u32 alarm_sec; > + > + regmap_read(rtc->map, RTC_ALARM0_REG, &alarm_sec); > + if (rtc->config->gray_stored) > + alarm_sec = gray_to_binary(alarm_sec); > + return alarm_sec; > +} > + > +static void aml_set_alarm(struct aml_rtc_data *rtc, u32 alarm_sec) Ditto > +{ > + if (rtc->config->gray_stored) > + alarm_sec = binary_to_gray(alarm_sec); > + regmap_write(rtc->map, RTC_ALARM0_REG, alarm_sec); > +} > + > +static int aml_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) > +{ > + struct aml_rtc_data *rtc = dev_get_drvdata(dev); > + time64_t alarm_sec; > + > + if (alarm->enabled) { Why aren't you setting the alarm when it is not enabled? > + regmap_update_bits(rtc->map, RTC_CTRL, > + RTC_ALRM0_EN, RTC_ALRM0_EN); > + regmap_update_bits(rtc->map, RTC_INT_MASK, > + RTC_ALRM0_IRQ_MSK, 0); > + > + alarm_sec = rtc_tm_to_time64(&alarm->time); > + if (alarm_sec > U32_MAX) { This is never going to happen, the test and error message are not necessary. > + dev_err(dev, "alarm value invalid!\n"); > + return -EINVAL; > + } > + aml_set_alarm(rtc, alarm_sec); > + } > + dev_dbg(dev, "%s: alarm->enabled=%d alarm_set=%llds\n", __func__, > + alarm->enabled, alarm_sec); > + > + return 0; > +} > + > +static int aml_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) > +{ > + struct aml_rtc_data *rtc = dev_get_drvdata(dev); > + u32 alarm_sec; > + u32 reg_val; > + int alarm_enable, alarm_mask; > + > + alarm_sec = aml_read_alarm(rtc); > + rtc_time64_to_tm(alarm_sec, &alarm->time); > + > + regmap_read(rtc->map, RTC_CTRL, ®_val); > + alarm_enable = FIELD_GET(RTC_ALRM0_EN, reg_val); > + > + regmap_read(rtc->map, RTC_INT_MASK, ®_val); > + alarm_mask = FIELD_GET(RTC_ALRM0_IRQ_MSK, reg_val); > + > + alarm->enabled = (alarm_enable && !alarm_mask) ? 1 : 0; > + dev_dbg(dev, "%s: alarm->enabled=%d alarm=%us\n", __func__, > + alarm->enabled, alarm_sec); > + > + return 0; > +} > + > +static irqreturn_t aml_rtc_handler(int irq, void *data) > +{ > + struct aml_rtc_data *rtc = (struct aml_rtc_data *)data; > + > + regmap_write(rtc->map, RTC_ALARM0_REG, 0); > + regmap_update_bits(rtc->map, RTC_INT_CLR, > + RTC_ALRM0_IRQ_STATUS, RTC_ALRM0_IRQ_STATUS); Are you sure regmap_update_bits is necessary here? > + > + rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF); > + > + return IRQ_HANDLED; > +} > + > +static int aml_rtc_adjust_sec(struct device *dev, u32 match_counter, > + int ops, int enable) > +{ > + struct aml_rtc_data *rtc = dev_get_drvdata(dev->parent); > + u32 reg_val; > + > + if (!FIELD_FIT(RTC_MATCH_COUNTER, match_counter)) { > + pr_err("%s: invalid match_counter\n", __func__); > + return -EINVAL; > + } > + > + reg_val = FIELD_PREP(RTC_SEC_ADJUST_CTRL, ops) > + | FIELD_PREP(RTC_MATCH_COUNTER, match_counter) > + | FIELD_PREP(RTC_ADJ_VALID, enable); > + /* Set sec_adjust_ctrl, match_counter and Valid adjust */ > + regmap_write(rtc->map, RTC_SEC_ADJUST_REG, reg_val); > + > + return 0; > +} > + > +static int aml_rtc_set_calibration(struct device *dev, u32 calibration) > +{ > + int cal_ops, enable, match_counter; > + int ret; > + > + match_counter = FIELD_GET(RTC_MATCH_COUNTER, calibration); > + cal_ops = FIELD_GET(RTC_SEC_ADJUST_CTRL, calibration); > + enable = FIELD_GET(RTC_ADJ_VALID, calibration); > + > + ret = aml_rtc_adjust_sec(dev, match_counter, cal_ops, enable); > + dev_dbg(dev, "%s: Success to store RTC calibration attribute\n", > + __func__); > + > + return ret; > +} > + > +static int aml_rtc_get_calibration(struct device *dev, u32 *calibration) > +{ > + struct aml_rtc_data *rtc = dev_get_drvdata(dev->parent); > + u32 reg_val; > + > + regmap_read(rtc->map, RTC_SEC_ADJUST_REG, ®_val); > + *calibration = FIELD_GET(RTC_SEC_ADJUST_CTRL | RTC_MATCH_COUNTER, reg_val); > + /* BIT is only UL defined，and GENMASK has no type, its' donot used together */ > + *calibration |= FIELD_PREP(RTC_ADJ_VALID, FIELD_GET(RTC_ADJ_VALID, reg_val)); > + > + return 0; > +} > + > +/** > + * The calibration value transferred from buf takes bit[18:0] to represent > + * match_counter, while takes bit[20:19] to represent sec_adjust_ctrl, bit[23] > + * to represent adj_valid. enable/disable sec_adjust_ctrl and match_counter. > + * @buf: Separate buf to match_counter, sec_adjust_ctrl and adj_valid > + * match_counter: bit[18:0], value is 0 ~ 0x7fff > + * sec_adjust_ctrl: bit[20:19], value is 0 ~ 2. 3 to insert a second once every > + * match_counter+1 seconds, 2 to swallow a second once every match_counter+1 seconds > + * 0 or 1 to no adjustment > + * adj_valid: bit[23], value is 0 or 1, 0 to disable sec_adjust_ctrl and > + * match_counter, and 1 to enable them. > + */ > +static ssize_t rtc_calibration_store(struct device *dev, > + struct device_attribute *attr, > + const char *buf, size_t count) > +{ > + int retval; > + int calibration = 0; > + > + if (sscanf(buf, " %i ", &calibration) != 1) { > + dev_err(dev, "Failed to store RTC calibration attribute\n"); > + return -EINVAL; > + } > + retval = aml_rtc_set_calibration(dev, calibration); > + > + return retval ? retval : count; > +} > + > +static ssize_t rtc_calibration_show(struct device *dev, > + struct device_attribute *attr, char *buf) > +{ > + int retval = 0; > + u32 calibration = 0; > + > + retval = aml_rtc_get_calibration(dev, &calibration); > + if (retval < 0) { > + dev_err(dev, "Failed to read RTC calibration attribute\n"); > + sprintf(buf, "0\n"); > + return retval; > + } > + > + return sprintf(buf, "0x%x\n", calibration); > +} > +static DEVICE_ATTR_RW(rtc_calibration); > + > +static int rtc_set_div256_adjust(struct device *dev, u32 *value) > +{ > + struct aml_rtc_data *rtc = dev_get_drvdata(dev->parent); > + u32 div256_adj; > + > + div256_adj = FIELD_PREP(RTC_DIV256_ADJ_DSR | RTC_DIV256_ADJ_VAL, *value); > + /* > + * AO_RTC_SEC_ADJUST_REG bit 24 insert/remove(1/0) a div256 cycle, > + * bit 25 valid/invalid(1/0) div256_adj_val > + */ > + regmap_write_bits(rtc->map, RTC_SEC_ADJUST_REG, > + RTC_DIV256_ADJ_DSR | RTC_DIV256_ADJ_VAL, div256_adj); > + /* rtc need about 30ms to adjust its time after written */ > + mdelay(30); > + > + return 0; > +} > + > +static int rtc_get_div256_adjust(struct device *dev, u32 *value) > +{ > + struct aml_rtc_data *rtc = dev_get_drvdata(dev->parent); > + u32 reg_val; > + > + regmap_read(rtc->map, RTC_SEC_ADJUST_REG, ®_val); > + *value = FIELD_GET(RTC_DIV256_ADJ_DSR | RTC_DIV256_ADJ_VAL, reg_val); > + > + return 0; > +} > + > +/** > + * div256 adjust function is controlled using bit[24] and bit[25]. > + * transferred buf takes bit[0] to represent div256 adj val, bit[1] > + * to represent div256 adj enable/disable. div256 cycle means that adjust > + * 1/32768/256 once by written once, it's val is equal to 1/128s > + * @buf: 3: enable div256 adjust and insert a div256 cycle > + * 2: enable div256 adjust and remove a div256 cycle > + * 1 or 0: disable div256 adjust > + */ > +static ssize_t rtc_div256_adjust_store(struct device *dev, > + struct device_attribute *attr, > + const char *buf, size_t count) > +{ > + int retval; > + u32 value = 0; > + > + if (sscanf(buf, " %i ", &value) != 1) { > + dev_err(dev, "Failed to store RTC div256 adjust attribute\n"); > + return -EINVAL; > + } > + retval = rtc_set_div256_adjust(dev, &value); > + > + return retval ? retval : count; > +} > + > +static ssize_t rtc_div256_adjust_show(struct device *dev, > + struct device_attribute *attr, char *buf) > +{ > + int retval = 0; > + u32 value = 0; > + > + retval = rtc_get_div256_adjust(dev, &value); > + if (retval < 0) { > + dev_err(dev, "Failed to read RTC div256 adjust attribute\n"); > + sprintf(buf, "0\n"); > + return retval; > + } > + > + return sprintf(buf, "0x%x\n", value); > +} > +static DEVICE_ATTR_RW(rtc_div256_adjust); > + > +static struct attribute *aml_rtc_attrs[] = { > + &dev_attr_rtc_calibration.attr, > + &dev_attr_rtc_div256_adjust.attr, > + NULL, > +}; > + > +static const struct attribute_group aml_rtc_sysfs_files = { > + .attrs = aml_rtc_attrs, > +}; > + You must use the standard RTC API to handle calibration, see .read_offset and .set_offset > +static void aml_rtc_init(struct device *dev, struct aml_rtc_data *rtc) > +{ > + u32 reg_val; > + u32 rtc_enable; > + > + regmap_read(rtc->map, RTC_CTRL, ®_val); > + rtc_enable = FIELD_GET(RTC_ENABLE, reg_val); > + if (!rtc_enable) { > + if (clk_get_rate(rtc->sclk) == OSC_24M) { > + /* select 24M oscillator */ > + regmap_update_bits(rtc->map, RTC_CTRL, RTC_OSC_SEL, RTC_OSC_SEL); > + > + /* > + * Set RTC oscillator to freq_out to freq_in/((N0*M0+N1*M1)/(M0+M1)) > + * Enable clock_in gate of oscillator 24MHz > + * Set N0 to 733, N1 to 732 > + */ > + reg_val = FIELD_PREP(RTC_OSCIN_IN_EN, 1) > + | FIELD_PREP(RTC_OSCIN_OUT_CFG, 1) > + | FIELD_PREP(RTC_OSCIN_OUT_N0M0, RTC_OSCIN_OUT_32K_N0) > + | FIELD_PREP(RTC_OSCIN_OUT_N1M1, RTC_OSCIN_OUT_32K_N1); > + regmap_write_bits(rtc->map, RTC_OSCIN_CTRL0, RTC_OSCIN_IN_EN > + | RTC_OSCIN_OUT_CFG | RTC_OSCIN_OUT_N0M0 > + | RTC_OSCIN_OUT_N1M1, reg_val); > + > + /* Set M0 to 2, M1 to 3, so freq_out = 32768 Hz*/ > + reg_val = FIELD_PREP(RTC_OSCIN_OUT_N0M0, RTC_OSCIN_OUT_32K_M0) > + | FIELD_PREP(RTC_OSCIN_OUT_N1M1, RTC_OSCIN_OUT_32K_M1); > + regmap_write_bits(rtc->map, RTC_OSCIN_CTRL1, RTC_OSCIN_OUT_N0M0 > + | RTC_OSCIN_OUT_N1M1, reg_val); > + } else { > + /* select 32K oscillator */ > + regmap_write_bits(rtc->map, RTC_CTRL, RTC_OSC_SEL, 0); > + } > + /* Enable RTC */ > + regmap_write_bits(rtc->map, RTC_CTRL, RTC_ENABLE, RTC_ENABLE); This must not be done at probe time, else you loose the important information taht the time has never been set. Instead, it should only be enabled on the first .set_time invocation do you could now in .read_time that the time is currently invalid. > + usleep_range(100, 200); > + } > + regmap_write_bits(rtc->map, RTC_INT_MASK, > + RTC_ALRM0_IRQ_MSK, RTC_ALRM0_IRQ_MSK); > + regmap_write_bits(rtc->map, RTC_CTRL, RTC_ALRM0_EN, 0); > +} > + -- Alexandre Belloni, co-owner and COO, Bootlin Embedded Linux and Kernel engineering https://bootlin.com