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 2338CC624D0 for ; Wed, 2 Sep 2026 03:32:26 +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:MIME-Version:Reply-To:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:Message-Id:Date: References:In-Reply-To:Cc:To:Subject:From:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=SFNPbdU7A0sxPjp0WRNHiJBXsq3VLOki7yE+RkyVqDk=; b=EgiU+hnKpP5LcD WplWi/pi0LJvH6cikOf5tgvtIKMEF1610N53xSEIpEOgSDhtLcvAJ8wXpc1rGgh5Kn/84qRYw+Rhw pa6LTO0zJdPvzg4jEnyC7xoXR8CIip/sGgvtbbBLoE/qBZfKcuZKDOBq5DhK9dWUbbhAzLokZDCBR lXTvPzbefVndG7rgA0NRj9vX5d+kLadyZGp+ubvc7wOtDBffXzPeubA6VHXx+hH9OpwExhoSBxNTd U9SwRNXf59El52AjeSAs43xSQ7eXDgCKcgYmfGt8rIGHUFAXVZNZBzs0gemcZ0bqLSqwfIV0Zb0dT m34gviTo4YAvHOoMWC5w==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1x1bi5-0000000Dj51-3Qrf; Wed, 02 Sep 2026 03:32:25 +0000 Received: from sea.source.kernel.org ([172.234.252.31]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1x1bi4-0000000Dj4q-1T7M for linux-phy@lists.infradead.org; Wed, 02 Sep 2026 03:32:24 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 5D6CE43BCD; Wed, 2 Sep 2026 03:32:23 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id CA24A1F000E9; Wed, 2 Sep 2026 03:32:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788319943; bh=uEhLsjX4mcPRU4LShL1Gu6TdGWkkCFUPfe8iS/HC7oE=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=RszOs/CeAmAC7YIyLp9uDmOfTuSktR6ONfR3zrqT2MAm3Lt1qau4QXAMoC0ce4Igk vSRp3ZKdyQurhL8qUrrs67hPuXo5V359/CIpmr8l0thLKWp1WA4DneC3v5iWQ1VsCC xrFIj240gWCiLsvmUAyxNj3vNwm5oofDXVXHxZkf3D/KX/jz+aR2HkeQzk7naBZVzN wQeQp16VeKaPzj5KNcZIvJI5AO/76E4iUhwn2vvjHyLEfyUTQqej52oUiPrN+BJ5cw Uis8fQi3dOe2L542Y66Dj6yeypD2S35tK0JqcuNjlV3cQAZB0XRO7X6ta2I3We2bhg B2Zt7TvPYrqgA== From: sashiko-bot@kernel.org Subject: Re: [PATCH v2 4/5] usb: cdns3: Add CIX Sky1 glue driver To: "Hongliang Yang" Cc: vkoul@kernel.org, linux-phy@lists.infradead.org, olteanv@gmail.com, robh@kernel.org, devicetree@vger.kernel.org, conor+dt@kernel.org, neil.armstrong@linaro.org In-Reply-To: <20260902032134.1182634-5-hongliang.yang@cixtech.com> References: <20260831082309.3854507-1-hongliang.yang@cixtech.com> <20260902032134.1182634-5-hongliang.yang@cixtech.com> Date: Wed, 02 Sep 2026 03:32:22 +0000 Message-Id: <20260902033222.CA24A1F000E9@smtp.kernel.org> X-BeenThere: linux-phy@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux Phy Mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: sashiko-reviews@lists.linux.dev MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-phy" Errors-To: linux-phy-bounces+linux-phy=archiver.kernel.org@lists.infradead.org VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg MTAgcG90ZW50aWFsIGlzc3VlKHMpIHRvIGNvbnNpZGVyOgotIFtIaWdoXSBNYXNzaXZlIHJlc291 cmNlIGxlYWsgb24gcHJvYmUgZXJyb3IgcGF0aHMgKEkvTyBtZW1vcnksIGNsb2NrcywgYW5kIHJl c2V0cykuCi0gW0hpZ2hdIFRocmVhZC1zYWZldHkgYW5kIGRvdWJsZS1mcmVlIHZ1bG5lcmFiaWxp dHkgZHVlIHRvIG1vZGlmeWluZyBhIHN0YXRpYyBnbG9iYWwgb2ZfZGV2X2F1eGRhdGEgYXJyYXkg ZHVyaW5nIHByb2JlLgotIFtIaWdoXSBVbmJhbGFuY2VkIHJ1bnRpbWUgUE0gdXNhZ2UgY291bnQg YW5kIG1pc3NpbmcgUE0gZGlzYWJsZSBpbiBjZG5zcF9za3kxX3JlbW92ZS4KLSBbSGlnaF0gSW5j b3JyZWN0IHJlc2V0IGNvbnRyb2wgYXNzZXJ0aW9uIGxvZ2ljIGluIHJlbW92ZSBwYXRoIGZhaWxz IHRvIHF1aWVzY2UgaGFyZHdhcmUuCi0gW0hpZ2hdIE5VTEwgcG9pbnRlciBkZXJlZmVyZW5jZSB3 aGVuIGFjY2Vzc2luZyB4aGNpX2Rldi0+ZGV2IGluIHBsYXRmb3JtX3N1c3BlbmQuCi0gW01lZGl1 bV0gT0Ygbm9kZSByZWZlcmVuY2UgbGVhayBpbiBza3kxX29mX2dldF9hZGRyX2J5X25hbWUoKSBi ZWNhdXNlIHRoZSByZWZlcmVuY2Ugb2J0YWluZWQgYnkgb2ZfZ2V0X25leHRfY2hpbGQoKSBpcyBu ZXZlciByZWxlYXNlZC4KLSBbTWVkaXVtXSBEZXN0cnVjdGl2ZSBlcnJvciBoYW5kbGluZyBpbiBj ZG5zcF9za3kxX2Nsa19lbmFibGVfcmVzdW1lIGNvcnJ1cHRzIGludGVybmFsIGNsb2NrIHBvaW50 ZXJzLgotIFtNZWRpdW1dIFBvdGVudGlhbCBVc2UtQWZ0ZXItRnJlZSAoVUFGKSBkdWUgdG8gbWlz c2luZyBkZXZpY2UgcmVmY291bnRpbmcgaW4gaXRlcmF0b3IgY2FsbGJhY2tzIGR1cmluZyBzaHV0 ZG93bi4KLSBbTWVkaXVtXSBVbmRlZmluZWQgYmVoYXZpb3IgZHVlIHRvIGJpdHdpc2Ugc2hpZnQg aW50byB0aGUgc2lnbiBiaXQuCi0gW01lZGl1bV0gUE0gc3Vic3lzdGVtIGd1aWRlbGluZSB2aW9s YXRpb246IFBNIHNsZWVwIGNhbGxiYWNrcyBhcmUgYXNzaWduZWQgd2l0aG91dCB0aGUgcmVxdWly ZWQgcG1fc2xlZXBfcHRyKCkgd3JhcHBlci4KLS0KCmNvbW1pdCAwMjMyMzE4NDI2Y2ZmZTc5N2M2 MmE5MzY1MTExNjEwMWMzOTZlYmI0CkF1dGhvcjogSG9uZ2xpYW5nIFlhbmcgPGhvbmdsaWFuZy55 YW5nQGNpeHRlY2guY29tPgoKdXNiOiBjZG5zMzogQWRkIENJWCBTa3kxIGdsdWUgZHJpdmVyCgpU aGlzIGNvbW1pdCBhZGRzIGEgZ2x1ZSBsYXllciBkcml2ZXIgZm9yIHRoZSBDYWRlbmNlIFVTQlNT UCBjb250cm9sbGVyCmludGVncmF0ZWQgaW4gdGhlIENJWCBTa3kxIFNvQy4gVGhlIGRyaXZlciBt YW5hZ2VzIHRoZSBjb250cm9sbGVyIGNsb2NrcywKcmVzZXRzLCBhbmQgdGhlIG1vZGUgc3RyYXAg Y29udHJvbHMgbG9jYXRlZCBpbiB0aGUgU2t5MSBTNSBzeXN0ZW0KY29udHJvbGxlci4KCj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NkbnMzL2NkbnNwLXNreTEuYyBiL2RyaXZlcnMvdXNiL2Nk bnMzL2NkbnNwLXNreTEuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAw MDAwMC4uNDQ3YzY4M2I3MjZjMQo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL3VzYi9j ZG5zMy9jZG5zcC1za3kxLmMKClsgLi4uIF0KCj4gK3N0YXRpYyBpbnQgY2Ruc3Bfc2t5MV9jbGtf ZW5hYmxlX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCWludCBpLCByZXQ7Cj4g KwlzdHJ1Y3QgY2Ruc3Bfc2t5MSAqZGF0YSA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsJc3Ry dWN0IGNsayAqKmNpeF91c2JfY2xrcyA9IGRhdGEtPmNpeF91c2JfY2xrczsKPiArCj4gKwlmb3Ig KGkgPSAwOyBpIDwgQ0lYX1VTQl9DTEtfT0ZGX05VTTsgaSsrKSB7Cj4gKwkJcmV0ID0gY2xrX3By ZXBhcmVfZW5hYmxlKGNpeF91c2JfY2xrc1tpXSk7Cj4gKwkJaWYgKHJldCkgewo+ICsJCQlkZXZf ZXJyKGRldiwgImZhaWxlZCB0byBlbmFibGUgY2xvY2sgJXM6ICVkXG4iLAo+ICsJCQkJY2l4X3Vz Yl9jbGtfbmFtZXNbaV0sIHJldCk7Cj4gKwkJCWdvdG8gZXJyX3VzYl9jbGtzOwo+ICsJCX0KPiAr CX0KPiArCXJldHVybiAwOwo+ICsKPiArZXJyX3VzYl9jbGtzOgo+ICsJY2l4X3VzYl9jbGtzW2ld ID0gTlVMTDsKPiArCXdoaWxlICgtLWkgPj0gMCkgewo+ICsJCWNsa19kaXNhYmxlX3VucHJlcGFy ZShjaXhfdXNiX2Nsa3NbaV0pOwo+ICsJCWNpeF91c2JfY2xrc1tpXSA9IE5VTEw7Cj4gKwl9Cj4g KwlyZXR1cm4gcmV0Owo+ICt9OwoKW1NldmVyaXR5OiBNZWRpdW1dCkRvZXMgc2V0dGluZyBjaXhf dXNiX2Nsa3NbaV0gdG8gTlVMTCBoZXJlIHBlcm1hbmVudGx5IHdpcGUgdGhlIGRldm0tbWFuYWdl ZApjbG9jayByZWZlcmVuY2VzIGZyb20gdGhlIGRyaXZlcidzIHByaXZhdGUgc3RhdGU/IElmIGEg c3lzdGVtIGNsb2NrIGZhaWxzCnRvIHJlc3VtZSwgd29uJ3Qgc3Vic2VxdWVudCBjYWxscyB0byBl bmFibGUgb3IgZGlzYWJsZSB0aGVzZSBjbG9ja3MgcmVjZWl2ZQpOVUxMIHBvaW50ZXJzIGFuZCBz aWxlbnRseSBmYWlsIHRvIGNvbmZpZ3VyZSB0aGUgaGFyZHdhcmU/CgpbIC4uLiBdCgo+ICtzdGF0 aWMgaW50IGNkbnNfc2t5MV9wbGF0Zm9ybV9zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRldiwKPiAr CQkJCSAgICAgIGJvb2wgc3VzcGVuZCwgYm9vbCB3YWtldXApCj4gK3sKPiArCXN0cnVjdCBjZG5z ICpjZG5zID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4gKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNl ICp4aGNpX2RldiA9IGNkbnMtPmhvc3RfZGV2Owo+ICsJc3RydWN0IHVzYl9oY2QgICpoY2Q7Cj4g KwlzdHJ1Y3QgZGV2aWNlICpwYXJlbnQgPSBjZG5zLT5kZXYtPnBhcmVudDsKPiArCXN0cnVjdCBj ZG5zcF9za3kxICpkYXRhID0gZGV2X2dldF9kcnZkYXRhKHBhcmVudCk7Cj4gKwl1MzIgdmFsdWU7 Cj4gKwlpbnQgcmV0ID0gMDsKPiArCWludCBjb3VudCA9IDM7Cj4gKwo+ICsJZGF0YS0+d2FrZXVw ID0gd2FrZXVwOwo+ICsKPiArCWlmIChjZG5zLT5yb2xlICE9IFVTQl9ST0xFX0hPU1QpCj4gKwkJ cmV0dXJuIDA7Cj4gKwo+ICsJaGNkID0gZGV2X2dldF9kcnZkYXRhKCZ4aGNpX2Rldi0+ZGV2KTsK CltTZXZlcml0eTogSGlnaF0KQ291bGQgeGhjaV9kZXYgYmUgTlVMTCBpZiB0aGUgaG9zdCBpbml0 aWFsaXphdGlvbiBmYWlsZWQgb3Igd2FzIHVuYm91bmQ/CklmIHNvLCB3b3VsZCBhY2Nlc3Npbmcg JnhoY2lfZGV2LT5kZXYgbGVhZCB0byBhbiBvdXQtb2YtYm91bmRzIHBvaW50ZXIKZGVyZWZlcmVu Y2UgZHVyaW5nIHN5c3RlbSBzdXNwZW5kPwoKWyAuLi4gXQoKPiArc3RhdGljIHZvaWQgKnNreTFf b2ZfZ2V0X2FkZHJfYnlfbmFtZShzdHJ1Y3QgZGV2aWNlX25vZGUgKnBhcmVudCwgY2hhciAqbmFt ZSkKPiArewo+ICsJc3RydWN0IGRldmljZV9ub2RlICpub2RlOwo+ICsJaW50IGluZGV4Owo+ICsK PiArCW5vZGUgPSBvZl9nZXRfbmV4dF9jaGlsZChwYXJlbnQsIE5VTEwpOwo+ICsJaWYgKG5vZGUp IHsKPiArCQlpbmRleCA9IG9mX3Byb3BlcnR5X21hdGNoX3N0cmluZyhub2RlLCAicmVnLW5hbWVz IiwgbmFtZSk7Cj4gKwkJaWYgKGluZGV4ID49IDApCj4gKwkJCXJldHVybiBvZl9pb21hcChub2Rl LCBpbmRleCk7Cj4gKwl9Cj4gKwlyZXR1cm4gTlVMTDsKPiArfQoKW1NldmVyaXR5OiBNZWRpdW1d CkRvZXMgb2ZfZ2V0X25leHRfY2hpbGQoKSByZXR1cm4gdGhlIG5vZGUgd2l0aCBhbiBpbmNyZW1l bnRlZCByZWZlcmVuY2UgY291bnQ/ClNob3VsZCB0aGVyZSBiZSBhIGNhbGwgdG8gb2Zfbm9kZV9w dXQobm9kZSkgYmVmb3JlIHJldHVybmluZyB0byBwcmV2ZW50IGEKbWVtb3J5IGxlYWs/CgpbIC4u LiBdCgo+ICtzdGF0aWMgaW50IGNkbnNwX3NreTFfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rldmlj ZSAqcGRldikKPiArewo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKPiArCXN0 cnVjdCBkZXZpY2Vfbm9kZSAqbm9kZSA9IGRldi0+b2Zfbm9kZTsKPiArCXN0cnVjdCBjZG5zcF9z a3kxICpkYXRhOwo+ICsJaW50IHJldCA9IDA7Cj4gKwlzdHJ1Y3QgY2RuczNfcGxhdGZvcm1fZGF0 YSAqY2Ruc19za3kxX3BkYXRhOwoKWyAuLi4gXQoKPiArCXJldCA9IGNkbnNwX3NreTFfZHJkX2lu aXQoZGF0YSk7Cj4gKwlpZiAocmV0ID09IC1FVElNRURPVVQpCj4gKwkJcmV0dXJuIC1FUFJPQkVf REVGRVI7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7CgpbU2V2ZXJpdHk6IEhpZ2hdCklm IHByb2JlIGZhaWxzIGhlcmUgYW5kIHJldHVybnMgZGlyZWN0bHksIGFyZSB0aGUgSS9PIG1lbW9y eSBtYXBwaW5ncwpmb3IgeGhjaV9iYXNlIGFuZCBkZXZpY2VfYmFzZSAod2hpY2ggd2VyZSBtYXBw ZWQgdmlhIG5vbi1kZXZtIG9mX2lvbWFwKQpsZWZ0IGFjdGl2ZT8gU2hvdWxkIHRoZXkgYmUgdW5t YXBwZWQgYW5kIHRoZSBjbG9ja3MvcmVzZXRzIGNsZWFuZWQgdXA/CgpbIC4uLiBdCgo+ICsJLyog cmVsZWFzZSBieSBwbGF0Zm9ybV9kZXZpY2VfcmVsZWFzZSAqLwo+ICsJY2Ruc19za3kxX3BkYXRh ID0ga3phbGxvYyhzaXplb2YoKmNkbnNfc2t5MV9wZGF0YSksIEdGUF9LRVJORUwpOwo+ICsJaWYg KCFjZG5zX3NreTFfcGRhdGEpCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwljZG5zX3NreTFfcGRh dGEtPnBsYXRmb3JtX3N1c3BlbmQgPSBjZG5zX3NreTFfcGxhdGZvcm1fc3VzcGVuZDsKPiArCWNk bnNfc2t5MV9wZGF0YS0+cXVpcmtzID0gQ0ROUzNfREVGQVVMVF9QTV9SVU5USU1FX0FMTE9XOwo+ ICsJY2Ruc19za3kxX2F1eGRhdGEtPnBsYXRmb3JtX2RhdGEgPSBjZG5zX3NreTFfcGRhdGE7Cj4g KwlyZXQgPSBvZl9wbGF0Zm9ybV9wb3B1bGF0ZShub2RlLCBOVUxMLCBjZG5zX3NreTFfYXV4ZGF0 YSwgZGV2KTsKCltTZXZlcml0eTogSGlnaF0KSXMgaXQgc2FmZSB0byBhc3NpZ24gYSBkeW5hbWlj YWxseSBhbGxvY2F0ZWQgaW5zdGFuY2Utc3BlY2lmaWMgcG9pbnRlcgooY2Ruc19za3kxX3BkYXRh KSB0byB0aGUgc3RhdGljYWxseSBhbGxvY2F0ZWQgZ2xvYmFsIGFycmF5IGNkbnNfc2t5MV9hdXhk YXRhPwpDb3VsZCB0aGlzIGxlYWQgdG8gYSBkb3VibGUtZnJlZSB2dWxuZXJhYmlsaXR5IGlmIG11 bHRpcGxlIGNvbnRyb2xsZXIgaW5zdGFuY2VzCmV4aXN0IG9yIGlmIHRoZSBkcml2ZXIgaXMgcmVw ZWF0ZWRseSB1bmJvdW5kIGFuZCByZWJvdW5kPwoKPiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJy KGRldiwgImZhaWxlZCB0byBjcmVhdGUgY2hpbGRyZW46ICVkXG4iLCByZXQpOwo+ICsJCWdvdG8g ZXJyOwo+ICsJfQo+ICsJZGV2aWNlX3NldF93YWtldXBfY2FwYWJsZShkZXYsIHRydWUpOwo+ICsJ cG1fcnVudGltZV9zZXRfYWN0aXZlKGRldik7Cj4gKwlwbV9ydW50aW1lX2VuYWJsZShkZXYpOwo+ ICsJcmV0dXJuIDA7Cj4gK2VycjoKPiArCWtmcmVlKGNkbnNfc2t5MV9wZGF0YSk7Cj4gKwlyZXR1 cm4gcmV0Owo+ICt9CgpbU2V2ZXJpdHk6IEhpZ2hdCkRvZXMgdGhpcyBzaGFyZWQgZXJyb3IgcGF0 aCBmYWlsIHRvIGNsZWFuIHVwIHRoZSBJL08gbWVtb3J5IG1hcHBpbmdzLCBhc3NlcnQKcmVzZXRz LCBhbmQgZGlzYWJsZSBjbG9ja3MgYmVmb3JlIHJldHVybmluZz8KCj4gK3N0YXRpYyB2b2lkIGNk bnNwX3NreTFfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gK3sKPiArCXN0 cnVjdCBkZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7Cj4gKwlzdHJ1Y3QgY2Ruc3Bfc2t5MSAqZGF0 YSA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsKPiArCXBtX3J1bnRpbWVfZ2V0X3N5bmMoZGV2 KTsKPiArCW9mX3BsYXRmb3JtX2RlcG9wdWxhdGUoZGV2KTsKPiArCXNreTFfcHV0X2FkZHIoZGF0 YS0+eGhjaV9iYXNlKTsKPiArCXNreTFfcHV0X2FkZHIoZGF0YS0+ZGV2aWNlX2Jhc2UpOwo+ICsJ cmVzZXRfY29udHJvbF9kZWFzc2VydChkYXRhLT5yZXNldCk7Cj4gKwlyZXNldF9jb250cm9sX2Rl YXNzZXJ0KGRhdGEtPnByZXNldCk7CgpbU2V2ZXJpdHk6IEhpZ2hdClNob3VsZCB0aGVzZSBiZSBy ZXNldF9jb250cm9sX2Fzc2VydCgpIGluc3RlYWQgb2YgZGVhc3NlcnQoKSB0byBjb3JyZWN0bHkK cXVpZXNjZSB0aGUgaGFyZHdhcmUgYmVmb3JlIHRoZSBjbG9ja3MgYXJlIGRpc2FibGVkPwoKPiAr CWNkbnNwX3NreTFfY2xrX2Rpc2FibGVfYWxsKGRldik7Cj4gKwlwbGF0Zm9ybV9zZXRfZHJ2ZGF0 YShwZGV2LCBOVUxMKTsKPiArfQoKW1NldmVyaXR5OiBIaWdoXQpEb2VzIHRoaXMgZnVuY3Rpb24g bmVlZCB0byBjYWxsIHBtX3J1bnRpbWVfcHV0X3N5bmMoKSBhbmQgcG1fcnVudGltZV9kaXNhYmxl KCk/CkJlY2F1c2UgcG1fcnVudGltZV9nZXRfc3luYyhkZXYpIGluY3JlbWVudHMgdGhlIHVzYWdl IGNvdW50ZXIgYXQgdGhlIHN0YXJ0IG9mCnRoZSBmdW5jdGlvbiwgY291bGQgb21pdHRpbmcgdGhl IGRlY3JlbWVudCBsZWFkIHRvIGEgbGVha2VkIHVzYWdlIGNvdW50IGFuZCBhCmJyb2tlbiBQTSBz dGF0ZSBtYWNoaW5lIGZvciB0aGUgZGV2aWNlIG9uIHN1YnNlcXVlbnQgYmluZHM/CgpbIC4uLiBd Cgo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGRldl9wbV9vcHMgY2Ruc3Bfc2t5MV9wbV9vcHMgPSB7 Cj4gKwkuc3VzcGVuZCA9IGNkbnNwX3NreTFfc3lzdGVtX3N1c3BlbmQsCj4gKwkucmVzdW1lID0g Y2Ruc3Bfc2t5MV9zeXN0ZW1fcmVzdW1lLAo+ICt9OwoKW1NldmVyaXR5OiBNZWRpdW1dClNob3Vs ZCB0aGVzZSBzbGVlcCBjYWxsYmFja3MgYmUgd3JhcHBlZCB3aXRoIHBtX3NsZWVwX3B0cigpPyBX aXRob3V0IGl0LAppZiBDT05GSUdfUE0gaXMgZW5hYmxlZCBidXQgQ09ORklHX1BNX1NMRUVQIGlz IGRpc2FibGVkLCBjb3VsZCB0aGlzIGdlbmVyYXRlCmRlYWQgY29kZSB3YXJuaW5ncyBmb3IgdGhl IHN1c3BlbmQgYW5kIHJlc3VtZSBmdW5jdGlvbnM/CgpbIC4uLiBdCgo+ICtzdGF0aWMgdm9pZCBj ZG5zcF9za3kxX3NodXRkb3duKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gK3sKPiAr CXN0cnVjdCBkZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7Cj4gKwlzdHJ1Y3QgY2Ruc3Bfc2t5MSAq ZGF0YSA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsJc3RydWN0IGNkbnMgKmNkbnMgPSBOVUxM Owo+ICsJc3RydWN0IGRldmljZSAqZ2FkZ2V0X2RldiA9IE5VTEw7Cj4gKwo+ICsJaWYgKCFkZXZp Y2VfbWF5X3dha2V1cChkZXYpKSB7Cj4gKwkJLyoKPiArCQkgKiBGaW5kIHRoZSBjZG5zMyBjaGls ZCBkZXZpY2UsIHRoZW4gZmluZCBpdHMgZ2FkZ2V0IGRldmljZQo+ICsJCSAqIGFuZCByZWxlYXNl IHRoZSBmdW5jdGlvbiBkcml2ZXIgYmVmb3JlIGRpc2FibGluZyBjbG9ja3MuCj4gKwkJICogVGhp cyBlbnN1cmVzIGFsbCByZWdpc3RlciBhY2Nlc3NlcyBpbiBnYWRnZXRfdW5iaW5kX2RyaXZlcgo+ ICsJCSAqIGNvbXBsZXRlIGJlZm9yZSBjbG9ja3MgYXJlIHR1cm5lZCBvZmYuCj4gKwkJICovCj4g KwkJZGV2aWNlX2Zvcl9lYWNoX2NoaWxkKGRldiwgJmNkbnMsIGNkbnNwX3NreTFfZmluZF9jZG5z KTsKPiArCQlpZiAoY2RucykKPiArCQkJZGV2aWNlX2Zvcl9lYWNoX2NoaWxkKGNkbnMtPmRldiwg JmdhZGdldF9kZXYsCj4gKwkJCQkJICAgICAgY2Ruc3Bfc2t5MV9maW5kX2dhZGdldF9tYXRjaCk7 Cj4gKwkJaWYgKGdhZGdldF9kZXYpCj4gKwkJCWRldmljZV9yZWxlYXNlX2RyaXZlcihnYWRnZXRf ZGV2KTsKCltTZXZlcml0eTogTWVkaXVtXQpEb2VzIGRldmljZV9mb3JfZWFjaF9jaGlsZCgpIHJl bGVhc2UgdGhlIHJlZmVyZW5jZSBvbiB0aGUgY2hpbGQgZGV2aWNlCmltbWVkaWF0ZWx5IGFmdGVy IHRoZSBjYWxsYmFjayByZXR1cm5zPwoKSWYgc28sIGNvdWxkIGV4dHJhY3RpbmcgdGhlIGNkbnMg YW5kIGdhZGdldF9kZXYgcG9pbnRlcnMgb3V0IG9mIHRoZSBpdGVyYXRvcgpsb29wIHdpdGhvdXQg YWNxdWlyaW5nIHJlZmVyZW5jZXMgY3JlYXRlIGEgdXNlLWFmdGVyLWZyZWUgd2luZG93IHdoZW4g dGhleQphcmUgc3Vic2VxdWVudGx5IGRlcmVmZXJlbmNlZD8KCj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvdXNiL2NkbnMzL2NkbnNwLXNreTEuaCBiL2RyaXZlcnMvdXNiL2NkbnMzL2NkbnNwLXNreTEu aAo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwMC4uNDljM2Q1ZWFi MTc0NAo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL3VzYi9jZG5zMy9jZG5zcC1za3kx LmgKClsgLi4uIF0KCj4gKyNkZWZpbmUgRF9YRUNfQ0ZHXzNYUE9SVF9NT0RFX1ZBTFVFICAgICAw eGEwMDMxZTA3Cj4gKyNkZWZpbmUgWEVDX0NGR18zWFBPUlRfTU9ERV9WQUxVRSAgICAgICAweGEw MDMxZTA3Cj4gKyNkZWZpbmUgQ0ZHXzNYUE9SVF9NT0RFX0RJU19TU1AgICAgICAgICAofigxIDw8 IDMxKSkKCltTZXZlcml0eTogTWVkaXVtXQpEb2VzIHNoaWZ0aW5nIDEgYnkgMzEgYml0cyBoZXJl IHRyaWdnZXIgdW5kZWZpbmVkIGJlaGF2aW9yIHNpbmNlIDEgaXMgYQpzaWduZWQgaW50PyBDb3Vs ZCB0aGlzIHVzZSAxVSBvciBCSVQoMzEpIGluc3RlYWQ/CgotLSAKU2FzaGlrbyBBSSByZXZpZXcg wrcgaHR0cHM6Ly9zYXNoaWtvLmRldi8jL3BhdGNoc2V0LzIwMjYwODMxMDgyMzA5LjM4NTQ1MDct MS1ob25nbGlhbmcueWFuZ0BjaXh0ZWNoLmNvbT9wYXJ0PTQKCi0tIApsaW51eC1waHkgbWFpbGlu ZyBsaXN0CmxpbnV4LXBoeUBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHBzOi8vbGlzdHMuaW5mcmFk ZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXBoeQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 8F95820D4F0 for ; Wed, 2 Sep 2026 03:32:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788319944; cv=none; b=D9FkoIGavCLA3lJ/TC5xRoAhc+Z8moZp0OtqBXYpa4uskOCBRCO6KzqMFhQibdkhm7aOniMcF000ss8fSWEKXHMo14B5tlzVmqcmH6C6hrvpNZ10Tgahaj8wI4AJimF86RlQ3ChszkGRQjecLlcOvUhhq8/fBRUe/ZfzaO9SfP4= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788319944; c=relaxed/simple; bh=unqFh81SC4GrlgHaSxmgS1NQpTWfyNKvVwccyCP6RVk=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=pnqaxbeP0czKORO5zho7rq1UjKx98Cao2LlcDMVwST11FPLNRHUvPlWN5JQ1dXDB/lxBzDAyd3c3pQeOVXyQkkdPJ5zXPqsw6P0r2avRgQRjttJQ3rnyxFpY16vLDlWQ5Cb9gpY4lrEpXYHgglCEz+VOrS3gflUCfhvwe96kk/w= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=RszOs/Ce; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="RszOs/Ce" Received: by smtp.kernel.org (Postfix) with ESMTPSA id CA24A1F000E9; Wed, 2 Sep 2026 03:32:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788319943; bh=uEhLsjX4mcPRU4LShL1Gu6TdGWkkCFUPfe8iS/HC7oE=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=RszOs/CeAmAC7YIyLp9uDmOfTuSktR6ONfR3zrqT2MAm3Lt1qau4QXAMoC0ce4Igk vSRp3ZKdyQurhL8qUrrs67hPuXo5V359/CIpmr8l0thLKWp1WA4DneC3v5iWQ1VsCC xrFIj240gWCiLsvmUAyxNj3vNwm5oofDXVXHxZkf3D/KX/jz+aR2HkeQzk7naBZVzN wQeQp16VeKaPzj5KNcZIvJI5AO/76E4iUhwn2vvjHyLEfyUTQqej52oUiPrN+BJ5cw Uis8fQi3dOe2L542Y66Dj6yeypD2S35tK0JqcuNjlV3cQAZB0XRO7X6ta2I3We2bhg B2Zt7TvPYrqgA== From: sashiko-bot@kernel.org Subject: Re: [PATCH v2 4/5] usb: cdns3: Add CIX Sky1 glue driver Reply-To: sashiko-reviews@lists.linux.dev To: "Hongliang Yang" Cc: vkoul@kernel.org, linux-phy@lists.infradead.org, olteanv@gmail.com, robh@kernel.org, devicetree@vger.kernel.org, conor+dt@kernel.org, neil.armstrong@linaro.org In-Reply-To: <20260902032134.1182634-5-hongliang.yang@cixtech.com> References: <20260831082309.3854507-1-hongliang.yang@cixtech.com> <20260902032134.1182634-5-hongliang.yang@cixtech.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Wed, 02 Sep 2026 03:32:22 +0000 Message-Id: <20260902033222.CA24A1F000E9@smtp.kernel.org> Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Thank you for your contribution! Sashiko AI review found 10 potential issue= (s) to consider: - [High] Massive resource leak on probe error paths (I/O memory, clocks, an= d resets). - [High] Thread-safety and double-free vulnerability due to modifying a sta= tic global of_dev_auxdata array during probe. - [High] Unbalanced runtime PM usage count and missing PM disable in cdnsp_= sky1_remove. - [High] Incorrect reset control assertion logic in remove path fails to qu= iesce hardware. - [High] NULL pointer dereference when accessing xhci_dev->dev in platform_= suspend. - [Medium] OF node reference leak in sky1_of_get_addr_by_name() because the= reference obtained by of_get_next_child() is never released. - [Medium] Destructive error handling in cdnsp_sky1_clk_enable_resume corru= pts internal clock pointers. - [Medium] Potential Use-After-Free (UAF) due to missing device refcounting= in iterator callbacks during shutdown. - [Medium] Undefined behavior due to bitwise shift into the sign bit. - [Medium] PM subsystem guideline violation: PM sleep callbacks are assigne= d without the required pm_sleep_ptr() wrapper. -- commit 0232318426cffe797c62a93651116101c396ebb4 Author: Hongliang Yang usb: cdns3: Add CIX Sky1 glue driver This commit adds a glue layer driver for the Cadence USBSSP controller integrated in the CIX Sky1 SoC. The driver manages the controller clocks, resets, and the mode strap controls located in the Sky1 S5 system controller. > diff --git a/drivers/usb/cdns3/cdnsp-sky1.c b/drivers/usb/cdns3/cdnsp-sky= 1.c > new file mode 100644 > index 0000000000000..447c683b726c1 > --- /dev/null > +++ b/drivers/usb/cdns3/cdnsp-sky1.c [ ... ] > +static int cdnsp_sky1_clk_enable_resume(struct device *dev) > +{ > + int i, ret; > + struct cdnsp_sky1 *data =3D dev_get_drvdata(dev); > + struct clk **cix_usb_clks =3D data->cix_usb_clks; > + > + for (i =3D 0; i < CIX_USB_CLK_OFF_NUM; i++) { > + ret =3D clk_prepare_enable(cix_usb_clks[i]); > + if (ret) { > + dev_err(dev, "failed to enable clock %s: %d\n", > + cix_usb_clk_names[i], ret); > + goto err_usb_clks; > + } > + } > + return 0; > + > +err_usb_clks: > + cix_usb_clks[i] =3D NULL; > + while (--i >=3D 0) { > + clk_disable_unprepare(cix_usb_clks[i]); > + cix_usb_clks[i] =3D NULL; > + } > + return ret; > +}; [Severity: Medium] Does setting cix_usb_clks[i] to NULL here permanently wipe the devm-managed clock references from the driver's private state? If a system clock fails to resume, won't subsequent calls to enable or disable these clocks receive NULL pointers and silently fail to configure the hardware? [ ... ] > +static int cdns_sky1_platform_suspend(struct device *dev, > + bool suspend, bool wakeup) > +{ > + struct cdns *cdns =3D dev_get_drvdata(dev); > + struct platform_device *xhci_dev =3D cdns->host_dev; > + struct usb_hcd *hcd; > + struct device *parent =3D cdns->dev->parent; > + struct cdnsp_sky1 *data =3D dev_get_drvdata(parent); > + u32 value; > + int ret =3D 0; > + int count =3D 3; > + > + data->wakeup =3D wakeup; > + > + if (cdns->role !=3D USB_ROLE_HOST) > + return 0; > + > + hcd =3D dev_get_drvdata(&xhci_dev->dev); [Severity: High] Could xhci_dev be NULL if the host initialization failed or was unbound? If so, would accessing &xhci_dev->dev lead to an out-of-bounds pointer dereference during system suspend? [ ... ] > +static void *sky1_of_get_addr_by_name(struct device_node *parent, char *= name) > +{ > + struct device_node *node; > + int index; > + > + node =3D of_get_next_child(parent, NULL); > + if (node) { > + index =3D of_property_match_string(node, "reg-names", name); > + if (index >=3D 0) > + return of_iomap(node, index); > + } > + return NULL; > +} [Severity: Medium] Does of_get_next_child() return the node with an incremented reference coun= t? Should there be a call to of_node_put(node) before returning to prevent a memory leak? [ ... ] > +static int cdnsp_sky1_probe(struct platform_device *pdev) > +{ > + struct device *dev =3D &pdev->dev; > + struct device_node *node =3D dev->of_node; > + struct cdnsp_sky1 *data; > + int ret =3D 0; > + struct cdns3_platform_data *cdns_sky1_pdata; [ ... ] > + ret =3D cdnsp_sky1_drd_init(data); > + if (ret =3D=3D -ETIMEDOUT) > + return -EPROBE_DEFER; > + if (ret) > + return ret; [Severity: High] If probe fails here and returns directly, are the I/O memory mappings for xhci_base and device_base (which were mapped via non-devm of_iomap) left active? Should they be unmapped and the clocks/resets cleaned up? [ ... ] > + /* release by platform_device_release */ > + cdns_sky1_pdata =3D kzalloc(sizeof(*cdns_sky1_pdata), GFP_KERNEL); > + if (!cdns_sky1_pdata) > + return -ENOMEM; > + cdns_sky1_pdata->platform_suspend =3D cdns_sky1_platform_suspend; > + cdns_sky1_pdata->quirks =3D CDNS3_DEFAULT_PM_RUNTIME_ALLOW; > + cdns_sky1_auxdata->platform_data =3D cdns_sky1_pdata; > + ret =3D of_platform_populate(node, NULL, cdns_sky1_auxdata, dev); [Severity: High] Is it safe to assign a dynamically allocated instance-specific pointer (cdns_sky1_pdata) to the statically allocated global array cdns_sky1_auxdat= a? Could this lead to a double-free vulnerability if multiple controller insta= nces exist or if the driver is repeatedly unbound and rebound? > + if (ret) { > + dev_err(dev, "failed to create children: %d\n", ret); > + goto err; > + } > + device_set_wakeup_capable(dev, true); > + pm_runtime_set_active(dev); > + pm_runtime_enable(dev); > + return 0; > +err: > + kfree(cdns_sky1_pdata); > + return ret; > +} [Severity: High] Does this shared error path fail to clean up the I/O memory mappings, assert resets, and disable clocks before returning? > +static void cdnsp_sky1_remove(struct platform_device *pdev) > +{ > + struct device *dev =3D &pdev->dev; > + struct cdnsp_sky1 *data =3D dev_get_drvdata(dev); > + > + pm_runtime_get_sync(dev); > + of_platform_depopulate(dev); > + sky1_put_addr(data->xhci_base); > + sky1_put_addr(data->device_base); > + reset_control_deassert(data->reset); > + reset_control_deassert(data->preset); [Severity: High] Should these be reset_control_assert() instead of deassert() to correctly quiesce the hardware before the clocks are disabled? > + cdnsp_sky1_clk_disable_all(dev); > + platform_set_drvdata(pdev, NULL); > +} [Severity: High] Does this function need to call pm_runtime_put_sync() and pm_runtime_disabl= e()? Because pm_runtime_get_sync(dev) increments the usage counter at the start = of the function, could omitting the decrement lead to a leaked usage count and= a broken PM state machine for the device on subsequent binds? [ ... ] > +static const struct dev_pm_ops cdnsp_sky1_pm_ops =3D { > + .suspend =3D cdnsp_sky1_system_suspend, > + .resume =3D cdnsp_sky1_system_resume, > +}; [Severity: Medium] Should these sleep callbacks be wrapped with pm_sleep_ptr()? Without it, if CONFIG_PM is enabled but CONFIG_PM_SLEEP is disabled, could this generate dead code warnings for the suspend and resume functions? [ ... ] > +static void cdnsp_sky1_shutdown(struct platform_device *pdev) > +{ > + struct device *dev =3D &pdev->dev; > + struct cdnsp_sky1 *data =3D dev_get_drvdata(dev); > + struct cdns *cdns =3D NULL; > + struct device *gadget_dev =3D NULL; > + > + if (!device_may_wakeup(dev)) { > + /* > + * Find the cdns3 child device, then find its gadget device > + * and release the function driver before disabling clocks. > + * This ensures all register accesses in gadget_unbind_driver > + * complete before clocks are turned off. > + */ > + device_for_each_child(dev, &cdns, cdnsp_sky1_find_cdns); > + if (cdns) > + device_for_each_child(cdns->dev, &gadget_dev, > + cdnsp_sky1_find_gadget_match); > + if (gadget_dev) > + device_release_driver(gadget_dev); [Severity: Medium] Does device_for_each_child() release the reference on the child device immediately after the callback returns? If so, could extracting the cdns and gadget_dev pointers out of the iterator loop without acquiring references create a use-after-free window when they are subsequently dereferenced? > diff --git a/drivers/usb/cdns3/cdnsp-sky1.h b/drivers/usb/cdns3/cdnsp-sky= 1.h > new file mode 100644 > index 0000000000000..49c3d5eab1744 > --- /dev/null > +++ b/drivers/usb/cdns3/cdnsp-sky1.h [ ... ] > +#define D_XEC_CFG_3XPORT_MODE_VALUE 0xa0031e07 > +#define XEC_CFG_3XPORT_MODE_VALUE 0xa0031e07 > +#define CFG_3XPORT_MODE_DIS_SSP (~(1 << 31)) [Severity: Medium] Does shifting 1 by 31 bits here trigger undefined behavior since 1 is a signed int? Could this use 1U or BIT(31) instead? --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260831082309.3854= 507-1-hongliang.yang@cixtech.com?part=3D4