From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 316F8C433F5 for ; Mon, 21 Feb 2022 20:27:07 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233660AbiBUU12 (ORCPT ); Mon, 21 Feb 2022 15:27:28 -0500 Received: from mxb-00190b01.gslb.pphosted.com ([23.128.96.19]:48532 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233665AbiBUU1W (ORCPT ); Mon, 21 Feb 2022 15:27:22 -0500 Received: from mail-ed1-x535.google.com (mail-ed1-x535.google.com [IPv6:2a00:1450:4864:20::535]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8911D237CA; Mon, 21 Feb 2022 12:26:58 -0800 (PST) Received: by mail-ed1-x535.google.com with SMTP id s24so25330150edr.5; Mon, 21 Feb 2022 12:26:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:date:mime-version:user-agent:subject:content-language :from:to:cc:references:in-reply-to:content-transfer-encoding; bh=f54s1QNFfJCjG5iDYvLw8C940im9nMlBHjJVOUqHXNc=; b=fvZOp6+H9iTtbujgBKUPDoxhljH2zNj4zT+xFwml+WCOQkj9OXc5aRIMCYF0s25J0V jdEGI5CYpLOLLlXYCihYVM/AZVN88u+HRPyQAaAnsz748Msoc5t3uQ3ojmHjZVGK1m9F 8sHpWvG5bGpRFTGuRIWaMTlLSgJ3qrva8ZPazKzYdwRCHj125GvRfSaDxu9/29ycggnS BcAXAC6FBVcPDbRVv7lkCrJV4KNoqqhwxa14/wbM+Pl/jGNXbcROL0UuRgPI1HYk7xY+ nWML1VOE61jQt1lLCW/G20mzuznJwyyoaf4va9Jb8nWyGQJl1iAcUPUvv1LccSbl4qlT /p9g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:date:mime-version:user-agent:subject :content-language:from:to:cc:references:in-reply-to :content-transfer-encoding; bh=f54s1QNFfJCjG5iDYvLw8C940im9nMlBHjJVOUqHXNc=; b=72wxP/Zb29fo7RulNE8dPM0jjsJ8CkNfvyCXCpy3WIhLfFDFA9xDmLbn3dvAYfg26I 0nPtVgjr0LOM/iusM6s0nkV+vjajMD3O1fZqQDazrz5xKMhkdRZBx33cMoA5Y3aAJYD0 qKDSxUvW9YmzvUvtjnDiwOHUErVw6dGOYoO5MjVSrxbnYr20CFFHwXIoztcP19lpWs3Z W3VCrh/lEb0BFOme/IWd5EWzGImIZpMTvezry9/uHJ+54xJdqTVXvIqQaaiFKNPejLaF 3lavOt8sR/pnZViA1v7gA7AiTf01dkun8lI2YgIH5tUXAF0psqDM5PfLoLf97vhvx8EP wQtA== X-Gm-Message-State: AOAM532omOP5ByLFClu8nXRpP0UywnFbioB+J0T+dmz/OumJnq2nMSGD L+AwmvmcfFG54vsa13x7MaQ= X-Google-Smtp-Source: ABdhPJyGimAPuKCSRTEHAVrEE59NMqIp9PLTnGsJ602mqHGEDhc4wpic8DIHDnBwnUwF7ELwXKxYQQ== X-Received: by 2002:a05:6402:5242:b0:40f:6a4f:ff33 with SMTP id t2-20020a056402524200b0040f6a4fff33mr23582938edd.30.1645475217030; Mon, 21 Feb 2022 12:26:57 -0800 (PST) Received: from ?IPV6:2003:ea:8f4d:2b00:b141:a0d:4aad:2a06? (p200300ea8f4d2b00b1410a0d4aad2a06.dip0.t-ipconnect.de. [2003:ea:8f4d:2b00:b141:a0d:4aad:2a06]) by smtp.googlemail.com with ESMTPSA id p19sm5562744ejc.42.2022.02.21.12.26.56 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 21 Feb 2022 12:26:56 -0800 (PST) Message-ID: <3facc242-0ce6-9170-1fee-a5ec0a66660a@gmail.com> Date: Mon, 21 Feb 2022 21:25:32 +0100 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.6.1 Subject: [PATCH v2 5/6] auxdisplay: add support for Titanmec TM1628 7 segment display controller Content-Language: en-US From: Heiner Kallweit To: Mark Brown , Rob Herring , Krzysztof Kozlowski , =?UTF-8?Q?Andreas_F=c3=a4rber?= , Geert Uytterhoeven , Miguel Ojeda , Neil Armstrong , Kevin Hilman , Jerome Brunet , Martin Blumenstingl Cc: "linux-spi@vger.kernel.org" , "devicetree@vger.kernel.org" , "linux-arm-kernel@lists.infradead.org" , "open list:ARM/Amlogic Meson..." References: <1f39432b-84e2-e6dc-a6b8-c48ad5cf2210@gmail.com> In-Reply-To: <1f39432b-84e2-e6dc-a6b8-c48ad5cf2210@gmail.com> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org This patch adds support for the Titanmec TM1628 7 segment display controller. It's based on previous RFC work from Andreas Färber. The RFC version placed the driver in the LED subsystem, but this was NAK'ed by the LED maintainer. Therefore I moved the driver to /drivers/auxdisplay what seems most reasonable to me. Further changes to the RFC version: - Driver can be built also w/o LED class support, for displays that don't have any symbols to be exposed as LED's. - Simplified the code and rewrote a lot of it. - Driver is now kind of a MVP, but functionality should be sufficient for most use cases. - Use the existing 7 segment support in uapi/linux/map_to_7segment.h as suggested by Geert Uytterhoeven. Note: There's a number of chips from other manufacturers that are almost identical, e.g. FD628, SM1628. Only difference I saw so far is that they partially support other display modes. TM1628: 6x12, 7x11 SM1628C: 4x13, 5x12, 6x11, 7x10 For typical displays on devices using these chips this difference shouldn't matter. Successfully tested on a TX3 Mini TV box that has an SM1628C and a display with 4 digits and 7 symbols. Tested-by: Christian Hewitt Signed-off-by: Andreas Färber Signed-off-by: Heiner Kallweit --- v2: - include ctype.h explicitly - add info message in probe() - (re-)add Andreas' SoB --- drivers/auxdisplay/Kconfig | 10 + drivers/auxdisplay/Makefile | 1 + drivers/auxdisplay/tm1628.c | 376 ++++++++++++++++++++++++++++++++++++ 3 files changed, 387 insertions(+) create mode 100644 drivers/auxdisplay/tm1628.c diff --git a/drivers/auxdisplay/Kconfig b/drivers/auxdisplay/Kconfig index 64012cda4..25ef2e452 100644 --- a/drivers/auxdisplay/Kconfig +++ b/drivers/auxdisplay/Kconfig @@ -203,6 +203,16 @@ config ARM_CHARLCD line and the Linux version on the second line, but that's still useful. +config TM1628 + tristate "TM1628 driver for LED 7/11 segment displays" + depends on SPI + depends on OF || COMPILE_TEST + help + Say Y to enable support for Titan Micro Electronics TM1628 + LED controller. + It's a 3-wire SPI device controlling a two-dimensional grid of + LEDs. Dimming is applied to all outputs through an internal PWM. + menuconfig PARPORT_PANEL tristate "Parallel port LCD/Keypad Panel support" depends on PARPORT diff --git a/drivers/auxdisplay/Makefile b/drivers/auxdisplay/Makefile index 6968ed4d3..7728e17e1 100644 --- a/drivers/auxdisplay/Makefile +++ b/drivers/auxdisplay/Makefile @@ -14,3 +14,4 @@ obj-$(CONFIG_HT16K33) += ht16k33.o obj-$(CONFIG_PARPORT_PANEL) += panel.o obj-$(CONFIG_LCD2S) += lcd2s.o obj-$(CONFIG_LINEDISP) += line-display.o +obj-$(CONFIG_TM1628) += tm1628.o diff --git a/drivers/auxdisplay/tm1628.c b/drivers/auxdisplay/tm1628.c new file mode 100644 index 000000000..b802b5c30 --- /dev/null +++ b/drivers/auxdisplay/tm1628.c @@ -0,0 +1,376 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Titan Micro Electronics TM1628 LED controller + * + * Copyright (c) 2019 Andreas Färber + */ + +#include +#include +#include +#include +#include +#include +#include + +#define TM1628_CMD_DISPLAY_MODE (0 << 6) +#define TM1628_DISPLAY_MODE_6_12 0x02 +#define TM1628_DISPLAY_MODE_7_11 0x03 + +#define TM1628_CMD_DATA (1 << 6) +#define TM1628_DATA_TEST_MODE BIT(3) +#define TM1628_DATA_FIXED_ADDR BIT(2) +#define TM1628_DATA_WRITE_DATA 0x00 +#define TM1628_DATA_READ_DATA 0x02 + +#define TM1628_CMD_DISPLAY_CTRL (2 << 6) +#define TM1628_DISPLAY_CTRL_DISPLAY_ON BIT(3) + +#define TM1628_CMD_SET_ADDRESS (3 << 6) + +#define TM1628_BRIGHTNESS_MAX 7 + +/* Physical limits, depending on the mode the chip may support less */ +#define MAX_GRID_SIZE 7 +#define MAX_SEGMENT_NUM 16 + +struct tm1628_led { + struct led_classdev leddev; + struct tm1628 *ctrl; + u32 grid; + u32 seg; +}; + +struct tm1628 { + struct spi_device *spi; + __le16 data[MAX_GRID_SIZE]; + struct mutex disp_lock; + char text[MAX_GRID_SIZE + 1]; + u8 segment_mapping[7]; + u8 grid[MAX_GRID_SIZE]; + int grid_size; + struct tm1628_led leds[]; +}; + +/* Command 1: Display Mode Setting */ +static int tm1628_set_display_mode(struct spi_device *spi, u8 grid_mode) +{ + u8 cmd = TM1628_CMD_DISPLAY_MODE | grid_mode; + + return spi_write(spi, &cmd, 1); +} + +/* Command 3: Address Setting */ +static int tm1628_set_address(struct spi_device *spi, u8 offset) +{ + u8 cmd = TM1628_CMD_SET_ADDRESS | (offset * sizeof(__le16)); + + return spi_write(spi, &cmd, 1); +} + +/* Command 2: Data Setting */ +static int tm1628_write_data(struct spi_device *spi, unsigned int offset, + unsigned int len) +{ + struct tm1628 *s = spi_get_drvdata(spi); + u8 cmd = TM1628_CMD_DATA | TM1628_DATA_WRITE_DATA; + struct spi_transfer xfers[] = { + { + .tx_buf = &cmd, + .len = 1, + }, + { + .tx_buf = (__force void *)(s->data + offset), + .len = len * sizeof(__le16), + }, + }; + + if (offset + len > MAX_GRID_SIZE) { + dev_err(&spi->dev, "Invalid data address offset %u len %u\n", + offset, len); + return -EINVAL; + } + + tm1628_set_address(spi, offset); + + return spi_sync_transfer(spi, xfers, ARRAY_SIZE(xfers)); +} + +/* Command 4: Display Control */ +static int tm1628_set_display_ctrl(struct spi_device *spi, bool on) +{ + u8 cmd = TM1628_CMD_DISPLAY_CTRL | TM1628_BRIGHTNESS_MAX; + + if (on) + cmd |= TM1628_DISPLAY_CTRL_DISPLAY_ON; + + return spi_write(spi, &cmd, 1); +} + +static int tm1628_show_text(struct tm1628 *s) +{ + static SEG7_CONVERSION_MAP(map_seg7, MAP_ASCII7SEG_ALPHANUM); + int i, ret; + + int msg_len = strlen(s->text); + + mutex_lock(&s->disp_lock); + + for (i = 0; i < s->grid_size; i++) { + int pos = s->grid[i] - 1; + + if (i < msg_len) { + int char7_raw = map_to_seg7(&map_seg7, s->text[i]); + int j, char7; + + for (j = 0, char7 = 0; j < 7; j++) { + if (char7_raw & BIT(j)) + char7 |= BIT(s->segment_mapping[j] - 1); + } + + s->data[pos] = cpu_to_le16(char7); + } else { + s->data[pos] = 0; + } + } + + ret = tm1628_write_data(s->spi, 0, s->grid_size); + + mutex_unlock(&s->disp_lock); + + return ret; +} + +static int tm1628_led_set_brightness(struct led_classdev *led_cdev, + enum led_brightness brightness) +{ + struct tm1628_led *led = container_of(led_cdev, struct tm1628_led, leddev); + struct tm1628 *s = led->ctrl; + int offset, ret; + __le16 bit; + + offset = led->grid - 1; + bit = cpu_to_le16(BIT(led->seg - 1)); + + mutex_lock(&s->disp_lock); + + if (brightness == LED_OFF) + s->data[offset] &= ~bit; + else + s->data[offset] |= bit; + + ret = tm1628_write_data(s->spi, offset, 1); + + mutex_unlock(&s->disp_lock); + + return ret; +} + +static enum led_brightness tm1628_led_get_brightness(struct led_classdev *led_cdev) +{ + struct tm1628_led *led = container_of(led_cdev, struct tm1628_led, leddev); + struct tm1628 *s = led->ctrl; + int offset; + __le16 bit; + bool on; + + offset = led->grid - 1; + bit = cpu_to_le16(BIT(led->seg - 1)); + + mutex_lock(&s->disp_lock); + on = s->data[offset] & bit; + mutex_unlock(&s->disp_lock); + + return on ? LED_ON : LED_OFF; +} + +static int tm1628_register_led(struct tm1628 *s, struct fwnode_handle *node, + u32 grid, u32 seg, struct tm1628_led *led) +{ + struct device *dev = &s->spi->dev; + struct led_init_data init_data = { .fwnode = node }; + + led->ctrl = s; + led->grid = grid; + led->seg = seg; + led->leddev.max_brightness = LED_ON; + led->leddev.brightness_set_blocking = tm1628_led_set_brightness; + led->leddev.brightness_get = tm1628_led_get_brightness; + + return devm_led_classdev_register_ext(dev, &led->leddev, &init_data); +} + +static ssize_t display_text_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct tm1628 *s = dev_get_drvdata(dev); + + return sysfs_emit(buf, "%s\n", s->text); +} + +static ssize_t display_text_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + struct tm1628 *s = dev_get_drvdata(dev); + int ret, i; + + if (count > s->grid_size + 1) /* consider trailing newline */ + return -E2BIG; + + for (i = 0; i < count && isprint(buf[i]); i++) + s->text[i] = buf[i]; + + s->text[i] = '\0'; + + ret = tm1628_show_text(s); + if (ret < 0) + return ret; + + return count; +} + +static const DEVICE_ATTR_RW(display_text); + +static int tm1628_spi_probe(struct spi_device *spi) +{ + struct fwnode_handle *child; + unsigned int num_leds; + struct tm1628 *s; + int ret, i; + + num_leds = device_get_child_node_count(&spi->dev); + + s = devm_kzalloc(&spi->dev, struct_size(s, leds, num_leds), GFP_KERNEL); + if (!s) + return -ENOMEM; + + s->spi = spi; + spi_set_drvdata(spi, s); + + mutex_init(&s->disp_lock); + + msleep(200); /* according to TM1628 datasheet */ + + /* clear screen */ + ret = tm1628_write_data(spi, 0, MAX_GRID_SIZE); + if (ret) + return ret; + /* Assume that subsequent SPI transfers will be ok if first was ok */ + + /* For now we support 6x12 mode only. This should be sufficient for most use cases */ + tm1628_set_display_mode(spi, TM1628_DISPLAY_MODE_6_12); + + tm1628_set_display_ctrl(spi, true); + + if (!IS_REACHABLE(CONFIG_LEDS_CLASS)) + goto no_leds; + + num_leds = 0; + + device_for_each_child_node(&spi->dev, child) { + u32 reg[2]; + + ret = fwnode_property_read_u32_array(child, "reg", reg, 2); + if (ret) { + dev_err(&spi->dev, "Reading %s reg property failed (%d)\n", + fwnode_get_name(child), ret); + continue; + } + + if (reg[0] == 0 || reg[0] > MAX_GRID_SIZE) { + dev_err(&spi->dev, "Invalid grid %u at %s\n", + reg[0], fwnode_get_name(child)); + continue; + } + + if (reg[1] == 0 || reg[1] > MAX_SEGMENT_NUM) { + dev_err(&spi->dev, "Invalid segment %u at %s\n", + reg[1], fwnode_get_name(child)); + continue; + } + + ret = tm1628_register_led(s, child, reg[0], reg[1], s->leds + num_leds); + if (ret) { + dev_err(&spi->dev, "Failed to register LED %s (%d)\n", + fwnode_get_name(child), ret); + continue; + } + num_leds++; + } + +no_leds: + ret = device_property_count_u8(&spi->dev, "grid"); + if (ret < 1 || ret > MAX_GRID_SIZE) { + dev_err(&spi->dev, "Invalid display length (%d)\n", ret); + return -EINVAL; + } + + s->grid_size = ret; + + ret = device_property_read_u8_array(&spi->dev, "grid", s->grid, s->grid_size); + if (ret < 0) + return ret; + + for (i = 0; i < s->grid_size; i++) { + if (s->grid[i] < 1 || s->grid[i] > s->grid_size) + return -EINVAL; + } + + ret = device_property_read_u8_array(&spi->dev, "segment-mapping", s->segment_mapping, 7); + if (ret < 0) + return ret; + + for (i = 0; i < 7; i++) { + if (s->segment_mapping[i] < 1 || s->segment_mapping[i] > MAX_SEGMENT_NUM) + return -EINVAL; + } + + ret = device_create_file(&spi->dev, &dev_attr_display_text); + if (ret) + return ret; + + dev_info(&spi->dev, "Configured display with %u digits and %u symbols\n", + s->grid_size, num_leds); + + return 0; +} + +static void tm1628_spi_remove(struct spi_device *spi) +{ + device_remove_file(&spi->dev, &dev_attr_display_text); + tm1628_set_display_ctrl(spi, false); +} + +static void tm1628_spi_shutdown(struct spi_device *spi) +{ + tm1628_set_display_ctrl(spi, false); +} + +static const struct of_device_id tm1628_spi_of_matches[] = { + { .compatible = "titanmec,tm1628" }, + {} +}; +MODULE_DEVICE_TABLE(of, tm1628_spi_of_matches); + +static const struct spi_device_id tm1628_spi_id_table[] = { + { "tm1628" }, + {}, +}; +MODULE_DEVICE_TABLE(spi, tm1628_spi_id_table); + +static struct spi_driver tm1628_spi_driver = { + .probe = tm1628_spi_probe, + .remove = tm1628_spi_remove, + .shutdown = tm1628_spi_shutdown, + .id_table = tm1628_spi_id_table, + + .driver = { + .name = "tm1628", + .of_match_table = tm1628_spi_of_matches, + }, +}; +module_spi_driver(tm1628_spi_driver); + +MODULE_DESCRIPTION("TM1628 LED controller driver"); +MODULE_AUTHOR("Andreas Färber"); +MODULE_LICENSE("GPL"); -- 2.35.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id B4E6DC433F5 for ; Mon, 21 Feb 2022 20:28:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:References:Cc:To:From: Subject:MIME-Version:Date:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=bz1Sh+VMP4GUveX21tqXJknx68c8DmY+xKalgOw+lAg=; b=x6KwbKCGq1aYp9 i3Eh2XAIGvQrBNMRWCsEZLuMzVuQc4yOJv2oW52Om2HRBXugmYojjPJrsNaxHjLodCRgcJTAdRZk2 XDzcMVoDz9qDTVTRsSVS6x0iHgxDZggBHtpx55q+2dXKR7G8rfDrH6PYrAxS1uXkq5xZYBYLuKodS VjzzHqscOAgyktPWqngflj8ofj8PsVtq3Tl4L7YC23j66/9jdn7eT4Pegf7PMht+0IssvYhLeBYa2 pZce4H64R75c61LtxAZTGypmYQs+ZRRXz61Mkp1KFyVfQxnqWq1q1PSTnJDPt1tdL0s2Bm6BNetmm y9ARtcyyl34jr5UvzeBw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nMFIF-007Bjz-Et; Mon, 21 Feb 2022 20:28:23 +0000 Received: from mail-ed1-x534.google.com ([2a00:1450:4864:20::534]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nMFGs-007B4B-VC; Mon, 21 Feb 2022 20:27:01 +0000 Received: by mail-ed1-x534.google.com with SMTP id q17so31899596edd.4; Mon, 21 Feb 2022 12:26:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:date:mime-version:user-agent:subject:content-language :from:to:cc:references:in-reply-to:content-transfer-encoding; bh=f54s1QNFfJCjG5iDYvLw8C940im9nMlBHjJVOUqHXNc=; b=fvZOp6+H9iTtbujgBKUPDoxhljH2zNj4zT+xFwml+WCOQkj9OXc5aRIMCYF0s25J0V jdEGI5CYpLOLLlXYCihYVM/AZVN88u+HRPyQAaAnsz748Msoc5t3uQ3ojmHjZVGK1m9F 8sHpWvG5bGpRFTGuRIWaMTlLSgJ3qrva8ZPazKzYdwRCHj125GvRfSaDxu9/29ycggnS BcAXAC6FBVcPDbRVv7lkCrJV4KNoqqhwxa14/wbM+Pl/jGNXbcROL0UuRgPI1HYk7xY+ nWML1VOE61jQt1lLCW/G20mzuznJwyyoaf4va9Jb8nWyGQJl1iAcUPUvv1LccSbl4qlT /p9g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:date:mime-version:user-agent:subject :content-language:from:to:cc:references:in-reply-to :content-transfer-encoding; bh=f54s1QNFfJCjG5iDYvLw8C940im9nMlBHjJVOUqHXNc=; b=g2vYGT4ewwUuWyCvGpt178kYb3gcybULwRtH10I35LTdJto7ysswvM+3sp/CwJyEeb V3jeSSfcz43lB27FjGxg5GEXgqLC+mDnR3VP6bnverlKodA3ldmhl13msZN8cMtY3a1E UucAYBGgr0jKb2HjTQE4vdODK139JkwNxXEnyAYnXNZhGJsHcfgiFORhcw/Zx7I8X1EJ 8Uo93uZEI7AUEg79uYtVbaFZUh6BbQWCUPQXbl4ZAo2z8NIdUZpPXrcgCFMttSsS53hk cqe1JIxo3rGilWGl8BPCF4hMt7jbdY6cpOu1p6WEfXR1qtj2NWtYR5kCD5kx+89WU2p8 ywVQ== X-Gm-Message-State: AOAM530Qqm8SuuGfdzlHVaUsPD40CVAutJxHDOcrEGGY46mxs5usdr34 88xwSHjR1HgbEeo3CWl9Kvk= X-Google-Smtp-Source: ABdhPJyGimAPuKCSRTEHAVrEE59NMqIp9PLTnGsJ602mqHGEDhc4wpic8DIHDnBwnUwF7ELwXKxYQQ== X-Received: by 2002:a05:6402:5242:b0:40f:6a4f:ff33 with SMTP id t2-20020a056402524200b0040f6a4fff33mr23582938edd.30.1645475217030; Mon, 21 Feb 2022 12:26:57 -0800 (PST) Received: from ?IPV6:2003:ea:8f4d:2b00:b141:a0d:4aad:2a06? (p200300ea8f4d2b00b1410a0d4aad2a06.dip0.t-ipconnect.de. [2003:ea:8f4d:2b00:b141:a0d:4aad:2a06]) by smtp.googlemail.com with ESMTPSA id p19sm5562744ejc.42.2022.02.21.12.26.56 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 21 Feb 2022 12:26:56 -0800 (PST) Message-ID: <3facc242-0ce6-9170-1fee-a5ec0a66660a@gmail.com> Date: Mon, 21 Feb 2022 21:25:32 +0100 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.6.1 Subject: [PATCH v2 5/6] auxdisplay: add support for Titanmec TM1628 7 segment display controller Content-Language: en-US From: Heiner Kallweit To: Mark Brown , Rob Herring , Krzysztof Kozlowski , =?UTF-8?Q?Andreas_F=c3=a4rber?= , Geert Uytterhoeven , Miguel Ojeda , Neil Armstrong , Kevin Hilman , Jerome Brunet , Martin Blumenstingl Cc: "linux-spi@vger.kernel.org" , "devicetree@vger.kernel.org" , "linux-arm-kernel@lists.infradead.org" , "open list:ARM/Amlogic Meson..." References: <1f39432b-84e2-e6dc-a6b8-c48ad5cf2210@gmail.com> In-Reply-To: <1f39432b-84e2-e6dc-a6b8-c48ad5cf2210@gmail.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220221_122659_054333_DCD3F27A X-CRM114-Status: GOOD ( 31.26 ) X-BeenThere: linux-amlogic@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-amlogic" Errors-To: linux-amlogic-bounces+linux-amlogic=archiver.kernel.org@lists.infradead.org VGhpcyBwYXRjaCBhZGRzIHN1cHBvcnQgZm9yIHRoZSBUaXRhbm1lYyBUTTE2MjggNyBzZWdtZW50 IGRpc3BsYXkKY29udHJvbGxlci4gSXQncyBiYXNlZCBvbiBwcmV2aW91cyBSRkMgd29yayBmcm9t IEFuZHJlYXMgRsOkcmJlci4KVGhlIFJGQyB2ZXJzaW9uIHBsYWNlZCB0aGUgZHJpdmVyIGluIHRo ZSBMRUQgc3Vic3lzdGVtLCBidXQgdGhpcyB3YXMKTkFLJ2VkIGJ5IHRoZSBMRUQgbWFpbnRhaW5l ci4gVGhlcmVmb3JlIEkgbW92ZWQgdGhlIGRyaXZlciB0bwovZHJpdmVycy9hdXhkaXNwbGF5IHdo YXQgc2VlbXMgbW9zdCByZWFzb25hYmxlIHRvIG1lLgoKRnVydGhlciBjaGFuZ2VzIHRvIHRoZSBS RkMgdmVyc2lvbjoKLSBEcml2ZXIgY2FuIGJlIGJ1aWx0IGFsc28gdy9vIExFRCBjbGFzcyBzdXBw b3J0LCBmb3IgZGlzcGxheXMgdGhhdAogIGRvbid0IGhhdmUgYW55IHN5bWJvbHMgdG8gYmUgZXhw b3NlZCBhcyBMRUQncy4KLSBTaW1wbGlmaWVkIHRoZSBjb2RlIGFuZCByZXdyb3RlIGEgbG90IG9m IGl0LgotIERyaXZlciBpcyBub3cga2luZCBvZiBhIE1WUCwgYnV0IGZ1bmN0aW9uYWxpdHkgc2hv dWxkIGJlIHN1ZmZpY2llbnQKICBmb3IgbW9zdCB1c2UgY2FzZXMuCi0gVXNlIHRoZSBleGlzdGlu ZyA3IHNlZ21lbnQgc3VwcG9ydCBpbiB1YXBpL2xpbnV4L21hcF90b183c2VnbWVudC5oCiAgYXMg c3VnZ2VzdGVkIGJ5IEdlZXJ0IFV5dHRlcmhvZXZlbi4KCk5vdGU6IFRoZXJlJ3MgYSBudW1iZXIg b2YgY2hpcHMgZnJvbSBvdGhlciBtYW51ZmFjdHVyZXJzIHRoYXQgYXJlCiAgICAgIGFsbW9zdCBp ZGVudGljYWwsIGUuZy4gRkQ2MjgsIFNNMTYyOC4gT25seSBkaWZmZXJlbmNlIEkgc2F3IHNvCiAg ICAgIGZhciBpcyB0aGF0IHRoZXkgcGFydGlhbGx5IHN1cHBvcnQgb3RoZXIgZGlzcGxheSBtb2Rl cy4KICAgICAgVE0xNjI4OiA2eDEyLCA3eDExCiAgICAgIFNNMTYyOEM6IDR4MTMsIDV4MTIsIDZ4 MTEsIDd4MTAKICAgICAgRm9yIHR5cGljYWwgZGlzcGxheXMgb24gZGV2aWNlcyB1c2luZyB0aGVz ZSBjaGlwcyB0aGlzCiAgICAgIGRpZmZlcmVuY2Ugc2hvdWxkbid0IG1hdHRlci4KClN1Y2Nlc3Nm dWxseSB0ZXN0ZWQgb24gYSBUWDMgTWluaSBUViBib3ggdGhhdCBoYXMgYW4gU00xNjI4QyBhbmQg YQpkaXNwbGF5IHdpdGggNCBkaWdpdHMgYW5kIDcgc3ltYm9scy4KClRlc3RlZC1ieTogQ2hyaXN0 aWFuIEhld2l0dCA8Y2hyaXN0aWFuc2hld2l0dEBnbWFpbC5jb20+ClNpZ25lZC1vZmYtYnk6IEFu ZHJlYXMgRsOkcmJlciA8YWZhZXJiZXJAc3VzZS5kZT4KU2lnbmVkLW9mZi1ieTogSGVpbmVyIEth bGx3ZWl0IDxoa2FsbHdlaXQxQGdtYWlsLmNvbT4KLS0tCnYyOgotIGluY2x1ZGUgY3R5cGUuaCBl eHBsaWNpdGx5Ci0gYWRkIGluZm8gbWVzc2FnZSBpbiBwcm9iZSgpCi0gKHJlLSlhZGQgQW5kcmVh cycgU29CCi0tLQogZHJpdmVycy9hdXhkaXNwbGF5L0tjb25maWcgIHwgIDEwICsKIGRyaXZlcnMv YXV4ZGlzcGxheS9NYWtlZmlsZSB8ICAgMSArCiBkcml2ZXJzL2F1eGRpc3BsYXkvdG0xNjI4LmMg fCAzNzYgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5n ZWQsIDM4NyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9hdXhkaXNw bGF5L3RtMTYyOC5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdXhkaXNwbGF5L0tjb25maWcgYi9k cml2ZXJzL2F1eGRpc3BsYXkvS2NvbmZpZwppbmRleCA2NDAxMmNkYTQuLjI1ZWYyZTQ1MiAxMDA2 NDQKLS0tIGEvZHJpdmVycy9hdXhkaXNwbGF5L0tjb25maWcKKysrIGIvZHJpdmVycy9hdXhkaXNw bGF5L0tjb25maWcKQEAgLTIwMyw2ICsyMDMsMTYgQEAgY29uZmlnIEFSTV9DSEFSTENECiAJICBs aW5lIGFuZCB0aGUgTGludXggdmVyc2lvbiBvbiB0aGUgc2Vjb25kIGxpbmUsIGJ1dCB0aGF0J3MK IAkgIHN0aWxsIHVzZWZ1bC4KIAorY29uZmlnIFRNMTYyOAorCXRyaXN0YXRlICJUTTE2MjggZHJp dmVyIGZvciBMRUQgNy8xMSBzZWdtZW50IGRpc3BsYXlzIgorCWRlcGVuZHMgb24gU1BJCisJZGVw ZW5kcyBvbiBPRiB8fCBDT01QSUxFX1RFU1QKKwloZWxwCisJICBTYXkgWSB0byBlbmFibGUgc3Vw cG9ydCBmb3IgVGl0YW4gTWljcm8gRWxlY3Ryb25pY3MgVE0xNjI4CisJICBMRUQgY29udHJvbGxl ci4KKwkgIEl0J3MgYSAzLXdpcmUgU1BJIGRldmljZSBjb250cm9sbGluZyBhIHR3by1kaW1lbnNp b25hbCBncmlkIG9mCisJICBMRURzLiBEaW1taW5nIGlzIGFwcGxpZWQgdG8gYWxsIG91dHB1dHMg dGhyb3VnaCBhbiBpbnRlcm5hbCBQV00uCisKIG1lbnVjb25maWcgUEFSUE9SVF9QQU5FTAogCXRy aXN0YXRlICJQYXJhbGxlbCBwb3J0IExDRC9LZXlwYWQgUGFuZWwgc3VwcG9ydCIKIAlkZXBlbmRz IG9uIFBBUlBPUlQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXV4ZGlzcGxheS9NYWtlZmlsZSBiL2Ry aXZlcnMvYXV4ZGlzcGxheS9NYWtlZmlsZQppbmRleCA2OTY4ZWQ0ZDMuLjc3MjhlMTdlMSAxMDA2 NDQKLS0tIGEvZHJpdmVycy9hdXhkaXNwbGF5L01ha2VmaWxlCisrKyBiL2RyaXZlcnMvYXV4ZGlz cGxheS9NYWtlZmlsZQpAQCAtMTQsMyArMTQsNCBAQCBvYmotJChDT05GSUdfSFQxNkszMykJCSs9 IGh0MTZrMzMubwogb2JqLSQoQ09ORklHX1BBUlBPUlRfUEFORUwpCSs9IHBhbmVsLm8KIG9iai0k KENPTkZJR19MQ0QyUykJCSs9IGxjZDJzLm8KIG9iai0kKENPTkZJR19MSU5FRElTUCkJCSs9IGxp bmUtZGlzcGxheS5vCitvYmotJChDT05GSUdfVE0xNjI4KQkJKz0gdG0xNjI4Lm8KZGlmZiAtLWdp dCBhL2RyaXZlcnMvYXV4ZGlzcGxheS90bTE2MjguYyBiL2RyaXZlcnMvYXV4ZGlzcGxheS90bTE2 MjguYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAuLmI4MDJiNWMzMAotLS0g L2Rldi9udWxsCisrKyBiL2RyaXZlcnMvYXV4ZGlzcGxheS90bTE2MjguYwpAQCAtMCwwICsxLDM3 NiBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb3ItbGF0ZXIKKy8qCisg KiBUaXRhbiBNaWNybyBFbGVjdHJvbmljcyBUTTE2MjggTEVEIGNvbnRyb2xsZXIKKyAqCisgKiBD b3B5cmlnaHQgKGMpIDIwMTkgQW5kcmVhcyBGw6RyYmVyCisgKi8KKworI2luY2x1ZGUgPGxpbnV4 L2N0eXBlLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9sZWRz Lmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvcHJvcGVydHku aD4KKyNpbmNsdWRlIDxsaW51eC9zcGkvc3BpLmg+CisjaW5jbHVkZSA8dWFwaS9saW51eC9tYXBf dG9fN3NlZ21lbnQuaD4KKworI2RlZmluZSBUTTE2MjhfQ01EX0RJU1BMQVlfTU9ERQkJKDAgPDwg NikKKyNkZWZpbmUgVE0xNjI4X0RJU1BMQVlfTU9ERV82XzEyCTB4MDIKKyNkZWZpbmUgVE0xNjI4 X0RJU1BMQVlfTU9ERV83XzExCTB4MDMKKworI2RlZmluZSBUTTE2MjhfQ01EX0RBVEEJCQkoMSA8 PCA2KQorI2RlZmluZSBUTTE2MjhfREFUQV9URVNUX01PREUJCUJJVCgzKQorI2RlZmluZSBUTTE2 MjhfREFUQV9GSVhFRF9BRERSCQlCSVQoMikKKyNkZWZpbmUgVE0xNjI4X0RBVEFfV1JJVEVfREFU QQkJMHgwMAorI2RlZmluZSBUTTE2MjhfREFUQV9SRUFEX0RBVEEJCTB4MDIKKworI2RlZmluZSBU TTE2MjhfQ01EX0RJU1BMQVlfQ1RSTAkJKDIgPDwgNikKKyNkZWZpbmUgVE0xNjI4X0RJU1BMQVlf Q1RSTF9ESVNQTEFZX09OCUJJVCgzKQorCisjZGVmaW5lIFRNMTYyOF9DTURfU0VUX0FERFJFU1MJ CSgzIDw8IDYpCisKKyNkZWZpbmUgVE0xNjI4X0JSSUdIVE5FU1NfTUFYCQk3CisKKy8qIFBoeXNp Y2FsIGxpbWl0cywgZGVwZW5kaW5nIG9uIHRoZSBtb2RlIHRoZSBjaGlwIG1heSBzdXBwb3J0IGxl c3MgKi8KKyNkZWZpbmUgTUFYX0dSSURfU0laRQkJCTcKKyNkZWZpbmUgTUFYX1NFR01FTlRfTlVN CQkJMTYKKworc3RydWN0IHRtMTYyOF9sZWQgeworCXN0cnVjdCBsZWRfY2xhc3NkZXYJbGVkZGV2 OworCXN0cnVjdCB0bTE2MjgJCSpjdHJsOworCXUzMgkJCWdyaWQ7CisJdTMyCQkJc2VnOworfTsK Kworc3RydWN0IHRtMTYyOCB7CisJc3RydWN0IHNwaV9kZXZpY2UJCSpzcGk7CisJX19sZTE2CQkJ CWRhdGFbTUFYX0dSSURfU0laRV07CisJc3RydWN0IG11dGV4CQkJZGlzcF9sb2NrOworCWNoYXIJ CQkJdGV4dFtNQVhfR1JJRF9TSVpFICsgMV07CisJdTgJCQkJc2VnbWVudF9tYXBwaW5nWzddOwor CXU4CQkJCWdyaWRbTUFYX0dSSURfU0laRV07CisJaW50CQkJCWdyaWRfc2l6ZTsKKwlzdHJ1Y3Qg dG0xNjI4X2xlZAkJbGVkc1tdOworfTsKKworLyogQ29tbWFuZCAxOiBEaXNwbGF5IE1vZGUgU2V0 dGluZyAqLworc3RhdGljIGludCB0bTE2Mjhfc2V0X2Rpc3BsYXlfbW9kZShzdHJ1Y3Qgc3BpX2Rl dmljZSAqc3BpLCB1OCBncmlkX21vZGUpCit7CisJdTggY21kID0gVE0xNjI4X0NNRF9ESVNQTEFZ X01PREUgfCBncmlkX21vZGU7CisKKwlyZXR1cm4gc3BpX3dyaXRlKHNwaSwgJmNtZCwgMSk7Cit9 CisKKy8qIENvbW1hbmQgMzogQWRkcmVzcyBTZXR0aW5nICovCitzdGF0aWMgaW50IHRtMTYyOF9z ZXRfYWRkcmVzcyhzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpLCB1OCBvZmZzZXQpCit7CisJdTggY21k ID0gVE0xNjI4X0NNRF9TRVRfQUREUkVTUyB8IChvZmZzZXQgKiBzaXplb2YoX19sZTE2KSk7CisK KwlyZXR1cm4gc3BpX3dyaXRlKHNwaSwgJmNtZCwgMSk7Cit9CisKKy8qIENvbW1hbmQgMjogRGF0 YSBTZXR0aW5nICovCitzdGF0aWMgaW50IHRtMTYyOF93cml0ZV9kYXRhKHN0cnVjdCBzcGlfZGV2 aWNlICpzcGksIHVuc2lnbmVkIGludCBvZmZzZXQsCisJCQkgICAgIHVuc2lnbmVkIGludCBsZW4p Cit7CisJc3RydWN0IHRtMTYyOCAqcyA9IHNwaV9nZXRfZHJ2ZGF0YShzcGkpOworCXU4IGNtZCA9 IFRNMTYyOF9DTURfREFUQSB8IFRNMTYyOF9EQVRBX1dSSVRFX0RBVEE7CisJc3RydWN0IHNwaV90 cmFuc2ZlciB4ZmVyc1tdID0geworCQl7CisJCQkudHhfYnVmID0gJmNtZCwKKwkJCS5sZW4gPSAx LAorCQl9LAorCQl7CisJCQkudHhfYnVmID0gKF9fZm9yY2Ugdm9pZCAqKShzLT5kYXRhICsgb2Zm c2V0KSwKKwkJCS5sZW4gPSBsZW4gKiBzaXplb2YoX19sZTE2KSwKKwkJfSwKKwl9OworCisJaWYg KG9mZnNldCArIGxlbiA+IE1BWF9HUklEX1NJWkUpIHsKKwkJZGV2X2Vycigmc3BpLT5kZXYsICJJ bnZhbGlkIGRhdGEgYWRkcmVzcyBvZmZzZXQgJXUgbGVuICV1XG4iLAorCQkJb2Zmc2V0LCBsZW4p OworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwl0bTE2Mjhfc2V0X2FkZHJlc3Moc3BpLCBvZmZz ZXQpOworCisJcmV0dXJuIHNwaV9zeW5jX3RyYW5zZmVyKHNwaSwgeGZlcnMsIEFSUkFZX1NJWkUo eGZlcnMpKTsKK30KKworLyogQ29tbWFuZCA0OiBEaXNwbGF5IENvbnRyb2wgKi8KK3N0YXRpYyBp bnQgdG0xNjI4X3NldF9kaXNwbGF5X2N0cmwoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSwgYm9vbCBv bikKK3sKKwl1OCBjbWQgPSBUTTE2MjhfQ01EX0RJU1BMQVlfQ1RSTCB8IFRNMTYyOF9CUklHSFRO RVNTX01BWDsKKworCWlmIChvbikKKwkJY21kIHw9IFRNMTYyOF9ESVNQTEFZX0NUUkxfRElTUExB WV9PTjsKKworCXJldHVybiBzcGlfd3JpdGUoc3BpLCAmY21kLCAxKTsKK30KKworc3RhdGljIGlu dCB0bTE2Mjhfc2hvd190ZXh0KHN0cnVjdCB0bTE2MjggKnMpCit7CisJc3RhdGljIFNFRzdfQ09O VkVSU0lPTl9NQVAobWFwX3NlZzcsIE1BUF9BU0NJSTdTRUdfQUxQSEFOVU0pOworCWludCBpLCBy ZXQ7CisKKwlpbnQgbXNnX2xlbiA9IHN0cmxlbihzLT50ZXh0KTsKKworCW11dGV4X2xvY2soJnMt PmRpc3BfbG9jayk7CisKKwlmb3IgKGkgPSAwOyBpIDwgcy0+Z3JpZF9zaXplOyBpKyspIHsKKwkJ aW50IHBvcyA9IHMtPmdyaWRbaV0gLSAxOworCisJCWlmIChpIDwgbXNnX2xlbikgeworCQkJaW50 IGNoYXI3X3JhdyA9IG1hcF90b19zZWc3KCZtYXBfc2VnNywgcy0+dGV4dFtpXSk7CisJCQlpbnQg aiwgY2hhcjc7CisKKwkJCWZvciAoaiA9IDAsIGNoYXI3ID0gMDsgaiA8IDc7IGorKykgeworCQkJ CWlmIChjaGFyN19yYXcgJiBCSVQoaikpCisJCQkJCWNoYXI3IHw9IEJJVChzLT5zZWdtZW50X21h cHBpbmdbal0gLSAxKTsKKwkJCX0KKworCQkJcy0+ZGF0YVtwb3NdID0gY3B1X3RvX2xlMTYoY2hh cjcpOworCQl9IGVsc2UgeworCQkJcy0+ZGF0YVtwb3NdID0gMDsKKwkJfQorCX0KKworCXJldCA9 IHRtMTYyOF93cml0ZV9kYXRhKHMtPnNwaSwgMCwgcy0+Z3JpZF9zaXplKTsKKworCW11dGV4X3Vu bG9jaygmcy0+ZGlzcF9sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgdG0x NjI4X2xlZF9zZXRfYnJpZ2h0bmVzcyhzdHJ1Y3QgbGVkX2NsYXNzZGV2ICpsZWRfY2RldiwKKwkJ CQkgICAgIGVudW0gbGVkX2JyaWdodG5lc3MgYnJpZ2h0bmVzcykKK3sKKwlzdHJ1Y3QgdG0xNjI4 X2xlZCAqbGVkID0gY29udGFpbmVyX29mKGxlZF9jZGV2LCBzdHJ1Y3QgdG0xNjI4X2xlZCwgbGVk ZGV2KTsKKwlzdHJ1Y3QgdG0xNjI4ICpzID0gbGVkLT5jdHJsOworCWludCBvZmZzZXQsIHJldDsK KwlfX2xlMTYgYml0OworCisJb2Zmc2V0ID0gbGVkLT5ncmlkIC0gMTsKKwliaXQgPSBjcHVfdG9f bGUxNihCSVQobGVkLT5zZWcgLSAxKSk7CisKKwltdXRleF9sb2NrKCZzLT5kaXNwX2xvY2spOwor CisJaWYgKGJyaWdodG5lc3MgPT0gTEVEX09GRikKKwkJcy0+ZGF0YVtvZmZzZXRdICY9IH5iaXQ7 CisJZWxzZQorCQlzLT5kYXRhW29mZnNldF0gfD0gYml0OworCisJcmV0ID0gdG0xNjI4X3dyaXRl X2RhdGEocy0+c3BpLCBvZmZzZXQsIDEpOworCisJbXV0ZXhfdW5sb2NrKCZzLT5kaXNwX2xvY2sp OworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGVudW0gbGVkX2JyaWdodG5lc3MgdG0xNjI4 X2xlZF9nZXRfYnJpZ2h0bmVzcyhzdHJ1Y3QgbGVkX2NsYXNzZGV2ICpsZWRfY2RldikKK3sKKwlz dHJ1Y3QgdG0xNjI4X2xlZCAqbGVkID0gY29udGFpbmVyX29mKGxlZF9jZGV2LCBzdHJ1Y3QgdG0x NjI4X2xlZCwgbGVkZGV2KTsKKwlzdHJ1Y3QgdG0xNjI4ICpzID0gbGVkLT5jdHJsOworCWludCBv ZmZzZXQ7CisJX19sZTE2IGJpdDsKKwlib29sIG9uOworCisJb2Zmc2V0ID0gbGVkLT5ncmlkIC0g MTsKKwliaXQgPSBjcHVfdG9fbGUxNihCSVQobGVkLT5zZWcgLSAxKSk7CisKKwltdXRleF9sb2Nr KCZzLT5kaXNwX2xvY2spOworCW9uID0gcy0+ZGF0YVtvZmZzZXRdICYgYml0OworCW11dGV4X3Vu bG9jaygmcy0+ZGlzcF9sb2NrKTsKKworCXJldHVybiBvbiA/IExFRF9PTiA6IExFRF9PRkY7Cit9 CisKK3N0YXRpYyBpbnQgdG0xNjI4X3JlZ2lzdGVyX2xlZChzdHJ1Y3QgdG0xNjI4ICpzLCBzdHJ1 Y3QgZndub2RlX2hhbmRsZSAqbm9kZSwKKwkJCSAgICAgICB1MzIgZ3JpZCwgdTMyIHNlZywgc3Ry dWN0IHRtMTYyOF9sZWQgKmxlZCkKK3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcy0+c3BpLT5k ZXY7CisJc3RydWN0IGxlZF9pbml0X2RhdGEgaW5pdF9kYXRhID0geyAuZndub2RlID0gbm9kZSB9 OworCisJbGVkLT5jdHJsID0gczsKKwlsZWQtPmdyaWQgPSBncmlkOworCWxlZC0+c2VnICA9IHNl ZzsKKwlsZWQtPmxlZGRldi5tYXhfYnJpZ2h0bmVzcyA9IExFRF9PTjsKKwlsZWQtPmxlZGRldi5i cmlnaHRuZXNzX3NldF9ibG9ja2luZyA9IHRtMTYyOF9sZWRfc2V0X2JyaWdodG5lc3M7CisJbGVk LT5sZWRkZXYuYnJpZ2h0bmVzc19nZXQgPSB0bTE2MjhfbGVkX2dldF9icmlnaHRuZXNzOworCisJ cmV0dXJuIGRldm1fbGVkX2NsYXNzZGV2X3JlZ2lzdGVyX2V4dChkZXYsICZsZWQtPmxlZGRldiwg JmluaXRfZGF0YSk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IGRpc3BsYXlfdGV4dF9zaG93KHN0cnVj dCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCisJCQkJIGNoYXIg KmJ1ZikKK3sKKwlzdHJ1Y3QgdG0xNjI4ICpzID0gZGV2X2dldF9kcnZkYXRhKGRldik7CisKKwly ZXR1cm4gc3lzZnNfZW1pdChidWYsICIlc1xuIiwgcy0+dGV4dCk7Cit9CisKK3N0YXRpYyBzc2l6 ZV90IGRpc3BsYXlfdGV4dF9zdG9yZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2Vf YXR0cmlidXRlICphdHRyLAorCQkJCSAgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7 CisJc3RydWN0IHRtMTYyOCAqcyA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOworCWludCByZXQsIGk7 CisKKwlpZiAoY291bnQgPiBzLT5ncmlkX3NpemUgKyAxKSAvKiBjb25zaWRlciB0cmFpbGluZyBu ZXdsaW5lICovCisJCXJldHVybiAtRTJCSUc7CisKKwlmb3IgKGkgPSAwOyBpIDwgY291bnQgJiYg aXNwcmludChidWZbaV0pOyBpKyspCisJCXMtPnRleHRbaV0gPSBidWZbaV07CisKKwlzLT50ZXh0 W2ldID0gJ1wwJzsKKworCXJldCA9IHRtMTYyOF9zaG93X3RleHQocyk7CisJaWYgKHJldCA8IDAp CisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gY291bnQ7Cit9CisKK3N0YXRpYyBjb25zdCBERVZJ Q0VfQVRUUl9SVyhkaXNwbGF5X3RleHQpOworCitzdGF0aWMgaW50IHRtMTYyOF9zcGlfcHJvYmUo c3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKK3sKKwlzdHJ1Y3QgZndub2RlX2hhbmRsZSAqY2hpbGQ7 CisJdW5zaWduZWQgaW50IG51bV9sZWRzOworCXN0cnVjdCB0bTE2MjggKnM7CisJaW50IHJldCwg aTsKKworCW51bV9sZWRzID0gZGV2aWNlX2dldF9jaGlsZF9ub2RlX2NvdW50KCZzcGktPmRldik7 CisKKwlzID0gZGV2bV9remFsbG9jKCZzcGktPmRldiwgc3RydWN0X3NpemUocywgbGVkcywgbnVt X2xlZHMpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXMpCisJCXJldHVybiAtRU5PTUVNOworCisJcy0+ c3BpID0gc3BpOworCXNwaV9zZXRfZHJ2ZGF0YShzcGksIHMpOworCisJbXV0ZXhfaW5pdCgmcy0+ ZGlzcF9sb2NrKTsKKworCW1zbGVlcCgyMDApOyAvKiBhY2NvcmRpbmcgdG8gVE0xNjI4IGRhdGFz aGVldCAqLworCisJLyogY2xlYXIgc2NyZWVuICovCisJcmV0ID0gdG0xNjI4X3dyaXRlX2RhdGEo c3BpLCAwLCBNQVhfR1JJRF9TSVpFKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCS8qIEFz c3VtZSB0aGF0IHN1YnNlcXVlbnQgU1BJIHRyYW5zZmVycyB3aWxsIGJlIG9rIGlmIGZpcnN0IHdh cyBvayAqLworCisJLyogRm9yIG5vdyB3ZSBzdXBwb3J0IDZ4MTIgbW9kZSBvbmx5LiBUaGlzIHNo b3VsZCBiZSBzdWZmaWNpZW50IGZvciBtb3N0IHVzZSBjYXNlcyAqLworCXRtMTYyOF9zZXRfZGlz cGxheV9tb2RlKHNwaSwgVE0xNjI4X0RJU1BMQVlfTU9ERV82XzEyKTsKKworCXRtMTYyOF9zZXRf ZGlzcGxheV9jdHJsKHNwaSwgdHJ1ZSk7CisKKwlpZiAoIUlTX1JFQUNIQUJMRShDT05GSUdfTEVE U19DTEFTUykpCisJCWdvdG8gbm9fbGVkczsKKworCW51bV9sZWRzID0gMDsKKworCWRldmljZV9m b3JfZWFjaF9jaGlsZF9ub2RlKCZzcGktPmRldiwgY2hpbGQpIHsKKwkJdTMyIHJlZ1syXTsKKwor CQlyZXQgPSBmd25vZGVfcHJvcGVydHlfcmVhZF91MzJfYXJyYXkoY2hpbGQsICJyZWciLCByZWcs IDIpOworCQlpZiAocmV0KSB7CisJCQlkZXZfZXJyKCZzcGktPmRldiwgIlJlYWRpbmcgJXMgcmVn IHByb3BlcnR5IGZhaWxlZCAoJWQpXG4iLAorCQkJCWZ3bm9kZV9nZXRfbmFtZShjaGlsZCksIHJl dCk7CisJCQljb250aW51ZTsKKwkJfQorCisJCWlmIChyZWdbMF0gPT0gMCB8fCByZWdbMF0gPiBN QVhfR1JJRF9TSVpFKSB7CisJCQlkZXZfZXJyKCZzcGktPmRldiwgIkludmFsaWQgZ3JpZCAldSBh dCAlc1xuIiwKKwkJCQlyZWdbMF0sIGZ3bm9kZV9nZXRfbmFtZShjaGlsZCkpOworCQkJY29udGlu dWU7CisJCX0KKworCQlpZiAocmVnWzFdID09IDAgfHwgcmVnWzFdID4gTUFYX1NFR01FTlRfTlVN KSB7CisJCQlkZXZfZXJyKCZzcGktPmRldiwgIkludmFsaWQgc2VnbWVudCAldSBhdCAlc1xuIiwK KwkJCQlyZWdbMV0sIGZ3bm9kZV9nZXRfbmFtZShjaGlsZCkpOworCQkJY29udGludWU7CisJCX0K KworCQlyZXQgPSB0bTE2MjhfcmVnaXN0ZXJfbGVkKHMsIGNoaWxkLCByZWdbMF0sIHJlZ1sxXSwg cy0+bGVkcyArIG51bV9sZWRzKTsKKwkJaWYgKHJldCkgeworCQkJZGV2X2Vycigmc3BpLT5kZXYs ICJGYWlsZWQgdG8gcmVnaXN0ZXIgTEVEICVzICglZClcbiIsCisJCQkJZndub2RlX2dldF9uYW1l KGNoaWxkKSwgcmV0KTsKKwkJCWNvbnRpbnVlOworCQl9CisJCW51bV9sZWRzKys7CisJfQorCitu b19sZWRzOgorCXJldCA9IGRldmljZV9wcm9wZXJ0eV9jb3VudF91OCgmc3BpLT5kZXYsICJncmlk Iik7CisJaWYgKHJldCA8IDEgfHwgcmV0ID4gTUFYX0dSSURfU0laRSkgeworCQlkZXZfZXJyKCZz cGktPmRldiwgIkludmFsaWQgZGlzcGxheSBsZW5ndGggKCVkKVxuIiwgcmV0KTsKKwkJcmV0dXJu IC1FSU5WQUw7CisJfQorCisJcy0+Z3JpZF9zaXplID0gcmV0OworCisJcmV0ID0gZGV2aWNlX3By b3BlcnR5X3JlYWRfdThfYXJyYXkoJnNwaS0+ZGV2LCAiZ3JpZCIsIHMtPmdyaWQsIHMtPmdyaWRf c2l6ZSk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlmb3IgKGkgPSAwOyBpIDwg cy0+Z3JpZF9zaXplOyBpKyspIHsKKwkJaWYgKHMtPmdyaWRbaV0gPCAxIHx8IHMtPmdyaWRbaV0g PiBzLT5ncmlkX3NpemUpCisJCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlyZXQgPSBkZXZpY2Vf cHJvcGVydHlfcmVhZF91OF9hcnJheSgmc3BpLT5kZXYsICJzZWdtZW50LW1hcHBpbmciLCBzLT5z ZWdtZW50X21hcHBpbmcsIDcpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJZm9y IChpID0gMDsgaSA8IDc7IGkrKykgeworCQlpZiAocy0+c2VnbWVudF9tYXBwaW5nW2ldIDwgMSB8 fCBzLT5zZWdtZW50X21hcHBpbmdbaV0gPiBNQVhfU0VHTUVOVF9OVU0pCisJCQlyZXR1cm4gLUVJ TlZBTDsKKwl9CisKKwlyZXQgPSBkZXZpY2VfY3JlYXRlX2ZpbGUoJnNwaS0+ZGV2LCAmZGV2X2F0 dHJfZGlzcGxheV90ZXh0KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJZGV2X2luZm8o JnNwaS0+ZGV2LCAiQ29uZmlndXJlZCBkaXNwbGF5IHdpdGggJXUgZGlnaXRzIGFuZCAldSBzeW1i b2xzXG4iLAorCQkgcy0+Z3JpZF9zaXplLCBudW1fbGVkcyk7CisKKwlyZXR1cm4gMDsKK30KKwor c3RhdGljIHZvaWQgdG0xNjI4X3NwaV9yZW1vdmUoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKK3sK KwlkZXZpY2VfcmVtb3ZlX2ZpbGUoJnNwaS0+ZGV2LCAmZGV2X2F0dHJfZGlzcGxheV90ZXh0KTsK Kwl0bTE2Mjhfc2V0X2Rpc3BsYXlfY3RybChzcGksIGZhbHNlKTsKK30KKworc3RhdGljIHZvaWQg dG0xNjI4X3NwaV9zaHV0ZG93bihzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpKQoreworCXRtMTYyOF9z ZXRfZGlzcGxheV9jdHJsKHNwaSwgZmFsc2UpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IG9m X2RldmljZV9pZCB0bTE2Mjhfc3BpX29mX21hdGNoZXNbXSA9IHsKKwl7IC5jb21wYXRpYmxlID0g InRpdGFubWVjLHRtMTYyOCIgfSwKKwl7fQorfTsKK01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIHRt MTYyOF9zcGlfb2ZfbWF0Y2hlcyk7CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc3BpX2RldmljZV9p ZCB0bTE2Mjhfc3BpX2lkX3RhYmxlW10gPSB7CisJeyAidG0xNjI4IiB9LAorCXt9LAorfTsKK01P RFVMRV9ERVZJQ0VfVEFCTEUoc3BpLCB0bTE2Mjhfc3BpX2lkX3RhYmxlKTsKKworc3RhdGljIHN0 cnVjdCBzcGlfZHJpdmVyIHRtMTYyOF9zcGlfZHJpdmVyID0geworCS5wcm9iZSA9IHRtMTYyOF9z cGlfcHJvYmUsCisJLnJlbW92ZSA9IHRtMTYyOF9zcGlfcmVtb3ZlLAorCS5zaHV0ZG93biA9IHRt MTYyOF9zcGlfc2h1dGRvd24sCisJLmlkX3RhYmxlID0gdG0xNjI4X3NwaV9pZF90YWJsZSwKKwor CS5kcml2ZXIgPSB7CisJCS5uYW1lID0gInRtMTYyOCIsCisJCS5vZl9tYXRjaF90YWJsZSA9IHRt MTYyOF9zcGlfb2ZfbWF0Y2hlcywKKwl9LAorfTsKK21vZHVsZV9zcGlfZHJpdmVyKHRtMTYyOF9z cGlfZHJpdmVyKTsKKworTU9EVUxFX0RFU0NSSVBUSU9OKCJUTTE2MjggTEVEIGNvbnRyb2xsZXIg ZHJpdmVyIik7CitNT0RVTEVfQVVUSE9SKCJBbmRyZWFzIEbDpHJiZXIiKTsKK01PRFVMRV9MSUNF TlNFKCJHUEwiKTsKLS0gCjIuMzUuMQoKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpsaW51eC1hbWxvZ2ljIG1haWxpbmcgbGlzdApsaW51eC1hbWxvZ2lj QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9s aXN0aW5mby9saW51eC1hbWxvZ2ljCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 465BEC433EF for ; Mon, 21 Feb 2022 20:29:24 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:References:Cc:To:From: Subject:MIME-Version:Date:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=L7oRqIUGFUGPrmEAKqfHaAL0Gk+91OZHrpSCTAoos/M=; b=DkAXONVCYsFSlm 9htHIbSErZd258HAIFvK3/lHT/jQB/Ndj4NmXv0JW1hlEO0x3jBUu1B/OpoBnGhLfb19sWb1xdgN7 hWRuvPi4c9cFlje61P1x1PfavHADPQCZ5vpxW/ucuOs9EuzQYt+d1FV+bCM7eRzicLAoA7DewWxHc 4vFGJG5LCuJrnDFGbrf4QJ4EnaN1O/KBcO/jCqdRH+Y7YQvamqKbY6jtU0RTmhG+t+7PEsvne/z9n 72W2Tk5dwoz1XNvOUYuMA2Wb+LYc7y3FGyrW8HYmpcNaAMfZXK+sQRJGeWLt+p0L5kvbEQFa1K5bs Q1EQ4Apfsgxem77AZhHw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nMFHt-007BUU-4u; Mon, 21 Feb 2022 20:28:01 +0000 Received: from mail-ed1-x534.google.com ([2a00:1450:4864:20::534]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nMFGs-007B4B-VC; Mon, 21 Feb 2022 20:27:01 +0000 Received: by mail-ed1-x534.google.com with SMTP id q17so31899596edd.4; Mon, 21 Feb 2022 12:26:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:date:mime-version:user-agent:subject:content-language :from:to:cc:references:in-reply-to:content-transfer-encoding; bh=f54s1QNFfJCjG5iDYvLw8C940im9nMlBHjJVOUqHXNc=; b=fvZOp6+H9iTtbujgBKUPDoxhljH2zNj4zT+xFwml+WCOQkj9OXc5aRIMCYF0s25J0V jdEGI5CYpLOLLlXYCihYVM/AZVN88u+HRPyQAaAnsz748Msoc5t3uQ3ojmHjZVGK1m9F 8sHpWvG5bGpRFTGuRIWaMTlLSgJ3qrva8ZPazKzYdwRCHj125GvRfSaDxu9/29ycggnS BcAXAC6FBVcPDbRVv7lkCrJV4KNoqqhwxa14/wbM+Pl/jGNXbcROL0UuRgPI1HYk7xY+ nWML1VOE61jQt1lLCW/G20mzuznJwyyoaf4va9Jb8nWyGQJl1iAcUPUvv1LccSbl4qlT /p9g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:date:mime-version:user-agent:subject :content-language:from:to:cc:references:in-reply-to :content-transfer-encoding; bh=f54s1QNFfJCjG5iDYvLw8C940im9nMlBHjJVOUqHXNc=; b=g2vYGT4ewwUuWyCvGpt178kYb3gcybULwRtH10I35LTdJto7ysswvM+3sp/CwJyEeb V3jeSSfcz43lB27FjGxg5GEXgqLC+mDnR3VP6bnverlKodA3ldmhl13msZN8cMtY3a1E UucAYBGgr0jKb2HjTQE4vdODK139JkwNxXEnyAYnXNZhGJsHcfgiFORhcw/Zx7I8X1EJ 8Uo93uZEI7AUEg79uYtVbaFZUh6BbQWCUPQXbl4ZAo2z8NIdUZpPXrcgCFMttSsS53hk cqe1JIxo3rGilWGl8BPCF4hMt7jbdY6cpOu1p6WEfXR1qtj2NWtYR5kCD5kx+89WU2p8 ywVQ== X-Gm-Message-State: AOAM530Qqm8SuuGfdzlHVaUsPD40CVAutJxHDOcrEGGY46mxs5usdr34 88xwSHjR1HgbEeo3CWl9Kvk= X-Google-Smtp-Source: ABdhPJyGimAPuKCSRTEHAVrEE59NMqIp9PLTnGsJ602mqHGEDhc4wpic8DIHDnBwnUwF7ELwXKxYQQ== X-Received: by 2002:a05:6402:5242:b0:40f:6a4f:ff33 with SMTP id t2-20020a056402524200b0040f6a4fff33mr23582938edd.30.1645475217030; Mon, 21 Feb 2022 12:26:57 -0800 (PST) Received: from ?IPV6:2003:ea:8f4d:2b00:b141:a0d:4aad:2a06? (p200300ea8f4d2b00b1410a0d4aad2a06.dip0.t-ipconnect.de. [2003:ea:8f4d:2b00:b141:a0d:4aad:2a06]) by smtp.googlemail.com with ESMTPSA id p19sm5562744ejc.42.2022.02.21.12.26.56 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 21 Feb 2022 12:26:56 -0800 (PST) Message-ID: <3facc242-0ce6-9170-1fee-a5ec0a66660a@gmail.com> Date: Mon, 21 Feb 2022 21:25:32 +0100 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.6.1 Subject: [PATCH v2 5/6] auxdisplay: add support for Titanmec TM1628 7 segment display controller Content-Language: en-US From: Heiner Kallweit To: Mark Brown , Rob Herring , Krzysztof Kozlowski , =?UTF-8?Q?Andreas_F=c3=a4rber?= , Geert Uytterhoeven , Miguel Ojeda , Neil Armstrong , Kevin Hilman , Jerome Brunet , Martin Blumenstingl Cc: "linux-spi@vger.kernel.org" , "devicetree@vger.kernel.org" , "linux-arm-kernel@lists.infradead.org" , "open list:ARM/Amlogic Meson..." References: <1f39432b-84e2-e6dc-a6b8-c48ad5cf2210@gmail.com> In-Reply-To: <1f39432b-84e2-e6dc-a6b8-c48ad5cf2210@gmail.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220221_122659_054333_DCD3F27A X-CRM114-Status: GOOD ( 31.26 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org VGhpcyBwYXRjaCBhZGRzIHN1cHBvcnQgZm9yIHRoZSBUaXRhbm1lYyBUTTE2MjggNyBzZWdtZW50 IGRpc3BsYXkKY29udHJvbGxlci4gSXQncyBiYXNlZCBvbiBwcmV2aW91cyBSRkMgd29yayBmcm9t IEFuZHJlYXMgRsOkcmJlci4KVGhlIFJGQyB2ZXJzaW9uIHBsYWNlZCB0aGUgZHJpdmVyIGluIHRo ZSBMRUQgc3Vic3lzdGVtLCBidXQgdGhpcyB3YXMKTkFLJ2VkIGJ5IHRoZSBMRUQgbWFpbnRhaW5l ci4gVGhlcmVmb3JlIEkgbW92ZWQgdGhlIGRyaXZlciB0bwovZHJpdmVycy9hdXhkaXNwbGF5IHdo YXQgc2VlbXMgbW9zdCByZWFzb25hYmxlIHRvIG1lLgoKRnVydGhlciBjaGFuZ2VzIHRvIHRoZSBS RkMgdmVyc2lvbjoKLSBEcml2ZXIgY2FuIGJlIGJ1aWx0IGFsc28gdy9vIExFRCBjbGFzcyBzdXBw b3J0LCBmb3IgZGlzcGxheXMgdGhhdAogIGRvbid0IGhhdmUgYW55IHN5bWJvbHMgdG8gYmUgZXhw b3NlZCBhcyBMRUQncy4KLSBTaW1wbGlmaWVkIHRoZSBjb2RlIGFuZCByZXdyb3RlIGEgbG90IG9m IGl0LgotIERyaXZlciBpcyBub3cga2luZCBvZiBhIE1WUCwgYnV0IGZ1bmN0aW9uYWxpdHkgc2hv dWxkIGJlIHN1ZmZpY2llbnQKICBmb3IgbW9zdCB1c2UgY2FzZXMuCi0gVXNlIHRoZSBleGlzdGlu ZyA3IHNlZ21lbnQgc3VwcG9ydCBpbiB1YXBpL2xpbnV4L21hcF90b183c2VnbWVudC5oCiAgYXMg c3VnZ2VzdGVkIGJ5IEdlZXJ0IFV5dHRlcmhvZXZlbi4KCk5vdGU6IFRoZXJlJ3MgYSBudW1iZXIg b2YgY2hpcHMgZnJvbSBvdGhlciBtYW51ZmFjdHVyZXJzIHRoYXQgYXJlCiAgICAgIGFsbW9zdCBp ZGVudGljYWwsIGUuZy4gRkQ2MjgsIFNNMTYyOC4gT25seSBkaWZmZXJlbmNlIEkgc2F3IHNvCiAg ICAgIGZhciBpcyB0aGF0IHRoZXkgcGFydGlhbGx5IHN1cHBvcnQgb3RoZXIgZGlzcGxheSBtb2Rl cy4KICAgICAgVE0xNjI4OiA2eDEyLCA3eDExCiAgICAgIFNNMTYyOEM6IDR4MTMsIDV4MTIsIDZ4 MTEsIDd4MTAKICAgICAgRm9yIHR5cGljYWwgZGlzcGxheXMgb24gZGV2aWNlcyB1c2luZyB0aGVz ZSBjaGlwcyB0aGlzCiAgICAgIGRpZmZlcmVuY2Ugc2hvdWxkbid0IG1hdHRlci4KClN1Y2Nlc3Nm dWxseSB0ZXN0ZWQgb24gYSBUWDMgTWluaSBUViBib3ggdGhhdCBoYXMgYW4gU00xNjI4QyBhbmQg YQpkaXNwbGF5IHdpdGggNCBkaWdpdHMgYW5kIDcgc3ltYm9scy4KClRlc3RlZC1ieTogQ2hyaXN0 aWFuIEhld2l0dCA8Y2hyaXN0aWFuc2hld2l0dEBnbWFpbC5jb20+ClNpZ25lZC1vZmYtYnk6IEFu ZHJlYXMgRsOkcmJlciA8YWZhZXJiZXJAc3VzZS5kZT4KU2lnbmVkLW9mZi1ieTogSGVpbmVyIEth bGx3ZWl0IDxoa2FsbHdlaXQxQGdtYWlsLmNvbT4KLS0tCnYyOgotIGluY2x1ZGUgY3R5cGUuaCBl eHBsaWNpdGx5Ci0gYWRkIGluZm8gbWVzc2FnZSBpbiBwcm9iZSgpCi0gKHJlLSlhZGQgQW5kcmVh cycgU29CCi0tLQogZHJpdmVycy9hdXhkaXNwbGF5L0tjb25maWcgIHwgIDEwICsKIGRyaXZlcnMv YXV4ZGlzcGxheS9NYWtlZmlsZSB8ICAgMSArCiBkcml2ZXJzL2F1eGRpc3BsYXkvdG0xNjI4LmMg fCAzNzYgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5n ZWQsIDM4NyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9hdXhkaXNw bGF5L3RtMTYyOC5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdXhkaXNwbGF5L0tjb25maWcgYi9k cml2ZXJzL2F1eGRpc3BsYXkvS2NvbmZpZwppbmRleCA2NDAxMmNkYTQuLjI1ZWYyZTQ1MiAxMDA2 NDQKLS0tIGEvZHJpdmVycy9hdXhkaXNwbGF5L0tjb25maWcKKysrIGIvZHJpdmVycy9hdXhkaXNw bGF5L0tjb25maWcKQEAgLTIwMyw2ICsyMDMsMTYgQEAgY29uZmlnIEFSTV9DSEFSTENECiAJICBs aW5lIGFuZCB0aGUgTGludXggdmVyc2lvbiBvbiB0aGUgc2Vjb25kIGxpbmUsIGJ1dCB0aGF0J3MK IAkgIHN0aWxsIHVzZWZ1bC4KIAorY29uZmlnIFRNMTYyOAorCXRyaXN0YXRlICJUTTE2MjggZHJp dmVyIGZvciBMRUQgNy8xMSBzZWdtZW50IGRpc3BsYXlzIgorCWRlcGVuZHMgb24gU1BJCisJZGVw ZW5kcyBvbiBPRiB8fCBDT01QSUxFX1RFU1QKKwloZWxwCisJICBTYXkgWSB0byBlbmFibGUgc3Vw cG9ydCBmb3IgVGl0YW4gTWljcm8gRWxlY3Ryb25pY3MgVE0xNjI4CisJICBMRUQgY29udHJvbGxl ci4KKwkgIEl0J3MgYSAzLXdpcmUgU1BJIGRldmljZSBjb250cm9sbGluZyBhIHR3by1kaW1lbnNp b25hbCBncmlkIG9mCisJICBMRURzLiBEaW1taW5nIGlzIGFwcGxpZWQgdG8gYWxsIG91dHB1dHMg dGhyb3VnaCBhbiBpbnRlcm5hbCBQV00uCisKIG1lbnVjb25maWcgUEFSUE9SVF9QQU5FTAogCXRy aXN0YXRlICJQYXJhbGxlbCBwb3J0IExDRC9LZXlwYWQgUGFuZWwgc3VwcG9ydCIKIAlkZXBlbmRz IG9uIFBBUlBPUlQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXV4ZGlzcGxheS9NYWtlZmlsZSBiL2Ry aXZlcnMvYXV4ZGlzcGxheS9NYWtlZmlsZQppbmRleCA2OTY4ZWQ0ZDMuLjc3MjhlMTdlMSAxMDA2 NDQKLS0tIGEvZHJpdmVycy9hdXhkaXNwbGF5L01ha2VmaWxlCisrKyBiL2RyaXZlcnMvYXV4ZGlz cGxheS9NYWtlZmlsZQpAQCAtMTQsMyArMTQsNCBAQCBvYmotJChDT05GSUdfSFQxNkszMykJCSs9 IGh0MTZrMzMubwogb2JqLSQoQ09ORklHX1BBUlBPUlRfUEFORUwpCSs9IHBhbmVsLm8KIG9iai0k KENPTkZJR19MQ0QyUykJCSs9IGxjZDJzLm8KIG9iai0kKENPTkZJR19MSU5FRElTUCkJCSs9IGxp bmUtZGlzcGxheS5vCitvYmotJChDT05GSUdfVE0xNjI4KQkJKz0gdG0xNjI4Lm8KZGlmZiAtLWdp dCBhL2RyaXZlcnMvYXV4ZGlzcGxheS90bTE2MjguYyBiL2RyaXZlcnMvYXV4ZGlzcGxheS90bTE2 MjguYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAuLmI4MDJiNWMzMAotLS0g L2Rldi9udWxsCisrKyBiL2RyaXZlcnMvYXV4ZGlzcGxheS90bTE2MjguYwpAQCAtMCwwICsxLDM3 NiBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb3ItbGF0ZXIKKy8qCisg KiBUaXRhbiBNaWNybyBFbGVjdHJvbmljcyBUTTE2MjggTEVEIGNvbnRyb2xsZXIKKyAqCisgKiBD b3B5cmlnaHQgKGMpIDIwMTkgQW5kcmVhcyBGw6RyYmVyCisgKi8KKworI2luY2x1ZGUgPGxpbnV4 L2N0eXBlLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9sZWRz Lmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvcHJvcGVydHku aD4KKyNpbmNsdWRlIDxsaW51eC9zcGkvc3BpLmg+CisjaW5jbHVkZSA8dWFwaS9saW51eC9tYXBf dG9fN3NlZ21lbnQuaD4KKworI2RlZmluZSBUTTE2MjhfQ01EX0RJU1BMQVlfTU9ERQkJKDAgPDwg NikKKyNkZWZpbmUgVE0xNjI4X0RJU1BMQVlfTU9ERV82XzEyCTB4MDIKKyNkZWZpbmUgVE0xNjI4 X0RJU1BMQVlfTU9ERV83XzExCTB4MDMKKworI2RlZmluZSBUTTE2MjhfQ01EX0RBVEEJCQkoMSA8 PCA2KQorI2RlZmluZSBUTTE2MjhfREFUQV9URVNUX01PREUJCUJJVCgzKQorI2RlZmluZSBUTTE2 MjhfREFUQV9GSVhFRF9BRERSCQlCSVQoMikKKyNkZWZpbmUgVE0xNjI4X0RBVEFfV1JJVEVfREFU QQkJMHgwMAorI2RlZmluZSBUTTE2MjhfREFUQV9SRUFEX0RBVEEJCTB4MDIKKworI2RlZmluZSBU TTE2MjhfQ01EX0RJU1BMQVlfQ1RSTAkJKDIgPDwgNikKKyNkZWZpbmUgVE0xNjI4X0RJU1BMQVlf Q1RSTF9ESVNQTEFZX09OCUJJVCgzKQorCisjZGVmaW5lIFRNMTYyOF9DTURfU0VUX0FERFJFU1MJ CSgzIDw8IDYpCisKKyNkZWZpbmUgVE0xNjI4X0JSSUdIVE5FU1NfTUFYCQk3CisKKy8qIFBoeXNp Y2FsIGxpbWl0cywgZGVwZW5kaW5nIG9uIHRoZSBtb2RlIHRoZSBjaGlwIG1heSBzdXBwb3J0IGxl c3MgKi8KKyNkZWZpbmUgTUFYX0dSSURfU0laRQkJCTcKKyNkZWZpbmUgTUFYX1NFR01FTlRfTlVN CQkJMTYKKworc3RydWN0IHRtMTYyOF9sZWQgeworCXN0cnVjdCBsZWRfY2xhc3NkZXYJbGVkZGV2 OworCXN0cnVjdCB0bTE2MjgJCSpjdHJsOworCXUzMgkJCWdyaWQ7CisJdTMyCQkJc2VnOworfTsK Kworc3RydWN0IHRtMTYyOCB7CisJc3RydWN0IHNwaV9kZXZpY2UJCSpzcGk7CisJX19sZTE2CQkJ CWRhdGFbTUFYX0dSSURfU0laRV07CisJc3RydWN0IG11dGV4CQkJZGlzcF9sb2NrOworCWNoYXIJ CQkJdGV4dFtNQVhfR1JJRF9TSVpFICsgMV07CisJdTgJCQkJc2VnbWVudF9tYXBwaW5nWzddOwor CXU4CQkJCWdyaWRbTUFYX0dSSURfU0laRV07CisJaW50CQkJCWdyaWRfc2l6ZTsKKwlzdHJ1Y3Qg dG0xNjI4X2xlZAkJbGVkc1tdOworfTsKKworLyogQ29tbWFuZCAxOiBEaXNwbGF5IE1vZGUgU2V0 dGluZyAqLworc3RhdGljIGludCB0bTE2Mjhfc2V0X2Rpc3BsYXlfbW9kZShzdHJ1Y3Qgc3BpX2Rl dmljZSAqc3BpLCB1OCBncmlkX21vZGUpCit7CisJdTggY21kID0gVE0xNjI4X0NNRF9ESVNQTEFZ X01PREUgfCBncmlkX21vZGU7CisKKwlyZXR1cm4gc3BpX3dyaXRlKHNwaSwgJmNtZCwgMSk7Cit9 CisKKy8qIENvbW1hbmQgMzogQWRkcmVzcyBTZXR0aW5nICovCitzdGF0aWMgaW50IHRtMTYyOF9z ZXRfYWRkcmVzcyhzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpLCB1OCBvZmZzZXQpCit7CisJdTggY21k ID0gVE0xNjI4X0NNRF9TRVRfQUREUkVTUyB8IChvZmZzZXQgKiBzaXplb2YoX19sZTE2KSk7CisK KwlyZXR1cm4gc3BpX3dyaXRlKHNwaSwgJmNtZCwgMSk7Cit9CisKKy8qIENvbW1hbmQgMjogRGF0 YSBTZXR0aW5nICovCitzdGF0aWMgaW50IHRtMTYyOF93cml0ZV9kYXRhKHN0cnVjdCBzcGlfZGV2 aWNlICpzcGksIHVuc2lnbmVkIGludCBvZmZzZXQsCisJCQkgICAgIHVuc2lnbmVkIGludCBsZW4p Cit7CisJc3RydWN0IHRtMTYyOCAqcyA9IHNwaV9nZXRfZHJ2ZGF0YShzcGkpOworCXU4IGNtZCA9 IFRNMTYyOF9DTURfREFUQSB8IFRNMTYyOF9EQVRBX1dSSVRFX0RBVEE7CisJc3RydWN0IHNwaV90 cmFuc2ZlciB4ZmVyc1tdID0geworCQl7CisJCQkudHhfYnVmID0gJmNtZCwKKwkJCS5sZW4gPSAx LAorCQl9LAorCQl7CisJCQkudHhfYnVmID0gKF9fZm9yY2Ugdm9pZCAqKShzLT5kYXRhICsgb2Zm c2V0KSwKKwkJCS5sZW4gPSBsZW4gKiBzaXplb2YoX19sZTE2KSwKKwkJfSwKKwl9OworCisJaWYg KG9mZnNldCArIGxlbiA+IE1BWF9HUklEX1NJWkUpIHsKKwkJZGV2X2Vycigmc3BpLT5kZXYsICJJ bnZhbGlkIGRhdGEgYWRkcmVzcyBvZmZzZXQgJXUgbGVuICV1XG4iLAorCQkJb2Zmc2V0LCBsZW4p OworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwl0bTE2Mjhfc2V0X2FkZHJlc3Moc3BpLCBvZmZz ZXQpOworCisJcmV0dXJuIHNwaV9zeW5jX3RyYW5zZmVyKHNwaSwgeGZlcnMsIEFSUkFZX1NJWkUo eGZlcnMpKTsKK30KKworLyogQ29tbWFuZCA0OiBEaXNwbGF5IENvbnRyb2wgKi8KK3N0YXRpYyBp bnQgdG0xNjI4X3NldF9kaXNwbGF5X2N0cmwoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSwgYm9vbCBv bikKK3sKKwl1OCBjbWQgPSBUTTE2MjhfQ01EX0RJU1BMQVlfQ1RSTCB8IFRNMTYyOF9CUklHSFRO RVNTX01BWDsKKworCWlmIChvbikKKwkJY21kIHw9IFRNMTYyOF9ESVNQTEFZX0NUUkxfRElTUExB WV9PTjsKKworCXJldHVybiBzcGlfd3JpdGUoc3BpLCAmY21kLCAxKTsKK30KKworc3RhdGljIGlu dCB0bTE2Mjhfc2hvd190ZXh0KHN0cnVjdCB0bTE2MjggKnMpCit7CisJc3RhdGljIFNFRzdfQ09O VkVSU0lPTl9NQVAobWFwX3NlZzcsIE1BUF9BU0NJSTdTRUdfQUxQSEFOVU0pOworCWludCBpLCBy ZXQ7CisKKwlpbnQgbXNnX2xlbiA9IHN0cmxlbihzLT50ZXh0KTsKKworCW11dGV4X2xvY2soJnMt PmRpc3BfbG9jayk7CisKKwlmb3IgKGkgPSAwOyBpIDwgcy0+Z3JpZF9zaXplOyBpKyspIHsKKwkJ aW50IHBvcyA9IHMtPmdyaWRbaV0gLSAxOworCisJCWlmIChpIDwgbXNnX2xlbikgeworCQkJaW50 IGNoYXI3X3JhdyA9IG1hcF90b19zZWc3KCZtYXBfc2VnNywgcy0+dGV4dFtpXSk7CisJCQlpbnQg aiwgY2hhcjc7CisKKwkJCWZvciAoaiA9IDAsIGNoYXI3ID0gMDsgaiA8IDc7IGorKykgeworCQkJ CWlmIChjaGFyN19yYXcgJiBCSVQoaikpCisJCQkJCWNoYXI3IHw9IEJJVChzLT5zZWdtZW50X21h cHBpbmdbal0gLSAxKTsKKwkJCX0KKworCQkJcy0+ZGF0YVtwb3NdID0gY3B1X3RvX2xlMTYoY2hh cjcpOworCQl9IGVsc2UgeworCQkJcy0+ZGF0YVtwb3NdID0gMDsKKwkJfQorCX0KKworCXJldCA9 IHRtMTYyOF93cml0ZV9kYXRhKHMtPnNwaSwgMCwgcy0+Z3JpZF9zaXplKTsKKworCW11dGV4X3Vu bG9jaygmcy0+ZGlzcF9sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgdG0x NjI4X2xlZF9zZXRfYnJpZ2h0bmVzcyhzdHJ1Y3QgbGVkX2NsYXNzZGV2ICpsZWRfY2RldiwKKwkJ CQkgICAgIGVudW0gbGVkX2JyaWdodG5lc3MgYnJpZ2h0bmVzcykKK3sKKwlzdHJ1Y3QgdG0xNjI4 X2xlZCAqbGVkID0gY29udGFpbmVyX29mKGxlZF9jZGV2LCBzdHJ1Y3QgdG0xNjI4X2xlZCwgbGVk ZGV2KTsKKwlzdHJ1Y3QgdG0xNjI4ICpzID0gbGVkLT5jdHJsOworCWludCBvZmZzZXQsIHJldDsK KwlfX2xlMTYgYml0OworCisJb2Zmc2V0ID0gbGVkLT5ncmlkIC0gMTsKKwliaXQgPSBjcHVfdG9f bGUxNihCSVQobGVkLT5zZWcgLSAxKSk7CisKKwltdXRleF9sb2NrKCZzLT5kaXNwX2xvY2spOwor CisJaWYgKGJyaWdodG5lc3MgPT0gTEVEX09GRikKKwkJcy0+ZGF0YVtvZmZzZXRdICY9IH5iaXQ7 CisJZWxzZQorCQlzLT5kYXRhW29mZnNldF0gfD0gYml0OworCisJcmV0ID0gdG0xNjI4X3dyaXRl X2RhdGEocy0+c3BpLCBvZmZzZXQsIDEpOworCisJbXV0ZXhfdW5sb2NrKCZzLT5kaXNwX2xvY2sp OworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGVudW0gbGVkX2JyaWdodG5lc3MgdG0xNjI4 X2xlZF9nZXRfYnJpZ2h0bmVzcyhzdHJ1Y3QgbGVkX2NsYXNzZGV2ICpsZWRfY2RldikKK3sKKwlz dHJ1Y3QgdG0xNjI4X2xlZCAqbGVkID0gY29udGFpbmVyX29mKGxlZF9jZGV2LCBzdHJ1Y3QgdG0x NjI4X2xlZCwgbGVkZGV2KTsKKwlzdHJ1Y3QgdG0xNjI4ICpzID0gbGVkLT5jdHJsOworCWludCBv ZmZzZXQ7CisJX19sZTE2IGJpdDsKKwlib29sIG9uOworCisJb2Zmc2V0ID0gbGVkLT5ncmlkIC0g MTsKKwliaXQgPSBjcHVfdG9fbGUxNihCSVQobGVkLT5zZWcgLSAxKSk7CisKKwltdXRleF9sb2Nr KCZzLT5kaXNwX2xvY2spOworCW9uID0gcy0+ZGF0YVtvZmZzZXRdICYgYml0OworCW11dGV4X3Vu bG9jaygmcy0+ZGlzcF9sb2NrKTsKKworCXJldHVybiBvbiA/IExFRF9PTiA6IExFRF9PRkY7Cit9 CisKK3N0YXRpYyBpbnQgdG0xNjI4X3JlZ2lzdGVyX2xlZChzdHJ1Y3QgdG0xNjI4ICpzLCBzdHJ1 Y3QgZndub2RlX2hhbmRsZSAqbm9kZSwKKwkJCSAgICAgICB1MzIgZ3JpZCwgdTMyIHNlZywgc3Ry dWN0IHRtMTYyOF9sZWQgKmxlZCkKK3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcy0+c3BpLT5k ZXY7CisJc3RydWN0IGxlZF9pbml0X2RhdGEgaW5pdF9kYXRhID0geyAuZndub2RlID0gbm9kZSB9 OworCisJbGVkLT5jdHJsID0gczsKKwlsZWQtPmdyaWQgPSBncmlkOworCWxlZC0+c2VnICA9IHNl ZzsKKwlsZWQtPmxlZGRldi5tYXhfYnJpZ2h0bmVzcyA9IExFRF9PTjsKKwlsZWQtPmxlZGRldi5i cmlnaHRuZXNzX3NldF9ibG9ja2luZyA9IHRtMTYyOF9sZWRfc2V0X2JyaWdodG5lc3M7CisJbGVk LT5sZWRkZXYuYnJpZ2h0bmVzc19nZXQgPSB0bTE2MjhfbGVkX2dldF9icmlnaHRuZXNzOworCisJ cmV0dXJuIGRldm1fbGVkX2NsYXNzZGV2X3JlZ2lzdGVyX2V4dChkZXYsICZsZWQtPmxlZGRldiwg JmluaXRfZGF0YSk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IGRpc3BsYXlfdGV4dF9zaG93KHN0cnVj dCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCisJCQkJIGNoYXIg KmJ1ZikKK3sKKwlzdHJ1Y3QgdG0xNjI4ICpzID0gZGV2X2dldF9kcnZkYXRhKGRldik7CisKKwly ZXR1cm4gc3lzZnNfZW1pdChidWYsICIlc1xuIiwgcy0+dGV4dCk7Cit9CisKK3N0YXRpYyBzc2l6 ZV90IGRpc3BsYXlfdGV4dF9zdG9yZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2Vf YXR0cmlidXRlICphdHRyLAorCQkJCSAgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7 CisJc3RydWN0IHRtMTYyOCAqcyA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOworCWludCByZXQsIGk7 CisKKwlpZiAoY291bnQgPiBzLT5ncmlkX3NpemUgKyAxKSAvKiBjb25zaWRlciB0cmFpbGluZyBu ZXdsaW5lICovCisJCXJldHVybiAtRTJCSUc7CisKKwlmb3IgKGkgPSAwOyBpIDwgY291bnQgJiYg aXNwcmludChidWZbaV0pOyBpKyspCisJCXMtPnRleHRbaV0gPSBidWZbaV07CisKKwlzLT50ZXh0 W2ldID0gJ1wwJzsKKworCXJldCA9IHRtMTYyOF9zaG93X3RleHQocyk7CisJaWYgKHJldCA8IDAp CisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gY291bnQ7Cit9CisKK3N0YXRpYyBjb25zdCBERVZJ Q0VfQVRUUl9SVyhkaXNwbGF5X3RleHQpOworCitzdGF0aWMgaW50IHRtMTYyOF9zcGlfcHJvYmUo c3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKK3sKKwlzdHJ1Y3QgZndub2RlX2hhbmRsZSAqY2hpbGQ7 CisJdW5zaWduZWQgaW50IG51bV9sZWRzOworCXN0cnVjdCB0bTE2MjggKnM7CisJaW50IHJldCwg aTsKKworCW51bV9sZWRzID0gZGV2aWNlX2dldF9jaGlsZF9ub2RlX2NvdW50KCZzcGktPmRldik7 CisKKwlzID0gZGV2bV9remFsbG9jKCZzcGktPmRldiwgc3RydWN0X3NpemUocywgbGVkcywgbnVt X2xlZHMpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXMpCisJCXJldHVybiAtRU5PTUVNOworCisJcy0+ c3BpID0gc3BpOworCXNwaV9zZXRfZHJ2ZGF0YShzcGksIHMpOworCisJbXV0ZXhfaW5pdCgmcy0+ ZGlzcF9sb2NrKTsKKworCW1zbGVlcCgyMDApOyAvKiBhY2NvcmRpbmcgdG8gVE0xNjI4IGRhdGFz aGVldCAqLworCisJLyogY2xlYXIgc2NyZWVuICovCisJcmV0ID0gdG0xNjI4X3dyaXRlX2RhdGEo c3BpLCAwLCBNQVhfR1JJRF9TSVpFKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCS8qIEFz c3VtZSB0aGF0IHN1YnNlcXVlbnQgU1BJIHRyYW5zZmVycyB3aWxsIGJlIG9rIGlmIGZpcnN0IHdh cyBvayAqLworCisJLyogRm9yIG5vdyB3ZSBzdXBwb3J0IDZ4MTIgbW9kZSBvbmx5LiBUaGlzIHNo b3VsZCBiZSBzdWZmaWNpZW50IGZvciBtb3N0IHVzZSBjYXNlcyAqLworCXRtMTYyOF9zZXRfZGlz cGxheV9tb2RlKHNwaSwgVE0xNjI4X0RJU1BMQVlfTU9ERV82XzEyKTsKKworCXRtMTYyOF9zZXRf ZGlzcGxheV9jdHJsKHNwaSwgdHJ1ZSk7CisKKwlpZiAoIUlTX1JFQUNIQUJMRShDT05GSUdfTEVE U19DTEFTUykpCisJCWdvdG8gbm9fbGVkczsKKworCW51bV9sZWRzID0gMDsKKworCWRldmljZV9m b3JfZWFjaF9jaGlsZF9ub2RlKCZzcGktPmRldiwgY2hpbGQpIHsKKwkJdTMyIHJlZ1syXTsKKwor CQlyZXQgPSBmd25vZGVfcHJvcGVydHlfcmVhZF91MzJfYXJyYXkoY2hpbGQsICJyZWciLCByZWcs IDIpOworCQlpZiAocmV0KSB7CisJCQlkZXZfZXJyKCZzcGktPmRldiwgIlJlYWRpbmcgJXMgcmVn IHByb3BlcnR5IGZhaWxlZCAoJWQpXG4iLAorCQkJCWZ3bm9kZV9nZXRfbmFtZShjaGlsZCksIHJl dCk7CisJCQljb250aW51ZTsKKwkJfQorCisJCWlmIChyZWdbMF0gPT0gMCB8fCByZWdbMF0gPiBN QVhfR1JJRF9TSVpFKSB7CisJCQlkZXZfZXJyKCZzcGktPmRldiwgIkludmFsaWQgZ3JpZCAldSBh dCAlc1xuIiwKKwkJCQlyZWdbMF0sIGZ3bm9kZV9nZXRfbmFtZShjaGlsZCkpOworCQkJY29udGlu dWU7CisJCX0KKworCQlpZiAocmVnWzFdID09IDAgfHwgcmVnWzFdID4gTUFYX1NFR01FTlRfTlVN KSB7CisJCQlkZXZfZXJyKCZzcGktPmRldiwgIkludmFsaWQgc2VnbWVudCAldSBhdCAlc1xuIiwK KwkJCQlyZWdbMV0sIGZ3bm9kZV9nZXRfbmFtZShjaGlsZCkpOworCQkJY29udGludWU7CisJCX0K KworCQlyZXQgPSB0bTE2MjhfcmVnaXN0ZXJfbGVkKHMsIGNoaWxkLCByZWdbMF0sIHJlZ1sxXSwg cy0+bGVkcyArIG51bV9sZWRzKTsKKwkJaWYgKHJldCkgeworCQkJZGV2X2Vycigmc3BpLT5kZXYs ICJGYWlsZWQgdG8gcmVnaXN0ZXIgTEVEICVzICglZClcbiIsCisJCQkJZndub2RlX2dldF9uYW1l KGNoaWxkKSwgcmV0KTsKKwkJCWNvbnRpbnVlOworCQl9CisJCW51bV9sZWRzKys7CisJfQorCitu b19sZWRzOgorCXJldCA9IGRldmljZV9wcm9wZXJ0eV9jb3VudF91OCgmc3BpLT5kZXYsICJncmlk Iik7CisJaWYgKHJldCA8IDEgfHwgcmV0ID4gTUFYX0dSSURfU0laRSkgeworCQlkZXZfZXJyKCZz cGktPmRldiwgIkludmFsaWQgZGlzcGxheSBsZW5ndGggKCVkKVxuIiwgcmV0KTsKKwkJcmV0dXJu IC1FSU5WQUw7CisJfQorCisJcy0+Z3JpZF9zaXplID0gcmV0OworCisJcmV0ID0gZGV2aWNlX3By b3BlcnR5X3JlYWRfdThfYXJyYXkoJnNwaS0+ZGV2LCAiZ3JpZCIsIHMtPmdyaWQsIHMtPmdyaWRf c2l6ZSk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlmb3IgKGkgPSAwOyBpIDwg cy0+Z3JpZF9zaXplOyBpKyspIHsKKwkJaWYgKHMtPmdyaWRbaV0gPCAxIHx8IHMtPmdyaWRbaV0g PiBzLT5ncmlkX3NpemUpCisJCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlyZXQgPSBkZXZpY2Vf cHJvcGVydHlfcmVhZF91OF9hcnJheSgmc3BpLT5kZXYsICJzZWdtZW50LW1hcHBpbmciLCBzLT5z ZWdtZW50X21hcHBpbmcsIDcpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJZm9y IChpID0gMDsgaSA8IDc7IGkrKykgeworCQlpZiAocy0+c2VnbWVudF9tYXBwaW5nW2ldIDwgMSB8 fCBzLT5zZWdtZW50X21hcHBpbmdbaV0gPiBNQVhfU0VHTUVOVF9OVU0pCisJCQlyZXR1cm4gLUVJ TlZBTDsKKwl9CisKKwlyZXQgPSBkZXZpY2VfY3JlYXRlX2ZpbGUoJnNwaS0+ZGV2LCAmZGV2X2F0 dHJfZGlzcGxheV90ZXh0KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJZGV2X2luZm8o JnNwaS0+ZGV2LCAiQ29uZmlndXJlZCBkaXNwbGF5IHdpdGggJXUgZGlnaXRzIGFuZCAldSBzeW1i b2xzXG4iLAorCQkgcy0+Z3JpZF9zaXplLCBudW1fbGVkcyk7CisKKwlyZXR1cm4gMDsKK30KKwor c3RhdGljIHZvaWQgdG0xNjI4X3NwaV9yZW1vdmUoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKK3sK KwlkZXZpY2VfcmVtb3ZlX2ZpbGUoJnNwaS0+ZGV2LCAmZGV2X2F0dHJfZGlzcGxheV90ZXh0KTsK Kwl0bTE2Mjhfc2V0X2Rpc3BsYXlfY3RybChzcGksIGZhbHNlKTsKK30KKworc3RhdGljIHZvaWQg dG0xNjI4X3NwaV9zaHV0ZG93bihzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpKQoreworCXRtMTYyOF9z ZXRfZGlzcGxheV9jdHJsKHNwaSwgZmFsc2UpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IG9m X2RldmljZV9pZCB0bTE2Mjhfc3BpX29mX21hdGNoZXNbXSA9IHsKKwl7IC5jb21wYXRpYmxlID0g InRpdGFubWVjLHRtMTYyOCIgfSwKKwl7fQorfTsKK01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIHRt MTYyOF9zcGlfb2ZfbWF0Y2hlcyk7CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc3BpX2RldmljZV9p ZCB0bTE2Mjhfc3BpX2lkX3RhYmxlW10gPSB7CisJeyAidG0xNjI4IiB9LAorCXt9LAorfTsKK01P RFVMRV9ERVZJQ0VfVEFCTEUoc3BpLCB0bTE2Mjhfc3BpX2lkX3RhYmxlKTsKKworc3RhdGljIHN0 cnVjdCBzcGlfZHJpdmVyIHRtMTYyOF9zcGlfZHJpdmVyID0geworCS5wcm9iZSA9IHRtMTYyOF9z cGlfcHJvYmUsCisJLnJlbW92ZSA9IHRtMTYyOF9zcGlfcmVtb3ZlLAorCS5zaHV0ZG93biA9IHRt MTYyOF9zcGlfc2h1dGRvd24sCisJLmlkX3RhYmxlID0gdG0xNjI4X3NwaV9pZF90YWJsZSwKKwor CS5kcml2ZXIgPSB7CisJCS5uYW1lID0gInRtMTYyOCIsCisJCS5vZl9tYXRjaF90YWJsZSA9IHRt MTYyOF9zcGlfb2ZfbWF0Y2hlcywKKwl9LAorfTsKK21vZHVsZV9zcGlfZHJpdmVyKHRtMTYyOF9z cGlfZHJpdmVyKTsKKworTU9EVUxFX0RFU0NSSVBUSU9OKCJUTTE2MjggTEVEIGNvbnRyb2xsZXIg ZHJpdmVyIik7CitNT0RVTEVfQVVUSE9SKCJBbmRyZWFzIEbDpHJiZXIiKTsKK01PRFVMRV9MSUNF TlNFKCJHUEwiKTsKLS0gCjIuMzUuMQoKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0t a2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFp bG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==