From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Zimmermann Date: Mon, 14 Oct 2019 14:04:14 +0000 Subject: [PATCH v2 13/15] staging: Add mgakms driver Message-Id: <20191014140416.28517-14-tzimmermann@suse.de> List-Id: References: <20191014140416.28517-1-tzimmermann@suse.de> In-Reply-To: <20191014140416.28517-1-tzimmermann@suse.de> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: airlied@linux.ie, daniel@ffwll.ch, maarten.lankhorst@linux.intel.com, mripard@kernel.org, sean@poorly.run, b.zolnierkie@samsung.com, ajax@redhat.com, ville.syrjala@linux.intel.com, malat@debian.org, michel@daenzer.net Cc: gregkh@linuxfoundation.org, linux-fbdev@vger.kernel.org, Thomas Zimmermann , dri-devel@lists.freedesktop.org, corbet@lwn.net The mgakms driver uses DRM's fbconv helpers to provide a DRM driver for Matrox chipsets. This will allow matroxfb to be refactored into a first-class DRM driver. Signed-off-by: Thomas Zimmermann --- drivers/staging/Kconfig | 2 + drivers/staging/Makefile | 1 + drivers/staging/mgakms/Kconfig | 13 +++ drivers/staging/mgakms/Makefile | 6 ++ drivers/staging/mgakms/mga_device.c | 68 +++++++++++++++ drivers/staging/mgakms/mga_device.h | 30 +++++++ drivers/staging/mgakms/mga_drv.c | 129 ++++++++++++++++++++++++++++ drivers/staging/mgakms/mga_drv.h | 14 +++ 8 files changed, 263 insertions(+) create mode 100644 drivers/staging/mgakms/Kconfig create mode 100644 drivers/staging/mgakms/Makefile create mode 100644 drivers/staging/mgakms/mga_device.c create mode 100644 drivers/staging/mgakms/mga_device.h create mode 100644 drivers/staging/mgakms/mga_drv.c create mode 100644 drivers/staging/mgakms/mga_drv.h diff --git a/drivers/staging/Kconfig b/drivers/staging/Kconfig index 6f1fa4c849a1..fd25596813c5 100644 --- a/drivers/staging/Kconfig +++ b/drivers/staging/Kconfig @@ -125,4 +125,6 @@ source "drivers/staging/exfat/Kconfig" source "drivers/staging/qlge/Kconfig" +source "drivers/staging/mgakms/Kconfig" + endif # STAGING diff --git a/drivers/staging/Makefile b/drivers/staging/Makefile index a90f9b308c8d..4c98b028ee99 100644 --- a/drivers/staging/Makefile +++ b/drivers/staging/Makefile @@ -53,3 +53,4 @@ obj-$(CONFIG_UWB) += uwb/ obj-$(CONFIG_USB_WUSB) += wusbcore/ obj-$(CONFIG_EXFAT_FS) += exfat/ obj-$(CONFIG_QLGE) += qlge/ +obj-$(CONFIG_DRM_MGAKMS) += mgakms/ diff --git a/drivers/staging/mgakms/Kconfig b/drivers/staging/mgakms/Kconfig new file mode 100644 index 000000000000..de23e76317bd --- /dev/null +++ b/drivers/staging/mgakms/Kconfig @@ -0,0 +1,13 @@ +config DRM_MGAKMS + tristate "Matrox g200/g400" + depends on DRM && PCI + select DRM_FBCONV_HELPER + select DRM_GEM_SHMEM_HELPER + select DRM_KMS_HELPER + help + Choose this option if you have a Matrox Millennium, + Matrox Millennium II, Matrox Mystique, Matrox Mystique 220, + Matrox Productiva G100, Matrox Mystique G200, + Matrox Millennium G200, Matrox Marvel G200 video, Matrox G400, + G450 or G550 card. If M is selected, the module will be called mga. + AGP support is required for this driver to work. diff --git a/drivers/staging/mgakms/Makefile b/drivers/staging/mgakms/Makefile new file mode 100644 index 000000000000..65695f04eb7f --- /dev/null +++ b/drivers/staging/mgakms/Makefile @@ -0,0 +1,6 @@ +# SPDX-License-Identifier: GPL-2.0 + +mgakms-y := mga_device.o \ + mga_drv.o + +obj-$(CONFIG_DRM_MGAKMS) += mgakms.o diff --git a/drivers/staging/mgakms/mga_device.c b/drivers/staging/mgakms/mga_device.c new file mode 100644 index 000000000000..34b3bb1ed8a5 --- /dev/null +++ b/drivers/staging/mgakms/mga_device.c @@ -0,0 +1,68 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include + +#include +#include +#include + +#include "mga_device.h" + +/* + * struct mga_device + */ + +int mga_device_init(struct mga_device *mdev, struct drm_driver *drv, + struct fb_info *fb_info) +{ + static const uint32_t formats[] = { + DRM_FORMAT_XRGB8888, + DRM_FORMAT_RGB565 + }; + static unsigned int max_width = 2048; + static unsigned int max_height = 2048; + static unsigned int preferred_depth = 32; + + int ret; + + ret = drm_dev_init(&mdev->dev, drv, fb_info->device); + if (ret) + return ret; + mdev->dev.dev_private = mdev; + mdev->dev.pdev = container_of(fb_info->device, struct pci_dev, dev); + mdev->fb_info = fb_info; + + ret = drm_fbconv_modeset_init(&mdev->modeset, &mdev->dev, fb_info, + max_width, max_height, preferred_depth); + if (ret) + goto err_drm_dev_fini; + + ret = drm_fbconv_modeset_setup_pipe(&mdev->modeset, NULL, formats, + ARRAY_SIZE(formats), NULL, NULL); + if (ret) + goto err_drm_fbconv_modeset_cleanup; + + ret = drm_fbdev_generic_setup(&mdev->dev, 0); + if (ret) + goto err_drm_fbconv_modeset_cleanup; + + return 0; + +err_drm_fbconv_modeset_cleanup: + /* cleans up all mode-setting structures */ + drm_fbconv_modeset_cleanup(&mdev->modeset); +err_drm_dev_fini: + drm_dev_fini(&mdev->dev); + return ret; +} + +void mga_device_cleanup(struct mga_device *mdev) +{ + struct drm_device *dev = &mdev->dev; + + drm_fbconv_modeset_cleanup(&mdev->modeset); + + drm_dev_fini(dev); + dev->dev_private = NULL; +} diff --git a/drivers/staging/mgakms/mga_device.h b/drivers/staging/mgakms/mga_device.h new file mode 100644 index 000000000000..442effbf37bc --- /dev/null +++ b/drivers/staging/mgakms/mga_device.h @@ -0,0 +1,30 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef MGA_DEVICE_H +#define MGA_DEVICE_H + +#include + +#include +#include + +struct drm_driver; +struct fb_info; + +struct mga_device { + struct drm_device dev; + struct fb_info *fb_info; + + struct drm_fbconv_modeset modeset; +}; + +static inline struct mga_device *mga_device_of_dev(struct drm_device *dev) +{ + return container_of(dev, struct mga_device, dev); +} + +int mga_device_init(struct mga_device *mdev, struct drm_driver *drv, + struct fb_info *fb_info); +void mga_device_cleanup(struct mga_device *mdev); + +#endif diff --git a/drivers/staging/mgakms/mga_drv.c b/drivers/staging/mgakms/mga_drv.c new file mode 100644 index 000000000000..75e26d3046f3 --- /dev/null +++ b/drivers/staging/mgakms/mga_drv.c @@ -0,0 +1,129 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "mga_device.h" +#include "mga_drv.h" + +#define DRIVER_AUTHOR "Thomas Zimmermann " +#define DRIVER_NAME "mgakms" +#define DRIVER_DESCRIPTION "DRM driver for Matrox graphics chipsets" +#define DRIVER_LICENSE "GPL" +#define DRIVER_DATE "20190301" +#define DRIVER_MAJOR 0 +#define DRIVER_MINOR 0 +#define DRIVER_PATCHLEVEL 1 + +/* + * DRM driver + */ + +DEFINE_DRM_GEM_SHMEM_FOPS(mga_file_operations); + +static struct drm_driver mga_driver = { + .major = DRIVER_MAJOR, + .minor = DRIVER_MINOR, + .patchlevel = DRIVER_PATCHLEVEL, + .name = DRIVER_NAME, + .desc = DRIVER_DESCRIPTION, + .date = DRIVER_DATE, + .driver_features = DRIVER_ATOMIC | + DRIVER_GEM | + DRIVER_MODESET, + .fops = &mga_file_operations, + DRM_GEM_SHMEM_DRIVER_OPS, +}; + +static void mga_remove_conflicting_framebuffers(struct pci_dev *pdev) +{ + struct apertures_struct *ap; + bool primary = false; + + ap = alloc_apertures(1); + if (!ap) + return; + + ap->ranges[0].base = pci_resource_start(pdev, 1); + ap->ranges[0].size = pci_resource_len(pdev, 1); + +#ifdef CONFIG_X86 + primary = pdev->resource[PCI_ROM_RESOURCE].flags & + IORESOURCE_ROM_SHADOW; +#endif + drm_fb_helper_remove_conflicting_framebuffers(ap, DRIVER_NAME, + primary); + kfree(ap); +} + +static struct mga_device *mga_create_device(struct fb_info *fb_info) +{ + struct mga_device *mdev; + int ret; + + mdev = devm_kzalloc(fb_info->device, sizeof(*mdev), GFP_KERNEL); + if (!mdev) + return ERR_PTR(-ENOMEM); + ret = mga_device_init(mdev, &mga_driver, fb_info); + if (ret) + goto err_devm_kfree; + return mdev; + +err_devm_kfree: + devm_kfree(fb_info->device, mdev); + return ERR_PTR(ret); +} + +static void mga_destroy_device(struct mga_device *mdev) +{ + struct device *dev = mdev->fb_info->device; + + mga_device_cleanup(mdev); + devm_kfree(dev, mdev); +} + +struct mga_device *mga_register_framebuffer(struct fb_info *fb_info, + struct pci_dev *pdev) +{ + int ret; + struct mga_device *mdev; + + mga_remove_conflicting_framebuffers(pdev); + + ret = drm_fbconv_fill_fb_info(fb_info); + if (ret) + return ERR_PTR(ret); + + mdev = mga_create_device(fb_info); + if (IS_ERR(mdev)) { + ret = PTR_ERR(mdev); + goto err_drm_fbconv_cleanup_fb_info; + } + + ret = drm_dev_register(&mdev->dev, 0); + if (ret) + goto err_mga_destroy_device; + + return mdev; + +err_mga_destroy_device: + mga_destroy_device(mdev); +err_drm_fbconv_cleanup_fb_info: + drm_fbconv_cleanup_fb_info(fb_info); + return ERR_PTR(ret); +} + +void mga_unregister_framebuffer(struct mga_device *mdev) +{ + struct fb_info *fb_info = mdev->fb_info; + + mga_destroy_device(mdev); + drm_fbconv_cleanup_fb_info(fb_info); +} diff --git a/drivers/staging/mgakms/mga_drv.h b/drivers/staging/mgakms/mga_drv.h new file mode 100644 index 000000000000..d214719516c0 --- /dev/null +++ b/drivers/staging/mgakms/mga_drv.h @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef MGA_DRV_H +#define MGA_DRV_H + +struct fb_info; +struct mga_device; +struct pci_dev; + +struct mga_device *mga_register_framebuffer(struct fb_info *fb_info, + struct pci_dev *pdev); +void mga_unregister_framebuffer(struct mga_device *mdev); + +#endif -- 2.23.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Zimmermann Subject: [PATCH v2 13/15] staging: Add mgakms driver Date: Mon, 14 Oct 2019 16:04:14 +0200 Message-ID: <20191014140416.28517-14-tzimmermann@suse.de> References: <20191014140416.28517-1-tzimmermann@suse.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mx1.suse.de (mx2.suse.de [195.135.220.15]) by gabe.freedesktop.org (Postfix) with ESMTPS id 4DF446E4B7 for ; Mon, 14 Oct 2019 14:04:27 +0000 (UTC) In-Reply-To: <20191014140416.28517-1-tzimmermann@suse.de> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: airlied@linux.ie, daniel@ffwll.ch, maarten.lankhorst@linux.intel.com, mripard@kernel.org, sean@poorly.run, b.zolnierkie@samsung.com, ajax@redhat.com, ville.syrjala@linux.intel.com, malat@debian.org, michel@daenzer.net Cc: gregkh@linuxfoundation.org, linux-fbdev@vger.kernel.org, Thomas Zimmermann , dri-devel@lists.freedesktop.org, corbet@lwn.net List-Id: dri-devel@lists.freedesktop.org VGhlIG1nYWttcyBkcml2ZXIgdXNlcyBEUk0ncyBmYmNvbnYgaGVscGVycyB0byBwcm92aWRlIGEg RFJNIGRyaXZlcgpmb3IgTWF0cm94IGNoaXBzZXRzLiBUaGlzIHdpbGwgYWxsb3cgbWF0cm94ZmIg dG8gYmUgcmVmYWN0b3JlZCBpbnRvCmEgZmlyc3QtY2xhc3MgRFJNIGRyaXZlci4KClNpZ25lZC1v ZmYtYnk6IFRob21hcyBaaW1tZXJtYW5uIDx0emltbWVybWFubkBzdXNlLmRlPgotLS0KIGRyaXZl cnMvc3RhZ2luZy9LY29uZmlnICAgICAgICAgICAgIHwgICAyICsKIGRyaXZlcnMvc3RhZ2luZy9N YWtlZmlsZSAgICAgICAgICAgIHwgICAxICsKIGRyaXZlcnMvc3RhZ2luZy9tZ2FrbXMvS2NvbmZp ZyAgICAgIHwgIDEzICsrKwogZHJpdmVycy9zdGFnaW5nL21nYWttcy9NYWtlZmlsZSAgICAgfCAg IDYgKysKIGRyaXZlcnMvc3RhZ2luZy9tZ2FrbXMvbWdhX2RldmljZS5jIHwgIDY4ICsrKysrKysr KysrKysrKwogZHJpdmVycy9zdGFnaW5nL21nYWttcy9tZ2FfZGV2aWNlLmggfCAgMzAgKysrKysr KwogZHJpdmVycy9zdGFnaW5nL21nYWttcy9tZ2FfZHJ2LmMgICAgfCAxMjkgKysrKysrKysrKysr KysrKysrKysrKysrKysrKwogZHJpdmVycy9zdGFnaW5nL21nYWttcy9tZ2FfZHJ2LmggICAgfCAg MTQgKysrCiA4IGZpbGVzIGNoYW5nZWQsIDI2MyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAx MDA2NDQgZHJpdmVycy9zdGFnaW5nL21nYWttcy9LY29uZmlnCiBjcmVhdGUgbW9kZSAxMDA2NDQg ZHJpdmVycy9zdGFnaW5nL21nYWttcy9NYWtlZmlsZQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZl cnMvc3RhZ2luZy9tZ2FrbXMvbWdhX2RldmljZS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy cy9zdGFnaW5nL21nYWttcy9tZ2FfZGV2aWNlLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJz L3N0YWdpbmcvbWdha21zL21nYV9kcnYuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvc3Rh Z2luZy9tZ2FrbXMvbWdhX2Rydi5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL0tjb25m aWcgYi9kcml2ZXJzL3N0YWdpbmcvS2NvbmZpZwppbmRleCA2ZjFmYTRjODQ5YTEuLmZkMjU1OTY4 MTNjNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL0tjb25maWcKKysrIGIvZHJpdmVycy9z dGFnaW5nL0tjb25maWcKQEAgLTEyNSw0ICsxMjUsNiBAQCBzb3VyY2UgImRyaXZlcnMvc3RhZ2lu Zy9leGZhdC9LY29uZmlnIgogCiBzb3VyY2UgImRyaXZlcnMvc3RhZ2luZy9xbGdlL0tjb25maWci CiAKK3NvdXJjZSAiZHJpdmVycy9zdGFnaW5nL21nYWttcy9LY29uZmlnIgorCiBlbmRpZiAjIFNU QUdJTkcKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9NYWtlZmlsZSBiL2RyaXZlcnMvc3Rh Z2luZy9NYWtlZmlsZQppbmRleCBhOTBmOWIzMDhjOGQuLjRjOThiMDI4ZWU5OSAxMDA2NDQKLS0t IGEvZHJpdmVycy9zdGFnaW5nL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9NYWtlZmls ZQpAQCAtNTMsMyArNTMsNCBAQCBvYmotJChDT05GSUdfVVdCKQkJKz0gdXdiLwogb2JqLSQoQ09O RklHX1VTQl9XVVNCKQkJKz0gd3VzYmNvcmUvCiBvYmotJChDT05GSUdfRVhGQVRfRlMpCQkrPSBl eGZhdC8KIG9iai0kKENPTkZJR19RTEdFKQkJKz0gcWxnZS8KK29iai0kKENPTkZJR19EUk1fTUdB S01TKQkrPSBtZ2FrbXMvCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvbWdha21zL0tjb25m aWcgYi9kcml2ZXJzL3N0YWdpbmcvbWdha21zL0tjb25maWcKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwLi5kZTIzZTc2MzE3YmQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2 ZXJzL3N0YWdpbmcvbWdha21zL0tjb25maWcKQEAgLTAsMCArMSwxMyBAQAorY29uZmlnIERSTV9N R0FLTVMKKwl0cmlzdGF0ZSAiTWF0cm94IGcyMDAvZzQwMCIKKwlkZXBlbmRzIG9uIERSTSAmJiBQ Q0kKKwlzZWxlY3QgRFJNX0ZCQ09OVl9IRUxQRVIKKwlzZWxlY3QgRFJNX0dFTV9TSE1FTV9IRUxQ RVIKKwlzZWxlY3QgRFJNX0tNU19IRUxQRVIKKwloZWxwCisJICBDaG9vc2UgdGhpcyBvcHRpb24g aWYgeW91IGhhdmUgYSBNYXRyb3ggTWlsbGVubml1bSwKKwkgIE1hdHJveCBNaWxsZW5uaXVtIElJ LCBNYXRyb3ggTXlzdGlxdWUsIE1hdHJveCBNeXN0aXF1ZSAyMjAsCisJICBNYXRyb3ggUHJvZHVj dGl2YSBHMTAwLCBNYXRyb3ggTXlzdGlxdWUgRzIwMCwKKwkgIE1hdHJveCBNaWxsZW5uaXVtIEcy MDAsIE1hdHJveCBNYXJ2ZWwgRzIwMCB2aWRlbywgTWF0cm94IEc0MDAsCisJICBHNDUwIG9yIEc1 NTAgY2FyZC4gSWYgTSBpcyBzZWxlY3RlZCwgdGhlIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCBtZ2Eu CisJICBBR1Agc3VwcG9ydCBpcyByZXF1aXJlZCBmb3IgdGhpcyBkcml2ZXIgdG8gd29yay4KZGlm ZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9tZ2FrbXMvTWFrZWZpbGUgYi9kcml2ZXJzL3N0YWdp bmcvbWdha21zL01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MC4uNjU2OTVmMDRlYjdmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zdGFnaW5nL21nYWtt cy9NYWtlZmlsZQpAQCAtMCwwICsxLDYgQEAKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQ TC0yLjAKKworbWdha21zLXkJOj0gbWdhX2RldmljZS5vIFwKKwkJICAgbWdhX2Rydi5vCisKK29i ai0kKENPTkZJR19EUk1fTUdBS01TKQkrPSBtZ2FrbXMubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9z dGFnaW5nL21nYWttcy9tZ2FfZGV2aWNlLmMgYi9kcml2ZXJzL3N0YWdpbmcvbWdha21zL21nYV9k ZXZpY2UuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjM0YjNiYjFl ZDhhNQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9tZ2FrbXMvbWdhX2Rldmlj ZS5jCkBAIC0wLDAgKzEsNjggQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4w CisKKyNpbmNsdWRlIDxsaW51eC9mYi5oPgorI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgorCisjaW5j bHVkZSA8ZHJtL2RybV9kcnYuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2ZiX2hlbHBlci5oPgorI2lu Y2x1ZGUgPGRybS9kcm1fbW9kZXNldF9oZWxwZXIuaD4KKworI2luY2x1ZGUgIm1nYV9kZXZpY2Uu aCIKKworLyoKKyAqIHN0cnVjdCBtZ2FfZGV2aWNlCisgKi8KKworaW50IG1nYV9kZXZpY2VfaW5p dChzdHJ1Y3QgbWdhX2RldmljZSAqbWRldiwgc3RydWN0IGRybV9kcml2ZXIgKmRydiwKKwkJICAg IHN0cnVjdCBmYl9pbmZvICpmYl9pbmZvKQoreworCXN0YXRpYyBjb25zdCB1aW50MzJfdCBmb3Jt YXRzW10gPSB7CisJCURSTV9GT1JNQVRfWFJHQjg4ODgsCisJCURSTV9GT1JNQVRfUkdCNTY1CisJ fTsKKwlzdGF0aWMgdW5zaWduZWQgaW50IG1heF93aWR0aCA9IDIwNDg7CisJc3RhdGljIHVuc2ln bmVkIGludCBtYXhfaGVpZ2h0ID0gMjA0ODsKKwlzdGF0aWMgdW5zaWduZWQgaW50IHByZWZlcnJl ZF9kZXB0aCA9IDMyOworCisJaW50IHJldDsKKworCXJldCA9IGRybV9kZXZfaW5pdCgmbWRldi0+ ZGV2LCBkcnYsIGZiX2luZm8tPmRldmljZSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKwlt ZGV2LT5kZXYuZGV2X3ByaXZhdGUgPSBtZGV2OworCW1kZXYtPmRldi5wZGV2ID0gY29udGFpbmVy X29mKGZiX2luZm8tPmRldmljZSwgc3RydWN0IHBjaV9kZXYsIGRldik7CisJbWRldi0+ZmJfaW5m byA9IGZiX2luZm87CisKKwlyZXQgPSBkcm1fZmJjb252X21vZGVzZXRfaW5pdCgmbWRldi0+bW9k ZXNldCwgJm1kZXYtPmRldiwgZmJfaW5mbywKKwkJCQkgICAgICBtYXhfd2lkdGgsIG1heF9oZWln aHQsIHByZWZlcnJlZF9kZXB0aCk7CisJaWYgKHJldCkKKwkJZ290byBlcnJfZHJtX2Rldl9maW5p OworCisJcmV0ID0gZHJtX2ZiY29udl9tb2Rlc2V0X3NldHVwX3BpcGUoJm1kZXYtPm1vZGVzZXQs IE5VTEwsIGZvcm1hdHMsCisJCQkJCSAgICBBUlJBWV9TSVpFKGZvcm1hdHMpLCBOVUxMLCBOVUxM KTsKKwlpZiAocmV0KQorCQlnb3RvIGVycl9kcm1fZmJjb252X21vZGVzZXRfY2xlYW51cDsKKwor CXJldCA9IGRybV9mYmRldl9nZW5lcmljX3NldHVwKCZtZGV2LT5kZXYsIDApOworCWlmIChyZXQp CisJCWdvdG8gZXJyX2RybV9mYmNvbnZfbW9kZXNldF9jbGVhbnVwOworCisJcmV0dXJuIDA7CisK K2Vycl9kcm1fZmJjb252X21vZGVzZXRfY2xlYW51cDoKKwkvKiBjbGVhbnMgdXAgYWxsIG1vZGUt c2V0dGluZyBzdHJ1Y3R1cmVzICovCisJZHJtX2ZiY29udl9tb2Rlc2V0X2NsZWFudXAoJm1kZXYt Pm1vZGVzZXQpOworZXJyX2RybV9kZXZfZmluaToKKwlkcm1fZGV2X2ZpbmkoJm1kZXYtPmRldik7 CisJcmV0dXJuIHJldDsKK30KKwordm9pZCBtZ2FfZGV2aWNlX2NsZWFudXAoc3RydWN0IG1nYV9k ZXZpY2UgKm1kZXYpCit7CisJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9ICZtZGV2LT5kZXY7CisK Kwlkcm1fZmJjb252X21vZGVzZXRfY2xlYW51cCgmbWRldi0+bW9kZXNldCk7CisKKwlkcm1fZGV2 X2ZpbmkoZGV2KTsKKwlkZXYtPmRldl9wcml2YXRlID0gTlVMTDsKK30KZGlmZiAtLWdpdCBhL2Ry aXZlcnMvc3RhZ2luZy9tZ2FrbXMvbWdhX2RldmljZS5oIGIvZHJpdmVycy9zdGFnaW5nL21nYWtt cy9tZ2FfZGV2aWNlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi40 NDJlZmZiZjM3YmMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3N0YWdpbmcvbWdha21zL21n YV9kZXZpY2UuaApAQCAtMCwwICsxLDMwIEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog R1BMLTIuMCAqLworCisjaWZuZGVmIE1HQV9ERVZJQ0VfSAorI2RlZmluZSBNR0FfREVWSUNFX0gK KworI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorCisjaW5jbHVkZSA8ZHJtL2RybV9kZXZpY2Uu aD4KKyNpbmNsdWRlIDxkcm0vZHJtX2ZiY29udl9oZWxwZXIuaD4KKworc3RydWN0IGRybV9kcml2 ZXI7CitzdHJ1Y3QgZmJfaW5mbzsKKworc3RydWN0IG1nYV9kZXZpY2UgeworCXN0cnVjdCBkcm1f ZGV2aWNlIGRldjsKKwlzdHJ1Y3QgZmJfaW5mbyAqZmJfaW5mbzsKKworCXN0cnVjdCBkcm1fZmJj b252X21vZGVzZXQgbW9kZXNldDsKK307CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IG1nYV9kZXZp Y2UgKm1nYV9kZXZpY2Vfb2ZfZGV2KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCit7CisJcmV0dXJu IGNvbnRhaW5lcl9vZihkZXYsIHN0cnVjdCBtZ2FfZGV2aWNlLCBkZXYpOworfQorCitpbnQgbWdh X2RldmljZV9pbml0KHN0cnVjdCBtZ2FfZGV2aWNlICptZGV2LCBzdHJ1Y3QgZHJtX2RyaXZlciAq ZHJ2LAorCQkgICAgc3RydWN0IGZiX2luZm8gKmZiX2luZm8pOwordm9pZCBtZ2FfZGV2aWNlX2Ns ZWFudXAoc3RydWN0IG1nYV9kZXZpY2UgKm1kZXYpOworCisjZW5kaWYKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvc3RhZ2luZy9tZ2FrbXMvbWdhX2Rydi5jIGIvZHJpdmVycy9zdGFnaW5nL21nYWttcy9t Z2FfZHJ2LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi43NWUyNmQz MDQ2ZjMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3N0YWdpbmcvbWdha21zL21nYV9kcnYu YwpAQCAtMCwwICsxLDEyOSBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAK KworI2luY2x1ZGUgPGxpbnV4L2ZiLmg+CisjaW5jbHVkZSA8bGludXgvcGNpLmg+CisKKyNpbmNs dWRlIDxkcm0vZHJtX2Rydi5oPgorI2luY2x1ZGUgPGRybS9kcm1fZmJjb252X2hlbHBlci5oPgor I2luY2x1ZGUgPGRybS9kcm1fZmJfaGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9maWxlLmg+ CisjaW5jbHVkZSA8ZHJtL2RybV9nZW1fc2htZW1faGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2Ry bV9pb2N0bC5oPgorCisjaW5jbHVkZSAibWdhX2RldmljZS5oIgorI2luY2x1ZGUgIm1nYV9kcnYu aCIKKworI2RlZmluZSBEUklWRVJfQVVUSE9SCQkiVGhvbWFzIFppbW1lcm1hbm4gPHR6aW1tZXJt YW5uQHN1c2UuZGU+IgorI2RlZmluZSBEUklWRVJfTkFNRQkJIm1nYWttcyIKKyNkZWZpbmUgRFJJ VkVSX0RFU0NSSVBUSU9OCSJEUk0gZHJpdmVyIGZvciBNYXRyb3ggZ3JhcGhpY3MgY2hpcHNldHMi CisjZGVmaW5lIERSSVZFUl9MSUNFTlNFCQkiR1BMIgorI2RlZmluZSBEUklWRVJfREFURQkJIjIw MTkwMzAxIgorI2RlZmluZSBEUklWRVJfTUFKT1IJCTAKKyNkZWZpbmUgRFJJVkVSX01JTk9SCQkw CisjZGVmaW5lIERSSVZFUl9QQVRDSExFVkVMCTEKKworLyoKKyAqIERSTSBkcml2ZXIKKyAqLwor CitERUZJTkVfRFJNX0dFTV9TSE1FTV9GT1BTKG1nYV9maWxlX29wZXJhdGlvbnMpOworCitzdGF0 aWMgc3RydWN0IGRybV9kcml2ZXIgbWdhX2RyaXZlciA9IHsKKwkubWFqb3IgPSBEUklWRVJfTUFK T1IsCisJLm1pbm9yID0gRFJJVkVSX01JTk9SLAorCS5wYXRjaGxldmVsID0gRFJJVkVSX1BBVENI TEVWRUwsCisJLm5hbWUgPSBEUklWRVJfTkFNRSwKKwkuZGVzYyA9IERSSVZFUl9ERVNDUklQVElP TiwKKwkuZGF0ZSA9IERSSVZFUl9EQVRFLAorCS5kcml2ZXJfZmVhdHVyZXMgPSBEUklWRVJfQVRP TUlDIHwKKwkJCSAgIERSSVZFUl9HRU0gfAorCQkJICAgRFJJVkVSX01PREVTRVQsCisJLmZvcHMg PSAmbWdhX2ZpbGVfb3BlcmF0aW9ucywKKwlEUk1fR0VNX1NITUVNX0RSSVZFUl9PUFMsCit9Owor CitzdGF0aWMgdm9pZCBtZ2FfcmVtb3ZlX2NvbmZsaWN0aW5nX2ZyYW1lYnVmZmVycyhzdHJ1Y3Qg cGNpX2RldiAqcGRldikKK3sKKwlzdHJ1Y3QgYXBlcnR1cmVzX3N0cnVjdCAqYXA7CisJYm9vbCBw cmltYXJ5ID0gZmFsc2U7CisKKwlhcCA9IGFsbG9jX2FwZXJ0dXJlcygxKTsKKwlpZiAoIWFwKQor CQlyZXR1cm47CisKKwlhcC0+cmFuZ2VzWzBdLmJhc2UgPSBwY2lfcmVzb3VyY2Vfc3RhcnQocGRl diwgMSk7CisJYXAtPnJhbmdlc1swXS5zaXplID0gcGNpX3Jlc291cmNlX2xlbihwZGV2LCAxKTsK KworI2lmZGVmIENPTkZJR19YODYKKwlwcmltYXJ5ID0gcGRldi0+cmVzb3VyY2VbUENJX1JPTV9S RVNPVVJDRV0uZmxhZ3MgJgorCQlJT1JFU09VUkNFX1JPTV9TSEFET1c7CisjZW5kaWYKKwlkcm1f ZmJfaGVscGVyX3JlbW92ZV9jb25mbGljdGluZ19mcmFtZWJ1ZmZlcnMoYXAsIERSSVZFUl9OQU1F LAorCQkJCQkJICAgICAgcHJpbWFyeSk7CisJa2ZyZWUoYXApOworfQorCitzdGF0aWMgc3RydWN0 IG1nYV9kZXZpY2UgKm1nYV9jcmVhdGVfZGV2aWNlKHN0cnVjdCBmYl9pbmZvICpmYl9pbmZvKQor eworCXN0cnVjdCBtZ2FfZGV2aWNlICptZGV2OworCWludCByZXQ7CisKKwltZGV2ID0gZGV2bV9r emFsbG9jKGZiX2luZm8tPmRldmljZSwgc2l6ZW9mKCptZGV2KSwgR0ZQX0tFUk5FTCk7CisJaWYg KCFtZGV2KQorCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKwlyZXQgPSBtZ2FfZGV2aWNlX2lu aXQobWRldiwgJm1nYV9kcml2ZXIsIGZiX2luZm8pOworCWlmIChyZXQpCisJCWdvdG8gZXJyX2Rl dm1fa2ZyZWU7CisJcmV0dXJuIG1kZXY7CisKK2Vycl9kZXZtX2tmcmVlOgorCWRldm1fa2ZyZWUo ZmJfaW5mby0+ZGV2aWNlLCBtZGV2KTsKKwlyZXR1cm4gRVJSX1BUUihyZXQpOworfQorCitzdGF0 aWMgdm9pZCBtZ2FfZGVzdHJveV9kZXZpY2Uoc3RydWN0IG1nYV9kZXZpY2UgKm1kZXYpCit7CisJ c3RydWN0IGRldmljZSAqZGV2ID0gbWRldi0+ZmJfaW5mby0+ZGV2aWNlOworCisJbWdhX2Rldmlj ZV9jbGVhbnVwKG1kZXYpOworCWRldm1fa2ZyZWUoZGV2LCBtZGV2KTsKK30KKworc3RydWN0IG1n YV9kZXZpY2UgKm1nYV9yZWdpc3Rlcl9mcmFtZWJ1ZmZlcihzdHJ1Y3QgZmJfaW5mbyAqZmJfaW5m bywKKwkJCQkJICAgIHN0cnVjdCBwY2lfZGV2ICpwZGV2KQoreworCWludCByZXQ7CisJc3RydWN0 IG1nYV9kZXZpY2UgKm1kZXY7CisKKwltZ2FfcmVtb3ZlX2NvbmZsaWN0aW5nX2ZyYW1lYnVmZmVy cyhwZGV2KTsKKworCXJldCA9IGRybV9mYmNvbnZfZmlsbF9mYl9pbmZvKGZiX2luZm8pOworCWlm IChyZXQpCisJCXJldHVybiBFUlJfUFRSKHJldCk7CisKKwltZGV2ID0gbWdhX2NyZWF0ZV9kZXZp Y2UoZmJfaW5mbyk7CisJaWYgKElTX0VSUihtZGV2KSkgeworCQlyZXQgPSBQVFJfRVJSKG1kZXYp OworCQlnb3RvIGVycl9kcm1fZmJjb252X2NsZWFudXBfZmJfaW5mbzsKKwl9CisKKwlyZXQgPSBk cm1fZGV2X3JlZ2lzdGVyKCZtZGV2LT5kZXYsIDApOworCWlmIChyZXQpCisJCWdvdG8gZXJyX21n YV9kZXN0cm95X2RldmljZTsKKworCXJldHVybiBtZGV2OworCitlcnJfbWdhX2Rlc3Ryb3lfZGV2 aWNlOgorCW1nYV9kZXN0cm95X2RldmljZShtZGV2KTsKK2Vycl9kcm1fZmJjb252X2NsZWFudXBf ZmJfaW5mbzoKKwlkcm1fZmJjb252X2NsZWFudXBfZmJfaW5mbyhmYl9pbmZvKTsKKwlyZXR1cm4g RVJSX1BUUihyZXQpOworfQorCit2b2lkIG1nYV91bnJlZ2lzdGVyX2ZyYW1lYnVmZmVyKHN0cnVj dCBtZ2FfZGV2aWNlICptZGV2KQoreworCXN0cnVjdCBmYl9pbmZvICpmYl9pbmZvID0gbWRldi0+ ZmJfaW5mbzsKKworCW1nYV9kZXN0cm95X2RldmljZShtZGV2KTsKKwlkcm1fZmJjb252X2NsZWFu dXBfZmJfaW5mbyhmYl9pbmZvKTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9tZ2Fr bXMvbWdhX2Rydi5oIGIvZHJpdmVycy9zdGFnaW5nL21nYWttcy9tZ2FfZHJ2LmgKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5kMjE0NzE5NTE2YzAKLS0tIC9kZXYvbnVs bAorKysgYi9kcml2ZXJzL3N0YWdpbmcvbWdha21zL21nYV9kcnYuaApAQCAtMCwwICsxLDE0IEBA CisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCAqLworCisjaWZuZGVmIE1HQV9E UlZfSAorI2RlZmluZSBNR0FfRFJWX0gKKworc3RydWN0IGZiX2luZm87CitzdHJ1Y3QgbWdhX2Rl dmljZTsKK3N0cnVjdCBwY2lfZGV2OworCitzdHJ1Y3QgbWdhX2RldmljZSAqbWdhX3JlZ2lzdGVy X2ZyYW1lYnVmZmVyKHN0cnVjdCBmYl9pbmZvICpmYl9pbmZvLAorCQkJCQkgICAgc3RydWN0IHBj aV9kZXYgKnBkZXYpOwordm9pZCBtZ2FfdW5yZWdpc3Rlcl9mcmFtZWJ1ZmZlcihzdHJ1Y3QgbWdh X2RldmljZSAqbWRldik7CisKKyNlbmRpZgotLSAKMi4yMy4wCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1k ZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcv bWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWw=