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 3A2E8C3DA4A for ; Fri, 9 Aug 2024 06:28:30 +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=CtBTM8xRs+Xnvyt5wd6rM28fx6pQt1tJl10r9rBMtgc=; b=0YFF6IhXkro9iF cJeCpRhivD3TCSKz0c3cNUSGusnaagm60wGkUfAnyGSejjKFW+0XxVeH4eS9P9vjU+NQNDHtOyWVY WH8+eC9D6a7YbcvziPht+pbkGWFEPLdA0xiAqrixfF5HaXzvqTc+YktzZk9h2CYrtIXaphggkFy8T yfLKIlj74K1RugOQ46ky2l5iQa2IihZtwaqperKh9JgQ2wbRkWscDH0qSEYUvb1g8Xsw90+Eer61M nf/Iu4bElkfOZuXNIhdPT/FYaTBSyLso7ysI5BlLFmnEETpkUutU6SATBLOgiAMp0YVvVjbF+FoS0 ZcFopHCqeIUeIKnO78SQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1scJ6w-0000000ARLV-224W; Fri, 09 Aug 2024 06:28:26 +0000 Received: from mail-pl1-x629.google.com ([2607:f8b0:4864:20::629]) by bombadil.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1scJ6s-0000000ARJX-3WPh for linux-rockchip@lists.infradead.org; Fri, 09 Aug 2024 06:28:25 +0000 Received: by mail-pl1-x629.google.com with SMTP id d9443c01a7336-1fec34f94abso17021525ad.2 for ; Thu, 08 Aug 2024 23:28:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1723184902; x=1723789702; darn=lists.infradead.org; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date:from:to :cc:subject:date:message-id:reply-to; bh=ZIb81mdm3Y+W7n5dTfDQvbXoixCEejMCmdPndqcOSy0=; b=pKQiYlSOQp3ba9Xntw23JZv7Mos8eV9beo5miRVvqNEbR77F+i1/CVaqnjk+gx2+Kp f4QsaJ4Rkaci6XjO/6KlJM2xJlHOS/TTWCinZJF0hgMW72lgB4+pilcoc9oQKyOivzQ9 XSTfspJzJN4kU6f9Y2fBOVh1gAoU1gg6HP+4hoOcq/ndhsA1DdMEyE/4VBAf3EX1e8H/ fpYGYFaPiIqeDFNIWNPdkLzzb7GhfH+q/N+zxda1Uofazcw5LvHB6/HX+6uQzYC//b5C 1vk8zSJ2i6Qihu70h4nylqKaZpeoQur5dm2Ml7587DIeoyLovPe20pKTavg8IjQAvFpL CjMg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1723184902; x=1723789702; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=ZIb81mdm3Y+W7n5dTfDQvbXoixCEejMCmdPndqcOSy0=; b=ga0jqQQp7naGenZMMf77SbHLCxpTQf6ZYBSeAQuv07nB2Up/stqljmBjD+o+adiHEB tPv+85p3KBjAZZbW4zQ9yL+xe3OTzu1AP6u/g/P5C5c8mOusz1I+BPnTMwHZKK10BbPx fpzU5lU4neGYeTRg5EKx/9ObmGzV2j57t8ydD4jJnU1nP4wYr6kMpBuEjGcfUyuUKLKW E5gxni9fBcG0nUkZdXqNTtn4xDBheIni8a/NTFWF2P96W0HdpmKkbpWruxY94b8vx+nD YpH9t2bxACINEVFIuQ5UuB6PJ35vtUSAhn6d7dWbuVNNCVUjAKGKC29zFjZ4xL1Npder Dy+w== X-Forwarded-Encrypted: i=1; AJvYcCVEM/ueDYKWxxe1aWhl+YNJpnO+patkztC7iojtSIRL/Hys+LecoUinIWvMrbMPoPvI6Sj7Lu0hw6KkMtLsXnbH+YHs8R5AN0NcvoCXgk0OqgNy X-Gm-Message-State: AOJu0YwTDKzTdSMnA+LMsNYkb+IRZQTFUBsZTukp/BUr2Qm359/AXesc CbWCME1BaafU2OS2b9j9Ckgm4vuhzORTBVSc05v9zHvY2n7KxoRjGQSRaVj6iw== X-Google-Smtp-Source: AGHT+IGsasHpV/b0wZ6hW5jBeHdTPZmWl2BTJu2ASUcJUsUFz15Ge+CsJmrwMOugSuJO5MJnkscfGQ== X-Received: by 2002:a17:902:f68c:b0:1fb:6e06:a099 with SMTP id d9443c01a7336-200ae5ce2c7mr5006435ad.40.1723184901711; Thu, 08 Aug 2024 23:28:21 -0700 (PDT) Received: from thinkpad ([117.213.100.70]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-1ff5916eaffsm134860975ad.194.2024.08.08.23.28.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 08 Aug 2024 23:28:21 -0700 (PDT) Date: Fri, 9 Aug 2024 11:58:13 +0530 From: Manivannan Sadhasivam To: Shawn Lin Cc: Rob Herring , "James E . J . Bottomley" , "Martin K . Petersen" , Krzysztof Kozlowski , Conor Dooley , Heiko Stuebner , Alim Akhtar , Avri Altman , Bart Van Assche , YiFeng Zhao , Liang Chen , linux-scsi@vger.kernel.org, linux-rockchip@lists.infradead.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org Subject: Re: [PATCH v2 3/3] scsi: ufs: rockchip: init support for UFS Message-ID: <20240809062813.GC2826@thinkpad> References: <1723089163-28983-1-git-send-email-shawn.lin@rock-chips.com> <1723089163-28983-4-git-send-email-shawn.lin@rock-chips.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <1723089163-28983-4-git-send-email-shawn.lin@rock-chips.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240808_232823_089481_20FBC52C X-CRM114-Status: GOOD ( 39.30 ) 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 T24gVGh1LCBBdWcgMDgsIDIwMjQgYXQgMTE6NTI6NDNBTSArMDgwMCwgU2hhd24gTGluIHdyb3Rl Ogo+IFJLMzU3NiBjb250YWlucyBhIFVGUyBjb250cm9sbGVyLCBhZGQgaW5pdCBzdXBwb3J0IGZv dCBpdC4KPiAKClRoaXMgZGVzY3JpcHRpb24gaXMgdmVyeSBzaW1wbGUuIFBsZWFzZSBhZGQgbW9y ZSBpbmZvIGxpa2UgdGhlIFVGU0hDRCB2ZXJzaW9uLApsYW5lIGNvbmZpZywgcXVpcmtzIGFuZCBh bnkgb3RoZXIgdmVuZG9yIHNwZWNpZmljIGRpZmZlcmVuY2UuCgo+IFNpZ25lZC1vZmYtYnk6IFNo YXduIExpbiA8c2hhd24ubGluQHJvY2stY2hpcHMuY29tPgo+IAo+IC0tLQo+IAo+IENoYW5nZXMg aW4gdjI6Cj4gLSB1c2UgZGV2X3Byb2JlX2Vycgo+IC0gcmVtb3ZlIHVmcy1waHktY29uZmlnLW1v ZGUgYXMgaXQncyBub3QgdXNlZAo+IC0gZHJvcCBvZl9tYXRjaF9wdHIKPiAKPiAgZHJpdmVycy91 ZnMvaG9zdC9LY29uZmlnICAgICAgICB8ICAxMiArKwo+ICBkcml2ZXJzL3Vmcy9ob3N0L01ha2Vm aWxlICAgICAgIHwgICAxICsKPiAgZHJpdmVycy91ZnMvaG9zdC91ZnMtcm9ja2NoaXAuYyB8IDQz OCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gIGRyaXZlcnMvdWZz L2hvc3QvdWZzLXJvY2tjaGlwLmggfCAgNTEgKysrKysKPiAgNCBmaWxlcyBjaGFuZ2VkLCA1MDIg aW5zZXJ0aW9ucygrKQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy91ZnMvaG9zdC91ZnMt cm9ja2NoaXAuYwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy91ZnMvaG9zdC91ZnMtcm9j a2NoaXAuaAo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3Vmcy9ob3N0L0tjb25maWcgYi9kcml2 ZXJzL3Vmcy9ob3N0L0tjb25maWcKPiBpbmRleCA1ODBjOGQwLi5mYWZhYTMzIDEwMDY0NAo+IC0t LSBhL2RyaXZlcnMvdWZzL2hvc3QvS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvdWZzL2hvc3QvS2Nv bmZpZwo+IEBAIC0xNDIsMyArMTQyLDE1IEBAIGNvbmZpZyBTQ1NJX1VGU19TUFJECj4gIAo+ICAJ ICBTZWxlY3QgdGhpcyBpZiB5b3UgaGF2ZSBVRlMgY29udHJvbGxlciBvbiBVbmlzb2MgY2hpcHNl dC4KPiAgCSAgSWYgdW5zdXJlLCBzYXkgTi4KPiArCj4gK2NvbmZpZyBTQ1NJX1VGU19ST0NLQ0hJ UAo+ICsJdHJpc3RhdGUgIlJvY2tjaGlwIHNwZWNpZmljIGhvb2tzIHRvIFVGUyBjb250cm9sbGVy IHBsYXRmb3JtIGRyaXZlciIKPiArCWRlcGVuZHMgb24gU0NTSV9VRlNIQ0RfUExBVEZPUk0gJiYg KEFSQ0hfUk9DS0NISVAgfHwgQ09NUElMRV9URVNUKQo+ICsJaGVscAo+ICsJICBUaGlzIHNlbGVj dHMgdGhlIFJvY2tjaGlwIHNwZWNpZmljIGFkZGl0aW9ucyB0byBVRlNIQ0QgcGxhdGZvcm0gZHJp dmVyLgo+ICsJICBVRlMgaG9zdCBvbiBSb2NrY2hpcCBuZWVkcyBzb21lIHZlbmRvciBzcGVjaWZp YyBjb25maWd1cmF0aW9uIGJlZm9yZQo+ICsJICBhY2Nlc3NpbmcgdGhlIGhhcmR3YXJlIHdoaWNo IGluY2x1ZGVzIFBIWSBjb25maWd1cmF0aW9uIGFuZCB2ZW5kb3IKPiArCSAgc3BlY2lmaWMgcmVn aXN0ZXJzLgo+ICsKPiArCSAgU2VsZWN0IHRoaXMgaWYgeW91IGhhdmUgVUZTIGNvbnRyb2xsZXIg b24gUm9ja2NoaXAgY2hpcHNldC4KPiArCSAgSWYgdW5zdXJlLCBzYXkgTi4KPiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy91ZnMvaG9zdC9NYWtlZmlsZSBiL2RyaXZlcnMvdWZzL2hvc3QvTWFrZWZpbGUK PiBpbmRleCA0NTczYWVhLi4yZjk3ZmViIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvdWZzL2hvc3Qv TWFrZWZpbGUKPiArKysgYi9kcml2ZXJzL3Vmcy9ob3N0L01ha2VmaWxlCj4gQEAgLTEwLDUgKzEw LDYgQEAgb2JqLSQoQ09ORklHX1NDU0lfVUZTSENEX1BMQVRGT1JNKSArPSB1ZnNoY2QtcGx0ZnJt Lm8KPiAgb2JqLSQoQ09ORklHX1NDU0lfVUZTX0hJU0kpICs9IHVmcy1oaXNpLm8KPiAgb2JqLSQo Q09ORklHX1NDU0lfVUZTX01FRElBVEVLKSArPSB1ZnMtbWVkaWF0ZWsubwo+ICBvYmotJChDT05G SUdfU0NTSV9VRlNfUkVORVNBUykgKz0gdWZzLXJlbmVzYXMubwo+ICtvYmotJChDT05GSUdfU0NT SV9VRlNfUk9DS0NISVApICs9IHVmcy1yb2NrY2hpcC5vCj4gIG9iai0kKENPTkZJR19TQ1NJX1VG U19TUFJEKSArPSB1ZnMtc3ByZC5vCj4gIG9iai0kKENPTkZJR19TQ1NJX1VGU19USV9KNzIxRSkg Kz0gdGktajcyMWUtdWZzLm8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy91ZnMvaG9zdC91ZnMtcm9j a2NoaXAuYyBiL2RyaXZlcnMvdWZzL2hvc3QvdWZzLXJvY2tjaGlwLmMKPiBuZXcgZmlsZSBtb2Rl IDEwMDY0NAo+IGluZGV4IDAwMDAwMDAuLjQ2YzkwZDYKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIv ZHJpdmVycy91ZnMvaG9zdC91ZnMtcm9ja2NoaXAuYwo+IEBAIC0wLDAgKzEsNDM4IEBACj4gKy8v IFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkKPiArLyoKPiArICogUm9ja2No aXAgVUZTIEhvc3QgQ29udHJvbGxlciBkcml2ZXIKPiArICoKPiArICogQ29weXJpZ2h0IChDKSAy MDI0IFJvY2tjaGlwIEVsZWN0cm9uaWNzIENvLkx0ZC4KPiArICovCj4gKwo+ICsjaW5jbHVkZSA8 bGludXgvY2xrLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9ncGlvLmg+Cj4gKyNpbmNsdWRlIDxsaW51 eC9tZmQvc3lzY29uLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9vZi5oPgo+ICsjaW5jbHVkZSA8bGlu dXgvcGxhdGZvcm1fZGV2aWNlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KPiArI2lu Y2x1ZGUgPGxpbnV4L3Jlc2V0Lmg+Cj4gKwo+ICsjaW5jbHVkZSA8dWZzL3Vmc2hjZC5oPgo+ICsj aW5jbHVkZSA8dWZzL3VuaXByby5oPgo+ICsjaW5jbHVkZSAidWZzaGNkLXBsdGZybS5oIgo+ICsj aW5jbHVkZSAidWZzaGNkLWR3Yy5oIgo+ICsjaW5jbHVkZSAidWZzLXJvY2tjaGlwLmgiCj4gKwo+ ICtzdGF0aWMgaW5saW5lIGJvb2wgdWZzaGNkX2lzX2RldmljZV9wcmVzZW50KHN0cnVjdCB1ZnNf aGJhICpoYmEpCgpObyBpbmxpbmUgaW4gLmMgZmlsZSBwbGVhc2UuCgo+ICt7Cj4gKwlyZXR1cm4g dWZzaGNkX3JlYWRsKGhiYSwgUkVHX0NPTlRST0xMRVJfU1RBVFVTKSAmIERFVklDRV9QUkVTRU5U Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHVmc19yb2NrY2hpcF9oY2VfZW5hYmxlX25vdGlmeShz dHJ1Y3QgdWZzX2hiYSAqaGJhLAo+ICsJCQkJCSBlbnVtIHVmc19ub3RpZnlfY2hhbmdlX3N0YXR1 cyBzdGF0dXMpCj4gK3sKPiArCWludCBlcnIgPSAwOwo+ICsKPiArCWlmIChzdGF0dXMgPT0gUFJF X0NIQU5HRSkgewo+ICsJCWludCByZXRyeV9vdXRlciA9IDM7Cj4gKwkJaW50IHJldHJ5X2lubmVy Owo+ICtzdGFydDoKPiArCQlpZiAodWZzaGNkX2lzX2hiYV9hY3RpdmUoaGJhKSkKPiArCQkJLyog Y2hhbmdlIGNvbnRyb2xsZXIgc3RhdGUgdG8gInJlc2V0IHN0YXRlIiAqLwo+ICsJCQl1ZnNoY2Rf aGJhX3N0b3AoaGJhKTsKPiArCj4gKwkJLyogVW5pUHJvIGxpbmsgaXMgZGlzYWJsZWQgYXQgdGhp cyBwb2ludCAqLwo+ICsJCXVmc2hjZF9zZXRfbGlua19vZmYoaGJhKTsKPiArCj4gKwkJLyogc3Rh cnQgY29udHJvbGxlciBpbml0aWFsaXphdGlvbiBzZXF1ZW5jZSAqLwo+ICsJCXVmc2hjZF93cml0 ZWwoaGJhLCBDT05UUk9MTEVSX0VOQUJMRSwgUkVHX0NPTlRST0xMRVJfRU5BQkxFKTsKPiArCj4g KwkJdXNsZWVwX3JhbmdlKDEwMCwgMjAwKTsKPiArCj4gKwkJLyogd2FpdCBmb3IgdGhlIGhvc3Qg Y29udHJvbGxlciB0byBjb21wbGV0ZSBpbml0aWFsaXphdGlvbiAqLwo+ICsJCXJldHJ5X2lubmVy ID0gNTA7Cj4gKwkJd2hpbGUgKCF1ZnNoY2RfaXNfaGJhX2FjdGl2ZShoYmEpKSB7Cj4gKwkJCWlm IChyZXRyeV9pbm5lcikgewo+ICsJCQkJcmV0cnlfaW5uZXItLTsKPiArCQkJfSBlbHNlIHsKPiAr CQkJCWRldl9lcnIoaGJhLT5kZXYsCj4gKwkJCQkJIkNvbnRyb2xsZXIgZW5hYmxlIGZhaWxlZFxu Iik7Cj4gKwkJCQlpZiAocmV0cnlfb3V0ZXIpIHsKPiArCQkJCQlyZXRyeV9vdXRlci0tOwo+ICsJ CQkJCWdvdG8gc3RhcnQ7Cj4gKwkJCQl9Cj4gKwkJCQlyZXR1cm4gLUVJTzsKPiArCQkJfQo+ICsJ CQl1c2xlZXBfcmFuZ2UoMTAwMCwgMTEwMCk7Cj4gKwkJfQoKWW91IGp1c3QgZHVwbGljYXRlZCB1 ZnNoY2RfaGJhX2V4ZWN1dGVfaGNlKCkgaGVyZS4gV2h5PyBUaGlzIGRvZXNuJ3QgbWFrZSBzZW5z ZS4KCj4gKwl9IGVsc2UgeyAvKiBQT1NUX0NIQU5HRSAqLwo+ICsJCWVyciA9IHVmc2hjZF92b3Bz X3BoeV9pbml0aWFsaXphdGlvbihoYmEpOwo+ICsJfQo+ICsKPiArCXJldHVybiBlcnI7Cj4gK30K PiArCj4gK3N0YXRpYyB2b2lkIHVmc19yb2NrY2hpcF9zZXRfcG1fbHZsKHN0cnVjdCB1ZnNfaGJh ICpoYmEpCj4gK3sKPiArCWhiYS0+cnBtX2x2bCA9IFVGU19QTV9MVkxfMTsKPiArCWhiYS0+c3Bt X2x2bCA9IFVGU19QTV9MVkxfMzsKPiArfQo+ICsKPiArc3RhdGljIGludCB1ZnNfcm9ja2NoaXBf cmszNTc2X3BoeV9pbml0KHN0cnVjdCB1ZnNfaGJhICpoYmEpCj4gK3sKPiArCXN0cnVjdCB1ZnNf cm9ja2NoaXBfaG9zdCAqaG9zdCA9IHVmc2hjZF9nZXRfdmFyaWFudChoYmEpOwo+ICsKPiArCXVm c2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJfU0VMKFBBX0xPQ0FMX1RYX0xDQ19FTkFCTEUs IDB4MCksIDB4MCk7Cj4gKwkvKiBlbmFibGUgdGhlIG1waHkgRE1FX1NFVCBjZmcgKi8KPiArCXVm c2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJfU0VMKDB4MjAwLCAweDApLCAweDQwKTsKPiAr CWZvciAoaW50IGkgPSAwOyBpIDwgMjsgaSsrKSB7Cj4gKwkJLyogQ29uZmlndXJhdGlvbiBNLVRY ICovCj4gKwkJdWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQl9TRUwoMHhhYSwgU0VMX1RY X0xBTkUwICsgaSksIDB4MDYpOwo+ICsJCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJf U0VMKDB4YTksIFNFTF9UWF9MQU5FMCArIGkpLCAweDAyKTsKPiArCQl1ZnNoY2RfZG1lX3NldCho YmEsIFVJQ19BUkdfTUlCX1NFTCgweGFkLCBTRUxfVFhfTEFORTAgKyBpKSwgMHg0NCk7Cj4gKwkJ dWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQl9TRUwoMHhhYywgU0VMX1RYX0xBTkUwICsg aSksIDB4ZTYpOwo+ICsJCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJfU0VMKDB4YWIs IFNFTF9UWF9MQU5FMCArIGkpLCAweDA3KTsKPiArCQl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19B UkdfTUlCX1NFTCgweDk0LCBTRUxfVFhfTEFORTAgKyBpKSwgMHg5Myk7Cj4gKwkJdWZzaGNkX2Rt ZV9zZXQoaGJhLCBVSUNfQVJHX01JQl9TRUwoMHg5MywgU0VMX1RYX0xBTkUwICsgaSksIDB4Yzkp Owo+ICsJCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJfU0VMKDB4N2YsIFNFTF9UWF9M QU5FMCArIGkpLCAweDAwKTsKPiArCQkvKiBDb25maWd1cmF0aW9uIE0tUlggKi8KPiArCQl1ZnNo Y2RfZG1lX3NldChoYmEsIFVJQ19BUkdfTUlCX1NFTCgweDEyLCBTRUxfUlhfTEFORTAgKyBpKSwg MHgwNik7Cj4gKwkJdWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQl9TRUwoMHgxMSwgU0VM X1JYX0xBTkUwICsgaSksIDB4MDApOwo+ICsJCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19N SUJfU0VMKDB4MWQsIFNFTF9SWF9MQU5FMCArIGkpLCAweDU4KTsKPiArCQl1ZnNoY2RfZG1lX3Nl dChoYmEsIFVJQ19BUkdfTUlCX1NFTCgweDFjLCBTRUxfUlhfTEFORTAgKyBpKSwgMHg4Yyk7Cj4g KwkJdWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQl9TRUwoMHgxYiwgU0VMX1JYX0xBTkUw ICsgaSksIDB4MDIpOwo+ICsJCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJfU0VMKDB4 MjUsIFNFTF9SWF9MQU5FMCArIGkpLCAweGY2KTsKPiArCQl1ZnNoY2RfZG1lX3NldChoYmEsIFVJ Q19BUkdfTUlCX1NFTCgweDJmLCBTRUxfUlhfTEFORTAgKyBpKSwgMHg2OSk7Cj4gKwl9Cj4gKwkv KiBkaXNhYmxlIHRoZSBtcGh5IERNRV9TRVQgY2ZnICovCj4gKwl1ZnNoY2RfZG1lX3NldChoYmEs IFVJQ19BUkdfTUlCX1NFTCgweDIwMCwgMHgwKSwgMHgwMCk7Cj4gKwo+ICsJdWZzX3N5c193cml0 ZWwoaG9zdC0+bXBoeV9iYXNlLCAweDgwLCAweDA4Qyk7Cj4gKwl1ZnNfc3lzX3dyaXRlbChob3N0 LT5tcGh5X2Jhc2UsIDB4QjUsIDB4MTEwKTsKPiArCXVmc19zeXNfd3JpdGVsKGhvc3QtPm1waHlf YmFzZSwgMHhCNSwgMHgyNTApOwo+ICsKCldoeSBjYW4ndCB5b3UgZG8gdGhlc2Ugc2V0dGluZ3Mg aW4gYSBQSFkgZHJpdmVyPwoKPiArCXVmc19zeXNfd3JpdGVsKGhvc3QtPm1waHlfYmFzZSwgMHgw MywgMHgxMzQpOwo+ICsJdWZzX3N5c193cml0ZWwoaG9zdC0+bXBoeV9iYXNlLCAweDAzLCAweDI3 NCk7Cj4gKwo+ICsJdWZzX3N5c193cml0ZWwoaG9zdC0+bXBoeV9iYXNlLCAweDM4LCAweDBFMCk7 Cj4gKwl1ZnNfc3lzX3dyaXRlbChob3N0LT5tcGh5X2Jhc2UsIDB4MzgsIDB4MjIwKTsKPiArCj4g Kwl1ZnNfc3lzX3dyaXRlbChob3N0LT5tcGh5X2Jhc2UsIDB4NTAsIDB4MTY0KTsKPiArCXVmc19z eXNfd3JpdGVsKGhvc3QtPm1waHlfYmFzZSwgMHg1MCwgMHgyQTQpOwo+ICsKPiArCXVmc19zeXNf d3JpdGVsKGhvc3QtPm1waHlfYmFzZSwgMHg4MCwgMHgxNzgpOwo+ICsJdWZzX3N5c193cml0ZWwo aG9zdC0+bXBoeV9iYXNlLCAweDgwLCAweDJCOCk7Cj4gKwo+ICsJdWZzX3N5c193cml0ZWwoaG9z dC0+bXBoeV9iYXNlLCAweDE4LCAweDFCMCk7Cj4gKwl1ZnNfc3lzX3dyaXRlbChob3N0LT5tcGh5 X2Jhc2UsIDB4MTgsIDB4MkYwKTsKPiArCj4gKwl1ZnNfc3lzX3dyaXRlbChob3N0LT5tcGh5X2Jh c2UsIDB4MDMsIDB4MTI4KTsKPiArCXVmc19zeXNfd3JpdGVsKGhvc3QtPm1waHlfYmFzZSwgMHgw MywgMHgyNjgpOwo+ICsKPiArCXVmc19zeXNfd3JpdGVsKGhvc3QtPm1waHlfYmFzZSwgMHgyMCwg MHgxMkMpOwo+ICsJdWZzX3N5c193cml0ZWwoaG9zdC0+bXBoeV9iYXNlLCAweDIwLCAweDI2Qyk7 Cj4gKwo+ICsJdWZzX3N5c193cml0ZWwoaG9zdC0+bXBoeV9iYXNlLCAweEMwLCAweDEyMCk7Cj4g Kwl1ZnNfc3lzX3dyaXRlbChob3N0LT5tcGh5X2Jhc2UsIDB4QzAsIDB4MjYwKTsKPiArCj4gKwl1 ZnNfc3lzX3dyaXRlbChob3N0LT5tcGh5X2Jhc2UsIDB4MDMsIDB4MDk0KTsKPiArCj4gKwl1ZnNf c3lzX3dyaXRlbChob3N0LT5tcGh5X2Jhc2UsIDB4MDMsIDB4MUI0KTsKPiArCXVmc19zeXNfd3Jp dGVsKGhvc3QtPm1waHlfYmFzZSwgMHgwMywgMHgyRjQpOwo+ICsKPiArCXVmc19zeXNfd3JpdGVs KGhvc3QtPm1waHlfYmFzZSwgMHhDMCwgMHgwOEMpOwo+ICsJdWRlbGF5KDEpOwo+ICsJdWZzX3N5 c193cml0ZWwoaG9zdC0+bXBoeV9iYXNlLCAweDAwLCAweDA4Qyk7Cj4gKwo+ICsJdWRlbGF5KDIw MCk7Cj4gKwkvKiBzdGFydCBsaW5rIHVwICovCj4gKwl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19B UkdfTUlCX1NFTChNSUJfVF9EQkdfQ1BPUlRfVFhfRU5ESUFOLCAwKSwgMHgwKTsKPiArCXVmc2hj ZF9kbWVfc2V0KGhiYSwgVUlDX0FSR19NSUJfU0VMKE1JQl9UX0RCR19DUE9SVF9SWF9FTkRJQU4s IDApLCAweDApOwo+ICsJdWZzaGNkX2RtZV9zZXQoaGJhLCBVSUNfQVJHX01JQl9TRUwoTl9ERVZJ Q0VJRCwgMCksIDB4MCk7Cj4gKwl1ZnNoY2RfZG1lX3NldChoYmEsIFVJQ19BUkdfTUlCX1NFTChO X0RFVklDRUlEX1ZBTElELCAwKSwgMHgxKTsKPiArCXVmc2hjZF9kbWVfc2V0KGhiYSwgVUlDX0FS R19NSUJfU0VMKFRfUEVFUkRFVklDRUlELCAwKSwgMHgxKTsKPiArCXVmc2hjZF9kbWVfc2V0KGhi YSwgVUlDX0FSR19NSUJfU0VMKFRfQ09OTkVDVElPTlNUQVRFLCAwKSwgMHgxKTsKPiArCj4gKwly ZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludCB1ZnNfcm9ja2NoaXBfY29tbW9uX2luaXQo c3RydWN0IHVmc19oYmEgKmhiYSkKPiArewo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gaGJhLT5k ZXY7Cj4gKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2ID0gdG9fcGxhdGZvcm1fZGV2aWNl KGRldik7Cj4gKwlzdHJ1Y3QgdWZzX3JvY2tjaGlwX2hvc3QgKmhvc3Q7Cj4gKwlpbnQgZXJyID0g MDsKPiArCj4gKwlob3N0ID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpob3N0KSwgR0ZQX0tF Uk5FTCk7Cj4gKwlpZiAoIWhvc3QpCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJLyogc3lz dGVtIGNvbnRyb2wgcmVnaXN0ZXIgZm9yIGhjaSAqLwo+ICsJaG9zdC0+dWZzX3N5c19jdHJsID0g ZGV2bV9wbGF0Zm9ybV9pb3JlbWFwX3Jlc291cmNlX2J5bmFtZShwZGV2LCAiaGNpX2dyZiIpOwo+ ICsJaWYgKElTX0VSUihob3N0LT51ZnNfc3lzX2N0cmwpKQo+ICsJCXJldHVybiBkZXZfZXJyX3By b2JlKGRldiwgUFRSX0VSUihob3N0LT51ZnNfc3lzX2N0cmwpLAo+ICsJCQkJCSJjYW5ub3QgaW9y ZW1hcCBmb3IgaGNpIHN5c3RlbSBjb250cm9sIHJlZ2lzdGVyXG4iKTsKPiArCj4gKwkvKiBzeXN0 ZW0gY29udHJvbCByZWdpc3RlciBmb3IgbXBoeSAqLwo+ICsJaG9zdC0+dWZzX3BoeV9jdHJsID0g ZGV2bV9wbGF0Zm9ybV9pb3JlbWFwX3Jlc291cmNlX2J5bmFtZShwZGV2LCAibXBoeV9ncmYiKTsK PiArCWlmIChJU19FUlIoaG9zdC0+dWZzX3BoeV9jdHJsKSkKPiArCQlyZXR1cm4gZGV2X2Vycl9w cm9iZShkZXYsIFBUUl9FUlIoaG9zdC0+dWZzX3BoeV9jdHJsKSwKPiArCQkJCSJjYW5ub3QgaW9y ZW1hcCBmb3IgbXBoeSBzeXN0ZW0gY29udHJvbCByZWdpc3RlclxuIik7Cj4gKwo+ICsJLyogbXBo eSBiYXNlIHJlZ2lzdGVyICovCj4gKwlob3N0LT5tcGh5X2Jhc2UgPSBkZXZtX3BsYXRmb3JtX2lv cmVtYXBfcmVzb3VyY2VfYnluYW1lKHBkZXYsICJtcGh5Iik7Cj4gKwlpZiAoSVNfRVJSKGhvc3Qt Pm1waHlfYmFzZSkpCj4gKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoZGV2LCBQVFJfRVJSKGhvc3Qt Pm1waHlfYmFzZSksCj4gKwkJCQkJImNhbm5vdCBpb3JlbWFwIGZvciBtcGh5IGJhc2UgcmVnaXN0 ZXJcbiIpOwo+ICsKPiArCWhvc3QtPnJzdCA9IGRldm1fcmVzZXRfY29udHJvbF9hcnJheV9nZXRf ZXhjbHVzaXZlKGRldik7Cj4gKwlpZiAoSVNfRVJSKGhvc3QtPnJzdCkpCj4gKwkJcmV0dXJuIGRl dl9lcnJfcHJvYmUoZGV2LCBQVFJfRVJSKGhvc3QtPnJzdCksICJmYWlsZWQgdG8gZ2V0IHJlc2V0 IGNvbnRyb2xcbiIpOwo+ICsKPiArCXJlc2V0X2NvbnRyb2xfYXNzZXJ0KGhvc3QtPnJzdCk7Cj4g Kwl1ZGVsYXkoMSk7Cj4gKwlyZXNldF9jb250cm9sX2RlYXNzZXJ0KGhvc3QtPnJzdCk7Cj4gKwo+ ICsJaG9zdC0+cmVmX291dF9jbGsgPSBkZXZtX2Nsa19nZXQoZGV2LCAicmVmX291dCIpOwo+ICsJ aWYgKElTX0VSUihob3N0LT5yZWZfb3V0X2NsaykpCj4gKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUo ZGV2LCBQVFJfRVJSKGhvc3QtPnJlZl9vdXRfY2xrKSwgImNpdS1kcml2ZSBub3QgYXZhaWxhYmxl XG4iKTsKCldoYXQgaXMgJ2NpdS1kcml2ZSc/Cgo+ICsKPiArCWVyciA9IGNsa19wcmVwYXJlX2Vu YWJsZShob3N0LT5yZWZfb3V0X2Nsayk7Cj4gKwlpZiAoZXJyKQo+ICsJCXJldHVybiBkZXZfZXJy X3Byb2JlKGRldiwgZXJyLCAiZmFpbGVkIHRvIGVuYWJsZSByZWYgb3V0IGNsb2NrXG4iKTsKPiAr Cj4gKwlob3N0LT5yc3RfZ3BpbyA9IGRldm1fZ3Bpb2RfZ2V0KCZwZGV2LT5kZXYsICJyZXNldCIs IEdQSU9EX09VVF9MT1cpOwo+ICsJaWYgKElTX0VSUihob3N0LT5yc3RfZ3BpbykpIHsKPiArCQlk ZXZfZXJyX3Byb2JlKCZwZGV2LT5kZXYsIFBUUl9FUlIoaG9zdC0+cnN0X2dwaW8pLAo+ICsJCQkJ ImludmFsaWQgcmVzZXQtZ3Bpb3MgcHJvcGVydHkgaW4gbm9kZVxuIik7Cj4gKwkJZXJyID0gUFRS X0VSUihob3N0LT5yc3RfZ3Bpbyk7CgpLcnp5c3p0b2YgYWxyZWFkeSBwb2ludGVkIG91dCB0aGlz LgoKPiArCQlnb3RvIG91dDsKPiArCX0KPiArCXVkZWxheSgyMCk7Cj4gKwlncGlvZF9zZXRfdmFs dWVfY2Fuc2xlZXAoaG9zdC0+cnN0X2dwaW8sIDEpOwoKV2h5IGRvIHlvdSBuZWVkIHRvIGFzc2Vy dCBkZXZpY2UgcmVzZXQgaGVyZT8gdWZzaGNkIGRyaXZlciB3aWxsIGRvIGl0IGFueXdheS4KCj4g Kwo+ICsJaG9zdC0+Y2xrc1swXS5pZCA9ICJjb3JlIjsKPiArCWhvc3QtPmNsa3NbMV0uaWQgPSAi cGNsayI7Cj4gKwlob3N0LT5jbGtzWzJdLmlkID0gInBjbGtfbXBoeSI7Cj4gKwllcnIgPSBkZXZt X2Nsa19idWxrX2dldF9vcHRpb25hbChkZXYsIFVGU19NQVhfQ0xLUywgaG9zdC0+Y2xrcyk7Cj4g KwlpZiAoZXJyKSB7Cj4gKwkJZGV2X2Vycl9wcm9iZShkZXYsIGVyciwgImZhaWxlZCB0byBnZXQg Y2xvY2tzXG4iKTsKPiArCQlnb3RvIG91dDsKPiArCX0KPiArCj4gKwllcnIgPSBjbGtfYnVsa19w cmVwYXJlX2VuYWJsZShVRlNfTUFYX0NMS1MsIGhvc3QtPmNsa3MpOwo+ICsJaWYgKGVycikgewo+ ICsJCWRldl9lcnJfcHJvYmUoZGV2LCBlcnIsICJmYWlsZWQgdG8gZW5hYmxlIGNsb2Nrc1xuIik7 Cj4gKwkJZ290byBvdXQ7Cj4gKwl9Cj4gKwo+ICsJcG1fcnVudGltZV9zZXRfYWN0aXZlKCZwZGV2 LT5kZXYpOwoKVGhpcyBpcyBhbHJlYWR5IGNhbGxlZCBpbiB1ZnNoY2RfcGx0ZnJtX2luaXQoKS4K Cj4gKwo+ICsJaG9zdC0+aGJhID0gaGJhOwo+ICsJdWZzX3JvY2tjaGlwX3NldF9wbV9sdmwoaGJh KTsKPiArCj4gKwl1ZnNoY2Rfc2V0X3ZhcmlhbnQoaGJhLCBob3N0KTsKPiArCj4gKwlyZXR1cm4g MDsKPiArb3V0OgoKcy9vdXQvZGlzYWJsZV9yZWZfY2xrCgo+ICsJY2xrX2Rpc2FibGVfdW5wcmVw YXJlKGhvc3QtPnJlZl9vdXRfY2xrKTsKPiArCXJldHVybiBlcnI7Cj4gK30KPiArCj4gK3N0YXRp YyBpbnQgdWZzX3JvY2tjaGlwX3JrMzU3Nl9pbml0KHN0cnVjdCB1ZnNfaGJhICpoYmEpCj4gK3sK PiArCWludCByZXQgPSAwOwoKSW5pdGlhbGl6YXRpb24gbm90IG5lZWRlZC4KCj4gKwlzdHJ1Y3Qg ZGV2aWNlICpkZXYgPSBoYmEtPmRldjsKPiArCgpBbHNvIHJldmVyc2UgWG1hcyBvcmRlciBmb3Ig bG9jYWwgdmFyaWFibGVzIHBsZWFzZS4KCj4gKwloYmEtPnF1aXJrcyA9IFVGU0hDSV9RVUlSS19C Uk9LRU5fSENFIHwgVUZTSENEX1FVSVJLX1NLSVBfREVGX1VOSVBST19USU1FT1VUX1NFVFRJTkc7 Cj4gKwo+ICsJLyogRW5hYmxlIEJLT1BTIHdoZW4gc3VzcGVuZCAqLwo+ICsJaGJhLT5jYXBzIHw9 IFVGU0hDRF9DQVBfQVVUT19CS09QU19TVVNQRU5EOwo+ICsJLyogRW5hYmxlIHB1dHRpbmcgZGV2 aWNlIGludG8gZGVlcCBzbGVlcCAqLwo+ICsJaGJhLT5jYXBzIHw9IFVGU0hDRF9DQVBfREVFUFNM RUVQOwo+ICsJLyogRW5hYmxlIGRldmZyZXEgb2YgVUZTICovCj4gKwloYmEtPmNhcHMgfD0gVUZT SENEX0NBUF9DTEtfU0NBTElORzsKPiArCS8qIEVuYWJsZSBXcml0ZUJvb3N0ZXIgKi8KPiArCWhi YS0+Y2FwcyB8PSBVRlNIQ0RfQ0FQX1dCX0VOOwo+ICsKPiArCXJldCA9IHVmc19yb2NrY2hpcF9j b21tb25faW5pdChoYmEpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShk ZXYsIHJldCwgInVmcyBjb21tb24gaW5pdCBmYWlsXG4iKTsKPiArCj4gKwlyZXR1cm4gMDsKPiAr fQo+ICsKPiArc3RhdGljIGludCB1ZnNfcm9ja2NoaXBfZGV2aWNlX3Jlc2V0KHN0cnVjdCB1ZnNf aGJhICpoYmEpCj4gK3sKPiArCXN0cnVjdCB1ZnNfcm9ja2NoaXBfaG9zdCAqaG9zdCA9IHVmc2hj ZF9nZXRfdmFyaWFudChoYmEpOwo+ICsKPiArCWlmICghaG9zdC0+cnN0X2dwaW8pCj4gKwkJcmV0 dXJuIC1FT1BOT1RTVVBQOwoKSXMgaXQgcG9zc2libGUgdG8gaGl0IHRoaXMgY29uZGl0aW9uPwoK PiArCj4gKwlncGlvZF9zZXRfdmFsdWVfY2Fuc2xlZXAoaG9zdC0+cnN0X2dwaW8sIDApOwo+ICsJ dWRlbGF5KDIwKTsKPiArCj4gKwlncGlvZF9zZXRfdmFsdWVfY2Fuc2xlZXAoaG9zdC0+cnN0X2dw aW8sIDEpOwo+ICsJdWRlbGF5KDIwKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3Rh dGljIGNvbnN0IHN0cnVjdCB1ZnNfaGJhX3ZhcmlhbnRfb3BzIHVmc19oYmFfcmszNTc2X3ZvcHMg PSB7Cj4gKwkubmFtZSA9ICJyazM1NzYiLAo+ICsJLmluaXQgPSB1ZnNfcm9ja2NoaXBfcmszNTc2 X2luaXQsCj4gKwkuZGV2aWNlX3Jlc2V0ID0gdWZzX3JvY2tjaGlwX2RldmljZV9yZXNldCwKPiAr CS5oY2VfZW5hYmxlX25vdGlmeSA9IHVmc19yb2NrY2hpcF9oY2VfZW5hYmxlX25vdGlmeSwKPiAr CS5waHlfaW5pdGlhbGl6YXRpb24gPSB1ZnNfcm9ja2NoaXBfcmszNTc2X3BoeV9pbml0LAo+ICt9 Owo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgdWZzX3JvY2tjaGlwX29m X21hdGNoW10gPSB7Cj4gKwl7IC5jb21wYXRpYmxlID0gInJvY2tjaGlwLHJrMzU3Ni11ZnMiLCAu ZGF0YSA9ICZ1ZnNfaGJhX3JrMzU3Nl92b3BzfSwKClVzZSAncm9ja2NoaXAscmszNTc2LXVmc2hj Jy4KCj4gKwl7fSwKPiArfTsKPiArTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgdWZzX3JvY2tjaGlw X29mX21hdGNoKTsKPiArCj4gK3N0YXRpYyBpbnQgdWZzX3JvY2tjaGlwX3Byb2JlKHN0cnVjdCBw bGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gK3sKPiArCWludCBlcnIgPSAwOwoKQWdhaW4gbm8gaW5p dCBuZWVkZWQgYW5kIHVzZSByZXZlcnNlIFhtYXMgb3JkZXIgKGV2ZXJ5d2hlcmUpLgoKPiArCXN0 cnVjdCBkZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7Cj4gKwljb25zdCBzdHJ1Y3QgdWZzX2hiYV92 YXJpYW50X29wcyAqdm9wczsKPiArCj4gKwl2b3BzID0gZGV2aWNlX2dldF9tYXRjaF9kYXRhKGRl dik7CgpJcyBpdCBPSyBpZiB2b3BzIGlzIE5VTEw/Cgo+ICsJZXJyID0gdWZzaGNkX3BsdGZybV9p bml0KHBkZXYsIHZvcHMpOwo+ICsJaWYgKGVycikKPiArCQlkZXZfZXJyX3Byb2JlKGRldiwgZXJy LCAidWZzaGNkX3BsdGZybV9pbml0IGZhaWxlZFxuIik7CgpSZXR1cm4gZXJyIGhlcmUgYW5kIHJl dHVybiAwIGJlbG93LgoKPiArCj4gKwlyZXR1cm4gZXJyOwo+ICt9Cj4gKwoKWy4uLl0KCj4gK3N0 YXRpYyBjb25zdCBzdHJ1Y3QgZGV2X3BtX29wcyB1ZnNfcm9ja2NoaXBfcG1fb3BzID0gewo+ICsJ U0VUX1NZU1RFTV9TTEVFUF9QTV9PUFModWZzX3JvY2tjaGlwX3N1c3BlbmQsIHVmc19yb2NrY2hp cF9yZXN1bWUpCj4gKwlTRVRfUlVOVElNRV9QTV9PUFModWZzX3JvY2tjaGlwX3J1bnRpbWVfc3Vz cGVuZCwgdWZzX3JvY2tjaGlwX3J1bnRpbWVfcmVzdW1lLCBOVUxMKQoKV2h5IGNhbid0IHlvdSB1 c2UgdWZzaGNkIFBNIG9wcyBhcyBsaWtlIG90aGVyIHZlbmRvciBkcml2ZXJzPwoKPiArCS5wcmVw YXJlCSA9IHVmc2hjZF9zdXNwZW5kX3ByZXBhcmUsCj4gKwkuY29tcGxldGUJID0gdWZzaGNkX3Jl c3VtZV9jb21wbGV0ZSwKPiArfTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVy IHVmc19yb2NrY2hpcF9wbHRmb3JtID0gewo+ICsJLnByb2JlID0gdWZzX3JvY2tjaGlwX3Byb2Jl LAo+ICsJLnJlbW92ZSA9IHVmc19yb2NrY2hpcF9yZW1vdmUsCj4gKwkuZHJpdmVyID0gewo+ICsJ CS5uYW1lID0gInVmc2hjZC1yb2NrY2hpcCIsCj4gKwkJLnBtID0gJnVmc19yb2NrY2hpcF9wbV9v cHMsCj4gKwkJLm9mX21hdGNoX3RhYmxlID0gdWZzX3JvY2tjaGlwX29mX21hdGNoLAo+ICsJfSwK PiArfTsKPiArbW9kdWxlX3BsYXRmb3JtX2RyaXZlcih1ZnNfcm9ja2NoaXBfcGx0Zm9ybSk7Cj4g Kwo+ICtNT0RVTEVfTElDRU5TRSgiR1BMIik7Cj4gK01PRFVMRV9ERVNDUklQVElPTigiUm9ja2No aXAgVUZTIEhvc3QgRHJpdmVyIik7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdWZzL2hvc3QvdWZz LXJvY2tjaGlwLmggYi9kcml2ZXJzL3Vmcy9ob3N0L3Vmcy1yb2NrY2hpcC5oCj4gbmV3IGZpbGUg bW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwLi45ZWI4MGU4Cj4gLS0tIC9kZXYvbnVsbAo+ICsr KyBiL2RyaXZlcnMvdWZzL2hvc3QvdWZzLXJvY2tjaGlwLmgKPiBAQCAtMCwwICsxLDUxIEBACj4g Ky8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkgKi8KPiArLyoKPiArICog Um9ja2NoaXAgVUZTIEhvc3QgQ29udHJvbGxlciBkcml2ZXIKPiArICoKPiArICogQ29weXJpZ2h0 IChDKSAyMDI0IFJvY2tjaGlwIEVsZWN0cm9uaWNzIENvLkx0ZC4KPiArICovCj4gKwo+ICsjaWZu ZGVmIF9VRlNfUk9DS0NISVBfSF8KPiArI2RlZmluZSBfVUZTX1JPQ0tDSElQX0hfCj4gKwo+ICsj ZGVmaW5lIFVGU19NQVhfQ0xLUyAzCj4gKwo+ICsjZGVmaW5lIFNFTF9UWF9MQU5FMCAweDAKPiAr I2RlZmluZSBTRUxfVFhfTEFORTEgMHgxCj4gKyNkZWZpbmUgU0VMX1RYX0xBTkUyIDB4Mgo+ICsj ZGVmaW5lIFNFTF9UWF9MQU5FMyAweDMKPiArI2RlZmluZSBTRUxfUlhfTEFORTAgMHg0Cj4gKyNk ZWZpbmUgU0VMX1JYX0xBTkUxIDB4NQo+ICsjZGVmaW5lIFNFTF9SWF9MQU5FMiAweDYKPiArI2Rl ZmluZSBTRUxfUlhfTEFORTMgMHg3Cj4gKwo+ICsjZGVmaW5lIE1JQl9UX0RCR19DUE9SVF9UWF9F TkRJQU4JMHhjMDIyCj4gKyNkZWZpbmUgTUlCX1RfREJHX0NQT1JUX1JYX0VORElBTgkweGMwMjMK PiArCj4gK3N0cnVjdCB1ZnNfcm9ja2NoaXBfaG9zdCB7Cj4gKwlzdHJ1Y3QgdWZzX2hiYSAqaGJh Owo+ICsJdm9pZCBfX2lvbWVtICp1ZnNfcGh5X2N0cmw7Cj4gKwl2b2lkIF9faW9tZW0gKnVmc19z eXNfY3RybDsKPiArCXZvaWQgX19pb21lbSAqbXBoeV9iYXNlOwo+ICsJc3RydWN0IGdwaW9fZGVz YyAqcnN0X2dwaW87Cj4gKwlzdHJ1Y3QgcmVzZXRfY29udHJvbCAqcnN0Owo+ICsJc3RydWN0IGNs ayAqcmVmX291dF9jbGs7Cj4gKwlzdHJ1Y3QgY2xrX2J1bGtfZGF0YSBjbGtzW1VGU19NQVhfQ0xL U107Cj4gKwl1aW50NjRfdCBjYXBzOwo+ICsJYm9vbCBpbl9zdXNwZW5kOwoKTW92ZSBib29sIHRv IHRoZSBlbmQgdG8gYXZvaWQgaG9sZXMuCgotIE1hbmkKCi0tIArgrq7grqPgrr/grrXgrqPgr43g rqPgrqngr40g4K6a4K6k4K6+4K6a4K6/4K614K6u4K+NCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51eC1yb2NrY2hpcCBtYWlsaW5nIGxpc3QKTGlu dXgtcm9ja2NoaXBAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJvY2tjaGlwCg== From mboxrd@z Thu Jan 1 00:00:00 1970 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 6B03016C6B0 for ; Fri, 9 Aug 2024 06:28:22 +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=1723184904; cv=none; b=KRXUGMDuFI2w+DkgMvxdlTOEPgioT4Tq8Pw+CjmgJ5Hu6Xduot8Uho7FPrKiYXASBtPdmwE62Ty1CCelCSjOVO3TQ9QS+HATFMlN8BlmRhKd/D6LjCTmKXGMkQ2xxJuQ0RD72PeOGCP98CvgVegw9aglN8ZQy1gPmbJHyANHMtY= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1723184904; c=relaxed/simple; bh=k36dnBFZIeLBvQIBC1qpxq5W5ItsDC7kxBApVOMKWso=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=CYd7ljhlEkJZJJzzVH9vErVsXYrFJpvroSt008DvCPL6HHI38moUbxxyCS443a1YraLHGGSc1KBvCMDpvK472EszcUyExMUcEsDJg63ikNCfDPhCaxZZhcYOhDmAB2UmEkqOaEuudYhG8BeAEG6qQGJSpo9FngU/FLDIIy1G1xo= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org; spf=pass smtp.mailfrom=linaro.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b=hqeZ2Mz3; arc=none smtp.client-ip=209.85.214.177 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linaro.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="hqeZ2Mz3" Received: by mail-pl1-f177.google.com with SMTP id d9443c01a7336-1fc491f9b55so14703095ad.3 for ; Thu, 08 Aug 2024 23:28:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1723184902; x=1723789702; darn=vger.kernel.org; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date:from:to :cc:subject:date:message-id:reply-to; bh=ZIb81mdm3Y+W7n5dTfDQvbXoixCEejMCmdPndqcOSy0=; b=hqeZ2Mz3DfKSYDydAsR4B6seyUMoFqP3cbAXx4rMfgBRQz/X11fIFajqvUzSA27OVY qfudlnKoGCqDMWbSWn/g3EFQaREnA+T4XodpImsh2xqZjpAe6ho29hzT4myXIZbqeN/p L9XY/cS6uw44d6nxZfCy9TNhPQB6VcPgcMv5N+brkGnVFdfJFt1U/ANnnqLNpburbjYU 9lww+yFlJjfbLbJyNlvkWz6lhelFxQJg8x4nSN57uiypJ2H4Bo3gpoCnrjLwTyKvHQTX 4e6dO5V4TZXcaL3wcc9JwQdDhHOugrTzen3KcLHcV/23RZQ8fCoFr8e9XId0VTx7u4Yt 0JXQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1723184902; x=1723789702; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=ZIb81mdm3Y+W7n5dTfDQvbXoixCEejMCmdPndqcOSy0=; b=mEH3hsl7HCNisGmShWkAUXGjZF1ErfWubGJOw+toO7ZLiHiLITV4H8nCj+mhHiDUMf 4NSuYdqT3Ha+8zJ3IAGcrjsylEdKbfTKvBb/136Ezwo6Xcw41ileD8ZVKPTUs+XX77jb 69ntQuq6rs8pf1fUL/NUdroJIpKSs8eN+kUldk9hn/oFcDqh+VFbMcwC1HhBSe1KnTWY kn7wg0DWoPUeX4EyqhnqBLhubnFKZXiDLUsMJ7YKdJBcHJVgufUgNVIC+ld07RqwK+9Q 0g9mxb5lUa19BRH8TETsMRHQVeQS3rG1EyoHZCKkultkGQ8ZBVzuRkZcq28uj2hhgSYz RYdA== X-Forwarded-Encrypted: i=1; AJvYcCWRw2NvCvSDPJnahxamM/4FJcT97kTXh8YB8tt8WC/E574zgzqgDoBYZ6UPRP4jz1jD3kAUdIR0SAVRGYIor+p9nV3sMTs8KCMJGA== X-Gm-Message-State: AOJu0Yx22WRlSQOyUtXTGsZvopqgHUcj5E09RXOMWsj6sqK8Q1A/T8Tc gLjBl072mF90EhFjYmpgxy8Tl9VoUDC4xay5ZCJbJbiI5NsVvnFzJnhS+AfxeQ== X-Google-Smtp-Source: AGHT+IGsasHpV/b0wZ6hW5jBeHdTPZmWl2BTJu2ASUcJUsUFz15Ge+CsJmrwMOugSuJO5MJnkscfGQ== X-Received: by 2002:a17:902:f68c:b0:1fb:6e06:a099 with SMTP id d9443c01a7336-200ae5ce2c7mr5006435ad.40.1723184901711; Thu, 08 Aug 2024 23:28:21 -0700 (PDT) Received: from thinkpad ([117.213.100.70]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-1ff5916eaffsm134860975ad.194.2024.08.08.23.28.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 08 Aug 2024 23:28:21 -0700 (PDT) Date: Fri, 9 Aug 2024 11:58:13 +0530 From: Manivannan Sadhasivam To: Shawn Lin Cc: Rob Herring , "James E . J . Bottomley" , "Martin K . Petersen" , Krzysztof Kozlowski , Conor Dooley , Heiko Stuebner , Alim Akhtar , Avri Altman , Bart Van Assche , YiFeng Zhao , Liang Chen , linux-scsi@vger.kernel.org, linux-rockchip@lists.infradead.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org Subject: Re: [PATCH v2 3/3] scsi: ufs: rockchip: init support for UFS Message-ID: <20240809062813.GC2826@thinkpad> References: <1723089163-28983-1-git-send-email-shawn.lin@rock-chips.com> <1723089163-28983-4-git-send-email-shawn.lin@rock-chips.com> Precedence: bulk X-Mailing-List: linux-scsi@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: <1723089163-28983-4-git-send-email-shawn.lin@rock-chips.com> On Thu, Aug 08, 2024 at 11:52:43AM +0800, Shawn Lin wrote: > RK3576 contains a UFS controller, add init support fot it. > This description is very simple. Please add more info like the UFSHCD version, lane config, quirks and any other vendor specific difference. > Signed-off-by: Shawn Lin > > --- > > Changes in v2: > - use dev_probe_err > - remove ufs-phy-config-mode as it's not used > - drop of_match_ptr > > drivers/ufs/host/Kconfig | 12 ++ > drivers/ufs/host/Makefile | 1 + > drivers/ufs/host/ufs-rockchip.c | 438 ++++++++++++++++++++++++++++++++++++++++ > drivers/ufs/host/ufs-rockchip.h | 51 +++++ > 4 files changed, 502 insertions(+) > create mode 100644 drivers/ufs/host/ufs-rockchip.c > create mode 100644 drivers/ufs/host/ufs-rockchip.h > > diff --git a/drivers/ufs/host/Kconfig b/drivers/ufs/host/Kconfig > index 580c8d0..fafaa33 100644 > --- a/drivers/ufs/host/Kconfig > +++ b/drivers/ufs/host/Kconfig > @@ -142,3 +142,15 @@ config SCSI_UFS_SPRD > > Select this if you have UFS controller on Unisoc chipset. > If unsure, say N. > + > +config SCSI_UFS_ROCKCHIP > + tristate "Rockchip specific hooks to UFS controller platform driver" > + depends on SCSI_UFSHCD_PLATFORM && (ARCH_ROCKCHIP || COMPILE_TEST) > + help > + This selects the Rockchip specific additions to UFSHCD platform driver. > + UFS host on Rockchip needs some vendor specific configuration before > + accessing the hardware which includes PHY configuration and vendor > + specific registers. > + > + Select this if you have UFS controller on Rockchip chipset. > + If unsure, say N. > diff --git a/drivers/ufs/host/Makefile b/drivers/ufs/host/Makefile > index 4573aea..2f97feb 100644 > --- a/drivers/ufs/host/Makefile > +++ b/drivers/ufs/host/Makefile > @@ -10,5 +10,6 @@ obj-$(CONFIG_SCSI_UFSHCD_PLATFORM) += ufshcd-pltfrm.o > obj-$(CONFIG_SCSI_UFS_HISI) += ufs-hisi.o > obj-$(CONFIG_SCSI_UFS_MEDIATEK) += ufs-mediatek.o > obj-$(CONFIG_SCSI_UFS_RENESAS) += ufs-renesas.o > +obj-$(CONFIG_SCSI_UFS_ROCKCHIP) += ufs-rockchip.o > obj-$(CONFIG_SCSI_UFS_SPRD) += ufs-sprd.o > obj-$(CONFIG_SCSI_UFS_TI_J721E) += ti-j721e-ufs.o > diff --git a/drivers/ufs/host/ufs-rockchip.c b/drivers/ufs/host/ufs-rockchip.c > new file mode 100644 > index 0000000..46c90d6 > --- /dev/null > +++ b/drivers/ufs/host/ufs-rockchip.c > @@ -0,0 +1,438 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * Rockchip UFS Host Controller driver > + * > + * Copyright (C) 2024 Rockchip Electronics Co.Ltd. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include "ufshcd-pltfrm.h" > +#include "ufshcd-dwc.h" > +#include "ufs-rockchip.h" > + > +static inline bool ufshcd_is_device_present(struct ufs_hba *hba) No inline in .c file please. > +{ > + return ufshcd_readl(hba, REG_CONTROLLER_STATUS) & DEVICE_PRESENT; > +} > + > +static int ufs_rockchip_hce_enable_notify(struct ufs_hba *hba, > + enum ufs_notify_change_status status) > +{ > + int err = 0; > + > + if (status == PRE_CHANGE) { > + int retry_outer = 3; > + int retry_inner; > +start: > + if (ufshcd_is_hba_active(hba)) > + /* change controller state to "reset state" */ > + ufshcd_hba_stop(hba); > + > + /* UniPro link is disabled at this point */ > + ufshcd_set_link_off(hba); > + > + /* start controller initialization sequence */ > + ufshcd_writel(hba, CONTROLLER_ENABLE, REG_CONTROLLER_ENABLE); > + > + usleep_range(100, 200); > + > + /* wait for the host controller to complete initialization */ > + retry_inner = 50; > + while (!ufshcd_is_hba_active(hba)) { > + if (retry_inner) { > + retry_inner--; > + } else { > + dev_err(hba->dev, > + "Controller enable failed\n"); > + if (retry_outer) { > + retry_outer--; > + goto start; > + } > + return -EIO; > + } > + usleep_range(1000, 1100); > + } You just duplicated ufshcd_hba_execute_hce() here. Why? This doesn't make sense. > + } else { /* POST_CHANGE */ > + err = ufshcd_vops_phy_initialization(hba); > + } > + > + return err; > +} > + > +static void ufs_rockchip_set_pm_lvl(struct ufs_hba *hba) > +{ > + hba->rpm_lvl = UFS_PM_LVL_1; > + hba->spm_lvl = UFS_PM_LVL_3; > +} > + > +static int ufs_rockchip_rk3576_phy_init(struct ufs_hba *hba) > +{ > + struct ufs_rockchip_host *host = ufshcd_get_variant(hba); > + > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(PA_LOCAL_TX_LCC_ENABLE, 0x0), 0x0); > + /* enable the mphy DME_SET cfg */ > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x200, 0x0), 0x40); > + for (int i = 0; i < 2; i++) { > + /* Configuration M-TX */ > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0xaa, SEL_TX_LANE0 + i), 0x06); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0xa9, SEL_TX_LANE0 + i), 0x02); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0xad, SEL_TX_LANE0 + i), 0x44); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0xac, SEL_TX_LANE0 + i), 0xe6); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0xab, SEL_TX_LANE0 + i), 0x07); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x94, SEL_TX_LANE0 + i), 0x93); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x93, SEL_TX_LANE0 + i), 0xc9); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x7f, SEL_TX_LANE0 + i), 0x00); > + /* Configuration M-RX */ > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x12, SEL_RX_LANE0 + i), 0x06); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x11, SEL_RX_LANE0 + i), 0x00); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x1d, SEL_RX_LANE0 + i), 0x58); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x1c, SEL_RX_LANE0 + i), 0x8c); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x1b, SEL_RX_LANE0 + i), 0x02); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x25, SEL_RX_LANE0 + i), 0xf6); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x2f, SEL_RX_LANE0 + i), 0x69); > + } > + /* disable the mphy DME_SET cfg */ > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(0x200, 0x0), 0x00); > + > + ufs_sys_writel(host->mphy_base, 0x80, 0x08C); > + ufs_sys_writel(host->mphy_base, 0xB5, 0x110); > + ufs_sys_writel(host->mphy_base, 0xB5, 0x250); > + Why can't you do these settings in a PHY driver? > + ufs_sys_writel(host->mphy_base, 0x03, 0x134); > + ufs_sys_writel(host->mphy_base, 0x03, 0x274); > + > + ufs_sys_writel(host->mphy_base, 0x38, 0x0E0); > + ufs_sys_writel(host->mphy_base, 0x38, 0x220); > + > + ufs_sys_writel(host->mphy_base, 0x50, 0x164); > + ufs_sys_writel(host->mphy_base, 0x50, 0x2A4); > + > + ufs_sys_writel(host->mphy_base, 0x80, 0x178); > + ufs_sys_writel(host->mphy_base, 0x80, 0x2B8); > + > + ufs_sys_writel(host->mphy_base, 0x18, 0x1B0); > + ufs_sys_writel(host->mphy_base, 0x18, 0x2F0); > + > + ufs_sys_writel(host->mphy_base, 0x03, 0x128); > + ufs_sys_writel(host->mphy_base, 0x03, 0x268); > + > + ufs_sys_writel(host->mphy_base, 0x20, 0x12C); > + ufs_sys_writel(host->mphy_base, 0x20, 0x26C); > + > + ufs_sys_writel(host->mphy_base, 0xC0, 0x120); > + ufs_sys_writel(host->mphy_base, 0xC0, 0x260); > + > + ufs_sys_writel(host->mphy_base, 0x03, 0x094); > + > + ufs_sys_writel(host->mphy_base, 0x03, 0x1B4); > + ufs_sys_writel(host->mphy_base, 0x03, 0x2F4); > + > + ufs_sys_writel(host->mphy_base, 0xC0, 0x08C); > + udelay(1); > + ufs_sys_writel(host->mphy_base, 0x00, 0x08C); > + > + udelay(200); > + /* start link up */ > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(MIB_T_DBG_CPORT_TX_ENDIAN, 0), 0x0); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(MIB_T_DBG_CPORT_RX_ENDIAN, 0), 0x0); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(N_DEVICEID, 0), 0x0); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(N_DEVICEID_VALID, 0), 0x1); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(T_PEERDEVICEID, 0), 0x1); > + ufshcd_dme_set(hba, UIC_ARG_MIB_SEL(T_CONNECTIONSTATE, 0), 0x1); > + > + return 0; > +} > + > +static int ufs_rockchip_common_init(struct ufs_hba *hba) > +{ > + struct device *dev = hba->dev; > + struct platform_device *pdev = to_platform_device(dev); > + struct ufs_rockchip_host *host; > + int err = 0; > + > + host = devm_kzalloc(dev, sizeof(*host), GFP_KERNEL); > + if (!host) > + return -ENOMEM; > + > + /* system control register for hci */ > + host->ufs_sys_ctrl = devm_platform_ioremap_resource_byname(pdev, "hci_grf"); > + if (IS_ERR(host->ufs_sys_ctrl)) > + return dev_err_probe(dev, PTR_ERR(host->ufs_sys_ctrl), > + "cannot ioremap for hci system control register\n"); > + > + /* system control register for mphy */ > + host->ufs_phy_ctrl = devm_platform_ioremap_resource_byname(pdev, "mphy_grf"); > + if (IS_ERR(host->ufs_phy_ctrl)) > + return dev_err_probe(dev, PTR_ERR(host->ufs_phy_ctrl), > + "cannot ioremap for mphy system control register\n"); > + > + /* mphy base register */ > + host->mphy_base = devm_platform_ioremap_resource_byname(pdev, "mphy"); > + if (IS_ERR(host->mphy_base)) > + return dev_err_probe(dev, PTR_ERR(host->mphy_base), > + "cannot ioremap for mphy base register\n"); > + > + host->rst = devm_reset_control_array_get_exclusive(dev); > + if (IS_ERR(host->rst)) > + return dev_err_probe(dev, PTR_ERR(host->rst), "failed to get reset control\n"); > + > + reset_control_assert(host->rst); > + udelay(1); > + reset_control_deassert(host->rst); > + > + host->ref_out_clk = devm_clk_get(dev, "ref_out"); > + if (IS_ERR(host->ref_out_clk)) > + return dev_err_probe(dev, PTR_ERR(host->ref_out_clk), "ciu-drive not available\n"); What is 'ciu-drive'? > + > + err = clk_prepare_enable(host->ref_out_clk); > + if (err) > + return dev_err_probe(dev, err, "failed to enable ref out clock\n"); > + > + host->rst_gpio = devm_gpiod_get(&pdev->dev, "reset", GPIOD_OUT_LOW); > + if (IS_ERR(host->rst_gpio)) { > + dev_err_probe(&pdev->dev, PTR_ERR(host->rst_gpio), > + "invalid reset-gpios property in node\n"); > + err = PTR_ERR(host->rst_gpio); Krzysztof already pointed out this. > + goto out; > + } > + udelay(20); > + gpiod_set_value_cansleep(host->rst_gpio, 1); Why do you need to assert device reset here? ufshcd driver will do it anyway. > + > + host->clks[0].id = "core"; > + host->clks[1].id = "pclk"; > + host->clks[2].id = "pclk_mphy"; > + err = devm_clk_bulk_get_optional(dev, UFS_MAX_CLKS, host->clks); > + if (err) { > + dev_err_probe(dev, err, "failed to get clocks\n"); > + goto out; > + } > + > + err = clk_bulk_prepare_enable(UFS_MAX_CLKS, host->clks); > + if (err) { > + dev_err_probe(dev, err, "failed to enable clocks\n"); > + goto out; > + } > + > + pm_runtime_set_active(&pdev->dev); This is already called in ufshcd_pltfrm_init(). > + > + host->hba = hba; > + ufs_rockchip_set_pm_lvl(hba); > + > + ufshcd_set_variant(hba, host); > + > + return 0; > +out: s/out/disable_ref_clk > + clk_disable_unprepare(host->ref_out_clk); > + return err; > +} > + > +static int ufs_rockchip_rk3576_init(struct ufs_hba *hba) > +{ > + int ret = 0; Initialization not needed. > + struct device *dev = hba->dev; > + Also reverse Xmas order for local variables please. > + hba->quirks = UFSHCI_QUIRK_BROKEN_HCE | UFSHCD_QUIRK_SKIP_DEF_UNIPRO_TIMEOUT_SETTING; > + > + /* Enable BKOPS when suspend */ > + hba->caps |= UFSHCD_CAP_AUTO_BKOPS_SUSPEND; > + /* Enable putting device into deep sleep */ > + hba->caps |= UFSHCD_CAP_DEEPSLEEP; > + /* Enable devfreq of UFS */ > + hba->caps |= UFSHCD_CAP_CLK_SCALING; > + /* Enable WriteBooster */ > + hba->caps |= UFSHCD_CAP_WB_EN; > + > + ret = ufs_rockchip_common_init(hba); > + if (ret) > + return dev_err_probe(dev, ret, "ufs common init fail\n"); > + > + return 0; > +} > + > +static int ufs_rockchip_device_reset(struct ufs_hba *hba) > +{ > + struct ufs_rockchip_host *host = ufshcd_get_variant(hba); > + > + if (!host->rst_gpio) > + return -EOPNOTSUPP; Is it possible to hit this condition? > + > + gpiod_set_value_cansleep(host->rst_gpio, 0); > + udelay(20); > + > + gpiod_set_value_cansleep(host->rst_gpio, 1); > + udelay(20); > + > + return 0; > +} > + > +static const struct ufs_hba_variant_ops ufs_hba_rk3576_vops = { > + .name = "rk3576", > + .init = ufs_rockchip_rk3576_init, > + .device_reset = ufs_rockchip_device_reset, > + .hce_enable_notify = ufs_rockchip_hce_enable_notify, > + .phy_initialization = ufs_rockchip_rk3576_phy_init, > +}; > + > +static const struct of_device_id ufs_rockchip_of_match[] = { > + { .compatible = "rockchip,rk3576-ufs", .data = &ufs_hba_rk3576_vops}, Use 'rockchip,rk3576-ufshc'. > + {}, > +}; > +MODULE_DEVICE_TABLE(of, ufs_rockchip_of_match); > + > +static int ufs_rockchip_probe(struct platform_device *pdev) > +{ > + int err = 0; Again no init needed and use reverse Xmas order (everywhere). > + struct device *dev = &pdev->dev; > + const struct ufs_hba_variant_ops *vops; > + > + vops = device_get_match_data(dev); Is it OK if vops is NULL? > + err = ufshcd_pltfrm_init(pdev, vops); > + if (err) > + dev_err_probe(dev, err, "ufshcd_pltfrm_init failed\n"); Return err here and return 0 below. > + > + return err; > +} > + [...] > +static const struct dev_pm_ops ufs_rockchip_pm_ops = { > + SET_SYSTEM_SLEEP_PM_OPS(ufs_rockchip_suspend, ufs_rockchip_resume) > + SET_RUNTIME_PM_OPS(ufs_rockchip_runtime_suspend, ufs_rockchip_runtime_resume, NULL) Why can't you use ufshcd PM ops as like other vendor drivers? > + .prepare = ufshcd_suspend_prepare, > + .complete = ufshcd_resume_complete, > +}; > + > +static struct platform_driver ufs_rockchip_pltform = { > + .probe = ufs_rockchip_probe, > + .remove = ufs_rockchip_remove, > + .driver = { > + .name = "ufshcd-rockchip", > + .pm = &ufs_rockchip_pm_ops, > + .of_match_table = ufs_rockchip_of_match, > + }, > +}; > +module_platform_driver(ufs_rockchip_pltform); > + > +MODULE_LICENSE("GPL"); > +MODULE_DESCRIPTION("Rockchip UFS Host Driver"); > diff --git a/drivers/ufs/host/ufs-rockchip.h b/drivers/ufs/host/ufs-rockchip.h > new file mode 100644 > index 0000000..9eb80e8 > --- /dev/null > +++ b/drivers/ufs/host/ufs-rockchip.h > @@ -0,0 +1,51 @@ > +/* SPDX-License-Identifier: GPL-2.0-only */ > +/* > + * Rockchip UFS Host Controller driver > + * > + * Copyright (C) 2024 Rockchip Electronics Co.Ltd. > + */ > + > +#ifndef _UFS_ROCKCHIP_H_ > +#define _UFS_ROCKCHIP_H_ > + > +#define UFS_MAX_CLKS 3 > + > +#define SEL_TX_LANE0 0x0 > +#define SEL_TX_LANE1 0x1 > +#define SEL_TX_LANE2 0x2 > +#define SEL_TX_LANE3 0x3 > +#define SEL_RX_LANE0 0x4 > +#define SEL_RX_LANE1 0x5 > +#define SEL_RX_LANE2 0x6 > +#define SEL_RX_LANE3 0x7 > + > +#define MIB_T_DBG_CPORT_TX_ENDIAN 0xc022 > +#define MIB_T_DBG_CPORT_RX_ENDIAN 0xc023 > + > +struct ufs_rockchip_host { > + struct ufs_hba *hba; > + void __iomem *ufs_phy_ctrl; > + void __iomem *ufs_sys_ctrl; > + void __iomem *mphy_base; > + struct gpio_desc *rst_gpio; > + struct reset_control *rst; > + struct clk *ref_out_clk; > + struct clk_bulk_data clks[UFS_MAX_CLKS]; > + uint64_t caps; > + bool in_suspend; Move bool to the end to avoid holes. - Mani -- மணிவண்ணன் சதாசிவம்