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 X-Spam-Level: X-Spam-Status: No, score=-12.9 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, SPF_HELO_NONE,SPF_PASS,UNWANTED_LANGUAGE_BODY,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8EB65C433E0 for ; Fri, 15 Jan 2021 15:51:36 +0000 (UTC) Received: by mail.kernel.org (Postfix) id 55711238E8; Fri, 15 Jan 2021 15:51:36 +0000 (UTC) Received: from metis.ext.pengutronix.de (metis.ext.pengutronix.de [85.220.165.71]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 6876423884 for ; Fri, 15 Jan 2021 15:51:35 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6876423884 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=pengutronix.de Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=ukl@pengutronix.de Received: from ptx.hi.pengutronix.de ([2001:67c:670:100:1d::c0]) by metis.ext.pengutronix.de with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1l0RNt-0003Nc-88; Fri, 15 Jan 2021 16:51:33 +0100 Received: from ukl by ptx.hi.pengutronix.de with local (Exim 4.92) (envelope-from ) id 1l0RNs-0008LT-TR; Fri, 15 Jan 2021 16:51:32 +0100 From: =?UTF-8?q?Uwe=20Kleine-K=C3=B6nig?= To: Arnd Bergmann , Olof Johansson , Mark Brown List-Id: Cc: soc@kernel.org, linux-arm-kernel@lists.infradead.org, kernel@pengutronix.de, linux-spi@vger.kernel.org Subject: [PATCH v2 4/7] spi: Drop unused efm32 bus driver Date: Fri, 15 Jan 2021 16:51:27 +0100 Message-Id: <20210115155130.185010-5-u.kleine-koenig@pengutronix.de> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20210115155130.185010-1-u.kleine-koenig@pengutronix.de> References: <20210115155130.185010-1-u.kleine-koenig@pengutronix.de> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-SA-Exim-Connect-IP: 2001:67c:670:100:1d::c0 X-SA-Exim-Mail-From: ukl@pengutronix.de X-SA-Exim-Scanned: No (on metis.ext.pengutronix.de); SAEximRunCond expanded to false X-PTX-Original-Recipient: soc@kernel.org Support for this machine was just removed, so drop the now unused spi bus driver, too. Signed-off-by: Uwe Kleine-König --- drivers/spi/Kconfig | 7 - drivers/spi/Makefile | 1 - drivers/spi/spi-efm32.c | 462 ------------------------ include/linux/platform_data/efm32-spi.h | 15 - 4 files changed, 485 deletions(-) delete mode 100644 drivers/spi/spi-efm32.c delete mode 100644 include/linux/platform_data/efm32-spi.h diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig index aadaea052f51..d3375aa6e292 100644 --- a/drivers/spi/Kconfig +++ b/drivers/spi/Kconfig @@ -292,13 +292,6 @@ config SPI_DLN2 This driver can also be built as a module. If so, the module will be called spi-dln2. -config SPI_EFM32 - tristate "EFM32 SPI controller" - depends on OF && ARM && (ARCH_EFM32 || COMPILE_TEST) - select SPI_BITBANG - help - Driver for the spi controller found on Energy Micro's EFM32 SoCs. - config SPI_EP93XX tristate "Cirrus Logic EP93xx SPI controller" depends on ARCH_EP93XX || COMPILE_TEST diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile index 6fea5821662e..5a21b5cc8015 100644 --- a/drivers/spi/Makefile +++ b/drivers/spi/Makefile @@ -42,7 +42,6 @@ spi-dw-$(CONFIG_SPI_DW_DMA) += spi-dw-dma.o obj-$(CONFIG_SPI_DW_BT1) += spi-dw-bt1.o obj-$(CONFIG_SPI_DW_MMIO) += spi-dw-mmio.o obj-$(CONFIG_SPI_DW_PCI) += spi-dw-pci.o -obj-$(CONFIG_SPI_EFM32) += spi-efm32.o obj-$(CONFIG_SPI_EP93XX) += spi-ep93xx.o obj-$(CONFIG_SPI_FALCON) += spi-falcon.o obj-$(CONFIG_SPI_FSI) += spi-fsi.o diff --git a/drivers/spi/spi-efm32.c b/drivers/spi/spi-efm32.c deleted file mode 100644 index ea6e4a7b3feb..000000000000 --- a/drivers/spi/spi-efm32.c +++ /dev/null @@ -1,462 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * Copyright (C) 2012-2013 Uwe Kleine-Koenig for Pengutronix - */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define DRIVER_NAME "efm32-spi" - -#define MASK_VAL(mask, val) ((val << __ffs(mask)) & mask) - -#define REG_CTRL 0x00 -#define REG_CTRL_SYNC 0x0001 -#define REG_CTRL_CLKPOL 0x0100 -#define REG_CTRL_CLKPHA 0x0200 -#define REG_CTRL_MSBF 0x0400 -#define REG_CTRL_TXBIL 0x1000 - -#define REG_FRAME 0x04 -#define REG_FRAME_DATABITS__MASK 0x000f -#define REG_FRAME_DATABITS(n) ((n) - 3) - -#define REG_CMD 0x0c -#define REG_CMD_RXEN 0x0001 -#define REG_CMD_RXDIS 0x0002 -#define REG_CMD_TXEN 0x0004 -#define REG_CMD_TXDIS 0x0008 -#define REG_CMD_MASTEREN 0x0010 - -#define REG_STATUS 0x10 -#define REG_STATUS_TXENS 0x0002 -#define REG_STATUS_TXC 0x0020 -#define REG_STATUS_TXBL 0x0040 -#define REG_STATUS_RXDATAV 0x0080 - -#define REG_CLKDIV 0x14 - -#define REG_RXDATAX 0x18 -#define REG_RXDATAX_RXDATA__MASK 0x01ff -#define REG_RXDATAX_PERR 0x4000 -#define REG_RXDATAX_FERR 0x8000 - -#define REG_TXDATA 0x34 - -#define REG_IF 0x40 -#define REG_IF_TXBL 0x0002 -#define REG_IF_RXDATAV 0x0004 - -#define REG_IFS 0x44 -#define REG_IFC 0x48 -#define REG_IEN 0x4c - -#define REG_ROUTE 0x54 -#define REG_ROUTE_RXPEN 0x0001 -#define REG_ROUTE_TXPEN 0x0002 -#define REG_ROUTE_CLKPEN 0x0008 -#define REG_ROUTE_LOCATION__MASK 0x0700 -#define REG_ROUTE_LOCATION(n) MASK_VAL(REG_ROUTE_LOCATION__MASK, (n)) - -struct efm32_spi_ddata { - struct spi_bitbang bitbang; - - spinlock_t lock; - - struct clk *clk; - void __iomem *base; - unsigned int rxirq, txirq; - struct efm32_spi_pdata pdata; - - /* irq data */ - struct completion done; - const u8 *tx_buf; - u8 *rx_buf; - unsigned tx_len, rx_len; -}; - -#define ddata_to_dev(ddata) (&(ddata->bitbang.master->dev)) -#define efm32_spi_vdbg(ddata, format, arg...) \ - dev_vdbg(ddata_to_dev(ddata), format, ##arg) - -static void efm32_spi_write32(struct efm32_spi_ddata *ddata, - u32 value, unsigned offset) -{ - writel_relaxed(value, ddata->base + offset); -} - -static u32 efm32_spi_read32(struct efm32_spi_ddata *ddata, unsigned offset) -{ - return readl_relaxed(ddata->base + offset); -} - -static int efm32_spi_setup_transfer(struct spi_device *spi, - struct spi_transfer *t) -{ - struct efm32_spi_ddata *ddata = spi_master_get_devdata(spi->master); - - unsigned bpw = t->bits_per_word ?: spi->bits_per_word; - unsigned speed = t->speed_hz ?: spi->max_speed_hz; - unsigned long clkfreq = clk_get_rate(ddata->clk); - u32 clkdiv; - - efm32_spi_write32(ddata, REG_CTRL_SYNC | REG_CTRL_MSBF | - (spi->mode & SPI_CPHA ? REG_CTRL_CLKPHA : 0) | - (spi->mode & SPI_CPOL ? REG_CTRL_CLKPOL : 0), REG_CTRL); - - efm32_spi_write32(ddata, - REG_FRAME_DATABITS(bpw), REG_FRAME); - - if (2 * speed >= clkfreq) - clkdiv = 0; - else - clkdiv = 64 * (DIV_ROUND_UP(2 * clkfreq, speed) - 4); - - if (clkdiv > (1U << 21)) - return -EINVAL; - - efm32_spi_write32(ddata, clkdiv, REG_CLKDIV); - efm32_spi_write32(ddata, REG_CMD_MASTEREN, REG_CMD); - efm32_spi_write32(ddata, REG_CMD_RXEN | REG_CMD_TXEN, REG_CMD); - - return 0; -} - -static void efm32_spi_tx_u8(struct efm32_spi_ddata *ddata) -{ - u8 val = 0; - - if (ddata->tx_buf) { - val = *ddata->tx_buf; - ddata->tx_buf++; - } - - ddata->tx_len--; - efm32_spi_write32(ddata, val, REG_TXDATA); - efm32_spi_vdbg(ddata, "%s: tx 0x%x\n", __func__, val); -} - -static void efm32_spi_rx_u8(struct efm32_spi_ddata *ddata) -{ - u32 rxdata = efm32_spi_read32(ddata, REG_RXDATAX); - efm32_spi_vdbg(ddata, "%s: rx 0x%x\n", __func__, rxdata); - - if (ddata->rx_buf) { - *ddata->rx_buf = rxdata; - ddata->rx_buf++; - } - - ddata->rx_len--; -} - -static void efm32_spi_filltx(struct efm32_spi_ddata *ddata) -{ - while (ddata->tx_len && - ddata->tx_len + 2 > ddata->rx_len && - efm32_spi_read32(ddata, REG_STATUS) & REG_STATUS_TXBL) { - efm32_spi_tx_u8(ddata); - } -} - -static int efm32_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t) -{ - struct efm32_spi_ddata *ddata = spi_master_get_devdata(spi->master); - int ret = -EBUSY; - - spin_lock_irq(&ddata->lock); - - if (ddata->tx_buf || ddata->rx_buf) - goto out_unlock; - - ddata->tx_buf = t->tx_buf; - ddata->rx_buf = t->rx_buf; - ddata->tx_len = ddata->rx_len = - t->len * DIV_ROUND_UP(t->bits_per_word, 8); - - efm32_spi_filltx(ddata); - - reinit_completion(&ddata->done); - - efm32_spi_write32(ddata, REG_IF_TXBL | REG_IF_RXDATAV, REG_IEN); - - spin_unlock_irq(&ddata->lock); - - wait_for_completion(&ddata->done); - - spin_lock_irq(&ddata->lock); - - ret = t->len - max(ddata->tx_len, ddata->rx_len); - - efm32_spi_write32(ddata, 0, REG_IEN); - ddata->tx_buf = ddata->rx_buf = NULL; - -out_unlock: - spin_unlock_irq(&ddata->lock); - - return ret; -} - -static irqreturn_t efm32_spi_rxirq(int irq, void *data) -{ - struct efm32_spi_ddata *ddata = data; - irqreturn_t ret = IRQ_NONE; - - spin_lock(&ddata->lock); - - while (ddata->rx_len > 0 && - efm32_spi_read32(ddata, REG_STATUS) & - REG_STATUS_RXDATAV) { - efm32_spi_rx_u8(ddata); - - ret = IRQ_HANDLED; - } - - if (!ddata->rx_len) { - u32 ien = efm32_spi_read32(ddata, REG_IEN); - - ien &= ~REG_IF_RXDATAV; - - efm32_spi_write32(ddata, ien, REG_IEN); - - complete(&ddata->done); - } - - spin_unlock(&ddata->lock); - - return ret; -} - -static irqreturn_t efm32_spi_txirq(int irq, void *data) -{ - struct efm32_spi_ddata *ddata = data; - - efm32_spi_vdbg(ddata, - "%s: txlen = %u, rxlen = %u, if=0x%08x, stat=0x%08x\n", - __func__, ddata->tx_len, ddata->rx_len, - efm32_spi_read32(ddata, REG_IF), - efm32_spi_read32(ddata, REG_STATUS)); - - spin_lock(&ddata->lock); - - efm32_spi_filltx(ddata); - - efm32_spi_vdbg(ddata, "%s: txlen = %u, rxlen = %u\n", - __func__, ddata->tx_len, ddata->rx_len); - - if (!ddata->tx_len) { - u32 ien = efm32_spi_read32(ddata, REG_IEN); - - ien &= ~REG_IF_TXBL; - - efm32_spi_write32(ddata, ien, REG_IEN); - efm32_spi_vdbg(ddata, "disable TXBL\n"); - } - - spin_unlock(&ddata->lock); - - return IRQ_HANDLED; -} - -static u32 efm32_spi_get_configured_location(struct efm32_spi_ddata *ddata) -{ - u32 reg = efm32_spi_read32(ddata, REG_ROUTE); - - return (reg & REG_ROUTE_LOCATION__MASK) >> __ffs(REG_ROUTE_LOCATION__MASK); -} - -static void efm32_spi_probe_dt(struct platform_device *pdev, - struct spi_master *master, struct efm32_spi_ddata *ddata) -{ - struct device_node *np = pdev->dev.of_node; - u32 location; - int ret; - - ret = of_property_read_u32(np, "energymicro,location", &location); - - if (ret) - /* fall back to wrongly namespaced property */ - ret = of_property_read_u32(np, "efm32,location", &location); - - if (ret) - /* fall back to old and (wrongly) generic property "location" */ - ret = of_property_read_u32(np, "location", &location); - - if (!ret) { - dev_dbg(&pdev->dev, "using location %u\n", location); - } else { - /* default to location configured in hardware */ - location = efm32_spi_get_configured_location(ddata); - - dev_info(&pdev->dev, "fall back to location %u\n", location); - } - - ddata->pdata.location = location; -} - -static int efm32_spi_probe(struct platform_device *pdev) -{ - struct efm32_spi_ddata *ddata; - struct resource *res; - int ret; - struct spi_master *master; - struct device_node *np = pdev->dev.of_node; - - if (!np) - return -EINVAL; - - master = spi_alloc_master(&pdev->dev, sizeof(*ddata)); - if (!master) { - dev_dbg(&pdev->dev, - "failed to allocate spi master controller\n"); - return -ENOMEM; - } - platform_set_drvdata(pdev, master); - - master->dev.of_node = pdev->dev.of_node; - - master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH; - master->bits_per_word_mask = SPI_BPW_RANGE_MASK(4, 16); - master->use_gpio_descriptors = true; - - ddata = spi_master_get_devdata(master); - - ddata->bitbang.master = master; - ddata->bitbang.setup_transfer = efm32_spi_setup_transfer; - ddata->bitbang.txrx_bufs = efm32_spi_txrx_bufs; - - spin_lock_init(&ddata->lock); - init_completion(&ddata->done); - - ddata->clk = devm_clk_get(&pdev->dev, NULL); - if (IS_ERR(ddata->clk)) { - ret = PTR_ERR(ddata->clk); - dev_err(&pdev->dev, "failed to get clock: %d\n", ret); - goto err; - } - - res = platform_get_resource(pdev, IORESOURCE_MEM, 0); - if (!res) { - ret = -ENODEV; - dev_err(&pdev->dev, "failed to determine base address\n"); - goto err; - } - - if (resource_size(res) < 0x60) { - ret = -EINVAL; - dev_err(&pdev->dev, "memory resource too small\n"); - goto err; - } - - ddata->base = devm_ioremap_resource(&pdev->dev, res); - if (IS_ERR(ddata->base)) { - ret = PTR_ERR(ddata->base); - goto err; - } - - ret = platform_get_irq(pdev, 0); - if (ret <= 0) - goto err; - - ddata->rxirq = ret; - - ret = platform_get_irq(pdev, 1); - if (ret <= 0) - ret = ddata->rxirq + 1; - - ddata->txirq = ret; - - ret = clk_prepare_enable(ddata->clk); - if (ret < 0) { - dev_err(&pdev->dev, "failed to enable clock (%d)\n", ret); - goto err; - } - - efm32_spi_probe_dt(pdev, master, ddata); - - efm32_spi_write32(ddata, 0, REG_IEN); - efm32_spi_write32(ddata, REG_ROUTE_TXPEN | REG_ROUTE_RXPEN | - REG_ROUTE_CLKPEN | - REG_ROUTE_LOCATION(ddata->pdata.location), REG_ROUTE); - - ret = request_irq(ddata->rxirq, efm32_spi_rxirq, - 0, DRIVER_NAME " rx", ddata); - if (ret) { - dev_err(&pdev->dev, "failed to register rxirq (%d)\n", ret); - goto err_disable_clk; - } - - ret = request_irq(ddata->txirq, efm32_spi_txirq, - 0, DRIVER_NAME " tx", ddata); - if (ret) { - dev_err(&pdev->dev, "failed to register txirq (%d)\n", ret); - goto err_free_rx_irq; - } - - ret = spi_bitbang_start(&ddata->bitbang); - if (ret) { - dev_err(&pdev->dev, "spi_bitbang_start failed (%d)\n", ret); - - free_irq(ddata->txirq, ddata); -err_free_rx_irq: - free_irq(ddata->rxirq, ddata); -err_disable_clk: - clk_disable_unprepare(ddata->clk); -err: - spi_master_put(master); - } - - return ret; -} - -static int efm32_spi_remove(struct platform_device *pdev) -{ - struct spi_master *master = platform_get_drvdata(pdev); - struct efm32_spi_ddata *ddata = spi_master_get_devdata(master); - - spi_bitbang_stop(&ddata->bitbang); - - efm32_spi_write32(ddata, 0, REG_IEN); - - free_irq(ddata->txirq, ddata); - free_irq(ddata->rxirq, ddata); - clk_disable_unprepare(ddata->clk); - spi_master_put(master); - - return 0; -} - -static const struct of_device_id efm32_spi_dt_ids[] = { - { - .compatible = "energymicro,efm32-spi", - }, { - /* doesn't follow the "vendor,device" scheme, don't use */ - .compatible = "efm32,spi", - }, { - /* sentinel */ - } -}; -MODULE_DEVICE_TABLE(of, efm32_spi_dt_ids); - -static struct platform_driver efm32_spi_driver = { - .probe = efm32_spi_probe, - .remove = efm32_spi_remove, - - .driver = { - .name = DRIVER_NAME, - .of_match_table = efm32_spi_dt_ids, - }, -}; -module_platform_driver(efm32_spi_driver); - -MODULE_AUTHOR("Uwe Kleine-Koenig "); -MODULE_DESCRIPTION("EFM32 SPI driver"); -MODULE_LICENSE("GPL v2"); -MODULE_ALIAS("platform:" DRIVER_NAME); diff --git a/include/linux/platform_data/efm32-spi.h b/include/linux/platform_data/efm32-spi.h deleted file mode 100644 index a2c56fcd0534..000000000000 --- a/include/linux/platform_data/efm32-spi.h +++ /dev/null @@ -1,15 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0 */ -#ifndef __LINUX_PLATFORM_DATA_EFM32_SPI_H__ -#define __LINUX_PLATFORM_DATA_EFM32_SPI_H__ - -#include - -/** - * struct efm32_spi_pdata - * @location: pinmux location for the I/O pins (to be written to the ROUTE - * register) - */ -struct efm32_spi_pdata { - u8 location; -}; -#endif /* ifndef __LINUX_PLATFORM_DATA_EFM32_SPI_H__ */ -- 2.29.2 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 X-Spam-Level: X-Spam-Status: No, score=-13.8 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,UNWANTED_LANGUAGE_BODY, URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 46472C433E6 for ; Fri, 15 Jan 2021 15:53:39 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id E0A602388B for ; Fri, 15 Jan 2021 15:53:38 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E0A602388B Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=pengutronix.de Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-Id:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=hc9mYq9TMaC6Sch5jeYp7F24a4xz9rAzSi0+Z2Hk+80=; b=mkdmPixHLNmHb1FAMyZn2upUX 2bDg9pXktPMdCHlBc2GZUuAOi+cCZ2ZTtK5/1y/TCRId81nmPFiE3TIUi9KFGT4jfL7J2S5l5r6aF M6jjOUkIGEIefowzM7PoZqFUMLrxIeNppPBxleRXj+ggcaTpijQF+yKU4KZKbJQhBXRcO5GcIk1S2 IN19Di5yndgE5K8nX8AaH0Xq9l4UDOGS+7U3ab5vQ8tz/BIku84KWwTmKij2EcQTlUJqld4jqBbja aUGUfHskrET3u6TeDqQMrdjYUHcW2YdgN9FIM1Du/5+fjfNxYdaOfI6gwpLplW642+BhWU+TIEFBi WOLDdOCyA==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1l0ROD-0007MV-LW; Fri, 15 Jan 2021 15:51:53 +0000 Received: from metis.ext.pengutronix.de ([2001:67c:670:201:290:27ff:fe1d:cc33]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1l0RNx-0007II-7y for linux-arm-kernel@lists.infradead.org; Fri, 15 Jan 2021 15:51:42 +0000 Received: from ptx.hi.pengutronix.de ([2001:67c:670:100:1d::c0]) by metis.ext.pengutronix.de with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1l0RNt-0003Nc-88; Fri, 15 Jan 2021 16:51:33 +0100 Received: from ukl by ptx.hi.pengutronix.de with local (Exim 4.92) (envelope-from ) id 1l0RNs-0008LT-TR; Fri, 15 Jan 2021 16:51:32 +0100 From: =?UTF-8?q?Uwe=20Kleine-K=C3=B6nig?= To: Arnd Bergmann , Olof Johansson , Mark Brown Subject: [PATCH v2 4/7] spi: Drop unused efm32 bus driver Date: Fri, 15 Jan 2021 16:51:27 +0100 Message-ID: <20210115155130.185010-5-u.kleine-koenig@pengutronix.de> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20210115155130.185010-1-u.kleine-koenig@pengutronix.de> References: <20210115155130.185010-1-u.kleine-koenig@pengutronix.de> MIME-Version: 1.0 X-SA-Exim-Connect-IP: 2001:67c:670:100:1d::c0 X-SA-Exim-Mail-From: ukl@pengutronix.de X-SA-Exim-Scanned: No (on metis.ext.pengutronix.de); SAEximRunCond expanded to false X-PTX-Original-Recipient: linux-arm-kernel@lists.infradead.org X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210115_105137_611687_5551A8D8 X-CRM114-Status: GOOD ( 25.19 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , List-Id: Cc: soc@kernel.org, kernel@pengutronix.de, linux-arm-kernel@lists.infradead.org, linux-spi@vger.kernel.org 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 Message-ID: <20210115155127.f9H6HPnq-gF0U5d2tuLHCfduiDXy-ti4wknN33Yy67Q@z> U3VwcG9ydCBmb3IgdGhpcyBtYWNoaW5lIHdhcyBqdXN0IHJlbW92ZWQsIHNvIGRyb3AgdGhlIG5v dyB1bnVzZWQgc3BpCmJ1cyBkcml2ZXIsIHRvby4KClNpZ25lZC1vZmYtYnk6IFV3ZSBLbGVpbmUt S8O2bmlnIDx1LmtsZWluZS1rb2VuaWdAcGVuZ3V0cm9uaXguZGU+Ci0tLQogZHJpdmVycy9zcGkv S2NvbmZpZyAgICAgICAgICAgICAgICAgICAgIHwgICA3IC0KIGRyaXZlcnMvc3BpL01ha2VmaWxl ICAgICAgICAgICAgICAgICAgICB8ICAgMSAtCiBkcml2ZXJzL3NwaS9zcGktZWZtMzIuYyAgICAg ICAgICAgICAgICAgfCA0NjIgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBpbmNsdWRlL2xpbnV4 L3BsYXRmb3JtX2RhdGEvZWZtMzItc3BpLmggfCAgMTUgLQogNCBmaWxlcyBjaGFuZ2VkLCA0ODUg ZGVsZXRpb25zKC0pCiBkZWxldGUgbW9kZSAxMDA2NDQgZHJpdmVycy9zcGkvc3BpLWVmbTMyLmMK IGRlbGV0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2xpbnV4L3BsYXRmb3JtX2RhdGEvZWZtMzItc3Bp LmgKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NwaS9LY29uZmlnIGIvZHJpdmVycy9zcGkvS2NvbmZp ZwppbmRleCBhYWRhZWEwNTJmNTEuLmQzMzc1YWE2ZTI5MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9z cGkvS2NvbmZpZworKysgYi9kcml2ZXJzL3NwaS9LY29uZmlnCkBAIC0yOTIsMTMgKzI5Miw2IEBA IGNvbmZpZyBTUElfRExOMgogCSBUaGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1v ZHVsZS4gIElmIHNvLCB0aGUgbW9kdWxlCiAJIHdpbGwgYmUgY2FsbGVkIHNwaS1kbG4yLgogCi1j b25maWcgU1BJX0VGTTMyCi0JdHJpc3RhdGUgIkVGTTMyIFNQSSBjb250cm9sbGVyIgotCWRlcGVu ZHMgb24gT0YgJiYgQVJNICYmIChBUkNIX0VGTTMyIHx8IENPTVBJTEVfVEVTVCkKLQlzZWxlY3Qg U1BJX0JJVEJBTkcKLQloZWxwCi0JICBEcml2ZXIgZm9yIHRoZSBzcGkgY29udHJvbGxlciBmb3Vu ZCBvbiBFbmVyZ3kgTWljcm8ncyBFRk0zMiBTb0NzLgotCiBjb25maWcgU1BJX0VQOTNYWAogCXRy aXN0YXRlICJDaXJydXMgTG9naWMgRVA5M3h4IFNQSSBjb250cm9sbGVyIgogCWRlcGVuZHMgb24g QVJDSF9FUDkzWFggfHwgQ09NUElMRV9URVNUCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NwaS9NYWtl ZmlsZSBiL2RyaXZlcnMvc3BpL01ha2VmaWxlCmluZGV4IDZmZWE1ODIxNjYyZS4uNWEyMWI1Y2M4 MDE1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3NwaS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL3NwaS9N YWtlZmlsZQpAQCAtNDIsNyArNDIsNiBAQCBzcGktZHctJChDT05GSUdfU1BJX0RXX0RNQSkJCSs9 IHNwaS1kdy1kbWEubwogb2JqLSQoQ09ORklHX1NQSV9EV19CVDEpCQkrPSBzcGktZHctYnQxLm8K IG9iai0kKENPTkZJR19TUElfRFdfTU1JTykJCSs9IHNwaS1kdy1tbWlvLm8KIG9iai0kKENPTkZJ R19TUElfRFdfUENJKQkJKz0gc3BpLWR3LXBjaS5vCi1vYmotJChDT05GSUdfU1BJX0VGTTMyKQkJ CSs9IHNwaS1lZm0zMi5vCiBvYmotJChDT05GSUdfU1BJX0VQOTNYWCkJCSs9IHNwaS1lcDkzeHgu bwogb2JqLSQoQ09ORklHX1NQSV9GQUxDT04pCQkrPSBzcGktZmFsY29uLm8KIG9iai0kKENPTkZJ R19TUElfRlNJKQkJCSs9IHNwaS1mc2kubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zcGkvc3BpLWVm bTMyLmMgYi9kcml2ZXJzL3NwaS9zcGktZWZtMzIuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggZWE2ZTRhN2IzZmViLi4wMDAwMDAwMDAwMDAKLS0tIGEvZHJpdmVycy9zcGkvc3BpLWVm bTMyLmMKKysrIC9kZXYvbnVsbApAQCAtMSw0NjIgKzAsMCBAQAotLy8gU1BEWC1MaWNlbnNlLUlk ZW50aWZpZXI6IEdQTC0yLjAtb25seQotLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMi0yMDEzIFV3 ZSBLbGVpbmUtS29lbmlnIGZvciBQZW5ndXRyb25peAotICovCi0jaW5jbHVkZSA8bGludXgva2Vy bmVsLmg+Ci0jaW5jbHVkZSA8bGludXgvaW8uaD4KLSNpbmNsdWRlIDxsaW51eC9zcGkvc3BpLmg+ Ci0jaW5jbHVkZSA8bGludXgvc3BpL3NwaV9iaXRiYW5nLmg+Ci0jaW5jbHVkZSA8bGludXgvaW50 ZXJydXB0Lmg+Ci0jaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+Ci0jaW5jbHVkZSA8 bGludXgvY2xrLmg+Ci0jaW5jbHVkZSA8bGludXgvZXJyLmg+Ci0jaW5jbHVkZSA8bGludXgvbW9k dWxlLmg+Ci0jaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGF0YS9lZm0zMi1zcGkuaD4KLSNpbmNs dWRlIDxsaW51eC9vZi5oPgotCi0jZGVmaW5lIERSSVZFUl9OQU1FICJlZm0zMi1zcGkiCi0KLSNk ZWZpbmUgTUFTS19WQUwobWFzaywgdmFsKQkJKCh2YWwgPDwgX19mZnMobWFzaykpICYgbWFzaykK LQotI2RlZmluZSBSRUdfQ1RSTAkJMHgwMAotI2RlZmluZSBSRUdfQ1RSTF9TWU5DCQkJMHgwMDAx Ci0jZGVmaW5lIFJFR19DVFJMX0NMS1BPTAkJCTB4MDEwMAotI2RlZmluZSBSRUdfQ1RSTF9DTEtQ SEEJCQkweDAyMDAKLSNkZWZpbmUgUkVHX0NUUkxfTVNCRgkJCTB4MDQwMAotI2RlZmluZSBSRUdf Q1RSTF9UWEJJTAkJCTB4MTAwMAotCi0jZGVmaW5lIFJFR19GUkFNRQkJMHgwNAotI2RlZmluZSBS RUdfRlJBTUVfREFUQUJJVFNfX01BU0sJMHgwMDBmCi0jZGVmaW5lIFJFR19GUkFNRV9EQVRBQklU UyhuKQkJKChuKSAtIDMpCi0KLSNkZWZpbmUgUkVHX0NNRAkJCTB4MGMKLSNkZWZpbmUgUkVHX0NN RF9SWEVOCQkJMHgwMDAxCi0jZGVmaW5lIFJFR19DTURfUlhESVMJCQkweDAwMDIKLSNkZWZpbmUg UkVHX0NNRF9UWEVOCQkJMHgwMDA0Ci0jZGVmaW5lIFJFR19DTURfVFhESVMJCQkweDAwMDgKLSNk ZWZpbmUgUkVHX0NNRF9NQVNURVJFTgkJMHgwMDEwCi0KLSNkZWZpbmUgUkVHX1NUQVRVUwkJMHgx MAotI2RlZmluZSBSRUdfU1RBVFVTX1RYRU5TCQkweDAwMDIKLSNkZWZpbmUgUkVHX1NUQVRVU19U WEMJCQkweDAwMjAKLSNkZWZpbmUgUkVHX1NUQVRVU19UWEJMCQkJMHgwMDQwCi0jZGVmaW5lIFJF R19TVEFUVVNfUlhEQVRBVgkJMHgwMDgwCi0KLSNkZWZpbmUgUkVHX0NMS0RJVgkJMHgxNAotCi0j ZGVmaW5lIFJFR19SWERBVEFYCQkweDE4Ci0jZGVmaW5lIFJFR19SWERBVEFYX1JYREFUQV9fTUFT SwkweDAxZmYKLSNkZWZpbmUgUkVHX1JYREFUQVhfUEVSUgkJMHg0MDAwCi0jZGVmaW5lIFJFR19S WERBVEFYX0ZFUlIJCTB4ODAwMAotCi0jZGVmaW5lIFJFR19UWERBVEEJCTB4MzQKLQotI2RlZmlu ZSBSRUdfSUYJCTB4NDAKLSNkZWZpbmUgUkVHX0lGX1RYQkwJCQkweDAwMDIKLSNkZWZpbmUgUkVH X0lGX1JYREFUQVYJCQkweDAwMDQKLQotI2RlZmluZSBSRUdfSUZTCQkweDQ0Ci0jZGVmaW5lIFJF R19JRkMJCTB4NDgKLSNkZWZpbmUgUkVHX0lFTgkJMHg0YwotCi0jZGVmaW5lIFJFR19ST1VURQkJ MHg1NAotI2RlZmluZSBSRUdfUk9VVEVfUlhQRU4JCQkweDAwMDEKLSNkZWZpbmUgUkVHX1JPVVRF X1RYUEVOCQkJMHgwMDAyCi0jZGVmaW5lIFJFR19ST1VURV9DTEtQRU4JCTB4MDAwOAotI2RlZmlu ZSBSRUdfUk9VVEVfTE9DQVRJT05fX01BU0sJMHgwNzAwCi0jZGVmaW5lIFJFR19ST1VURV9MT0NB VElPTihuKQkJTUFTS19WQUwoUkVHX1JPVVRFX0xPQ0FUSU9OX19NQVNLLCAobikpCi0KLXN0cnVj dCBlZm0zMl9zcGlfZGRhdGEgewotCXN0cnVjdCBzcGlfYml0YmFuZyBiaXRiYW5nOwotCi0Jc3Bp bmxvY2tfdCBsb2NrOwotCi0Jc3RydWN0IGNsayAqY2xrOwotCXZvaWQgX19pb21lbSAqYmFzZTsK LQl1bnNpZ25lZCBpbnQgcnhpcnEsIHR4aXJxOwotCXN0cnVjdCBlZm0zMl9zcGlfcGRhdGEgcGRh dGE7Ci0KLQkvKiBpcnEgZGF0YSAqLwotCXN0cnVjdCBjb21wbGV0aW9uIGRvbmU7Ci0JY29uc3Qg dTggKnR4X2J1ZjsKLQl1OCAqcnhfYnVmOwotCXVuc2lnbmVkIHR4X2xlbiwgcnhfbGVuOwotfTsK LQotI2RlZmluZSBkZGF0YV90b19kZXYoZGRhdGEpCSgmKGRkYXRhLT5iaXRiYW5nLm1hc3Rlci0+ ZGV2KSkKLSNkZWZpbmUgZWZtMzJfc3BpX3ZkYmcoZGRhdGEsIGZvcm1hdCwgYXJnLi4uKQlcCi0J ZGV2X3ZkYmcoZGRhdGFfdG9fZGV2KGRkYXRhKSwgZm9ybWF0LCAjI2FyZykKLQotc3RhdGljIHZv aWQgZWZtMzJfc3BpX3dyaXRlMzIoc3RydWN0IGVmbTMyX3NwaV9kZGF0YSAqZGRhdGEsCi0JCXUz MiB2YWx1ZSwgdW5zaWduZWQgb2Zmc2V0KQotewotCXdyaXRlbF9yZWxheGVkKHZhbHVlLCBkZGF0 YS0+YmFzZSArIG9mZnNldCk7Ci19Ci0KLXN0YXRpYyB1MzIgZWZtMzJfc3BpX3JlYWQzMihzdHJ1 Y3QgZWZtMzJfc3BpX2RkYXRhICpkZGF0YSwgdW5zaWduZWQgb2Zmc2V0KQotewotCXJldHVybiBy ZWFkbF9yZWxheGVkKGRkYXRhLT5iYXNlICsgb2Zmc2V0KTsKLX0KLQotc3RhdGljIGludCBlZm0z Ml9zcGlfc2V0dXBfdHJhbnNmZXIoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSwKLQkJc3RydWN0IHNw aV90cmFuc2ZlciAqdCkKLXsKLQlzdHJ1Y3QgZWZtMzJfc3BpX2RkYXRhICpkZGF0YSA9IHNwaV9t YXN0ZXJfZ2V0X2RldmRhdGEoc3BpLT5tYXN0ZXIpOwotCi0JdW5zaWduZWQgYnB3ID0gdC0+Yml0 c19wZXJfd29yZCA/OiBzcGktPmJpdHNfcGVyX3dvcmQ7Ci0JdW5zaWduZWQgc3BlZWQgPSB0LT5z cGVlZF9oeiA/OiBzcGktPm1heF9zcGVlZF9oejsKLQl1bnNpZ25lZCBsb25nIGNsa2ZyZXEgPSBj bGtfZ2V0X3JhdGUoZGRhdGEtPmNsayk7Ci0JdTMyIGNsa2RpdjsKLQotCWVmbTMyX3NwaV93cml0 ZTMyKGRkYXRhLCBSRUdfQ1RSTF9TWU5DIHwgUkVHX0NUUkxfTVNCRiB8Ci0JCQkoc3BpLT5tb2Rl ICYgU1BJX0NQSEEgPyBSRUdfQ1RSTF9DTEtQSEEgOiAwKSB8Ci0JCQkoc3BpLT5tb2RlICYgU1BJ X0NQT0wgPyBSRUdfQ1RSTF9DTEtQT0wgOiAwKSwgUkVHX0NUUkwpOwotCi0JZWZtMzJfc3BpX3dy aXRlMzIoZGRhdGEsCi0JCQlSRUdfRlJBTUVfREFUQUJJVFMoYnB3KSwgUkVHX0ZSQU1FKTsKLQot CWlmICgyICogc3BlZWQgPj0gY2xrZnJlcSkKLQkJY2xrZGl2ID0gMDsKLQllbHNlCi0JCWNsa2Rp diA9IDY0ICogKERJVl9ST1VORF9VUCgyICogY2xrZnJlcSwgc3BlZWQpIC0gNCk7Ci0KLQlpZiAo Y2xrZGl2ID4gKDFVIDw8IDIxKSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQllZm0zMl9zcGlfd3Jp dGUzMihkZGF0YSwgY2xrZGl2LCBSRUdfQ0xLRElWKTsKLQllZm0zMl9zcGlfd3JpdGUzMihkZGF0 YSwgUkVHX0NNRF9NQVNURVJFTiwgUkVHX0NNRCk7Ci0JZWZtMzJfc3BpX3dyaXRlMzIoZGRhdGEs IFJFR19DTURfUlhFTiB8IFJFR19DTURfVFhFTiwgUkVHX0NNRCk7Ci0KLQlyZXR1cm4gMDsKLX0K LQotc3RhdGljIHZvaWQgZWZtMzJfc3BpX3R4X3U4KHN0cnVjdCBlZm0zMl9zcGlfZGRhdGEgKmRk YXRhKQotewotCXU4IHZhbCA9IDA7Ci0KLQlpZiAoZGRhdGEtPnR4X2J1ZikgewotCQl2YWwgPSAq ZGRhdGEtPnR4X2J1ZjsKLQkJZGRhdGEtPnR4X2J1ZisrOwotCX0KLQotCWRkYXRhLT50eF9sZW4t LTsKLQllZm0zMl9zcGlfd3JpdGUzMihkZGF0YSwgdmFsLCBSRUdfVFhEQVRBKTsKLQllZm0zMl9z cGlfdmRiZyhkZGF0YSwgIiVzOiB0eCAweCV4XG4iLCBfX2Z1bmNfXywgdmFsKTsKLX0KLQotc3Rh dGljIHZvaWQgZWZtMzJfc3BpX3J4X3U4KHN0cnVjdCBlZm0zMl9zcGlfZGRhdGEgKmRkYXRhKQot ewotCXUzMiByeGRhdGEgPSBlZm0zMl9zcGlfcmVhZDMyKGRkYXRhLCBSRUdfUlhEQVRBWCk7Ci0J ZWZtMzJfc3BpX3ZkYmcoZGRhdGEsICIlczogcnggMHgleFxuIiwgX19mdW5jX18sIHJ4ZGF0YSk7 Ci0KLQlpZiAoZGRhdGEtPnJ4X2J1ZikgewotCQkqZGRhdGEtPnJ4X2J1ZiA9IHJ4ZGF0YTsKLQkJ ZGRhdGEtPnJ4X2J1ZisrOwotCX0KLQotCWRkYXRhLT5yeF9sZW4tLTsKLX0KLQotc3RhdGljIHZv aWQgZWZtMzJfc3BpX2ZpbGx0eChzdHJ1Y3QgZWZtMzJfc3BpX2RkYXRhICpkZGF0YSkKLXsKLQl3 aGlsZSAoZGRhdGEtPnR4X2xlbiAmJgotCQkJZGRhdGEtPnR4X2xlbiArIDIgPiBkZGF0YS0+cnhf bGVuICYmCi0JCQllZm0zMl9zcGlfcmVhZDMyKGRkYXRhLCBSRUdfU1RBVFVTKSAmIFJFR19TVEFU VVNfVFhCTCkgewotCQllZm0zMl9zcGlfdHhfdTgoZGRhdGEpOwotCX0KLX0KLQotc3RhdGljIGlu dCBlZm0zMl9zcGlfdHhyeF9idWZzKHN0cnVjdCBzcGlfZGV2aWNlICpzcGksIHN0cnVjdCBzcGlf dHJhbnNmZXIgKnQpCi17Ci0Jc3RydWN0IGVmbTMyX3NwaV9kZGF0YSAqZGRhdGEgPSBzcGlfbWFz dGVyX2dldF9kZXZkYXRhKHNwaS0+bWFzdGVyKTsKLQlpbnQgcmV0ID0gLUVCVVNZOwotCi0Jc3Bp bl9sb2NrX2lycSgmZGRhdGEtPmxvY2spOwotCi0JaWYgKGRkYXRhLT50eF9idWYgfHwgZGRhdGEt PnJ4X2J1ZikKLQkJZ290byBvdXRfdW5sb2NrOwotCi0JZGRhdGEtPnR4X2J1ZiA9IHQtPnR4X2J1 ZjsKLQlkZGF0YS0+cnhfYnVmID0gdC0+cnhfYnVmOwotCWRkYXRhLT50eF9sZW4gPSBkZGF0YS0+ cnhfbGVuID0KLQkJdC0+bGVuICogRElWX1JPVU5EX1VQKHQtPmJpdHNfcGVyX3dvcmQsIDgpOwot Ci0JZWZtMzJfc3BpX2ZpbGx0eChkZGF0YSk7Ci0KLQlyZWluaXRfY29tcGxldGlvbigmZGRhdGEt PmRvbmUpOwotCi0JZWZtMzJfc3BpX3dyaXRlMzIoZGRhdGEsIFJFR19JRl9UWEJMIHwgUkVHX0lG X1JYREFUQVYsIFJFR19JRU4pOwotCi0Jc3Bpbl91bmxvY2tfaXJxKCZkZGF0YS0+bG9jayk7Ci0K LQl3YWl0X2Zvcl9jb21wbGV0aW9uKCZkZGF0YS0+ZG9uZSk7Ci0KLQlzcGluX2xvY2tfaXJxKCZk ZGF0YS0+bG9jayk7Ci0KLQlyZXQgPSB0LT5sZW4gLSBtYXgoZGRhdGEtPnR4X2xlbiwgZGRhdGEt PnJ4X2xlbik7Ci0KLQllZm0zMl9zcGlfd3JpdGUzMihkZGF0YSwgMCwgUkVHX0lFTik7Ci0JZGRh dGEtPnR4X2J1ZiA9IGRkYXRhLT5yeF9idWYgPSBOVUxMOwotCi1vdXRfdW5sb2NrOgotCXNwaW5f dW5sb2NrX2lycSgmZGRhdGEtPmxvY2spOwotCi0JcmV0dXJuIHJldDsKLX0KLQotc3RhdGljIGly cXJldHVybl90IGVmbTMyX3NwaV9yeGlycShpbnQgaXJxLCB2b2lkICpkYXRhKQotewotCXN0cnVj dCBlZm0zMl9zcGlfZGRhdGEgKmRkYXRhID0gZGF0YTsKLQlpcnFyZXR1cm5fdCByZXQgPSBJUlFf Tk9ORTsKLQotCXNwaW5fbG9jaygmZGRhdGEtPmxvY2spOwotCi0Jd2hpbGUgKGRkYXRhLT5yeF9s ZW4gPiAwICYmCi0JCQllZm0zMl9zcGlfcmVhZDMyKGRkYXRhLCBSRUdfU1RBVFVTKSAmCi0JCQlS RUdfU1RBVFVTX1JYREFUQVYpIHsKLQkJZWZtMzJfc3BpX3J4X3U4KGRkYXRhKTsKLQotCQlyZXQg PSBJUlFfSEFORExFRDsKLQl9Ci0KLQlpZiAoIWRkYXRhLT5yeF9sZW4pIHsKLQkJdTMyIGllbiA9 IGVmbTMyX3NwaV9yZWFkMzIoZGRhdGEsIFJFR19JRU4pOwotCi0JCWllbiAmPSB+UkVHX0lGX1JY REFUQVY7Ci0KLQkJZWZtMzJfc3BpX3dyaXRlMzIoZGRhdGEsIGllbiwgUkVHX0lFTik7Ci0KLQkJ Y29tcGxldGUoJmRkYXRhLT5kb25lKTsKLQl9Ci0KLQlzcGluX3VubG9jaygmZGRhdGEtPmxvY2sp OwotCi0JcmV0dXJuIHJldDsKLX0KLQotc3RhdGljIGlycXJldHVybl90IGVmbTMyX3NwaV90eGly cShpbnQgaXJxLCB2b2lkICpkYXRhKQotewotCXN0cnVjdCBlZm0zMl9zcGlfZGRhdGEgKmRkYXRh ID0gZGF0YTsKLQotCWVmbTMyX3NwaV92ZGJnKGRkYXRhLAotCQkJIiVzOiB0eGxlbiA9ICV1LCBy eGxlbiA9ICV1LCBpZj0weCUwOHgsIHN0YXQ9MHglMDh4XG4iLAotCQkJX19mdW5jX18sIGRkYXRh LT50eF9sZW4sIGRkYXRhLT5yeF9sZW4sCi0JCQllZm0zMl9zcGlfcmVhZDMyKGRkYXRhLCBSRUdf SUYpLAotCQkJZWZtMzJfc3BpX3JlYWQzMihkZGF0YSwgUkVHX1NUQVRVUykpOwotCi0Jc3Bpbl9s b2NrKCZkZGF0YS0+bG9jayk7Ci0KLQllZm0zMl9zcGlfZmlsbHR4KGRkYXRhKTsKLQotCWVmbTMy X3NwaV92ZGJnKGRkYXRhLCAiJXM6IHR4bGVuID0gJXUsIHJ4bGVuID0gJXVcbiIsCi0JCQlfX2Z1 bmNfXywgZGRhdGEtPnR4X2xlbiwgZGRhdGEtPnJ4X2xlbik7Ci0KLQlpZiAoIWRkYXRhLT50eF9s ZW4pIHsKLQkJdTMyIGllbiA9IGVmbTMyX3NwaV9yZWFkMzIoZGRhdGEsIFJFR19JRU4pOwotCi0J CWllbiAmPSB+UkVHX0lGX1RYQkw7Ci0KLQkJZWZtMzJfc3BpX3dyaXRlMzIoZGRhdGEsIGllbiwg UkVHX0lFTik7Ci0JCWVmbTMyX3NwaV92ZGJnKGRkYXRhLCAiZGlzYWJsZSBUWEJMXG4iKTsKLQl9 Ci0KLQlzcGluX3VubG9jaygmZGRhdGEtPmxvY2spOwotCi0JcmV0dXJuIElSUV9IQU5ETEVEOwot fQotCi1zdGF0aWMgdTMyIGVmbTMyX3NwaV9nZXRfY29uZmlndXJlZF9sb2NhdGlvbihzdHJ1Y3Qg ZWZtMzJfc3BpX2RkYXRhICpkZGF0YSkKLXsKLQl1MzIgcmVnID0gZWZtMzJfc3BpX3JlYWQzMihk ZGF0YSwgUkVHX1JPVVRFKTsKLQotCXJldHVybiAocmVnICYgUkVHX1JPVVRFX0xPQ0FUSU9OX19N QVNLKSA+PiBfX2ZmcyhSRUdfUk9VVEVfTE9DQVRJT05fX01BU0spOwotfQotCi1zdGF0aWMgdm9p ZCBlZm0zMl9zcGlfcHJvYmVfZHQoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwKLQkJc3Ry dWN0IHNwaV9tYXN0ZXIgKm1hc3Rlciwgc3RydWN0IGVmbTMyX3NwaV9kZGF0YSAqZGRhdGEpCi17 Ci0Jc3RydWN0IGRldmljZV9ub2RlICpucCA9IHBkZXYtPmRldi5vZl9ub2RlOwotCXUzMiBsb2Nh dGlvbjsKLQlpbnQgcmV0OwotCi0JcmV0ID0gb2ZfcHJvcGVydHlfcmVhZF91MzIobnAsICJlbmVy Z3ltaWNybyxsb2NhdGlvbiIsICZsb2NhdGlvbik7Ci0KLQlpZiAocmV0KQotCQkvKiBmYWxsIGJh Y2sgdG8gd3JvbmdseSBuYW1lc3BhY2VkIHByb3BlcnR5ICovCi0JCXJldCA9IG9mX3Byb3BlcnR5 X3JlYWRfdTMyKG5wLCAiZWZtMzIsbG9jYXRpb24iLCAmbG9jYXRpb24pOwotCi0JaWYgKHJldCkK LQkJLyogZmFsbCBiYWNrIHRvIG9sZCBhbmQgKHdyb25nbHkpIGdlbmVyaWMgcHJvcGVydHkgImxv Y2F0aW9uIiAqLwotCQlyZXQgPSBvZl9wcm9wZXJ0eV9yZWFkX3UzMihucCwgImxvY2F0aW9uIiwg JmxvY2F0aW9uKTsKLQotCWlmICghcmV0KSB7Ci0JCWRldl9kYmcoJnBkZXYtPmRldiwgInVzaW5n IGxvY2F0aW9uICV1XG4iLCBsb2NhdGlvbik7Ci0JfSBlbHNlIHsKLQkJLyogZGVmYXVsdCB0byBs b2NhdGlvbiBjb25maWd1cmVkIGluIGhhcmR3YXJlICovCi0JCWxvY2F0aW9uID0gZWZtMzJfc3Bp X2dldF9jb25maWd1cmVkX2xvY2F0aW9uKGRkYXRhKTsKLQotCQlkZXZfaW5mbygmcGRldi0+ZGV2 LCAiZmFsbCBiYWNrIHRvIGxvY2F0aW9uICV1XG4iLCBsb2NhdGlvbik7Ci0JfQotCi0JZGRhdGEt PnBkYXRhLmxvY2F0aW9uID0gbG9jYXRpb247Ci19Ci0KLXN0YXRpYyBpbnQgZWZtMzJfc3BpX3By b2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCi17Ci0Jc3RydWN0IGVmbTMyX3NwaV9k ZGF0YSAqZGRhdGE7Ci0Jc3RydWN0IHJlc291cmNlICpyZXM7Ci0JaW50IHJldDsKLQlzdHJ1Y3Qg c3BpX21hc3RlciAqbWFzdGVyOwotCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAgPSBwZGV2LT5kZXYu b2Zfbm9kZTsKLQotCWlmICghbnApCi0JCXJldHVybiAtRUlOVkFMOwotCi0JbWFzdGVyID0gc3Bp X2FsbG9jX21hc3RlcigmcGRldi0+ZGV2LCBzaXplb2YoKmRkYXRhKSk7Ci0JaWYgKCFtYXN0ZXIp IHsKLQkJZGV2X2RiZygmcGRldi0+ZGV2LAotCQkJCSJmYWlsZWQgdG8gYWxsb2NhdGUgc3BpIG1h c3RlciBjb250cm9sbGVyXG4iKTsKLQkJcmV0dXJuIC1FTk9NRU07Ci0JfQotCXBsYXRmb3JtX3Nl dF9kcnZkYXRhKHBkZXYsIG1hc3Rlcik7Ci0KLQltYXN0ZXItPmRldi5vZl9ub2RlID0gcGRldi0+ ZGV2Lm9mX25vZGU7Ci0KLQltYXN0ZXItPm1vZGVfYml0cyA9IFNQSV9DUE9MIHwgU1BJX0NQSEEg fCBTUElfQ1NfSElHSDsKLQltYXN0ZXItPmJpdHNfcGVyX3dvcmRfbWFzayA9IFNQSV9CUFdfUkFO R0VfTUFTSyg0LCAxNik7Ci0JbWFzdGVyLT51c2VfZ3Bpb19kZXNjcmlwdG9ycyA9IHRydWU7Ci0K LQlkZGF0YSA9IHNwaV9tYXN0ZXJfZ2V0X2RldmRhdGEobWFzdGVyKTsKLQotCWRkYXRhLT5iaXRi YW5nLm1hc3RlciA9IG1hc3RlcjsKLQlkZGF0YS0+Yml0YmFuZy5zZXR1cF90cmFuc2ZlciA9IGVm bTMyX3NwaV9zZXR1cF90cmFuc2ZlcjsKLQlkZGF0YS0+Yml0YmFuZy50eHJ4X2J1ZnMgPSBlZm0z Ml9zcGlfdHhyeF9idWZzOwotCi0Jc3Bpbl9sb2NrX2luaXQoJmRkYXRhLT5sb2NrKTsKLQlpbml0 X2NvbXBsZXRpb24oJmRkYXRhLT5kb25lKTsKLQotCWRkYXRhLT5jbGsgPSBkZXZtX2Nsa19nZXQo JnBkZXYtPmRldiwgTlVMTCk7Ci0JaWYgKElTX0VSUihkZGF0YS0+Y2xrKSkgewotCQlyZXQgPSBQ VFJfRVJSKGRkYXRhLT5jbGspOwotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gZ2V0 IGNsb2NrOiAlZFxuIiwgcmV0KTsKLQkJZ290byBlcnI7Ci0JfQotCi0JcmVzID0gcGxhdGZvcm1f Z2V0X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsKLQlpZiAoIXJlcykgewotCQly ZXQgPSAtRU5PREVWOwotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gZGV0ZXJtaW5l IGJhc2UgYWRkcmVzc1xuIik7Ci0JCWdvdG8gZXJyOwotCX0KLQotCWlmIChyZXNvdXJjZV9zaXpl KHJlcykgPCAweDYwKSB7Ci0JCXJldCA9IC1FSU5WQUw7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwg Im1lbW9yeSByZXNvdXJjZSB0b28gc21hbGxcbiIpOwotCQlnb3RvIGVycjsKLQl9Ci0KLQlkZGF0 YS0+YmFzZSA9IGRldm1faW9yZW1hcF9yZXNvdXJjZSgmcGRldi0+ZGV2LCByZXMpOwotCWlmIChJ U19FUlIoZGRhdGEtPmJhc2UpKSB7Ci0JCXJldCA9IFBUUl9FUlIoZGRhdGEtPmJhc2UpOwotCQln b3RvIGVycjsKLQl9Ci0KLQlyZXQgPSBwbGF0Zm9ybV9nZXRfaXJxKHBkZXYsIDApOwotCWlmIChy ZXQgPD0gMCkKLQkJZ290byBlcnI7Ci0KLQlkZGF0YS0+cnhpcnEgPSByZXQ7Ci0KLQlyZXQgPSBw bGF0Zm9ybV9nZXRfaXJxKHBkZXYsIDEpOwotCWlmIChyZXQgPD0gMCkKLQkJcmV0ID0gZGRhdGEt PnJ4aXJxICsgMTsKLQotCWRkYXRhLT50eGlycSA9IHJldDsKLQotCXJldCA9IGNsa19wcmVwYXJl X2VuYWJsZShkZGF0YS0+Y2xrKTsKLQlpZiAocmV0IDwgMCkgewotCQlkZXZfZXJyKCZwZGV2LT5k ZXYsICJmYWlsZWQgdG8gZW5hYmxlIGNsb2NrICglZClcbiIsIHJldCk7Ci0JCWdvdG8gZXJyOwot CX0KLQotCWVmbTMyX3NwaV9wcm9iZV9kdChwZGV2LCBtYXN0ZXIsIGRkYXRhKTsKLQotCWVmbTMy X3NwaV93cml0ZTMyKGRkYXRhLCAwLCBSRUdfSUVOKTsKLQllZm0zMl9zcGlfd3JpdGUzMihkZGF0 YSwgUkVHX1JPVVRFX1RYUEVOIHwgUkVHX1JPVVRFX1JYUEVOIHwKLQkJCVJFR19ST1VURV9DTEtQ RU4gfAotCQkJUkVHX1JPVVRFX0xPQ0FUSU9OKGRkYXRhLT5wZGF0YS5sb2NhdGlvbiksIFJFR19S T1VURSk7Ci0KLQlyZXQgPSByZXF1ZXN0X2lycShkZGF0YS0+cnhpcnEsIGVmbTMyX3NwaV9yeGly cSwKLQkJCTAsIERSSVZFUl9OQU1FICIgcngiLCBkZGF0YSk7Ci0JaWYgKHJldCkgewotCQlkZXZf ZXJyKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gcmVnaXN0ZXIgcnhpcnEgKCVkKVxuIiwgcmV0KTsK LQkJZ290byBlcnJfZGlzYWJsZV9jbGs7Ci0JfQotCi0JcmV0ID0gcmVxdWVzdF9pcnEoZGRhdGEt PnR4aXJxLCBlZm0zMl9zcGlfdHhpcnEsCi0JCQkwLCBEUklWRVJfTkFNRSAiIHR4IiwgZGRhdGEp OwotCWlmIChyZXQpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIHJlZ2lzdGVy IHR4aXJxICglZClcbiIsIHJldCk7Ci0JCWdvdG8gZXJyX2ZyZWVfcnhfaXJxOwotCX0KLQotCXJl dCA9IHNwaV9iaXRiYW5nX3N0YXJ0KCZkZGF0YS0+Yml0YmFuZyk7Ci0JaWYgKHJldCkgewotCQlk ZXZfZXJyKCZwZGV2LT5kZXYsICJzcGlfYml0YmFuZ19zdGFydCBmYWlsZWQgKCVkKVxuIiwgcmV0 KTsKLQotCQlmcmVlX2lycShkZGF0YS0+dHhpcnEsIGRkYXRhKTsKLWVycl9mcmVlX3J4X2lycToK LQkJZnJlZV9pcnEoZGRhdGEtPnJ4aXJxLCBkZGF0YSk7Ci1lcnJfZGlzYWJsZV9jbGs6Ci0JCWNs a19kaXNhYmxlX3VucHJlcGFyZShkZGF0YS0+Y2xrKTsKLWVycjoKLQkJc3BpX21hc3Rlcl9wdXQo bWFzdGVyKTsKLQl9Ci0KLQlyZXR1cm4gcmV0OwotfQotCi1zdGF0aWMgaW50IGVmbTMyX3NwaV9y ZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKLXsKLQlzdHJ1Y3Qgc3BpX21hc3Rl ciAqbWFzdGVyID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7Ci0Jc3RydWN0IGVmbTMyX3Nw aV9kZGF0YSAqZGRhdGEgPSBzcGlfbWFzdGVyX2dldF9kZXZkYXRhKG1hc3Rlcik7Ci0KLQlzcGlf Yml0YmFuZ19zdG9wKCZkZGF0YS0+Yml0YmFuZyk7Ci0KLQllZm0zMl9zcGlfd3JpdGUzMihkZGF0 YSwgMCwgUkVHX0lFTik7Ci0KLQlmcmVlX2lycShkZGF0YS0+dHhpcnEsIGRkYXRhKTsKLQlmcmVl X2lycShkZGF0YS0+cnhpcnEsIGRkYXRhKTsKLQljbGtfZGlzYWJsZV91bnByZXBhcmUoZGRhdGEt PmNsayk7Ci0Jc3BpX21hc3Rlcl9wdXQobWFzdGVyKTsKLQotCXJldHVybiAwOwotfQotCi1zdGF0 aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBlZm0zMl9zcGlfZHRfaWRzW10gPSB7Ci0Jewot CQkuY29tcGF0aWJsZSA9ICJlbmVyZ3ltaWNybyxlZm0zMi1zcGkiLAotCX0sIHsKLQkJLyogZG9l c24ndCBmb2xsb3cgdGhlICJ2ZW5kb3IsZGV2aWNlIiBzY2hlbWUsIGRvbid0IHVzZSAqLwotCQku Y29tcGF0aWJsZSA9ICJlZm0zMixzcGkiLAotCX0sIHsKLQkJLyogc2VudGluZWwgKi8KLQl9Ci19 OwotTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgZWZtMzJfc3BpX2R0X2lkcyk7Ci0KLXN0YXRpYyBz dHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGVmbTMyX3NwaV9kcml2ZXIgPSB7Ci0JLnByb2JlID0gZWZt MzJfc3BpX3Byb2JlLAotCS5yZW1vdmUgPSBlZm0zMl9zcGlfcmVtb3ZlLAotCi0JLmRyaXZlciA9 IHsKLQkJLm5hbWUgPSBEUklWRVJfTkFNRSwKLQkJLm9mX21hdGNoX3RhYmxlID0gZWZtMzJfc3Bp X2R0X2lkcywKLQl9LAotfTsKLW1vZHVsZV9wbGF0Zm9ybV9kcml2ZXIoZWZtMzJfc3BpX2RyaXZl cik7Ci0KLU1PRFVMRV9BVVRIT1IoIlV3ZSBLbGVpbmUtS29lbmlnIDx1LmtsZWluZS1rb2VuaWdA cGVuZ3V0cm9uaXguZGU+Iik7Ci1NT0RVTEVfREVTQ1JJUFRJT04oIkVGTTMyIFNQSSBkcml2ZXIi KTsKLU1PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsKLU1PRFVMRV9BTElBUygicGxhdGZvcm06IiBE UklWRVJfTkFNRSk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3BsYXRmb3JtX2RhdGEvZWZt MzItc3BpLmggYi9pbmNsdWRlL2xpbnV4L3BsYXRmb3JtX2RhdGEvZWZtMzItc3BpLmgKZGVsZXRl ZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGEyYzU2ZmNkMDUzNC4uMDAwMDAwMDAwMDAwCi0tLSBh L2luY2x1ZGUvbGludXgvcGxhdGZvcm1fZGF0YS9lZm0zMi1zcGkuaAorKysgL2Rldi9udWxsCkBA IC0xLDE1ICswLDAgQEAKLS8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wICovCi0j aWZuZGVmIF9fTElOVVhfUExBVEZPUk1fREFUQV9FRk0zMl9TUElfSF9fCi0jZGVmaW5lIF9fTElO VVhfUExBVEZPUk1fREFUQV9FRk0zMl9TUElfSF9fCi0KLSNpbmNsdWRlIDxsaW51eC90eXBlcy5o PgotCi0vKioKLSAqIHN0cnVjdCBlZm0zMl9zcGlfcGRhdGEKLSAqIEBsb2NhdGlvbjogcGlubXV4 IGxvY2F0aW9uIGZvciB0aGUgSS9PIHBpbnMgKHRvIGJlIHdyaXR0ZW4gdG8gdGhlIFJPVVRFCi0g KiAJcmVnaXN0ZXIpCi0gKi8KLXN0cnVjdCBlZm0zMl9zcGlfcGRhdGEgewotCXU4IGxvY2F0aW9u OwotfTsKLSNlbmRpZiAvKiBpZm5kZWYgX19MSU5VWF9QTEFURk9STV9EQVRBX0VGTTMyX1NQSV9I X18gKi8KLS0gCjIuMjkuMgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxA bGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK