From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754237AbbAPK72 (ORCPT ); Fri, 16 Jan 2015 05:59:28 -0500 Received: from sism000.sis.com ([210.242.182.187]:44881 "EHLO sism02.sis.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1751931AbbAPK7Y (ORCPT ); Fri, 16 Jan 2015 05:59:24 -0500 X-MimeOLE: Produced By Microsoft Exchange V6.5 Content-class: urn:content-classes:message MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Subject: RE: [PATCH 1/2] INPUT/HID: add touch support for SiS touch driver Date: Fri, 16 Jan 2015 18:59:00 +0800 Message-ID: <8322374EB97AA24A95D0DDBFC8F1CA1DBF9E1B@SISMBEV01.sis.com.tw> In-Reply-To: <8322374EB97AA24A95D0DDBFC8F1CA1DBF9DE5@SISMBEV01.sis.com.tw> X-MS-Has-Attach: X-MS-TNEF-Correlator: Thread-Topic: [PATCH 1/2] INPUT/HID: add touch support for SiS touch driver Thread-Index: AdAxX1WC8D+hkTRzRS+b9ecI0wRMLgAABKZgAAR2pxA= References: <8322374EB97AA24A95D0DDBFC8F1CA1DBF987B@SISMBEV01.sis.com.tw><1421063449.12454.17.camel@linux-0dmf.site> <8322374EB97AA24A95D0DDBFC8F1CA1DBF9DE5@SISMBEV01.sis.com.tw> From: =?utf-8?B?5pu+5am36JGzICh0YW1teV90c2VuZyk=?= To: , , "Oliver Neukum" Cc: X-OriginalArrivalTime: 16 Jan 2015 10:59:02.0195 (UTC) FILETIME=[6FE7E030:01D0317B] X-TM-AS-Product-Ver: SMEX-10.2.0.3176-7.500.1018-21256.003 X-TM-AS-Result: No--24.390400-0.000000-31 X-TM-AS-User-Approved-Sender: Yes X-TM-AS-User-Blocked-Sender: No X-Received-IP: 192.168.50.87 X-Envelope-From: X-Sherlock-Send: MailFilter (sism02.sis.com) X-License: 1 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by nfs id t0GAxcbn021832 Hey, Oliver On Mon, Jan 12, 2015 at 7:50 PM, Oliver Neukum wrote: On Mon, 2015-01-12 at 18:53 +0800, 曾婷葳 (tammy_tseng) wrote: > > (Skip the code diff...) > > Again macros for endianness > > And the driver has a great number of conditional compilations are they > really needed? The driver as is has a number of issues and is hard to > review due to the use of "//" for comments and a lot of conditional > compilation and unnecessary variables used for constants. Could you > fix this up and resubmit? Thanks for the reply. I've modified the code (sis_i2c.c/sis_i2c.h/Kconfig/Makefile) to fix them. Please help check them if anything needs to fix. Thanks. Tammy --- diff --git a/linux-3.18.1/drivers/input/touchscreen/Kconfig b/linux-3.18.1/drivers/input/touchscreen/Kconfig index e1d8003..401cd8b 100644 --- a/linux-3.18.1/drivers/input/touchscreen/Kconfig +++ b/linux-3.18.1/drivers/input/touchscreen/Kconfig @@ -962,4 +962,12 @@ config TOUCHSCREEN_ZFORCE To compile this driver as a module, choose M here: the module will be called zforce_ts. +config TOUCHSCREEN_SIS_I2C + tristate "SiS 9200 family I2C touchscreen driver" + depends on I2C + default n + help + This enables support for SiS 9200 family over I2C based touchscreens. + + endif diff --git a/linux-3.18.1/drivers/input/touchscreen/Makefile b/linux-3.18.1/drivers/input/touchscreen/Makefile index 090e61c..67137af 100644 --- a/linux-3.18.1/drivers/input/touchscreen/Makefile +++ b/linux-3.18.1/drivers/input/touchscreen/Makefile @@ -79,3 +79,4 @@ obj-$(CONFIG_TOUCHSCREEN_WM97XX_ZYLONITE) += zylonite-wm97xx.o obj-$(CONFIG_TOUCHSCREEN_W90X900) += w90p910_ts.o obj-$(CONFIG_TOUCHSCREEN_TPS6507X) += tps6507x-ts.o obj-$(CONFIG_TOUCHSCREEN_ZFORCE) += zforce_ts.o +obj-$(CONFIG_TOUCHSCREEN_SIS_I2C) += sis_i2c.o diff --git a/linux-3.18.1/drivers/input/touchscreen/sis_i2c.c b/linux-3.18.1/drivers/input/touchscreen/sis_i2c.c new file mode 100644 index 0000000..157f991 --- /dev/null +++ b/linux-3.18.1/drivers/input/touchscreen/sis_i2c.c @@ -0,0 +1,1267 @@ +/* + * SiS 9200 family I2C Touch Screen Controller Driver + * + * Copyright (C) 2011 SiS, Inc. + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include +#include +#ifdef CONFIG_HAS_EARLYSUSPEND +#include +#endif +#include +#include +#include +#include +#include +#include +#include "sis_i2c.h" +#include +#include +#include +#include +#include +#include + +#ifdef _STD_RW_IO +#include +#include +#include +#define DEVICE_NAME "sis_aegis_touch_device" +static int sis_char_devs_count = 1; /* device count */ +static int sis_char_major = 0; +static struct cdev sis_char_cdev; +static struct class *sis_char_class = NULL; +#endif + +/* Addresses to scan */ +static const unsigned short normal_i2c[] = { SIS_SLAVE_ADDR, I2C_CLIENT_END }; +static struct workqueue_struct *sis_wq; +struct sis_ts_data *ts_bak = 0; +struct sisTP_driver_data *TPInfo = NULL; +static void sis_tpinfo_clear(struct sisTP_driver_data *TPInfo, int max); + +#ifdef CONFIG_HAS_EARLYSUSPEND +static void sis_ts_early_suspend(struct early_suspend *h); +static void sis_ts_late_resume(struct early_suspend *h); +#endif + +#ifdef CONFIG_X86 +/* static const struct i2c_client_address_data addr_data; */ +/* Insmod parameters */ +static int sis_ts_detect(struct i2c_client *client, struct i2c_board_info *info); +#endif + +#ifdef _CHECK_CRC +uint16_t cal_crc (char* cmd, int start, int end); +#endif + +static void PrintBuffer(int start, int length, char* buf) +{ + int i; + for ( i = start; i < length; i++ ) + { + printk("%02x ", buf[i]); + if (i != 0 && i % 30 == 0) + printk("\n"); + } + printk("\n"); +} + +int sis_command_for_write(struct i2c_client *client, int wlength, unsigned char *wdata) +{ + int ret = -1; + struct i2c_msg msg; + + msg.addr = client->addr; + /* Write */ + msg.flags = 0; + msg.len = wlength; + msg.buf = (unsigned char *)wdata; + + ret = i2c_transfer(client->adapter, &msg, 1); + + return ret; +} + +int sis_command_for_read(struct i2c_client *client, int rlength, unsigned char *rdata) +{ + int ret = -1; + struct i2c_msg msg; + + msg.addr = client->addr; + /* Read */ + msg.flags = I2C_M_RD; + msg.len = rlength; + msg.buf = rdata; + + ret = i2c_transfer(client->adapter, &msg, 1); + + return ret; +} + +int sis_cul_unit(uint8_t report_id) +{ + int ret = NORMAL_LEN_PER_POINT; + + if (report_id != ALL_IN_ONE_PACKAGE) + { + if (IS_AREA(report_id) /*&& IS_TOUCH(report_id)*/) + { + ret += AREA_LEN_PER_POINT; + } + if (IS_PRESSURE(report_id)) + { + ret += PRESSURE_LEN_PER_POINT; + } + } + + return ret; +} + +int sis_ReadPacket(struct i2c_client *client, uint8_t cmd, uint8_t* buf) +{ + uint8_t tmpbuf[MAX_BYTE] = {0}; +#ifdef _CHECK_CRC + uint16_t buf_crc = 0; + uint16_t package_crc = 0; + int l_package_crc = 0; + int crc_end = 0; +#endif + int ret = -1; + int touchnum = 0; + int p_count = 0; + int touc_formate_id = 0; + int locate = 0; + bool read_first = true; + +/* + New i2c format + * buf[0] = Low 8 bits of byte count value + * buf[1] = High 8 bits of byte counte value + * buf[2] = Report ID + * buf[touch num * 6 + 2 ] = Touch informations; 1 touch point has 6 bytes, it could be none if no touch + * buf[touch num * 6 + 3] = Touch numbers + * + * One touch point information include 6 bytes, the order is + * + * 1. status = touch down or touch up + * 2. id = finger id + * 3. x axis low 8 bits + * 4. x axis high 8 bits + * 5. y axis low 8 bits + * 6. y axis high 8 bits + * +*/ + do + { + if (locate >= PACKET_BUFFER_SIZE) + { + printk(KERN_ERR "sis_ReadPacket: Buf Overflow\n"); + return -1; + } + + ret = sis_command_for_read(client, MAX_BYTE, tmpbuf); + +#ifdef _DEBUG_PACKAGE + printk(KERN_INFO "chaoban test: Buf_Data [0~63] \n"); + PrintBuffer(0, 64, tmpbuf); +#endif + + if(ret < 0 ) + { + printk(KERN_ERR "sis_ReadPacket: i2c transfer error\n"); + return ret; + } + /* error package length of receiving data */ + else if (tmpbuf[P_BYTECOUNT] > MAX_BYTE) + { + printk(KERN_ERR "sis_ReadPacket: Error Bytecount\n"); + return -1; + } + + if (read_first) + { +#ifdef _SUPPORT_BUTTON_TOUCH + /* access BUTTON TOUCH event and BUTTON NO TOUCH event */ + if (tmpbuf[P_REPORT_ID] == BUTTON_FORMAT) + { + memcpy(&buf[0], &tmpbuf[0], 7); + return 0; /* touchnum is 0 */ + } +#endif + /* access NO TOUCH event unless BUTTON NO TOUCH event */ + if (tmpbuf[P_BYTECOUNT] == 0/*NO_TOUCH_BYTECOUNT*/) + { + return 0; /* touchnum is 0 */ + } + } + + /* skip parsing data when two devices are registered at the same slave address + * parsing data when P_REPORT_ID && 0xf is TOUCH_FORMAT or P_REPORT_ID is ALL_IN_ONE_PACKAGE + */ + touc_formate_id = tmpbuf[P_REPORT_ID] & 0xf; + if ((touc_formate_id != TOUCH_FORMAT) && (touc_formate_id != HIDI2C_FORMAT) && (tmpbuf[P_REPORT_ID] != ALL_IN_ONE_PACKAGE)) + { + printk(KERN_ERR "sis_ReadPacket: Error Report_ID\n"); + return -1; + } + + p_count = (int) tmpbuf[P_BYTECOUNT] - 1; /* start from 0 */ + if (tmpbuf[P_REPORT_ID] != ALL_IN_ONE_PACKAGE) + { + if (IS_TOUCH(tmpbuf[P_REPORT_ID])) + { + p_count -= BYTE_CRC_I2C; /* delete 2 byte crc */ + } + else if (IS_HIDI2C(tmpbuf[P_REPORT_ID])) + { + p_count -= BYTE_CRC_HIDI2C; + } + else /* should not be happen */ + { + printk(KERN_ERR "sis_ReadPacket: delete crc error\n"); + return -1; + } + + if (IS_SCANTIME(tmpbuf[P_REPORT_ID])) + { + p_count -= BYTE_SCANTIME; + } + } + /* else {} For ALL_IN_ONE_PACKAGE */ + + if (read_first) + { + touchnum = tmpbuf[p_count]; + } + else + { + if (tmpbuf[p_count] != 0) + { + printk(KERN_ERR "sis_ReadPacket: get error package\n"); + return -1; + } + } + +#ifdef _CHECK_CRC + crc_end = p_count + (IS_SCANTIME(tmpbuf[P_REPORT_ID]) * 2); + buf_crc = cal_crc(tmpbuf, 2, crc_end); /* sub bytecount (2 byte) */ + l_package_crc = p_count + 1 + (IS_SCANTIME(tmpbuf[P_REPORT_ID]) * 2); + package_crc = get_unaligned_le16(&tmpbuf[l_package_crc]); + + if (buf_crc != package_crc) + { + printk(KERN_ERR "sis_ReadPacket: CRC Error\n"); + return -1; + } +#endif + memcpy(&buf[locate], &tmpbuf[0], 64); /* Buf_Data [0~63] [64~128] */ + locate += 64; + read_first = false; + + }while(tmpbuf[P_REPORT_ID] != ALL_IN_ONE_PACKAGE && tmpbuf[p_count] > 5); + + return touchnum; +} + + +int check_gpio_interrupt(void) +{ + int ret = 0; + + /* CHECK GPIO INTERRUPT STATUS BY YOUR PLATFORM SETTING. */ + ret = gpio_get_value(GPIO_IRQ); + + return ret; +} + +void ts_report_key(struct i2c_client *client, uint8_t keybit_state) +{ + int i = 0; + uint8_t diff_keybit_state= 0x0; /* check keybit_state is difference with pre_keybit_state */ + uint8_t key_value = 0x0; /* button location for binary */ + uint8_t key_pressed = 0x0; /* button is up or down */ + struct sis_ts_data *ts = i2c_get_clientdata(client); + + if (!ts) + { + printk(KERN_ERR "%s error: Missing Platform Data!\n", __func__); + return; + } + + diff_keybit_state = TPInfo->pre_keybit_state ^ keybit_state; + + if (diff_keybit_state) + { + for (i = 0; i < BUTTON_KEY_COUNT; i++) + { + if ((diff_keybit_state >> i) & 0x01) + { + key_value = diff_keybit_state & (0x01 << i); + key_pressed = (keybit_state >> i) & 0x01; + switch (key_value) + { + case MSK_COMP: + input_report_key(ts->input_dev, KEY_COMPOSE, key_pressed); + break; + case MSK_BACK: + input_report_key(ts->input_dev, KEY_BACK, key_pressed); + break; + case MSK_MENU: + input_report_key(ts->input_dev, KEY_MENU, key_pressed); + break; + case MSK_HOME: + input_report_key(ts->input_dev, KEY_HOME, key_pressed); + break; + case MSK_NOBTN: + /* Release the button if it touched. */ + default: + break; + } + } + } + TPInfo->pre_keybit_state = keybit_state; + } +} + + +static void sis_ts_work_func(struct work_struct *work) +{ + struct sis_ts_data *ts = container_of(work, struct sis_ts_data, work); + int ret = -1; + int point_unit; + uint8_t buf[PACKET_BUFFER_SIZE] = {0}; + uint8_t i = 0, fingers = 0; + uint8_t px = 0, py = 0, pstatus = 0; + uint8_t p_area = 0; + uint8_t p_preasure = 0; +#ifdef _SUPPORT_BUTTON_TOUCH + int button_key; + uint8_t button_buf[10] = {0}; +#endif + +#ifdef _ANDROID_4 + bool all_touch_up = true; +#endif + + mutex_lock(&ts->mutex_wq); + + /* I2C or SMBUS block data read */ + ret = sis_ReadPacket(ts->client, SIS_CMD_NORMAL, buf); + +#ifdef _SUPPORT_BUTTON_TOUCH + sis_ReadPacket(ts->client, SIS_CMD_NORMAL, button_buf); +#endif + + /* Error Number */ + if (ret < 0) + { + goto err_free_allocate; + } +#ifdef _SUPPORT_BUTTON_TOUCH + /* access BUTTON TOUCH event and BUTTON NO TOUCH even */ + else if (button_buf[P_REPORT_ID] == BUTTON_FORMAT) + { + button_key = get_unaligned_le16(&button_buf[BUTTON_STATE]); + ts_report_key(ts->client, button_key); + } +#endif + /* access NO TOUCH event unless BUTTON NO TOUCH event */ + else if (ret == 0) + { + fingers = 0; + sis_tpinfo_clear(TPInfo, MAX_FINGERS); + goto label_send_report; /* need to report input_mt_sync() */ + } + + sis_tpinfo_clear(TPInfo, MAX_FINGERS); + + /* Parser and Get the sis9200 data */ + point_unit = sis_cul_unit(buf[P_REPORT_ID]); + fingers = ret; + + TPInfo->fingers = fingers = (fingers > MAX_FINGERS ? 0 : fingers); + + /* fingers 10 = 0 ~ 9 */ + for (i = 0; i < fingers; i++) + { + if ((buf[P_REPORT_ID] != ALL_IN_ONE_PACKAGE) && (i >= 5)) + { /* Calc point status */ + pstatus = BYTE_BYTECOUNT + BYTE_ReportID + ((i - 5) * point_unit); + pstatus += 64; + } + else + { /* Calc point status */ + pstatus = BYTE_BYTECOUNT + BYTE_ReportID + (i * point_unit); + } + + px = pstatus + 2; /* Calc point x_coord */ + py = px + 2; /* Calc point y_coord */ + + if ((buf[pstatus]) == TOUCHUP) + { + TPInfo->pt[i].Width = 0; + TPInfo->pt[i].Height = 0; + TPInfo->pt[i].Pressure = 0; + } + else if (buf[P_REPORT_ID] == ALL_IN_ONE_PACKAGE && (buf[pstatus]) == TOUCHDOWN) + { + TPInfo->pt[i].Width = 1; + TPInfo->pt[i].Height = 1; + TPInfo->pt[i].Pressure = 1; + } + else if ((buf[pstatus]) == TOUCHDOWN) + { + p_area = py + 2; + p_preasure = py + 2 + (IS_AREA(buf[P_REPORT_ID]) * 2); + + /* area */ + if (IS_AREA(buf[P_REPORT_ID])) + { + TPInfo->pt[i].Width = buf[p_area] & 0xff; + TPInfo->pt[i].Height = buf[p_area + 1] & 0xff; + } + else + { + TPInfo->pt[i].Width = 1; + TPInfo->pt[i].Height = 1; + } + /* preasure */ + if (IS_PRESSURE(buf[P_REPORT_ID])) + TPInfo->pt[i].Pressure = (buf[p_preasure]); + else + TPInfo->pt[i].Pressure = 1; + } + else + { + printk(KERN_ERR "sis_ts_work_func: Error Touch Status\n"); + goto err_free_allocate; + } + + TPInfo->pt[i].id = (buf[pstatus + 1]); + TPInfo->pt[i].x = ((buf[px] & 0xff) | ((buf[px + 1] & 0xff)<< 8)); + TPInfo->pt[i].y = ((buf[py] & 0xff) | ((buf[py + 1] & 0xff)<< 8)); + } + +#ifdef _DEBUG_REPORT + for (i = 0; i < TPInfo->fingers; i++) + { + printk(KERN_INFO "chaoban test: i = %d, id = %d, x = %d, y = %d, pstatus = %d, width = %d, height = %d, pressure = %d, \n", i, TPInfo->pt[i].id, TPInfo->pt[i].x, TPInfo->pt[i].y, buf[pstatus], TPInfo->pt[i].Width, TPInfo->pt[i].Height, TPInfo->pt[i].Pressure); + } +#endif + +label_send_report: +/* Report co-ordinates to the multi-touch stack */ +#ifdef _ANDROID_4 + for(i = 0; ((i < TPInfo->fingers) && (i < MAX_FINGERS)); i++) + { + if(TPInfo->pt[i].Pressure) + { + TPInfo->pt[i].Width *= AREA_UNIT; + input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, TPInfo->pt[i].Width); + TPInfo->pt[i].Height *= AREA_UNIT; + input_report_abs(ts->input_dev, ABS_MT_TOUCH_MINOR, TPInfo->pt[i].Height); + input_report_abs(ts->input_dev, ABS_MT_PRESSURE, TPInfo->pt[i].Pressure); + input_report_abs(ts->input_dev, ABS_MT_POSITION_X, TPInfo->pt[i].x); + input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, TPInfo->pt[i].y); + input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, TPInfo->pt[i].id); + input_mt_sync(ts->input_dev); + all_touch_up = false; + } + + if (i == (TPInfo->fingers -1) && all_touch_up == true) + { + input_mt_sync(ts->input_dev); + } + } + + if(TPInfo->fingers == 0) + { + input_mt_sync(ts->input_dev); + } +#else + i = 0; + do + { + input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, TPInfo->pt[i].Pressure); + input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, TPInfo->pt[i].Width); + input_report_abs(ts->input_dev, ABS_MT_WIDTH_MINOR, TPInfo->pt[i].Height); + input_report_abs(ts->input_dev, ABS_MT_POSITION_X, TPInfo->pt[i].x); + input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, TPInfo->pt[i].y); + input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, TPInfo->pt[i].id); /* Android 2.3 */ + input_mt_sync(ts->input_dev); + i++; + } + while ((i < TPInfo->fingers) && (i < MAX_FINGERS)); +#endif + input_sync(ts->input_dev); + +err_free_allocate: + + if (ts->use_irq) + { +/* case 1 mode */ +#ifdef _INT_MODE_1 + /*TODO: After interrupt status low, read i2c bus data by polling, until interrupt status is high */ + ret = check_gpio_interrupt(); /* interrupt pin is still LOW, read data until interrupt pin is released. */ + if (!ret) + { + hrtimer_start(&ts->timer, ktime_set(0, TIMER_NS), HRTIMER_MODE_REL); + } + else + { + if (TPInfo->pre_keybit_state) + { + ts_report_key(ts->client, 0x0); /* clear for interrupt */ + } + +#if ( LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 39) ) + if ((ts->desc->status & IRQ_DISABLED) == IRQ_STATUS_DISABLED) +#else + if ((ts->desc->irq_data.state_use_accessors & IRQD_IRQ_DISABLED) == IRQ_STATUS_DISABLED) +#endif + { + enable_irq(ts->client->irq); + } + } +/* case 2 mode */ +#else + +#if ( LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 39) ) + if ((ts->desc->status & IRQ_DISABLED) == IRQ_STATUS_DISABLED) +#else + if ((ts->desc->irq_data.state_use_accessors & IRQD_IRQ_DISABLED) == IRQ_STATUS_DISABLED) +#endif + { + enable_irq(ts->client->irq); + } +#endif + } + + mutex_unlock(&ts->mutex_wq); + return; +} + +static void sis_tpinfo_clear(struct sisTP_driver_data *TPInfo, int max) +{ + int i = 0; + for(i = 0; i < max; i++) + { + TPInfo->pt[i].id = -1; + TPInfo->pt[i].x = 0; + TPInfo->pt[i].y = 0; + TPInfo->pt[i].Pressure = 0; + TPInfo->pt[i].Width = 0; + } + TPInfo->id = 0x0; + TPInfo->fingers = 0; +} + +static enum hrtimer_restart sis_ts_timer_func(struct hrtimer *timer) +{ + struct sis_ts_data *ts = container_of(timer, struct sis_ts_data, timer); + queue_work(sis_wq, &ts->work); + if (!ts->use_irq) + { /* For Polling mode */ + hrtimer_start(&ts->timer, ktime_set(0, TIMER_NS), HRTIMER_MODE_REL); + } + return HRTIMER_NORESTART; +} + +static irqreturn_t sis_ts_irq_handler(int irq, void *dev_id) +{ + struct sis_ts_data *ts = dev_id; + +#if ( LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 39) ) + if ((ts->desc->status & IRQ_DISABLED) == IRQ_STATUS_ENABLED) +#else + if ((ts->desc->irq_data.state_use_accessors & IRQD_IRQ_DISABLED) == IRQ_STATUS_ENABLED) +#endif + { + disable_irq_nosync(ts->client->irq); + } + queue_work(sis_wq, &ts->work); + + return IRQ_HANDLED; +} + +static int initial_irq(void) +{ + int ret = 0; +#ifdef _I2C_INT_ENABLE + /* initialize gpio and interrupt pins */ + ret = gpio_request(GPIO_IRQ, "GPIO_133"); /* ex. GPIO_133 for interrupt mode */ + if (ret < 0) + { + /* Set Active Low. Please reference the file include/linux/interrupt.h */ + } + /* setting gpio direction here OR boardinfo file*/ + +#else + ret = -1; +#endif + return ret; +} + +uint16_t cal_crc (char* cmd, int start, int end) +{ + int i = 0; + uint16_t crc = 0; + + for (i = start; i <= end ; i++) + { + crc = (crc<<8) ^ crc16tab[((crc>>8) ^ cmd[i] )&0x00FF]; + } + + return crc; +} + +uint16_t cal_crc_with_cmd (char* data, int start, int end, uint8_t cmd) +{ + int i = 0; + uint16_t crc = 0; + + crc = (crc<<8) ^ crc16tab[((crc>>8) ^ cmd)&0x00FF]; + for (i = start; i <= end ; i++) + { + crc = (crc<<8) ^ crc16tab[((crc>>8) ^ data[i] )&0x00FF]; + } + + return crc; +} + +void write_crc (unsigned char *buf, int start, int end) +{ + uint16_t crc = 0; + + crc = cal_crc (buf, start , end); + buf[end+1] = (crc >> 8)& 0xff; + buf[end+2] = crc & 0xff; +} + +#ifdef _STD_RW_IO +#define BUFFER_SIZE MAX_BYTE +static ssize_t sis_cdev_write( struct file *file, const char __user *buf, size_t count, loff_t *f_pos ) +{ + int ret = 0; + char *kdata; + char cmd; + + printk(KERN_INFO "sis_cdev_write.\n"); + + if (ts_bak == 0) + return -13; + + ret = access_ok(VERIFY_WRITE, buf, BUFFER_SIZE); + if (!ret) { + printk(KERN_ERR "cannot access user space memory\n"); + return -11; + } + + kdata = kmalloc(BUFFER_SIZE, GFP_KERNEL); + if (kdata == 0) + return -12; + + ret = copy_from_user(kdata, buf, BUFFER_SIZE); + if (ret) { + printk(KERN_ERR "copy_from_user fail\n"); + kfree(kdata); + return -14; + } +#if 0 + PrintBuffer(0, count, kdata); +#endif + + cmd = kdata[6]; + +/* Write & Read */ + ret = sis_command_for_write(ts_bak->client, count, kdata); + if (ret < 0) { + printk(KERN_ERR "i2c_transfer write error %d\n", ret); + kfree(kdata); + return -21; + } + + if ( copy_to_user((char*) buf, kdata, BUFFER_SIZE ) ) + { + printk(KERN_ERR "copy_to_user fail\n" ); + ret = -19; + } + + kfree( kdata ); + + return ret; +} + +/* for get system time */ +static ssize_t sis_cdev_read( struct file *file, char __user *buf, size_t count, loff_t *f_pos ) +{ + int ret = 0; + char *kdata; + char cmd; + int i; + + printk(KERN_INFO "sis_cdev_read.\n"); + + if (ts_bak == 0) + return -13; + + ret = access_ok(VERIFY_WRITE, buf, BUFFER_SIZE); + if (!ret) { + printk(KERN_ERR "cannot access user space memory\n"); + return -11; + } + + kdata = kmalloc(BUFFER_SIZE, GFP_KERNEL); + if (kdata == 0) + return -12; + + ret = copy_from_user(kdata, buf, BUFFER_SIZE); + if (ret) { + printk(KERN_ERR "copy_from_user fail\n"); + kfree(kdata); + return -14; + } +#if 0 + PrintBuffer(0, count, kdata); +#endif + cmd = kdata[6]; + /* for making sure AP communicates with SiS driver */ + if(cmd == 0xa2) + { + kdata[0] = 5; + kdata[1] = 0; + kdata[3] = 'S'; + kdata[4] = 'i'; + kdata[5] = 'S'; + if ( copy_to_user((char*) buf, kdata, BUFFER_SIZE ) ) + { + printk(KERN_ERR "copy_to_user fail\n" ); + kfree( kdata ); + return -19; + } + + kfree( kdata ); + return 3; + } +/* Write & Read */ + ret = sis_command_for_read(ts_bak->client, MAX_BYTE, kdata); + if (ret < 0) { + printk(KERN_ERR "i2c_transfer read error %d\n", ret); + kfree(kdata); + return -21; + } + + ret = kdata[0] | (kdata[1] << 8); + + printk(KERN_INFO "%d\n", ret); + + for ( i = 0; i < ret && i < BUFFER_SIZE; i++ ) + { + printk("%02x ", kdata[i]); + } + + printk( "\n" ); + + if ( copy_to_user((char*) buf, kdata, BUFFER_SIZE ) ) + { + printk(KERN_ERR "copy_to_user fail\n" ); + ret = -19; + } + + kfree( kdata ); + + return ret; +} + +#undef BUFFER_SIZE + +static int sis_cdev_open(struct inode *inode, struct file *filp) +{ + printk(KERN_INFO "sis_cdev_open.\n"); + if ( ts_bak == 0 ) + return -13; + + msleep(200); + if (ts_bak->use_irq) + { +#if ( LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 39) ) + if ((ts_bak->desc->status & IRQ_DISABLED) == IRQ_STATUS_ENABLED) +#else + if ((ts_bak->desc->irq_data.state_use_accessors & IRQD_IRQ_DISABLED) == IRQ_STATUS_ENABLED) +#endif + { + disable_irq(ts_bak->client->irq); + } + else + { +#if ( LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 39) ) + printk(KERN_INFO "sis_cdev_open: IRQ_STATUS: %x\n",(ts_bak->desc->status & IRQ_DISABLED)); +#else + printk(KERN_INFO "sis_cdev_open: IRQ_STATUS: %x\n",(ts_bak->desc->irq_data.state_use_accessors & IRQD_IRQ_DISABLED)); +#endif + } + } + hrtimer_cancel(&ts_bak->timer); + + /* only flush sis_wq */ + flush_workqueue(sis_wq); + + msleep(200); + + return 0; /* success */ +} + +static int sis_cdev_release(struct inode *inode, struct file *filp) +{ + printk(KERN_INFO "sis_cdev_release.\n"); + + msleep(200); + + if (ts_bak == 0) + return -13; + + if (ts_bak->use_irq) + { +#if ( LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 39) ) + if ((ts_bak->desc->status & IRQ_DISABLED) == IRQ_STATUS_DISABLED) +#else + if ((ts_bak->desc->irq_data.state_use_accessors & IRQD_IRQ_DISABLED) == IRQ_STATUS_DISABLED) +#endif + { + enable_irq(ts_bak->client->irq); + } + } + else + hrtimer_start(&ts_bak->timer, ktime_set(1, 0), HRTIMER_MODE_REL); + + return 0; +} + +static const struct file_operations sis_cdev_fops = { + .owner = THIS_MODULE, + .read = sis_cdev_read, + .write = sis_cdev_write, + .open = sis_cdev_open, + .release= sis_cdev_release, +}; + +static int sis_setup_chardev(struct sis_ts_data *ts) +{ + + dev_t dev = MKDEV(sis_char_major, 0); + int alloc_ret = 0; + int cdev_err = 0; + int input_err = 0; + struct device *class_dev = NULL; + void *ptr_err; + + printk("sis_setup_chardev.\n"); + + if (ts == NULL) + { + input_err = -ENOMEM; + goto error; + } + /* dynamic allocate driver handle */ + alloc_ret = alloc_chrdev_region(&dev, 0, sis_char_devs_count, DEVICE_NAME); + if (alloc_ret) + goto error; + + sis_char_major = MAJOR(dev); + cdev_init(&sis_char_cdev, &sis_cdev_fops); + sis_char_cdev.owner = THIS_MODULE; + cdev_err = cdev_add(&sis_char_cdev, MKDEV(sis_char_major, 0), sis_char_devs_count); + + if (cdev_err) + goto error; + + printk(KERN_INFO "%s driver(major %d) installed.\n", DEVICE_NAME, sis_char_major); + + /* register class */ + sis_char_class = class_create(THIS_MODULE, DEVICE_NAME); + if(IS_ERR(ptr_err = sis_char_class)) + { + goto err2; + } + + class_dev = device_create(sis_char_class, NULL, MKDEV(sis_char_major, 0), NULL, DEVICE_NAME); + + if(IS_ERR(ptr_err = class_dev)) + { + goto err; + } + + return 0; +error: + if (cdev_err == 0) + cdev_del(&sis_char_cdev); + if (alloc_ret == 0) + unregister_chrdev_region(MKDEV(sis_char_major, 0), sis_char_devs_count); + if(input_err != 0) + { + printk("sis_ts_bak error!\n"); + } +err: + device_destroy(sis_char_class, MKDEV(sis_char_major, 0)); +err2: + class_destroy(sis_char_class); + return -1; +} +#endif + +static int sis_ts_probe( + struct i2c_client *client, const struct i2c_device_id *id) +{ + int ret = 0; + struct sis_ts_data *ts = NULL; + struct sis_i2c_rmi_platform_data *pdata = NULL; + + printk(KERN_INFO "sis_ts_probe\n"); + + TPInfo = kzalloc(sizeof(struct sisTP_driver_data), GFP_KERNEL); + if (TPInfo == NULL) + { + ret = -ENOMEM; + goto err_alloc_data_failed; + } + + ts = kzalloc(sizeof(struct sis_ts_data), GFP_KERNEL); + if (ts == NULL) + { + ret = -ENOMEM; + goto err_alloc_data_failed; + } + + ts_bak = ts; + + mutex_init(&ts->mutex_wq); + + /* 1. Init Work queue and necessary buffers */ + INIT_WORK(&ts->work, sis_ts_work_func); + ts->client = client; + i2c_set_clientdata(client, ts); + pdata = client->dev.platform_data; + + if (pdata) + ts->power = pdata->power; + if (ts->power) + { + ret = ts->power(1); + if (ret < 0) + { + printk(KERN_ERR "sis_ts_probe power on failed\n"); + goto err_power_failed; + } + } + + /* 2. Allocate input device */ + ts->input_dev = input_allocate_device(); + if (ts->input_dev == NULL) + { + ret = -ENOMEM; + printk(KERN_ERR "sis_ts_probe: Failed to allocate input device\n"); + goto err_input_dev_alloc_failed; + } + + /* This input device name should be the same to IDC file name. */ + ts->input_dev->name = "sis_touch"; + + set_bit(EV_ABS, ts->input_dev->evbit); + set_bit(EV_KEY, ts->input_dev->evbit); + set_bit(ABS_MT_POSITION_X, ts->input_dev->absbit); + set_bit(ABS_MT_POSITION_Y, ts->input_dev->absbit); + set_bit(ABS_MT_TRACKING_ID, ts->input_dev->absbit); + +#ifdef _ANDROID_4 + set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit); + set_bit(ABS_MT_PRESSURE, ts->input_dev->absbit); + set_bit(ABS_MT_TOUCH_MAJOR, ts->input_dev->absbit); + set_bit(ABS_MT_TOUCH_MINOR, ts->input_dev->absbit); + input_set_abs_params(ts->input_dev, ABS_MT_PRESSURE, 0, PRESSURE_MAX, 0, 0); + input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, AREA_LENGTH_LONGER, 0, 0); + input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MINOR, 0, AREA_LENGTH_SHORT, 0, 0); +#else + set_bit(ABS_MT_TOUCH_MAJOR, ts->input_dev->absbit); + set_bit(ABS_MT_WIDTH_MAJOR, ts->input_dev->absbit); + set_bit(ABS_MT_WIDTH_MINOR, ts->input_dev->absbit); + input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, PRESSURE_MAX, 0, 0); + input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, AREA_LENGTH_LONGER, 0, 0); + input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MINOR, 0, AREA_LENGTH_SHORT, 0, 0); +#endif + + input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, SIS_MAX_X, 0, 0); + input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, SIS_MAX_Y, 0, 0); + input_set_abs_params(ts->input_dev, ABS_MT_TRACKING_ID, 0, 15, 0, 0); + + /* add for touch keys */ + set_bit(KEY_COMPOSE, ts->input_dev->keybit); + set_bit(KEY_BACK, ts->input_dev->keybit); + set_bit(KEY_MENU, ts->input_dev->keybit); + set_bit(KEY_HOME, ts->input_dev->keybit); + + /* 3. Register input device to core */ + ret = input_register_device(ts->input_dev); + + if (ret) + { + printk(KERN_ERR "sis_ts_probe: Unable to register %s input device\n", ts->input_dev->name); + goto err_input_register_device_failed; + } + + /* 4. irq or timer setup */ + ret = initial_irq(); + if (ret < 0) + { + + } + else + { + client->irq = gpio_to_irq(GPIO_IRQ); + ret = request_irq(client->irq, sis_ts_irq_handler, IRQF_TRIGGER_FALLING, client->name, ts); + if (ret == 0) + { + ts->use_irq = 1; + } + else + { + dev_err(&client->dev, "request_irq failed\n"); + } + } + + ts->desc = irq_to_desc(ts_bak->client->irq); + + hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); + ts->timer.function = sis_ts_timer_func; + + if (!ts->use_irq) + { + hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL); + } + +#ifdef CONFIG_HAS_EARLYSUSPEND + ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; + ts->early_suspend.suspend = sis_ts_early_suspend; + ts->early_suspend.resume = sis_ts_late_resume; + register_early_suspend(&ts->early_suspend); +#endif + printk(KERN_INFO "sis_ts_probe: Start touchscreen %s in %s mode\n", ts->input_dev->name, ts->use_irq ? "interrupt" : "polling"); + + if (ts->use_irq) + { +#ifdef _INT_MODE_1 + printk(KERN_INFO "sis_ts_probe: interrupt case 1 mode\n"); +#else + printk(KERN_INFO "sis_ts_probe: interrupt case 2 mode\n"); +#endif + } + +#ifdef _STD_RW_IO + ret = sis_setup_chardev(ts); + if(ret) + { + printk( KERN_INFO"sis_setup_chardev fail\n"); + } +#endif + + printk( KERN_INFO"sis SIS_SLAVE_ADDR: %d\n", SIS_SLAVE_ADDR); + + return 0; + +err_input_register_device_failed: + input_free_device(ts->input_dev); + +err_input_dev_alloc_failed: +err_power_failed: + kfree(ts); +err_alloc_data_failed: + return ret; +} + +static int sis_ts_remove(struct i2c_client *client) +{ + struct sis_ts_data *ts = i2c_get_clientdata(client); + +#ifdef CONFIG_HAS_EARLYSUSPEND + unregister_early_suspend(&ts->early_suspend); +#endif + if (ts->use_irq) + free_irq(client->irq, ts); + else + hrtimer_cancel(&ts->timer); + input_unregister_device(ts->input_dev); + kfree(ts); + + return 0; +} + +static int sis_ts_suspend(struct i2c_client *client, pm_message_t mesg) +{ + int ret = 0; + struct sis_ts_data *ts = i2c_get_clientdata(client); + + TPInfo->pre_keybit_state = 0x0; + + if (ts->use_irq) + { +#if ( LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 39) ) + if ((ts->desc->status & IRQ_DISABLED) == IRQ_STATUS_ENABLED) +#else + if ((ts->desc->irq_data.state_use_accessors & IRQD_IRQ_DISABLED) == IRQ_STATUS_ENABLED) +#endif + { + disable_irq(client->irq); + } + } + else + hrtimer_cancel(&ts->timer); + /* only flush sis_wq */ + flush_workqueue(sis_wq); + + if (ts->power) { + ret = ts->power(0); + if (ret < 0) + printk(KERN_ERR "sis_ts_suspend power off failed\n"); + } + + return 0; +} + +static int sis_ts_resume(struct i2c_client *client) +{ + int ret = 0; + struct sis_ts_data *ts = i2c_get_clientdata(client); + + if (ts->power) + { + ret = ts->power(1); + if (ret < 0) + printk(KERN_ERR "sis_ts_resume power on failed\n"); + } + + if (ts->use_irq) + { +#if ( LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 39) ) + if ((ts->desc->status & IRQ_DISABLED) == IRQ_STATUS_DISABLED) +#else + if ((ts->desc->irq_data.state_use_accessors & IRQD_IRQ_DISABLED) == IRQ_STATUS_DISABLED) +#endif + { + enable_irq(client->irq); + } + } + else + hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL); + + return 0; +} + +#ifdef CONFIG_HAS_EARLYSUSPEND +static void sis_ts_early_suspend(struct early_suspend *h) +{ + struct sis_ts_data *ts; + + TPInfo->pre_keybit_state = 0x0; + ts = container_of(h, struct sis_ts_data, early_suspend); + sis_ts_suspend(ts->client, PMSG_SUSPEND); +} + +static void sis_ts_late_resume(struct early_suspend *h) +{ + struct sis_ts_data *ts; + + ts = container_of(h, struct sis_ts_data, early_suspend); + sis_ts_resume(ts->client); +} +#endif + +static const struct i2c_device_id sis_ts_id[] = { + { SIS_I2C_NAME, 0 }, + { } +}; + +MODULE_DEVICE_TABLE(i2c, sis_ts_id); + +static struct i2c_driver sis_ts_driver = { + .probe = sis_ts_probe, + .remove = sis_ts_remove, +#ifndef CONFIG_HAS_EARLYSUSPEND + .suspend = sis_ts_suspend, + .resume = sis_ts_resume, +#endif +#ifdef CONFIG_X86 + .class = I2C_CLASS_HWMON, + .detect = sis_ts_detect, + .address_list = normal_i2c, +#endif + .id_table = sis_ts_id, + .driver = { + .name = SIS_I2C_NAME, + }, +}; + +static int __init sis_ts_init(void) +{ + printk( KERN_INFO "sis_ts_init\n" ); + + sis_wq = create_singlethread_workqueue("sis_wq"); + + if (!sis_wq) + return -ENOMEM; + + return i2c_add_driver(&sis_ts_driver); +} + +#ifdef CONFIG_X86 +/* Return 0 if detection is successful, -ENODEV otherwise */ +static int sis_ts_detect(struct i2c_client *client, + struct i2c_board_info *info) +{ + const char *type_name; + + printk(KERN_INFO "sis_ts_detect\n"); + + type_name = "sis_i2c_ts"; + strlcpy(info->type, type_name, I2C_NAME_SIZE); + + return 0; +} +#endif + +static void __exit sis_ts_exit(void) +{ +#ifdef _STD_RW_IO + dev_t dev; +#endif + + printk(KERN_INFO "sis_ts_exit\n"); + + i2c_del_driver(&sis_ts_driver); + + if (sis_wq) + destroy_workqueue(sis_wq); + +#ifdef _STD_RW_IO + dev = MKDEV(sis_char_major, 0); + cdev_del(&sis_char_cdev); + unregister_chrdev_region(dev, sis_char_devs_count); + device_destroy(sis_char_class, MKDEV(sis_char_major, 0)); + class_destroy(sis_char_class); +#endif +} + +module_init(sis_ts_init); +module_exit(sis_ts_exit); +MODULE_DESCRIPTION("SiS 9200 Family Touchscreen Driver"); +MODULE_LICENSE("GPL"); diff --git a/linux-3.18.1/drivers/input/touchscreen/sis_i2c.h b/linux-3.18.1/drivers/input/touchscreen/sis_i2c.h new file mode 100644 index 0000000..c1d65c4 --- /dev/null +++ b/linux-3.18.1/drivers/input/touchscreen/sis_i2c.h @@ -0,0 +1,215 @@ +/* + * include/linux/sis_i2c.h - platform data structure for SiS 9200 family + * + * Copyright (C) 2011 SiS, Inc. + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Date: 2015/01/15 + * Version: Android_v2.05.00-A639-1113 + */ +#include + +#ifndef _LINUX_SIS_I2C_H +#define _LINUX_SIS_I2C_H + + +#define SIS_I2C_NAME "sis_i2c_ts" +#define SIS_SLAVE_ADDR 0x5c +#define TIMER_NS 10000000 //10ms +#define MAX_FINGERS 10 + + +/* For Android 4.0 */ +/* Only for Linux kernel 2.6.34 and later */ +#define _ANDROID_4 // ON/OFF + +/* For standard R/W IO*/ +#define _STD_RW_IO // ON/OFF + +/* Interrupt setting and modes */ +#define _I2C_INT_ENABLE // ON/OFF +#define GPIO_IRQ 133 + +/* Enable if use interrupt case 1 mode. */ +/* Disable if use interrupt case 2 mode. */ +//#define _INT_MODE_1 // ON/OFF + +/* IRQ STATUS */ +#if ( LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 39) ) +#define IRQ_STATUS_DISABLED 0x200 +#else +#define IRQ_STATUS_DISABLED (1<<16) +#endif +#define IRQ_STATUS_ENABLED 0x0 + +/* Resolution mode */ +// Constant value +#define SIS_MAX_X 4095 +#define SIS_MAX_Y 4095 + +#define ONE_BYTE 1 +#define FIVE_BYTE 5 +#define EIGHT_BYTE 8 +#define SIXTEEN_BYTE 16 +#define PACKET_BUFFER_SIZE 128 + +#define SIS_CMD_NORMAL 0x0 +#define SIS_CMD_SOFTRESET 0x82 +#define SIS_CMD_RECALIBRATE 0x87 +#define SIS_CMD_POWERMODE 0x90 +#define MSK_TOUCHNUM 0x0f +#define MSK_HAS_CRC 0x10 +#define MSK_DATAFMT 0xe0 +#define MSK_PSTATE 0x0f +#define MSK_PID 0xf0 +#define RES_FMT 0x00 +#define FIX_FMT 0x40 + +/* for new i2c format */ +#define TOUCHDOWN 0x3 +#define TOUCHUP 0x0 +#define MAX_BYTE 64 +#define PRESSURE_MAX 255 + +#ifdef _ANDROID_4 +#define AREA_LENGTH_LONGER 5792 //Resolution diagonal +#define AREA_LENGTH_SHORT 5792 // ((SIS_MAX_X^2) + (SIS_MAX_Y^2))^0.5 +#define AREA_UNIT (5792/32) +#else +#define AREA_LENGTH_LONGER 31 +#define AREA_LENGTH_SHORT 31 +#endif + + +#define FORMAT_MODE 1 + +#define MSK_NOBTN 0 +#define MSK_COMP 1 +#define MSK_BACK 2 +#define MSK_MENU 4 +#define MSK_HOME 8 + +#define P_BYTECOUNT 0 +#define ALL_IN_ONE_PACKAGE 0x10 +#define IS_TOUCH(x) (x & 0x1) +#define IS_HIDI2C(x) (x & 0x6) +#define IS_AREA(x) ((x >> 4) & 0x1) +#define IS_PRESSURE(x) ((x >> 5) & 0x1) +#define IS_SCANTIME(x) ((x >> 6) & 0x1) +//#define _DEBUG_PACKAGE // ON/OFF +//#define _DEBUG_REPORT // ON/OFF +#define NORMAL_LEN_PER_POINT 6 +#define AREA_LEN_PER_POINT 2 +#define PRESSURE_LEN_PER_POINT 1 + +//#define _CHECK_CRC // ON/OFF +//#define _SUPPORT_BUTTON_TOUCH // ON/OFF +#define TOUCH_FORMAT 0x1 +#define BUTTON_FORMAT 0x4 +#define HIDI2C_FORMAT 0x6 +#define P_REPORT_ID 2 +#define BUTTON_STATE 3 +#define BUTTON_KEY_COUNT 16 +#define BYTE_BYTECOUNT 2 +#define BYTE_COUNT 1 +#define BYTE_ReportID 1 +#define BYTE_CRC_HIDI2C 0 +#define BYTE_CRC_I2C 2 +#define BYTE_SCANTIME 2 +#define NO_TOUCH_BYTECOUNT 0x3 + +/* TODO */ +#define TOUCH_POWER_PIN 0 +#define TOUCH_RESET_PIN 1 + +/* CMD Define */ +#define BUF_ACK_PLACE_L 4 +#define BUF_ACK_PLACE_H 5 +#define BUF_ACK_L 0xEF +#define BUF_ACK_H 0xBE +#define BUF_NACK_L 0xAD +#define BUF_NACK_H 0xDE +#define BUF_CRC_PLACE 7 + + + +struct sis_i2c_rmi_platform_data { + int (*power)(int on); /* Only valid in first array entry */ +}; + +static const unsigned short crc16tab[256]= { + 0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7, + 0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef, + 0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6, + 0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de, + 0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485, + 0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d, + 0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4, + 0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc, + 0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823, + 0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b, + 0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12, + 0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a, + 0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41, + 0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49, + 0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70, + 0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78, + 0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f, + 0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067, + 0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e, + 0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256, + 0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d, + 0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405, + 0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c, + 0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634, + 0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab, + 0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3, + 0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a, + 0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92, + 0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9, + 0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1, + 0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8, + 0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0 +}; + +struct Point { + int id; + unsigned short x, y; // uint16_t ? + uint16_t Pressure; + uint16_t Width; + uint16_t Height; +}; + +struct sisTP_driver_data { + int id; + int fingers; + uint8_t pre_keybit_state; + struct Point pt[MAX_FINGERS]; +}; + +struct sis_ts_data { + int (*power)(int on); + int use_irq; + struct i2c_client *client; + struct input_dev *input_dev; + struct hrtimer timer; + struct irq_desc *desc; + struct work_struct work; + struct mutex mutex_wq; +#ifdef CONFIG_HAS_EARLYSUSPEND + struct early_suspend early_suspend; +#endif +}; + +static int sis_ts_suspend(struct i2c_client *client, pm_message_t mesg); +static int sis_ts_resume(struct i2c_client *client); + +#endif /* _LINUX_SIS_I2C_H */ {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?utf-8?B?5pu+5am36JGzICh0YW1teV90c2VuZyk=?= Subject: RE: [PATCH 1/2] INPUT/HID: add touch support for SiS touch driver Date: Fri, 16 Jan 2015 18:59:00 +0800 Message-ID: <8322374EB97AA24A95D0DDBFC8F1CA1DBF9E1B@SISMBEV01.sis.com.tw> References: <8322374EB97AA24A95D0DDBFC8F1CA1DBF987B@SISMBEV01.sis.com.tw><1421063449.12454.17.camel@linux-0dmf.site> <8322374EB97AA24A95D0DDBFC8F1CA1DBF9DE5@SISMBEV01.sis.com.tw> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from sism000.sis.com ([210.242.182.187]:44881 "EHLO sism02.sis.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1751931AbbAPK7Y (ORCPT ); Fri, 16 Jan 2015 05:59:24 -0500 Content-class: urn:content-classes:message In-Reply-To: <8322374EB97AA24A95D0DDBFC8F1CA1DBF9DE5@SISMBEV01.sis.com.tw> Sender: linux-input-owner@vger.kernel.org List-Id: linux-input@vger.kernel.org To: linux-kernel@vger.kernel.org, linux-input@vger.kernel.org, Oliver Neukum Cc: tammy0524@gmail.com SGV5LCBPbGl2ZXINCg0KT24gTW9uLCBKYW4gMTIsIDIwMTUgYXQgNzo1MCBQTSwgT2xpdmVyIE5l dWt1bSA8b25ldWt1bUBzdXNlLmRlPiB3cm90ZToNCk9uIE1vbiwgMjAxNS0wMS0xMiBhdCAxODo1 MyArMDgwMCwg5pu+5am36JGzICh0YW1teV90c2VuZykgd3JvdGU6DQo+ID4gKFNraXAgdGhlIGNv ZGUgZGlmZi4uLikNCj4gDQo+IEFnYWluIG1hY3JvcyBmb3IgZW5kaWFubmVzcw0KPiANCj4gQW5k IHRoZSBkcml2ZXIgaGFzIGEgZ3JlYXQgbnVtYmVyIG9mIGNvbmRpdGlvbmFsIGNvbXBpbGF0aW9u cyBhcmUgdGhleSANCj4gcmVhbGx5IG5lZWRlZD8gVGhlIGRyaXZlciBhcyBpcyBoYXMgYSBudW1i ZXIgb2YgaXNzdWVzIGFuZCBpcyBoYXJkIHRvIA0KPiByZXZpZXcgZHVlIHRvIHRoZSB1c2Ugb2Yg Ii8vIiBmb3IgY29tbWVudHMgYW5kIGEgbG90IG9mIGNvbmRpdGlvbmFsIA0KPiBjb21waWxhdGlv biBhbmQgdW5uZWNlc3NhcnkgdmFyaWFibGVzIHVzZWQgZm9yIGNvbnN0YW50cy4gQ291bGQgeW91 IA0KPiBmaXggdGhpcyB1cCBhbmQgcmVzdWJtaXQ/DQoNClRoYW5rcyBmb3IgdGhlIHJlcGx5LiBJ J3ZlIG1vZGlmaWVkIHRoZSBjb2RlIChzaXNfaTJjLmMvc2lzX2kyYy5oL0tjb25maWcvTWFrZWZp bGUpIHRvIGZpeCB0aGVtLg0KUGxlYXNlIGhlbHAgY2hlY2sgdGhlbSBpZiBhbnl0aGluZyBuZWVk cyB0byBmaXguDQpUaGFua3MuDQoNClRhbW15DQoNCi0tLQ0KZGlmZiAtLWdpdCBhL2xpbnV4LTMu MTguMS9kcml2ZXJzL2lucHV0L3RvdWNoc2NyZWVuL0tjb25maWcgYi9saW51eC0zLjE4LjEvZHJp dmVycy9pbnB1dC90b3VjaHNjcmVlbi9LY29uZmlnDQppbmRleCBlMWQ4MDAzLi40MDFjZDhiIDEw MDY0NA0KLS0tIGEvbGludXgtMy4xOC4xL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vS2NvbmZp Zw0KKysrIGIvbGludXgtMy4xOC4xL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vS2NvbmZpZw0K QEAgLTk2Miw0ICs5NjIsMTIgQEAgY29uZmlnIFRPVUNIU0NSRUVOX1pGT1JDRQ0KIAkgIFRvIGNv bXBpbGUgdGhpcyBkcml2ZXIgYXMgYSBtb2R1bGUsIGNob29zZSBNIGhlcmU6IHRoZQ0KIAkgIG1v ZHVsZSB3aWxsIGJlIGNhbGxlZCB6Zm9yY2VfdHMuDQogDQorY29uZmlnIFRPVUNIU0NSRUVOX1NJ U19JMkMNCisJdHJpc3RhdGUgIlNpUyA5MjAwIGZhbWlseSBJMkMgdG91Y2hzY3JlZW4gZHJpdmVy Ig0KKwlkZXBlbmRzIG9uIEkyQw0KKwlkZWZhdWx0IG4NCisJaGVscA0KKwkgIFRoaXMgZW5hYmxl cyBzdXBwb3J0IGZvciBTaVMgOTIwMCBmYW1pbHkgb3ZlciBJMkMgYmFzZWQgdG91Y2hzY3JlZW5z Lg0KKw0KKw0KIGVuZGlmDQpkaWZmIC0tZ2l0IGEvbGludXgtMy4xOC4xL2RyaXZlcnMvaW5wdXQv dG91Y2hzY3JlZW4vTWFrZWZpbGUgYi9saW51eC0zLjE4LjEvZHJpdmVycy9pbnB1dC90b3VjaHNj cmVlbi9NYWtlZmlsZQ0KaW5kZXggMDkwZTYxYy4uNjcxMzdhZiAxMDA2NDQNCi0tLSBhL2xpbnV4 LTMuMTguMS9kcml2ZXJzL2lucHV0L3RvdWNoc2NyZWVuL01ha2VmaWxlDQorKysgYi9saW51eC0z LjE4LjEvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi9NYWtlZmlsZQ0KQEAgLTc5LDMgKzc5LDQg QEAgb2JqLSQoQ09ORklHX1RPVUNIU0NSRUVOX1dNOTdYWF9aWUxPTklURSkJKz0genlsb25pdGUt d205N3h4Lm8NCiBvYmotJChDT05GSUdfVE9VQ0hTQ1JFRU5fVzkwWDkwMCkJKz0gdzkwcDkxMF90 cy5vDQogb2JqLSQoQ09ORklHX1RPVUNIU0NSRUVOX1RQUzY1MDdYKQkrPSB0cHM2NTA3eC10cy5v DQogb2JqLSQoQ09ORklHX1RPVUNIU0NSRUVOX1pGT1JDRSkJKz0gemZvcmNlX3RzLm8NCitvYmot JChDT05GSUdfVE9VQ0hTQ1JFRU5fU0lTX0kyQykgICAJKz0gc2lzX2kyYy5vDQpkaWZmIC0tZ2l0 IGEvbGludXgtMy4xOC4xL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vc2lzX2kyYy5jIGIvbGlu dXgtMy4xOC4xL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vc2lzX2kyYy5jDQpuZXcgZmlsZSBt b2RlIDEwMDY0NA0KaW5kZXggMDAwMDAwMC4uMTU3Zjk5MQ0KLS0tIC9kZXYvbnVsbA0KKysrIGIv bGludXgtMy4xOC4xL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vc2lzX2kyYy5jDQpAQCAtMCww ICsxLDEyNjcgQEANCisvKg0KKyAqIFNpUyA5MjAwIGZhbWlseSBJMkMgVG91Y2ggU2NyZWVuIENv bnRyb2xsZXIgRHJpdmVyDQorICoNCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgU2lTLCBJbmMuDQor ICoNCisgKiBUaGlzIHNvZnR3YXJlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIEdlbmVyYWwgUHVibGljDQorICogTGljZW5zZSB2ZXJzaW9uIDIsIGFzIHB1Ymxpc2hlZCBi eSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBhbmQNCisgKiBtYXkgYmUgY29waWVkLCBk aXN0cmlidXRlZCwgYW5kIG1vZGlmaWVkIHVuZGVyIHRob3NlIHRlcm1zLg0KKyAqDQorICogVGhp cyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsDQorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxp ZWQgd2FycmFudHkgb2YNCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlDQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4NCisgKg0KKyAqLw0KKw0KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUu aD4NCisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4NCisjaWZkZWYgQ09ORklHX0hBU19FQVJMWVNV U1BFTkQNCisjaW5jbHVkZSA8bGludXgvZWFybHlzdXNwZW5kLmg+DQorI2VuZGlmDQorI2luY2x1 ZGUgPGxpbnV4L2hydGltZXIuaD4NCisjaW5jbHVkZSA8bGludXgvaTJjLmg+DQorI2luY2x1ZGUg PGxpbnV4L2lucHV0Lmg+DQorI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPg0KKyNpbmNsdWRl IDxsaW51eC9pby5oPg0KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4NCisjaW5j bHVkZSAic2lzX2kyYy5oIg0KKyNpbmNsdWRlIDxsaW51eC9saW5rYWdlLmg+DQorI2luY2x1ZGUg PGxpbnV4L3NsYWIuaD4NCisjaW5jbHVkZSA8bGludXgvZ3Bpby5oPg0KKyNpbmNsdWRlIDxhc20v dWFjY2Vzcy5oPg0KKyNpbmNsdWRlIDxsaW51eC9pcnEuaD4NCisjaW5jbHVkZSA8YXNtL3VuYWxp Z25lZC5oPg0KKw0KKyNpZmRlZiBfU1REX1JXX0lPDQorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4N CisjaW5jbHVkZSA8bGludXgvZnMuaD4NCisjaW5jbHVkZSA8bGludXgvY2Rldi5oPg0KKyNkZWZp bmUgREVWSUNFX05BTUUgInNpc19hZWdpc190b3VjaF9kZXZpY2UiDQorc3RhdGljIGludCBzaXNf Y2hhcl9kZXZzX2NvdW50ID0gMTsgICAgICAgIC8qIGRldmljZSBjb3VudCAqLw0KK3N0YXRpYyBp bnQgc2lzX2NoYXJfbWFqb3IgPSAwOw0KK3N0YXRpYyBzdHJ1Y3QgY2RldiBzaXNfY2hhcl9jZGV2 Ow0KK3N0YXRpYyBzdHJ1Y3QgY2xhc3MgKnNpc19jaGFyX2NsYXNzID0gTlVMTDsNCisjZW5kaWYN CisNCisvKiBBZGRyZXNzZXMgdG8gc2NhbiAqLw0KK3N0YXRpYyBjb25zdCB1bnNpZ25lZCBzaG9y dCBub3JtYWxfaTJjW10gPSB7IFNJU19TTEFWRV9BRERSLCBJMkNfQ0xJRU5UX0VORCB9Ow0KK3N0 YXRpYyBzdHJ1Y3Qgd29ya3F1ZXVlX3N0cnVjdCAqc2lzX3dxOw0KK3N0cnVjdCBzaXNfdHNfZGF0 YSAqdHNfYmFrID0gMDsNCitzdHJ1Y3Qgc2lzVFBfZHJpdmVyX2RhdGEgKlRQSW5mbyA9IE5VTEw7 DQorc3RhdGljIHZvaWQgc2lzX3RwaW5mb19jbGVhcihzdHJ1Y3Qgc2lzVFBfZHJpdmVyX2RhdGEg KlRQSW5mbywgaW50IG1heCk7DQorDQorI2lmZGVmIENPTkZJR19IQVNfRUFSTFlTVVNQRU5EDQor c3RhdGljIHZvaWQgc2lzX3RzX2Vhcmx5X3N1c3BlbmQoc3RydWN0IGVhcmx5X3N1c3BlbmQgKmgp Ow0KK3N0YXRpYyB2b2lkIHNpc190c19sYXRlX3Jlc3VtZShzdHJ1Y3QgZWFybHlfc3VzcGVuZCAq aCk7DQorI2VuZGlmDQorDQorI2lmZGVmIENPTkZJR19YODYNCisvKiBzdGF0aWMgY29uc3Qgc3Ry dWN0IGkyY19jbGllbnRfYWRkcmVzc19kYXRhIGFkZHJfZGF0YTsgKi8NCisvKiBJbnNtb2QgcGFy YW1ldGVycyAqLw0KK3N0YXRpYyBpbnQgc2lzX3RzX2RldGVjdChzdHJ1Y3QgaTJjX2NsaWVudCAq Y2xpZW50LCBzdHJ1Y3QgaTJjX2JvYXJkX2luZm8gKmluZm8pOw0KKyNlbmRpZg0KKw0KKyNpZmRl ZiBfQ0hFQ0tfQ1JDDQordWludDE2X3QgY2FsX2NyYyAoY2hhciogY21kLCBpbnQgc3RhcnQsIGlu dCBlbmQpOw0KKyNlbmRpZg0KKw0KK3N0YXRpYyB2b2lkIFByaW50QnVmZmVyKGludCBzdGFydCwg aW50IGxlbmd0aCwgY2hhciogYnVmKQ0KK3sNCisJaW50IGk7DQorCWZvciAoIGkgPSBzdGFydDsg aSA8IGxlbmd0aDsgaSsrICkNCisJew0KKwkJcHJpbnRrKCIlMDJ4ICIsIGJ1ZltpXSk7DQorCQlp ZiAoaSAhPSAwICYmIGkgJSAzMCA9PSAwKQ0KKwkJCXByaW50aygiXG4iKTsNCisJfQ0KKwlwcmlu dGsoIlxuIik7CQ0KK30NCisNCitpbnQgc2lzX2NvbW1hbmRfZm9yX3dyaXRlKHN0cnVjdCBpMmNf Y2xpZW50ICpjbGllbnQsIGludCB3bGVuZ3RoLCB1bnNpZ25lZCBjaGFyICp3ZGF0YSkNCit7DQor ICAgIGludCByZXQgPSAtMTsNCisgICAgc3RydWN0IGkyY19tc2cgbXNnOw0KKw0KKyAgICBtc2cu YWRkciA9IGNsaWVudC0+YWRkcjsNCisgICAgLyogV3JpdGUgKi8NCisgICAgbXNnLmZsYWdzID0g MDsNCisgICAgbXNnLmxlbiA9IHdsZW5ndGg7DQorICAgIG1zZy5idWYgPSAodW5zaWduZWQgY2hh ciAqKXdkYXRhOw0KKw0KKyAgICByZXQgPSBpMmNfdHJhbnNmZXIoY2xpZW50LT5hZGFwdGVyLCAm bXNnLCAxKTsNCisNCisgICAgcmV0dXJuIHJldDsNCit9DQorDQoraW50IHNpc19jb21tYW5kX2Zv cl9yZWFkKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsIGludCBybGVuZ3RoLCB1bnNpZ25lZCBj aGFyICpyZGF0YSkNCit7DQorICAgIGludCByZXQgPSAtMTsNCisgICAgc3RydWN0IGkyY19tc2cg bXNnOw0KKw0KKyAgICBtc2cuYWRkciA9IGNsaWVudC0+YWRkcjsNCisgICAgLyogUmVhZCAqLw0K KyAgICBtc2cuZmxhZ3MgPSBJMkNfTV9SRDsNCisgICAgbXNnLmxlbiA9IHJsZW5ndGg7DQorICAg IG1zZy5idWYgPSByZGF0YTsNCisNCisgICAgcmV0ID0gaTJjX3RyYW5zZmVyKGNsaWVudC0+YWRh cHRlciwgJm1zZywgMSk7DQorDQorICAgIHJldHVybiByZXQ7DQorfQ0KKw0KK2ludCBzaXNfY3Vs X3VuaXQodWludDhfdCByZXBvcnRfaWQpDQorew0KKwlpbnQgcmV0ID0gTk9STUFMX0xFTl9QRVJf UE9JTlQ7DQorCQ0KKwlpZiAocmVwb3J0X2lkICE9IEFMTF9JTl9PTkVfUEFDS0FHRSkNCisJew0K KwkJaWYgKElTX0FSRUEocmVwb3J0X2lkKSAvKiYmIElTX1RPVUNIKHJlcG9ydF9pZCkqLykNCisJ CXsNCisJCQlyZXQgKz0gQVJFQV9MRU5fUEVSX1BPSU5UOw0KKwkJfQ0KKwkJaWYgKElTX1BSRVNT VVJFKHJlcG9ydF9pZCkpDQorCQl7DQorCQkJcmV0ICs9IFBSRVNTVVJFX0xFTl9QRVJfUE9JTlQ7 DQorCQl9DQorCX0NCisJDQorCXJldHVybiByZXQ7CQ0KK30NCisNCitpbnQgc2lzX1JlYWRQYWNr ZXQoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgdWludDhfdCBjbWQsIHVpbnQ4X3QqIGJ1ZikN Cit7DQorCXVpbnQ4X3QgdG1wYnVmW01BWF9CWVRFXSA9IHswfTsNCisjaWZkZWYgX0NIRUNLX0NS Qw0KKwl1aW50MTZfdCBidWZfY3JjID0gMDsNCisJdWludDE2X3QgcGFja2FnZV9jcmMgPSAwOw0K KwlpbnQgbF9wYWNrYWdlX2NyYyA9IDA7DQorCWludCBjcmNfZW5kID0gMDsNCisjZW5kaWYNCisg ICAgaW50IHJldCA9IC0xOw0KKyAgICBpbnQgdG91Y2hudW0gPSAwOw0KKyAgICBpbnQgcF9jb3Vu dCA9IDA7DQorICAgIGludCB0b3VjX2Zvcm1hdGVfaWQgPSAwOw0KKyAgICBpbnQgbG9jYXRlID0g MDsNCisgICAgYm9vbCByZWFkX2ZpcnN0ID0gdHJ1ZTsNCisgICAgDQorLyoNCisJCU5ldyBpMmMg Zm9ybWF0IA0KKwkqIGJ1ZlswXSA9IExvdyA4IGJpdHMgb2YgYnl0ZSBjb3VudCB2YWx1ZQ0KKwkq IGJ1ZlsxXSA9IEhpZ2ggOCBiaXRzIG9mIGJ5dGUgY291bnRlIHZhbHVlDQorCSogYnVmWzJdID0g UmVwb3J0IElEDQorCSogYnVmW3RvdWNoIG51bSAqIDYgKyAyIF0gPSBUb3VjaCBpbmZvcm1hdGlv bnM7IDEgdG91Y2ggcG9pbnQgaGFzIDYgYnl0ZXMsIGl0IGNvdWxkIGJlIG5vbmUgaWYgbm8gdG91 Y2ggDQorCSogYnVmW3RvdWNoIG51bSAqIDYgKyAzXSA9IFRvdWNoIG51bWJlcnMNCisJKiANCisJ KiBPbmUgdG91Y2ggcG9pbnQgaW5mb3JtYXRpb24gaW5jbHVkZSA2IGJ5dGVzLCB0aGUgb3JkZXIg aXMgDQorCSogDQorCSogMS4gc3RhdHVzID0gdG91Y2ggZG93biBvciB0b3VjaCB1cA0KKwkqIDIu IGlkID0gZmluZ2VyIGlkIA0KKwkqIDMuIHggYXhpcyBsb3cgOCBiaXRzDQorCSogNC4geCBheGlz IGhpZ2ggOCBiaXRzDQorCSogNS4geSBheGlzIGxvdyA4IGJpdHMNCisJKiA2LiB5IGF4aXMgaGln aCA4IGJpdHMNCisJKiANCisqLw0KKwlkbw0KKwl7DQorCQlpZiAobG9jYXRlID49IFBBQ0tFVF9C VUZGRVJfU0laRSkNCisJCXsNCisJCQlwcmludGsoS0VSTl9FUlIgInNpc19SZWFkUGFja2V0OiBC dWYgT3ZlcmZsb3dcbiIpOw0KKwkJCXJldHVybiAtMTsNCisJCX0NCisJCQ0KKwkJcmV0ID0gc2lz X2NvbW1hbmRfZm9yX3JlYWQoY2xpZW50LCBNQVhfQllURSwgdG1wYnVmKTsNCisNCisjaWZkZWYg X0RFQlVHX1BBQ0tBR0UNCisJCXByaW50ayhLRVJOX0lORk8gImNoYW9iYW4gdGVzdDogQnVmX0Rh dGEgWzB+NjNdIFxuIik7DQorCQlQcmludEJ1ZmZlcigwLCA2NCwgdG1wYnVmKTsJDQorI2VuZGlm CQkJDQorDQorCQlpZihyZXQgPCAwICkNCisJCXsNCisJCQlwcmludGsoS0VSTl9FUlIgInNpc19S ZWFkUGFja2V0OiBpMmMgdHJhbnNmZXIgZXJyb3JcbiIpOw0KKwkJCXJldHVybiByZXQ7DQorCQl9 DQorCQkvKiBlcnJvciBwYWNrYWdlIGxlbmd0aCBvZiByZWNlaXZpbmcgZGF0YSAqLw0KKwkJZWxz ZSBpZiAodG1wYnVmW1BfQllURUNPVU5UXSA+IE1BWF9CWVRFKQ0KKwkJew0KKwkJCXByaW50ayhL RVJOX0VSUiAic2lzX1JlYWRQYWNrZXQ6IEVycm9yIEJ5dGVjb3VudFxuIik7DQorCQkJcmV0dXJu IC0xOwkNCisJCX0NCisJCQ0KKwkJaWYgKHJlYWRfZmlyc3QpDQorCQl7DQorI2lmZGVmIF9TVVBQ T1JUX0JVVFRPTl9UT1VDSA0KKwkJCS8qIGFjY2VzcyBCVVRUT04gVE9VQ0ggZXZlbnQgYW5kIEJV VFRPTiBOTyBUT1VDSCBldmVudCAqLw0KKwkJCWlmICh0bXBidWZbUF9SRVBPUlRfSURdID09ICBC VVRUT05fRk9STUFUKQ0KKwkJCXsNCisJCQkJbWVtY3B5KCZidWZbMF0sICZ0bXBidWZbMF0sIDcp Ow0KKwkJCQlyZXR1cm4gMDsgCS8qIHRvdWNobnVtIGlzIDAgKi8NCisJCQl9DQorI2VuZGlmIA0K KwkJCS8qIGFjY2VzcyBOTyBUT1VDSCBldmVudCB1bmxlc3MgQlVUVE9OIE5PIFRPVUNIIGV2ZW50 ICovDQorCQkJaWYgKHRtcGJ1ZltQX0JZVEVDT1VOVF0gPT0gMC8qTk9fVE9VQ0hfQllURUNPVU5U Ki8pDQorCQkJew0KKwkJCQlyZXR1cm4gMDsJLyogdG91Y2hudW0gaXMgMCAqLw0KKwkJCX0NCisJ CX0NCisNCisJCS8qIHNraXAgcGFyc2luZyBkYXRhIHdoZW4gdHdvIGRldmljZXMgYXJlIHJlZ2lz dGVyZWQgYXQgdGhlIHNhbWUgc2xhdmUgYWRkcmVzcw0KKwkJICogcGFyc2luZyBkYXRhIHdoZW4g UF9SRVBPUlRfSUQgJiYgMHhmIGlzIFRPVUNIX0ZPUk1BVCBvciBQX1JFUE9SVF9JRCBpcyBBTExf SU5fT05FX1BBQ0tBR0UNCisJCSAqLyAgDQorCQl0b3VjX2Zvcm1hdGVfaWQgPSB0bXBidWZbUF9S RVBPUlRfSURdICYgMHhmOw0KKwkJaWYgKCh0b3VjX2Zvcm1hdGVfaWQgIT0gVE9VQ0hfRk9STUFU KSAmJiAodG91Y19mb3JtYXRlX2lkICE9IEhJREkyQ19GT1JNQVQpICYmICh0bXBidWZbUF9SRVBP UlRfSURdICE9IEFMTF9JTl9PTkVfUEFDS0FHRSkpDQorCQl7DQorCQkJcHJpbnRrKEtFUk5fRVJS ICJzaXNfUmVhZFBhY2tldDogRXJyb3IgUmVwb3J0X0lEXG4iKTsNCisJCQlyZXR1cm4gLTE7CQkN CisJCX0NCisJCQ0KKwkJcF9jb3VudCA9IChpbnQpIHRtcGJ1ZltQX0JZVEVDT1VOVF0gLSAxOwkv KiBzdGFydCBmcm9tIDAgKi8NCisJCWlmICh0bXBidWZbUF9SRVBPUlRfSURdICE9IEFMTF9JTl9P TkVfUEFDS0FHRSkNCisJCXsNCisJCQlpZiAoSVNfVE9VQ0godG1wYnVmW1BfUkVQT1JUX0lEXSkp DQorCQkJew0KKwkJCQlwX2NvdW50IC09IEJZVEVfQ1JDX0kyQzsJLyogZGVsZXRlIDIgYnl0ZSBj cmMgKi8NCisJCQl9DQorCQkJZWxzZSBpZiAoSVNfSElESTJDKHRtcGJ1ZltQX1JFUE9SVF9JRF0p KQ0KKwkJCXsNCisJCQkJcF9jb3VudCAtPSBCWVRFX0NSQ19ISURJMkM7DQorCQkJfQ0KKwkJCWVs c2UJLyogc2hvdWxkIG5vdCBiZSBoYXBwZW4gKi8NCisJCQl7DQorCQkJCXByaW50ayhLRVJOX0VS UiAic2lzX1JlYWRQYWNrZXQ6IGRlbGV0ZSBjcmMgZXJyb3JcbiIpOw0KKwkJCQlyZXR1cm4gLTE7 DQorCQkJfQ0KKw0KKwkJCWlmIChJU19TQ0FOVElNRSh0bXBidWZbUF9SRVBPUlRfSURdKSkNCisJ CQl7DQorCQkJCXBfY291bnQgLT0gQllURV9TQ0FOVElNRTsNCisJCQl9DQorCQl9DQorCQkvKiBl bHNlIHt9ICAgIAkJCQkJCSBGb3IgQUxMX0lOX09ORV9QQUNLQUdFICovDQorCQkNCisJCWlmIChy ZWFkX2ZpcnN0KQ0KKwkJew0KKwkJCXRvdWNobnVtID0gdG1wYnVmW3BfY291bnRdOyAJDQorCQl9 DQorCQllbHNlDQorCQl7DQorCQkJaWYgKHRtcGJ1ZltwX2NvdW50XSAhPSAwKQ0KKwkJCXsNCisJ CQkJcHJpbnRrKEtFUk5fRVJSICJzaXNfUmVhZFBhY2tldDogZ2V0IGVycm9yIHBhY2thZ2VcbiIp Ow0KKwkJCQlyZXR1cm4gLTE7DQorCQkJfQ0KKwkJfQ0KKw0KKyNpZmRlZiBfQ0hFQ0tfQ1JDDQor CQljcmNfZW5kID0gcF9jb3VudCArIChJU19TQ0FOVElNRSh0bXBidWZbUF9SRVBPUlRfSURdKSAq IDIpOw0KKwkJYnVmX2NyYyA9IGNhbF9jcmModG1wYnVmLCAyLCBjcmNfZW5kKTsgLyogc3ViIGJ5 dGVjb3VudCAoMiBieXRlKSAqLw0KKwkJbF9wYWNrYWdlX2NyYyA9IHBfY291bnQgKyAxICsgKElT X1NDQU5USU1FKHRtcGJ1ZltQX1JFUE9SVF9JRF0pICogMik7DQorCQlwYWNrYWdlX2NyYyA9IGdl dF91bmFsaWduZWRfbGUxNigmdG1wYnVmW2xfcGFja2FnZV9jcmNdKTsNCisJCQkNCisJCWlmIChi dWZfY3JjICE9IHBhY2thZ2VfY3JjKQ0KKwkJew0KKwkJCXByaW50ayhLRVJOX0VSUiAic2lzX1Jl YWRQYWNrZXQ6IENSQyBFcnJvclxuIik7DQorCQkJcmV0dXJuIC0xOw0KKwkJfQ0KKyNlbmRpZgkN CisJCW1lbWNweSgmYnVmW2xvY2F0ZV0sICZ0bXBidWZbMF0sIDY0KTsJLyogQnVmX0RhdGEgWzB+ NjNdIFs2NH4xMjhdICovDQorCQlsb2NhdGUgKz0gNjQ7DQorCQlyZWFkX2ZpcnN0ID0gZmFsc2U7 DQorCQkNCisJfXdoaWxlKHRtcGJ1ZltQX1JFUE9SVF9JRF0gIT0gQUxMX0lOX09ORV9QQUNLQUdF ICAmJiAgdG1wYnVmW3BfY291bnRdID4gNSk7DQorDQorCXJldHVybiB0b3VjaG51bTsNCit9CQ0K Kw0KKw0KK2ludCBjaGVja19ncGlvX2ludGVycnVwdCh2b2lkKQ0KK3sNCisgICAgaW50IHJldCA9 IDA7DQorDQorICAgIC8qIENIRUNLIEdQSU8gSU5URVJSVVBUIFNUQVRVUyBCWSBZT1VSIFBMQVRG T1JNIFNFVFRJTkcuICovDQorICAgIHJldCA9IGdwaW9fZ2V0X3ZhbHVlKEdQSU9fSVJRKTsNCisJ DQorICAgIHJldHVybiByZXQ7DQorfQ0KKw0KK3ZvaWQgdHNfcmVwb3J0X2tleShzdHJ1Y3QgaTJj X2NsaWVudCAqY2xpZW50LCB1aW50OF90IGtleWJpdF9zdGF0ZSkNCit7DQorCWludCBpID0gMDsN CisJdWludDhfdCBkaWZmX2tleWJpdF9zdGF0ZT0gMHgwOyAvKiBjaGVjayBrZXliaXRfc3RhdGUg aXMgZGlmZmVyZW5jZSB3aXRoIHByZV9rZXliaXRfc3RhdGUgKi8NCisJdWludDhfdCBrZXlfdmFs dWUgPSAweDA7IAkJLyogYnV0dG9uIGxvY2F0aW9uIGZvciBiaW5hcnkgKi8NCisJdWludDhfdCAg a2V5X3ByZXNzZWQgPSAweDA7IAkvKiBidXR0b24gaXMgdXAgb3IgZG93biAqLw0KKwlzdHJ1Y3Qg c2lzX3RzX2RhdGEgKnRzID0gaTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7DQorDQorCWlmICgh dHMpDQorCXsNCisJCXByaW50ayhLRVJOX0VSUiAiJXMgZXJyb3I6IE1pc3NpbmcgUGxhdGZvcm0g RGF0YSFcbiIsIF9fZnVuY19fKTsNCisJCXJldHVybjsNCisJfQ0KKw0KKwlkaWZmX2tleWJpdF9z dGF0ZSA9IFRQSW5mby0+cHJlX2tleWJpdF9zdGF0ZSBeIGtleWJpdF9zdGF0ZTsNCisNCisJaWYg KGRpZmZfa2V5Yml0X3N0YXRlKQ0KKwl7DQorCQlmb3IgKGkgPSAwOyBpIDwgQlVUVE9OX0tFWV9D T1VOVDsgaSsrKQ0KKwkJew0KKwkJICAgIGlmICgoZGlmZl9rZXliaXRfc3RhdGUgPj4gaSkgJiAw eDAxKQ0KKwkJCXsNCisJCQkJa2V5X3ZhbHVlID0gZGlmZl9rZXliaXRfc3RhdGUgJiAoMHgwMSA8 PCBpKTsNCisJCQkJa2V5X3ByZXNzZWQgPSAoa2V5Yml0X3N0YXRlID4+IGkpICYgMHgwMTsNCisJ CQkJc3dpdGNoIChrZXlfdmFsdWUpDQorCQkJCXsNCisJCQkJCWNhc2UgTVNLX0NPTVA6DQorCQkJ CQkJaW5wdXRfcmVwb3J0X2tleSh0cy0+aW5wdXRfZGV2LCBLRVlfQ09NUE9TRSwga2V5X3ByZXNz ZWQpOw0KKwkJCQkJCWJyZWFrOw0KKwkJCQkJY2FzZSBNU0tfQkFDSzoNCisJCQkJCQlpbnB1dF9y ZXBvcnRfa2V5KHRzLT5pbnB1dF9kZXYsIEtFWV9CQUNLLCBrZXlfcHJlc3NlZCk7DQorCQkJCQkJ YnJlYWs7DQorCQkJCQljYXNlIE1TS19NRU5VOg0KKwkJCQkJCWlucHV0X3JlcG9ydF9rZXkodHMt PmlucHV0X2RldiwgS0VZX01FTlUsIGtleV9wcmVzc2VkKTsNCisJCQkJCQlicmVhazsNCisJCQkJ CWNhc2UgTVNLX0hPTUU6DQorCQkJCQkJaW5wdXRfcmVwb3J0X2tleSh0cy0+aW5wdXRfZGV2LCBL RVlfSE9NRSwga2V5X3ByZXNzZWQpOw0KKwkJCQkJCWJyZWFrOw0KKwkJCQkJY2FzZSBNU0tfTk9C VE46DQorCQkJCQkJLyogUmVsZWFzZSB0aGUgYnV0dG9uIGlmIGl0IHRvdWNoZWQuICovDQorCQkJ CQlkZWZhdWx0Og0KKwkJCQkJCWJyZWFrOw0KKwkJCQl9DQorCQkJfQ0KKwkJfQ0KKwkJVFBJbmZv LT5wcmVfa2V5Yml0X3N0YXRlID0ga2V5Yml0X3N0YXRlOw0KKwl9DQorfQ0KKw0KKw0KK3N0YXRp YyB2b2lkIHNpc190c193b3JrX2Z1bmMoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQ0KK3sNCisJ c3RydWN0IHNpc190c19kYXRhICp0cyA9IGNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3Qgc2lzX3Rz X2RhdGEsIHdvcmspOw0KKyAgICBpbnQgcmV0ID0gLTE7DQorICAgIGludCBwb2ludF91bml0OyAg DQorCXVpbnQ4X3QgYnVmW1BBQ0tFVF9CVUZGRVJfU0laRV0gPSB7MH07DQorCXVpbnQ4X3QgaSA9 IDAsIGZpbmdlcnMgPSAwOw0KKwl1aW50OF90IHB4ID0gMCwgcHkgPSAwLCBwc3RhdHVzID0gMDsN CisJdWludDhfdCBwX2FyZWEgPSAwOw0KKyAgICB1aW50OF90IHBfcHJlYXN1cmUgPSAwOw0KKyNp ZmRlZiBfU1VQUE9SVF9CVVRUT05fVE9VQ0gJDQorCWludCBidXR0b25fa2V5Ow0KKwl1aW50OF90 IGJ1dHRvbl9idWZbMTBdID0gezB9Ow0KKyNlbmRpZg0KKw0KKyNpZmRlZiBfQU5EUk9JRF80DQor CWJvb2wgYWxsX3RvdWNoX3VwID0gdHJ1ZTsNCisjZW5kaWYNCisJDQorCW11dGV4X2xvY2soJnRz LT5tdXRleF93cSk7IA0KKw0KKyAgICAvKiBJMkMgb3IgU01CVVMgYmxvY2sgZGF0YSByZWFkICov DQorICAgIHJldCA9IHNpc19SZWFkUGFja2V0KHRzLT5jbGllbnQsIFNJU19DTURfTk9STUFMLCBi dWYpOw0KKyANCisjaWZkZWYgX1NVUFBPUlRfQlVUVE9OX1RPVUNIDQorCSBzaXNfUmVhZFBhY2tl dCh0cy0+Y2xpZW50LCBTSVNfQ01EX05PUk1BTCwgYnV0dG9uX2J1Zik7DQorI2VuZGlmDQorDQor CS8qIEVycm9yIE51bWJlciAqLw0KKwlpZiAocmV0IDwgMCkgDQorCXsNCisJCWdvdG8gZXJyX2Zy ZWVfYWxsb2NhdGU7DQorCX0NCisjaWZkZWYgX1NVUFBPUlRfQlVUVE9OX1RPVUNIDQorCS8qIGFj Y2VzcyBCVVRUT04gVE9VQ0ggZXZlbnQgYW5kIEJVVFRPTiBOTyBUT1VDSCBldmVuICovDQorCWVs c2UgaWYgKGJ1dHRvbl9idWZbUF9SRVBPUlRfSURdID09IEJVVFRPTl9GT1JNQVQpDQorCXsNCisJ CWJ1dHRvbl9rZXkgPSBnZXRfdW5hbGlnbmVkX2xlMTYoJmJ1dHRvbl9idWZbQlVUVE9OX1NUQVRF XSk7CQkNCisJCXRzX3JlcG9ydF9rZXkodHMtPmNsaWVudCwgYnV0dG9uX2tleSk7DQorCX0NCisj ZW5kaWYNCisJLyogYWNjZXNzIE5PIFRPVUNIIGV2ZW50IHVubGVzcyBCVVRUT04gTk8gVE9VQ0gg ZXZlbnQgKi8NCisJZWxzZSBpZiAocmV0ID09IDApDQorCXsNCisJCWZpbmdlcnMgPSAwOw0KKwkJ c2lzX3RwaW5mb19jbGVhcihUUEluZm8sIE1BWF9GSU5HRVJTKTsNCisJCWdvdG8gbGFiZWxfc2Vu ZF9yZXBvcnQ7ICAvKiBuZWVkIHRvIHJlcG9ydCBpbnB1dF9tdF9zeW5jKCkgKi8NCisJfQ0KKwkN CisJc2lzX3RwaW5mb19jbGVhcihUUEluZm8sIE1BWF9GSU5HRVJTKTsNCisJDQorCS8qIFBhcnNl ciBhbmQgR2V0IHRoZSBzaXM5MjAwIGRhdGEgKi8NCisJcG9pbnRfdW5pdCA9IHNpc19jdWxfdW5p dChidWZbUF9SRVBPUlRfSURdKTsNCisJZmluZ2VycyA9IHJldDsNCisJDQorCVRQSW5mby0+Zmlu Z2VycyA9IGZpbmdlcnMgPSAoZmluZ2VycyA+IE1BWF9GSU5HRVJTID8gMCA6IGZpbmdlcnMpOw0K KwkNCisJLyogZmluZ2VycyAxMCA9ICAwIH4gOSAqLw0KKwlmb3IgKGkgPSAwOyBpIDwgZmluZ2Vy czsgaSsrKSANCisJew0KKyAgICAgICAgaWYgKChidWZbUF9SRVBPUlRfSURdICE9IEFMTF9JTl9P TkVfUEFDS0FHRSkgJiYgKGkgPj0gNSkpDQorICAgICAgICB7IC8qIENhbGMgcG9pbnQgc3RhdHVz ICovDQorCQkJcHN0YXR1cyA9IEJZVEVfQllURUNPVU5UICsgQllURV9SZXBvcnRJRCArICgoaSAt IDUpICogcG9pbnRfdW5pdCk7ICAgIAkNCisJCQlwc3RhdHVzICs9IDY0Ow0KKwkJfQ0KKwkJZWxz ZSANCisJCXsgLyogQ2FsYyBwb2ludCBzdGF0dXMgKi8NCisJCQlwc3RhdHVzID0gQllURV9CWVRF Q09VTlQgKyBCWVRFX1JlcG9ydElEICsgKGkgKiBwb2ludF91bml0KTsgICAgICAgICAgCQ0KKwkJ fQ0KKw0KKwkgICAgcHggPSBwc3RhdHVzICsgMjsJLyogQ2FsYyBwb2ludCB4X2Nvb3JkICovDQor CSAgICBweSA9IHB4ICsgMjsJCS8qIENhbGMgcG9pbnQgeV9jb29yZCAqLw0KKw0KKwkJaWYgKChi dWZbcHN0YXR1c10pID09IFRPVUNIVVApDQorCQl7DQorCQkJVFBJbmZvLT5wdFtpXS5XaWR0aCA9 IDA7DQorCQkJVFBJbmZvLT5wdFtpXS5IZWlnaHQgPSAwOw0KKwkJCVRQSW5mby0+cHRbaV0uUHJl c3N1cmUgPSAwOw0KKwkJfQ0KKwkJZWxzZSBpZiAoYnVmW1BfUkVQT1JUX0lEXSA9PSBBTExfSU5f T05FX1BBQ0tBR0UgJiYgKGJ1Zltwc3RhdHVzXSkgPT0gVE9VQ0hET1dOKQ0KKwkJew0KKwkJCVRQ SW5mby0+cHRbaV0uV2lkdGggPSAxOw0KKwkJCVRQSW5mby0+cHRbaV0uSGVpZ2h0ID0gMTsNCisJ CQlUUEluZm8tPnB0W2ldLlByZXNzdXJlID0gMTsJCQkNCisJCX0NCisJCWVsc2UgaWYgKChidWZb cHN0YXR1c10pID09IFRPVUNIRE9XTikNCisJCXsJDQorCQkJcF9hcmVhID0gcHkgKyAyOw0KKwkJ CXBfcHJlYXN1cmUgPSBweSArIDIgKyAoSVNfQVJFQShidWZbUF9SRVBPUlRfSURdKSAqIDIpOw0K Kw0KKwkJCS8qIGFyZWEgKi8NCisJCQlpZiAoSVNfQVJFQShidWZbUF9SRVBPUlRfSURdKSkNCisJ CQl7DQorCQkJCVRQSW5mby0+cHRbaV0uV2lkdGggPSBidWZbcF9hcmVhXSAmIDB4ZmY7DQorCQkJ CVRQSW5mby0+cHRbaV0uSGVpZ2h0ID0gYnVmW3BfYXJlYSArIDFdICYgMHhmZjsNCisJCQl9DQor CQkJZWxzZSANCisJCQl7DQorCQkJCVRQSW5mby0+cHRbaV0uV2lkdGggPSAxOw0KKwkJCQlUUElu Zm8tPnB0W2ldLkhlaWdodCA9IDE7DQorCQkJfQ0KKwkJCS8qIHByZWFzdXJlICovDQorCQkJaWYg KElTX1BSRVNTVVJFKGJ1ZltQX1JFUE9SVF9JRF0pKQ0KKwkJCQlUUEluZm8tPnB0W2ldLlByZXNz dXJlID0gKGJ1ZltwX3ByZWFzdXJlXSk7DQorCQkJZWxzZSANCisJCQkJVFBJbmZvLT5wdFtpXS5Q cmVzc3VyZSA9IDE7CQkJCQ0KKwkJfQ0KKwkJZWxzZQ0KKwkJew0KKwkJCXByaW50ayhLRVJOX0VS UiAic2lzX3RzX3dvcmtfZnVuYzogRXJyb3IgVG91Y2ggU3RhdHVzXG4iKTsNCisJCQlnb3RvIGVy cl9mcmVlX2FsbG9jYXRlOw0KKwkJfQ0KKwkJDQorCQlUUEluZm8tPnB0W2ldLmlkID0gKGJ1Zltw c3RhdHVzICsgMV0pOw0KKwkJVFBJbmZvLT5wdFtpXS54ID0gKChidWZbcHhdICYgMHhmZikgfCAo KGJ1ZltweCArIDFdICYgMHhmZik8PCA4KSk7DQorICAgICAgICBUUEluZm8tPnB0W2ldLnkgPSAo KGJ1ZltweV0gJiAweGZmKSB8ICgoYnVmW3B5ICsgMV0gJiAweGZmKTw8IDgpKTsgICAgICANCisJ fQ0KKwkJDQorI2lmZGVmIF9ERUJVR19SRVBPUlQNCisJZm9yIChpID0gMDsgaSA8IFRQSW5mby0+ ZmluZ2VyczsgaSsrKQ0KKwl7DQorCQkgcHJpbnRrKEtFUk5fSU5GTyAiY2hhb2JhbiB0ZXN0OiBp ID0gJWQsIGlkID0gJWQsIHggPSAlZCwgeSA9ICVkLCBwc3RhdHVzID0gJWQsIHdpZHRoID0gJWQs IGhlaWdodCA9ICVkLCBwcmVzc3VyZSA9ICVkLCBcbiIsIGksIFRQSW5mby0+cHRbaV0uaWQsIFRQ SW5mby0+cHRbaV0ueCwgVFBJbmZvLT5wdFtpXS55LCBidWZbcHN0YXR1c10sIFRQSW5mby0+cHRb aV0uV2lkdGgsICBUUEluZm8tPnB0W2ldLkhlaWdodCwgVFBJbmZvLT5wdFtpXS5QcmVzc3VyZSk7 DQorCX0NCisjZW5kaWYNCisNCitsYWJlbF9zZW5kX3JlcG9ydDoNCisvKiBSZXBvcnQgY28tb3Jk aW5hdGVzIHRvIHRoZSBtdWx0aS10b3VjaCBzdGFjayAqLw0KKyNpZmRlZiBfQU5EUk9JRF80CQ0K Kwlmb3IoaSA9IDA7ICgoaSA8IFRQSW5mby0+ZmluZ2VycykgJiYgKGkgPCBNQVhfRklOR0VSUykp OyBpKyspDQorCXsNCisJCWlmKFRQSW5mby0+cHRbaV0uUHJlc3N1cmUpDQorCQl7DQorCQkJVFBJ bmZvLT5wdFtpXS5XaWR0aCAqPSBBUkVBX1VOSVQ7CQ0KKwkJCWlucHV0X3JlcG9ydF9hYnModHMt PmlucHV0X2RldiwgQUJTX01UX1RPVUNIX01BSk9SLCBUUEluZm8tPnB0W2ldLldpZHRoKTsNCisJ CQlUUEluZm8tPnB0W2ldLkhlaWdodCAqPSBBUkVBX1VOSVQ7DQorCQkJaW5wdXRfcmVwb3J0X2Fi cyh0cy0+aW5wdXRfZGV2LCBBQlNfTVRfVE9VQ0hfTUlOT1IsIFRQSW5mby0+cHRbaV0uSGVpZ2h0 KTsJCQkNCisJCQlpbnB1dF9yZXBvcnRfYWJzKHRzLT5pbnB1dF9kZXYsIEFCU19NVF9QUkVTU1VS RSwgVFBJbmZvLT5wdFtpXS5QcmVzc3VyZSk7DQorCQkJaW5wdXRfcmVwb3J0X2Ficyh0cy0+aW5w dXRfZGV2LCBBQlNfTVRfUE9TSVRJT05fWCwgVFBJbmZvLT5wdFtpXS54KTsNCisJCQlpbnB1dF9y ZXBvcnRfYWJzKHRzLT5pbnB1dF9kZXYsIEFCU19NVF9QT1NJVElPTl9ZLCBUUEluZm8tPnB0W2ld LnkpOw0KKwkJCWlucHV0X3JlcG9ydF9hYnModHMtPmlucHV0X2RldiwgQUJTX01UX1RSQUNLSU5H X0lELCBUUEluZm8tPnB0W2ldLmlkKTsNCisJCQlpbnB1dF9tdF9zeW5jKHRzLT5pbnB1dF9kZXYp Ow0KKwkJCWFsbF90b3VjaF91cCA9IGZhbHNlOw0KKwkJfQ0KKwkJDQorCQlpZiAoaSA9PSAoVFBJ bmZvLT5maW5nZXJzIC0xKSAmJiBhbGxfdG91Y2hfdXAgPT0gdHJ1ZSkNCisJCXsNCisJCQlpbnB1 dF9tdF9zeW5jKHRzLT5pbnB1dF9kZXYpOw0KKwkJfQ0KKwl9DQorDQorCWlmKFRQSW5mby0+Zmlu Z2VycyA9PSAwKQ0KKwl7DQorCQlpbnB1dF9tdF9zeW5jKHRzLT5pbnB1dF9kZXYpOw0KKwl9DQor I2Vsc2UNCisJaSA9IDA7DQorCWRvDQorCXsNCisJCWlucHV0X3JlcG9ydF9hYnModHMtPmlucHV0 X2RldiwgQUJTX01UX1RPVUNIX01BSk9SLCBUUEluZm8tPnB0W2ldLlByZXNzdXJlKTsNCisJCWlu cHV0X3JlcG9ydF9hYnModHMtPmlucHV0X2RldiwgQUJTX01UX1dJRFRIX01BSk9SLCBUUEluZm8t PnB0W2ldLldpZHRoKTsNCisJCWlucHV0X3JlcG9ydF9hYnModHMtPmlucHV0X2RldiwgQUJTX01U X1dJRFRIX01JTk9SLCBUUEluZm8tPnB0W2ldLkhlaWdodCk7DQorCQlpbnB1dF9yZXBvcnRfYWJz KHRzLT5pbnB1dF9kZXYsIEFCU19NVF9QT1NJVElPTl9YLCBUUEluZm8tPnB0W2ldLngpOw0KKwkJ aW5wdXRfcmVwb3J0X2Ficyh0cy0+aW5wdXRfZGV2LCBBQlNfTVRfUE9TSVRJT05fWSwgVFBJbmZv LT5wdFtpXS55KTsNCisJCWlucHV0X3JlcG9ydF9hYnModHMtPmlucHV0X2RldiwgQUJTX01UX1RS QUNLSU5HX0lELCBUUEluZm8tPnB0W2ldLmlkKTsgLyogQW5kcm9pZCAyLjMgKi8NCisJCWlucHV0 X210X3N5bmModHMtPmlucHV0X2Rldik7DQorCQlpKys7DQorCX0NCisJd2hpbGUgKChpIDwgVFBJ bmZvLT5maW5nZXJzKSAmJiAoaSA8IE1BWF9GSU5HRVJTKSk7DQorI2VuZGlmDQorCWlucHV0X3N5 bmModHMtPmlucHV0X2Rldik7DQorDQorZXJyX2ZyZWVfYWxsb2NhdGU6DQorDQorICAgIGlmICh0 cy0+dXNlX2lycSkNCisgICAgew0KKy8qIGNhc2UgMSBtb2RlICovDQorI2lmZGVmIF9JTlRfTU9E RV8xIA0KKwkgICAgLypUT0RPOiBBZnRlciBpbnRlcnJ1cHQgc3RhdHVzIGxvdywgcmVhZCBpMmMg YnVzIGRhdGEgYnkgcG9sbGluZywgdW50aWwgaW50ZXJydXB0IHN0YXR1cyBpcyBoaWdoICovDQor CSAgICByZXQgPSBjaGVja19ncGlvX2ludGVycnVwdCgpOwkvKiBpbnRlcnJ1cHQgcGluIGlzIHN0 aWxsIExPVywgcmVhZCBkYXRhIHVudGlsIGludGVycnVwdCBwaW4gaXMgcmVsZWFzZWQuICovDQor CSAgICBpZiAoIXJldCkNCisJICAgIHsNCisJICAgICAgICBocnRpbWVyX3N0YXJ0KCZ0cy0+dGlt ZXIsIGt0aW1lX3NldCgwLCBUSU1FUl9OUyksIEhSVElNRVJfTU9ERV9SRUwpOw0KKwkgICAgfQ0K KwkgICAgZWxzZQ0KKwkgICAgew0KKwkJCWlmIChUUEluZm8tPnByZV9rZXliaXRfc3RhdGUpDQor CQkJew0KKwkJCQl0c19yZXBvcnRfa2V5KHRzLT5jbGllbnQsIDB4MCk7CS8qIGNsZWFyIGZvciBp bnRlcnJ1cHQgKi8NCisJCQl9DQorCQkJDQorI2lmICggTElOVVhfVkVSU0lPTl9DT0RFIDwgS0VS TkVMX1ZFUlNJT04gKDIsIDYsIDM5KSApDQorICAgICAgICAJaWYgKCh0cy0+ZGVzYy0+c3RhdHVz ICYgSVJRX0RJU0FCTEVEKSA9PSBJUlFfU1RBVFVTX0RJU0FCTEVEKQ0KKyNlbHNlDQorICAgICAg ICAJaWYgKCh0cy0+ZGVzYy0+aXJxX2RhdGEuc3RhdGVfdXNlX2FjY2Vzc29ycyAmIElSUURfSVJR X0RJU0FCTEVEKSA9PSBJUlFfU1RBVFVTX0RJU0FCTEVEKQ0KKyNlbmRpZg0KKyAgICAgICAgCXsN CisJCQkJZW5hYmxlX2lycSh0cy0+Y2xpZW50LT5pcnEpOw0KKwkJCX0NCisJICAgIH0NCisvKiBj YXNlIDIgbW9kZSAqLw0KKyNlbHNlDQorDQorI2lmICggTElOVVhfVkVSU0lPTl9DT0RFIDwgS0VS TkVMX1ZFUlNJT04gKDIsIDYsIDM5KSApDQorCQlpZiAoKHRzLT5kZXNjLT5zdGF0dXMgJiBJUlFf RElTQUJMRUQpID09IElSUV9TVEFUVVNfRElTQUJMRUQpDQorI2Vsc2UNCisJCWlmICgodHMtPmRl c2MtPmlycV9kYXRhLnN0YXRlX3VzZV9hY2Nlc3NvcnMgJiBJUlFEX0lSUV9ESVNBQkxFRCkgPT0g SVJRX1NUQVRVU19ESVNBQkxFRCkNCisjZW5kaWYNCisJCXsNCisJCQllbmFibGVfaXJxKHRzLT5j bGllbnQtPmlycSk7DQorCQl9DQorI2VuZGlmDQorCX0NCisNCisJbXV0ZXhfdW5sb2NrKCZ0cy0+ bXV0ZXhfd3EpOw0KKyAgICByZXR1cm47DQorfQ0KKw0KK3N0YXRpYyB2b2lkIHNpc190cGluZm9f Y2xlYXIoc3RydWN0IHNpc1RQX2RyaXZlcl9kYXRhICpUUEluZm8sIGludCBtYXgpDQorew0KKwlp bnQgaSA9IDA7DQorCWZvcihpID0gMDsgaSA8IG1heDsgaSsrKQ0KKwl7DQorCQlUUEluZm8tPnB0 W2ldLmlkID0gLTE7DQorCQlUUEluZm8tPnB0W2ldLnggPSAwOw0KKwkJVFBJbmZvLT5wdFtpXS55 ID0gMDsNCisJCVRQSW5mby0+cHRbaV0uUHJlc3N1cmUgPSAwOw0KKwkJVFBJbmZvLT5wdFtpXS5X aWR0aCA9IDA7DQorCX0NCisJVFBJbmZvLT5pZCA9IDB4MDsNCisJVFBJbmZvLT5maW5nZXJzID0g MDsNCit9DQorDQorc3RhdGljIGVudW0gaHJ0aW1lcl9yZXN0YXJ0IHNpc190c190aW1lcl9mdW5j KHN0cnVjdCBocnRpbWVyICp0aW1lcikNCit7DQorCXN0cnVjdCBzaXNfdHNfZGF0YSAqdHMgPSBj b250YWluZXJfb2YodGltZXIsIHN0cnVjdCBzaXNfdHNfZGF0YSwgdGltZXIpOw0KKwlxdWV1ZV93 b3JrKHNpc193cSwgJnRzLT53b3JrKTsNCisJaWYgKCF0cy0+dXNlX2lycSkNCisJewkvKiBGb3Ig UG9sbGluZyBtb2RlICovDQorCSAgICBocnRpbWVyX3N0YXJ0KCZ0cy0+dGltZXIsIGt0aW1lX3Nl dCgwLCBUSU1FUl9OUyksIEhSVElNRVJfTU9ERV9SRUwpOw0KKwl9DQorCXJldHVybiBIUlRJTUVS X05PUkVTVEFSVDsNCit9DQorDQorc3RhdGljIGlycXJldHVybl90IHNpc190c19pcnFfaGFuZGxl cihpbnQgaXJxLCB2b2lkICpkZXZfaWQpDQorew0KKwlzdHJ1Y3Qgc2lzX3RzX2RhdGEgKnRzID0g ZGV2X2lkOw0KKwkNCisjaWYgKCBMSU5VWF9WRVJTSU9OX0NPREUgPCBLRVJORUxfVkVSU0lPTiAo MiwgNiwgMzkpICkNCisJaWYgKCh0cy0+ZGVzYy0+c3RhdHVzICYgSVJRX0RJU0FCTEVEKSA9PSBJ UlFfU1RBVFVTX0VOQUJMRUQpDQorI2Vsc2UNCisJaWYgKCh0cy0+ZGVzYy0+aXJxX2RhdGEuc3Rh dGVfdXNlX2FjY2Vzc29ycyAmIElSUURfSVJRX0RJU0FCTEVEKSA9PSBJUlFfU1RBVFVTX0VOQUJM RUQpDQorI2VuZGlmDQorCXsNCisJCWRpc2FibGVfaXJxX25vc3luYyh0cy0+Y2xpZW50LT5pcnEp Ow0KKwl9DQorCXF1ZXVlX3dvcmsoc2lzX3dxLCAmdHMtPndvcmspOw0KKwkJDQorCXJldHVybiBJ UlFfSEFORExFRDsNCit9DQorDQorc3RhdGljIGludCBpbml0aWFsX2lycSh2b2lkKQ0KK3sNCisJ aW50IHJldCA9IDA7DQorI2lmZGVmIF9JMkNfSU5UX0VOQUJMRQ0KKwkvKiBpbml0aWFsaXplIGdw aW8gYW5kIGludGVycnVwdCBwaW5zICovDQorCXJldCA9IGdwaW9fcmVxdWVzdChHUElPX0lSUSwg IkdQSU9fMTMzIik7CS8qIGV4LiBHUElPXzEzMyBmb3IgaW50ZXJydXB0IG1vZGUgKi8NCisJaWYg KHJldCA8IDApDQorCXsNCisJCS8qIFNldCBBY3RpdmUgTG93LiBQbGVhc2UgcmVmZXJlbmNlIHRo ZSBmaWxlIGluY2x1ZGUvbGludXgvaW50ZXJydXB0LmggKi8NCisJfQ0KKwkvKiBzZXR0aW5nIGdw aW8gZGlyZWN0aW9uIGhlcmUgT1IgYm9hcmRpbmZvIGZpbGUqLw0KKw0KKyNlbHNlDQorCXJldCA9 IC0xOw0KKyNlbmRpZg0KKwlyZXR1cm4gcmV0Ow0KK30NCisNCit1aW50MTZfdCBjYWxfY3JjIChj aGFyKiBjbWQsIGludCBzdGFydCwgaW50IGVuZCkNCit7DQorCWludCBpID0gMDsNCisJdWludDE2 X3QgY3JjID0gMDsNCisJDQorCWZvciAoaSA9IHN0YXJ0OyBpIDw9IGVuZCA7IGkrKykNCisJew0K KwkJY3JjID0gKGNyYzw8OCkgXiBjcmMxNnRhYlsoKGNyYz4+OCkgXiBjbWRbaV0gKSYweDAwRkZd Ow0KKwl9DQorCQ0KKwlyZXR1cm4gY3JjOw0KK30NCisNCit1aW50MTZfdCBjYWxfY3JjX3dpdGhf Y21kIChjaGFyKiBkYXRhLCBpbnQgc3RhcnQsIGludCBlbmQsIHVpbnQ4X3QgY21kKQ0KK3sNCisJ aW50IGkgPSAwOw0KKwl1aW50MTZfdCBjcmMgPSAwOw0KKwkNCisJY3JjID0gKGNyYzw8OCkgXiBj cmMxNnRhYlsoKGNyYz4+OCkgXiBjbWQpJjB4MDBGRl07DQorCWZvciAoaSA9IHN0YXJ0OyBpIDw9 IGVuZCA7IGkrKykNCisJew0KKwkJY3JjID0gKGNyYzw8OCkgXiBjcmMxNnRhYlsoKGNyYz4+OCkg XiBkYXRhW2ldICkmMHgwMEZGXTsNCisJfQ0KKwkNCisJcmV0dXJuIGNyYzsNCit9DQorDQordm9p ZCB3cml0ZV9jcmMgKHVuc2lnbmVkIGNoYXIgKmJ1ZiwgaW50IHN0YXJ0LCBpbnQgZW5kKQ0KK3sN CisJdWludDE2X3QgY3JjID0gMDsNCisJDQorCWNyYyA9IGNhbF9jcmMgKGJ1Ziwgc3RhcnQgLCBl bmQpOw0KKwlidWZbZW5kKzFdID0gKGNyYyA+PiA4KSYgMHhmZjsNCisJYnVmW2VuZCsyXSA9IGNy YyAmIDB4ZmY7DQorfQ0KKw0KKyNpZmRlZiBfU1REX1JXX0lPDQorI2RlZmluZSBCVUZGRVJfU0la RSBNQVhfQllURQ0KK3N0YXRpYyBzc2l6ZV90IHNpc19jZGV2X3dyaXRlKCBzdHJ1Y3QgZmlsZSAq ZmlsZSwgY29uc3QgY2hhciBfX3VzZXIgKmJ1Ziwgc2l6ZV90IGNvdW50LCBsb2ZmX3QgKmZfcG9z ICkNCit7DQorCSBpbnQgcmV0ID0gMDsNCisJIGNoYXIgKmtkYXRhOw0KKwkgY2hhciBjbWQ7DQor CSANCisJIHByaW50ayhLRVJOX0lORk8gInNpc19jZGV2X3dyaXRlLlxuIik7DQorCSANCisJIGlm ICh0c19iYWsgPT0gMCkNCisgICAgCXJldHVybiAtMTM7DQorICAgIAkNCisgICAgcmV0ID0gYWNj ZXNzX29rKFZFUklGWV9XUklURSwgYnVmLCBCVUZGRVJfU0laRSk7DQorICAgIGlmICghcmV0KSB7 DQorICAgICAgICBwcmludGsoS0VSTl9FUlIgImNhbm5vdCBhY2Nlc3MgdXNlciBzcGFjZSBtZW1v cnlcbiIpOw0KKyAgICAgICAgcmV0dXJuIC0xMTsNCisgICAgfQ0KKw0KKwkga2RhdGEgPSBrbWFs bG9jKEJVRkZFUl9TSVpFLCBHRlBfS0VSTkVMKTsNCisgICAgIGlmIChrZGF0YSA9PSAwKQ0KKyAg ICAJcmV0dXJuIC0xMjsNCisgICAgCQ0KKyAgICAgcmV0ID0gY29weV9mcm9tX3VzZXIoa2RhdGEs IGJ1ZiwgQlVGRkVSX1NJWkUpOw0KKyAgICAgaWYgKHJldCkgew0KKyAgICAgICAgcHJpbnRrKEtF Uk5fRVJSICJjb3B5X2Zyb21fdXNlciBmYWlsXG4iKTsNCisgICAgICAgIGtmcmVlKGtkYXRhKTsN CisgICAgICAgIHJldHVybiAtMTQ7DQorICAgICB9IA0KKyNpZiAwDQorCVByaW50QnVmZmVyKDAs IGNvdW50LCBrZGF0YSk7DQorI2VuZGlmDQorCQkNCisJY21kID0ga2RhdGFbNl07DQorDQorLyog V3JpdGUgJiBSZWFkICovDQorICAgIHJldCA9IHNpc19jb21tYW5kX2Zvcl93cml0ZSh0c19iYWst PmNsaWVudCwgY291bnQsIGtkYXRhKTsNCisgICAgaWYgKHJldCA8IDApIHsNCisgICAgICAgIHBy aW50ayhLRVJOX0VSUiAiaTJjX3RyYW5zZmVyIHdyaXRlIGVycm9yICVkXG4iLCByZXQpOw0KKwkJ a2ZyZWUoa2RhdGEpOw0KKwkJcmV0dXJuIC0yMTsNCisJfQ0KKw0KKyAgICBpZiAoIGNvcHlfdG9f dXNlcigoY2hhciopIGJ1Ziwga2RhdGEsIEJVRkZFUl9TSVpFICkgKQ0KKyAgICB7DQorICAgICAg ICBwcmludGsoS0VSTl9FUlIgImNvcHlfdG9fdXNlciBmYWlsXG4iICk7DQorICAgICAgICByZXQg PSAtMTk7DQorICAgIH0NCisNCisgICAga2ZyZWUoIGtkYXRhICk7DQorDQorCXJldHVybiByZXQ7 DQorfQ0KKw0KKy8qIGZvciBnZXQgc3lzdGVtIHRpbWUgKi8NCitzdGF0aWMgc3NpemVfdCBzaXNf Y2Rldl9yZWFkKCBzdHJ1Y3QgZmlsZSAqZmlsZSwgY2hhciBfX3VzZXIgKmJ1Ziwgc2l6ZV90IGNv dW50LCBsb2ZmX3QgKmZfcG9zICkNCit7DQorCSBpbnQgcmV0ID0gMDsNCisJIGNoYXIgKmtkYXRh Ow0KKwkgY2hhciBjbWQ7DQorCSBpbnQgaTsNCisJIA0KKwkgcHJpbnRrKEtFUk5fSU5GTyAic2lz X2NkZXZfcmVhZC5cbiIpOw0KKwkgDQorCSBpZiAodHNfYmFrID09IDApDQorICAgIAlyZXR1cm4g LTEzOw0KKyAgICAJDQorICAgIHJldCA9IGFjY2Vzc19vayhWRVJJRllfV1JJVEUsIGJ1ZiwgQlVG RkVSX1NJWkUpOw0KKyAgICBpZiAoIXJldCkgew0KKyAgICAgICAgcHJpbnRrKEtFUk5fRVJSICJj YW5ub3QgYWNjZXNzIHVzZXIgc3BhY2UgbWVtb3J5XG4iKTsNCisgICAgICAgIHJldHVybiAtMTE7 DQorICAgIH0NCisNCisJIGtkYXRhID0ga21hbGxvYyhCVUZGRVJfU0laRSwgR0ZQX0tFUk5FTCk7 DQorICAgICBpZiAoa2RhdGEgPT0gMCkNCisgICAgCXJldHVybiAtMTI7DQorICAgIAkNCisgICAg IHJldCA9IGNvcHlfZnJvbV91c2VyKGtkYXRhLCBidWYsIEJVRkZFUl9TSVpFKTsNCisgICAgIGlm IChyZXQpIHsNCisgICAgICAgIHByaW50ayhLRVJOX0VSUiAiY29weV9mcm9tX3VzZXIgZmFpbFxu Iik7DQorICAgICAgICBrZnJlZShrZGF0YSk7DQorICAgICAgICByZXR1cm4gLTE0Ow0KKyAgICAg fSAgICANCisjaWYgMA0KKyAgICBQcmludEJ1ZmZlcigwLCBjb3VudCwga2RhdGEpOw0KKyNlbmRp Zg0KKwkgY21kID0ga2RhdGFbNl07DQorCSAvKiBmb3IgbWFraW5nIHN1cmUgQVAgY29tbXVuaWNh dGVzIHdpdGggU2lTIGRyaXZlciAqLw0KKyAgICBpZihjbWQgPT0gMHhhMikNCisgICAgew0KKwkJ a2RhdGFbMF0gPSA1Ow0KKwkJa2RhdGFbMV0gPSAwOw0KKwkJa2RhdGFbM10gPSAnUyc7DQorCQlr ZGF0YVs0XSA9ICdpJzsNCisJCWtkYXRhWzVdID0gJ1MnOw0KKwkJaWYgKCBjb3B5X3RvX3VzZXIo KGNoYXIqKSBidWYsIGtkYXRhLCBCVUZGRVJfU0laRSApICkNCisJCXsNCisJCQlwcmludGsoS0VS Tl9FUlIgImNvcHlfdG9fdXNlciBmYWlsXG4iICk7DQorCQkJa2ZyZWUoIGtkYXRhICk7DQorCQkJ cmV0dXJuIC0xOTsNCisJCX0NCisNCisJCWtmcmVlKCBrZGF0YSApOw0KKwkJcmV0dXJuIDM7CQ0K Kwl9DQorLyogV3JpdGUgJiBSZWFkICovDQorICAgIHJldCA9IHNpc19jb21tYW5kX2Zvcl9yZWFk KHRzX2Jhay0+Y2xpZW50LCBNQVhfQllURSwga2RhdGEpOw0KKyAgICBpZiAocmV0IDwgMCkgew0K KyAgICAgICAgcHJpbnRrKEtFUk5fRVJSICJpMmNfdHJhbnNmZXIgcmVhZCBlcnJvciAlZFxuIiwg cmV0KTsNCisJCWtmcmVlKGtkYXRhKTsNCisJCXJldHVybiAtMjE7DQorCX0NCisNCisJcmV0ID0g a2RhdGFbMF0gfCAoa2RhdGFbMV0gPDwgOCk7DQorDQorICAgIHByaW50ayhLRVJOX0lORk8gIiVk XG4iLCByZXQpOw0KKw0KKyAgICBmb3IgKCBpID0gMDsgaSA8IHJldCAmJiBpIDwgQlVGRkVSX1NJ WkU7IGkrKyApDQorICAgIHsNCisgICAgICAgIHByaW50aygiJTAyeCAiLCBrZGF0YVtpXSk7DQor ICAgIH0NCisNCisgICAgcHJpbnRrKCAiXG4iICk7DQorDQorICAgIGlmICggY29weV90b191c2Vy KChjaGFyKikgYnVmLCBrZGF0YSwgQlVGRkVSX1NJWkUgKSApDQorICAgIHsNCisgICAgICAgIHBy aW50ayhLRVJOX0VSUiAiY29weV90b191c2VyIGZhaWxcbiIgKTsNCisgICAgICAgIHJldCA9IC0x OTsNCisgICAgfQ0KKw0KKyAgICBrZnJlZSgga2RhdGEgKTsNCisNCisJcmV0dXJuIHJldDsNCit9 DQorDQorI3VuZGVmIEJVRkZFUl9TSVpFDQorDQorc3RhdGljIGludCBzaXNfY2Rldl9vcGVuKHN0 cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxwKQ0KK3sNCisJcHJpbnRrKEtFUk5f SU5GTyAic2lzX2NkZXZfb3Blbi5cbiIpOw0KKwlpZiAoIHRzX2JhayA9PSAwICkNCisgICAgCXJl dHVybiAtMTM7DQorDQorCW1zbGVlcCgyMDApOw0KKwlpZiAodHNfYmFrLT51c2VfaXJxKQ0KKwl7 DQorI2lmICggTElOVVhfVkVSU0lPTl9DT0RFIDwgS0VSTkVMX1ZFUlNJT04gKDIsIDYsIDM5KSAp DQorICAgICAgICBpZiAoKHRzX2Jhay0+ZGVzYy0+c3RhdHVzICYgSVJRX0RJU0FCTEVEKSA9PSBJ UlFfU1RBVFVTX0VOQUJMRUQpDQorI2Vsc2UNCisJCWlmICgodHNfYmFrLT5kZXNjLT5pcnFfZGF0 YS5zdGF0ZV91c2VfYWNjZXNzb3JzICYgSVJRRF9JUlFfRElTQUJMRUQpID09IElSUV9TVEFUVVNf RU5BQkxFRCkNCisjZW5kaWYJDQorCQl7DQorCQkJZGlzYWJsZV9pcnEodHNfYmFrLT5jbGllbnQt PmlycSk7DQorCQl9DQorCQllbHNlDQorCQl7DQorI2lmICggTElOVVhfVkVSU0lPTl9DT0RFIDwg S0VSTkVMX1ZFUlNJT04gKDIsIDYsIDM5KSApDQorCQkJcHJpbnRrKEtFUk5fSU5GTyAic2lzX2Nk ZXZfb3BlbjogSVJRX1NUQVRVUzogJXhcbiIsKHRzX2Jhay0+ZGVzYy0+c3RhdHVzICYgSVJRX0RJ U0FCTEVEKSk7DQorI2Vsc2UNCisJCQlwcmludGsoS0VSTl9JTkZPICJzaXNfY2Rldl9vcGVuOiBJ UlFfU1RBVFVTOiAleFxuIiwodHNfYmFrLT5kZXNjLT5pcnFfZGF0YS5zdGF0ZV91c2VfYWNjZXNz b3JzICYgSVJRRF9JUlFfRElTQUJMRUQpKTsNCisjZW5kaWYJDQorCQl9DQorCX0NCisJaHJ0aW1l cl9jYW5jZWwoJnRzX2Jhay0+dGltZXIpOw0KKw0KKwkvKiBvbmx5IGZsdXNoIHNpc193cSAqLw0K KwlmbHVzaF93b3JrcXVldWUoc2lzX3dxKTsgCSAgIA0KKyAgICANCisgICAgbXNsZWVwKDIwMCk7 DQorDQorCXJldHVybiAwOyAvKiBzdWNjZXNzICovDQorfQ0KKw0KK3N0YXRpYyBpbnQgc2lzX2Nk ZXZfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlscCkNCit7DQor CXByaW50ayhLRVJOX0lORk8gInNpc19jZGV2X3JlbGVhc2UuXG4iKTsNCisJDQorCW1zbGVlcCgy MDApOw0KKwkNCisgICAgaWYgKHRzX2JhayA9PSAwKQ0KKyAgICAJcmV0dXJuIC0xMzsNCisNCisJ aWYgKHRzX2Jhay0+dXNlX2lycSkNCisJew0KKyNpZiAoIExJTlVYX1ZFUlNJT05fQ09ERSA8IEtF Uk5FTF9WRVJTSU9OICgyLCA2LCAzOSkgKQ0KKyAgICAgICAgaWYgKCh0c19iYWstPmRlc2MtPnN0 YXR1cyAmIElSUV9ESVNBQkxFRCkgPT0gSVJRX1NUQVRVU19ESVNBQkxFRCkNCisjZWxzZQ0KKwkJ aWYgKCh0c19iYWstPmRlc2MtPmlycV9kYXRhLnN0YXRlX3VzZV9hY2Nlc3NvcnMgJiBJUlFEX0lS UV9ESVNBQkxFRCkgPT0gSVJRX1NUQVRVU19ESVNBQkxFRCkNCisjZW5kaWYJDQorCQl7DQorCQkJ ZW5hYmxlX2lycSh0c19iYWstPmNsaWVudC0+aXJxKTsNCisJCX0NCisJfQ0KKwllbHNlDQorCQlo cnRpbWVyX3N0YXJ0KCZ0c19iYWstPnRpbWVyLCBrdGltZV9zZXQoMSwgMCksIEhSVElNRVJfTU9E RV9SRUwpOw0KKw0KKyAgICByZXR1cm4gMDsNCit9DQorDQorc3RhdGljIGNvbnN0IHN0cnVjdCBm aWxlX29wZXJhdGlvbnMgc2lzX2NkZXZfZm9wcyA9IHsNCisJLm93bmVyCT0gVEhJU19NT0RVTEUs DQorCS5yZWFkCT0gc2lzX2NkZXZfcmVhZCwNCisJLndyaXRlCT0gc2lzX2NkZXZfd3JpdGUsDQor CS5vcGVuCT0gc2lzX2NkZXZfb3BlbiwNCisJLnJlbGVhc2U9IHNpc19jZGV2X3JlbGVhc2UsDQor fTsNCisNCitzdGF0aWMgaW50IHNpc19zZXR1cF9jaGFyZGV2KHN0cnVjdCBzaXNfdHNfZGF0YSAq dHMpDQorew0KKwkNCisJZGV2X3QgZGV2ID0gTUtERVYoc2lzX2NoYXJfbWFqb3IsIDApOw0KKwlp bnQgYWxsb2NfcmV0ID0gMDsNCisJaW50IGNkZXZfZXJyID0gMDsNCisJaW50IGlucHV0X2VyciA9 IDA7DQorCXN0cnVjdCBkZXZpY2UgKmNsYXNzX2RldiA9IE5VTEw7DQorCXZvaWQgKnB0cl9lcnI7 DQorCQ0KKwlwcmludGsoInNpc19zZXR1cF9jaGFyZGV2LlxuIik7DQorCQ0KKwlpZiAodHMgPT0g TlVMTCkgDQorCXsNCisJICBpbnB1dF9lcnIgPSAtRU5PTUVNOw0KKwkgIGdvdG8gZXJyb3I7DQor CX0gDQorCS8qIGR5bmFtaWMgYWxsb2NhdGUgZHJpdmVyIGhhbmRsZSAqLw0KKwlhbGxvY19yZXQg PSBhbGxvY19jaHJkZXZfcmVnaW9uKCZkZXYsIDAsIHNpc19jaGFyX2RldnNfY291bnQsIERFVklD RV9OQU1FKTsNCisJaWYgKGFsbG9jX3JldCkNCisJCWdvdG8gZXJyb3I7DQorCQkNCisJc2lzX2No YXJfbWFqb3IgPSBNQUpPUihkZXYpOw0KKwljZGV2X2luaXQoJnNpc19jaGFyX2NkZXYsICZzaXNf Y2Rldl9mb3BzKTsNCisJc2lzX2NoYXJfY2Rldi5vd25lciA9IFRISVNfTU9EVUxFOw0KKwljZGV2 X2VyciA9IGNkZXZfYWRkKCZzaXNfY2hhcl9jZGV2LCBNS0RFVihzaXNfY2hhcl9tYWpvciwgMCks IHNpc19jaGFyX2RldnNfY291bnQpOw0KKwkNCisJaWYgKGNkZXZfZXJyKSANCisJCWdvdG8gZXJy b3I7DQorCQ0KKwlwcmludGsoS0VSTl9JTkZPICIlcyBkcml2ZXIobWFqb3IgJWQpIGluc3RhbGxl ZC5cbiIsIERFVklDRV9OQU1FLCBzaXNfY2hhcl9tYWpvcik7DQorCQ0KKwkvKiByZWdpc3RlciBj bGFzcyAqLw0KKwlzaXNfY2hhcl9jbGFzcyA9IGNsYXNzX2NyZWF0ZShUSElTX01PRFVMRSwgREVW SUNFX05BTUUpOw0KKwlpZihJU19FUlIocHRyX2VyciA9IHNpc19jaGFyX2NsYXNzKSkgDQorCXsN CisJCWdvdG8gZXJyMjsNCisJfQ0KKwkNCisJY2xhc3NfZGV2ID0gZGV2aWNlX2NyZWF0ZShzaXNf Y2hhcl9jbGFzcywgTlVMTCwgTUtERVYoc2lzX2NoYXJfbWFqb3IsIDApLCBOVUxMLCBERVZJQ0Vf TkFNRSk7DQorCQ0KKwlpZihJU19FUlIocHRyX2VyciA9IGNsYXNzX2RldikpIA0KKwl7DQorCQln b3RvIGVycjsNCisJfQ0KKwkNCisJcmV0dXJuIDA7DQorZXJyb3I6DQorCWlmIChjZGV2X2VyciA9 PSAwKQ0KKwkJY2Rldl9kZWwoJnNpc19jaGFyX2NkZXYpOw0KKwlpZiAoYWxsb2NfcmV0ID09IDAp DQorCQl1bnJlZ2lzdGVyX2NocmRldl9yZWdpb24oTUtERVYoc2lzX2NoYXJfbWFqb3IsIDApLCBz aXNfY2hhcl9kZXZzX2NvdW50KTsNCisJaWYoaW5wdXRfZXJyICE9IDApDQorCXsNCisJCXByaW50 aygic2lzX3RzX2JhayBlcnJvciFcbiIpOw0KKwl9DQorZXJyOg0KKwlkZXZpY2VfZGVzdHJveShz aXNfY2hhcl9jbGFzcywgTUtERVYoc2lzX2NoYXJfbWFqb3IsIDApKTsNCitlcnIyOg0KKwljbGFz c19kZXN0cm95KHNpc19jaGFyX2NsYXNzKTsNCisJcmV0dXJuIC0xOw0KK30NCisjZW5kaWYNCisN CitzdGF0aWMgaW50IHNpc190c19wcm9iZSgNCisJc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwg Y29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgKmlkKQ0KK3sNCisJaW50IHJldCA9IDA7DQorCXN0 cnVjdCBzaXNfdHNfZGF0YSAqdHMgPSBOVUxMOw0KKwlzdHJ1Y3Qgc2lzX2kyY19ybWlfcGxhdGZv cm1fZGF0YSAqcGRhdGEgPSBOVUxMOw0KKw0KKyAgICBwcmludGsoS0VSTl9JTkZPICJzaXNfdHNf cHJvYmVcbiIpOw0KKw0KKyAgICBUUEluZm8gPSBremFsbG9jKHNpemVvZihzdHJ1Y3Qgc2lzVFBf ZHJpdmVyX2RhdGEpLCBHRlBfS0VSTkVMKTsNCisgICAgaWYgKFRQSW5mbyA9PSBOVUxMKSANCisg ICAgew0KKwkJcmV0ID0gLUVOT01FTTsNCisJCWdvdG8gZXJyX2FsbG9jX2RhdGFfZmFpbGVkOw0K Kwl9DQorDQorCXRzID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHNpc190c19kYXRhKSwgR0ZQX0tF Uk5FTCk7DQorCWlmICh0cyA9PSBOVUxMKSANCisJew0KKwkJcmV0ID0gLUVOT01FTTsNCisJCWdv dG8gZXJyX2FsbG9jX2RhdGFfZmFpbGVkOw0KKwl9DQorDQorCXRzX2JhayA9IHRzOw0KKw0KKwlt dXRleF9pbml0KCZ0cy0+bXV0ZXhfd3EpOw0KKwkNCisJLyogMS4gSW5pdCBXb3JrIHF1ZXVlIGFu ZCBuZWNlc3NhcnkgYnVmZmVycyAqLw0KKwlJTklUX1dPUksoJnRzLT53b3JrLCBzaXNfdHNfd29y a19mdW5jKTsNCisJdHMtPmNsaWVudCA9IGNsaWVudDsNCisJaTJjX3NldF9jbGllbnRkYXRhKGNs aWVudCwgdHMpOw0KKyAgICBwZGF0YSA9IGNsaWVudC0+ZGV2LnBsYXRmb3JtX2RhdGE7DQorDQor CWlmIChwZGF0YSkNCisJCXRzLT5wb3dlciA9IHBkYXRhLT5wb3dlcjsNCisJaWYgKHRzLT5wb3dl cikgDQorCXsNCisJCXJldCA9IHRzLT5wb3dlcigxKTsNCisJCWlmIChyZXQgPCAwKSANCisJCXsN CisJCQlwcmludGsoS0VSTl9FUlIgInNpc190c19wcm9iZSBwb3dlciBvbiBmYWlsZWRcbiIpOw0K KwkJCWdvdG8gZXJyX3Bvd2VyX2ZhaWxlZDsNCisJCX0NCisJfQ0KKw0KKwkvKiAyLiBBbGxvY2F0 ZSBpbnB1dCBkZXZpY2UgKi8NCisJdHMtPmlucHV0X2RldiA9IGlucHV0X2FsbG9jYXRlX2Rldmlj ZSgpOw0KKwlpZiAodHMtPmlucHV0X2RldiA9PSBOVUxMKSANCisJew0KKwkJcmV0ID0gLUVOT01F TTsNCisJCXByaW50ayhLRVJOX0VSUiAic2lzX3RzX3Byb2JlOiBGYWlsZWQgdG8gYWxsb2NhdGUg aW5wdXQgZGV2aWNlXG4iKTsNCisJCWdvdG8gZXJyX2lucHV0X2Rldl9hbGxvY19mYWlsZWQ7DQor CX0NCisNCisJLyogVGhpcyBpbnB1dCBkZXZpY2UgbmFtZSBzaG91bGQgYmUgdGhlIHNhbWUgdG8g SURDIGZpbGUgbmFtZS4gKi8NCisJdHMtPmlucHV0X2Rldi0+bmFtZSA9ICJzaXNfdG91Y2giOw0K Kw0KKwlzZXRfYml0KEVWX0FCUywgdHMtPmlucHV0X2Rldi0+ZXZiaXQpOw0KKwlzZXRfYml0KEVW X0tFWSwgdHMtPmlucHV0X2Rldi0+ZXZiaXQpOw0KKyAgICBzZXRfYml0KEFCU19NVF9QT1NJVElP Tl9YLCB0cy0+aW5wdXRfZGV2LT5hYnNiaXQpOw0KKyAgICBzZXRfYml0KEFCU19NVF9QT1NJVElP Tl9ZLCB0cy0+aW5wdXRfZGV2LT5hYnNiaXQpOw0KKyAgICBzZXRfYml0KEFCU19NVF9UUkFDS0lO R19JRCwgdHMtPmlucHV0X2Rldi0+YWJzYml0KTsNCisNCisjaWZkZWYgX0FORFJPSURfNA0KKwlz ZXRfYml0KElOUFVUX1BST1BfRElSRUNULCB0cy0+aW5wdXRfZGV2LT5wcm9wYml0KTsNCisgICAg c2V0X2JpdChBQlNfTVRfUFJFU1NVUkUsIHRzLT5pbnB1dF9kZXYtPmFic2JpdCk7DQorICAgIHNl dF9iaXQoQUJTX01UX1RPVUNIX01BSk9SLCB0cy0+aW5wdXRfZGV2LT5hYnNiaXQpOw0KKyAgICBz ZXRfYml0KEFCU19NVF9UT1VDSF9NSU5PUiwgdHMtPmlucHV0X2Rldi0+YWJzYml0KTsNCisgICAg aW5wdXRfc2V0X2Fic19wYXJhbXModHMtPmlucHV0X2RldiwgQUJTX01UX1BSRVNTVVJFLCAwLCBQ UkVTU1VSRV9NQVgsIDAsIDApOw0KKyAgICBpbnB1dF9zZXRfYWJzX3BhcmFtcyh0cy0+aW5wdXRf ZGV2LCBBQlNfTVRfVE9VQ0hfTUFKT1IsIDAsIEFSRUFfTEVOR1RIX0xPTkdFUiwgMCwgMCk7DQor ICAgIGlucHV0X3NldF9hYnNfcGFyYW1zKHRzLT5pbnB1dF9kZXYsIEFCU19NVF9UT1VDSF9NSU5P UiwgMCwgQVJFQV9MRU5HVEhfU0hPUlQsIDAsIDApOyAgIA0KKyNlbHNlDQorICAgIHNldF9iaXQo QUJTX01UX1RPVUNIX01BSk9SLCB0cy0+aW5wdXRfZGV2LT5hYnNiaXQpOw0KKyAgICBzZXRfYml0 KEFCU19NVF9XSURUSF9NQUpPUiwgdHMtPmlucHV0X2Rldi0+YWJzYml0KTsNCisgICAgc2V0X2Jp dChBQlNfTVRfV0lEVEhfTUlOT1IsIHRzLT5pbnB1dF9kZXYtPmFic2JpdCk7DQorICAgIGlucHV0 X3NldF9hYnNfcGFyYW1zKHRzLT5pbnB1dF9kZXYsIEFCU19NVF9UT1VDSF9NQUpPUiwgMCwgUFJF U1NVUkVfTUFYLCAwLCAwKTsNCisgICAgaW5wdXRfc2V0X2Fic19wYXJhbXModHMtPmlucHV0X2Rl diwgQUJTX01UX1dJRFRIX01BSk9SLCAwLCBBUkVBX0xFTkdUSF9MT05HRVIsIDAsIDApOw0KKyAg ICBpbnB1dF9zZXRfYWJzX3BhcmFtcyh0cy0+aW5wdXRfZGV2LCBBQlNfTVRfV0lEVEhfTUlOT1Is IDAsIEFSRUFfTEVOR1RIX1NIT1JULCAwLCAwKTsNCisjZW5kaWYNCisNCisgICAgaW5wdXRfc2V0 X2Fic19wYXJhbXModHMtPmlucHV0X2RldiwgQUJTX01UX1BPU0lUSU9OX1gsIDAsIFNJU19NQVhf WCwgMCwgMCk7DQorICAgIGlucHV0X3NldF9hYnNfcGFyYW1zKHRzLT5pbnB1dF9kZXYsIEFCU19N VF9QT1NJVElPTl9ZLCAwLCBTSVNfTUFYX1ksIDAsIDApOw0KKyAgICBpbnB1dF9zZXRfYWJzX3Bh cmFtcyh0cy0+aW5wdXRfZGV2LCBBQlNfTVRfVFJBQ0tJTkdfSUQsIDAsIDE1LCAwLCAwKTsNCisJ DQorICAgIC8qIGFkZCBmb3IgdG91Y2gga2V5cyAqLw0KKwlzZXRfYml0KEtFWV9DT01QT1NFLCB0 cy0+aW5wdXRfZGV2LT5rZXliaXQpOw0KKwlzZXRfYml0KEtFWV9CQUNLLCB0cy0+aW5wdXRfZGV2 LT5rZXliaXQpOw0KKwlzZXRfYml0KEtFWV9NRU5VLCB0cy0+aW5wdXRfZGV2LT5rZXliaXQpOw0K KwlzZXRfYml0KEtFWV9IT01FLCB0cy0+aW5wdXRfZGV2LT5rZXliaXQpOw0KKw0KKwkvKiAzLiBS ZWdpc3RlciBpbnB1dCBkZXZpY2UgdG8gY29yZSAqLw0KKwlyZXQgPSBpbnB1dF9yZWdpc3Rlcl9k ZXZpY2UodHMtPmlucHV0X2Rldik7DQorDQorCWlmIChyZXQpIA0KKwl7DQorCQlwcmludGsoS0VS Tl9FUlIgInNpc190c19wcm9iZTogVW5hYmxlIHRvIHJlZ2lzdGVyICVzIGlucHV0IGRldmljZVxu IiwgdHMtPmlucHV0X2Rldi0+bmFtZSk7DQorCQlnb3RvIGVycl9pbnB1dF9yZWdpc3Rlcl9kZXZp Y2VfZmFpbGVkOw0KKwl9DQorCQ0KKwkvKiA0LiBpcnEgb3IgdGltZXIgc2V0dXAgKi8NCisJcmV0 ID0gaW5pdGlhbF9pcnEoKTsNCisJaWYgKHJldCA8IDApIA0KKwl7DQorDQorCX0NCisJZWxzZQ0K Kwl7DQorCQljbGllbnQtPmlycSA9IGdwaW9fdG9faXJxKEdQSU9fSVJRKTsNCisJCXJldCA9IHJl cXVlc3RfaXJxKGNsaWVudC0+aXJxLCBzaXNfdHNfaXJxX2hhbmRsZXIsIElSUUZfVFJJR0dFUl9G QUxMSU5HLCBjbGllbnQtPm5hbWUsIHRzKTsNCisJCWlmIChyZXQgPT0gMCkgDQorCQl7DQorCQkg ICB0cy0+dXNlX2lycSA9IDE7DQorCQl9DQorCQllbHNlIA0KKwkJew0KKwkJCWRldl9lcnIoJmNs aWVudC0+ZGV2LCAicmVxdWVzdF9pcnEgZmFpbGVkXG4iKTsNCisJCX0NCisJfQ0KKw0KKwl0cy0+ ZGVzYyA9IGlycV90b19kZXNjKHRzX2Jhay0+Y2xpZW50LT5pcnEpOw0KKwkNCisJaHJ0aW1lcl9p bml0KCZ0cy0+dGltZXIsIENMT0NLX01PTk9UT05JQywgSFJUSU1FUl9NT0RFX1JFTCk7DQorCXRz LT50aW1lci5mdW5jdGlvbiA9IHNpc190c190aW1lcl9mdW5jOw0KKw0KKwlpZiAoIXRzLT51c2Vf aXJxKSANCisJew0KKwkJaHJ0aW1lcl9zdGFydCgmdHMtPnRpbWVyLCBrdGltZV9zZXQoMSwgMCks IEhSVElNRVJfTU9ERV9SRUwpOw0KKwl9DQorDQorI2lmZGVmIENPTkZJR19IQVNfRUFSTFlTVVNQ RU5EDQorCXRzLT5lYXJseV9zdXNwZW5kLmxldmVsID0gRUFSTFlfU1VTUEVORF9MRVZFTF9CTEFO S19TQ1JFRU4gKyAxOw0KKwl0cy0+ZWFybHlfc3VzcGVuZC5zdXNwZW5kID0gc2lzX3RzX2Vhcmx5 X3N1c3BlbmQ7DQorCXRzLT5lYXJseV9zdXNwZW5kLnJlc3VtZSA9IHNpc190c19sYXRlX3Jlc3Vt ZTsNCisJcmVnaXN0ZXJfZWFybHlfc3VzcGVuZCgmdHMtPmVhcmx5X3N1c3BlbmQpOw0KKyNlbmRp Zg0KKwlwcmludGsoS0VSTl9JTkZPICJzaXNfdHNfcHJvYmU6IFN0YXJ0IHRvdWNoc2NyZWVuICVz IGluICVzIG1vZGVcbiIsIHRzLT5pbnB1dF9kZXYtPm5hbWUsIHRzLT51c2VfaXJxID8gImludGVy cnVwdCIgOiAicG9sbGluZyIpOw0KKwkNCisJaWYgKHRzLT51c2VfaXJxKQ0KKwl7DQorI2lmZGVm IF9JTlRfTU9ERV8xDQorCQlwcmludGsoS0VSTl9JTkZPICJzaXNfdHNfcHJvYmU6IGludGVycnVw dCBjYXNlIDEgbW9kZVxuIik7DQorI2Vsc2UNCisJCXByaW50ayhLRVJOX0lORk8gInNpc190c19w cm9iZTogaW50ZXJydXB0IGNhc2UgMiBtb2RlXG4iKTsNCisjZW5kaWYNCisJfQ0KKwkNCisjaWZk ZWYgX1NURF9SV19JTw0KKwlyZXQgPSBzaXNfc2V0dXBfY2hhcmRldih0cyk7DQorCWlmKHJldCkN CisJew0KKwkJcHJpbnRrKCBLRVJOX0lORk8ic2lzX3NldHVwX2NoYXJkZXYgZmFpbFxuIik7DQor CX0NCisjZW5kaWYNCisNCisJcHJpbnRrKCBLRVJOX0lORk8ic2lzIFNJU19TTEFWRV9BRERSOiAl ZFxuIiwgU0lTX1NMQVZFX0FERFIpOw0KKw0KKwlyZXR1cm4gMDsNCisNCitlcnJfaW5wdXRfcmVn aXN0ZXJfZGV2aWNlX2ZhaWxlZDoNCisJaW5wdXRfZnJlZV9kZXZpY2UodHMtPmlucHV0X2Rldik7 DQorDQorZXJyX2lucHV0X2Rldl9hbGxvY19mYWlsZWQ6DQorZXJyX3Bvd2VyX2ZhaWxlZDoNCisJ a2ZyZWUodHMpOw0KK2Vycl9hbGxvY19kYXRhX2ZhaWxlZDoNCisJcmV0dXJuIHJldDsNCit9DQor DQorc3RhdGljIGludCBzaXNfdHNfcmVtb3ZlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQpDQor ew0KKwlzdHJ1Y3Qgc2lzX3RzX2RhdGEgKnRzID0gaTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7 DQorCQ0KKyNpZmRlZiBDT05GSUdfSEFTX0VBUkxZU1VTUEVORA0KKwl1bnJlZ2lzdGVyX2Vhcmx5 X3N1c3BlbmQoJnRzLT5lYXJseV9zdXNwZW5kKTsNCisjZW5kaWYNCisJaWYgKHRzLT51c2VfaXJx KQ0KKwkJZnJlZV9pcnEoY2xpZW50LT5pcnEsIHRzKTsNCisJZWxzZQ0KKwkJaHJ0aW1lcl9jYW5j ZWwoJnRzLT50aW1lcik7DQorCWlucHV0X3VucmVnaXN0ZXJfZGV2aWNlKHRzLT5pbnB1dF9kZXYp Ow0KKwlrZnJlZSh0cyk7DQorCQ0KKwlyZXR1cm4gMDsNCit9DQorDQorc3RhdGljIGludCBzaXNf dHNfc3VzcGVuZChzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LCBwbV9tZXNzYWdlX3QgbWVzZykN Cit7DQorCWludCByZXQgPSAwOw0KKwlzdHJ1Y3Qgc2lzX3RzX2RhdGEgKnRzID0gaTJjX2dldF9j bGllbnRkYXRhKGNsaWVudCk7DQorDQorCVRQSW5mby0+cHJlX2tleWJpdF9zdGF0ZSA9IDB4MDsN CisNCisJaWYgKHRzLT51c2VfaXJxKQ0KKwl7DQorI2lmICggTElOVVhfVkVSU0lPTl9DT0RFIDwg S0VSTkVMX1ZFUlNJT04gKDIsIDYsIDM5KSApDQorCQlpZiAoKHRzLT5kZXNjLT5zdGF0dXMgJiBJ UlFfRElTQUJMRUQpID09IElSUV9TVEFUVVNfRU5BQkxFRCkNCisjZWxzZQ0KKwkJaWYgKCh0cy0+ ZGVzYy0+aXJxX2RhdGEuc3RhdGVfdXNlX2FjY2Vzc29ycyAmIElSUURfSVJRX0RJU0FCTEVEKSA9 PSBJUlFfU1RBVFVTX0VOQUJMRUQpDQorI2VuZGlmDQorCQl7DQorCQkJZGlzYWJsZV9pcnEoY2xp ZW50LT5pcnEpOw0KKwkJfQ0KKwl9DQorCWVsc2UNCisJCWhydGltZXJfY2FuY2VsKCZ0cy0+dGlt ZXIpOw0KKwkvKiBvbmx5IGZsdXNoIHNpc193cSAqLw0KKwlmbHVzaF93b3JrcXVldWUoc2lzX3dx KTsgCSAgIAkJDQorDQorCWlmICh0cy0+cG93ZXIpIHsNCisJCXJldCA9IHRzLT5wb3dlcigwKTsN CisJCWlmIChyZXQgPCAwKQ0KKwkJCXByaW50ayhLRVJOX0VSUiAic2lzX3RzX3N1c3BlbmQgcG93 ZXIgb2ZmIGZhaWxlZFxuIik7DQorCX0NCisJDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMg aW50IHNpc190c19yZXN1bWUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCkNCit7DQorCWludCBy ZXQgPSAwOw0KKwlzdHJ1Y3Qgc2lzX3RzX2RhdGEgKnRzID0gaTJjX2dldF9jbGllbnRkYXRhKGNs aWVudCk7DQorDQorCWlmICh0cy0+cG93ZXIpDQorCXsNCisJCXJldCA9IHRzLT5wb3dlcigxKTsN CisJCWlmIChyZXQgPCAwKQ0KKwkJCXByaW50ayhLRVJOX0VSUiAic2lzX3RzX3Jlc3VtZSBwb3dl ciBvbiBmYWlsZWRcbiIpOw0KKwl9DQorDQorCWlmICh0cy0+dXNlX2lycSkNCisJew0KKyNpZiAo IExJTlVYX1ZFUlNJT05fQ09ERSA8IEtFUk5FTF9WRVJTSU9OICgyLCA2LCAzOSkgKQ0KKwkJaWYg KCh0cy0+ZGVzYy0+c3RhdHVzICYgSVJRX0RJU0FCTEVEKSA9PSBJUlFfU1RBVFVTX0RJU0FCTEVE KQ0KKyNlbHNlDQorCQlpZiAoKHRzLT5kZXNjLT5pcnFfZGF0YS5zdGF0ZV91c2VfYWNjZXNzb3Jz ICYgSVJRRF9JUlFfRElTQUJMRUQpID09IElSUV9TVEFUVVNfRElTQUJMRUQpDQorI2VuZGlmDQor CQl7DQorCQkJZW5hYmxlX2lycShjbGllbnQtPmlycSk7DQorCQl9DQorCX0NCisJZWxzZQ0KKwkJ aHJ0aW1lcl9zdGFydCgmdHMtPnRpbWVyLCBrdGltZV9zZXQoMSwgMCksIEhSVElNRVJfTU9ERV9S RUwpOw0KKw0KKwlyZXR1cm4gMDsNCit9DQorDQorI2lmZGVmIENPTkZJR19IQVNfRUFSTFlTVVNQ RU5EDQorc3RhdGljIHZvaWQgc2lzX3RzX2Vhcmx5X3N1c3BlbmQoc3RydWN0IGVhcmx5X3N1c3Bl bmQgKmgpDQorew0KKwlzdHJ1Y3Qgc2lzX3RzX2RhdGEgKnRzOw0KKwkNCisJVFBJbmZvLT5wcmVf a2V5Yml0X3N0YXRlID0gMHgwOw0KKwl0cyA9IGNvbnRhaW5lcl9vZihoLCBzdHJ1Y3Qgc2lzX3Rz X2RhdGEsIGVhcmx5X3N1c3BlbmQpOw0KKwlzaXNfdHNfc3VzcGVuZCh0cy0+Y2xpZW50LCBQTVNH X1NVU1BFTkQpOw0KK30NCisNCitzdGF0aWMgdm9pZCBzaXNfdHNfbGF0ZV9yZXN1bWUoc3RydWN0 IGVhcmx5X3N1c3BlbmQgKmgpDQorew0KKwlzdHJ1Y3Qgc2lzX3RzX2RhdGEgKnRzOw0KKwkNCisJ dHMgPSBjb250YWluZXJfb2YoaCwgc3RydWN0IHNpc190c19kYXRhLCBlYXJseV9zdXNwZW5kKTsN CisJc2lzX3RzX3Jlc3VtZSh0cy0+Y2xpZW50KTsNCit9DQorI2VuZGlmDQorDQorc3RhdGljIGNv bnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkIHNpc190c19pZFtdID0gew0KKwl7IFNJU19JMkNfTkFN RSwgMCB9LA0KKwl7IH0NCit9Ow0KKw0KK01PRFVMRV9ERVZJQ0VfVEFCTEUoaTJjLCBzaXNfdHNf aWQpOw0KKw0KK3N0YXRpYyBzdHJ1Y3QgaTJjX2RyaXZlciBzaXNfdHNfZHJpdmVyID0gew0KKwku cHJvYmUJCT0gc2lzX3RzX3Byb2JlLA0KKwkucmVtb3ZlCQk9IHNpc190c19yZW1vdmUsDQorI2lm bmRlZiBDT05GSUdfSEFTX0VBUkxZU1VTUEVORA0KKwkuc3VzcGVuZAk9IHNpc190c19zdXNwZW5k LA0KKwkucmVzdW1lCQk9IHNpc190c19yZXN1bWUsDQorI2VuZGlmDQorI2lmZGVmIENPTkZJR19Y ODYNCisgICAgLmNsYXNzICAgICAgPSBJMkNfQ0xBU1NfSFdNT04sDQorICAgIC5kZXRlY3QJCT0g c2lzX3RzX2RldGVjdCwNCisJLmFkZHJlc3NfbGlzdAk9IG5vcm1hbF9pMmMsDQorI2VuZGlmDQor CS5pZF90YWJsZQk9IHNpc190c19pZCwNCisJLmRyaXZlciA9IHsNCisJCS5uYW1lCT0gU0lTX0ky Q19OQU1FLA0KKwl9LA0KK307DQorDQorc3RhdGljIGludCBfX2luaXQgc2lzX3RzX2luaXQodm9p ZCkNCit7DQorCXByaW50ayggS0VSTl9JTkZPICJzaXNfdHNfaW5pdFxuIiApOw0KKwkNCisJc2lz X3dxID0gY3JlYXRlX3NpbmdsZXRocmVhZF93b3JrcXVldWUoInNpc193cSIpOw0KKw0KKwlpZiAo IXNpc193cSkNCisJCXJldHVybiAtRU5PTUVNOw0KKwkJDQorCXJldHVybiBpMmNfYWRkX2RyaXZl cigmc2lzX3RzX2RyaXZlcik7DQorfQ0KKw0KKyNpZmRlZiBDT05GSUdfWDg2DQorLyogUmV0dXJu IDAgaWYgZGV0ZWN0aW9uIGlzIHN1Y2Nlc3NmdWwsIC1FTk9ERVYgb3RoZXJ3aXNlICovDQorc3Rh dGljIGludCBzaXNfdHNfZGV0ZWN0KHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsDQorCQkgICAg ICAgc3RydWN0IGkyY19ib2FyZF9pbmZvICppbmZvKQ0KK3sNCisJY29uc3QgY2hhciAqdHlwZV9u YW1lOw0KKwkNCisgICAgcHJpbnRrKEtFUk5fSU5GTyAic2lzX3RzX2RldGVjdFxuIik7DQorCQ0K Kwl0eXBlX25hbWUgPSAic2lzX2kyY190cyI7DQorCXN0cmxjcHkoaW5mby0+dHlwZSwgdHlwZV9u YW1lLCBJMkNfTkFNRV9TSVpFKTsNCisJDQorCXJldHVybiAwOw0KK30NCisjZW5kaWYNCisNCitz dGF0aWMgdm9pZCBfX2V4aXQgc2lzX3RzX2V4aXQodm9pZCkNCit7DQorI2lmZGVmIF9TVERfUldf SU8NCisJZGV2X3QgZGV2Ow0KKyNlbmRpZg0KKw0KKwlwcmludGsoS0VSTl9JTkZPICJzaXNfdHNf ZXhpdFxuIik7DQorCQ0KKwlpMmNfZGVsX2RyaXZlcigmc2lzX3RzX2RyaXZlcik7DQorCQ0KKwlp ZiAoc2lzX3dxKQ0KKwkJZGVzdHJveV93b3JrcXVldWUoc2lzX3dxKTsNCisNCisjaWZkZWYgX1NU RF9SV19JTw0KKwlkZXYgPSBNS0RFVihzaXNfY2hhcl9tYWpvciwgMCk7DQorCWNkZXZfZGVsKCZz aXNfY2hhcl9jZGV2KTsNCisJdW5yZWdpc3Rlcl9jaHJkZXZfcmVnaW9uKGRldiwgc2lzX2NoYXJf ZGV2c19jb3VudCk7DQorCWRldmljZV9kZXN0cm95KHNpc19jaGFyX2NsYXNzLCBNS0RFVihzaXNf Y2hhcl9tYWpvciwgMCkpOw0KKwljbGFzc19kZXN0cm95KHNpc19jaGFyX2NsYXNzKTsNCisjZW5k aWYNCit9DQorDQorbW9kdWxlX2luaXQoc2lzX3RzX2luaXQpOw0KK21vZHVsZV9leGl0KHNpc190 c19leGl0KTsNCitNT0RVTEVfREVTQ1JJUFRJT04oIlNpUyA5MjAwIEZhbWlseSBUb3VjaHNjcmVl biBEcml2ZXIiKTsNCitNT0RVTEVfTElDRU5TRSgiR1BMIik7DQpkaWZmIC0tZ2l0IGEvbGludXgt My4xOC4xL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vc2lzX2kyYy5oIGIvbGludXgtMy4xOC4x L2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vc2lzX2kyYy5oDQpuZXcgZmlsZSBtb2RlIDEwMDY0 NA0KaW5kZXggMDAwMDAwMC4uYzFkNjVjNA0KLS0tIC9kZXYvbnVsbA0KKysrIGIvbGludXgtMy4x OC4xL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vc2lzX2kyYy5oDQpAQCAtMCwwICsxLDIxNSBA QA0KKy8qDQorICogaW5jbHVkZS9saW51eC9zaXNfaTJjLmggLSBwbGF0Zm9ybSBkYXRhIHN0cnVj dHVyZSBmb3IgU2lTIDkyMDAgZmFtaWx5DQorICoNCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgU2lT LCBJbmMuDQorICoNCisgKiBUaGlzIHNvZnR3YXJlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljDQorICogTGljZW5zZSB2ZXJzaW9uIDIsIGFzIHB1 Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBhbmQNCisgKiBtYXkgYmUg Y29waWVkLCBkaXN0cmlidXRlZCwgYW5kIG1vZGlmaWVkIHVuZGVyIHRob3NlIHRlcm1zLg0KKyAq DQorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2ls bCBiZSB1c2VmdWwsDQorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4g dGhlIGltcGxpZWQgd2FycmFudHkgb2YNCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBG T1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlDQorICogR05VIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4NCisgKg0KKyAqIERhdGU6IDIwMTUvMDEvMTUNCisg KiBWZXJzaW9uOglBbmRyb2lkX3YyLjA1LjAwLUE2MzktMTExMw0KKyAqLw0KKyNpbmNsdWRlIDxs aW51eC92ZXJzaW9uLmg+DQorDQorI2lmbmRlZiBfTElOVVhfU0lTX0kyQ19IDQorI2RlZmluZSBf TElOVVhfU0lTX0kyQ19IDQorDQorDQorI2RlZmluZSBTSVNfSTJDX05BTUUgInNpc19pMmNfdHMi DQorI2RlZmluZSBTSVNfU0xBVkVfQUREUgkJCQkJMHg1Yw0KKyNkZWZpbmUgVElNRVJfTlMgICAg CQkJCQkxMDAwMDAwMCAvLzEwbXMNCisjZGVmaW5lIE1BWF9GSU5HRVJTCQkJCQkJMTANCisNCisN CisvKiBGb3IgQW5kcm9pZCA0LjAgCQkJCQkJCSovDQorLyogT25seSBmb3IgTGludXgga2VybmVs IDIuNi4zNCBhbmQgbGF0ZXIgCSovDQorI2RlZmluZSBfQU5EUk9JRF80CQkJCQkvLyAgT04vT0ZG DQorDQorLyogRm9yIHN0YW5kYXJkIFIvVyBJTyovDQorI2RlZmluZSBfU1REX1JXX0lPCQkJCQkJ Ly8gIE9OL09GRg0KKw0KKy8qIEludGVycnVwdCBzZXR0aW5nIGFuZCBtb2RlcyAqLw0KKyNkZWZp bmUgX0kyQ19JTlRfRU5BQkxFCQkJCQkvLyAgT04vT0ZGDQorI2RlZmluZSBHUElPX0lSUSAJCQkJ CQkxMzMNCisNCisvKiAgRW5hYmxlIGlmIHVzZSBpbnRlcnJ1cHQgY2FzZSAxIG1vZGUuICAqLw0K Ky8qIAlEaXNhYmxlIGlmIHVzZSBpbnRlcnJ1cHQgY2FzZSAyIG1vZGUuICovDQorLy8jZGVmaW5l IF9JTlRfTU9ERV8xCQkJCQkvLwlPTi9PRkYNCisNCisvKiBJUlEgU1RBVFVTICovDQorI2lmICgg TElOVVhfVkVSU0lPTl9DT0RFIDwgS0VSTkVMX1ZFUlNJT04gKDIsIDYsIDM5KSApDQorI2RlZmlu ZSBJUlFfU1RBVFVTX0RJU0FCTEVECQkJCTB4MjAwICANCisjZWxzZQ0KKyNkZWZpbmUgSVJRX1NU QVRVU19ESVNBQkxFRAkJCQkoMTw8MTYpDQorI2VuZGlmDQorI2RlZmluZSBJUlFfU1RBVFVTX0VO QUJMRUQJCQkJMHgwDQorDQorLyogUmVzb2x1dGlvbiBtb2RlICovDQorLy8gQ29uc3RhbnQgdmFs dWUgDQorI2RlZmluZSBTSVNfTUFYX1gJCQkJCQk0MDk1DQorI2RlZmluZSBTSVNfTUFYX1kJCQkJ CQk0MDk1DQorDQorI2RlZmluZSBPTkVfQllURQkJCQkJCTENCisjZGVmaW5lIEZJVkVfQllURQkJ CQkJCTUNCisjZGVmaW5lIEVJR0hUX0JZVEUgIAkJCQkJOA0KKyNkZWZpbmUgU0lYVEVFTl9CWVRF CQkJCQkxNg0KKyNkZWZpbmUgUEFDS0VUX0JVRkZFUl9TSVpFCQkJCTEyOA0KKw0KKyNkZWZpbmUg U0lTX0NNRF9OT1JNQUwJCQkJCTB4MA0KKyNkZWZpbmUgU0lTX0NNRF9TT0ZUUkVTRVQJCQkJMHg4 Mg0KKyNkZWZpbmUgU0lTX0NNRF9SRUNBTElCUkFURQkJCQkweDg3DQorI2RlZmluZSBTSVNfQ01E X1BPV0VSTU9ERSAgICAgICAJCTB4OTANCisjZGVmaW5lIE1TS19UT1VDSE5VTQkJCQkJMHgwZg0K KyNkZWZpbmUgTVNLX0hBU19DUkMJCQkJCQkweDEwDQorI2RlZmluZSBNU0tfREFUQUZNVAkJCQkJ CTB4ZTANCisjZGVmaW5lIE1TS19QU1RBVEUJCQkJCQkweDBmDQorI2RlZmluZSBNU0tfUElECSAg ICAgICAgICAgICAgICAJCTB4ZjANCisjZGVmaW5lIFJFU19GTVQJCQkJCQkJMHgwMA0KKyNkZWZp bmUgRklYX0ZNVAkJCQkJCQkweDQwDQorDQorLyogZm9yIG5ldyBpMmMgZm9ybWF0ICovDQorI2Rl ZmluZSBUT1VDSERPV04JCQkJCQkweDMNCisjZGVmaW5lIFRPVUNIVVAJCQkJCQkJMHgwDQorI2Rl ZmluZSBNQVhfQllURQkJCQkJCTY0DQorI2RlZmluZQlQUkVTU1VSRV9NQVgJCQkJCTI1NQ0KKw0K KyNpZmRlZiBfQU5EUk9JRF80DQorI2RlZmluZSBBUkVBX0xFTkdUSF9MT05HRVIJCQkJNTc5MiAv L1Jlc29sdXRpb24gZGlhZ29uYWwgDQorI2RlZmluZSBBUkVBX0xFTkdUSF9TSE9SVAkJCQk1Nzky IC8vICgoU0lTX01BWF9YXjIpICsgKFNJU19NQVhfWV4yKSleMC41DQorI2RlZmluZSBBUkVBX1VO SVQJCQkJCQkoNTc5Mi8zMikNCisjZWxzZQ0KKyNkZWZpbmUgQVJFQV9MRU5HVEhfTE9OR0VSCQkJ CTMxDQorI2RlZmluZSBBUkVBX0xFTkdUSF9TSE9SVAkJCQkzMQ0KKyNlbmRpZg0KKw0KKw0KKyNk ZWZpbmUgRk9STUFUX01PREUJCQkJCQkxDQorDQorI2RlZmluZSBNU0tfTk9CVE4JCQkJCQkwDQor I2RlZmluZSBNU0tfQ09NUAkJCQkJCTENCisjZGVmaW5lIE1TS19CQUNLCQkJCQkJMg0KKyNkZWZp bmUgTVNLX01FTlUJCQkJCQk0DQorI2RlZmluZSBNU0tfSE9NRQkJCQkJCTgNCisNCisjZGVmaW5l IFBfQllURUNPVU5UCQkJCQkJMCANCisjZGVmaW5lIEFMTF9JTl9PTkVfUEFDS0FHRQkJCQkweDEw DQorI2RlZmluZSBJU19UT1VDSCh4KQkJCQkJCSh4ICYgMHgxKQ0KKyNkZWZpbmUgSVNfSElESTJD KHgpCQkJCQkoeCAmIDB4NikNCisjZGVmaW5lIElTX0FSRUEoeCkJCQkJCQkoKHggPj4gNCkgJiAw eDEpDQorI2RlZmluZSBJU19QUkVTU1VSRSh4KQkJCQkgICAgKCh4ID4+IDUpICYgMHgxKQ0KKyNk ZWZpbmUgSVNfU0NBTlRJTUUoeCkJCQkgICAgICAgICgoeCA+PiA2KSAmIDB4MSkNCisvLyNkZWZp bmUgX0RFQlVHX1BBQ0tBR0UJCQkJLy8gIE9OL09GRg0KKy8vI2RlZmluZSBfREVCVUdfUkVQT1JU CQkJCQkvLyAgT04vT0ZGDQorI2RlZmluZSBOT1JNQUxfTEVOX1BFUl9QT0lOVAkJCTYNCisjZGVm aW5lIEFSRUFfTEVOX1BFUl9QT0lOVAkJCQkyDQorI2RlZmluZSBQUkVTU1VSRV9MRU5fUEVSX1BP SU5UCQkJMQ0KKw0KKy8vI2RlZmluZSBfQ0hFQ0tfQ1JDCQkJCQkvLyAgT04vT0ZGDQorLy8jZGVm aW5lIF9TVVBQT1JUX0JVVFRPTl9UT1VDSAkJCS8vICBPTi9PRkYNCisjZGVmaW5lIFRPVUNIX0ZP Uk1BVAkJCQkJMHgxDQorI2RlZmluZSBCVVRUT05fRk9STUFUCQkJCQkweDQNCisjZGVmaW5lIEhJ REkyQ19GT1JNQVQJCQkJCTB4Ng0KKyNkZWZpbmUgUF9SRVBPUlRfSUQJCQkJCQkyDQorI2RlZmlu ZSBCVVRUT05fU1RBVEUJCQkJCTMNCisjZGVmaW5lIEJVVFRPTl9LRVlfQ09VTlQJCQkJMTYNCisj ZGVmaW5lIEJZVEVfQllURUNPVU5UCQkJCQkyDQorI2RlZmluZSBCWVRFX0NPVU5UCQkJCQkJMQ0K KyNkZWZpbmUgQllURV9SZXBvcnRJRAkJCQkJMQ0KKyNkZWZpbmUgQllURV9DUkNfSElESTJDCQkJ CQkwDQorI2RlZmluZSBCWVRFX0NSQ19JMkMJCQkJCTINCisjZGVmaW5lIEJZVEVfU0NBTlRJTUUJ CQkJCTINCisjZGVmaW5lIE5PX1RPVUNIX0JZVEVDT1VOVAkJCQkweDMNCisNCisvKiBUT0RPICov DQorI2RlZmluZSBUT1VDSF9QT1dFUl9QSU4JCQkJCTANCisjZGVmaW5lIFRPVUNIX1JFU0VUX1BJ TgkJCQkJMQ0KKw0KKy8qIENNRCBEZWZpbmUgKi8NCisjZGVmaW5lIEJVRl9BQ0tfUExBQ0VfTAkJ CQkJNA0KKyNkZWZpbmUgQlVGX0FDS19QTEFDRV9ICQkJCQk1DQorI2RlZmluZSBCVUZfQUNLX0wJ CQkJCQkweEVGDQorI2RlZmluZSBCVUZfQUNLX0gJCQkJCQkweEJFDQorI2RlZmluZSBCVUZfTkFD S19MCQkJCQkJMHhBRA0KKyNkZWZpbmUgQlVGX05BQ0tfSAkJCQkJCTB4REUNCisjZGVmaW5lIEJV Rl9DUkNfUExBQ0UJCQkJCTcNCisNCisNCisNCitzdHJ1Y3Qgc2lzX2kyY19ybWlfcGxhdGZvcm1f ZGF0YSB7DQorCWludCAoKnBvd2VyKShpbnQgb24pOwkvKiBPbmx5IHZhbGlkIGluIGZpcnN0IGFy cmF5IGVudHJ5ICovDQorfTsNCisNCitzdGF0aWMgY29uc3QgdW5zaWduZWQgc2hvcnQgY3JjMTZ0 YWJbMjU2XT0gew0KKwkJMHgwMDAwLDB4MTAyMSwweDIwNDIsMHgzMDYzLDB4NDA4NCwweDUwYTUs MHg2MGM2LDB4NzBlNywNCisgICAgICAgIDB4ODEwOCwweDkxMjksMHhhMTRhLDB4YjE2YiwweGMx OGMsMHhkMWFkLDB4ZTFjZSwweGYxZWYsDQorICAgICAgICAweDEyMzEsMHgwMjEwLDB4MzI3Myww eDIyNTIsMHg1MmI1LDB4NDI5NCwweDcyZjcsMHg2MmQ2LA0KKyAgICAgICAgMHg5MzM5LDB4ODMx OCwweGIzN2IsMHhhMzVhLDB4ZDNiZCwweGMzOWMsMHhmM2ZmLDB4ZTNkZSwNCisgICAgICAgIDB4 MjQ2MiwweDM0NDMsMHgwNDIwLDB4MTQwMSwweDY0ZTYsMHg3NGM3LDB4NDRhNCwweDU0ODUsDQor ICAgICAgICAweGE1NmEsMHhiNTRiLDB4ODUyOCwweDk1MDksMHhlNWVlLDB4ZjVjZiwweGM1YWMs MHhkNThkLA0KKyAgICAgICAgMHgzNjUzLDB4MjY3MiwweDE2MTEsMHgwNjMwLDB4NzZkNywweDY2 ZjYsMHg1Njk1LDB4NDZiNCwNCisgICAgICAgIDB4Yjc1YiwweGE3N2EsMHg5NzE5LDB4ODczOCww eGY3ZGYsMHhlN2ZlLDB4ZDc5ZCwweGM3YmMsDQorICAgICAgICAweDQ4YzQsMHg1OGU1LDB4Njg4 NiwweDc4YTcsMHgwODQwLDB4MTg2MSwweDI4MDIsMHgzODIzLA0KKyAgICAgICAgMHhjOWNjLDB4 ZDllZCwweGU5OGUsMHhmOWFmLDB4ODk0OCwweDk5NjksMHhhOTBhLDB4YjkyYiwNCisgICAgICAg IDB4NWFmNSwweDRhZDQsMHg3YWI3LDB4NmE5NiwweDFhNzEsMHgwYTUwLDB4M2EzMywweDJhMTIs DQorICAgICAgICAweGRiZmQsMHhjYmRjLDB4ZmJiZiwweGViOWUsMHg5Yjc5LDB4OGI1OCwweGJi M2IsMHhhYjFhLA0KKyAgICAgICAgMHg2Y2E2LDB4N2M4NywweDRjZTQsMHg1Y2M1LDB4MmMyMiww eDNjMDMsMHgwYzYwLDB4MWM0MSwNCisgICAgICAgIDB4ZWRhZSwweGZkOGYsMHhjZGVjLDB4ZGRj ZCwweGFkMmEsMHhiZDBiLDB4OGQ2OCwweDlkNDksDQorICAgICAgICAweDdlOTcsMHg2ZWI2LDB4 NWVkNSwweDRlZjQsMHgzZTEzLDB4MmUzMiwweDFlNTEsMHgwZTcwLA0KKyAgICAgICAgMHhmZjlm LDB4ZWZiZSwweGRmZGQsMHhjZmZjLDB4YmYxYiwweGFmM2EsMHg5ZjU5LDB4OGY3OCwNCisgICAg ICAgIDB4OTE4OCwweDgxYTksMHhiMWNhLDB4YTFlYiwweGQxMGMsMHhjMTJkLDB4ZjE0ZSwweGUx NmYsDQorICAgICAgICAweDEwODAsMHgwMGExLDB4MzBjMiwweDIwZTMsMHg1MDA0LDB4NDAyNSww eDcwNDYsMHg2MDY3LA0KKyAgICAgICAgMHg4M2I5LDB4OTM5OCwweGEzZmIsMHhiM2RhLDB4YzMz ZCwweGQzMWMsMHhlMzdmLDB4ZjM1ZSwNCisgICAgICAgIDB4MDJiMSwweDEyOTAsMHgyMmYzLDB4 MzJkMiwweDQyMzUsMHg1MjE0LDB4NjI3NywweDcyNTYsDQorICAgICAgICAweGI1ZWEsMHhhNWNi LDB4OTVhOCwweDg1ODksMHhmNTZlLDB4ZTU0ZiwweGQ1MmMsMHhjNTBkLA0KKyAgICAgICAgMHgz NGUyLDB4MjRjMywweDE0YTAsMHgwNDgxLDB4NzQ2NiwweDY0NDcsMHg1NDI0LDB4NDQwNSwNCisg ICAgICAgIDB4YTdkYiwweGI3ZmEsMHg4Nzk5LDB4OTdiOCwweGU3NWYsMHhmNzdlLDB4YzcxZCww eGQ3M2MsDQorICAgICAgICAweDI2ZDMsMHgzNmYyLDB4MDY5MSwweDE2YjAsMHg2NjU3LDB4NzY3 NiwweDQ2MTUsMHg1NjM0LA0KKyAgICAgICAgMHhkOTRjLDB4Yzk2ZCwweGY5MGUsMHhlOTJmLDB4 OTljOCwweDg5ZTksMHhiOThhLDB4YTlhYiwNCisgICAgICAgIDB4NTg0NCwweDQ4NjUsMHg3ODA2 LDB4NjgyNywweDE4YzAsMHgwOGUxLDB4Mzg4MiwweDI4YTMsDQorICAgICAgICAweGNiN2QsMHhk YjVjLDB4ZWIzZiwweGZiMWUsMHg4YmY5LDB4OWJkOCwweGFiYmIsMHhiYjlhLA0KKyAgICAgICAg MHg0YTc1LDB4NWE1NCwweDZhMzcsMHg3YTE2LDB4MGFmMSwweDFhZDAsMHgyYWIzLDB4M2E5MiwN CisgICAgICAgIDB4ZmQyZSwweGVkMGYsMHhkZDZjLDB4Y2Q0ZCwweGJkYWEsMHhhZDhiLDB4OWRl OCwweDhkYzksDQorICAgICAgICAweDdjMjYsMHg2YzA3LDB4NWM2NCwweDRjNDUsMHgzY2EyLDB4 MmM4MywweDFjZTAsMHgwY2MxLA0KKyAgICAgICAgMHhlZjFmLDB4ZmYzZSwweGNmNWQsMHhkZjdj LDB4YWY5YiwweGJmYmEsMHg4ZmQ5LDB4OWZmOCwNCisgICAgICAgIDB4NmUxNywweDdlMzYsMHg0 ZTU1LDB4NWU3NCwweDJlOTMsMHgzZWIyLDB4MGVkMSwweDFlZjANCit9Ow0KKw0KK3N0cnVjdCBQ b2ludCB7DQorCWludCBpZDsNCisJdW5zaWduZWQgc2hvcnQgeCwgeTsgICAJLy8gdWludDE2X3Qg Pw0KKwl1aW50MTZfdCBQcmVzc3VyZTsNCisJdWludDE2X3QgV2lkdGg7DQorCXVpbnQxNl90IEhl aWdodDsNCit9Ow0KKw0KK3N0cnVjdCBzaXNUUF9kcml2ZXJfZGF0YSB7DQorCWludCBpZDsNCisJ aW50IGZpbmdlcnM7DQorCXVpbnQ4X3QgcHJlX2tleWJpdF9zdGF0ZTsJDQorCXN0cnVjdCBQb2lu dCBwdFtNQVhfRklOR0VSU107DQorfTsNCisNCitzdHJ1Y3Qgc2lzX3RzX2RhdGEgew0KKwlpbnQg KCpwb3dlcikoaW50IG9uKTsNCisJaW50IHVzZV9pcnE7DQorCXN0cnVjdCBpMmNfY2xpZW50ICpj bGllbnQ7DQorCXN0cnVjdCBpbnB1dF9kZXYgKmlucHV0X2RldjsNCisJc3RydWN0IGhydGltZXIg dGltZXI7DQorCXN0cnVjdCBpcnFfZGVzYyAqZGVzYzsNCisJc3RydWN0IHdvcmtfc3RydWN0IHdv cms7DQorCXN0cnVjdCBtdXRleCBtdXRleF93cTsNCisjaWZkZWYgQ09ORklHX0hBU19FQVJMWVNV U1BFTkQNCisJc3RydWN0IGVhcmx5X3N1c3BlbmQgZWFybHlfc3VzcGVuZDsNCisjZW5kaWYNCit9 Ow0KKw0KK3N0YXRpYyBpbnQgc2lzX3RzX3N1c3BlbmQoc3RydWN0IGkyY19jbGllbnQgKmNsaWVu dCwgcG1fbWVzc2FnZV90IG1lc2cpOw0KK3N0YXRpYyBpbnQgc2lzX3RzX3Jlc3VtZShzdHJ1Y3Qg aTJjX2NsaWVudCAqY2xpZW50KTsNCisNCisjZW5kaWYgLyogX0xJTlVYX1NJU19JMkNfSCAqLw0K