From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753953AbeEaFvV (ORCPT ); Thu, 31 May 2018 01:51:21 -0400 Received: from mga11.intel.com ([192.55.52.93]:55268 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753770AbeEaFvQ (ORCPT ); Thu, 31 May 2018 01:51:16 -0400 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.49,462,1520924400"; d="scan'208";a="233383260" From: "Hean-Loong, Ong" To: Rob Herring , Dinh Nguyen , Daniel Vetter , Laurent Pinchart Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, dri-devel@lists.freedesktop.org, hean.loong.ong@intel.com, yves.vandervennet@intel.com, chin.liang.see@intel.com Subject: [PATCH] ARM:drm ivip Intel FPGA Video and Image Processing Suite Date: Thu, 31 May 2018 13:50:51 +0800 Message-Id: <1527745851-3339-4-git-send-email-hean.loong.ong@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1527745851-3339-1-git-send-email-hean.loong.ong@intel.com> References: <1527745851-3339-1-git-send-email-hean.loong.ong@intel.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Ong Hean Loong Driver for Intel FPGA Video and Image Processing Suite Frame Buffer II. The driver only supports the Intel Arria10 devkit and its variants. This driver can be either loaded staticlly or in modules. The OF device tree binding is located at: Documentation/devicetree/bindings/display/altr,vip-fb2.txt Signed-off-by: Ong Hean Loong --- drivers/gpu/drm/Kconfig | 2 + drivers/gpu/drm/Makefile | 1 + drivers/gpu/drm/ivip/Kconfig | 14 +++ drivers/gpu/drm/ivip/Makefile | 9 ++ drivers/gpu/drm/ivip/intel_vip_conn.c | 95 ++++++++++++++++ drivers/gpu/drm/ivip/intel_vip_core.c | 163 ++++++++++++++++++++++++++++ drivers/gpu/drm/ivip/intel_vip_drv.h | 52 +++++++++ drivers/gpu/drm/ivip/intel_vip_of.c | 193 +++++++++++++++++++++++++++++++++ 8 files changed, 529 insertions(+), 0 deletions(-) create mode 100644 drivers/gpu/drm/ivip/Kconfig create mode 100644 drivers/gpu/drm/ivip/Makefile create mode 100644 drivers/gpu/drm/ivip/intel_vip_conn.c create mode 100644 drivers/gpu/drm/ivip/intel_vip_core.c create mode 100644 drivers/gpu/drm/ivip/intel_vip_drv.h create mode 100644 drivers/gpu/drm/ivip/intel_vip_of.c diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index deeefa7..cdc8e1a 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -204,6 +204,8 @@ source "drivers/gpu/drm/nouveau/Kconfig" source "drivers/gpu/drm/i915/Kconfig" +source "drivers/gpu/drm/ivip/Kconfig" + config DRM_VGEM tristate "Virtual GEM provider" depends on DRM diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 50093ff..c0fba1d 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -60,6 +60,7 @@ obj-$(CONFIG_DRM_AMDGPU)+= amd/amdgpu/ obj-$(CONFIG_DRM_MGA) += mga/ obj-$(CONFIG_DRM_I810) += i810/ obj-$(CONFIG_DRM_I915) += i915/ +obj-$(CONFIG_DRM_IVIP) += ivip/ obj-$(CONFIG_DRM_MGAG200) += mgag200/ obj-$(CONFIG_DRM_VC4) += vc4/ obj-$(CONFIG_DRM_CIRRUS_QEMU) += cirrus/ diff --git a/drivers/gpu/drm/ivip/Kconfig b/drivers/gpu/drm/ivip/Kconfig new file mode 100644 index 0000000..1d08b90 --- /dev/null +++ b/drivers/gpu/drm/ivip/Kconfig @@ -0,0 +1,14 @@ +config DRM_IVIP + tristate "Intel FGPA Video and Image Processing" + depends on DRM && OF + select DRM_GEM_CMA_HELPER + select DRM_KMS_HELPER + select DRM_KMS_FB_HELPER + select DRM_KMS_CMA_HELPER + help + Choose this option if you have an Intel FPGA Arria 10 system + and above with an Intel Display Port IP. This does not support + legacy Intel FPGA Cyclone V display port. Currently only single + frame buffer is supported. Note that ACPI and X_86 architecture + is not supported for Arria10. If M is selected the module will be + called ivip. diff --git a/drivers/gpu/drm/ivip/Makefile b/drivers/gpu/drm/ivip/Makefile new file mode 100644 index 0000000..cc55b04 --- /dev/null +++ b/drivers/gpu/drm/ivip/Makefile @@ -0,0 +1,9 @@ +# +# Makefile for the drm device driver. This driver provides support for the +# Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher. + +ccflags-y := -Iinclude/drm + +obj-$(CONFIG_DRM_IVIP) += ivip.o +ivip-objs := intel_vip_of.o intel_vip_core.o \ + intel_vip_conn.o diff --git a/drivers/gpu/drm/ivip/intel_vip_conn.c b/drivers/gpu/drm/ivip/intel_vip_conn.c new file mode 100644 index 0000000..46bb04c --- /dev/null +++ b/drivers/gpu/drm/ivip/intel_vip_conn.c @@ -0,0 +1,95 @@ +/* + * intel_vip_conn.c -- Intel Video and Image Processing(VIP) + * Frame Buffer II driver + * + * This driver supports the Intel VIP Frame Reader component. + * More info on the hardware can be found in the Intel Video + * and Image Processing Suite User Guide at this address + * http://www.altera.com/literature/ug/ug_vip.pdf. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * Authors: + * Ong, Hean-Loong + * + */ + +#include +#include +#include +#include +#include +#include + +static enum drm_connector_status +intelvipfb_drm_connector_detect(struct drm_connector *connector, bool force) +{ + return connector_status_connected; +} + +static void intelvipfb_drm_connector_destroy(struct drm_connector *connector) +{ + drm_connector_unregister(connector); + drm_connector_cleanup(connector); +} + +static const struct drm_connector_funcs intelvipfb_drm_connector_funcs = { + .reset = drm_atomic_helper_connector_reset, + .detect = intelvipfb_drm_connector_detect, + .fill_modes = drm_helper_probe_single_connector_modes, + .destroy = intelvipfb_drm_connector_destroy, + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, +}; + +static int intelvipfb_drm_connector_get_modes(struct drm_connector *connector) +{ + struct drm_device *drm = connector->dev; + int count; + + count = drm_add_modes_noedid(connector, drm->mode_config.max_width, + drm->mode_config.max_height); + drm_set_preferred_mode(connector, drm->mode_config.max_width, + drm->mode_config.max_height); + return count; +} + +static const struct drm_connector_helper_funcs +intelvipfb_drm_connector_helper_funcs = { + .get_modes = intelvipfb_drm_connector_get_modes, +}; + +struct drm_connector * +intelvipfb_conn_setup(struct drm_device *drm) +{ + struct drm_connector *conn; + int ret; + + conn = devm_kzalloc(drm->dev, sizeof(*conn), GFP_KERNEL); + if (IS_ERR(conn)) + return NULL; + + ret = drm_connector_init(drm, conn, &intelvipfb_drm_connector_funcs, + DRM_MODE_CONNECTOR_DisplayPort); + if (ret < 0) { + dev_err(drm->dev, "failed to initialize drm connector\n"); + ret = -ENOMEM; + goto error_connector_cleanup; + } + + conn->polled = 0; + drm_connector_helper_add(conn, &intelvipfb_drm_connector_helper_funcs); + + return conn; + +error_connector_cleanup: + drm_connector_cleanup(conn); + + return NULL; +} diff --git a/drivers/gpu/drm/ivip/intel_vip_core.c b/drivers/gpu/drm/ivip/intel_vip_core.c new file mode 100644 index 0000000..a09e1ca --- /dev/null +++ b/drivers/gpu/drm/ivip/intel_vip_core.c @@ -0,0 +1,163 @@ +/* + * intel_vip_core.c -- Intel Video and Image Processing(VIP) + * Frame Buffer II driver + * + * This driver supports the Intel VIP Frame Reader component. + * More info on the hardware can be found in the Intel Video + * and Image Processing Suite User Guide at this address + * http://www.altera.com/literature/ug/ug_vip.pdf. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * Authors: + * Ong, Hean-Loong + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "intel_vip_drv.h" + +static void intelvipfb_enable(struct drm_simple_display_pipe *pipe, + struct drm_crtc_state *crtc_state) +{ + /* + * The frameinfo variable has to correspond to the size of the VIP Suite + * Frame Reader register 7 which will determine the maximum size used + * in this frameinfo + */ + + u32 frameinfo; + struct intelvipfb_priv *priv = pipe->plane.dev->dev_private; + void __iomem *base = priv->base; + struct drm_plane_state *state = pipe->plane.state; + dma_addr_t addr; + + addr = drm_fb_cma_get_gem_addr(state->fb, state, 0); + + dev_info(pipe->plane.dev->dev, "Address 0x%x\n", addr); + + frameinfo = + readl(base + INTELVIPFB_FRAME_READER) & 0x00ffffff; + writel(frameinfo, base + INTELVIPFB_FRAME_INFO); + writel(addr, base + INTELVIPFB_FRAME_START); + /* Finally set the control register to 1 to start streaming */ + writel(1, base + INTELVIPFB_CONTROL); +} + +static void intelvipfb_disable(struct drm_simple_display_pipe *pipe) +{ + struct intelvipfb_priv *priv = pipe->plane.dev->dev_private; + void __iomem *base = priv->base; + /* set the control register to 0 to stop streaming */ + writel(0, base + INTELVIPFB_CONTROL); +} + +static const struct drm_mode_config_funcs intelvipfb_mode_config_funcs = { + .fb_create = drm_gem_fb_create, + .atomic_check = drm_atomic_helper_check, + .atomic_commit = drm_atomic_helper_commit, +}; + +static void intelvipfb_setup_mode_config(struct drm_device *drm) +{ + drm_mode_config_init(drm); + drm->mode_config.funcs = &intelvipfb_mode_config_funcs; +} + +static int intelvipfb_pipe_prepare_fb(struct drm_simple_display_pipe *pipe, + struct drm_plane_state *plane_state) +{ + return drm_gem_fb_prepare_fb(&pipe->plane, plane_state); +} + + +static struct drm_simple_display_pipe_funcs fbpriv_funcs = { + .prepare_fb = intelvipfb_pipe_prepare_fb, + .enable = intelvipfb_enable, + .disable = intelvipfb_disable +}; + +int intelvipfb_probe(struct device *dev) +{ + int retval; + struct drm_device *drm; + struct intelvipfb_priv *fbpriv = dev_get_drvdata(dev); + struct drm_connector *connector; + u32 formats[] = {DRM_FORMAT_XRGB8888}; + + drm = fbpriv->drm; + + drm->dev_private = fbpriv; + + intelvipfb_setup_mode_config(drm); + + connector = intelvipfb_conn_setup(drm); + if (!connector) { + dev_err(drm->dev, "Connector setup failed\n"); + goto err_mode_config; + } + + retval = drm_simple_display_pipe_init(drm, &fbpriv->pipe, + &fbpriv_funcs, formats, + ARRAY_SIZE(formats), NULL, connector); + if (retval < 0) { + dev_err(drm->dev, "Cannot setup simple display pipe\n"); + goto err_mode_config; + } + + fbpriv->fbcma = drm_fbdev_cma_init(drm, + drm->mode_config.preferred_depth, + drm->mode_config.num_connector); + + drm_mode_config_reset(drm); + + drm_dev_register(drm, 0); + + return retval; + +err_mode_config: + + drm_mode_config_cleanup(drm); + return -ENODEV; +} + +int intelvipfb_remove(struct device *dev) +{ + struct intelvipfb_priv *fbpriv = dev_get_drvdata(dev); + struct drm_device *drm = fbpriv->drm; + + drm_dev_unregister(drm); + + if (fbpriv->fbcma) + drm_fbdev_cma_fini(fbpriv->fbcma); + + drm_mode_config_cleanup(drm); + drm_dev_unref(drm); + + return 0; +} + +MODULE_AUTHOR("Ong, Hean-Loong "); +MODULE_DESCRIPTION("Intel VIP Frame Buffer II driver"); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/gpu/drm/ivip/intel_vip_drv.h b/drivers/gpu/drm/ivip/intel_vip_drv.h new file mode 100644 index 0000000..0a3555d --- /dev/null +++ b/drivers/gpu/drm/ivip/intel_vip_drv.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2017 Intel Corporation. + * + * Intel Video and Image Processing(VIP) Frame Buffer II driver. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * this program. If not, see . + * + * Authors: + * Ong, Hean-Loong + * + */ +#ifndef _INTEL_VIP_DRV_H +#define _INTEL_VIP_DRV_H + +#define DRIVER_NAME "intelvipfb" +#define BYTES_PER_PIXEL 4 +#define CRTC_NUM 1 +#define CONN_NUM 1 + +/* control registers */ +#define INTELVIPFB_CONTROL 0 +#define INTELVIPFB_STATUS 0x4 +#define INTELVIPFB_INTERRUPT 0x8 +#define INTELVIPFB_FRAME_COUNTER 0xC +#define INTELVIPFB_FRAME_DROP 0x10 +#define INTELVIPFB_FRAME_INFO 0x14 +#define INTELVIPFB_FRAME_START 0x18 +#define INTELVIPFB_FRAME_READER 0x1C + +int intelvipfb_probe(struct device *dev); +int intelvipfb_remove(struct device *dev); +int intelvipfb_setup_crtc(struct drm_device *drm); +struct drm_connector *intelvipfb_conn_setup(struct drm_device *drm); + +struct intelvipfb_priv { + struct drm_simple_display_pipe pipe; + struct drm_fbdev_cma *fbcma; + struct drm_device *drm; + void __iomem *base; +}; + +#endif diff --git a/drivers/gpu/drm/ivip/intel_vip_of.c b/drivers/gpu/drm/ivip/intel_vip_of.c new file mode 100644 index 0000000..47302f9 --- /dev/null +++ b/drivers/gpu/drm/ivip/intel_vip_of.c @@ -0,0 +1,193 @@ +/* + * intel_vip_of.c -- Intel Video and Image Processing(VIP) + * Frame Buffer II driver + * + * This driver supports the Intel VIP Frame Reader component. + * More info on the hardware can be found in the Intel Video + * and Image Processing Suite User Guide at this address + * http://www.altera.com/literature/ug/ug_vip.pdf. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * Authors: + * Ong, Hean-Loong + * + */ +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "intel_vip_drv.h" + +DEFINE_DRM_GEM_CMA_FOPS(drm_fops); + +static void intelvipfb_lastclose(struct drm_device *drm) +{ + struct intelvipfb_priv *priv = drm->dev_private; + + drm_fbdev_cma_restore_mode(priv->fbcma); +} + +static struct drm_driver intelvipfb_drm = { + .driver_features = + DRIVER_MODESET | DRIVER_GEM | + DRIVER_PRIME | DRIVER_ATOMIC, + .gem_free_object_unlocked = drm_gem_cma_free_object, + .gem_vm_ops = &drm_gem_cma_vm_ops, + .dumb_create = drm_gem_cma_dumb_create, + .dumb_destroy = drm_gem_dumb_destroy, + .prime_handle_to_fd = drm_gem_prime_handle_to_fd, + .prime_fd_to_handle = drm_gem_prime_fd_to_handle, + .gem_prime_export = drm_gem_prime_export, + .gem_prime_import = drm_gem_prime_import, + .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table, + .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table, + .gem_prime_vmap = drm_gem_cma_prime_vmap, + .gem_prime_vunmap = drm_gem_cma_prime_vunmap, + .gem_prime_mmap = drm_gem_cma_prime_mmap, + .lastclose = intelvipfb_lastclose, + .name = DRIVER_NAME, + .date = "20170729", + .desc = "Intel FPGA VIP SUITE", + .major = 1, + .minor = 0, + .ioctls = NULL, + .patchlevel = 0, + .fops = &drm_fops, +}; + +/* + * Setting up information derived from OF Device Tree Nodes + * max-width, max-height, bits per pixel, memory port width + */ + +static int intelvipfb_drm_setup(struct device *dev, + struct intelvipfb_priv *fbpriv) +{ + struct drm_device *drm = fbpriv->drm; + struct device_node *np = dev->of_node; + int mem_word_width; + int max_h, max_w; + int ret; + + ret = of_property_read_u32(np, "altr,max-width", &max_w); + if (ret) { + dev_err(dev, + "Missing required parameter 'altr,max-width'"); + return ret; + } + + ret = of_property_read_u32(np, "altr,max-height", &max_h); + if (ret) { + dev_err(dev, + "Missing required parameter 'altr,max-height'"); + return ret; + } + + ret = of_property_read_u32(np, "altr,mem-port-width", &mem_word_width); + if (ret) { + dev_err(dev, "Missing required parameter 'altr,mem-port-width '"); + return ret; + } + + if (!(mem_word_width >= 32 && mem_word_width % 32 == 0)) { + dev_err(dev, + "mem-word-width is set to %i. must be >= 32 and multiple of 32.", + mem_word_width); + return -ENODEV; + } + + drm->mode_config.min_width = 640; + drm->mode_config.min_height = 480; + drm->mode_config.max_width = max_w; + drm->mode_config.max_height = max_h; + drm->mode_config.preferred_depth = 32; + + return 0; +} + +static int intelvipfb_of_probe(struct platform_device *pdev) +{ + int retval; + struct resource *reg_res; + struct intelvipfb_priv *fbpriv; + struct device *dev = &pdev->dev; + struct drm_device *drm; + + fbpriv = devm_kzalloc(dev, sizeof(*fbpriv), GFP_KERNEL); + if (!fbpriv) + return -ENOMEM; + + /*setup DRM */ + drm = drm_dev_alloc(&intelvipfb_drm, dev); + if (IS_ERR(drm)) + return PTR_ERR(drm); + + retval = dma_set_mask_and_coherent(drm->dev, DMA_BIT_MASK(32)); + if (retval) + return -ENODEV; + + fbpriv->drm = drm; + + reg_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!reg_res) + return -ENOMEM; + + fbpriv->base = devm_ioremap_resource(dev, reg_res); + + if (IS_ERR(fbpriv->base)) { + dev_err(dev, "devm_ioremap_resource failed\n"); + retval = PTR_ERR(fbpriv->base); + return -ENOMEM; + } + + intelvipfb_drm_setup(dev, fbpriv); + + dev_set_drvdata(dev, fbpriv); + + return intelvipfb_probe(dev); +} + +static int intelvipfb_of_remove(struct platform_device *pdev) +{ + return intelvipfb_remove(&pdev->dev); +} + +/* + * The name vip-frame-buffer-2.0 is derived from + * http://www.altera.com/literature/ug/ug_vip.pdf + * frame buffer IP cores section 14 + */ + +static const struct of_device_id intelvipfb_of_match[] = { + { .compatible = "altr,vip-frame-buffer-2.0" }, + {}, +}; + +MODULE_DEVICE_TABLE(of, intelvipfb_of_match); + +static struct platform_driver intelvipfb_driver = { + .probe = intelvipfb_of_probe, + .remove = intelvipfb_of_remove, + .driver = { + .name = DRIVER_NAME, + .of_match_table = intelvipfb_of_match, + }, +}; + +module_platform_driver(intelvipfb_driver); -- 1.7.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Hean-Loong, Ong" Subject: [PATCH] ARM:drm ivip Intel FPGA Video and Image Processing Suite Date: Thu, 31 May 2018 13:50:51 +0800 Message-ID: <1527745851-3339-4-git-send-email-hean.loong.ong@intel.com> References: <1527745851-3339-1-git-send-email-hean.loong.ong@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1527745851-3339-1-git-send-email-hean.loong.ong@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Rob Herring , Dinh Nguyen , Daniel Vetter , Laurent Pinchart Cc: devicetree@vger.kernel.org, yves.vandervennet@intel.com, hean.loong.ong@intel.com, chin.liang.see@intel.com, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-arm-kernel@lists.infradead.org List-Id: devicetree@vger.kernel.org RnJvbTogT25nIEhlYW4gTG9vbmcgPGhlYW4ubG9vbmcub25nQGludGVsLmNvbT4KCkRyaXZlciBm b3IgSW50ZWwgRlBHQSBWaWRlbyBhbmQgSW1hZ2UgUHJvY2Vzc2luZyBTdWl0ZSBGcmFtZSBCdWZm ZXIgSUkuClRoZSBkcml2ZXIgb25seSBzdXBwb3J0cyB0aGUgSW50ZWwgQXJyaWExMCBkZXZraXQg YW5kIGl0cyB2YXJpYW50cy4KVGhpcyBkcml2ZXIgY2FuIGJlIGVpdGhlciBsb2FkZWQgc3RhdGlj bGx5IG9yIGluIG1vZHVsZXMuClRoZSBPRiBkZXZpY2UgdHJlZSBiaW5kaW5nIGlzIGxvY2F0ZWQg YXQ6CkRvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9kaXNwbGF5L2FsdHIsdmlwLWZi Mi50eHQKClNpZ25lZC1vZmYtYnk6IE9uZyBIZWFuIExvb25nIDxoZWFuLmxvb25nLm9uZ0BpbnRl bC5jb20+Ci0tLQogZHJpdmVycy9ncHUvZHJtL0tjb25maWcgICAgICAgICAgICAgICB8ICAgIDIg KwogZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlICAgICAgICAgICAgICB8ICAgIDEgKwogZHJpdmVy cy9ncHUvZHJtL2l2aXAvS2NvbmZpZyAgICAgICAgICB8ICAgMTQgKysrCiBkcml2ZXJzL2dwdS9k cm0vaXZpcC9NYWtlZmlsZSAgICAgICAgIHwgICAgOSArKwogZHJpdmVycy9ncHUvZHJtL2l2aXAv aW50ZWxfdmlwX2Nvbm4uYyB8ICAgOTUgKysrKysrKysrKysrKysrKwogZHJpdmVycy9ncHUvZHJt L2l2aXAvaW50ZWxfdmlwX2NvcmUuYyB8ICAxNjMgKysrKysrKysrKysrKysrKysrKysrKysrKysr KwogZHJpdmVycy9ncHUvZHJtL2l2aXAvaW50ZWxfdmlwX2Rydi5oICB8ICAgNTIgKysrKysrKysr CiBkcml2ZXJzL2dwdS9kcm0vaXZpcC9pbnRlbF92aXBfb2YuYyAgIHwgIDE5MyArKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysKIDggZmlsZXMgY2hhbmdlZCwgNTI5IGluc2VydGlvbnMo KyksIDAgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2l2 aXAvS2NvbmZpZwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9pdmlwL01ha2Vm aWxlCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2l2aXAvaW50ZWxfdmlwX2Nv bm4uYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9pdmlwL2ludGVsX3ZpcF9j b3JlLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vaXZpcC9pbnRlbF92aXBf ZHJ2LmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vaXZpcC9pbnRlbF92aXBf b2YuYwoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnIGIvZHJpdmVycy9ncHUv ZHJtL0tjb25maWcKaW5kZXggZGVlZWZhNy4uY2RjOGUxYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL0tjb25maWcKKysrIGIvZHJpdmVycy9ncHUvZHJtL0tjb25maWcKQEAgLTIwNCw2ICsy MDQsOCBAQCBzb3VyY2UgImRyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L0tjb25maWciCiAKIHNvdXJj ZSAiZHJpdmVycy9ncHUvZHJtL2k5MTUvS2NvbmZpZyIKIAorc291cmNlICJkcml2ZXJzL2dwdS9k cm0vaXZpcC9LY29uZmlnIgorCiBjb25maWcgRFJNX1ZHRU0KIAl0cmlzdGF0ZSAiVmlydHVhbCBH RU0gcHJvdmlkZXIiCiAJZGVwZW5kcyBvbiBEUk0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQppbmRleCA1MDA5M2ZmLi5jMGZi YTFkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUKKysrIGIvZHJpdmVycy9n cHUvZHJtL01ha2VmaWxlCkBAIC02MCw2ICs2MCw3IEBAIG9iai0kKENPTkZJR19EUk1fQU1ER1BV KSs9IGFtZC9hbWRncHUvCiBvYmotJChDT05GSUdfRFJNX01HQSkJKz0gbWdhLwogb2JqLSQoQ09O RklHX0RSTV9JODEwKQkrPSBpODEwLwogb2JqLSQoQ09ORklHX0RSTV9JOTE1KQkrPSBpOTE1Lwor b2JqLSQoQ09ORklHX0RSTV9JVklQKSArPSBpdmlwLwogb2JqLSQoQ09ORklHX0RSTV9NR0FHMjAw KSArPSBtZ2FnMjAwLwogb2JqLSQoQ09ORklHX0RSTV9WQzQpICArPSB2YzQvCiBvYmotJChDT05G SUdfRFJNX0NJUlJVU19RRU1VKSArPSBjaXJydXMvCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vaXZpcC9LY29uZmlnIGIvZHJpdmVycy9ncHUvZHJtL2l2aXAvS2NvbmZpZwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xZDA4YjkwCi0tLSAvZGV2L251bGwKKysrIGIvZHJp dmVycy9ncHUvZHJtL2l2aXAvS2NvbmZpZwpAQCAtMCwwICsxLDE0IEBACitjb25maWcgRFJNX0lW SVAKKyAgICAgICAgdHJpc3RhdGUgIkludGVsIEZHUEEgVmlkZW8gYW5kIEltYWdlIFByb2Nlc3Np bmciCisgICAgICAgIGRlcGVuZHMgb24gRFJNICYmIE9GCisgICAgICAgIHNlbGVjdCBEUk1fR0VN X0NNQV9IRUxQRVIKKyAgICAgICAgc2VsZWN0IERSTV9LTVNfSEVMUEVSCisgICAgICAgIHNlbGVj dCBEUk1fS01TX0ZCX0hFTFBFUgorICAgICAgICBzZWxlY3QgRFJNX0tNU19DTUFfSEVMUEVSCisg ICAgICAgIGhlbHAKKwkJICBDaG9vc2UgdGhpcyBvcHRpb24gaWYgeW91IGhhdmUgYW4gSW50ZWwg RlBHQSBBcnJpYSAxMCBzeXN0ZW0KKwkJICBhbmQgYWJvdmUgd2l0aCBhbiBJbnRlbCBEaXNwbGF5 IFBvcnQgSVAuIFRoaXMgZG9lcyBub3Qgc3VwcG9ydAorCQkgIGxlZ2FjeSBJbnRlbCBGUEdBIEN5 Y2xvbmUgViBkaXNwbGF5IHBvcnQuIEN1cnJlbnRseSBvbmx5IHNpbmdsZQorCQkgIGZyYW1lIGJ1 ZmZlciBpcyBzdXBwb3J0ZWQuIE5vdGUgdGhhdCBBQ1BJIGFuZCBYXzg2IGFyY2hpdGVjdHVyZQor CQkgIGlzIG5vdCBzdXBwb3J0ZWQgZm9yIEFycmlhMTAuIElmIE0gaXMgc2VsZWN0ZWQgdGhlIG1v ZHVsZSB3aWxsIGJlCisJCSAgY2FsbGVkIGl2aXAuCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vaXZpcC9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9pdmlwL01ha2VmaWxlCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmNjNTViMDQKLS0tIC9kZXYvbnVsbAorKysgYi9k cml2ZXJzL2dwdS9kcm0vaXZpcC9NYWtlZmlsZQpAQCAtMCwwICsxLDkgQEAKKyMKKyMgTWFrZWZp bGUgZm9yIHRoZSBkcm0gZGV2aWNlIGRyaXZlci4gIFRoaXMgZHJpdmVyIHByb3ZpZGVzIHN1cHBv cnQgZm9yIHRoZQorIyBEaXJlY3QgUmVuZGVyaW5nIEluZnJhc3RydWN0dXJlIChEUkkpIGluIFhG cmVlODYgNC4xLjAgYW5kIGhpZ2hlci4KKworY2NmbGFncy15IDo9IC1JaW5jbHVkZS9kcm0KKwor b2JqLSQoQ09ORklHX0RSTV9JVklQKSArPSBpdmlwLm8KK2l2aXAtb2JqcyA6PSBpbnRlbF92aXBf b2YubyBpbnRlbF92aXBfY29yZS5vIFwKKwlpbnRlbF92aXBfY29ubi5vCmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vaXZpcC9pbnRlbF92aXBfY29ubi5jIGIvZHJpdmVycy9ncHUvZHJtL2l2 aXAvaW50ZWxfdmlwX2Nvbm4uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40 NmJiMDRjCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL2l2aXAvaW50ZWxfdmlw X2Nvbm4uYwpAQCAtMCwwICsxLDk1IEBACisvKgorICogaW50ZWxfdmlwX2Nvbm4uYyAtLSBJbnRl bCBWaWRlbyBhbmQgSW1hZ2UgUHJvY2Vzc2luZyhWSVApCisgKiBGcmFtZSBCdWZmZXIgSUkgZHJp dmVyCisgKgorICogVGhpcyBkcml2ZXIgc3VwcG9ydHMgdGhlIEludGVsIFZJUCBGcmFtZSBSZWFk ZXIgY29tcG9uZW50LgorICogTW9yZSBpbmZvIG9uIHRoZSBoYXJkd2FyZSBjYW4gYmUgZm91bmQg aW4gdGhlIEludGVsIFZpZGVvCisgKiBhbmQgSW1hZ2UgUHJvY2Vzc2luZyBTdWl0ZSBVc2VyIEd1 aWRlIGF0IHRoaXMgYWRkcmVzcworICogaHR0cDovL3d3dy5hbHRlcmEuY29tL2xpdGVyYXR1cmUv dWcvdWdfdmlwLnBkZi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91 IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1z IGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKKyAqIHZl cnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisg KgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIGl0IHdpbGwgYmUg dXNlZnVsLCBidXQgV0lUSE9VVAorICogQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGlt cGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yCisgKiBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9y CisgKiBtb3JlIGRldGFpbHMuCisgKgorICogQXV0aG9yczoKKyAqIE9uZywgSGVhbi1Mb29uZyA8 aGVhbi5sb29uZy5vbmdAaW50ZWwuY29tPgorICoKKyAqLworCisjaW5jbHVkZSA8bGludXgvaW5p dC5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGRybS9kcm1fYXRvbWlj X2hlbHBlci5oPgorI2luY2x1ZGUgPGRybS9kcm1fY3J0Y19oZWxwZXIuaD4KKyNpbmNsdWRlIDxk cm0vZHJtX2VuY29kZXJfc2xhdmUuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX3BsYW5lX2hlbHBlci5o PgorCitzdGF0aWMgZW51bSBkcm1fY29ubmVjdG9yX3N0YXR1cworaW50ZWx2aXBmYl9kcm1fY29u bmVjdG9yX2RldGVjdChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yLCBib29sIGZvcmNl KQoreworCXJldHVybiBjb25uZWN0b3Jfc3RhdHVzX2Nvbm5lY3RlZDsKK30KKworc3RhdGljIHZv aWQgaW50ZWx2aXBmYl9kcm1fY29ubmVjdG9yX2Rlc3Ryb3koc3RydWN0IGRybV9jb25uZWN0b3Ig KmNvbm5lY3RvcikKK3sKKwlkcm1fY29ubmVjdG9yX3VucmVnaXN0ZXIoY29ubmVjdG9yKTsKKwlk cm1fY29ubmVjdG9yX2NsZWFudXAoY29ubmVjdG9yKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVj dCBkcm1fY29ubmVjdG9yX2Z1bmNzIGludGVsdmlwZmJfZHJtX2Nvbm5lY3Rvcl9mdW5jcyA9IHsK KwkucmVzZXQgPSBkcm1fYXRvbWljX2hlbHBlcl9jb25uZWN0b3JfcmVzZXQsCisJLmRldGVjdCA9 IGludGVsdmlwZmJfZHJtX2Nvbm5lY3Rvcl9kZXRlY3QsCisJLmZpbGxfbW9kZXMgPSBkcm1faGVs cGVyX3Byb2JlX3NpbmdsZV9jb25uZWN0b3JfbW9kZXMsCisJLmRlc3Ryb3kgPSBpbnRlbHZpcGZi X2RybV9jb25uZWN0b3JfZGVzdHJveSwKKwkuYXRvbWljX2Rlc3Ryb3lfc3RhdGUgPSBkcm1fYXRv bWljX2hlbHBlcl9jb25uZWN0b3JfZGVzdHJveV9zdGF0ZSwKK307CisKK3N0YXRpYyBpbnQgaW50 ZWx2aXBmYl9kcm1fY29ubmVjdG9yX2dldF9tb2RlcyhzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29u bmVjdG9yKQoreworCXN0cnVjdCBkcm1fZGV2aWNlICpkcm0gPSBjb25uZWN0b3ItPmRldjsKKwlp bnQgY291bnQ7CisKKwljb3VudCA9IGRybV9hZGRfbW9kZXNfbm9lZGlkKGNvbm5lY3RvciwgZHJt LT5tb2RlX2NvbmZpZy5tYXhfd2lkdGgsCisJCQlkcm0tPm1vZGVfY29uZmlnLm1heF9oZWlnaHQp OworCWRybV9zZXRfcHJlZmVycmVkX21vZGUoY29ubmVjdG9yLCBkcm0tPm1vZGVfY29uZmlnLm1h eF93aWR0aCwKKwkJCWRybS0+bW9kZV9jb25maWcubWF4X2hlaWdodCk7CisJcmV0dXJuIGNvdW50 OworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9jb25uZWN0b3JfaGVscGVyX2Z1bmNzCitp bnRlbHZpcGZiX2RybV9jb25uZWN0b3JfaGVscGVyX2Z1bmNzID0geworCS5nZXRfbW9kZXMgPSBp bnRlbHZpcGZiX2RybV9jb25uZWN0b3JfZ2V0X21vZGVzLAorfTsKKworc3RydWN0IGRybV9jb25u ZWN0b3IgKgoraW50ZWx2aXBmYl9jb25uX3NldHVwKHN0cnVjdCBkcm1fZGV2aWNlICpkcm0pCit7 CisJc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm47CisJaW50IHJldDsKKworCWNvbm4gPSBkZXZt X2t6YWxsb2MoZHJtLT5kZXYsIHNpemVvZigqY29ubiksIEdGUF9LRVJORUwpOworCWlmIChJU19F UlIoY29ubikpCisJCXJldHVybiBOVUxMOworCisJcmV0ID0gZHJtX2Nvbm5lY3Rvcl9pbml0KGRy bSwgY29ubiwgJmludGVsdmlwZmJfZHJtX2Nvbm5lY3Rvcl9mdW5jcywKKwkJCURSTV9NT0RFX0NP Tk5FQ1RPUl9EaXNwbGF5UG9ydCk7CisJaWYgKHJldCA8IDApIHsKKwkJZGV2X2Vycihkcm0tPmRl diwgImZhaWxlZCB0byBpbml0aWFsaXplIGRybSBjb25uZWN0b3JcbiIpOworCQlyZXQgPSAtRU5P TUVNOworCQlnb3RvIGVycm9yX2Nvbm5lY3Rvcl9jbGVhbnVwOworCX0KKworCWNvbm4tPnBvbGxl ZCA9IDA7CisJZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfYWRkKGNvbm4sICZpbnRlbHZpcGZiX2RybV9j b25uZWN0b3JfaGVscGVyX2Z1bmNzKTsKKworCXJldHVybiBjb25uOworCitlcnJvcl9jb25uZWN0 b3JfY2xlYW51cDoKKwlkcm1fY29ubmVjdG9yX2NsZWFudXAoY29ubik7CisKKwlyZXR1cm4gTlVM TDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pdmlwL2ludGVsX3ZpcF9jb3JlLmMg Yi9kcml2ZXJzL2dwdS9kcm0vaXZpcC9pbnRlbF92aXBfY29yZS5jCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAuLmEwOWUxY2EKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dw dS9kcm0vaXZpcC9pbnRlbF92aXBfY29yZS5jCkBAIC0wLDAgKzEsMTYzIEBACisvKgorICogaW50 ZWxfdmlwX2NvcmUuYyAtLSBJbnRlbCBWaWRlbyBhbmQgSW1hZ2UgUHJvY2Vzc2luZyhWSVApCisg KiBGcmFtZSBCdWZmZXIgSUkgZHJpdmVyCisgKgorICogVGhpcyBkcml2ZXIgc3VwcG9ydHMgdGhl IEludGVsIFZJUCBGcmFtZSBSZWFkZXIgY29tcG9uZW50LgorICogTW9yZSBpbmZvIG9uIHRoZSBo YXJkd2FyZSBjYW4gYmUgZm91bmQgaW4gdGhlIEludGVsIFZpZGVvCisgKiBhbmQgSW1hZ2UgUHJv Y2Vzc2luZyBTdWl0ZSBVc2VyIEd1aWRlIGF0IHRoaXMgYWRkcmVzcworICogaHR0cDovL3d3dy5h bHRlcmEuY29tL2xpdGVyYXR1cmUvdWcvdWdfdmlwLnBkZi4KKyAqCisgKiBUaGlzIHByb2dyYW0g aXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBp dAorICogdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQ dWJsaWMgTGljZW5zZSwKKyAqIHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNv ZnR3YXJlIEZvdW5kYXRpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIGl0IHdpbGwgYmUgdXNlZnVsLCBidXQgV0lUSE9VVAorICogQU5ZIFdBUlJBTlRZ OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9y CisgKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VIEdlbmVy YWwgUHVibGljIExpY2Vuc2UgZm9yCisgKiBtb3JlIGRldGFpbHMuCisgKgorICogQXV0aG9yczoK KyAqIE9uZywgSGVhbi1Mb29uZyA8aGVhbi5sb29uZy5vbmdAaW50ZWwuY29tPgorICoKKyAqLwor CisjaW5jbHVkZSA8ZHJtL2RybVAuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2F0b21pYy5oPgorI2lu Y2x1ZGUgPGRybS9kcm1fYXRvbWljX2hlbHBlci5oPgorI2luY2x1ZGUgPGRybS9kcm1fY3J0Y19o ZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2ZiX2hlbHBlci5oPgorI2luY2x1ZGUgPGRybS9k cm1fZmJfY21hX2hlbHBlci5oPgorI2luY2x1ZGUgPGRybS9kcm1fZ2VtX2NtYV9oZWxwZXIuaD4K KyNpbmNsdWRlIDxkcm0vZHJtX3BsYW5lX2hlbHBlci5oPgorI2luY2x1ZGUgPGRybS9kcm1fc2lt cGxlX2ttc19oZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2dlbV9mcmFtZWJ1ZmZlcl9oZWxw ZXIuaD4KKworI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwu aD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKworI2luY2x1ZGUgImludGVsX3ZpcF9kcnYu aCIKKworc3RhdGljIHZvaWQgaW50ZWx2aXBmYl9lbmFibGUoc3RydWN0IGRybV9zaW1wbGVfZGlz cGxheV9waXBlICpwaXBlLAorCSAgICAgICBzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNfc3Rh dGUpCit7CisJLyoKKwkgKiBUaGUgZnJhbWVpbmZvIHZhcmlhYmxlIGhhcyB0byBjb3JyZXNwb25k IHRvIHRoZSBzaXplIG9mIHRoZSBWSVAgU3VpdGUKKwkgKiBGcmFtZSBSZWFkZXIgcmVnaXN0ZXIg NyB3aGljaCB3aWxsIGRldGVybWluZSB0aGUgbWF4aW11bSBzaXplIHVzZWQKKwkgKiBpbiB0aGlz IGZyYW1laW5mbworCSAqLworCisJdTMyIGZyYW1laW5mbzsKKwlzdHJ1Y3QgaW50ZWx2aXBmYl9w cml2ICpwcml2ID0gcGlwZS0+cGxhbmUuZGV2LT5kZXZfcHJpdmF0ZTsKKwl2b2lkIF9faW9tZW0g KmJhc2UgPSBwcml2LT5iYXNlOworCXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnN0YXRlID0gcGlw ZS0+cGxhbmUuc3RhdGU7CisJZG1hX2FkZHJfdCBhZGRyOworCisJYWRkciA9IGRybV9mYl9jbWFf Z2V0X2dlbV9hZGRyKHN0YXRlLT5mYiwgc3RhdGUsIDApOworCisJZGV2X2luZm8ocGlwZS0+cGxh bmUuZGV2LT5kZXYsICJBZGRyZXNzIDB4JXhcbiIsIGFkZHIpOworCisJZnJhbWVpbmZvID0KKwkJ cmVhZGwoYmFzZSArIElOVEVMVklQRkJfRlJBTUVfUkVBREVSKSAmIDB4MDBmZmZmZmY7CisJd3Jp dGVsKGZyYW1laW5mbywgYmFzZSArIElOVEVMVklQRkJfRlJBTUVfSU5GTyk7CisJd3JpdGVsKGFk ZHIsIGJhc2UgKyBJTlRFTFZJUEZCX0ZSQU1FX1NUQVJUKTsKKwkvKiBGaW5hbGx5IHNldCB0aGUg Y29udHJvbCByZWdpc3RlciB0byAxIHRvIHN0YXJ0IHN0cmVhbWluZyAqLworCXdyaXRlbCgxLCBi YXNlICsgSU5URUxWSVBGQl9DT05UUk9MKTsKK30KKworc3RhdGljIHZvaWQgaW50ZWx2aXBmYl9k aXNhYmxlKHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSAqcGlwZSkKK3sKKwlzdHJ1Y3Qg aW50ZWx2aXBmYl9wcml2ICpwcml2ID0gcGlwZS0+cGxhbmUuZGV2LT5kZXZfcHJpdmF0ZTsKKwl2 b2lkIF9faW9tZW0gKmJhc2UgPSBwcml2LT5iYXNlOworCS8qIHNldCB0aGUgY29udHJvbCByZWdp c3RlciB0byAwIHRvIHN0b3Agc3RyZWFtaW5nICovCisJd3JpdGVsKDAsIGJhc2UgKyBJTlRFTFZJ UEZCX0NPTlRST0wpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9tb2RlX2NvbmZpZ19m dW5jcyBpbnRlbHZpcGZiX21vZGVfY29uZmlnX2Z1bmNzID0geworCS5mYl9jcmVhdGUgPSBkcm1f Z2VtX2ZiX2NyZWF0ZSwKKwkuYXRvbWljX2NoZWNrID0gZHJtX2F0b21pY19oZWxwZXJfY2hlY2ss CisJLmF0b21pY19jb21taXQgPSBkcm1fYXRvbWljX2hlbHBlcl9jb21taXQsCit9OworCitzdGF0 aWMgdm9pZCBpbnRlbHZpcGZiX3NldHVwX21vZGVfY29uZmlnKHN0cnVjdCBkcm1fZGV2aWNlICpk cm0pCit7CisJZHJtX21vZGVfY29uZmlnX2luaXQoZHJtKTsKKwlkcm0tPm1vZGVfY29uZmlnLmZ1 bmNzID0gJmludGVsdmlwZmJfbW9kZV9jb25maWdfZnVuY3M7Cit9CisKK3N0YXRpYyBpbnQgaW50 ZWx2aXBmYl9waXBlX3ByZXBhcmVfZmIoc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlICpw aXBlLAorCQkJCQlzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFuZV9zdGF0ZSkKK3sKKwlyZXR1 cm4gZHJtX2dlbV9mYl9wcmVwYXJlX2ZiKCZwaXBlLT5wbGFuZSwgcGxhbmVfc3RhdGUpOworfQor CisKK3N0YXRpYyBzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVfZnVuY3MgZmJwcml2X2Z1 bmNzID0geworCS5wcmVwYXJlX2ZiID0gaW50ZWx2aXBmYl9waXBlX3ByZXBhcmVfZmIsCisJLmVu YWJsZSA9IGludGVsdmlwZmJfZW5hYmxlLAorCS5kaXNhYmxlID0gaW50ZWx2aXBmYl9kaXNhYmxl Cit9OworCitpbnQgaW50ZWx2aXBmYl9wcm9iZShzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJaW50 IHJldHZhbDsKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZHJtOworCXN0cnVjdCBpbnRlbHZpcGZiX3By aXYgKmZicHJpdiA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOworCXN0cnVjdCBkcm1fY29ubmVjdG9y ICpjb25uZWN0b3I7CisJdTMyIGZvcm1hdHNbXSA9IHtEUk1fRk9STUFUX1hSR0I4ODg4fTsKKwor CWRybSA9IGZicHJpdi0+ZHJtOworCisJZHJtLT5kZXZfcHJpdmF0ZSA9IGZicHJpdjsKKworCWlu dGVsdmlwZmJfc2V0dXBfbW9kZV9jb25maWcoZHJtKTsKKworCWNvbm5lY3RvciA9IGludGVsdmlw ZmJfY29ubl9zZXR1cChkcm0pOworCWlmICghY29ubmVjdG9yKSB7CisJCWRldl9lcnIoZHJtLT5k ZXYsICJDb25uZWN0b3Igc2V0dXAgZmFpbGVkXG4iKTsKKwkJZ290byBlcnJfbW9kZV9jb25maWc7 CisJfQorCisJcmV0dmFsID0gZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVfaW5pdChkcm0sICZmYnBy aXYtPnBpcGUsCisJCQkmZmJwcml2X2Z1bmNzLCBmb3JtYXRzLAorCQkJQVJSQVlfU0laRShmb3Jt YXRzKSwgTlVMTCwgY29ubmVjdG9yKTsKKwlpZiAocmV0dmFsIDwgMCkgeworCQlkZXZfZXJyKGRy bS0+ZGV2LCAiQ2Fubm90IHNldHVwIHNpbXBsZSBkaXNwbGF5IHBpcGVcbiIpOworCQlnb3RvIGVy cl9tb2RlX2NvbmZpZzsKKwl9CisKKwlmYnByaXYtPmZiY21hID0gZHJtX2ZiZGV2X2NtYV9pbml0 KGRybSwKKwkJCWRybS0+bW9kZV9jb25maWcucHJlZmVycmVkX2RlcHRoLAorCQkJZHJtLT5tb2Rl X2NvbmZpZy5udW1fY29ubmVjdG9yKTsKKworCWRybV9tb2RlX2NvbmZpZ19yZXNldChkcm0pOwor CisJZHJtX2Rldl9yZWdpc3Rlcihkcm0sIDApOworCisJcmV0dXJuIHJldHZhbDsKKworZXJyX21v ZGVfY29uZmlnOgorCisJZHJtX21vZGVfY29uZmlnX2NsZWFudXAoZHJtKTsKKwlyZXR1cm4gLUVO T0RFVjsKK30KKworaW50IGludGVsdmlwZmJfcmVtb3ZlKHN0cnVjdCBkZXZpY2UgKmRldikKK3sK KwlzdHJ1Y3QgaW50ZWx2aXBmYl9wcml2ICpmYnByaXYgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsK KwlzdHJ1Y3QgZHJtX2RldmljZSAqZHJtID0gIGZicHJpdi0+ZHJtOworCisJZHJtX2Rldl91bnJl Z2lzdGVyKGRybSk7CisKKwlpZiAoZmJwcml2LT5mYmNtYSkKKwkJZHJtX2ZiZGV2X2NtYV9maW5p KGZicHJpdi0+ZmJjbWEpOworCisJZHJtX21vZGVfY29uZmlnX2NsZWFudXAoZHJtKTsKKwlkcm1f ZGV2X3VucmVmKGRybSk7CisKKwlyZXR1cm4gMDsKK30KKworTU9EVUxFX0FVVEhPUigiT25nLCBI ZWFuLUxvb25nIDxoZWFuLmxvb25nLm9uZ0BpbnRlbC5jb20+Iik7CitNT0RVTEVfREVTQ1JJUFRJ T04oIkludGVsIFZJUCBGcmFtZSBCdWZmZXIgSUkgZHJpdmVyIik7CitNT0RVTEVfTElDRU5TRSgi R1BMIHYyIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaXZpcC9pbnRlbF92aXBfZHJ2 LmggYi9kcml2ZXJzL2dwdS9kcm0vaXZpcC9pbnRlbF92aXBfZHJ2LmgKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uMGEzNTU1ZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMv Z3B1L2RybS9pdmlwL2ludGVsX3ZpcF9kcnYuaApAQCAtMCwwICsxLDUyIEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDE3IEludGVsIENvcnBvcmF0aW9uLgorICoKKyAqIEludGVsIFZpZGVvIGFu ZCBJbWFnZSBQcm9jZXNzaW5nKFZJUCkgRnJhbWUgQnVmZmVyIElJIGRyaXZlci4KKyAqCisgKiBU aGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5k L29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBH TlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKKyAqIHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5 IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIGl0IHdpbGwgYmUgdXNlZnVsLCBidXQgV0lUSE9VVAorICog QU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hB TlRBQklMSVRZIG9yCisgKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0 aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yCisgKiBtb3JlIGRldGFpbHMuCisgKgor ICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVi bGljIExpY2Vuc2UgYWxvbmcgd2l0aAorICogdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0 dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgorICoKKyAqIEF1dGhvcnM6CisgKiBPbmcsIEhl YW4tTG9vbmcgPGhlYW4ubG9vbmcub25nQGludGVsLmNvbT4KKyAqCisgKi8KKyNpZm5kZWYgX0lO VEVMX1ZJUF9EUlZfSAorI2RlZmluZSBfSU5URUxfVklQX0RSVl9ICisKKyNkZWZpbmUgRFJJVkVS X05BTUUgICAgImludGVsdmlwZmIiCisjZGVmaW5lIEJZVEVTX1BFUl9QSVhFTAkgNAorI2RlZmlu ZSBDUlRDX05VTQkgICAgICAgIDEKKyNkZWZpbmUgQ09OTl9OVU0JICAgICAgICAxCisKKy8qIGNv bnRyb2wgcmVnaXN0ZXJzICovCisjZGVmaW5lIElOVEVMVklQRkJfQ09OVFJPTAkgICAgICAwCisj ZGVmaW5lIElOVEVMVklQRkJfU1RBVFVTCSAgICAgICAweDQKKyNkZWZpbmUgSU5URUxWSVBGQl9J TlRFUlJVUFQJICAgIDB4OAorI2RlZmluZSBJTlRFTFZJUEZCX0ZSQU1FX0NPVU5URVIJMHhDCisj ZGVmaW5lIElOVEVMVklQRkJfRlJBTUVfRFJPUAkgICAweDEwCisjZGVmaW5lIElOVEVMVklQRkJf RlJBTUVfSU5GTwkgICAweDE0CisjZGVmaW5lIElOVEVMVklQRkJfRlJBTUVfU1RBUlQJICAweDE4 CisjZGVmaW5lIElOVEVMVklQRkJfRlJBTUVfUkVBREVSCSAgICAgICAgIDB4MUMKKworaW50IGlu dGVsdmlwZmJfcHJvYmUoc3RydWN0IGRldmljZSAqZGV2KTsKK2ludCBpbnRlbHZpcGZiX3JlbW92 ZShzdHJ1Y3QgZGV2aWNlICpkZXYpOworaW50IGludGVsdmlwZmJfc2V0dXBfY3J0YyhzdHJ1Y3Qg ZHJtX2RldmljZSAqZHJtKTsKK3N0cnVjdCBkcm1fY29ubmVjdG9yICppbnRlbHZpcGZiX2Nvbm5f c2V0dXAoc3RydWN0IGRybV9kZXZpY2UgKmRybSk7CisKK3N0cnVjdCBpbnRlbHZpcGZiX3ByaXYg eworCXN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSBwaXBlOworCXN0cnVjdCBkcm1fZmJk ZXZfY21hICpmYmNtYTsKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZHJtOworCXZvaWQgICAgX19pb21l bSAqYmFzZTsKK307CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2l2aXAv aW50ZWxfdmlwX29mLmMgYi9kcml2ZXJzL2dwdS9kcm0vaXZpcC9pbnRlbF92aXBfb2YuYwpuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40NzMwMmY5Ci0tLSAvZGV2L251bGwKKysr IGIvZHJpdmVycy9ncHUvZHJtL2l2aXAvaW50ZWxfdmlwX29mLmMKQEAgLTAsMCArMSwxOTMgQEAK Ky8qCisgKiBpbnRlbF92aXBfb2YuYyAtLSBJbnRlbCBWaWRlbyBhbmQgSW1hZ2UgUHJvY2Vzc2lu ZyhWSVApCisgKiBGcmFtZSBCdWZmZXIgSUkgZHJpdmVyCisgKgorICogVGhpcyBkcml2ZXIgc3Vw cG9ydHMgdGhlIEludGVsIFZJUCBGcmFtZSBSZWFkZXIgY29tcG9uZW50LgorICogTW9yZSBpbmZv IG9uIHRoZSBoYXJkd2FyZSBjYW4gYmUgZm91bmQgaW4gdGhlIEludGVsIFZpZGVvCisgKiBhbmQg SW1hZ2UgUHJvY2Vzc2luZyBTdWl0ZSBVc2VyIEd1aWRlIGF0IHRoaXMgYWRkcmVzcworICogaHR0 cDovL3d3dy5hbHRlcmEuY29tL2xpdGVyYXR1cmUvdWcvdWdfdmlwLnBkZi4KKyAqCisgKiBUaGlz IHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29y IG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKKyAqIHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3Ry aWJ1dGVkIGluIHRoZSBob3BlIGl0IHdpbGwgYmUgdXNlZnVsLCBidXQgV0lUSE9VVAorICogQU5Z IFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRB QklMSVRZIG9yCisgKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUg R05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yCisgKiBtb3JlIGRldGFpbHMuCisgKgorICog QXV0aG9yczoKKyAqIE9uZywgSGVhbi1Mb29uZyA8aGVhbi5sb29uZy5vbmdAaW50ZWwuY29tPgor ICoKKyAqLworI2luY2x1ZGUgPGRybS9kcm1fZmJfaGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2Ry bV9mYl9jbWFfaGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9nZW1fY21hX2hlbHBlci5oPgor I2luY2x1ZGUgPGRybS9kcm1fb2YuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX3NpbXBsZV9rbXNfaGVs cGVyLmg+CisKKyNpbmNsdWRlIDxsaW51eC9jb21wb25lbnQuaD4KKyNpbmNsdWRlIDxsaW51eC9p bml0Lmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxl Lmg+CisjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisKKyNpbmNsdWRlICJpbnRl bF92aXBfZHJ2LmgiCisKK0RFRklORV9EUk1fR0VNX0NNQV9GT1BTKGRybV9mb3BzKTsKKworc3Rh dGljIHZvaWQgaW50ZWx2aXBmYl9sYXN0Y2xvc2Uoc3RydWN0IGRybV9kZXZpY2UgKmRybSkKK3sK KwlzdHJ1Y3QgaW50ZWx2aXBmYl9wcml2ICpwcml2ID0gZHJtLT5kZXZfcHJpdmF0ZTsKKworCWRy bV9mYmRldl9jbWFfcmVzdG9yZV9tb2RlKHByaXYtPmZiY21hKTsKK30KKworc3RhdGljIHN0cnVj dCBkcm1fZHJpdmVyIGludGVsdmlwZmJfZHJtID0geworCS5kcml2ZXJfZmVhdHVyZXMgPQorCQkJ RFJJVkVSX01PREVTRVQgfCBEUklWRVJfR0VNIHwKKwkJCURSSVZFUl9QUklNRSB8IERSSVZFUl9B VE9NSUMsCisJLmdlbV9mcmVlX29iamVjdF91bmxvY2tlZCA9IGRybV9nZW1fY21hX2ZyZWVfb2Jq ZWN0LAorCS5nZW1fdm1fb3BzID0gJmRybV9nZW1fY21hX3ZtX29wcywKKwkuZHVtYl9jcmVhdGUg PSBkcm1fZ2VtX2NtYV9kdW1iX2NyZWF0ZSwKKwkuZHVtYl9kZXN0cm95ID0gZHJtX2dlbV9kdW1i X2Rlc3Ryb3ksCisJLnByaW1lX2hhbmRsZV90b19mZCA9IGRybV9nZW1fcHJpbWVfaGFuZGxlX3Rv X2ZkLAorCS5wcmltZV9mZF90b19oYW5kbGUgPSBkcm1fZ2VtX3ByaW1lX2ZkX3RvX2hhbmRsZSwK KwkuZ2VtX3ByaW1lX2V4cG9ydCA9IGRybV9nZW1fcHJpbWVfZXhwb3J0LAorCS5nZW1fcHJpbWVf aW1wb3J0ID0gZHJtX2dlbV9wcmltZV9pbXBvcnQsCisJLmdlbV9wcmltZV9nZXRfc2dfdGFibGUg PSBkcm1fZ2VtX2NtYV9wcmltZV9nZXRfc2dfdGFibGUsCisJLmdlbV9wcmltZV9pbXBvcnRfc2df dGFibGUgPSBkcm1fZ2VtX2NtYV9wcmltZV9pbXBvcnRfc2dfdGFibGUsCisJLmdlbV9wcmltZV92 bWFwID0gZHJtX2dlbV9jbWFfcHJpbWVfdm1hcCwKKwkuZ2VtX3ByaW1lX3Z1bm1hcCA9IGRybV9n ZW1fY21hX3ByaW1lX3Z1bm1hcCwKKwkuZ2VtX3ByaW1lX21tYXAgPSBkcm1fZ2VtX2NtYV9wcmlt ZV9tbWFwLAorCS5sYXN0Y2xvc2UgPSBpbnRlbHZpcGZiX2xhc3RjbG9zZSwKKwkubmFtZSA9IERS SVZFUl9OQU1FLAorCS5kYXRlID0gIjIwMTcwNzI5IiwKKwkuZGVzYyA9ICJJbnRlbCBGUEdBIFZJ UCBTVUlURSIsCisJLm1ham9yID0gMSwKKwkubWlub3IgPSAwLAorCS5pb2N0bHMgPSBOVUxMLAor CS5wYXRjaGxldmVsID0gMCwKKwkuZm9wcyA9ICZkcm1fZm9wcywKK307CisKKy8qCisgKiBTZXR0 aW5nIHVwIGluZm9ybWF0aW9uIGRlcml2ZWQgZnJvbSBPRiBEZXZpY2UgVHJlZSBOb2RlcworICog bWF4LXdpZHRoLCBtYXgtaGVpZ2h0LCBiaXRzIHBlciBwaXhlbCwgbWVtb3J5IHBvcnQgd2lkdGgK KyAqLworCitzdGF0aWMgaW50IGludGVsdmlwZmJfZHJtX3NldHVwKHN0cnVjdCBkZXZpY2UgKmRl diwKKwkJCQkJc3RydWN0IGludGVsdmlwZmJfcHJpdiAqZmJwcml2KQoreworCXN0cnVjdCBkcm1f ZGV2aWNlICpkcm0gPSBmYnByaXYtPmRybTsKKwlzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wID0gZGV2 LT5vZl9ub2RlOworCWludCBtZW1fd29yZF93aWR0aDsKKwlpbnQgbWF4X2gsIG1heF93OworCWlu dCByZXQ7CisKKwlyZXQgPSBvZl9wcm9wZXJ0eV9yZWFkX3UzMihucCwgImFsdHIsbWF4LXdpZHRo IiwgJm1heF93KTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIoZGV2LAorCQkJIk1pc3NpbmcgcmVx dWlyZWQgcGFyYW1ldGVyICdhbHRyLG1heC13aWR0aCciKTsKKwkJcmV0dXJuIHJldDsKKwl9CisK KwlyZXQgPSBvZl9wcm9wZXJ0eV9yZWFkX3UzMihucCwgImFsdHIsbWF4LWhlaWdodCIsICZtYXhf aCk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwKKwkJCSJNaXNzaW5nIHJlcXVpcmVkIHBh cmFtZXRlciAnYWx0cixtYXgtaGVpZ2h0JyIpOworCQlyZXR1cm4gcmV0OworCX0KKworCXJldCA9 IG9mX3Byb3BlcnR5X3JlYWRfdTMyKG5wLCAiYWx0cixtZW0tcG9ydC13aWR0aCIsICZtZW1fd29y ZF93aWR0aCk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwgIk1pc3NpbmcgcmVxdWlyZWQg cGFyYW1ldGVyICdhbHRyLG1lbS1wb3J0LXdpZHRoICciKTsKKwkJcmV0dXJuIHJldDsKKwl9CisK KwlpZiAoIShtZW1fd29yZF93aWR0aCA+PSAzMiAmJiBtZW1fd29yZF93aWR0aCAlIDMyID09IDAp KSB7CisJCWRldl9lcnIoZGV2LAorCQkJIm1lbS13b3JkLXdpZHRoIGlzIHNldCB0byAlaS4gbXVz dCBiZSA+PSAzMiBhbmQgbXVsdGlwbGUgb2YgMzIuIiwKKwkJCSBtZW1fd29yZF93aWR0aCk7CisJ CXJldHVybiAtRU5PREVWOworCX0KKworCWRybS0+bW9kZV9jb25maWcubWluX3dpZHRoID0gNjQw OworCWRybS0+bW9kZV9jb25maWcubWluX2hlaWdodCA9IDQ4MDsKKwlkcm0tPm1vZGVfY29uZmln Lm1heF93aWR0aCA9IG1heF93OworCWRybS0+bW9kZV9jb25maWcubWF4X2hlaWdodCA9IG1heF9o OworCWRybS0+bW9kZV9jb25maWcucHJlZmVycmVkX2RlcHRoID0gMzI7CisKKwlyZXR1cm4gMDsK K30KKworc3RhdGljIGludCBpbnRlbHZpcGZiX29mX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZp Y2UgKnBkZXYpCit7CisJaW50IHJldHZhbDsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnJlZ19yZXM7CisJ c3RydWN0IGludGVsdmlwZmJfcHJpdiAqZmJwcml2OworCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZw ZGV2LT5kZXY7CisJc3RydWN0IGRybV9kZXZpY2UgKmRybTsKKworCWZicHJpdiA9IGRldm1fa3ph bGxvYyhkZXYsIHNpemVvZigqZmJwcml2KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFmYnByaXYpCisJ CXJldHVybiAtRU5PTUVNOworCisJLypzZXR1cCBEUk0gKi8KKwlkcm0gPSBkcm1fZGV2X2FsbG9j KCZpbnRlbHZpcGZiX2RybSwgZGV2KTsKKwlpZiAoSVNfRVJSKGRybSkpCisJCXJldHVybiBQVFJf RVJSKGRybSk7CisKKwlyZXR2YWwgPSBkbWFfc2V0X21hc2tfYW5kX2NvaGVyZW50KGRybS0+ZGV2 LCBETUFfQklUX01BU0soMzIpKTsKKwlpZiAocmV0dmFsKQorCQlyZXR1cm4gLUVOT0RFVjsKKwor CWZicHJpdi0+ZHJtID0gZHJtOworCisJcmVnX3JlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShw ZGV2LCBJT1JFU09VUkNFX01FTSwgMCk7CisJaWYgKCFyZWdfcmVzKQorCQlyZXR1cm4gLUVOT01F TTsKKworCWZicHJpdi0+YmFzZSA9IGRldm1faW9yZW1hcF9yZXNvdXJjZShkZXYsIHJlZ19yZXMp OworCisJaWYgKElTX0VSUihmYnByaXYtPmJhc2UpKSB7CisJCWRldl9lcnIoZGV2LCAiZGV2bV9p b3JlbWFwX3Jlc291cmNlIGZhaWxlZFxuIik7CisJCXJldHZhbCA9IFBUUl9FUlIoZmJwcml2LT5i YXNlKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJaW50ZWx2aXBmYl9kcm1fc2V0dXAoZGV2 LCBmYnByaXYpOworCisJZGV2X3NldF9kcnZkYXRhKGRldiwgZmJwcml2KTsKKworCXJldHVybiBp bnRlbHZpcGZiX3Byb2JlKGRldik7Cit9CisKK3N0YXRpYyBpbnQgaW50ZWx2aXBmYl9vZl9yZW1v dmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlyZXR1cm4gaW50ZWx2aXBmYl9y ZW1vdmUoJnBkZXYtPmRldik7Cit9CisKKy8qCisgKiBUaGUgbmFtZSB2aXAtZnJhbWUtYnVmZmVy LTIuMCBpcyBkZXJpdmVkIGZyb20KKyAqIGh0dHA6Ly93d3cuYWx0ZXJhLmNvbS9saXRlcmF0dXJl L3VnL3VnX3ZpcC5wZGYKKyAqIGZyYW1lIGJ1ZmZlciBJUCBjb3JlcyBzZWN0aW9uIDE0CisgKi8K Kworc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgaW50ZWx2aXBmYl9vZl9tYXRjaFtd ID0geworCXsgLmNvbXBhdGlibGUgPSAiYWx0cix2aXAtZnJhbWUtYnVmZmVyLTIuMCIgfSwKKwl7 fSwKK307CisKK01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIGludGVsdmlwZmJfb2ZfbWF0Y2gpOwor CitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBpbnRlbHZpcGZiX2RyaXZlciA9IHsKKwku cHJvYmUgPSBpbnRlbHZpcGZiX29mX3Byb2JlLAorCS5yZW1vdmUgPSBpbnRlbHZpcGZiX29mX3Jl bW92ZSwKKwkuZHJpdmVyID0geworCQkubmFtZSA9IERSSVZFUl9OQU1FLAorCQkub2ZfbWF0Y2hf dGFibGUgPSBpbnRlbHZpcGZiX29mX21hdGNoLAorCX0sCit9OworCittb2R1bGVfcGxhdGZvcm1f ZHJpdmVyKGludGVsdmlwZmJfZHJpdmVyKTsKLS0gCjEuNy4xCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1k ZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcv bWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 From: hean.loong.ong@intel.com (Hean-Loong, Ong) Date: Thu, 31 May 2018 13:50:51 +0800 Subject: [PATCH] ARM:drm ivip Intel FPGA Video and Image Processing Suite In-Reply-To: <1527745851-3339-1-git-send-email-hean.loong.ong@intel.com> References: <1527745851-3339-1-git-send-email-hean.loong.ong@intel.com> Message-ID: <1527745851-3339-4-git-send-email-hean.loong.ong@intel.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org From: Ong Hean Loong Driver for Intel FPGA Video and Image Processing Suite Frame Buffer II. The driver only supports the Intel Arria10 devkit and its variants. This driver can be either loaded staticlly or in modules. The OF device tree binding is located at: Documentation/devicetree/bindings/display/altr,vip-fb2.txt Signed-off-by: Ong Hean Loong --- drivers/gpu/drm/Kconfig | 2 + drivers/gpu/drm/Makefile | 1 + drivers/gpu/drm/ivip/Kconfig | 14 +++ drivers/gpu/drm/ivip/Makefile | 9 ++ drivers/gpu/drm/ivip/intel_vip_conn.c | 95 ++++++++++++++++ drivers/gpu/drm/ivip/intel_vip_core.c | 163 ++++++++++++++++++++++++++++ drivers/gpu/drm/ivip/intel_vip_drv.h | 52 +++++++++ drivers/gpu/drm/ivip/intel_vip_of.c | 193 +++++++++++++++++++++++++++++++++ 8 files changed, 529 insertions(+), 0 deletions(-) create mode 100644 drivers/gpu/drm/ivip/Kconfig create mode 100644 drivers/gpu/drm/ivip/Makefile create mode 100644 drivers/gpu/drm/ivip/intel_vip_conn.c create mode 100644 drivers/gpu/drm/ivip/intel_vip_core.c create mode 100644 drivers/gpu/drm/ivip/intel_vip_drv.h create mode 100644 drivers/gpu/drm/ivip/intel_vip_of.c diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index deeefa7..cdc8e1a 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -204,6 +204,8 @@ source "drivers/gpu/drm/nouveau/Kconfig" source "drivers/gpu/drm/i915/Kconfig" +source "drivers/gpu/drm/ivip/Kconfig" + config DRM_VGEM tristate "Virtual GEM provider" depends on DRM diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 50093ff..c0fba1d 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -60,6 +60,7 @@ obj-$(CONFIG_DRM_AMDGPU)+= amd/amdgpu/ obj-$(CONFIG_DRM_MGA) += mga/ obj-$(CONFIG_DRM_I810) += i810/ obj-$(CONFIG_DRM_I915) += i915/ +obj-$(CONFIG_DRM_IVIP) += ivip/ obj-$(CONFIG_DRM_MGAG200) += mgag200/ obj-$(CONFIG_DRM_VC4) += vc4/ obj-$(CONFIG_DRM_CIRRUS_QEMU) += cirrus/ diff --git a/drivers/gpu/drm/ivip/Kconfig b/drivers/gpu/drm/ivip/Kconfig new file mode 100644 index 0000000..1d08b90 --- /dev/null +++ b/drivers/gpu/drm/ivip/Kconfig @@ -0,0 +1,14 @@ +config DRM_IVIP + tristate "Intel FGPA Video and Image Processing" + depends on DRM && OF + select DRM_GEM_CMA_HELPER + select DRM_KMS_HELPER + select DRM_KMS_FB_HELPER + select DRM_KMS_CMA_HELPER + help + Choose this option if you have an Intel FPGA Arria 10 system + and above with an Intel Display Port IP. This does not support + legacy Intel FPGA Cyclone V display port. Currently only single + frame buffer is supported. Note that ACPI and X_86 architecture + is not supported for Arria10. If M is selected the module will be + called ivip. diff --git a/drivers/gpu/drm/ivip/Makefile b/drivers/gpu/drm/ivip/Makefile new file mode 100644 index 0000000..cc55b04 --- /dev/null +++ b/drivers/gpu/drm/ivip/Makefile @@ -0,0 +1,9 @@ +# +# Makefile for the drm device driver. This driver provides support for the +# Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher. + +ccflags-y := -Iinclude/drm + +obj-$(CONFIG_DRM_IVIP) += ivip.o +ivip-objs := intel_vip_of.o intel_vip_core.o \ + intel_vip_conn.o diff --git a/drivers/gpu/drm/ivip/intel_vip_conn.c b/drivers/gpu/drm/ivip/intel_vip_conn.c new file mode 100644 index 0000000..46bb04c --- /dev/null +++ b/drivers/gpu/drm/ivip/intel_vip_conn.c @@ -0,0 +1,95 @@ +/* + * intel_vip_conn.c -- Intel Video and Image Processing(VIP) + * Frame Buffer II driver + * + * This driver supports the Intel VIP Frame Reader component. + * More info on the hardware can be found in the Intel Video + * and Image Processing Suite User Guide at this address + * http://www.altera.com/literature/ug/ug_vip.pdf. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * Authors: + * Ong, Hean-Loong + * + */ + +#include +#include +#include +#include +#include +#include + +static enum drm_connector_status +intelvipfb_drm_connector_detect(struct drm_connector *connector, bool force) +{ + return connector_status_connected; +} + +static void intelvipfb_drm_connector_destroy(struct drm_connector *connector) +{ + drm_connector_unregister(connector); + drm_connector_cleanup(connector); +} + +static const struct drm_connector_funcs intelvipfb_drm_connector_funcs = { + .reset = drm_atomic_helper_connector_reset, + .detect = intelvipfb_drm_connector_detect, + .fill_modes = drm_helper_probe_single_connector_modes, + .destroy = intelvipfb_drm_connector_destroy, + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, +}; + +static int intelvipfb_drm_connector_get_modes(struct drm_connector *connector) +{ + struct drm_device *drm = connector->dev; + int count; + + count = drm_add_modes_noedid(connector, drm->mode_config.max_width, + drm->mode_config.max_height); + drm_set_preferred_mode(connector, drm->mode_config.max_width, + drm->mode_config.max_height); + return count; +} + +static const struct drm_connector_helper_funcs +intelvipfb_drm_connector_helper_funcs = { + .get_modes = intelvipfb_drm_connector_get_modes, +}; + +struct drm_connector * +intelvipfb_conn_setup(struct drm_device *drm) +{ + struct drm_connector *conn; + int ret; + + conn = devm_kzalloc(drm->dev, sizeof(*conn), GFP_KERNEL); + if (IS_ERR(conn)) + return NULL; + + ret = drm_connector_init(drm, conn, &intelvipfb_drm_connector_funcs, + DRM_MODE_CONNECTOR_DisplayPort); + if (ret < 0) { + dev_err(drm->dev, "failed to initialize drm connector\n"); + ret = -ENOMEM; + goto error_connector_cleanup; + } + + conn->polled = 0; + drm_connector_helper_add(conn, &intelvipfb_drm_connector_helper_funcs); + + return conn; + +error_connector_cleanup: + drm_connector_cleanup(conn); + + return NULL; +} diff --git a/drivers/gpu/drm/ivip/intel_vip_core.c b/drivers/gpu/drm/ivip/intel_vip_core.c new file mode 100644 index 0000000..a09e1ca --- /dev/null +++ b/drivers/gpu/drm/ivip/intel_vip_core.c @@ -0,0 +1,163 @@ +/* + * intel_vip_core.c -- Intel Video and Image Processing(VIP) + * Frame Buffer II driver + * + * This driver supports the Intel VIP Frame Reader component. + * More info on the hardware can be found in the Intel Video + * and Image Processing Suite User Guide at this address + * http://www.altera.com/literature/ug/ug_vip.pdf. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * Authors: + * Ong, Hean-Loong + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "intel_vip_drv.h" + +static void intelvipfb_enable(struct drm_simple_display_pipe *pipe, + struct drm_crtc_state *crtc_state) +{ + /* + * The frameinfo variable has to correspond to the size of the VIP Suite + * Frame Reader register 7 which will determine the maximum size used + * in this frameinfo + */ + + u32 frameinfo; + struct intelvipfb_priv *priv = pipe->plane.dev->dev_private; + void __iomem *base = priv->base; + struct drm_plane_state *state = pipe->plane.state; + dma_addr_t addr; + + addr = drm_fb_cma_get_gem_addr(state->fb, state, 0); + + dev_info(pipe->plane.dev->dev, "Address 0x%x\n", addr); + + frameinfo = + readl(base + INTELVIPFB_FRAME_READER) & 0x00ffffff; + writel(frameinfo, base + INTELVIPFB_FRAME_INFO); + writel(addr, base + INTELVIPFB_FRAME_START); + /* Finally set the control register to 1 to start streaming */ + writel(1, base + INTELVIPFB_CONTROL); +} + +static void intelvipfb_disable(struct drm_simple_display_pipe *pipe) +{ + struct intelvipfb_priv *priv = pipe->plane.dev->dev_private; + void __iomem *base = priv->base; + /* set the control register to 0 to stop streaming */ + writel(0, base + INTELVIPFB_CONTROL); +} + +static const struct drm_mode_config_funcs intelvipfb_mode_config_funcs = { + .fb_create = drm_gem_fb_create, + .atomic_check = drm_atomic_helper_check, + .atomic_commit = drm_atomic_helper_commit, +}; + +static void intelvipfb_setup_mode_config(struct drm_device *drm) +{ + drm_mode_config_init(drm); + drm->mode_config.funcs = &intelvipfb_mode_config_funcs; +} + +static int intelvipfb_pipe_prepare_fb(struct drm_simple_display_pipe *pipe, + struct drm_plane_state *plane_state) +{ + return drm_gem_fb_prepare_fb(&pipe->plane, plane_state); +} + + +static struct drm_simple_display_pipe_funcs fbpriv_funcs = { + .prepare_fb = intelvipfb_pipe_prepare_fb, + .enable = intelvipfb_enable, + .disable = intelvipfb_disable +}; + +int intelvipfb_probe(struct device *dev) +{ + int retval; + struct drm_device *drm; + struct intelvipfb_priv *fbpriv = dev_get_drvdata(dev); + struct drm_connector *connector; + u32 formats[] = {DRM_FORMAT_XRGB8888}; + + drm = fbpriv->drm; + + drm->dev_private = fbpriv; + + intelvipfb_setup_mode_config(drm); + + connector = intelvipfb_conn_setup(drm); + if (!connector) { + dev_err(drm->dev, "Connector setup failed\n"); + goto err_mode_config; + } + + retval = drm_simple_display_pipe_init(drm, &fbpriv->pipe, + &fbpriv_funcs, formats, + ARRAY_SIZE(formats), NULL, connector); + if (retval < 0) { + dev_err(drm->dev, "Cannot setup simple display pipe\n"); + goto err_mode_config; + } + + fbpriv->fbcma = drm_fbdev_cma_init(drm, + drm->mode_config.preferred_depth, + drm->mode_config.num_connector); + + drm_mode_config_reset(drm); + + drm_dev_register(drm, 0); + + return retval; + +err_mode_config: + + drm_mode_config_cleanup(drm); + return -ENODEV; +} + +int intelvipfb_remove(struct device *dev) +{ + struct intelvipfb_priv *fbpriv = dev_get_drvdata(dev); + struct drm_device *drm = fbpriv->drm; + + drm_dev_unregister(drm); + + if (fbpriv->fbcma) + drm_fbdev_cma_fini(fbpriv->fbcma); + + drm_mode_config_cleanup(drm); + drm_dev_unref(drm); + + return 0; +} + +MODULE_AUTHOR("Ong, Hean-Loong "); +MODULE_DESCRIPTION("Intel VIP Frame Buffer II driver"); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/gpu/drm/ivip/intel_vip_drv.h b/drivers/gpu/drm/ivip/intel_vip_drv.h new file mode 100644 index 0000000..0a3555d --- /dev/null +++ b/drivers/gpu/drm/ivip/intel_vip_drv.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2017 Intel Corporation. + * + * Intel Video and Image Processing(VIP) Frame Buffer II driver. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * this program. If not, see . + * + * Authors: + * Ong, Hean-Loong + * + */ +#ifndef _INTEL_VIP_DRV_H +#define _INTEL_VIP_DRV_H + +#define DRIVER_NAME "intelvipfb" +#define BYTES_PER_PIXEL 4 +#define CRTC_NUM 1 +#define CONN_NUM 1 + +/* control registers */ +#define INTELVIPFB_CONTROL 0 +#define INTELVIPFB_STATUS 0x4 +#define INTELVIPFB_INTERRUPT 0x8 +#define INTELVIPFB_FRAME_COUNTER 0xC +#define INTELVIPFB_FRAME_DROP 0x10 +#define INTELVIPFB_FRAME_INFO 0x14 +#define INTELVIPFB_FRAME_START 0x18 +#define INTELVIPFB_FRAME_READER 0x1C + +int intelvipfb_probe(struct device *dev); +int intelvipfb_remove(struct device *dev); +int intelvipfb_setup_crtc(struct drm_device *drm); +struct drm_connector *intelvipfb_conn_setup(struct drm_device *drm); + +struct intelvipfb_priv { + struct drm_simple_display_pipe pipe; + struct drm_fbdev_cma *fbcma; + struct drm_device *drm; + void __iomem *base; +}; + +#endif diff --git a/drivers/gpu/drm/ivip/intel_vip_of.c b/drivers/gpu/drm/ivip/intel_vip_of.c new file mode 100644 index 0000000..47302f9 --- /dev/null +++ b/drivers/gpu/drm/ivip/intel_vip_of.c @@ -0,0 +1,193 @@ +/* + * intel_vip_of.c -- Intel Video and Image Processing(VIP) + * Frame Buffer II driver + * + * This driver supports the Intel VIP Frame Reader component. + * More info on the hardware can be found in the Intel Video + * and Image Processing Suite User Guide at this address + * http://www.altera.com/literature/ug/ug_vip.pdf. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * Authors: + * Ong, Hean-Loong + * + */ +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "intel_vip_drv.h" + +DEFINE_DRM_GEM_CMA_FOPS(drm_fops); + +static void intelvipfb_lastclose(struct drm_device *drm) +{ + struct intelvipfb_priv *priv = drm->dev_private; + + drm_fbdev_cma_restore_mode(priv->fbcma); +} + +static struct drm_driver intelvipfb_drm = { + .driver_features = + DRIVER_MODESET | DRIVER_GEM | + DRIVER_PRIME | DRIVER_ATOMIC, + .gem_free_object_unlocked = drm_gem_cma_free_object, + .gem_vm_ops = &drm_gem_cma_vm_ops, + .dumb_create = drm_gem_cma_dumb_create, + .dumb_destroy = drm_gem_dumb_destroy, + .prime_handle_to_fd = drm_gem_prime_handle_to_fd, + .prime_fd_to_handle = drm_gem_prime_fd_to_handle, + .gem_prime_export = drm_gem_prime_export, + .gem_prime_import = drm_gem_prime_import, + .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table, + .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table, + .gem_prime_vmap = drm_gem_cma_prime_vmap, + .gem_prime_vunmap = drm_gem_cma_prime_vunmap, + .gem_prime_mmap = drm_gem_cma_prime_mmap, + .lastclose = intelvipfb_lastclose, + .name = DRIVER_NAME, + .date = "20170729", + .desc = "Intel FPGA VIP SUITE", + .major = 1, + .minor = 0, + .ioctls = NULL, + .patchlevel = 0, + .fops = &drm_fops, +}; + +/* + * Setting up information derived from OF Device Tree Nodes + * max-width, max-height, bits per pixel, memory port width + */ + +static int intelvipfb_drm_setup(struct device *dev, + struct intelvipfb_priv *fbpriv) +{ + struct drm_device *drm = fbpriv->drm; + struct device_node *np = dev->of_node; + int mem_word_width; + int max_h, max_w; + int ret; + + ret = of_property_read_u32(np, "altr,max-width", &max_w); + if (ret) { + dev_err(dev, + "Missing required parameter 'altr,max-width'"); + return ret; + } + + ret = of_property_read_u32(np, "altr,max-height", &max_h); + if (ret) { + dev_err(dev, + "Missing required parameter 'altr,max-height'"); + return ret; + } + + ret = of_property_read_u32(np, "altr,mem-port-width", &mem_word_width); + if (ret) { + dev_err(dev, "Missing required parameter 'altr,mem-port-width '"); + return ret; + } + + if (!(mem_word_width >= 32 && mem_word_width % 32 == 0)) { + dev_err(dev, + "mem-word-width is set to %i. must be >= 32 and multiple of 32.", + mem_word_width); + return -ENODEV; + } + + drm->mode_config.min_width = 640; + drm->mode_config.min_height = 480; + drm->mode_config.max_width = max_w; + drm->mode_config.max_height = max_h; + drm->mode_config.preferred_depth = 32; + + return 0; +} + +static int intelvipfb_of_probe(struct platform_device *pdev) +{ + int retval; + struct resource *reg_res; + struct intelvipfb_priv *fbpriv; + struct device *dev = &pdev->dev; + struct drm_device *drm; + + fbpriv = devm_kzalloc(dev, sizeof(*fbpriv), GFP_KERNEL); + if (!fbpriv) + return -ENOMEM; + + /*setup DRM */ + drm = drm_dev_alloc(&intelvipfb_drm, dev); + if (IS_ERR(drm)) + return PTR_ERR(drm); + + retval = dma_set_mask_and_coherent(drm->dev, DMA_BIT_MASK(32)); + if (retval) + return -ENODEV; + + fbpriv->drm = drm; + + reg_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!reg_res) + return -ENOMEM; + + fbpriv->base = devm_ioremap_resource(dev, reg_res); + + if (IS_ERR(fbpriv->base)) { + dev_err(dev, "devm_ioremap_resource failed\n"); + retval = PTR_ERR(fbpriv->base); + return -ENOMEM; + } + + intelvipfb_drm_setup(dev, fbpriv); + + dev_set_drvdata(dev, fbpriv); + + return intelvipfb_probe(dev); +} + +static int intelvipfb_of_remove(struct platform_device *pdev) +{ + return intelvipfb_remove(&pdev->dev); +} + +/* + * The name vip-frame-buffer-2.0 is derived from + * http://www.altera.com/literature/ug/ug_vip.pdf + * frame buffer IP cores section 14 + */ + +static const struct of_device_id intelvipfb_of_match[] = { + { .compatible = "altr,vip-frame-buffer-2.0" }, + {}, +}; + +MODULE_DEVICE_TABLE(of, intelvipfb_of_match); + +static struct platform_driver intelvipfb_driver = { + .probe = intelvipfb_of_probe, + .remove = intelvipfb_of_remove, + .driver = { + .name = DRIVER_NAME, + .of_match_table = intelvipfb_of_match, + }, +}; + +module_platform_driver(intelvipfb_driver); -- 1.7.1