From mboxrd@z Thu Jan 1 00:00:00 1970 From: Marc Zyngier Subject: Re: [PATCH v3 2/2] net: usb: asix88179_178a: de-duplicate code Date: Mon, 2 Apr 2018 21:25:26 +0100 Message-ID: <20180402212526.2a9b709a@why.wild-wind.fr.eu.org> References: <20180402074349.12010-1-akurz@blala.de> <20180402074349.12010-2-akurz@blala.de> Mime-Version: 1.0 Content-Type: text/plain; charset=US-ASCII Content-Transfer-Encoding: 7bit Cc: "David S . Miller" , "Andrew F . Davis" , , To: Alexander Kurz Return-path: Received: from foss.arm.com ([217.140.101.70]:54254 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756672AbeDBUZd (ORCPT ); Mon, 2 Apr 2018 16:25:33 -0400 In-Reply-To: <20180402074349.12010-2-akurz@blala.de> Sender: netdev-owner@vger.kernel.org List-ID: On Mon, 2 Apr 2018 07:43:49 +0000 Alexander Kurz wrote: > Remove the duplicated code for asix88179_178a bind and reset methods. > > Signed-off-by: Alexander Kurz > --- > drivers/net/usb/ax88179_178a.c | 137 ++++++++++------------------------------- > 1 file changed, 31 insertions(+), 106 deletions(-) The good news is that this patch doesn't seem to break anything this time. A few remarks below: > > diff --git a/drivers/net/usb/ax88179_178a.c b/drivers/net/usb/ax88179_178a.c > index a6ef75907ae9..fea4c7b877cc 100644 > --- a/drivers/net/usb/ax88179_178a.c > +++ b/drivers/net/usb/ax88179_178a.c > @@ -1223,7 +1223,7 @@ static int ax88179_led_setting(struct usbnet *dev) > return 0; > } > > -static int ax88179_bind(struct usbnet *dev, struct usb_interface *intf) > +static int ax88179_bind_or_reset(struct usbnet *dev, bool do_reset) > { > u8 buf[5]; > u16 *tmp16; > @@ -1231,12 +1231,11 @@ static int ax88179_bind(struct usbnet *dev, struct usb_interface *intf) > struct ax88179_data *ax179_data = (struct ax88179_data *)dev->data; > struct ethtool_eee eee_data; > > - usbnet_get_endpoints(dev, intf); > - So you move this to "bind"... > tmp16 = (u16 *)buf; > tmp = (u8 *)buf; > > - memset(ax179_data, 0, sizeof(*ax179_data)); > + if (!do_reset) > + memset(ax179_data, 0, sizeof(*ax179_data)); ... but not that. Why? They both are exclusive to the bind operation. > > /* Power up ethernet PHY */ > *tmp16 = 0; > @@ -1249,9 +1248,13 @@ static int ax88179_bind(struct usbnet *dev, struct usb_interface *intf) > ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, tmp); > msleep(100); > > + if (do_reset) > + ax88179_auto_detach(dev, 0); > + > ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_NODE_ID, ETH_ALEN, > ETH_ALEN, dev->net->dev_addr); > - memcpy(dev->net->perm_addr, dev->net->dev_addr, ETH_ALEN); > + if (!do_reset) > + memcpy(dev->net->perm_addr, dev->net->dev_addr, ETH_ALEN); > > /* RX bulk configuration */ > memcpy(tmp, &AX88179_BULKIN_SIZE[0], 5); > @@ -1266,19 +1269,21 @@ static int ax88179_bind(struct usbnet *dev, struct usb_interface *intf) > ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PAUSE_WATERLVL_HIGH, > 1, 1, tmp); > > - dev->net->netdev_ops = &ax88179_netdev_ops; > - dev->net->ethtool_ops = &ax88179_ethtool_ops; > - dev->net->needed_headroom = 8; > - dev->net->max_mtu = 4088; > - > - /* Initialize MII structure */ > - dev->mii.dev = dev->net; > - dev->mii.mdio_read = ax88179_mdio_read; > - dev->mii.mdio_write = ax88179_mdio_write; > - dev->mii.phy_id_mask = 0xff; > - dev->mii.reg_num_mask = 0xff; > - dev->mii.phy_id = 0x03; > - dev->mii.supports_gmii = 1; > + if (!do_reset) { > + dev->net->netdev_ops = &ax88179_netdev_ops; > + dev->net->ethtool_ops = &ax88179_ethtool_ops; > + dev->net->needed_headroom = 8; > + dev->net->max_mtu = 4088; > + > + /* Initialize MII structure */ > + dev->mii.dev = dev->net; > + dev->mii.mdio_read = ax88179_mdio_read; > + dev->mii.mdio_write = ax88179_mdio_write; > + dev->mii.phy_id_mask = 0xff; > + dev->mii.reg_num_mask = 0xff; > + dev->mii.phy_id = 0x03; > + dev->mii.supports_gmii = 1; > + } > > dev->net->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | > NETIF_F_RXCSUM; > @@ -1330,6 +1335,13 @@ static int ax88179_bind(struct usbnet *dev, struct usb_interface *intf) > return 0; > } > > +static int ax88179_bind(struct usbnet *dev, struct usb_interface *intf) > +{ > + usbnet_get_endpoints(dev, intf); > + > + return ax88179_bind_or_reset(dev, false); > +} I find the whole construct extremely messy. You shouldn't need to "bind or reset" the adapter. You first reset it (that's the HW part), and you then bind it (that's the SW part). I understand that the code is quite messy already, and that you're trying to improve it. I'm just not convinced that having a single function containing everything and the kitchen sink is the most sensible approach. Instead, you probably want to extract stuff that needs to be done at reset time from what can be done at bind time, and keep the two quite separate. The fact that bind is mostly a superset of reset is a bit of an odd thing, and it'd be good to get to the bottom of that (I fully admit that my understanding of USB networking is close to zero). I came up with the below hack on top of your patch, and things seem to still behave. Thanks, M. diff --git a/drivers/net/usb/ax88179_178a.c b/drivers/net/usb/ax88179_178a.c index fea4c7b877cc..aed98d400d7a 100644 --- a/drivers/net/usb/ax88179_178a.c +++ b/drivers/net/usb/ax88179_178a.c @@ -1223,7 +1223,7 @@ static int ax88179_led_setting(struct usbnet *dev) return 0; } -static int ax88179_bind_or_reset(struct usbnet *dev, bool do_reset) +static int ax88179_reset(struct usbnet *dev) { u8 buf[5]; u16 *tmp16; @@ -1234,9 +1234,6 @@ static int ax88179_bind_or_reset(struct usbnet *dev, bool do_reset) tmp16 = (u16 *)buf; tmp = (u8 *)buf; - if (!do_reset) - memset(ax179_data, 0, sizeof(*ax179_data)); - /* Power up ethernet PHY */ *tmp16 = 0; ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, tmp16); @@ -1248,13 +1245,10 @@ static int ax88179_bind_or_reset(struct usbnet *dev, bool do_reset) ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, tmp); msleep(100); - if (do_reset) - ax88179_auto_detach(dev, 0); + ax88179_auto_detach(dev, 0); ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_NODE_ID, ETH_ALEN, ETH_ALEN, dev->net->dev_addr); - if (!do_reset) - memcpy(dev->net->perm_addr, dev->net->dev_addr, ETH_ALEN); /* RX bulk configuration */ memcpy(tmp, &AX88179_BULKIN_SIZE[0], 5); @@ -1269,28 +1263,6 @@ static int ax88179_bind_or_reset(struct usbnet *dev, bool do_reset) ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PAUSE_WATERLVL_HIGH, 1, 1, tmp); - if (!do_reset) { - dev->net->netdev_ops = &ax88179_netdev_ops; - dev->net->ethtool_ops = &ax88179_ethtool_ops; - dev->net->needed_headroom = 8; - dev->net->max_mtu = 4088; - - /* Initialize MII structure */ - dev->mii.dev = dev->net; - dev->mii.mdio_read = ax88179_mdio_read; - dev->mii.mdio_write = ax88179_mdio_write; - dev->mii.phy_id_mask = 0xff; - dev->mii.reg_num_mask = 0xff; - dev->mii.phy_id = 0x03; - dev->mii.supports_gmii = 1; - } - - dev->net->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | - NETIF_F_RXCSUM; - - dev->net->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | - NETIF_F_RXCSUM; - /* Enable checksum offload */ *tmp = AX_RXCOE_IP | AX_RXCOE_TCP | AX_RXCOE_UDP | AX_RXCOE_TCPV6 | AX_RXCOE_UDPV6; @@ -1337,9 +1309,36 @@ static int ax88179_bind_or_reset(struct usbnet *dev, bool do_reset) static int ax88179_bind(struct usbnet *dev, struct usb_interface *intf) { + struct ax88179_data *ax179_data = (struct ax88179_data *)dev->data; + usbnet_get_endpoints(dev, intf); - return ax88179_bind_or_reset(dev, false); + memset(ax179_data, 0, sizeof(*ax179_data)); + + dev->net->netdev_ops = &ax88179_netdev_ops; + dev->net->ethtool_ops = &ax88179_ethtool_ops; + dev->net->needed_headroom = 8; + dev->net->max_mtu = 4088; + + dev->net->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | + NETIF_F_RXCSUM; + + dev->net->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | + NETIF_F_RXCSUM; + + /* Initialize MII structure */ + dev->mii.dev = dev->net; + dev->mii.mdio_read = ax88179_mdio_read; + dev->mii.mdio_write = ax88179_mdio_write; + dev->mii.phy_id_mask = 0xff; + dev->mii.reg_num_mask = 0xff; + dev->mii.phy_id = 0x03; + dev->mii.supports_gmii = 1; + + ax88179_reset(dev); + memcpy(dev->net->perm_addr, dev->net->dev_addr, ETH_ALEN); + + return 0; } static void ax88179_unbind(struct usbnet *dev, struct usb_interface *intf) @@ -1540,11 +1539,6 @@ static int ax88179_link_reset(struct usbnet *dev) return 0; } -static int ax88179_reset(struct usbnet *dev) -{ - return ax88179_bind_or_reset(dev, true); -} - static int ax88179_stop(struct usbnet *dev) { u16 tmp16; -- Without deviation from the norm, progress is not possible. From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v3,2/2] net: usb: asix88179_178a: de-duplicate code From: Marc Zyngier Message-Id: <20180402212526.2a9b709a@why.wild-wind.fr.eu.org> Date: Mon, 2 Apr 2018 21:25:26 +0100 To: Alexander Kurz Cc: "David S . Miller" , "Andrew F . Davis" , linux-usb@vger.kernel.org, netdev@vger.kernel.org List-ID: T24gTW9uLCAyIEFwciAyMDE4IDA3OjQzOjQ5ICswMDAwCkFsZXhhbmRlciBLdXJ6IDxha3VyekBi bGFsYS5kZT4gd3JvdGU6Cgo+IFJlbW92ZSB0aGUgZHVwbGljYXRlZCBjb2RlIGZvciBhc2l4ODgx NzlfMTc4YSBiaW5kIGFuZCByZXNldCBtZXRob2RzLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEFsZXhh bmRlciBLdXJ6IDxha3VyekBibGFsYS5kZT4KPiAtLS0KPiAgZHJpdmVycy9uZXQvdXNiL2F4ODgx NzlfMTc4YS5jIHwgMTM3ICsrKysrKysrKystLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t Cj4gIDEgZmlsZSBjaGFuZ2VkLCAzMSBpbnNlcnRpb25zKCspLCAxMDYgZGVsZXRpb25zKC0pCgpU aGUgZ29vZCBuZXdzIGlzIHRoYXQgdGhpcyBwYXRjaCBkb2Vzbid0IHNlZW0gdG8gYnJlYWsgYW55 dGhpbmcgdGhpcwp0aW1lLiBBIGZldyByZW1hcmtzIGJlbG93OgoKPiAKPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9uZXQvdXNiL2F4ODgxNzlfMTc4YS5jIGIvZHJpdmVycy9uZXQvdXNiL2F4ODgxNzlf MTc4YS5jCj4gaW5kZXggYTZlZjc1OTA3YWU5Li5mZWE0YzdiODc3Y2MgMTAwNjQ0Cj4gLS0tIGEv ZHJpdmVycy9uZXQvdXNiL2F4ODgxNzlfMTc4YS5jCj4gKysrIGIvZHJpdmVycy9uZXQvdXNiL2F4 ODgxNzlfMTc4YS5jCj4gQEAgLTEyMjMsNyArMTIyMyw3IEBAIHN0YXRpYyBpbnQgYXg4ODE3OV9s ZWRfc2V0dGluZyhzdHJ1Y3QgdXNibmV0ICpkZXYpCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAKPiAt c3RhdGljIGludCBheDg4MTc5X2JpbmQoc3RydWN0IHVzYm5ldCAqZGV2LCBzdHJ1Y3QgdXNiX2lu dGVyZmFjZSAqaW50ZikKPiArc3RhdGljIGludCBheDg4MTc5X2JpbmRfb3JfcmVzZXQoc3RydWN0 IHVzYm5ldCAqZGV2LCBib29sIGRvX3Jlc2V0KQo+ICB7Cj4gIAl1OCBidWZbNV07Cj4gIAl1MTYg KnRtcDE2Owo+IEBAIC0xMjMxLDEyICsxMjMxLDExIEBAIHN0YXRpYyBpbnQgYXg4ODE3OV9iaW5k KHN0cnVjdCB1c2JuZXQgKmRldiwgc3RydWN0IHVzYl9pbnRlcmZhY2UgKmludGYpCj4gIAlzdHJ1 Y3QgYXg4ODE3OV9kYXRhICpheDE3OV9kYXRhID0gKHN0cnVjdCBheDg4MTc5X2RhdGEgKilkZXYt PmRhdGE7Cj4gIAlzdHJ1Y3QgZXRodG9vbF9lZWUgZWVlX2RhdGE7Cj4gIAo+IC0JdXNibmV0X2dl dF9lbmRwb2ludHMoZGV2LCBpbnRmKTsKPiAtCgpTbyB5b3UgbW92ZSB0aGlzIHRvICJiaW5kIi4u LgoKPiAgCXRtcDE2ID0gKHUxNiAqKWJ1ZjsKPiAgCXRtcCA9ICh1OCAqKWJ1ZjsKPiAgCj4gLQlt ZW1zZXQoYXgxNzlfZGF0YSwgMCwgc2l6ZW9mKCpheDE3OV9kYXRhKSk7Cj4gKwlpZiAoIWRvX3Jl c2V0KQo+ICsJCW1lbXNldChheDE3OV9kYXRhLCAwLCBzaXplb2YoKmF4MTc5X2RhdGEpKTsKCi4u LiBidXQgbm90IHRoYXQuIFdoeT8gVGhleSBib3RoIGFyZSBleGNsdXNpdmUgdG8gdGhlIGJpbmQg b3BlcmF0aW9uLgoKPiAgCj4gIAkvKiBQb3dlciB1cCBldGhlcm5ldCBQSFkgKi8KPiAgCSp0bXAx NiA9IDA7Cj4gQEAgLTEyNDksOSArMTI0OCwxMyBAQCBzdGF0aWMgaW50IGF4ODgxNzlfYmluZChz dHJ1Y3QgdXNibmV0ICpkZXYsIHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRmKQo+ICAJYXg4ODE3 OV93cml0ZV9jbWQoZGV2LCBBWF9BQ0NFU1NfTUFDLCBBWF9DTEtfU0VMRUNULCAxLCAxLCB0bXAp Owo+ICAJbXNsZWVwKDEwMCk7Cj4gIAo+ICsJaWYgKGRvX3Jlc2V0KQo+ICsJCWF4ODgxNzlfYXV0 b19kZXRhY2goZGV2LCAwKTsKPiArCj4gIAlheDg4MTc5X3JlYWRfY21kKGRldiwgQVhfQUNDRVNT X01BQywgQVhfTk9ERV9JRCwgRVRIX0FMRU4sCj4gIAkJCSBFVEhfQUxFTiwgZGV2LT5uZXQtPmRl dl9hZGRyKTsKPiAtCW1lbWNweShkZXYtPm5ldC0+cGVybV9hZGRyLCBkZXYtPm5ldC0+ZGV2X2Fk ZHIsIEVUSF9BTEVOKTsKPiArCWlmICghZG9fcmVzZXQpCj4gKwkJbWVtY3B5KGRldi0+bmV0LT5w ZXJtX2FkZHIsIGRldi0+bmV0LT5kZXZfYWRkciwgRVRIX0FMRU4pOwo+ICAKPiAgCS8qIFJYIGJ1 bGsgY29uZmlndXJhdGlvbiAqLwo+ICAJbWVtY3B5KHRtcCwgJkFYODgxNzlfQlVMS0lOX1NJWkVb MF0sIDUpOwo+IEBAIC0xMjY2LDE5ICsxMjY5LDIxIEBAIHN0YXRpYyBpbnQgYXg4ODE3OV9iaW5k KHN0cnVjdCB1c2JuZXQgKmRldiwgc3RydWN0IHVzYl9pbnRlcmZhY2UgKmludGYpCj4gIAlheDg4 MTc5X3dyaXRlX2NtZChkZXYsIEFYX0FDQ0VTU19NQUMsIEFYX1BBVVNFX1dBVEVSTFZMX0hJR0gs Cj4gIAkJCSAgMSwgMSwgdG1wKTsKPiAgCj4gLQlkZXYtPm5ldC0+bmV0ZGV2X29wcyA9ICZheDg4 MTc5X25ldGRldl9vcHM7Cj4gLQlkZXYtPm5ldC0+ZXRodG9vbF9vcHMgPSAmYXg4ODE3OV9ldGh0 b29sX29wczsKPiAtCWRldi0+bmV0LT5uZWVkZWRfaGVhZHJvb20gPSA4Owo+IC0JZGV2LT5uZXQt Pm1heF9tdHUgPSA0MDg4Owo+IC0KPiAtCS8qIEluaXRpYWxpemUgTUlJIHN0cnVjdHVyZSAqLwo+ IC0JZGV2LT5taWkuZGV2ID0gZGV2LT5uZXQ7Cj4gLQlkZXYtPm1paS5tZGlvX3JlYWQgPSBheDg4 MTc5X21kaW9fcmVhZDsKPiAtCWRldi0+bWlpLm1kaW9fd3JpdGUgPSBheDg4MTc5X21kaW9fd3Jp dGU7Cj4gLQlkZXYtPm1paS5waHlfaWRfbWFzayA9IDB4ZmY7Cj4gLQlkZXYtPm1paS5yZWdfbnVt X21hc2sgPSAweGZmOwo+IC0JZGV2LT5taWkucGh5X2lkID0gMHgwMzsKPiAtCWRldi0+bWlpLnN1 cHBvcnRzX2dtaWkgPSAxOwo+ICsJaWYgKCFkb19yZXNldCkgewo+ICsJCWRldi0+bmV0LT5uZXRk ZXZfb3BzID0gJmF4ODgxNzlfbmV0ZGV2X29wczsKPiArCQlkZXYtPm5ldC0+ZXRodG9vbF9vcHMg PSAmYXg4ODE3OV9ldGh0b29sX29wczsKPiArCQlkZXYtPm5ldC0+bmVlZGVkX2hlYWRyb29tID0g ODsKPiArCQlkZXYtPm5ldC0+bWF4X210dSA9IDQwODg7Cj4gKwo+ICsJCS8qIEluaXRpYWxpemUg TUlJIHN0cnVjdHVyZSAqLwo+ICsJCWRldi0+bWlpLmRldiA9IGRldi0+bmV0Owo+ICsJCWRldi0+ bWlpLm1kaW9fcmVhZCA9IGF4ODgxNzlfbWRpb19yZWFkOwo+ICsJCWRldi0+bWlpLm1kaW9fd3Jp dGUgPSBheDg4MTc5X21kaW9fd3JpdGU7Cj4gKwkJZGV2LT5taWkucGh5X2lkX21hc2sgPSAweGZm Owo+ICsJCWRldi0+bWlpLnJlZ19udW1fbWFzayA9IDB4ZmY7Cj4gKwkJZGV2LT5taWkucGh5X2lk ID0gMHgwMzsKPiArCQlkZXYtPm1paS5zdXBwb3J0c19nbWlpID0gMTsKPiArCX0KPiAgCj4gIAlk ZXYtPm5ldC0+ZmVhdHVyZXMgfD0gTkVUSUZfRl9JUF9DU1VNIHwgTkVUSUZfRl9JUFY2X0NTVU0g fAo+ICAJCQkgICAgICBORVRJRl9GX1JYQ1NVTTsKPiBAQCAtMTMzMCw2ICsxMzM1LDEzIEBAIHN0 YXRpYyBpbnQgYXg4ODE3OV9iaW5kKHN0cnVjdCB1c2JuZXQgKmRldiwgc3RydWN0IHVzYl9pbnRl cmZhY2UgKmludGYpCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAKPiArc3RhdGljIGludCBheDg4MTc5 X2JpbmQoc3RydWN0IHVzYm5ldCAqZGV2LCBzdHJ1Y3QgdXNiX2ludGVyZmFjZSAqaW50ZikKPiAr ewo+ICsJdXNibmV0X2dldF9lbmRwb2ludHMoZGV2LCBpbnRmKTsKPiArCj4gKwlyZXR1cm4gYXg4 ODE3OV9iaW5kX29yX3Jlc2V0KGRldiwgZmFsc2UpOwo+ICt9CgpJIGZpbmQgdGhlIHdob2xlIGNv bnN0cnVjdCBleHRyZW1lbHkgbWVzc3kuCgpZb3Ugc2hvdWxkbid0IG5lZWQgdG8gImJpbmQgb3Ig cmVzZXQiIHRoZSBhZGFwdGVyLiBZb3UgZmlyc3QgcmVzZXQgaXQKKHRoYXQncyB0aGUgSFcgcGFy dCksIGFuZCB5b3UgdGhlbiBiaW5kIGl0ICh0aGF0J3MgdGhlIFNXIHBhcnQpLiBJCnVuZGVyc3Rh bmQgdGhhdCB0aGUgY29kZSBpcyBxdWl0ZSBtZXNzeSBhbHJlYWR5LCBhbmQgdGhhdCB5b3UncmUg dHJ5aW5nCnRvIGltcHJvdmUgaXQuIEknbSBqdXN0IG5vdCBjb252aW5jZWQgdGhhdCBoYXZpbmcg YSBzaW5nbGUgZnVuY3Rpb24KY29udGFpbmluZyBldmVyeXRoaW5nIGFuZCB0aGUga2l0Y2hlbiBz aW5rIGlzIHRoZSBtb3N0IHNlbnNpYmxlCmFwcHJvYWNoLgoKSW5zdGVhZCwgeW91IHByb2JhYmx5 IHdhbnQgdG8gZXh0cmFjdCBzdHVmZiB0aGF0IG5lZWRzIHRvIGJlIGRvbmUgYXQKcmVzZXQgdGlt ZSBmcm9tIHdoYXQgY2FuIGJlIGRvbmUgYXQgYmluZCB0aW1lLCBhbmQga2VlcCB0aGUgdHdvIHF1 aXRlCnNlcGFyYXRlLiBUaGUgZmFjdCB0aGF0IGJpbmQgaXMgbW9zdGx5IGEgc3VwZXJzZXQgb2Yg cmVzZXQgaXMgYSBiaXQgb2YKYW4gb2RkIHRoaW5nLCBhbmQgaXQnZCBiZSBnb29kIHRvIGdldCB0 byB0aGUgYm90dG9tIG9mIHRoYXQgKEkgZnVsbHkKYWRtaXQgdGhhdCBteSB1bmRlcnN0YW5kaW5n IG9mIFVTQiBuZXR3b3JraW5nIGlzIGNsb3NlIHRvIHplcm8pLgoKSSBjYW1lIHVwIHdpdGggdGhl IGJlbG93IGhhY2sgb24gdG9wIG9mIHlvdXIgcGF0Y2gsIGFuZCB0aGluZ3Mgc2VlbSB0bwpzdGls bCBiZWhhdmUuCgpUaGFua3MsCgoJTS4KCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC91c2IvYXg4 ODE3OV8xNzhhLmMgYi9kcml2ZXJzL25ldC91c2IvYXg4ODE3OV8xNzhhLmMKaW5kZXggZmVhNGM3 Yjg3N2NjLi5hZWQ5OGQ0MDBkN2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3VzYi9heDg4MTc5 XzE3OGEuYworKysgYi9kcml2ZXJzL25ldC91c2IvYXg4ODE3OV8xNzhhLmMKQEAgLTEyMjMsNyAr MTIyMyw3IEBAIHN0YXRpYyBpbnQgYXg4ODE3OV9sZWRfc2V0dGluZyhzdHJ1Y3QgdXNibmV0ICpk ZXYpCiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgYXg4ODE3OV9iaW5kX29yX3Jlc2V0KHN0 cnVjdCB1c2JuZXQgKmRldiwgYm9vbCBkb19yZXNldCkKK3N0YXRpYyBpbnQgYXg4ODE3OV9yZXNl dChzdHJ1Y3QgdXNibmV0ICpkZXYpCiB7CiAJdTggYnVmWzVdOwogCXUxNiAqdG1wMTY7CkBAIC0x MjM0LDkgKzEyMzQsNiBAQCBzdGF0aWMgaW50IGF4ODgxNzlfYmluZF9vcl9yZXNldChzdHJ1Y3Qg dXNibmV0ICpkZXYsIGJvb2wgZG9fcmVzZXQpCiAJdG1wMTYgPSAodTE2ICopYnVmOwogCXRtcCA9 ICh1OCAqKWJ1ZjsKIAotCWlmICghZG9fcmVzZXQpCi0JCW1lbXNldChheDE3OV9kYXRhLCAwLCBz aXplb2YoKmF4MTc5X2RhdGEpKTsKLQogCS8qIFBvd2VyIHVwIGV0aGVybmV0IFBIWSAqLwogCSp0 bXAxNiA9IDA7CiAJYXg4ODE3OV93cml0ZV9jbWQoZGV2LCBBWF9BQ0NFU1NfTUFDLCBBWF9QSFlQ V1JfUlNUQ1RMLCAyLCAyLCB0bXAxNik7CkBAIC0xMjQ4LDEzICsxMjQ1LDEwIEBAIHN0YXRpYyBp bnQgYXg4ODE3OV9iaW5kX29yX3Jlc2V0KHN0cnVjdCB1c2JuZXQgKmRldiwgYm9vbCBkb19yZXNl dCkKIAlheDg4MTc5X3dyaXRlX2NtZChkZXYsIEFYX0FDQ0VTU19NQUMsIEFYX0NMS19TRUxFQ1Qs IDEsIDEsIHRtcCk7CiAJbXNsZWVwKDEwMCk7CiAKLQlpZiAoZG9fcmVzZXQpCi0JCWF4ODgxNzlf YXV0b19kZXRhY2goZGV2LCAwKTsKKwlheDg4MTc5X2F1dG9fZGV0YWNoKGRldiwgMCk7CiAKIAlh eDg4MTc5X3JlYWRfY21kKGRldiwgQVhfQUNDRVNTX01BQywgQVhfTk9ERV9JRCwgRVRIX0FMRU4s CiAJCQkgRVRIX0FMRU4sIGRldi0+bmV0LT5kZXZfYWRkcik7Ci0JaWYgKCFkb19yZXNldCkKLQkJ bWVtY3B5KGRldi0+bmV0LT5wZXJtX2FkZHIsIGRldi0+bmV0LT5kZXZfYWRkciwgRVRIX0FMRU4p OwogCiAJLyogUlggYnVsayBjb25maWd1cmF0aW9uICovCiAJbWVtY3B5KHRtcCwgJkFYODgxNzlf QlVMS0lOX1NJWkVbMF0sIDUpOwpAQCAtMTI2OSwyOCArMTI2Myw2IEBAIHN0YXRpYyBpbnQgYXg4 ODE3OV9iaW5kX29yX3Jlc2V0KHN0cnVjdCB1c2JuZXQgKmRldiwgYm9vbCBkb19yZXNldCkKIAlh eDg4MTc5X3dyaXRlX2NtZChkZXYsIEFYX0FDQ0VTU19NQUMsIEFYX1BBVVNFX1dBVEVSTFZMX0hJ R0gsCiAJCQkgIDEsIDEsIHRtcCk7CiAKLQlpZiAoIWRvX3Jlc2V0KSB7Ci0JCWRldi0+bmV0LT5u ZXRkZXZfb3BzID0gJmF4ODgxNzlfbmV0ZGV2X29wczsKLQkJZGV2LT5uZXQtPmV0aHRvb2xfb3Bz ID0gJmF4ODgxNzlfZXRodG9vbF9vcHM7Ci0JCWRldi0+bmV0LT5uZWVkZWRfaGVhZHJvb20gPSA4 OwotCQlkZXYtPm5ldC0+bWF4X210dSA9IDQwODg7Ci0KLQkJLyogSW5pdGlhbGl6ZSBNSUkgc3Ry dWN0dXJlICovCi0JCWRldi0+bWlpLmRldiA9IGRldi0+bmV0OwotCQlkZXYtPm1paS5tZGlvX3Jl YWQgPSBheDg4MTc5X21kaW9fcmVhZDsKLQkJZGV2LT5taWkubWRpb193cml0ZSA9IGF4ODgxNzlf bWRpb193cml0ZTsKLQkJZGV2LT5taWkucGh5X2lkX21hc2sgPSAweGZmOwotCQlkZXYtPm1paS5y ZWdfbnVtX21hc2sgPSAweGZmOwotCQlkZXYtPm1paS5waHlfaWQgPSAweDAzOwotCQlkZXYtPm1p aS5zdXBwb3J0c19nbWlpID0gMTsKLQl9Ci0KLQlkZXYtPm5ldC0+ZmVhdHVyZXMgfD0gTkVUSUZf Rl9JUF9DU1VNIHwgTkVUSUZfRl9JUFY2X0NTVU0gfAotCQkJICAgICAgTkVUSUZfRl9SWENTVU07 Ci0KLQlkZXYtPm5ldC0+aHdfZmVhdHVyZXMgfD0gTkVUSUZfRl9JUF9DU1VNIHwgTkVUSUZfRl9J UFY2X0NTVU0gfAotCQkJCSBORVRJRl9GX1JYQ1NVTTsKLQogCS8qIEVuYWJsZSBjaGVja3N1bSBv ZmZsb2FkICovCiAJKnRtcCA9IEFYX1JYQ09FX0lQIHwgQVhfUlhDT0VfVENQIHwgQVhfUlhDT0Vf VURQIHwKIAkgICAgICAgQVhfUlhDT0VfVENQVjYgfCBBWF9SWENPRV9VRFBWNjsKQEAgLTEzMzcs OSArMTMwOSwzNiBAQCBzdGF0aWMgaW50IGF4ODgxNzlfYmluZF9vcl9yZXNldChzdHJ1Y3QgdXNi bmV0ICpkZXYsIGJvb2wgZG9fcmVzZXQpCiAKIHN0YXRpYyBpbnQgYXg4ODE3OV9iaW5kKHN0cnVj dCB1c2JuZXQgKmRldiwgc3RydWN0IHVzYl9pbnRlcmZhY2UgKmludGYpCiB7CisJc3RydWN0IGF4 ODgxNzlfZGF0YSAqYXgxNzlfZGF0YSA9IChzdHJ1Y3QgYXg4ODE3OV9kYXRhICopZGV2LT5kYXRh OworCiAJdXNibmV0X2dldF9lbmRwb2ludHMoZGV2LCBpbnRmKTsKIAotCXJldHVybiBheDg4MTc5 X2JpbmRfb3JfcmVzZXQoZGV2LCBmYWxzZSk7CisJbWVtc2V0KGF4MTc5X2RhdGEsIDAsIHNpemVv ZigqYXgxNzlfZGF0YSkpOworCisJZGV2LT5uZXQtPm5ldGRldl9vcHMgPSAmYXg4ODE3OV9uZXRk ZXZfb3BzOworCWRldi0+bmV0LT5ldGh0b29sX29wcyA9ICZheDg4MTc5X2V0aHRvb2xfb3BzOwor CWRldi0+bmV0LT5uZWVkZWRfaGVhZHJvb20gPSA4OworCWRldi0+bmV0LT5tYXhfbXR1ID0gNDA4 ODsKKworCWRldi0+bmV0LT5mZWF0dXJlcyB8PSBORVRJRl9GX0lQX0NTVU0gfCBORVRJRl9GX0lQ VjZfQ1NVTSB8CisJCQkgICAgICBORVRJRl9GX1JYQ1NVTTsKKworCWRldi0+bmV0LT5od19mZWF0 dXJlcyB8PSBORVRJRl9GX0lQX0NTVU0gfCBORVRJRl9GX0lQVjZfQ1NVTSB8CisJCQkJIE5FVElG X0ZfUlhDU1VNOworCisJLyogSW5pdGlhbGl6ZSBNSUkgc3RydWN0dXJlICovCisJZGV2LT5taWku ZGV2ID0gZGV2LT5uZXQ7CisJZGV2LT5taWkubWRpb19yZWFkID0gYXg4ODE3OV9tZGlvX3JlYWQ7 CisJZGV2LT5taWkubWRpb193cml0ZSA9IGF4ODgxNzlfbWRpb193cml0ZTsKKwlkZXYtPm1paS5w aHlfaWRfbWFzayA9IDB4ZmY7CisJZGV2LT5taWkucmVnX251bV9tYXNrID0gMHhmZjsKKwlkZXYt Pm1paS5waHlfaWQgPSAweDAzOworCWRldi0+bWlpLnN1cHBvcnRzX2dtaWkgPSAxOworCisJYXg4 ODE3OV9yZXNldChkZXYpOworCW1lbWNweShkZXYtPm5ldC0+cGVybV9hZGRyLCBkZXYtPm5ldC0+ ZGV2X2FkZHIsIEVUSF9BTEVOKTsKKworCXJldHVybiAwOwogfQogCiBzdGF0aWMgdm9pZCBheDg4 MTc5X3VuYmluZChzdHJ1Y3QgdXNibmV0ICpkZXYsIHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRm KQpAQCAtMTU0MCwxMSArMTUzOSw2IEBAIHN0YXRpYyBpbnQgYXg4ODE3OV9saW5rX3Jlc2V0KHN0 cnVjdCB1c2JuZXQgKmRldikKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCBheDg4MTc5X3Jl c2V0KHN0cnVjdCB1c2JuZXQgKmRldikKLXsKLQlyZXR1cm4gYXg4ODE3OV9iaW5kX29yX3Jlc2V0 KGRldiwgdHJ1ZSk7Ci19Ci0KIHN0YXRpYyBpbnQgYXg4ODE3OV9zdG9wKHN0cnVjdCB1c2JuZXQg KmRldikKIHsKIAl1MTYgdG1wMTY7Cg==