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 8A465E94139 for ; Fri, 6 Oct 2023 22:31:44 +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:MIME-Version:Message-ID:Date:References :In-Reply-To:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=Zry6FLDqs6qLQjlIndczFLeMQAkjOVIBGWX1o2R/YDw=; b=H9ogugqjZzdb04 3JaS+IopXUXXIenpdt0iPpuqKtqMO1KifP4b77vqhJDz72pf7DJKsoLoyrqJjh31pu2gyKsR92+r5 LNzLDJP0MsKKHtSFwfguIER3an7486sa/b9bz4mCfg63++hWhaXs943TZXhetLpWGVz8h6bB2K880 Em0IYtdnq8IOvRn9APIuHPvFuA5bTJK29nFL4BBsAYwe8lAvdymIOHgYeS4dJ6kC1XEmZOSv8lnuK uesRp2GA9LaDy/cUMq2n/aSUx9Bv/l8S4B+FogMi6HfrTUzy+ivbMswxVvv/wDcy1+tJTxySOMzRD MZtBRqiIsZ0XlsJfJS3g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1qotLm-006ap6-1e; Fri, 06 Oct 2023 22:31:14 +0000 Received: from mgamail.intel.com ([192.55.52.136]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1qotLi-006aoW-0G for linux-arm-kernel@lists.infradead.org; Fri, 06 Oct 2023 22:31:13 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1696631470; x=1728167470; h=from:to:cc:subject:in-reply-to:references:date: message-id:mime-version:content-transfer-encoding; bh=1Xh5Xl6zIju/WmK1saMVcq0Jh6v2ct7XttOxs4wQacA=; b=nliveBalLNFlHi0riM7erSHc4TcDNgcpd/DlM6YNJayt+zflEI4p3BZD ihh5Ff+MMTNh/7FtGYuIyz5LLYUGic+vvxupVsqBiQzHgZYQRkFJkdtTK 8kVAzviGPu2c+NzNesyVUeFszL/kCynyW16CYIJPoq2E1ZSiSlRK0C34y 1kaVlznUXVXW2cYx1afx2P2c237iQndeZ/Dq44cDP6IOLfz+GGiVfc6PX G4QTpIOwZHiaCtbkIgFazJ+1TecslXztLuJjkyEzx9HvOAxfYwVeqmIhZ RCVc+imAQ3CYwGKZOyomrfECqxQRSDAd8A6Y5ty+NJ4N3ufAHpkteN0t5 g==; X-IronPort-AV: E=McAfee;i="6600,9927,10855"; a="363198138" X-IronPort-AV: E=Sophos;i="6.03,204,1694761200"; d="scan'208";a="363198138" Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by fmsmga106.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Oct 2023 15:31:05 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10855"; a="1083607625" X-IronPort-AV: E=Sophos;i="6.03,204,1694761200"; d="scan'208";a="1083607625" Received: from vcostago-mobl3.jf.intel.com (HELO vcostago-mobl3) ([10.24.14.106]) by fmsmga005-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Oct 2023 15:31:04 -0700 From: Vinicius Costa Gomes To: MD Danish Anwar , Andrew Lunn , Roger Quadros , Vignesh Raghavendra , MD Danish Anwar , Richard Cochran , Paolo Abeni , Jakub Kicinski , Eric Dumazet , "David S. Miller" , vladimir.oltean@nxp.com, Simon Horman Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, srk@ti.com, r-gunasekaran@ti.com, linux-arm-kernel@lists.infradead.org, Roger Quadros Subject: Re: [PATCH net-next v4] net: ti: icssg_prueth: add TAPRIO offload support In-Reply-To: <20231006102028.3831341-1-danishanwar@ti.com> References: <20231006102028.3831341-1-danishanwar@ti.com> Date: Fri, 06 Oct 2023 15:31:03 -0700 Message-ID: <87cyxr8jtk.fsf@intel.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20231006_153110_196628_DDCF6AAA X-CRM114-Status: GOOD ( 38.24 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org TUQgRGFuaXNoIEFud2FyIDxkYW5pc2hhbndhckB0aS5jb20+IHdyaXRlczoKCj4gRnJvbTogUm9n ZXIgUXVhZHJvcyA8cm9nZXJxQHRpLmNvbT4KPgo+IElDU1NHIGR1YWwtZW1hYyBmL3cgc3VwcG9y dHMgRW5oYW5jZWQgU2NoZWR1bGVkIFRyYWZmaWMgKEVTVCDigJMgZGVmaW5lZAo+IGluIFA4MDIu MVFidi9EMi4yIHRoYXQgbGF0ZXIgZ290IGluY2x1ZGVkIGluIElFRUUgODAyLjFRLTIwMTgpCj4g Y29uZmlndXJhdGlvbi4gRVNUIGFsbG93cyBleHByZXNzIHF1ZXVlIHRyYWZmaWMgdG8gYmUgc2No ZWR1bGVkCj4gKHBsYWNlZCkgb24gdGhlIHdpcmUgYXQgc3BlY2lmaWMgcmVwZWF0YWJsZSB0aW1l IGludGVydmFscy4gSW4KPiBMaW51eCBrZXJuZWwsIEVTVCBjb25maWd1cmF0aW9uIGlzIGRvbmUg dGhyb3VnaCB0YyBjb21tYW5kIGFuZAo+IHRoZSB0YXByaW8gc2NoZWR1bGVyIGluIHRoZSBuZXQg Y29yZSBpbXBsZW1lbnRzIGEgc29mdHdhcmUgb25seQo+IHNjaGVkdWxlciAoU0NIX1RBUFJJTyku IElmIHRoZSBOSUMgaXMgY2FwYWJsZSBvZiBFU1QgY29uZmlndXJhdGlvbiwKPiB1c2VyIGluZGlj YXRlICJmbGFnIDIiIGluIHRoZSBjb21tYW5kIHdoaWNoIGlzIHRoZW4gcGFyc2VkIGJ5Cj4gdGFw cmlvIHNjaGVkdWxlciBpbiBuZXQgY29yZSBhbmQgaW5kaWNhdGUgdGhhdCB0aGUgY29tbWFuZCBp cyB0bwo+IGJlIG9mZmxvYWRlZCB0byBoL3cuIHRhcHJpbyB0aGVuIG9mZmxvYWRzIHRoZSBjb21t YW5kIHRvIHRoZQo+IGRyaXZlciBieSBjYWxsaW5nIG5kb19zZXR1cF90YygpIG5kbyBvcHMuIFRo aXMgcGF0Y2ggaW1wbGVtZW50cwo+IG5kb19zZXR1cF90YygpIHRvIG9mZmxvYWQgRVNUIGNvbmZp Z3VyYXRpb24gdG8gSUNTU0cuCj4KPiBTaWduZWQtb2ZmLWJ5OiBSb2dlciBRdWFkcm9zIDxyb2dl cnFAdGkuY29tPgo+IFNpZ25lZC1vZmYtYnk6IFZpZ25lc2ggUmFnaGF2ZW5kcmEgPHZpZ25lc2hy QHRpLmNvbT4KPiBTaWduZWQtb2ZmLWJ5OiBNRCBEYW5pc2ggQW53YXIgPGRhbmlzaGFud2FyQHRp LmNvbT4KPiAtLS0KPiBDYzogUm9nZXIgUXVhZHJvcyA8cm9nZXJxQHRpLmNvbT4KPiBDYzogQW5k cmV3IEx1bm4gPGFuZHJld0BsdW5uLmNoPgo+IENjOiBWaW5pY2l1cyBDb3N0YSBHb21lcyA8dmlu aWNpdXMuZ29tZXNAaW50ZWwuY29tPgo+IENjOiBKYWt1YiBLaWNpbnNraSA8a3ViYUBrZXJuZWwu b3JnPgo+Cj4gQ2hhbmdlcyBmcm9tIHYzIHRvIHY0Ogo+ICopIFJlYmFzZWQgb24gdGhlIGxhdGVz dCBuZXh0LTIwMjMxMDA1IGxpbnV4LW5leHQuCj4gKikgQWRkcmVzc2VkIFJvZ2VyIGFuZCBWaW5p Y2l1cycgY29tbWVudHMgYW5kIG1vdmVkIGFsbCB0aGUgdmFsaWRhdGlvbnMgdG8KPiAgICBlbWFj X3RhcHJpb19yZXBsYWNlKCkgQVBJLgo+ICopIE1vZGlmaWVkIGVtYWNfc2V0dXBfdGFwcmlvKCkg QVBJIHRvIHVzZSBzd2l0Y2ggY2FzZSBiYXNlZCBvbiB0YXByaW8tPmNtZAo+ICAgIGFuZCBhZGRl ZCBlbWFjX3RhcHJpb19kZXN0cm95KCkgYW5kIGVtYWNfdGFwcmlvX3JlcGxhY2UoKSBBUElzLgo+ ICopIE1vZGlmaWVkIHRoZSBkb2N1bWVudGF0aW9uIG9mIHN0cnVjdHMgLyBlbnVtcyBpbiBpY3Nz Z19xb3MuaCBieSB1c2luZwo+ICAgIHRoZSBjb3JyZWN0IGtkb2MgZm9ybWF0Lgo+Cj4gQ2hhbmdl cyBmcm9tIHYyIHRvIHYzOgo+ICopIFJlYmFzZWQgb24gdGhlIGxhdGVzdCBuZXh0LTIwMjMwOTI4 IGxpbnV4LW5leHQuCj4gKikgUmV0YWluZWQgb3JpZ2luYWwgYXV0aG9yc2hpcCBvZiB0aGUgcGF0 Y2guCj4gKikgQWRkcmVzc2VkIFJvZ2VyJ3MgY29tbWVudHMgYW5kIG1vZGlmaWVkIGVtYWNfc2V0 dXBfdGFwcmlvKCkgYW5kCj4gICAgZW1hY19zZXRfdGFwcmlvKCkgQVBJcyBhY2NvcmRpbmdseS4K PiAqKSBSZW1vdmVkIG5ldGlmX3J1bm5pbmcoKSBjaGVjayBmcm9tIGVtYWNfc2V0dXBfdGFwcmlv KCkuCj4gKikgQWRkcmVzc2VkIFZpbmljaXVzJyBjb21tZW50cyBhbmQgYWRkZWQgY2hlY2sgZm9y IE1JTiBhbmQgTUFYIGN5Y2xlIHRpbWUuCj4gKikgQWRkZWQgY2hlY2sgZm9yIGFsbG9jYXRpb24g ZmFpbHVyZSBvZiBlc3RfbmV3IGluIGVtYWNfc2V0dXBfdGFwcmlvKCkuCj4KPiBDaGFuZ2VzIGZy b20gdjEgdG8gdjI6Cj4gKikgUmViYXNlZCBvbiB0aGUgbGF0ZXN0IG5leHQtMjAyMzA5MjEgbGlu dXgtbmV4dC4KPiAqKSBEcm9wcGVkIHRoZSBSRkMgdGFnIGFzIG1lcmdlIHdpbmRvdyBpcyBvcGVu IG5vdy4KPiAqKSBTcGxpdHRlZCB0aGlzIHBhdGNoIGZyb20gdGhlIHN3aXRjaCBtb2RlIHNlcmll cyBbdjFdLgo+ICopIFJlbW92ZWQgVE9ETyBjb21tZW50IGFzIGFza2VkIGJ5IEFuZHJldyBhbmQg Um9nZXIuCj4gKikgQ2hhbmdlZCBDb3B5cmlnaHQgdG8gMjAyMyBhcyBhc2tlZCBieSBSb2dlci4K Pgo+IHYzOiBodHRwczovL2xvcmUua2VybmVsLm9yZy9hbGwvMjAyMzA5MjgxMDMwMDAuMTg2MzA0 LTEtZGFuaXNoYW53YXJAdGkuY29tLwo+IHYyOiBodHRwczovL2xvcmUua2VybmVsLm9yZy9hbGwv MjAyMzA5MjEwNzAwMzEuNzk1Nzg4LTEtZGFuaXNoYW53YXJAdGkuY29tLwo+IHYxOiBodHRwczov L2xvcmUua2VybmVsLm9yZy9hbGwvMjAyMzA4MzAxMTA4NDcuMTIxOTUxNS0xLWRhbmlzaGFud2Fy QHRpLmNvbS8KPgo+ICBkcml2ZXJzL25ldC9ldGhlcm5ldC90aS9NYWtlZmlsZSAgICAgICAgICAg ICB8ICAgMyArLQo+ICBkcml2ZXJzL25ldC9ldGhlcm5ldC90aS9pY3NzZy9pY3NzZ19wcnVldGgu YyB8ICAgNSArLQo+ICBkcml2ZXJzL25ldC9ldGhlcm5ldC90aS9pY3NzZy9pY3NzZ19wcnVldGgu aCB8ICAgNiArCj4gIGRyaXZlcnMvbmV0L2V0aGVybmV0L3RpL2ljc3NnL2ljc3NnX3Fvcy5jICAg IHwgMzAxICsrKysrKysrKysrKysrKysrKysKPiAgZHJpdmVycy9uZXQvZXRoZXJuZXQvdGkvaWNz c2cvaWNzc2dfcW9zLmggICAgfCAxMTMgKysrKysrKwo+ICA1IGZpbGVzIGNoYW5nZWQsIDQyNiBp bnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy cy9uZXQvZXRoZXJuZXQvdGkvaWNzc2cvaWNzc2dfcW9zLmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0 IGRyaXZlcnMvbmV0L2V0aGVybmV0L3RpL2ljc3NnL2ljc3NnX3Fvcy5oCj4KPiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvdGkvTWFrZWZpbGUgYi9kcml2ZXJzL25ldC9ldGhlcm5l dC90aS9NYWtlZmlsZQo+IGluZGV4IDM0ZmQ3YTcxNmJhNi4uMGRmNjBkZWQxYjJkIDEwMDY0NAo+ IC0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3RpL01ha2VmaWxlCj4gKysrIGIvZHJpdmVycy9u ZXQvZXRoZXJuZXQvdGkvTWFrZWZpbGUKPiBAQCAtMzcsNSArMzcsNiBAQCBpY3NzZy1wcnVldGgt eSA6PSBrMy1jcHBpLWRlc2MtcG9vbC5vIFwKPiAgCQkgIGljc3NnL2ljc3NnX2NvbmZpZy5vIFwK PiAgCQkgIGljc3NnL2ljc3NnX21paV9jZmcubyBcCj4gIAkJICBpY3NzZy9pY3NzZ19zdGF0cy5v IFwKPiAtCQkgIGljc3NnL2ljc3NnX2V0aHRvb2wubwo+ICsJCSAgaWNzc2cvaWNzc2dfZXRodG9v bC5vIFwKPiArCQkgIGljc3NnL2ljc3NnX3Fvcy5vCj4gIG9iai0kKENPTkZJR19USV9JQ1NTX0lF UCkgKz0gaWNzc2cvaWNzc19pZXAubwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5l dC90aS9pY3NzZy9pY3NzZ19wcnVldGguYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3RpL2ljc3Nn L2ljc3NnX3BydWV0aC5jCj4gaW5kZXggNjYzNWIyOGJjNjcyLi44OWMzMDE3MTY5MjYgMTAwNjQ0 Cj4gLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvdGkvaWNzc2cvaWNzc2dfcHJ1ZXRoLmMKPiAr KysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC90aS9pY3NzZy9pY3NzZ19wcnVldGguYwo+IEBAIC0x MTY2LDcgKzExNjYsNyBAQCBzdGF0aWMgaW50IGVtYWNfcGh5X2Nvbm5lY3Qoc3RydWN0IHBydWV0 aF9lbWFjICplbWFjKQo+ICAJcmV0dXJuIDA7Cj4gIH0KPiAgCj4gLXN0YXRpYyB1NjQgcHJ1ZXRo X2llcF9nZXR0aW1lKHZvaWQgKmNsb2Nrb3BzX2RhdGEsIHN0cnVjdCBwdHBfc3lzdGVtX3RpbWVz dGFtcCAqc3RzKQo+ICt1NjQgcHJ1ZXRoX2llcF9nZXR0aW1lKHZvaWQgKmNsb2Nrb3BzX2RhdGEs IHN0cnVjdCBwdHBfc3lzdGVtX3RpbWVzdGFtcCAqc3RzKQo+ICB7Cj4gIAl1MzIgaGlfcm9sbG92 ZXJfY291bnQsIGhpX3JvbGxvdmVyX2NvdW50X3I7Cj4gIAlzdHJ1Y3QgcHJ1ZXRoX2VtYWMgKmVt YWMgPSBjbG9ja29wc19kYXRhOwo+IEBAIC0xNDAzLDYgKzE0MDMsOCBAQCBzdGF0aWMgaW50IGVt YWNfbmRvX29wZW4oc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYpCj4gIAkJbmFwaV9lbmFibGUoJmVt YWMtPnR4X2NobnNbaV0ubmFwaV90eCk7Cj4gIAluYXBpX2VuYWJsZSgmZW1hYy0+bmFwaV9yeCk7 Cj4gIAo+ICsJaWNzc2dfcW9zX3Rhc19pbml0KG5kZXYpOwo+ICsKPiAgCS8qIHN0YXJ0IFBIWSAq Lwo+ICAJcGh5X3N0YXJ0KG5kZXYtPnBoeWRldik7Cj4gIAo+IEBAIC0xNjY5LDYgKzE2NzEsNyBA QCBzdGF0aWMgY29uc3Qgc3RydWN0IG5ldF9kZXZpY2Vfb3BzIGVtYWNfbmV0ZGV2X29wcyA9IHsK PiAgCS5uZG9fc2V0X3J4X21vZGUgPSBlbWFjX25kb19zZXRfcnhfbW9kZSwKPiAgCS5uZG9fZXRo X2lvY3RsID0gZW1hY19uZG9faW9jdGwsCj4gIAkubmRvX2dldF9zdGF0czY0ID0gZW1hY19uZG9f Z2V0X3N0YXRzNjQsCj4gKwkubmRvX3NldHVwX3RjID0gaWNzc2dfcW9zX25kb19zZXR1cF90YywK PiAgfTsKPiAgCj4gIC8qIGdldCBlbWFjX3BvcnQgY29ycmVzcG9uZGluZyB0byBldGhfbm9kZSBu YW1lICovCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3RpL2ljc3NnL2ljc3Nn X3BydWV0aC5oIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvdGkvaWNzc2cvaWNzc2dfcHJ1ZXRoLmgK PiBpbmRleCA4YjZkNmI0OTcwMTAuLjdjYmYwZTU2MTkwNSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L25ldC9ldGhlcm5ldC90aS9pY3NzZy9pY3NzZ19wcnVldGguaAo+ICsrKyBiL2RyaXZlcnMvbmV0 L2V0aGVybmV0L3RpL2ljc3NnL2ljc3NnX3BydWV0aC5oCj4gQEAgLTM3LDYgKzM3LDcgQEAKPiAg I2luY2x1ZGUgImljc3NnX2NvbmZpZy5oIgo+ICAjaW5jbHVkZSAiaWNzc19pZXAuaCIKPiAgI2lu Y2x1ZGUgImljc3NnX3N3aXRjaF9tYXAuaCIKPiArI2luY2x1ZGUgImljc3NnX3Fvcy5oIgo+ICAK PiAgI2RlZmluZSBQUlVFVEhfTUFYX01UVSAgICAgICAgICAoMjAwMCAtIEVUSF9ITEVOIC0gRVRI X0ZDU19MRU4pCj4gICNkZWZpbmUgUFJVRVRIX01JTl9QS1RfU0laRSAgICAgKFZMQU5fRVRIX1pM RU4pCj4gQEAgLTE3NCw2ICsxNzUsOCBAQCBzdHJ1Y3QgcHJ1ZXRoX2VtYWMgewo+ICAKPiAgCXN0 cnVjdCBwcnVzc19tZW1fcmVnaW9uIGRyYW07Cj4gIAo+ICsJc3RydWN0IHBydWV0aF9xb3MgcW9z Owo+ICsKPiAgCXN0cnVjdCBkZWxheWVkX3dvcmsgc3RhdHNfd29yazsKPiAgCXU2NCBzdGF0c1tJ Q1NTR19OVU1fU1RBVFNdOwo+ICB9Owo+IEBAIC0yODUsNCArMjg4LDcgQEAgdTMyIGljc3NnX3F1 ZXVlX2xldmVsKHN0cnVjdCBwcnVldGggKnBydWV0aCwgaW50IHF1ZXVlKTsKPiAgdm9pZCBlbWFj X3N0YXRzX3dvcmtfaGFuZGxlcihzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspOwo+ICB2b2lkIGVt YWNfdXBkYXRlX2hhcmR3YXJlX3N0YXRzKHN0cnVjdCBwcnVldGhfZW1hYyAqZW1hYyk7Cj4gIGlu dCBlbWFjX2dldF9zdGF0X2J5X25hbWUoc3RydWN0IHBydWV0aF9lbWFjICplbWFjLCBjaGFyICpz dGF0X25hbWUpOwo+ICsKPiArdTY0IHBydWV0aF9pZXBfZ2V0dGltZSh2b2lkICpjbG9ja29wc19k YXRhLCBzdHJ1Y3QgcHRwX3N5c3RlbV90aW1lc3RhbXAgKnN0cyk7Cj4gKwo+ICAjZW5kaWYgLyog X19ORVRfVElfSUNTU0dfUFJVRVRIX0ggKi8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRo ZXJuZXQvdGkvaWNzc2cvaWNzc2dfcW9zLmMgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC90aS9pY3Nz Zy9pY3NzZ19xb3MuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAw Li5jOGM0NDUwYzQxYmIKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy9uZXQvZXRoZXJu ZXQvdGkvaWNzc2cvaWNzc2dfcW9zLmMKPiBAQCAtMCwwICsxLDMwMSBAQAo+ICsvLyBTUERYLUxp Y2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAo+ICsvKiBUZXhhcyBJbnN0cnVtZW50cyBJQ1NTRyBQ UlVFVEggUW9TIHN1Ym1vZHVsZQo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMjMgVGV4YXMgSW5zdHJ1 bWVudHMgSW5jb3Jwb3JhdGVkIC0gaHR0cDovL3d3dy50aS5jb20vCj4gKyAqLwo+ICsKPiArI2lu Y2x1ZGUgPGxpbnV4L3ByaW50ay5oPgo+ICsjaW5jbHVkZSAiaWNzc2dfcHJ1ZXRoLmgiCj4gKyNp bmNsdWRlICJpY3NzZ19zd2l0Y2hfbWFwLmgiCj4gKwo+ICtzdGF0aWMgdm9pZCB0YXNfdXBkYXRl X2Z3X2xpc3RfcG9pbnRlcnMoc3RydWN0IHBydWV0aF9lbWFjICplbWFjKQo+ICt7Cj4gKwlzdHJ1 Y3QgdGFzX2NvbmZpZyAqdGFzID0gJmVtYWMtPnFvcy50YXMuY29uZmlnOwo+ICsKPiArCWlmICgo cmVhZGIodGFzLT5hY3RpdmVfbGlzdCkpID09IFRBU19MSVNUMCkgewo+ICsJCXRhcy0+ZndfYWN0 aXZlX2xpc3QgPSBlbWFjLT5kcmFtLnZhICsgVEFTX0dBVEVfTUFTS19MSVNUMDsKPiArCQl0YXMt PmZ3X3NoYWRvd19saXN0ID0gZW1hYy0+ZHJhbS52YSArIFRBU19HQVRFX01BU0tfTElTVDE7Cj4g Kwl9IGVsc2Ugewo+ICsJCXRhcy0+ZndfYWN0aXZlX2xpc3QgPSBlbWFjLT5kcmFtLnZhICsgVEFT X0dBVEVfTUFTS19MSVNUMTsKPiArCQl0YXMtPmZ3X3NoYWRvd19saXN0ID0gZW1hYy0+ZHJhbS52 YSArIFRBU19HQVRFX01BU0tfTElTVDA7Cj4gKwl9Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHRh c191cGRhdGVfbWF4c2R1X3RhYmxlKHN0cnVjdCBwcnVldGhfZW1hYyAqZW1hYykKPiArewo+ICsJ c3RydWN0IHRhc19jb25maWcgKnRhcyA9ICZlbWFjLT5xb3MudGFzLmNvbmZpZzsKPiArCXUxNiBf X2lvbWVtICptYXhfc2R1X3RibF9wdHI7Cj4gKwl1OCBnYXRlX2lkeDsKPiArCj4gKwkvKiB1cGRh dGUgdGhlIG1heHNkdSB0YWJsZSAqLwo+ICsJbWF4X3NkdV90YmxfcHRyID0gZW1hYy0+ZHJhbS52 YSArIFRBU19RVUVVRV9NQVhfU0RVX0xJU1Q7Cj4gKwo+ICsJZm9yIChnYXRlX2lkeCA9IDA7IGdh dGVfaWR4IDwgVEFTX01BWF9OVU1fUVVFVUVTOyBnYXRlX2lkeCsrKQo+ICsJCXdyaXRldyh0YXMt Pm1heF9zZHVfdGFibGUubWF4X3NkdVtnYXRlX2lkeF0sICZtYXhfc2R1X3RibF9wdHJbZ2F0ZV9p ZHhdKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdGFzX3Jlc2V0KHN0cnVjdCBwcnVldGhfZW1h YyAqZW1hYykKPiArewo+ICsJc3RydWN0IHRhc19jb25maWcgKnRhcyA9ICZlbWFjLT5xb3MudGFz LmNvbmZpZzsKPiArCWludCBpOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBUQVNfTUFYX05VTV9R VUVVRVM7IGkrKykKPiArCQl0YXMtPm1heF9zZHVfdGFibGUubWF4X3NkdVtpXSA9IDIwNDg7Cj4g Kwo+ICsJdGFzX3VwZGF0ZV9tYXhzZHVfdGFibGUoZW1hYyk7Cj4gKwo+ICsJd3JpdGViKFRBU19M SVNUMCwgdGFzLT5hY3RpdmVfbGlzdCk7Cj4gKwo+ICsJbWVtc2V0X2lvKHRhcy0+ZndfYWN0aXZl X2xpc3QsIDAsIHNpemVvZigqdGFzLT5md19hY3RpdmVfbGlzdCkpOwo+ICsJbWVtc2V0X2lvKHRh cy0+Zndfc2hhZG93X2xpc3QsIDAsIHNpemVvZigqdGFzLT5md19zaGFkb3dfbGlzdCkpOwo+ICt9 Cj4gKwo+ICtzdGF0aWMgaW50IHRhc19zZXRfc3RhdGUoc3RydWN0IHBydWV0aF9lbWFjICplbWFj LCBlbnVtIHRhc19zdGF0ZSBzdGF0ZSkKPiArewo+ICsJc3RydWN0IHRhc19jb25maWcgKnRhcyA9 ICZlbWFjLT5xb3MudGFzLmNvbmZpZzsKPiArCWludCByZXQ7Cj4gKwo+ICsJaWYgKHRhcy0+c3Rh dGUgPT0gc3RhdGUpCj4gKwkJcmV0dXJuIDA7Cj4gKwo+ICsJc3dpdGNoIChzdGF0ZSkgewo+ICsJ Y2FzZSBUQVNfU1RBVEVfUkVTRVQ6Cj4gKwkJdGFzX3Jlc2V0KGVtYWMpOwo+ICsJCXJldCA9IGVt YWNfc2V0X3BvcnRfc3RhdGUoZW1hYywgSUNTU0dfRU1BQ19QT1JUX1RBU19SRVNFVCk7Cj4gKwkJ dGFzLT5zdGF0ZSA9IFRBU19TVEFURV9SRVNFVDsKPiArCQlicmVhazsKPiArCWNhc2UgVEFTX1NU QVRFX0VOQUJMRToKPiArCQlyZXQgPSBlbWFjX3NldF9wb3J0X3N0YXRlKGVtYWMsIElDU1NHX0VN QUNfUE9SVF9UQVNfRU5BQkxFKTsKPiArCQl0YXMtPnN0YXRlID0gVEFTX1NUQVRFX0VOQUJMRTsK PiArCQlicmVhazsKPiArCWNhc2UgVEFTX1NUQVRFX0RJU0FCTEU6Cj4gKwkJcmV0ID0gZW1hY19z ZXRfcG9ydF9zdGF0ZShlbWFjLCBJQ1NTR19FTUFDX1BPUlRfVEFTX0RJU0FCTEUpOwo+ICsJCXRh cy0+c3RhdGUgPSBUQVNfU1RBVEVfRElTQUJMRTsKPiArCQlicmVhazsKPiArCWRlZmF1bHQ6Cj4g KwkJbmV0ZGV2X2VycihlbWFjLT5uZGV2LCAiJXM6IHVuc3VwcG9ydGVkIHN0YXRlXG4iLCBfX2Z1 bmNfXyk7Cj4gKwkJcmV0ID0gLUVJTlZBTDsKPiArCQlicmVhazsKPiArCX0KPiArCj4gKwlpZiAo cmV0KQo+ICsJCW5ldGRldl9lcnIoZW1hYy0+bmRldiwgIlRBUyBzZXQgc3RhdGUgZmFpbGVkICVk XG4iLCByZXQpOwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIGludCB0YXNfc2V0 X3RyaWdnZXJfbGlzdF9jaGFuZ2Uoc3RydWN0IHBydWV0aF9lbWFjICplbWFjKQo+ICt7Cj4gKwlz dHJ1Y3QgdGNfdGFwcmlvX3FvcHRfb2ZmbG9hZCAqYWRtaW5fbGlzdCA9IGVtYWMtPnFvcy50YXMu dGFwcmlvX2FkbWluOwo+ICsJc3RydWN0IHRhc19jb25maWcgKnRhcyA9ICZlbWFjLT5xb3MudGFz LmNvbmZpZzsKPiArCXN0cnVjdCBwdHBfc3lzdGVtX3RpbWVzdGFtcCBzdHM7Cj4gKwl1MzIgY2hh bmdlX2N5Y2xlX2NvdW50Owo+ICsJdTMyIGN5Y2xlX3RpbWU7Cj4gKwl1NjQgYmFzZV90aW1lOwo+ ICsJdTY0IGN1cl90aW1lOwo+ICsKPiArCWlmIChhZG1pbl9saXN0LT5jeWNsZV90aW1lIDwgVEFT X01JTl9DWUNMRV9USU1FKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCWN5Y2xlX3RpbWUg PSBhZG1pbl9saXN0LT5jeWNsZV90aW1lIC0gNDsgLyogLTRucyB0byBjb21wZW5zYXRlIGZvciBJ RVAgd3JhcGFyb3VuZCB0aW1lICovCj4gKwliYXNlX3RpbWUgPSBhZG1pbl9saXN0LT5iYXNlX3Rp bWU7Cj4gKwljdXJfdGltZSA9IHBydWV0aF9pZXBfZ2V0dGltZShlbWFjLCAmc3RzKTsKPiArCj4g KwlpZiAoYmFzZV90aW1lID4gY3VyX3RpbWUpCj4gKwkJY2hhbmdlX2N5Y2xlX2NvdW50ID0gRElW X1JPVU5EX1VQX1VMTChiYXNlX3RpbWUgLSBjdXJfdGltZSwgY3ljbGVfdGltZSk7Cj4gKwllbHNl Cj4gKwkJY2hhbmdlX2N5Y2xlX2NvdW50ID0gMTsKPiArCj4gKwl3cml0ZWwoY3ljbGVfdGltZSwg ZW1hYy0+ZHJhbS52YSArIFRBU19BRE1JTl9DWUNMRV9USU1FKTsKPiArCXdyaXRlbChjaGFuZ2Vf Y3ljbGVfY291bnQsIGVtYWMtPmRyYW0udmEgKyBUQVNfQ09ORklHX0NIQU5HRV9DWUNMRV9DT1VO VCk7Cj4gKwl3cml0ZWIoYWRtaW5fbGlzdC0+bnVtX2VudHJpZXMsIGVtYWMtPmRyYW0udmEgKyBU QVNfQURNSU5fTElTVF9MRU5HVEgpOwo+ICsKPiArCS8qIGNvbmZpZ19jaGFuZ2UgY2xlYXJlZCBi eSBmL3cgdG8gYWNrIHJlY2VwdGlvbiBvZiBuZXcgc2hhZG93IGxpc3QgKi8KPiArCXdyaXRlYigx LCAmdGFzLT5jb25maWdfbGlzdC0+Y29uZmlnX2NoYW5nZSk7Cj4gKwkvKiBjb25maWdfcGVuZGlu ZyBjbGVhcmVkIGJ5IGYvdyB3aGVuIG5ldyBzaGFkb3cgbGlzdCBpcyBjb3BpZWQgdG8gYWN0aXZl IGxpc3QgKi8KPiArCXdyaXRlYigxLCAmdGFzLT5jb25maWdfbGlzdC0+Y29uZmlnX3BlbmRpbmcp Owo+ICsKPiArCXJldHVybiBlbWFjX3NldF9wb3J0X3N0YXRlKGVtYWMsIElDU1NHX0VNQUNfUE9S VF9UQVNfVFJJR0dFUik7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdGFzX3VwZGF0ZV9vcGVyX2xp c3Qoc3RydWN0IHBydWV0aF9lbWFjICplbWFjKQo+ICt7Cj4gKwlzdHJ1Y3QgdGNfdGFwcmlvX3Fv cHRfb2ZmbG9hZCAqYWRtaW5fbGlzdCA9IGVtYWMtPnFvcy50YXMudGFwcmlvX2FkbWluOwo+ICsJ c3RydWN0IHRhc19jb25maWcgKnRhcyA9ICZlbWFjLT5xb3MudGFzLmNvbmZpZzsKPiArCXUzMiB0 YXNfYWNjX2dhdGVfY2xvc2VfdGltZSA9IDA7Cj4gKwl1OCBpZHgsIGdhdGVfaWR4LCB2YWw7Cj4g KwlpbnQgcmV0Owo+ICsKPiArCWlmIChhZG1pbl9saXN0LT5jeWNsZV90aW1lID4gVEFTX01BWF9D WUNMRV9USU1FKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCXRhc191cGRhdGVfZndfbGlz dF9wb2ludGVycyhlbWFjKTsKPiArCj4gKwlmb3IgKGlkeCA9IDA7IGlkeCA8IGFkbWluX2xpc3Qt Pm51bV9lbnRyaWVzOyBpZHgrKykgewo+ICsJCXdyaXRlYihhZG1pbl9saXN0LT5lbnRyaWVzW2lk eF0uZ2F0ZV9tYXNrLAo+ICsJCSAgICAgICAmdGFzLT5md19zaGFkb3dfbGlzdC0+Z2F0ZV9tYXNr X2xpc3RbaWR4XSk7Cj4gKwkJdGFzX2FjY19nYXRlX2Nsb3NlX3RpbWUgKz0gYWRtaW5fbGlzdC0+ ZW50cmllc1tpZHhdLmludGVydmFsOwo+ICsKPiArCQkvKiBleHRlbmQgbGFzdCBlbnRyeSB0aWxs IGVuZCBvZiBjeWNsZSB0aW1lICovCj4gKwkJaWYgKGlkeCA9PSBhZG1pbl9saXN0LT5udW1fZW50 cmllcyAtIDEpCj4gKwkJCXdyaXRlbChhZG1pbl9saXN0LT5jeWNsZV90aW1lLAo+ICsJCQkgICAg ICAgJnRhcy0+Zndfc2hhZG93X2xpc3QtPndpbl9lbmRfdGltZV9saXN0W2lkeF0pOwo+ICsJCWVs c2UKPiArCQkJd3JpdGVsKHRhc19hY2NfZ2F0ZV9jbG9zZV90aW1lLAo+ICsJCQkgICAgICAgJnRh cy0+Zndfc2hhZG93X2xpc3QtPndpbl9lbmRfdGltZV9saXN0W2lkeF0pOwo+ICsJfQo+ICsKPiAr CS8qIGNsZWFyIHJlbWFpbmluZyBlbnRyaWVzICovCj4gKwlmb3IgKGlkeCA9IGFkbWluX2xpc3Qt Pm51bV9lbnRyaWVzOyBpZHggPCBUQVNfTUFYX0NNRF9MSVNUUzsgaWR4KyspIHsKPiArCQl3cml0 ZWIoMCwgJnRhcy0+Zndfc2hhZG93X2xpc3QtPmdhdGVfbWFza19saXN0W2lkeF0pOwo+ICsJCXdy aXRlbCgwLCAmdGFzLT5md19zaGFkb3dfbGlzdC0+d2luX2VuZF90aW1lX2xpc3RbaWR4XSk7Cj4g Kwl9Cj4gKwo+ICsJLyogdXBkYXRlIHRoZSBBcnJheSBvZiBnYXRlIGNsb3NlIHRpbWUgZm9yIGVh Y2ggcXVldWUgaW4gZWFjaCB3aW5kb3cgKi8KPiArCWZvciAoaWR4ID0gMCA7IGlkeCA8IGFkbWlu X2xpc3QtPm51bV9lbnRyaWVzOyBpZHgrKykgewo+ICsJCS8qIE9uIExpbnV4LCBvbmx5IFBSVUVU SF9NQVhfVFhfUVVFVUVTIGFyZSBzdXBwb3J0ZWQgcGVyIHBvcnQgKi8KPiArCQlmb3IgKGdhdGVf aWR4ID0gMDsgZ2F0ZV9pZHggPCBQUlVFVEhfTUFYX1RYX1FVRVVFUzsgZ2F0ZV9pZHgrKykgewo+ ICsJCQl1OCBnYXRlX21hc2tfbGlzdF9pZHggPSByZWFkYigmdGFzLT5md19zaGFkb3dfbGlzdC0+ Z2F0ZV9tYXNrX2xpc3RbaWR4XSk7Cj4gKwkJCXUzMiBnYXRlX2Nsb3NlX3RpbWUgPSAwOwo+ICsK PiArCQkJaWYgKGdhdGVfbWFza19saXN0X2lkeCAmIEJJVChnYXRlX2lkeCkpCj4gKwkJCQlnYXRl X2Nsb3NlX3RpbWUgPSByZWFkbCgmdGFzLT5md19zaGFkb3dfbGlzdC0+d2luX2VuZF90aW1lX2xp c3RbaWR4XSk7Cj4gKwo+ICsJCQl3cml0ZWwoZ2F0ZV9jbG9zZV90aW1lLAo+ICsJCQkgICAgICAg JnRhcy0+Zndfc2hhZG93X2xpc3QtPmdhdGVfY2xvc2VfdGltZV9saXN0W2lkeF1bZ2F0ZV9pZHhd KTsKPiArCQl9Cj4gKwl9Cj4gKwo+ICsJLyogdGVsbCBmL3cgdG8gc3dhcCBhY3RpdmUgJiBzaGFk b3cgbGlzdCAqLwo+ICsJcmV0ID0gdGFzX3NldF90cmlnZ2VyX2xpc3RfY2hhbmdlKGVtYWMpOwo+ ICsJaWYgKHJldCkgewo+ICsJCW5ldGRldl9lcnIoZW1hYy0+bmRldiwgImZhaWxlZCB0byBzd2Fw IGYvdyBjb25maWcgbGlzdDogJWRcbiIsIHJldCk7Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0KPiAr Cj4gKwkvKiBXYWl0IGZvciBjb21wbGV0aW9uICovCj4gKwlyZXQgPSByZWFkYl9wb2xsX3RpbWVv dXQoJnRhcy0+Y29uZmlnX2xpc3QtPmNvbmZpZ19jaGFuZ2UsIHZhbCwgIXZhbCwKPiArCQkJCSBV U0VDX1BFUl9NU0VDLCAxMCAqIFVTRUNfUEVSX01TRUMpOwo+ICsJaWYgKHJldCkgewo+ICsJCW5l dGRldl9lcnIoZW1hYy0+bmRldiwgIlRBUyBsaXN0IGNoYW5nZSBjb21wbGV0aW9uIHRpbWUgb3V0 XG4iKTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsKPiArCXRhc191cGRhdGVfZndfbGlzdF9w b2ludGVycyhlbWFjKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQg ZW1hY19jcF90YXByaW8oc3RydWN0IHRjX3RhcHJpb19xb3B0X29mZmxvYWQgKmZyb20sCj4gKwkJ CSAgIHN0cnVjdCB0Y190YXByaW9fcW9wdF9vZmZsb2FkICp0bykKPiArewo+ICsJaW50IGk7Cj4g Kwo+ICsJKnRvID0gKmZyb207Cj4gKwlmb3IgKGkgPSAwOyBpIDwgZnJvbS0+bnVtX2VudHJpZXM7 IGkrKykKPiArCQl0by0+ZW50cmllc1tpXSA9IGZyb20tPmVudHJpZXNbaV07Cj4gK30KPiArCj4g K3N0YXRpYyBpbnQgZW1hY190YXByaW9fcmVwbGFjZShzdHJ1Y3QgbmV0X2RldmljZSAqbmRldiwK PiArCQkJICAgICAgIHN0cnVjdCB0Y190YXByaW9fcW9wdF9vZmZsb2FkICp0YXByaW8pCj4gK3sK PiArCXN0cnVjdCBwcnVldGhfZW1hYyAqZW1hYyA9IG5ldGRldl9wcml2KG5kZXYpOwo+ICsJc3Ry dWN0IHRjX3RhcHJpb19xb3B0X29mZmxvYWQgKmVzdF9uZXc7Cj4gKwlpbnQgcmV0LCBpZHg7Cj4g Kwo+ICsJaWYgKHRhcHJpby0+Y3ljbGVfdGltZV9leHRlbnNpb24pIHsKPiArCQluZXRkZXZfZXJy KG5kZXYsICJGYWlsZWQgdG8gc2V0IGN5Y2xlIHRpbWUgZXh0ZW5zaW9uIik7Cj4gKwkJcmV0dXJu IC1FT1BOT1RTVVBQOwo+ICsJfQo+ICsKPiArCWlmICh0YXByaW8tPm51bV9lbnRyaWVzID09IDAg fHwKPiArCSAgICB0YXByaW8tPm51bV9lbnRyaWVzID4gVEFTX01BWF9DTURfTElTVFMpIHsKPiAr CQlOTF9TRVRfRVJSX01TR19GTVRfTU9EKHRhcHJpby0+ZXh0YWNrLCAidW5zdXBwb3J0ZWQgbnVt X2VudHJpZXMgJWxkIGluIHRhcHJpbyBjb25maWdcbiIsCj4gKwkJCQkgICAgICAgdGFwcmlvLT5u dW1fZW50cmllcyk7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJLyogSWYgYW55 IHRpbWVfaW50ZXJ2YWwgaXMgMCBpbiBiZXR3ZWVuIHRoZSBsaXN0LCB0aGVuIGV4aXQgKi8KPiAr CWZvciAoaWR4ID0gMDsgaWR4IDwgdGFwcmlvLT5udW1fZW50cmllczsgaWR4KyspIHsKPiArCQlp ZiAodGFwcmlvLT5lbnRyaWVzW2lkeF0uaW50ZXJ2YWwgPT0gMCkgewo+ICsJCQlOTF9TRVRfRVJS X01TR19NT0QodGFwcmlvLT5leHRhY2ssICIwIGludGVydmFsIGluIHRhcHJpbyBjb25maWcgbm90 IHN1cHBvcnRlZFxuIik7Cj4gKwkJCXJldHVybiAtRUlOVkFMOwo+ICsJCX0KPiArCX0KPiArCj4g KwlpZiAoZW1hYy0+cW9zLnRhcy50YXByaW9fYWRtaW4pCj4gKwkJZGV2bV9rZnJlZSgmbmRldi0+ ZGV2LCBlbWFjLT5xb3MudGFzLnRhcHJpb19hZG1pbik7Cj4gKwo+ICsJZXN0X25ldyA9IGRldm1f a3phbGxvYygmbmRldi0+ZGV2LAo+ICsJCQkgICAgICAgc3RydWN0X3NpemUoZXN0X25ldywgZW50 cmllcywgdGFwcmlvLT5udW1fZW50cmllcyksCj4gKwkJCSAgICAgICBHRlBfS0VSTkVMKTsKPiAr CWlmICghZXN0X25ldykKPiArCQlyZXR1cm4gLUVOT01FTTsKPiArCj4gKwllbWFjX2NwX3RhcHJp byh0YXByaW8sIGVzdF9uZXcpOwo+ICsJZW1hYy0+cW9zLnRhcy50YXByaW9fYWRtaW4gPSBlc3Rf bmV3Owo+ICsJcmV0ID0gdGFzX3VwZGF0ZV9vcGVyX2xpc3QoZW1hYyk7Cj4gKwlpZiAocmV0KQo+ ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0ID0gIHRhc19zZXRfc3RhdGUoZW1hYywgVEFTX1NU QVRFX0VOQUJMRSk7CgpUaGUgZG91YmxlIHNwYWNlIGlzIHN0aWxsIGhlcmUuLi4KCj4gKwlpZiAo cmV0KQo+ICsJCWRldm1fa2ZyZWUoJm5kZXYtPmRldiwgZXN0X25ldyk7CgouLi4gYXMgaXMgdGhl IGZyZWUnaW5nIG9mICdlc3RfbmV3JyB3aGlsZSAndGFwcmlvX2FkbWluJyBzdGlsbCBwb2ludHMg dG8gaXQuCgo+ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgZW1hY190 YXByaW9fZGVzdHJveShzdHJ1Y3QgbmV0X2RldmljZSAqbmRldikKPiArewo+ICsJc3RydWN0IHBy dWV0aF9lbWFjICplbWFjID0gbmV0ZGV2X3ByaXYobmRldik7Cj4gKwlpbnQgcmV0Owo+ICsKPiAr CXJldCA9IHRhc19zZXRfc3RhdGUoZW1hYywgVEFTX1NUQVRFX1JFU0VUKTsKPiArCWlmIChyZXQp Cj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwlyZXR1cm4gdGFzX3NldF9zdGF0ZShlbWFjLCBUQVNf U1RBVEVfRElTQUJMRSk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgZW1hY19zZXR1cF90YXByaW8o c3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIHZvaWQgKnR5cGVfZGF0YSkKPiArewo+ICsJc3RydWN0 IHRjX3RhcHJpb19xb3B0X29mZmxvYWQgKnRhcHJpbyA9IHR5cGVfZGF0YTsKPiArCWludCByZXQ7 Cj4gKwo+ICsJc3dpdGNoICh0YXByaW8tPmNtZCkgewo+ICsJY2FzZSBUQVBSSU9fQ01EX1JFUExB Q0U6Cj4gKwkJcmV0ID0gZW1hY190YXByaW9fcmVwbGFjZShuZGV2LCB0YXByaW8pOwo+ICsJCWJy ZWFrOwo+ICsJY2FzZSBUQVBSSU9fQ01EX0RFU1RST1k6Cj4gKwkJcmV0ID0gZW1hY190YXByaW9f ZGVzdHJveShuZGV2KTsKPiArCQlicmVhazsKPiArCWRlZmF1bHQ6Cj4gKwkJcmV0ID0gLUVPUE5P VFNVUFA7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiAraW50IGljc3NnX3Fv c19uZG9fc2V0dXBfdGMoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIGVudW0gdGNfc2V0dXBfdHlw ZSB0eXBlLAo+ICsJCQkgICB2b2lkICp0eXBlX2RhdGEpCj4gK3sKPiArCXN3aXRjaCAodHlwZSkg ewo+ICsJY2FzZSBUQ19TRVRVUF9RRElTQ19UQVBSSU86Cj4gKwkJcmV0dXJuIGVtYWNfc2V0dXBf dGFwcmlvKG5kZXYsIHR5cGVfZGF0YSk7Cj4gKwlkZWZhdWx0Ogo+ICsJCXJldHVybiAtRU9QTk9U U1VQUDsKPiArCX0KPiArfQo+ICsKPiArdm9pZCBpY3NzZ19xb3NfdGFzX2luaXQoc3RydWN0IG5l dF9kZXZpY2UgKm5kZXYpCj4gK3sKPiArCXN0cnVjdCBwcnVldGhfZW1hYyAqZW1hYyA9IG5ldGRl dl9wcml2KG5kZXYpOwo+ICsJc3RydWN0IHRhc19jb25maWcgKnRhczsKPiArCj4gKwl0YXMgPSAm ZW1hYy0+cW9zLnRhcy5jb25maWc7Cj4gKwo+ICsJdGFzLT5jb25maWdfbGlzdCA9IGVtYWMtPmRy YW0udmEgKyBUQVNfQ09ORklHX0NIQU5HRV9USU1FOwo+ICsJdGFzLT5hY3RpdmVfbGlzdCA9IGVt YWMtPmRyYW0udmEgKyBUQVNfQUNUSVZFX0xJU1RfSU5ERVg7Cj4gKwo+ICsJdGFzX3VwZGF0ZV9m d19saXN0X3BvaW50ZXJzKGVtYWMpOwo+ICsKPiArCXRhc19zZXRfc3RhdGUoZW1hYywgVEFTX1NU QVRFX1JFU0VUKTsKPiArfQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC90aS9p Y3NzZy9pY3NzZ19xb3MuaCBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3RpL2ljc3NnL2ljc3NnX3Fv cy5oCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLjI1YmFjY2Rk MWNlNQo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC90aS9pY3Nz Zy9pY3NzZ19xb3MuaAo+IEBAIC0wLDAgKzEsMTEzIEBACj4gKy8qIFNQRFgtTGljZW5zZS1JZGVu dGlmaWVyOiBHUEwtMi4wICovCj4gKy8qIENvcHlyaWdodCAoQykgMjAyMyBUZXhhcyBJbnN0cnVt ZW50cyBJbmNvcnBvcmF0ZWQgLSBodHRwOi8vd3d3LnRpLmNvbS8KPiArICovCj4gKwo+ICsjaWZu ZGVmIF9fTkVUX1RJX0lDU1NHX1FPU19ICj4gKyNkZWZpbmUgX19ORVRfVElfSUNTU0dfUU9TX0gK PiArCj4gKyNpbmNsdWRlIDxsaW51eC9hdG9taWMuaD4KPiArI2luY2x1ZGUgPGxpbnV4L25ldGRl dmljZS5oPgo+ICsjaW5jbHVkZSA8bmV0L3BrdF9zY2hlZC5oPgo+ICsKPiArLyogTWF4aW11bSBu dW1iZXIgb2YgZ2F0ZSBjb21tYW5kIGVudHJpZXMgaW4gZWFjaCBsaXN0LiAqLwo+ICsjZGVmaW5l IFRBU19NQVhfQ01EX0xJU1RTICAgKDE2KQo+ICsKPiArLyogTWF4aW11bSBudW1iZXIgb2YgdHJh bnNtaXQgcXVldWVzIHN1cHBvcnRlZCBieSBpbXBsZW1lbnRhdGlvbiAqLwo+ICsjZGVmaW5lIFRB U19NQVhfTlVNX1FVRVVFUyAgKDgpCj4gKwo+ICsvKiBNaW5pbXVtIGN5Y2xlIHRpbWUgc3VwcG9y dGVkIGJ5IGltcGxlbWVudGF0aW9uIChpbiBucykgKi8KPiArI2RlZmluZSBUQVNfTUlOX0NZQ0xF X1RJTUUgICgxMDAwMDAwKQo+ICsKPiArLyogTWluaW11bSBjeWNsZSB0aW1lIHN1cHBvcnRlZCBi eSBpbXBsZW1lbnRhdGlvbiAoaW4gbnMpICovCj4gKyNkZWZpbmUgVEFTX01BWF9DWUNMRV9USU1F ICAoNDAwMDAwMDAwMCkKPiArCj4gKy8qIE1pbmltdW0gVEFTIHdpbmRvdyBkdXJhdGlvbiBzdXBw b3J0ZWQgYnkgaW1wbGVtZW50YXRpb24gKGluIG5zKSAqLwo+ICsjZGVmaW5lIFRBU19NSU5fV0lO RE9XX0RVUkFUSU9OICAoMTAwMDApCj4gKwo+ICsvKioKPiArICogZW51bSB0YXNfbGlzdF9udW0g LSBUQVMgbGlzdCBudW1iZXIKPiArICogQFRBU19MSVNUMDogVEFTIGxpc3QgbnVtYmVyIGlzIDAK PiArICogQFRBU19MSVNUMTogVEFTIGxpc3QgbnVtYmVyIGlzIDEKPiArICovCj4gK2VudW0gdGFz X2xpc3RfbnVtIHsKPiArCVRBU19MSVNUMCA9IDAsCj4gKwlUQVNfTElTVDEgPSAxCj4gK307Cj4g Kwo+ICsvKioKPiArICogZW51bSB0YXNfc3RhdGUgLSBTdGF0ZSBvZiBUQVMgaW4gZmlybXdhcmUK PiArICogQFRBU19TVEFURV9ESVNBQkxFOiBUQVMgc3RhdGUgbWFjaGluZSBpcyBkaXNhYmxlZC4K PiArICogQFRBU19TVEFURV9FTkFCTEU6IFRBUyBzdGF0ZSBtYWNoaW5lIGlzIGVuYWJsZWQuCj4g KyAqIEBUQVNfU1RBVEVfUkVTRVQ6IFRBUyBzdGF0ZSBtYWNoaW5lIGlzIHJlc2V0Lgo+ICsgKi8K PiArZW51bSB0YXNfc3RhdGUgewo+ICsJVEFTX1NUQVRFX0RJU0FCTEUgPSAwLAo+ICsJVEFTX1NU QVRFX0VOQUJMRSA9IDEsCj4gKwlUQVNfU1RBVEVfUkVTRVQgPSAyLAo+ICt9Owo+ICsKPiArLyoq Cj4gKyAqIHN0cnVjdCB0YXNfY29uZmlnX2xpc3QgLSBDb25maWcgc3RhdGUgbWFjaGluZSB2YXJp YWJsZXMKPiArICogQGNvbmZpZ19jaGFuZ2VfdGltZTogTmV3IGxpc3QgaXMgY29waWVkIGF0IHRo aXMgdGltZQo+ICsgKiBAY29uZmlnX2NoYW5nZV9lcnJvcl9jb3VudGVyOiBJbmNyZW1lbnRlZCBp ZiBhZG1pbi0+QmFzZVRpbWUgPCBjdXJyZW50IHRpbWUKPiArICoJCQkJIGFuZCBUQVNfZW5hYmxl ZCBpcyB0cnVlCj4gKyAqIEBjb25maWdfcGVuZGluZzogVHJ1ZSBpZiBsaXN0IHVwZGF0ZSBpcyBw ZW5kaW5nCj4gKyAqIEBjb25maWdfY2hhbmdlOiBTZXQgdG8gdHJ1ZSB3aGVuIGFwcGxpY2F0aW9u IHRyaWdnZXIgdXBkYXRpbmcgb2YgYWRtaW4gbGlzdAo+ICsgKgkJICAgdG8gYWN0aXZlIGxpc3Qs IGNsZWFyZWQgd2hlbiBjb25maWdDaGFuZ2VUaW1lIGlzIHVwZGF0ZWQKPiArICovCj4gK3N0cnVj dCB0YXNfY29uZmlnX2xpc3Qgewo+ICsJdTY0IGNvbmZpZ19jaGFuZ2VfdGltZTsKPiArCXUzMiBj b25maWdfY2hhbmdlX2Vycm9yX2NvdW50ZXI7Cj4gKwl1OCBjb25maWdfcGVuZGluZzsKPiArCXU4 IGNvbmZpZ19jaGFuZ2U7Cj4gK307Cj4gKwo+ICsvKiBNYXggU0RVIHRhYmxlLiBTZWUgSUVFRSBT dGQgODAyLjFRLTIwMTggMTIuMjkuMS4xICovCj4gK3N0cnVjdCB0YXNfbWF4X3NkdV90YWJsZSB7 Cj4gKwl1MTYgbWF4X3NkdVtUQVNfTUFYX05VTV9RVUVVRVNdOwo+ICt9Owo+ICsKPiArLyoqCj4g KyAqIHN0cnVjdCB0YXNfZmlybXdhcmVfbGlzdCAtIFRBUyBMaXN0IFN0cnVjdHVyZSBiYXNlZCBv biBmaXJtd2FyZSBtZW1vcnkgbWFwCj4gKyAqIEBnYXRlX21hc2tfbGlzdDogV2luZG93IGdhdGUg bWFzayBsaXN0Cj4gKyAqIEB3aW5fZW5kX3RpbWVfbGlzdDogV2luZG93IGVuZCB0aW1lIGxpc3QK PiArICogQGdhdGVfY2xvc2VfdGltZV9saXN0OiBBcnJheSBvZiBnYXRlIGNsb3NlIHRpbWUgZm9y IGVhY2ggcXVldWUgaW4gZWFjaCB3aW5kb3cKPiArICovCj4gK3N0cnVjdCB0YXNfZmlybXdhcmVf bGlzdCB7Cj4gKwl1OCBnYXRlX21hc2tfbGlzdFtUQVNfTUFYX0NNRF9MSVNUU107Cj4gKwl1MzIg d2luX2VuZF90aW1lX2xpc3RbVEFTX01BWF9DTURfTElTVFNdOwo+ICsJdTMyIGdhdGVfY2xvc2Vf dGltZV9saXN0W1RBU19NQVhfQ01EX0xJU1RTXVtUQVNfTUFYX05VTV9RVUVVRVNdOwo+ICt9Owo+ ICsKPiArLyoqCj4gKyAqIHN0cnVjdCB0YXNfY29uZmlnIC0gTWFpbiBUaW1lIEF3YXJlIFNoYXBl ciBIYW5kbGUKPiArICogQHN0YXRlOiBUQVMgc3RhdGUKPiArICogQG1heF9zZHVfdGFibGU6IE1h eCBTRFUgdGFibGUKPiArICogQGNvbmZpZ19saXN0OiBDb25maWcgY2hhbmdlIHZhcmlhYmxlcwo+ ICsgKiBAYWN0aXZlX2xpc3Q6IEN1cnJlbnQgb3BlcmF0aW5nIGxpc3Qgb3BlcmF0aW5nIGxpc3QK PiArICogQGZ3X2FjdGl2ZV9saXN0OiBBY3RpdmUgTGlzdCBwb2ludGVyLCB1c2VkIGJ5IGZpcm13 YXJlCj4gKyAqIEBmd19zaGFkb3dfbGlzdDogU2hhZG93IExpc3QgcG9pbnRlciwgdXNlZCBieSBk cml2ZXIKPiArICovCj4gK3N0cnVjdCB0YXNfY29uZmlnIHsKPiArCWVudW0gdGFzX3N0YXRlIHN0 YXRlOwo+ICsJc3RydWN0IHRhc19tYXhfc2R1X3RhYmxlIG1heF9zZHVfdGFibGU7Cj4gKwlzdHJ1 Y3QgdGFzX2NvbmZpZ19saXN0IF9faW9tZW0gKmNvbmZpZ19saXN0Owo+ICsJdTggX19pb21lbSAq YWN0aXZlX2xpc3Q7Cj4gKwlzdHJ1Y3QgdGFzX2Zpcm13YXJlX2xpc3QgX19pb21lbSAqZndfYWN0 aXZlX2xpc3Q7Cj4gKwlzdHJ1Y3QgdGFzX2Zpcm13YXJlX2xpc3QgX19pb21lbSAqZndfc2hhZG93 X2xpc3Q7Cj4gK307Cj4gKwo+ICtzdHJ1Y3QgcHJ1ZXRoX3Fvc190YXMgewo+ICsJc3RydWN0IHRj X3RhcHJpb19xb3B0X29mZmxvYWQgKnRhcHJpb19hZG1pbjsKPiArCXN0cnVjdCB0Y190YXByaW9f cW9wdF9vZmZsb2FkICp0YXByaW9fb3BlcjsKPiArCXN0cnVjdCB0YXNfY29uZmlnIGNvbmZpZzsK PiArfTsKPiArCj4gK3N0cnVjdCBwcnVldGhfcW9zIHsKPiArCXN0cnVjdCBwcnVldGhfcW9zX3Rh cyB0YXM7Cj4gK307Cj4gKwo+ICt2b2lkIGljc3NnX3Fvc190YXNfaW5pdChzdHJ1Y3QgbmV0X2Rl dmljZSAqbmRldik7Cj4gK2ludCBpY3NzZ19xb3NfbmRvX3NldHVwX3RjKHN0cnVjdCBuZXRfZGV2 aWNlICpuZGV2LCBlbnVtIHRjX3NldHVwX3R5cGUgdHlwZSwKPiArCQkJICAgdm9pZCAqdHlwZV9k YXRhKTsKPiArI2VuZGlmIC8qIF9fTkVUX1RJX0lDU1NHX1FPU19IICovCj4gLS0gCj4gMi4zNC4x Cj4KCi0tIApWaW5pY2l1cwoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBs aXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlz dGluZm8vbGludXgtYXJtLWtlcm5lbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 74EA2E94136 for ; Fri, 6 Oct 2023 22:31:13 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233737AbjJFWbL (ORCPT ); Fri, 6 Oct 2023 18:31:11 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59378 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233473AbjJFWbJ (ORCPT ); Fri, 6 Oct 2023 18:31:09 -0400 Received: from mgamail.intel.com (mgamail.intel.com [192.55.52.136]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4B023A2; Fri, 6 Oct 2023 15:31:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1696631467; x=1728167467; h=from:to:cc:subject:in-reply-to:references:date: message-id:mime-version:content-transfer-encoding; bh=1Xh5Xl6zIju/WmK1saMVcq0Jh6v2ct7XttOxs4wQacA=; b=OniiqDy2ghSTdl3lq6IAo0Q7lnK7UFCL3233nLwkYV/mvRA+hCeJPevB +c2HAcQD7jAcNwSSo7IrczkNyx5brVkiqr7QKWeOiZ6BGQIhtE5wtU4+N d3Bzyltz7ZPeSXaTgZ0J7z8kcVglXRWqlgHPRKs8ULnTvkDKiu+8yCzMk 4U6Tm4z8ioP6GU5PCuyqhsqnhcU3ZoBDEllHPVsh17Nq1SFFU1F6Kv3Y6 lA41lc9JsLuE0ZSjRbTbdmTscV7hVKReSMYd9EJ6Nu+RQMFWmSElfYlIq rWUnZYFLRD5ucAAUiMWNM4zTxLe5EC2N0qGChit6mALymt3x58BOqgv39 A==; X-IronPort-AV: E=McAfee;i="6600,9927,10855"; a="363198135" X-IronPort-AV: E=Sophos;i="6.03,204,1694761200"; d="scan'208";a="363198135" Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by fmsmga106.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Oct 2023 15:31:05 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10855"; a="1083607625" X-IronPort-AV: E=Sophos;i="6.03,204,1694761200"; d="scan'208";a="1083607625" Received: from vcostago-mobl3.jf.intel.com (HELO vcostago-mobl3) ([10.24.14.106]) by fmsmga005-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Oct 2023 15:31:04 -0700 From: Vinicius Costa Gomes To: MD Danish Anwar , Andrew Lunn , Roger Quadros , Vignesh Raghavendra , MD Danish Anwar , Richard Cochran , Paolo Abeni , Jakub Kicinski , Eric Dumazet , "David S. Miller" , vladimir.oltean@nxp.com, Simon Horman Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, srk@ti.com, r-gunasekaran@ti.com, linux-arm-kernel@lists.infradead.org, Roger Quadros Subject: Re: [PATCH net-next v4] net: ti: icssg_prueth: add TAPRIO offload support In-Reply-To: <20231006102028.3831341-1-danishanwar@ti.com> References: <20231006102028.3831341-1-danishanwar@ti.com> Date: Fri, 06 Oct 2023 15:31:03 -0700 Message-ID: <87cyxr8jtk.fsf@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org MD Danish Anwar writes: > From: Roger Quadros > > ICSSG dual-emac f/w supports Enhanced Scheduled Traffic (EST =E2=80=93 de= fined > in P802.1Qbv/D2.2 that later got included in IEEE 802.1Q-2018) > configuration. EST allows express queue traffic to be scheduled > (placed) on the wire at specific repeatable time intervals. In > Linux kernel, EST configuration is done through tc command and > the taprio scheduler in the net core implements a software only > scheduler (SCH_TAPRIO). If the NIC is capable of EST configuration, > user indicate "flag 2" in the command which is then parsed by > taprio scheduler in net core and indicate that the command is to > be offloaded to h/w. taprio then offloads the command to the > driver by calling ndo_setup_tc() ndo ops. This patch implements > ndo_setup_tc() to offload EST configuration to ICSSG. > > Signed-off-by: Roger Quadros > Signed-off-by: Vignesh Raghavendra > Signed-off-by: MD Danish Anwar > --- > Cc: Roger Quadros > Cc: Andrew Lunn > Cc: Vinicius Costa Gomes > Cc: Jakub Kicinski > > Changes from v3 to v4: > *) Rebased on the latest next-20231005 linux-next. > *) Addressed Roger and Vinicius' comments and moved all the validations to > emac_taprio_replace() API. > *) Modified emac_setup_taprio() API to use switch case based on taprio->c= md > and added emac_taprio_destroy() and emac_taprio_replace() APIs. > *) Modified the documentation of structs / enums in icssg_qos.h by using > the correct kdoc format. > > Changes from v2 to v3: > *) Rebased on the latest next-20230928 linux-next. > *) Retained original authorship of the patch. > *) Addressed Roger's comments and modified emac_setup_taprio() and > emac_set_taprio() APIs accordingly. > *) Removed netif_running() check from emac_setup_taprio(). > *) Addressed Vinicius' comments and added check for MIN and MAX cycle tim= e. > *) Added check for allocation failure of est_new in emac_setup_taprio(). > > Changes from v1 to v2: > *) Rebased on the latest next-20230921 linux-next. > *) Dropped the RFC tag as merge window is open now. > *) Splitted this patch from the switch mode series [v1]. > *) Removed TODO comment as asked by Andrew and Roger. > *) Changed Copyright to 2023 as asked by Roger. > > v3: https://lore.kernel.org/all/20230928103000.186304-1-danishanwar@ti.co= m/ > v2: https://lore.kernel.org/all/20230921070031.795788-1-danishanwar@ti.co= m/ > v1: https://lore.kernel.org/all/20230830110847.1219515-1-danishanwar@ti.c= om/ > > drivers/net/ethernet/ti/Makefile | 3 +- > drivers/net/ethernet/ti/icssg/icssg_prueth.c | 5 +- > drivers/net/ethernet/ti/icssg/icssg_prueth.h | 6 + > drivers/net/ethernet/ti/icssg/icssg_qos.c | 301 +++++++++++++++++++ > drivers/net/ethernet/ti/icssg/icssg_qos.h | 113 +++++++ > 5 files changed, 426 insertions(+), 2 deletions(-) > create mode 100644 drivers/net/ethernet/ti/icssg/icssg_qos.c > create mode 100644 drivers/net/ethernet/ti/icssg/icssg_qos.h > > diff --git a/drivers/net/ethernet/ti/Makefile b/drivers/net/ethernet/ti/M= akefile > index 34fd7a716ba6..0df60ded1b2d 100644 > --- a/drivers/net/ethernet/ti/Makefile > +++ b/drivers/net/ethernet/ti/Makefile > @@ -37,5 +37,6 @@ icssg-prueth-y :=3D k3-cppi-desc-pool.o \ > icssg/icssg_config.o \ > icssg/icssg_mii_cfg.o \ > icssg/icssg_stats.o \ > - icssg/icssg_ethtool.o > + icssg/icssg_ethtool.o \ > + icssg/icssg_qos.o > obj-$(CONFIG_TI_ICSS_IEP) +=3D icssg/icss_iep.o > diff --git a/drivers/net/ethernet/ti/icssg/icssg_prueth.c b/drivers/net/e= thernet/ti/icssg/icssg_prueth.c > index 6635b28bc672..89c301716926 100644 > --- a/drivers/net/ethernet/ti/icssg/icssg_prueth.c > +++ b/drivers/net/ethernet/ti/icssg/icssg_prueth.c > @@ -1166,7 +1166,7 @@ static int emac_phy_connect(struct prueth_emac *ema= c) > return 0; > } >=20=20 > -static u64 prueth_iep_gettime(void *clockops_data, struct ptp_system_tim= estamp *sts) > +u64 prueth_iep_gettime(void *clockops_data, struct ptp_system_timestamp = *sts) > { > u32 hi_rollover_count, hi_rollover_count_r; > struct prueth_emac *emac =3D clockops_data; > @@ -1403,6 +1403,8 @@ static int emac_ndo_open(struct net_device *ndev) > napi_enable(&emac->tx_chns[i].napi_tx); > napi_enable(&emac->napi_rx); >=20=20 > + icssg_qos_tas_init(ndev); > + > /* start PHY */ > phy_start(ndev->phydev); >=20=20 > @@ -1669,6 +1671,7 @@ static const struct net_device_ops emac_netdev_ops = =3D { > .ndo_set_rx_mode =3D emac_ndo_set_rx_mode, > .ndo_eth_ioctl =3D emac_ndo_ioctl, > .ndo_get_stats64 =3D emac_ndo_get_stats64, > + .ndo_setup_tc =3D icssg_qos_ndo_setup_tc, > }; >=20=20 > /* get emac_port corresponding to eth_node name */ > diff --git a/drivers/net/ethernet/ti/icssg/icssg_prueth.h b/drivers/net/e= thernet/ti/icssg/icssg_prueth.h > index 8b6d6b497010..7cbf0e561905 100644 > --- a/drivers/net/ethernet/ti/icssg/icssg_prueth.h > +++ b/drivers/net/ethernet/ti/icssg/icssg_prueth.h > @@ -37,6 +37,7 @@ > #include "icssg_config.h" > #include "icss_iep.h" > #include "icssg_switch_map.h" > +#include "icssg_qos.h" >=20=20 > #define PRUETH_MAX_MTU (2000 - ETH_HLEN - ETH_FCS_LEN) > #define PRUETH_MIN_PKT_SIZE (VLAN_ETH_ZLEN) > @@ -174,6 +175,8 @@ struct prueth_emac { >=20=20 > struct pruss_mem_region dram; >=20=20 > + struct prueth_qos qos; > + > struct delayed_work stats_work; > u64 stats[ICSSG_NUM_STATS]; > }; > @@ -285,4 +288,7 @@ u32 icssg_queue_level(struct prueth *prueth, int queu= e); > void emac_stats_work_handler(struct work_struct *work); > void emac_update_hardware_stats(struct prueth_emac *emac); > int emac_get_stat_by_name(struct prueth_emac *emac, char *stat_name); > + > +u64 prueth_iep_gettime(void *clockops_data, struct ptp_system_timestamp = *sts); > + > #endif /* __NET_TI_ICSSG_PRUETH_H */ > diff --git a/drivers/net/ethernet/ti/icssg/icssg_qos.c b/drivers/net/ethe= rnet/ti/icssg/icssg_qos.c > new file mode 100644 > index 000000000000..c8c4450c41bb > --- /dev/null > +++ b/drivers/net/ethernet/ti/icssg/icssg_qos.c > @@ -0,0 +1,301 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* Texas Instruments ICSSG PRUETH QoS submodule > + * Copyright (C) 2023 Texas Instruments Incorporated - http://www.ti.com/ > + */ > + > +#include > +#include "icssg_prueth.h" > +#include "icssg_switch_map.h" > + > +static void tas_update_fw_list_pointers(struct prueth_emac *emac) > +{ > + struct tas_config *tas =3D &emac->qos.tas.config; > + > + if ((readb(tas->active_list)) =3D=3D TAS_LIST0) { > + tas->fw_active_list =3D emac->dram.va + TAS_GATE_MASK_LIST0; > + tas->fw_shadow_list =3D emac->dram.va + TAS_GATE_MASK_LIST1; > + } else { > + tas->fw_active_list =3D emac->dram.va + TAS_GATE_MASK_LIST1; > + tas->fw_shadow_list =3D emac->dram.va + TAS_GATE_MASK_LIST0; > + } > +} > + > +static void tas_update_maxsdu_table(struct prueth_emac *emac) > +{ > + struct tas_config *tas =3D &emac->qos.tas.config; > + u16 __iomem *max_sdu_tbl_ptr; > + u8 gate_idx; > + > + /* update the maxsdu table */ > + max_sdu_tbl_ptr =3D emac->dram.va + TAS_QUEUE_MAX_SDU_LIST; > + > + for (gate_idx =3D 0; gate_idx < TAS_MAX_NUM_QUEUES; gate_idx++) > + writew(tas->max_sdu_table.max_sdu[gate_idx], &max_sdu_tbl_ptr[gate_idx= ]); > +} > + > +static void tas_reset(struct prueth_emac *emac) > +{ > + struct tas_config *tas =3D &emac->qos.tas.config; > + int i; > + > + for (i =3D 0; i < TAS_MAX_NUM_QUEUES; i++) > + tas->max_sdu_table.max_sdu[i] =3D 2048; > + > + tas_update_maxsdu_table(emac); > + > + writeb(TAS_LIST0, tas->active_list); > + > + memset_io(tas->fw_active_list, 0, sizeof(*tas->fw_active_list)); > + memset_io(tas->fw_shadow_list, 0, sizeof(*tas->fw_shadow_list)); > +} > + > +static int tas_set_state(struct prueth_emac *emac, enum tas_state state) > +{ > + struct tas_config *tas =3D &emac->qos.tas.config; > + int ret; > + > + if (tas->state =3D=3D state) > + return 0; > + > + switch (state) { > + case TAS_STATE_RESET: > + tas_reset(emac); > + ret =3D emac_set_port_state(emac, ICSSG_EMAC_PORT_TAS_RESET); > + tas->state =3D TAS_STATE_RESET; > + break; > + case TAS_STATE_ENABLE: > + ret =3D emac_set_port_state(emac, ICSSG_EMAC_PORT_TAS_ENABLE); > + tas->state =3D TAS_STATE_ENABLE; > + break; > + case TAS_STATE_DISABLE: > + ret =3D emac_set_port_state(emac, ICSSG_EMAC_PORT_TAS_DISABLE); > + tas->state =3D TAS_STATE_DISABLE; > + break; > + default: > + netdev_err(emac->ndev, "%s: unsupported state\n", __func__); > + ret =3D -EINVAL; > + break; > + } > + > + if (ret) > + netdev_err(emac->ndev, "TAS set state failed %d\n", ret); > + return ret; > +} > + > +static int tas_set_trigger_list_change(struct prueth_emac *emac) > +{ > + struct tc_taprio_qopt_offload *admin_list =3D emac->qos.tas.taprio_admi= n; > + struct tas_config *tas =3D &emac->qos.tas.config; > + struct ptp_system_timestamp sts; > + u32 change_cycle_count; > + u32 cycle_time; > + u64 base_time; > + u64 cur_time; > + > + if (admin_list->cycle_time < TAS_MIN_CYCLE_TIME) > + return -EINVAL; > + > + cycle_time =3D admin_list->cycle_time - 4; /* -4ns to compensate for IE= P wraparound time */ > + base_time =3D admin_list->base_time; > + cur_time =3D prueth_iep_gettime(emac, &sts); > + > + if (base_time > cur_time) > + change_cycle_count =3D DIV_ROUND_UP_ULL(base_time - cur_time, cycle_ti= me); > + else > + change_cycle_count =3D 1; > + > + writel(cycle_time, emac->dram.va + TAS_ADMIN_CYCLE_TIME); > + writel(change_cycle_count, emac->dram.va + TAS_CONFIG_CHANGE_CYCLE_COUN= T); > + writeb(admin_list->num_entries, emac->dram.va + TAS_ADMIN_LIST_LENGTH); > + > + /* config_change cleared by f/w to ack reception of new shadow list */ > + writeb(1, &tas->config_list->config_change); > + /* config_pending cleared by f/w when new shadow list is copied to acti= ve list */ > + writeb(1, &tas->config_list->config_pending); > + > + return emac_set_port_state(emac, ICSSG_EMAC_PORT_TAS_TRIGGER); > +} > + > +static int tas_update_oper_list(struct prueth_emac *emac) > +{ > + struct tc_taprio_qopt_offload *admin_list =3D emac->qos.tas.taprio_admi= n; > + struct tas_config *tas =3D &emac->qos.tas.config; > + u32 tas_acc_gate_close_time =3D 0; > + u8 idx, gate_idx, val; > + int ret; > + > + if (admin_list->cycle_time > TAS_MAX_CYCLE_TIME) > + return -EINVAL; > + > + tas_update_fw_list_pointers(emac); > + > + for (idx =3D 0; idx < admin_list->num_entries; idx++) { > + writeb(admin_list->entries[idx].gate_mask, > + &tas->fw_shadow_list->gate_mask_list[idx]); > + tas_acc_gate_close_time +=3D admin_list->entries[idx].interval; > + > + /* extend last entry till end of cycle time */ > + if (idx =3D=3D admin_list->num_entries - 1) > + writel(admin_list->cycle_time, > + &tas->fw_shadow_list->win_end_time_list[idx]); > + else > + writel(tas_acc_gate_close_time, > + &tas->fw_shadow_list->win_end_time_list[idx]); > + } > + > + /* clear remaining entries */ > + for (idx =3D admin_list->num_entries; idx < TAS_MAX_CMD_LISTS; idx++) { > + writeb(0, &tas->fw_shadow_list->gate_mask_list[idx]); > + writel(0, &tas->fw_shadow_list->win_end_time_list[idx]); > + } > + > + /* update the Array of gate close time for each queue in each window */ > + for (idx =3D 0 ; idx < admin_list->num_entries; idx++) { > + /* On Linux, only PRUETH_MAX_TX_QUEUES are supported per port */ > + for (gate_idx =3D 0; gate_idx < PRUETH_MAX_TX_QUEUES; gate_idx++) { > + u8 gate_mask_list_idx =3D readb(&tas->fw_shadow_list->gate_mask_list[= idx]); > + u32 gate_close_time =3D 0; > + > + if (gate_mask_list_idx & BIT(gate_idx)) > + gate_close_time =3D readl(&tas->fw_shadow_list->win_end_time_list[id= x]); > + > + writel(gate_close_time, > + &tas->fw_shadow_list->gate_close_time_list[idx][gate_idx]); > + } > + } > + > + /* tell f/w to swap active & shadow list */ > + ret =3D tas_set_trigger_list_change(emac); > + if (ret) { > + netdev_err(emac->ndev, "failed to swap f/w config list: %d\n", ret); > + return ret; > + } > + > + /* Wait for completion */ > + ret =3D readb_poll_timeout(&tas->config_list->config_change, val, !val, > + USEC_PER_MSEC, 10 * USEC_PER_MSEC); > + if (ret) { > + netdev_err(emac->ndev, "TAS list change completion time out\n"); > + return ret; > + } > + > + tas_update_fw_list_pointers(emac); > + > + return 0; > +} > + > +static void emac_cp_taprio(struct tc_taprio_qopt_offload *from, > + struct tc_taprio_qopt_offload *to) > +{ > + int i; > + > + *to =3D *from; > + for (i =3D 0; i < from->num_entries; i++) > + to->entries[i] =3D from->entries[i]; > +} > + > +static int emac_taprio_replace(struct net_device *ndev, > + struct tc_taprio_qopt_offload *taprio) > +{ > + struct prueth_emac *emac =3D netdev_priv(ndev); > + struct tc_taprio_qopt_offload *est_new; > + int ret, idx; > + > + if (taprio->cycle_time_extension) { > + netdev_err(ndev, "Failed to set cycle time extension"); > + return -EOPNOTSUPP; > + } > + > + if (taprio->num_entries =3D=3D 0 || > + taprio->num_entries > TAS_MAX_CMD_LISTS) { > + NL_SET_ERR_MSG_FMT_MOD(taprio->extack, "unsupported num_entries %ld in= taprio config\n", > + taprio->num_entries); > + return -EINVAL; > + } > + > + /* If any time_interval is 0 in between the list, then exit */ > + for (idx =3D 0; idx < taprio->num_entries; idx++) { > + if (taprio->entries[idx].interval =3D=3D 0) { > + NL_SET_ERR_MSG_MOD(taprio->extack, "0 interval in taprio config not s= upported\n"); > + return -EINVAL; > + } > + } > + > + if (emac->qos.tas.taprio_admin) > + devm_kfree(&ndev->dev, emac->qos.tas.taprio_admin); > + > + est_new =3D devm_kzalloc(&ndev->dev, > + struct_size(est_new, entries, taprio->num_entries), > + GFP_KERNEL); > + if (!est_new) > + return -ENOMEM; > + > + emac_cp_taprio(taprio, est_new); > + emac->qos.tas.taprio_admin =3D est_new; > + ret =3D tas_update_oper_list(emac); > + if (ret) > + return ret; > + > + ret =3D tas_set_state(emac, TAS_STATE_ENABLE); The double space is still here... > + if (ret) > + devm_kfree(&ndev->dev, est_new); ... as is the free'ing of 'est_new' while 'taprio_admin' still points to it. > + > + return ret; > +} > + > +static int emac_taprio_destroy(struct net_device *ndev) > +{ > + struct prueth_emac *emac =3D netdev_priv(ndev); > + int ret; > + > + ret =3D tas_set_state(emac, TAS_STATE_RESET); > + if (ret) > + return ret; > + > + return tas_set_state(emac, TAS_STATE_DISABLE); > +} > + > +static int emac_setup_taprio(struct net_device *ndev, void *type_data) > +{ > + struct tc_taprio_qopt_offload *taprio =3D type_data; > + int ret; > + > + switch (taprio->cmd) { > + case TAPRIO_CMD_REPLACE: > + ret =3D emac_taprio_replace(ndev, taprio); > + break; > + case TAPRIO_CMD_DESTROY: > + ret =3D emac_taprio_destroy(ndev); > + break; > + default: > + ret =3D -EOPNOTSUPP; > + } > + > + return ret; > +} > + > +int icssg_qos_ndo_setup_tc(struct net_device *ndev, enum tc_setup_type t= ype, > + void *type_data) > +{ > + switch (type) { > + case TC_SETUP_QDISC_TAPRIO: > + return emac_setup_taprio(ndev, type_data); > + default: > + return -EOPNOTSUPP; > + } > +} > + > +void icssg_qos_tas_init(struct net_device *ndev) > +{ > + struct prueth_emac *emac =3D netdev_priv(ndev); > + struct tas_config *tas; > + > + tas =3D &emac->qos.tas.config; > + > + tas->config_list =3D emac->dram.va + TAS_CONFIG_CHANGE_TIME; > + tas->active_list =3D emac->dram.va + TAS_ACTIVE_LIST_INDEX; > + > + tas_update_fw_list_pointers(emac); > + > + tas_set_state(emac, TAS_STATE_RESET); > +} > diff --git a/drivers/net/ethernet/ti/icssg/icssg_qos.h b/drivers/net/ethe= rnet/ti/icssg/icssg_qos.h > new file mode 100644 > index 000000000000..25baccdd1ce5 > --- /dev/null > +++ b/drivers/net/ethernet/ti/icssg/icssg_qos.h > @@ -0,0 +1,113 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* Copyright (C) 2023 Texas Instruments Incorporated - http://www.ti.com/ > + */ > + > +#ifndef __NET_TI_ICSSG_QOS_H > +#define __NET_TI_ICSSG_QOS_H > + > +#include > +#include > +#include > + > +/* Maximum number of gate command entries in each list. */ > +#define TAS_MAX_CMD_LISTS (16) > + > +/* Maximum number of transmit queues supported by implementation */ > +#define TAS_MAX_NUM_QUEUES (8) > + > +/* Minimum cycle time supported by implementation (in ns) */ > +#define TAS_MIN_CYCLE_TIME (1000000) > + > +/* Minimum cycle time supported by implementation (in ns) */ > +#define TAS_MAX_CYCLE_TIME (4000000000) > + > +/* Minimum TAS window duration supported by implementation (in ns) */ > +#define TAS_MIN_WINDOW_DURATION (10000) > + > +/** > + * enum tas_list_num - TAS list number > + * @TAS_LIST0: TAS list number is 0 > + * @TAS_LIST1: TAS list number is 1 > + */ > +enum tas_list_num { > + TAS_LIST0 =3D 0, > + TAS_LIST1 =3D 1 > +}; > + > +/** > + * enum tas_state - State of TAS in firmware > + * @TAS_STATE_DISABLE: TAS state machine is disabled. > + * @TAS_STATE_ENABLE: TAS state machine is enabled. > + * @TAS_STATE_RESET: TAS state machine is reset. > + */ > +enum tas_state { > + TAS_STATE_DISABLE =3D 0, > + TAS_STATE_ENABLE =3D 1, > + TAS_STATE_RESET =3D 2, > +}; > + > +/** > + * struct tas_config_list - Config state machine variables > + * @config_change_time: New list is copied at this time > + * @config_change_error_counter: Incremented if admin->BaseTime < curren= t time > + * and TAS_enabled is true > + * @config_pending: True if list update is pending > + * @config_change: Set to true when application trigger updating of admi= n list > + * to active list, cleared when configChangeTime is updated > + */ > +struct tas_config_list { > + u64 config_change_time; > + u32 config_change_error_counter; > + u8 config_pending; > + u8 config_change; > +}; > + > +/* Max SDU table. See IEEE Std 802.1Q-2018 12.29.1.1 */ > +struct tas_max_sdu_table { > + u16 max_sdu[TAS_MAX_NUM_QUEUES]; > +}; > + > +/** > + * struct tas_firmware_list - TAS List Structure based on firmware memor= y map > + * @gate_mask_list: Window gate mask list > + * @win_end_time_list: Window end time list > + * @gate_close_time_list: Array of gate close time for each queue in eac= h window > + */ > +struct tas_firmware_list { > + u8 gate_mask_list[TAS_MAX_CMD_LISTS]; > + u32 win_end_time_list[TAS_MAX_CMD_LISTS]; > + u32 gate_close_time_list[TAS_MAX_CMD_LISTS][TAS_MAX_NUM_QUEUES]; > +}; > + > +/** > + * struct tas_config - Main Time Aware Shaper Handle > + * @state: TAS state > + * @max_sdu_table: Max SDU table > + * @config_list: Config change variables > + * @active_list: Current operating list operating list > + * @fw_active_list: Active List pointer, used by firmware > + * @fw_shadow_list: Shadow List pointer, used by driver > + */ > +struct tas_config { > + enum tas_state state; > + struct tas_max_sdu_table max_sdu_table; > + struct tas_config_list __iomem *config_list; > + u8 __iomem *active_list; > + struct tas_firmware_list __iomem *fw_active_list; > + struct tas_firmware_list __iomem *fw_shadow_list; > +}; > + > +struct prueth_qos_tas { > + struct tc_taprio_qopt_offload *taprio_admin; > + struct tc_taprio_qopt_offload *taprio_oper; > + struct tas_config config; > +}; > + > +struct prueth_qos { > + struct prueth_qos_tas tas; > +}; > + > +void icssg_qos_tas_init(struct net_device *ndev); > +int icssg_qos_ndo_setup_tc(struct net_device *ndev, enum tc_setup_type t= ype, > + void *type_data); > +#endif /* __NET_TI_ICSSG_QOS_H */ > --=20 > 2.34.1 > --=20 Vinicius