From mboxrd@z Thu Jan 1 00:00:00 1970 From: Igor Russkikh Subject: [PATCH net-next 06/19] net: usb: aqc111: Introduce link management Date: Fri, 5 Oct 2018 10:24:55 +0000 Message-ID: References: Mime-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: quoted-printable Cc: "linux-usb@vger.kernel.org" , "netdev@vger.kernel.org" , Igor Russkikh , Dmitry Bezrukov To: "David S . Miller" Return-path: Received: from mail-bl2nam02on0081.outbound.protection.outlook.com ([104.47.38.81]:6901 "EHLO NAM02-BL2-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1727535AbeJERX3 (ORCPT ); Fri, 5 Oct 2018 13:23:29 -0400 In-Reply-To: Content-Language: en-US Sender: netdev-owner@vger.kernel.org List-ID: From: Dmitry Bezrukov Add full hardware initialization sequence and link configuration logic Signed-off-by: Dmitry Bezrukov Signed-off-by: Igor Russkikh --- drivers/net/usb/aqc111.c | 330 +++++++++++++++++++++++++++++++++++++++++++= ++++ drivers/net/usb/aqc111.h | 51 ++++++++ 2 files changed, 381 insertions(+) diff --git a/drivers/net/usb/aqc111.c b/drivers/net/usb/aqc111.c index 30219bb6ddfd..1d366f4a1c51 100644 --- a/drivers/net/usb/aqc111.c +++ b/drivers/net/usb/aqc111.c @@ -150,6 +150,122 @@ static int aq_mdio_write_cmd(struct usbnet *dev, u16 = value, u16 index, return aqc111_write_cmd(dev, AQ_PHY_CMD, value, index, size, data); } =20 +static void aqc111_set_phy_speed_fw_iface(struct usbnet *dev, + struct aqc111_data *aqc111_data) +{ + aqc111_write_cmd(dev, AQ_PHY_OPS, 0, 0, 4, &aqc111_data->phy_ops); +} + +static void aqc111_set_phy_speed_direct(struct usbnet *dev, + struct aqc111_data *aqc111_data) +{ + u16 reg16_1 =3D 0; + u16 reg16_2 =3D 0; + u16 reg16_3 =3D 0; + + /* Disable auto-negotiation */ + reg16_1 =3D AQ_ANEG_EX_PAGE_CTRL; + aq_mdio_write_cmd(dev, AQ_AUTONEG_STD_CTRL_REG, AQ_PHY_AUTONEG_ADDR, + 2, ®16_1); + + reg16_1 =3D AQ_ANEG_EX_PHY_ID | AQ_ANEG_ADV_AQRATE; + if (aqc111_data->phy_ops.downshift) { + reg16_1 |=3D AQ_ANEG_EN_DSH; + reg16_1 |=3D aqc111_data->phy_ops.dsh_ret_cnt & 0x0F; + } + + reg16_2 =3D AQ_ANEG_ADV_LT; + if (aqc111_data->phy_ops.pause) + reg16_3 |=3D AQ_ANEG_PAUSE; + + if (aqc111_data->phy_ops.asym_pause) + reg16_3 |=3D AQ_ANEG_ASYM_PAUSE; + + if (aqc111_data->phy_ops.adv_5G) { + reg16_1 |=3D AQ_ANEG_ADV_5G_N; + reg16_2 |=3D AQ_ANEG_ADV_5G_T; + } + if (aqc111_data->phy_ops.adv_2G5) { + reg16_1 |=3D AQ_ANEG_ADV_2G5_N; + reg16_2 |=3D AQ_ANEG_ADV_2G5_T; + } + if (aqc111_data->phy_ops.adv_1G) + reg16_1 |=3D AQ_ANEG_ADV_1G; + + if (aqc111_data->phy_ops.adv_5G) + reg16_3 |=3D AQ_ANEG_100M; + + aq_mdio_write_cmd(dev, AQ_AUTONEG_VEN_PROV1_REG, + AQ_PHY_AUTONEG_ADDR, 2, ®16_1); + aq_mdio_write_cmd(dev, AQ_AUTONEG_10GT_CTRL_REG, + AQ_PHY_AUTONEG_ADDR, 2, ®16_2); + + aq_mdio_read_cmd(dev, AQ_AUTONEG_ADV_REG, AQ_PHY_AUTONEG_ADDR, + 2, ®16_1); + reg16_1 &=3D ~AQ_ANEG_ABILITY_MASK; + reg16_1 |=3D reg16_3; + aq_mdio_write_cmd(dev, AQ_AUTONEG_ADV_REG, AQ_PHY_AUTONEG_ADDR, + 2, ®16_1); + + /* Restart auto-negotiation */ + reg16_1 =3D AQ_ANEG_EX_PAGE_CTRL | AQ_ANEG_EN_ANEG | + AQ_ANEG_RESTART_ANEG; + + aq_mdio_write_cmd(dev, AQ_AUTONEG_STD_CTRL_REG, + AQ_PHY_AUTONEG_ADDR, 2, ®16_1); +} + +static void aqc111_set_phy_speed(struct usbnet *dev, u8 autoneg, u16 speed= ) +{ + struct aqc111_data *aqc111_data =3D (struct aqc111_data *)dev->data[0]; + + aqc111_data->phy_ops.advertising =3D 0; + aqc111_data->phy_ops.pause =3D 1; + aqc111_data->phy_ops.asym_pause =3D 1; + aqc111_data->phy_ops.downshift =3D 1; + aqc111_data->phy_ops.dsh_ret_cnt =3D 3; + if (autoneg =3D=3D AUTONEG_ENABLE) { + switch (speed) { + case SPEED_5000: + aqc111_data->phy_ops.adv_5G =3D 1; + case SPEED_2500: + aqc111_data->phy_ops.adv_2G5 =3D 1; + case SPEED_1000: + aqc111_data->phy_ops.adv_1G =3D 1; + case SPEED_100: + aqc111_data->phy_ops.adv_100M =3D 1; + } + } else { + switch (speed) { + case SPEED_5000: + { + aqc111_data->phy_ops.adv_5G =3D 1; + break; + } + case SPEED_2500: + { + aqc111_data->phy_ops.adv_2G5 =3D 1; + break; + } + case SPEED_1000: + { + aqc111_data->phy_ops.adv_1G =3D 1; + break; + } + case SPEED_100: + { + aqc111_data->phy_ops.adv_100M =3D 1; + break; + } + } + } + + if (aqc111_data->dpa) + aqc111_set_phy_speed_direct(dev, aqc111_data); + else + aqc111_set_phy_speed_fw_iface(dev, aqc111_data); +} + static const struct net_device_ops aqc111_netdev_ops =3D { .ndo_open =3D usbnet_open, .ndo_stop =3D usbnet_stop, @@ -176,6 +292,7 @@ static int aqc111_bind(struct usbnet *dev, struct usb_i= nterface *intf) int ret; struct usb_device *udev =3D interface_to_usbdev(intf); struct aqc111_data *aqc111_data; + enum usb_device_speed usb_speed =3D dev->udev->speed; =20 /* Check if vendor configuration */ if (udev->actconfig->desc.bConfigurationValue !=3D 1) { @@ -202,6 +319,9 @@ static int aqc111_bind(struct usbnet *dev, struct usb_i= nterface *intf) dev->net->netdev_ops =3D &aqc111_netdev_ops; =20 aqc111_read_fw_version(dev, aqc111_data); + aqc111_data->autoneg =3D AUTONEG_ENABLE; + aqc111_data->advertised_speed =3D (usb_speed =3D=3D USB_SPEED_SUPER) ? + SPEED_5000 : SPEED_1000; =20 return 0; } @@ -227,6 +347,7 @@ static void aqc111_unbind(struct usbnet *dev, struct us= b_interface *intf) aqc111_write_cmd_nopm(dev, AQ_PHY_POWER, 0, 0, 1, ®8); } else { + aqc111_data->phy_ops.advertising =3D 0; aqc111_data->phy_ops.low_power =3D 1; aqc111_data->phy_ops.phy_power =3D 0; aqc111_write_cmd_nopm(dev, AQ_PHY_OPS, 0, 0, @@ -236,13 +357,212 @@ static void aqc111_unbind(struct usbnet *dev, struct= usb_interface *intf) kfree(aqc111_data); } =20 +static void aqc111_status(struct usbnet *dev, struct urb *urb) +{ + struct aqc111_int_data *event =3D NULL; + struct aqc111_data *aqc111_data =3D (struct aqc111_data *)dev->data[0]; + int link =3D 0; + + if (urb->actual_length < 8) + return; + + event =3D urb->transfer_buffer; + + if (event->link_status) + link =3D 1; + else + link =3D 0; + + aqc111_data->link_speed =3D event->link_speed; + aqc111_data->link =3D link; + + if (netif_carrier_ok(dev->net) !=3D link) + usbnet_defer_kevent(dev, EVENT_LINK_RESET); +} + +static void aqc111_configure_rx(struct usbnet *dev, + struct aqc111_data *aqc111_data) +{ + u8 reg8 =3D 0; + u8 queue_num =3D 0; + u16 reg16 =3D 0; + u16 link_speed =3D 0, usb_host =3D 0; + u8 buf[5] =3D { 0 }; + enum usb_device_speed usb_speed =3D dev->udev->speed; + + buf[0] =3D 0x00; + buf[1] =3D 0xF8; + buf[2] =3D 0x07; + switch (aqc111_data->link_speed) { + case AQ_INT_SPEED_5G: + { + link_speed =3D 5000; + reg8 =3D 0x05; + reg16 =3D 0x001F; + break; + } + case AQ_INT_SPEED_2_5G: + { + link_speed =3D 2500; + reg16 =3D 0x003F; + break; + } + case AQ_INT_SPEED_1G: + { + link_speed =3D 1000; + reg16 =3D 0x009F; + break; + } + case AQ_INT_SPEED_100M: + { + link_speed =3D 100; + queue_num =3D 1; + reg16 =3D 0x063F; + buf[1] =3D 0xFB; + buf[2] =3D 0x4; + break; + } + } + + if (aqc111_data->dpa) { + /* Set Phy Flow control */ + aq_mdio_write_cmd(dev, AQ_GLB_ING_PAUSE_CTRL_REG, + AQ_PHY_AUTONEG_ADDR, 2, ®16); + aq_mdio_write_cmd(dev, AQ_GLB_EGR_PAUSE_CTRL_REG, + AQ_PHY_AUTONEG_ADDR, 2, ®16); + } + + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_INTER_PACKET_GAP_0, + 1, 1, ®8); + + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_TX_PAUSE_RESEND_T, 3, 3, buf); + + switch (usb_speed) { + case USB_SPEED_SUPER: + { + usb_host =3D 3; + break; + } + case USB_SPEED_HIGH: + { + usb_host =3D 2; + break; + } + case USB_SPEED_FULL: + case USB_SPEED_LOW: + { + usb_host =3D 1; + queue_num =3D 0; + break; + } + default: + { + usb_host =3D 0; + break; + } + } + + memcpy(buf, &AQC111_BULKIN_SIZE[queue_num], 5); + /* RX bulk configuration */ + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_RX_BULKIN_QCTRL, 5, 5, buf); + + /* Set high low water level */ + reg16 =3D 0x0810; + + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_PAUSE_WATERLVL_LOW, + 2, 2, ®16); + netdev_info(dev->net, "Link Speed %d, USB %d", link_speed, usb_host); +} + +static int aqc111_link_reset(struct usbnet *dev) +{ + u8 reg8 =3D 0; + u16 reg16 =3D 0; + struct aqc111_data *aqc111_data =3D (struct aqc111_data *)dev->data[0]; + + if (aqc111_data->link =3D=3D 1) { /* Link up */ + aqc111_configure_rx(dev, aqc111_data); + + /* Vlan Tag Filter */ + reg8 =3D SFR_VLAN_CONTROL_VSO; + + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, + 1, 1, ®8); + + reg8 =3D 0x0; + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BMRX_DMA_CONTROL, + 1, 1, ®8); + + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BMTX_DMA_CONTROL, + 1, 1, ®8); + + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_ARC_CTRL, 1, 1, ®8); + + reg16 =3D SFR_RX_CTL_IPE | SFR_RX_CTL_AB; + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_RX_CTL, 2, 2, ®16); + + reg8 =3D SFR_RX_PATH_READY; + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_ETH_MAC_PATH, + 1, 1, ®8); + + reg8 =3D SFR_BULK_OUT_EFF_EN; + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BULK_OUT_CTRL, + 1, 1, ®8); + + reg16 =3D 0; + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, + 2, 2, ®16); + + reg16 =3D SFR_MEDIUM_XGMIIMODE | SFR_MEDIUM_FULL_DUPLEX; + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, + 2, 2, ®16); + + aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, + 2, 2, ®16); + + reg16 |=3D SFR_MEDIUM_RECEIVE_EN | SFR_MEDIUM_RXFLOW_CTRLEN | + SFR_MEDIUM_TXFLOW_CTRLEN; + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, + 2, 2, ®16); + + reg16 =3D SFR_RX_CTL_IPE | SFR_RX_CTL_AB | SFR_RX_CTL_START; + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_RX_CTL, 2, 2, ®16); + + netif_carrier_on(dev->net); + } else { + aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, + 2, 2, ®16); + reg16 &=3D ~SFR_MEDIUM_RECEIVE_EN; + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, + 2, 2, ®16); + + aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_RX_CTL, 2, 2, ®16); + reg16 &=3D ~SFR_RX_CTL_START; + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_RX_CTL, 2, 2, ®16); + + reg8 =3D SFR_BULK_OUT_FLUSH_EN | SFR_BULK_OUT_EFF_EN; + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BULK_OUT_CTRL, + 1, 1, ®8); + reg8 =3D SFR_BULK_OUT_EFF_EN; + aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BULK_OUT_CTRL, + 1, 1, ®8); + + netif_carrier_off(dev->net); + } + return 0; +} + static int aqc111_reset(struct usbnet *dev) { u8 reg8 =3D 0; u16 reg16 =3D 0; + enum usb_device_speed usb_speed; struct aqc111_data *aqc111_data =3D (struct aqc111_data *)dev->data[0]; =20 + usb_speed =3D dev->udev->speed; + /* Power up ethernet PHY */ + aqc111_data->phy_ops.advertising =3D 0; aqc111_data->phy_ops.phy_ctrl1 =3D 0; aqc111_data->phy_ops.phy_ctrl2 =3D 0; =20 @@ -279,6 +599,12 @@ static int aqc111_reset(struct usbnet *dev) SFR_MONITOR_MODE_RW_FLAG); aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_MONITOR_MODE, 1, 1, ®8); =20 + netif_carrier_off(dev->net); + + /* Phy advertise */ + aqc111_set_phy_speed(dev, aqc111_data->autoneg, + aqc111_data->advertised_speed); + return 0; } =20 @@ -307,6 +633,8 @@ static int aqc111_stop(struct usbnet *dev) 4, &aqc111_data->phy_ops); } =20 + netif_carrier_off(dev->net); + return 0; } =20 @@ -314,6 +642,8 @@ static const struct driver_info aqc111_info =3D { .description =3D "Aquantia AQtion USB to 5GbE Controller", .bind =3D aqc111_bind, .unbind =3D aqc111_unbind, + .status =3D aqc111_status, + .link_reset =3D aqc111_link_reset, .reset =3D aqc111_reset, .stop =3D aqc111_stop, }; diff --git a/drivers/net/usb/aqc111.h b/drivers/net/usb/aqc111.h index 8738d2c4ae90..5c5602e6d236 100644 --- a/drivers/net/usb/aqc111.h +++ b/drivers/net/usb/aqc111.h @@ -18,12 +18,44 @@ #define AQC111_PHY_ID 0x00 #define AQ_PHY_ADDR(mmd) ((AQC111_PHY_ID << 8) | mmd) =20 +#define AQ_PHY_AUTONEG_MMD 0x07 +#define AQ_PHY_AUTONEG_ADDR AQ_PHY_ADDR(AQ_PHY_AUTONEG_MMD) + +#define AQ_AUTONEG_STD_CTRL_REG 0x0000 + #define AQ_ANEG_EX_PAGE_CTRL 0x2000 + #define AQ_ANEG_EN_ANEG 0x1000 + #define AQ_ANEG_RESTART_ANEG 0x0200 + +#define AQ_AUTONEG_ADV_REG 0x0010 + #define AQ_ANEG_100M 0x0100 + #define AQ_ANEG_PAUSE 0x0400 + #define AQ_ANEG_ASYM_PAUSE 0x0800 + #define AQ_ANEG_ABILITY_MASK 0x0FE0 + +#define AQ_AUTONEG_10GT_CTRL_REG 0x0020 + #define AQ_ANEG_ADV_10G_T 0x1000 + #define AQ_ANEG_ADV_5G_T 0x0100 + #define AQ_ANEG_ADV_2G5_T 0x0080 + #define AQ_ANEG_ADV_LT 0x0001 + +#define AQ_AUTONEG_VEN_PROV1_REG 0xC400 + #define AQ_ANEG_ADV_1G 0x8000 + #define AQ_ANEG_ADV_AQRATE 0x1000 + #define AQ_ANEG_ADV_5G_N 0x0800 + #define AQ_ANEG_ADV_2G5_N 0x0400 + #define AQ_ANEG_EX_PHY_ID 0x0040 + #define AQ_ANEG_EN_DSH 0x0010 + #define AQ_ANEG_DSH_RETRY 0x0003 + #define AQ_PHY_GLOBAL_MMD 0x1E #define AQ_PHY_GLOBAL_ADDR AQ_PHY_ADDR(AQ_PHY_GLOBAL_MMD) =20 #define AQ_GLB_STD_CTRL_REG 0x0000 #define AQ_PHY_LOW_POWER_MODE 0x0800 =20 +#define AQ_GLB_ING_PAUSE_CTRL_REG 0x7148 +#define AQ_GLB_EGR_PAUSE_CTRL_REG 0x4148 + #define AQ_USB_PHY_SET_TIMEOUT 10000 #define AQ_USB_SET_TIMEOUT 4000 =20 @@ -163,6 +195,10 @@ struct aqc111_phy_options { }; =20 struct aqc111_data { + u8 link_speed; + u8 link; + u8 autoneg; + u32 advertised_speed; struct { u8 major; u8 minor; @@ -172,6 +208,21 @@ struct aqc111_data { struct aqc111_phy_options phy_ops; } __packed; =20 +struct aqc111_int_data { + u8 res1; + u8 link_speed: 7; + u8 link_status: 1; + __le16 res2; + __le16 res3; + __le16 res4; +} __packed; + +#define AQ_INT_SPEED_10G 0x0E +#define AQ_INT_SPEED_5G 0x0F +#define AQ_INT_SPEED_2_5G 0x10 +#define AQ_INT_SPEED_1G 0x11 +#define AQ_INT_SPEED_100M 0x13 + static struct { unsigned char ctrl; unsigned char timer_l; --=20 2.7.4 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: [net-next,06/19] net: usb: aqc111: Introduce link management From: Igor Russkikh Message-Id: Date: Fri, 5 Oct 2018 10:24:55 +0000 To: "David S . Miller" Cc: "linux-usb@vger.kernel.org" , "netdev@vger.kernel.org" , Igor Russkikh , Dmitry Bezrukov List-ID: RnJvbTogRG1pdHJ5IEJlenJ1a292IDxkbWl0cnkuYmV6cnVrb3ZAYXF1YW50aWEuY29tPgoKQWRk IGZ1bGwgaGFyZHdhcmUgaW5pdGlhbGl6YXRpb24gc2VxdWVuY2UgYW5kIGxpbmsgY29uZmlndXJh dGlvbiBsb2dpYwoKU2lnbmVkLW9mZi1ieTogRG1pdHJ5IEJlenJ1a292IDxkbWl0cnkuYmV6cnVr b3ZAYXF1YW50aWEuY29tPgpTaWduZWQtb2ZmLWJ5OiBJZ29yIFJ1c3NraWtoIDxpZ29yLnJ1c3Nr aWtoQGFxdWFudGlhLmNvbT4KLS0tCiBkcml2ZXJzL25ldC91c2IvYXFjMTExLmMgfCAzMzAgKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvbmV0 L3VzYi9hcWMxMTEuaCB8ICA1MSArKysrKysrKwogMiBmaWxlcyBjaGFuZ2VkLCAzODEgaW5zZXJ0 aW9ucygrKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3VzYi9hcWMxMTEuYyBiL2RyaXZlcnMv bmV0L3VzYi9hcWMxMTEuYwppbmRleCAzMDIxOWJiNmRkZmQuLjFkMzY2ZjRhMWM1MSAxMDA2NDQK LS0tIGEvZHJpdmVycy9uZXQvdXNiL2FxYzExMS5jCisrKyBiL2RyaXZlcnMvbmV0L3VzYi9hcWMx MTEuYwpAQCAtMTUwLDYgKzE1MCwxMjIgQEAgc3RhdGljIGludCBhcV9tZGlvX3dyaXRlX2NtZChz dHJ1Y3QgdXNibmV0ICpkZXYsIHUxNiB2YWx1ZSwgdTE2IGluZGV4LAogCXJldHVybiBhcWMxMTFf d3JpdGVfY21kKGRldiwgQVFfUEhZX0NNRCwgdmFsdWUsIGluZGV4LCBzaXplLCBkYXRhKTsKIH0K IAorc3RhdGljIHZvaWQgYXFjMTExX3NldF9waHlfc3BlZWRfZndfaWZhY2Uoc3RydWN0IHVzYm5l dCAqZGV2LAorCQkJCQkgIHN0cnVjdCBhcWMxMTFfZGF0YSAqYXFjMTExX2RhdGEpCit7CisJYXFj MTExX3dyaXRlX2NtZChkZXYsIEFRX1BIWV9PUFMsIDAsIDAsIDQsICZhcWMxMTFfZGF0YS0+cGh5 X29wcyk7Cit9CisKK3N0YXRpYyB2b2lkIGFxYzExMV9zZXRfcGh5X3NwZWVkX2RpcmVjdChzdHJ1 Y3QgdXNibmV0ICpkZXYsCisJCQkJCXN0cnVjdCBhcWMxMTFfZGF0YSAqYXFjMTExX2RhdGEpCit7 CisJdTE2IHJlZzE2XzEgPSAwOworCXUxNiByZWcxNl8yID0gMDsKKwl1MTYgcmVnMTZfMyA9IDA7 CisKKwkvKiBEaXNhYmxlIGF1dG8tbmVnb3RpYXRpb24gKi8KKwlyZWcxNl8xID0gQVFfQU5FR19F WF9QQUdFX0NUUkw7CisJYXFfbWRpb193cml0ZV9jbWQoZGV2LCBBUV9BVVRPTkVHX1NURF9DVFJM X1JFRywgQVFfUEhZX0FVVE9ORUdfQUREUiwKKwkJCSAgMiwgJnJlZzE2XzEpOworCisJcmVnMTZf MSA9IEFRX0FORUdfRVhfUEhZX0lEIHwgQVFfQU5FR19BRFZfQVFSQVRFOworCWlmIChhcWMxMTFf ZGF0YS0+cGh5X29wcy5kb3duc2hpZnQpIHsKKwkJcmVnMTZfMSB8PSBBUV9BTkVHX0VOX0RTSDsK KwkJcmVnMTZfMSB8PSBhcWMxMTFfZGF0YS0+cGh5X29wcy5kc2hfcmV0X2NudCAmIDB4MEY7CisJ fQorCisJcmVnMTZfMiA9IEFRX0FORUdfQURWX0xUOworCWlmIChhcWMxMTFfZGF0YS0+cGh5X29w cy5wYXVzZSkKKwkJcmVnMTZfMyB8PSBBUV9BTkVHX1BBVVNFOworCisJaWYgKGFxYzExMV9kYXRh LT5waHlfb3BzLmFzeW1fcGF1c2UpCisJCXJlZzE2XzMgfD0gQVFfQU5FR19BU1lNX1BBVVNFOwor CisJaWYgKGFxYzExMV9kYXRhLT5waHlfb3BzLmFkdl81RykgeworCQlyZWcxNl8xIHw9IEFRX0FO RUdfQURWXzVHX047CisJCXJlZzE2XzIgfD0gQVFfQU5FR19BRFZfNUdfVDsKKwl9CisJaWYgKGFx YzExMV9kYXRhLT5waHlfb3BzLmFkdl8yRzUpIHsKKwkJcmVnMTZfMSB8PSBBUV9BTkVHX0FEVl8y RzVfTjsKKwkJcmVnMTZfMiB8PSBBUV9BTkVHX0FEVl8yRzVfVDsKKwl9CisJaWYgKGFxYzExMV9k YXRhLT5waHlfb3BzLmFkdl8xRykKKwkJcmVnMTZfMSB8PSBBUV9BTkVHX0FEVl8xRzsKKworCWlm IChhcWMxMTFfZGF0YS0+cGh5X29wcy5hZHZfNUcpCisJCXJlZzE2XzMgfD0gQVFfQU5FR18xMDBN OworCisJYXFfbWRpb193cml0ZV9jbWQoZGV2LCBBUV9BVVRPTkVHX1ZFTl9QUk9WMV9SRUcsCisJ CQkgIEFRX1BIWV9BVVRPTkVHX0FERFIsIDIsICZyZWcxNl8xKTsKKwlhcV9tZGlvX3dyaXRlX2Nt ZChkZXYsIEFRX0FVVE9ORUdfMTBHVF9DVFJMX1JFRywKKwkJCSAgQVFfUEhZX0FVVE9ORUdfQURE UiwgMiwgJnJlZzE2XzIpOworCisJYXFfbWRpb19yZWFkX2NtZChkZXYsIEFRX0FVVE9ORUdfQURW X1JFRywgQVFfUEhZX0FVVE9ORUdfQUREUiwKKwkJCSAyLCAmcmVnMTZfMSk7CisJcmVnMTZfMSAm PSB+QVFfQU5FR19BQklMSVRZX01BU0s7CisJcmVnMTZfMSB8PSByZWcxNl8zOworCWFxX21kaW9f d3JpdGVfY21kKGRldiwgQVFfQVVUT05FR19BRFZfUkVHLCBBUV9QSFlfQVVUT05FR19BRERSLAor CQkJICAyLCAmcmVnMTZfMSk7CisKKwkvKiBSZXN0YXJ0IGF1dG8tbmVnb3RpYXRpb24gKi8KKwly ZWcxNl8xID0gQVFfQU5FR19FWF9QQUdFX0NUUkwgfCBBUV9BTkVHX0VOX0FORUcgfAorCQkgIEFR X0FORUdfUkVTVEFSVF9BTkVHOworCisJYXFfbWRpb193cml0ZV9jbWQoZGV2LCBBUV9BVVRPTkVH X1NURF9DVFJMX1JFRywKKwkJCSAgQVFfUEhZX0FVVE9ORUdfQUREUiwgMiwgJnJlZzE2XzEpOwor fQorCitzdGF0aWMgdm9pZCBhcWMxMTFfc2V0X3BoeV9zcGVlZChzdHJ1Y3QgdXNibmV0ICpkZXYs IHU4IGF1dG9uZWcsIHUxNiBzcGVlZCkKK3sKKwlzdHJ1Y3QgYXFjMTExX2RhdGEgKmFxYzExMV9k YXRhID0gKHN0cnVjdCBhcWMxMTFfZGF0YSAqKWRldi0+ZGF0YVswXTsKKworCWFxYzExMV9kYXRh LT5waHlfb3BzLmFkdmVydGlzaW5nID0gMDsKKwlhcWMxMTFfZGF0YS0+cGh5X29wcy5wYXVzZSA9 IDE7CisJYXFjMTExX2RhdGEtPnBoeV9vcHMuYXN5bV9wYXVzZSA9IDE7CisJYXFjMTExX2RhdGEt PnBoeV9vcHMuZG93bnNoaWZ0ID0gMTsKKwlhcWMxMTFfZGF0YS0+cGh5X29wcy5kc2hfcmV0X2Nu dCA9IDM7CisJaWYgKGF1dG9uZWcgPT0gQVVUT05FR19FTkFCTEUpIHsKKwkJc3dpdGNoIChzcGVl ZCkgeworCQljYXNlIFNQRUVEXzUwMDA6CisJCQlhcWMxMTFfZGF0YS0+cGh5X29wcy5hZHZfNUcg PSAxOworCQljYXNlIFNQRUVEXzI1MDA6CisJCQlhcWMxMTFfZGF0YS0+cGh5X29wcy5hZHZfMkc1 ID0gMTsKKwkJY2FzZSBTUEVFRF8xMDAwOgorCQkJYXFjMTExX2RhdGEtPnBoeV9vcHMuYWR2XzFH ID0gMTsKKwkJY2FzZSBTUEVFRF8xMDA6CisJCQlhcWMxMTFfZGF0YS0+cGh5X29wcy5hZHZfMTAw TSA9IDE7CisJCX0KKwl9IGVsc2UgeworCQlzd2l0Y2ggKHNwZWVkKSB7CisJCWNhc2UgU1BFRURf NTAwMDoKKwkJeworCQkJYXFjMTExX2RhdGEtPnBoeV9vcHMuYWR2XzVHID0gMTsKKwkJCWJyZWFr OworCQl9CisJCWNhc2UgU1BFRURfMjUwMDoKKwkJeworCQkJYXFjMTExX2RhdGEtPnBoeV9vcHMu YWR2XzJHNSA9IDE7CisJCQlicmVhazsKKwkJfQorCQljYXNlIFNQRUVEXzEwMDA6CisJCXsKKwkJ CWFxYzExMV9kYXRhLT5waHlfb3BzLmFkdl8xRyA9IDE7CisJCQlicmVhazsKKwkJfQorCQljYXNl IFNQRUVEXzEwMDoKKwkJeworCQkJYXFjMTExX2RhdGEtPnBoeV9vcHMuYWR2XzEwME0gPSAxOwor CQkJYnJlYWs7CisJCX0KKwkJfQorCX0KKworCWlmIChhcWMxMTFfZGF0YS0+ZHBhKQorCQlhcWMx MTFfc2V0X3BoeV9zcGVlZF9kaXJlY3QoZGV2LCBhcWMxMTFfZGF0YSk7CisJZWxzZQorCQlhcWMx MTFfc2V0X3BoeV9zcGVlZF9md19pZmFjZShkZXYsIGFxYzExMV9kYXRhKTsKK30KKwogc3RhdGlj IGNvbnN0IHN0cnVjdCBuZXRfZGV2aWNlX29wcyBhcWMxMTFfbmV0ZGV2X29wcyA9IHsKIAkubmRv X29wZW4JCT0gdXNibmV0X29wZW4sCiAJLm5kb19zdG9wCQk9IHVzYm5ldF9zdG9wLApAQCAtMTc2 LDYgKzI5Miw3IEBAIHN0YXRpYyBpbnQgYXFjMTExX2JpbmQoc3RydWN0IHVzYm5ldCAqZGV2LCBz dHJ1Y3QgdXNiX2ludGVyZmFjZSAqaW50ZikKIAlpbnQgcmV0OwogCXN0cnVjdCB1c2JfZGV2aWNl ICp1ZGV2ID0gaW50ZXJmYWNlX3RvX3VzYmRldihpbnRmKTsKIAlzdHJ1Y3QgYXFjMTExX2RhdGEg KmFxYzExMV9kYXRhOworCWVudW0gdXNiX2RldmljZV9zcGVlZCB1c2Jfc3BlZWQgPSBkZXYtPnVk ZXYtPnNwZWVkOwogCiAJLyogQ2hlY2sgaWYgdmVuZG9yIGNvbmZpZ3VyYXRpb24gKi8KIAlpZiAo dWRldi0+YWN0Y29uZmlnLT5kZXNjLmJDb25maWd1cmF0aW9uVmFsdWUgIT0gMSkgewpAQCAtMjAy LDYgKzMxOSw5IEBAIHN0YXRpYyBpbnQgYXFjMTExX2JpbmQoc3RydWN0IHVzYm5ldCAqZGV2LCBz dHJ1Y3QgdXNiX2ludGVyZmFjZSAqaW50ZikKIAlkZXYtPm5ldC0+bmV0ZGV2X29wcyA9ICZhcWMx MTFfbmV0ZGV2X29wczsKIAogCWFxYzExMV9yZWFkX2Z3X3ZlcnNpb24oZGV2LCBhcWMxMTFfZGF0 YSk7CisJYXFjMTExX2RhdGEtPmF1dG9uZWcgPSBBVVRPTkVHX0VOQUJMRTsKKwlhcWMxMTFfZGF0 YS0+YWR2ZXJ0aXNlZF9zcGVlZCA9ICh1c2Jfc3BlZWQgPT0gVVNCX1NQRUVEX1NVUEVSKSA/CisJ CQkJCSBTUEVFRF81MDAwIDogU1BFRURfMTAwMDsKIAogCXJldHVybiAwOwogfQpAQCAtMjI3LDYg KzM0Nyw3IEBAIHN0YXRpYyB2b2lkIGFxYzExMV91bmJpbmQoc3RydWN0IHVzYm5ldCAqZGV2LCBz dHJ1Y3QgdXNiX2ludGVyZmFjZSAqaW50ZikKIAkJYXFjMTExX3dyaXRlX2NtZF9ub3BtKGRldiwg QVFfUEhZX1BPV0VSLCAwLAogCQkJCSAgICAgIDAsIDEsICZyZWc4KTsKIAl9IGVsc2UgeworCQlh cWMxMTFfZGF0YS0+cGh5X29wcy5hZHZlcnRpc2luZyA9IDA7CiAJCWFxYzExMV9kYXRhLT5waHlf b3BzLmxvd19wb3dlciA9IDE7CiAJCWFxYzExMV9kYXRhLT5waHlfb3BzLnBoeV9wb3dlciA9IDA7 CiAJCWFxYzExMV93cml0ZV9jbWRfbm9wbShkZXYsIEFRX1BIWV9PUFMsIDAsIDAsCkBAIC0yMzYs MTMgKzM1NywyMTIgQEAgc3RhdGljIHZvaWQgYXFjMTExX3VuYmluZChzdHJ1Y3QgdXNibmV0ICpk ZXYsIHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRmKQogCWtmcmVlKGFxYzExMV9kYXRhKTsKIH0K IAorc3RhdGljIHZvaWQgYXFjMTExX3N0YXR1cyhzdHJ1Y3QgdXNibmV0ICpkZXYsIHN0cnVjdCB1 cmIgKnVyYikKK3sKKwlzdHJ1Y3QgYXFjMTExX2ludF9kYXRhICpldmVudCA9IE5VTEw7CisJc3Ry dWN0IGFxYzExMV9kYXRhICphcWMxMTFfZGF0YSA9IChzdHJ1Y3QgYXFjMTExX2RhdGEgKilkZXYt PmRhdGFbMF07CisJaW50IGxpbmsgPSAwOworCisJaWYgKHVyYi0+YWN0dWFsX2xlbmd0aCA8IDgp CisJCXJldHVybjsKKworCWV2ZW50ID0gdXJiLT50cmFuc2Zlcl9idWZmZXI7CisKKwlpZiAoZXZl bnQtPmxpbmtfc3RhdHVzKQorCQlsaW5rID0gMTsKKwllbHNlCisJCWxpbmsgPSAwOworCisJYXFj MTExX2RhdGEtPmxpbmtfc3BlZWQgPSBldmVudC0+bGlua19zcGVlZDsKKwlhcWMxMTFfZGF0YS0+ bGluayA9IGxpbms7CisKKwlpZiAobmV0aWZfY2Fycmllcl9vayhkZXYtPm5ldCkgIT0gbGluaykK KwkJdXNibmV0X2RlZmVyX2tldmVudChkZXYsIEVWRU5UX0xJTktfUkVTRVQpOworfQorCitzdGF0 aWMgdm9pZCBhcWMxMTFfY29uZmlndXJlX3J4KHN0cnVjdCB1c2JuZXQgKmRldiwKKwkJCQlzdHJ1 Y3QgYXFjMTExX2RhdGEgKmFxYzExMV9kYXRhKQoreworCXU4IHJlZzggPSAwOworCXU4IHF1ZXVl X251bSA9IDA7CisJdTE2IHJlZzE2ID0gMDsKKwl1MTYgbGlua19zcGVlZCA9IDAsIHVzYl9ob3N0 ID0gMDsKKwl1OCBidWZbNV0gPSB7IDAgfTsKKwllbnVtIHVzYl9kZXZpY2Vfc3BlZWQgdXNiX3Nw ZWVkID0gZGV2LT51ZGV2LT5zcGVlZDsKKworCWJ1ZlswXSA9IDB4MDA7CisJYnVmWzFdID0gMHhG ODsKKwlidWZbMl0gPSAweDA3OworCXN3aXRjaCAoYXFjMTExX2RhdGEtPmxpbmtfc3BlZWQpIHsK KwljYXNlIEFRX0lOVF9TUEVFRF81RzoKKwl7CisJCWxpbmtfc3BlZWQgPSA1MDAwOworCQlyZWc4 ID0gMHgwNTsKKwkJcmVnMTYgPSAweDAwMUY7CisJCWJyZWFrOworCX0KKwljYXNlIEFRX0lOVF9T UEVFRF8yXzVHOgorCXsKKwkJbGlua19zcGVlZCA9IDI1MDA7CisJCXJlZzE2ID0gMHgwMDNGOwor CQlicmVhazsKKwl9CisJY2FzZSBBUV9JTlRfU1BFRURfMUc6CisJeworCQlsaW5rX3NwZWVkID0g MTAwMDsKKwkJcmVnMTYgPSAweDAwOUY7CisJCWJyZWFrOworCX0KKwljYXNlIEFRX0lOVF9TUEVF RF8xMDBNOgorCXsKKwkJbGlua19zcGVlZCA9IDEwMDsKKwkJcXVldWVfbnVtID0gMTsKKwkJcmVn MTYgPSAweDA2M0Y7CisJCWJ1ZlsxXSA9IDB4RkI7CisJCWJ1ZlsyXSA9IDB4NDsKKwkJYnJlYWs7 CisJfQorCX0KKworCWlmIChhcWMxMTFfZGF0YS0+ZHBhKSB7CisJCS8qIFNldCBQaHkgRmxvdyBj b250cm9sICovCisJCWFxX21kaW9fd3JpdGVfY21kKGRldiwgQVFfR0xCX0lOR19QQVVTRV9DVFJM X1JFRywKKwkJCQkgIEFRX1BIWV9BVVRPTkVHX0FERFIsIDIsICZyZWcxNik7CisJCWFxX21kaW9f d3JpdGVfY21kKGRldiwgQVFfR0xCX0VHUl9QQVVTRV9DVFJMX1JFRywKKwkJCQkgIEFRX1BIWV9B VVRPTkVHX0FERFIsIDIsICZyZWcxNik7CisJfQorCisJYXFjMTExX3dyaXRlX2NtZChkZXYsIEFR X0FDQ0VTU19NQUMsIFNGUl9JTlRFUl9QQUNLRVRfR0FQXzAsCisJCQkgMSwgMSwgJnJlZzgpOwor CisJYXFjMTExX3dyaXRlX2NtZChkZXYsIEFRX0FDQ0VTU19NQUMsIFNGUl9UWF9QQVVTRV9SRVNF TkRfVCwgMywgMywgYnVmKTsKKworCXN3aXRjaCAodXNiX3NwZWVkKSB7CisJY2FzZSBVU0JfU1BF RURfU1VQRVI6CisJeworCQl1c2JfaG9zdCA9IDM7CisJCWJyZWFrOworCX0KKwljYXNlIFVTQl9T UEVFRF9ISUdIOgorCXsKKwkJdXNiX2hvc3QgPSAyOworCQlicmVhazsKKwl9CisJY2FzZSBVU0Jf U1BFRURfRlVMTDoKKwljYXNlIFVTQl9TUEVFRF9MT1c6CisJeworCQl1c2JfaG9zdCA9IDE7CisJ CXF1ZXVlX251bSA9IDA7CisJCWJyZWFrOworCX0KKwlkZWZhdWx0OgorCXsKKwkJdXNiX2hvc3Qg PSAwOworCQlicmVhazsKKwl9CisJfQorCisJbWVtY3B5KGJ1ZiwgJkFRQzExMV9CVUxLSU5fU0la RVtxdWV1ZV9udW1dLCA1KTsKKwkvKiBSWCBidWxrIGNvbmZpZ3VyYXRpb24gKi8KKwlhcWMxMTFf d3JpdGVfY21kKGRldiwgQVFfQUNDRVNTX01BQywgU0ZSX1JYX0JVTEtJTl9RQ1RSTCwgNSwgNSwg YnVmKTsKKworCS8qIFNldCBoaWdoIGxvdyB3YXRlciBsZXZlbCAqLworCXJlZzE2ID0gMHgwODEw OworCisJYXFjMTExX3dyaXRlX2NtZChkZXYsIEFRX0FDQ0VTU19NQUMsIFNGUl9QQVVTRV9XQVRF UkxWTF9MT1csCisJCQkgMiwgMiwgJnJlZzE2KTsKKwluZXRkZXZfaW5mbyhkZXYtPm5ldCwgIkxp bmsgU3BlZWQgJWQsIFVTQiAlZCIsIGxpbmtfc3BlZWQsIHVzYl9ob3N0KTsKK30KKworc3RhdGlj IGludCBhcWMxMTFfbGlua19yZXNldChzdHJ1Y3QgdXNibmV0ICpkZXYpCit7CisJdTggcmVnOCA9 IDA7CisJdTE2IHJlZzE2ID0gMDsKKwlzdHJ1Y3QgYXFjMTExX2RhdGEgKmFxYzExMV9kYXRhID0g KHN0cnVjdCBhcWMxMTFfZGF0YSAqKWRldi0+ZGF0YVswXTsKKworCWlmIChhcWMxMTFfZGF0YS0+ bGluayA9PSAxKSB7IC8qIExpbmsgdXAgKi8KKwkJYXFjMTExX2NvbmZpZ3VyZV9yeChkZXYsIGFx YzExMV9kYXRhKTsKKworCQkvKiBWbGFuIFRhZyBGaWx0ZXIgKi8KKwkJcmVnOCA9IFNGUl9WTEFO X0NPTlRST0xfVlNPOworCisJCWFxYzExMV93cml0ZV9jbWQoZGV2LCBBUV9BQ0NFU1NfTUFDLCBT RlJfVkxBTl9JRF9DT05UUk9MLAorCQkJCSAxLCAxLCAmcmVnOCk7CisKKwkJcmVnOCA9IDB4MDsK KwkJYXFjMTExX3dyaXRlX2NtZChkZXYsIEFRX0FDQ0VTU19NQUMsIFNGUl9CTVJYX0RNQV9DT05U Uk9MLAorCQkJCSAxLCAxLCAmcmVnOCk7CisKKwkJYXFjMTExX3dyaXRlX2NtZChkZXYsIEFRX0FD Q0VTU19NQUMsIFNGUl9CTVRYX0RNQV9DT05UUk9MLAorCQkJCSAxLCAxLCAmcmVnOCk7CisKKwkJ YXFjMTExX3dyaXRlX2NtZChkZXYsIEFRX0FDQ0VTU19NQUMsIFNGUl9BUkNfQ1RSTCwgMSwgMSwg JnJlZzgpOworCisJCXJlZzE2ID0gU0ZSX1JYX0NUTF9JUEUgfCBTRlJfUlhfQ1RMX0FCOworCQlh cWMxMTFfd3JpdGVfY21kKGRldiwgQVFfQUNDRVNTX01BQywgU0ZSX1JYX0NUTCwgMiwgMiwgJnJl ZzE2KTsKKworCQlyZWc4ID0gU0ZSX1JYX1BBVEhfUkVBRFk7CisJCWFxYzExMV93cml0ZV9jbWQo ZGV2LCBBUV9BQ0NFU1NfTUFDLCBTRlJfRVRIX01BQ19QQVRILAorCQkJCSAxLCAxLCAmcmVnOCk7 CisKKwkJcmVnOCA9IFNGUl9CVUxLX09VVF9FRkZfRU47CisJCWFxYzExMV93cml0ZV9jbWQoZGV2 LCBBUV9BQ0NFU1NfTUFDLCBTRlJfQlVMS19PVVRfQ1RSTCwKKwkJCQkgMSwgMSwgJnJlZzgpOwor CisJCXJlZzE2ID0gMDsKKwkJYXFjMTExX3dyaXRlX2NtZChkZXYsIEFRX0FDQ0VTU19NQUMsIFNG Ul9NRURJVU1fU1RBVFVTX01PREUsCisJCQkJIDIsIDIsICZyZWcxNik7CisKKwkJcmVnMTYgPSBT RlJfTUVESVVNX1hHTUlJTU9ERSB8IFNGUl9NRURJVU1fRlVMTF9EVVBMRVg7CisJCWFxYzExMV93 cml0ZV9jbWQoZGV2LCBBUV9BQ0NFU1NfTUFDLCBTRlJfTUVESVVNX1NUQVRVU19NT0RFLAorCQkJ CSAyLCAyLCAmcmVnMTYpOworCisJCWFxYzExMV9yZWFkX2NtZChkZXYsIEFRX0FDQ0VTU19NQUMs IFNGUl9NRURJVU1fU1RBVFVTX01PREUsCisJCQkJMiwgMiwgJnJlZzE2KTsKKworCQlyZWcxNiB8 PSBTRlJfTUVESVVNX1JFQ0VJVkVfRU4gfCBTRlJfTUVESVVNX1JYRkxPV19DVFJMRU4gfAorCQkJ IFNGUl9NRURJVU1fVFhGTE9XX0NUUkxFTjsKKwkJYXFjMTExX3dyaXRlX2NtZChkZXYsIEFRX0FD Q0VTU19NQUMsIFNGUl9NRURJVU1fU1RBVFVTX01PREUsCisJCQkJIDIsIDIsICZyZWcxNik7CisK KwkJcmVnMTYgPSBTRlJfUlhfQ1RMX0lQRSB8IFNGUl9SWF9DVExfQUIgfCBTRlJfUlhfQ1RMX1NU QVJUOworCQlhcWMxMTFfd3JpdGVfY21kKGRldiwgQVFfQUNDRVNTX01BQywgU0ZSX1JYX0NUTCwg MiwgMiwgJnJlZzE2KTsKKworCQluZXRpZl9jYXJyaWVyX29uKGRldi0+bmV0KTsKKwl9IGVsc2Ug eworCQlhcWMxMTFfcmVhZF9jbWQoZGV2LCBBUV9BQ0NFU1NfTUFDLCBTRlJfTUVESVVNX1NUQVRV U19NT0RFLAorCQkJCTIsIDIsICZyZWcxNik7CisJCXJlZzE2ICY9IH5TRlJfTUVESVVNX1JFQ0VJ VkVfRU47CisJCWFxYzExMV93cml0ZV9jbWQoZGV2LCBBUV9BQ0NFU1NfTUFDLCBTRlJfTUVESVVN X1NUQVRVU19NT0RFLAorCQkJCSAyLCAyLCAmcmVnMTYpOworCisJCWFxYzExMV9yZWFkX2NtZChk ZXYsIEFRX0FDQ0VTU19NQUMsIFNGUl9SWF9DVEwsIDIsIDIsICZyZWcxNik7CisJCXJlZzE2ICY9 IH5TRlJfUlhfQ1RMX1NUQVJUOworCQlhcWMxMTFfd3JpdGVfY21kKGRldiwgQVFfQUNDRVNTX01B QywgU0ZSX1JYX0NUTCwgMiwgMiwgJnJlZzE2KTsKKworCQlyZWc4ID0gU0ZSX0JVTEtfT1VUX0ZM VVNIX0VOIHwgU0ZSX0JVTEtfT1VUX0VGRl9FTjsKKwkJYXFjMTExX3dyaXRlX2NtZChkZXYsIEFR X0FDQ0VTU19NQUMsIFNGUl9CVUxLX09VVF9DVFJMLAorCQkJCSAxLCAxLCAmcmVnOCk7CisJCXJl ZzggPSBTRlJfQlVMS19PVVRfRUZGX0VOOworCQlhcWMxMTFfd3JpdGVfY21kKGRldiwgQVFfQUND RVNTX01BQywgU0ZSX0JVTEtfT1VUX0NUUkwsCisJCQkJIDEsIDEsICZyZWc4KTsKKworCQluZXRp Zl9jYXJyaWVyX29mZihkZXYtPm5ldCk7CisJfQorCXJldHVybiAwOworfQorCiBzdGF0aWMgaW50 IGFxYzExMV9yZXNldChzdHJ1Y3QgdXNibmV0ICpkZXYpCiB7CiAJdTggcmVnOCA9IDA7CiAJdTE2 IHJlZzE2ID0gMDsKKwllbnVtIHVzYl9kZXZpY2Vfc3BlZWQgdXNiX3NwZWVkOwogCXN0cnVjdCBh cWMxMTFfZGF0YSAqYXFjMTExX2RhdGEgPSAoc3RydWN0IGFxYzExMV9kYXRhICopZGV2LT5kYXRh WzBdOwogCisJdXNiX3NwZWVkID0gZGV2LT51ZGV2LT5zcGVlZDsKKwogCS8qIFBvd2VyIHVwIGV0 aGVybmV0IFBIWSAqLworCWFxYzExMV9kYXRhLT5waHlfb3BzLmFkdmVydGlzaW5nID0gMDsKIAlh cWMxMTFfZGF0YS0+cGh5X29wcy5waHlfY3RybDEgPSAwOwogCWFxYzExMV9kYXRhLT5waHlfb3Bz LnBoeV9jdHJsMiA9IDA7CiAKQEAgLTI3OSw2ICs1OTksMTIgQEAgc3RhdGljIGludCBhcWMxMTFf cmVzZXQoc3RydWN0IHVzYm5ldCAqZGV2KQogCQkgIFNGUl9NT05JVE9SX01PREVfUldfRkxBRyk7 CiAJYXFjMTExX3dyaXRlX2NtZChkZXYsIEFRX0FDQ0VTU19NQUMsIFNGUl9NT05JVE9SX01PREUs IDEsIDEsICZyZWc4KTsKIAorCW5ldGlmX2NhcnJpZXJfb2ZmKGRldi0+bmV0KTsKKworCS8qIFBo eSBhZHZlcnRpc2UgKi8KKwlhcWMxMTFfc2V0X3BoeV9zcGVlZChkZXYsIGFxYzExMV9kYXRhLT5h dXRvbmVnLAorCQkJICAgICBhcWMxMTFfZGF0YS0+YWR2ZXJ0aXNlZF9zcGVlZCk7CisKIAlyZXR1 cm4gMDsKIH0KIApAQCAtMzA3LDYgKzYzMyw4IEBAIHN0YXRpYyBpbnQgYXFjMTExX3N0b3Aoc3Ry dWN0IHVzYm5ldCAqZGV2KQogCQkJCSA0LCAmYXFjMTExX2RhdGEtPnBoeV9vcHMpOwogCX0KIAor CW5ldGlmX2NhcnJpZXJfb2ZmKGRldi0+bmV0KTsKKwogCXJldHVybiAwOwogfQogCkBAIC0zMTQs NiArNjQyLDggQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBkcml2ZXJfaW5mbyBhcWMxMTFfaW5mbyA9 IHsKIAkuZGVzY3JpcHRpb24JPSAiQXF1YW50aWEgQVF0aW9uIFVTQiB0byA1R2JFIENvbnRyb2xs ZXIiLAogCS5iaW5kCQk9IGFxYzExMV9iaW5kLAogCS51bmJpbmQJCT0gYXFjMTExX3VuYmluZCwK Kwkuc3RhdHVzCQk9IGFxYzExMV9zdGF0dXMsCisJLmxpbmtfcmVzZXQJPSBhcWMxMTFfbGlua19y ZXNldCwKIAkucmVzZXQJCT0gYXFjMTExX3Jlc2V0LAogCS5zdG9wCQk9IGFxYzExMV9zdG9wLAog fTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3VzYi9hcWMxMTEuaCBiL2RyaXZlcnMvbmV0L3Vz Yi9hcWMxMTEuaAppbmRleCA4NzM4ZDJjNGFlOTAuLjVjNTYwMmU2ZDIzNiAxMDA2NDQKLS0tIGEv ZHJpdmVycy9uZXQvdXNiL2FxYzExMS5oCisrKyBiL2RyaXZlcnMvbmV0L3VzYi9hcWMxMTEuaApA QCAtMTgsMTIgKzE4LDQ0IEBACiAjZGVmaW5lIEFRQzExMV9QSFlfSUQJCQkweDAwCiAjZGVmaW5l IEFRX1BIWV9BRERSKG1tZCkJCSgoQVFDMTExX1BIWV9JRCA8PCA4KSB8IG1tZCkKIAorI2RlZmlu ZSBBUV9QSFlfQVVUT05FR19NTUQJCTB4MDcKKyNkZWZpbmUgQVFfUEhZX0FVVE9ORUdfQUREUgkJ QVFfUEhZX0FERFIoQVFfUEhZX0FVVE9ORUdfTU1EKQorCisjZGVmaW5lIEFRX0FVVE9ORUdfU1RE X0NUUkxfUkVHCQkweDAwMDAKKwkjZGVmaW5lIEFRX0FORUdfRVhfUEFHRV9DVFJMCQkweDIwMDAK KwkjZGVmaW5lIEFRX0FORUdfRU5fQU5FRwkJCTB4MTAwMAorCSNkZWZpbmUgQVFfQU5FR19SRVNU QVJUX0FORUcJCTB4MDIwMAorCisjZGVmaW5lIEFRX0FVVE9ORUdfQURWX1JFRwkJMHgwMDEwCisJ I2RlZmluZSBBUV9BTkVHXzEwME0JCQkweDAxMDAKKwkjZGVmaW5lIEFRX0FORUdfUEFVU0UJCQkw eDA0MDAKKwkjZGVmaW5lIEFRX0FORUdfQVNZTV9QQVVTRQkJMHgwODAwCisJI2RlZmluZSBBUV9B TkVHX0FCSUxJVFlfTUFTSwkJMHgwRkUwCisKKyNkZWZpbmUgQVFfQVVUT05FR18xMEdUX0NUUkxf UkVHCTB4MDAyMAorCSNkZWZpbmUgQVFfQU5FR19BRFZfMTBHX1QJCTB4MTAwMAorCSNkZWZpbmUg QVFfQU5FR19BRFZfNUdfVAkJMHgwMTAwCisJI2RlZmluZSBBUV9BTkVHX0FEVl8yRzVfVAkJMHgw MDgwCisJI2RlZmluZSBBUV9BTkVHX0FEVl9MVAkJCTB4MDAwMQorCisjZGVmaW5lIEFRX0FVVE9O RUdfVkVOX1BST1YxX1JFRwkweEM0MDAKKwkjZGVmaW5lIEFRX0FORUdfQURWXzFHCQkJMHg4MDAw CisJI2RlZmluZSBBUV9BTkVHX0FEVl9BUVJBVEUJCTB4MTAwMAorCSNkZWZpbmUgQVFfQU5FR19B RFZfNUdfTgkJMHgwODAwCisJI2RlZmluZSBBUV9BTkVHX0FEVl8yRzVfTgkJMHgwNDAwCisJI2Rl ZmluZSBBUV9BTkVHX0VYX1BIWV9JRAkJMHgwMDQwCisJI2RlZmluZSBBUV9BTkVHX0VOX0RTSAkJ CTB4MDAxMAorCSNkZWZpbmUgQVFfQU5FR19EU0hfUkVUUlkJCTB4MDAwMworCiAjZGVmaW5lIEFR X1BIWV9HTE9CQUxfTU1ECQkweDFFCiAjZGVmaW5lIEFRX1BIWV9HTE9CQUxfQUREUgkJQVFfUEhZ X0FERFIoQVFfUEhZX0dMT0JBTF9NTUQpCiAKICNkZWZpbmUgQVFfR0xCX1NURF9DVFJMX1JFRwkJ MHgwMDAwCiAJI2RlZmluZSBBUV9QSFlfTE9XX1BPV0VSX01PREUJCTB4MDgwMAogCisjZGVmaW5l IEFRX0dMQl9JTkdfUEFVU0VfQ1RSTF9SRUcJMHg3MTQ4CisjZGVmaW5lIEFRX0dMQl9FR1JfUEFV U0VfQ1RSTF9SRUcJMHg0MTQ4CisKICNkZWZpbmUgQVFfVVNCX1BIWV9TRVRfVElNRU9VVAkJMTAw MDAKICNkZWZpbmUgQVFfVVNCX1NFVF9USU1FT1VUCQk0MDAwCiAKQEAgLTE2Myw2ICsxOTUsMTAg QEAgc3RydWN0IGFxYzExMV9waHlfb3B0aW9ucyB7CiB9OwogCiBzdHJ1Y3QgYXFjMTExX2RhdGEg eworCXU4IGxpbmtfc3BlZWQ7CisJdTggbGluazsKKwl1OCBhdXRvbmVnOworCXUzMiBhZHZlcnRp c2VkX3NwZWVkOwogCXN0cnVjdCB7CiAJCXU4IG1ham9yOwogCQl1OCBtaW5vcjsKQEAgLTE3Miw2 ICsyMDgsMjEgQEAgc3RydWN0IGFxYzExMV9kYXRhIHsKIAlzdHJ1Y3QgYXFjMTExX3BoeV9vcHRp b25zIHBoeV9vcHM7CiB9IF9fcGFja2VkOwogCitzdHJ1Y3QgYXFjMTExX2ludF9kYXRhIHsKKwl1 OCByZXMxOworCXU4IGxpbmtfc3BlZWQ6IDc7CisJdTggbGlua19zdGF0dXM6IDE7CisJX19sZTE2 IHJlczI7CisJX19sZTE2IHJlczM7CisJX19sZTE2IHJlczQ7Cit9IF9fcGFja2VkOworCisjZGVm aW5lIEFRX0lOVF9TUEVFRF8xMEcJMHgwRQorI2RlZmluZSBBUV9JTlRfU1BFRURfNUcJCTB4MEYK KyNkZWZpbmUgQVFfSU5UX1NQRUVEXzJfNUcJMHgxMAorI2RlZmluZSBBUV9JTlRfU1BFRURfMUcJ CTB4MTEKKyNkZWZpbmUgQVFfSU5UX1NQRUVEXzEwME0JMHgxMworCiBzdGF0aWMgc3RydWN0IHsK IAl1bnNpZ25lZCBjaGFyIGN0cmw7CiAJdW5zaWduZWQgY2hhciB0aW1lcl9sOwo=