Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id ; Wed, 18 Sep 2002 16:33:55 -0400 Received: (majordomo@vger.kernel.org) by vger.kernel.org id ; Wed, 18 Sep 2002 16:33:55 -0400 Received: from air-2.osdl.org ([65.172.181.6]:3968 "EHLO cherise.pdx.osdl.net") by vger.kernel.org with ESMTP id ; Wed, 18 Sep 2002 16:33:30 -0400 Date: Wed, 18 Sep 2002 13:40:05 -0700 (PDT) From: Patrick Mochel X-X-Sender: mochel@cherise.pdx.osdl.net To: torvalds@transmeta.com cc: linux-kernel@vger.kernel.org, Subject: [BK PATCH] Representing System devices and CPUs Message-ID: MIME-Version: 1.0 Content-Type: MULTIPART/MIXED; BOUNDARY="346834433-165056036-1032381605=:968" Sender: linux-kernel-owner@vger.kernel.org X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 28536 Lines: 536 This message is in MIME format. The first part should be readable text, while the remaining parts are likely unreadable without MIME-aware tools. Send mail to mime@docserver.cac.washington.edu for more info. --346834433-165056036-1032381605=:968 Content-Type: TEXT/PLAIN; charset=US-ASCII Hey there. The changelogs are below, but this is the executive summary. This beefs up the support for system devices. It introduces the following structures: struct sys_root { u32 id; struct device dev; struct device sysdev; }; struct sys_device { char * name; u32 id; struct sys_root * root; struct device dev; }; The former is intended for multi-board systems (e.g. NUMA-like) so they can accurately represent their topology. The latter is for basic description of system-level devices, like CPUs, PICs, etc. The idea is that the enumerators for multi-board systems will register each board (aka 'node') on boot. They should also know what board each system device is on, and set that in the sys_device structure. Without ->root set, system devices will be added as a child of a pseudo bus: 'sys'. They appear in driverfs in the root/sys/ directory. Each alternative root gets a directory under root/, and each gets a 'sys' subdirectory. System devices appear as children of the root's 'sysdev'. struct sys_root::dev can be used to parent other devices and buses discovered on that board; e.g. PCI buses on that board. I've taken the liberty to also implement a CPU device class, and a generic cpu structure. The device class is registered on boot, which exports all CPUs in a common place in driverfs in class/cpu/. For ia32, I've created a simple CPU device driver and a static array of cpu devices of size NR_CPUS, which are manually registered on boot. The cpus get directories under root/sys/ in driverfs, like this: `-- root `-- sys |-- cpu0 |-- cpu1 ... And get symlinks in the class directory like this: |-- class | |-- cpu | | |-- devices | | | |-- 0 -> ../../../root/sys/cpu0 | | | |-- 1 -> ../../../root/sys/cpu1 ... When the CPUs are registered, driverfs files may now be created for them. I recommend creating device interfaces for various CPU features and registering them with the device class. When the device is registered with the class, it will also be registered with all of the interfaces of the class. More documentation about this is available in the Documentation/driver-model/ directory (which is now updated!) Pending approval/comments of the CPU device code, I will be working on converting some of the interfaces over to use it. Please apply, -pat p.s. the patch is attached for non-BK users. Please pull from bk://ldm.bkbits.net/linux-2.5 This will update the following files: arch/i386/kernel/cpu/common.c | 34 +++++++++ arch/i386/kernel/i8259.c | 16 ++-- arch/i386/kernel/time.c | 15 ++-- drivers/acpi/bus.c | 120 ----------------------------------- drivers/base/Makefile | 5 - drivers/base/core.c | 36 ++++++++-- drivers/base/cpu.c | 28 ++++++++ drivers/base/driver.c | 11 +++ drivers/base/sys.c | 144 +++++++++++++++++++++++++++++++++++++----- include/linux/cpu.h | 28 ++++++++ include/linux/device.h | 31 ++++++--- 11 files changed, 303 insertions(+), 165 deletions(-) through these ChangeSets: (02/09/18 1.553) driver model: add CPU device support Declare a CPU device class, which gives CPUs a directory in driverfs under class/cpu/. Define a generic 'struct cpu' for basic defintion of CPU devices. Declare a static array of size NR_CPUS for ia32 and manually register each one on boot. Declare an archtecture specific (ia32 only for now) cpu device driver for handling generic device operations. (02/09/18 1.551) driver model: strengthen system device support. Introduce struct sys_root (to describe alternative system roots in multi- board (NUMA-like) systems; and struct sys_device to better describe system level devices. Implement registration functions for alternative system roots (for multi- board systems; e.g. NUMA-like systems) Beef-up system device registration functions so it registers the device in the root it belongs to and so it sets the bus type. It also sets the device's bus_id based on the fields in struct sys_device. Add a system_bus_type, so we have place to group the devices and drivers.. (02/09/18 1.550) driver model: Handle devices that have ->driver set on registration. If a device is registered, and its driver is set, we call found_match() immediately (and don't walk through the list of drivers of the bus). We also handle the case where the driver hasn't been registered yet, so if we a NULL driver from get_driver() in device_attach(), we assume the driver is awaiting a driver_register(). (02/09/18 1.549) ACPI: get rid of the silly acpi_bus_driver, since it didn't do anything, and won't ever do anything. --346834433-165056036-1032381605=:968 Content-Type: TEXT/PLAIN; charset=US-ASCII; name="system-device-sep18.diff" Content-Transfer-Encoding: BASE64 Content-ID: Content-Description: Content-Disposition: attachment; filename="system-device-sep18.diff" QmluYXJ5IGZpbGVzIGxpbnV4LTIuNS12aXJnaW4vYXJjaC9pMzg2L2Jvb3Qv Y29tcHJlc3NlZC9idm1saW51eCBhbmQgbGludXgtMi41L2FyY2gvaTM4Ni9i b290L2NvbXByZXNzZWQvYnZtbGludXggZGlmZmVyDQpkaWZmIC1OdXIgLXgg Qml0S2VlcGVyIC14IFNDQ1MgLXggQ2hhbmdlU2V0IC14IGlkZSAteCBzY3Np IGxpbnV4LTIuNS12aXJnaW4vYXJjaC9pMzg2L2tlcm5lbC9jcHUvY29tbW9u LmMgbGludXgtMi41L2FyY2gvaTM4Ni9rZXJuZWwvY3B1L2NvbW1vbi5jDQot LS0gbGludXgtMi41LXZpcmdpbi9hcmNoL2kzODYva2VybmVsL2NwdS9jb21t b24uYwlNb24gU2VwIDE2IDE2OjQ4OjU3IDIwMDINCisrKyBsaW51eC0yLjUv YXJjaC9pMzg2L2tlcm5lbC9jcHUvY29tbW9uLmMJV2VkIFNlcCAxOCAxMzoz Nzo0MSAyMDAyDQpAQCAtMSw2ICsxLDcgQEANCiAjaW5jbHVkZSA8bGludXgv aW5pdC5oPg0KICNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4NCiAjaW5jbHVk ZSA8bGludXgvZGVsYXkuaD4NCisjaW5jbHVkZSA8bGludXgvY3B1Lmg+DQog I2luY2x1ZGUgPGxpbnV4L3NtcC5oPg0KICNpbmNsdWRlIDxhc20vc2VtYXBo b3JlLmg+DQogI2luY2x1ZGUgPGFzbS9wcm9jZXNzb3IuaD4NCkBAIC01MDYs MyArNTA3LDM2IEBADQogCWN1cnJlbnQtPnVzZWRfbWF0aCA9IDA7DQogCXN0 dHMoKTsNCiB9DQorDQorLyoNCisgKiBCdWxrIHJlZ2lzdHJhdGlvbiBvZiB0 aGUgY3B1IGRldmljZXMgd2l0aCB0aGUgc3lzdGVtLg0KKyAqIFNvbWUgb2Yg dGhpcyBzdHVmZiBjb3VsZCBwb3NzaWJseSBiZSBtb3ZlZCBpbnRvIGEgc2hh cmVkIA0KKyAqIGxvY2F0aW9uLi4NCisgKiBBbHNvLCB0aGVzZSBkZXZpY2Vz IHNob3VsZCBiZSBpbnRlZ3JhdGVkIHdpdGggb3RoZXIgQ1BVIGRhdGEuLg0K KyAqLw0KKw0KK3N0YXRpYyBzdHJ1Y3QgY3B1IGNwdV9kZXZpY2VzW05SX0NQ VVNdOw0KKw0KK3N0YXRpYyBzdHJ1Y3QgZGV2aWNlX2RyaXZlciBjcHVfZHJp dmVyID0gew0KKwkubmFtZQkJPSAiY3B1IiwNCisJLmJ1cwkJPSAmc3lzdGVt X2J1c190eXBlLA0KKwkuZGV2Y2xhc3MJPSAmY3B1X2RldmNsYXNzLA0KK307 DQorDQorc3RhdGljIGludCBfX2luaXQgcmVnaXN0ZXJfY3B1cyh2b2lkKQ0K K3sNCisJaW50IGk7DQorDQorCWRyaXZlcl9yZWdpc3RlcigmY3B1X2RyaXZl cik7DQorDQorCWZvciAoaSA9IDA7IGkgPCBOUl9DUFVTOyBpKyspIHsNCisJ CXN0cnVjdCBzeXNfZGV2aWNlICogc3lzZGV2ID0gJmNwdV9kZXZpY2VzW2ld LnN5c2RldjsNCisJCXN5c2Rldi0+bmFtZSA9ICJjcHUiOw0KKwkJc3lzZGV2 LT5pZCA9IGk7DQorCQlzeXNkZXYtPmRldi5kcml2ZXIgPSAmY3B1X2RyaXZl cjsNCisJCXN5c19yZWdpc3Rlcl9kZXZpY2Uoc3lzZGV2KTsNCisJfQ0KKwly ZXR1cm4gMDsNCit9DQorDQorc3Vic3lzX2luaXRjYWxsKHJlZ2lzdGVyX2Nw dXMpOw0KZGlmZiAtTnVyIC14IEJpdEtlZXBlciAteCBTQ0NTIC14IENoYW5n ZVNldCAteCBpZGUgLXggc2NzaSBsaW51eC0yLjUtdmlyZ2luL2FyY2gvaTM4 Ni9rZXJuZWwvaTgyNTkuYyBsaW51eC0yLjUvYXJjaC9pMzg2L2tlcm5lbC9p ODI1OS5jDQotLS0gbGludXgtMi41LXZpcmdpbi9hcmNoL2kzODYva2VybmVs L2k4MjU5LmMJVHVlIEF1ZyAyMCAwOTo1NzoxNSAyMDAyDQorKysgbGludXgt Mi41L2FyY2gvaTM4Ni9rZXJuZWwvaTgyNTkuYwlXZWQgU2VwIDE4IDEyOjA1 OjE2IDIwMDINCkBAIC0yNDYsMjEgKzI0NiwyNSBAQA0KIH0NCiANCiBzdGF0 aWMgc3RydWN0IGRldmljZV9kcml2ZXIgZHJpdmVyX2k4MjU5QSA9IHsNCisJ Lm5hbWUJCT0gInBpYyIsDQogCS5yZXN1bWUJCT0gaTgyNTlBX3Jlc3VtZSwN CiB9Ow0KIA0KLXN0YXRpYyBzdHJ1Y3QgZGV2aWNlIGRldmljZV9pODI1OUEg PSB7DQotCS5uYW1lCSAgICAgICAJPSAiaTgyNTlBIiwNCi0JLmJ1c19pZAkJ PSAiMDAyMCIsDQotCS5kcml2ZXIJCT0gJmRyaXZlcl9pODI1OUEsDQorc3Rh dGljIHN0cnVjdCBzeXNfZGV2aWNlIGRldmljZV9pODI1OUEgPSB7DQorCS5u YW1lCQk9ICJwaWMiLA0KKwkuaWQJCT0gMCwNCisJLmRldgkJPSB7DQorCQku bmFtZQk9ICJpODI1OUEgUElDIiwNCisJCS5kcml2ZXIJPSAmZHJpdmVyX2k4 MjU5QSwNCisJfSwNCiB9Ow0KIA0KIHN0YXRpYyBpbnQgX19pbml0IGluaXRf ODI1OUFfZGV2aWNlZnModm9pZCkNCiB7DQotCXJldHVybiByZWdpc3Rlcl9z eXNfZGV2aWNlKCZkZXZpY2VfaTgyNTlBKTsNCisJcmV0dXJuIHN5c19yZWdp c3Rlcl9kZXZpY2UoJmRldmljZV9pODI1OUEpOw0KIH0NCiANCi1fX2luaXRj YWxsKGluaXRfODI1OUFfZGV2aWNlZnMpOw0KK2RldmljZV9pbml0Y2FsbChp bml0XzgyNTlBX2RldmljZWZzKTsNCiANCiB2b2lkIGluaXRfODI1OUEoaW50 IGF1dG9fZW9pKQ0KIHsNCmRpZmYgLU51ciAteCBCaXRLZWVwZXIgLXggU0ND UyAteCBDaGFuZ2VTZXQgLXggaWRlIC14IHNjc2kgbGludXgtMi41LXZpcmdp bi9hcmNoL2kzODYva2VybmVsL3RpbWUuYyBsaW51eC0yLjUvYXJjaC9pMzg2 L2tlcm5lbC90aW1lLmMNCi0tLSBsaW51eC0yLjUtdmlyZ2luL2FyY2gvaTM4 Ni9rZXJuZWwvdGltZS5jCVR1ZSBTZXAgMTAgMTY6MjY6MTAgMjAwMg0KKysr IGxpbnV4LTIuNS9hcmNoL2kzODYva2VybmVsL3RpbWUuYwlXZWQgU2VwIDE4 IDEyOjA1OjE5IDIwMDINCkBAIC02MzksMTcgKzYzOSwyMCBAQA0KIAlyZXR1 cm4gMDsNCiB9DQogDQotc3RhdGljIHN0cnVjdCBkZXZpY2UgZGV2aWNlX2k4 MjUzID0gew0KLQkubmFtZQkgICAgICAgCT0gImk4MjUzIiwNCi0JLmJ1c19p ZAkJPSAiMDA0MCIsDQorc3RhdGljIHN0cnVjdCBzeXNfZGV2aWNlIGRldmlj ZV9pODI1MyA9IHsNCisJLm5hbWUJCT0gInJ0YyIsDQorCS5pZAkJPSAwLA0K KwkuZGV2CT0gew0KKwkJLm5hbWUJPSAiaTgyNTMgUmVhbCBUaW1lIENsb2Nr IiwNCisJfSwNCiB9Ow0KIA0KLXN0YXRpYyBpbnQgdGltZV9pbml0X2RyaXZl cmZzKHZvaWQpDQorc3RhdGljIGludCB0aW1lX2luaXRfZGV2aWNlKHZvaWQp DQogew0KLQlyZXR1cm4gcmVnaXN0ZXJfc3lzX2RldmljZSgmZGV2aWNlX2k4 MjUzKTsNCisJcmV0dXJuIHN5c19yZWdpc3Rlcl9kZXZpY2UoJmRldmljZV9p ODI1Myk7DQogfQ0KIA0KLV9faW5pdGNhbGwodGltZV9pbml0X2RyaXZlcmZz KTsNCitkZXZpY2VfaW5pdGNhbGwodGltZV9pbml0X2RldmljZSk7DQogDQog dm9pZCBfX2luaXQgdGltZV9pbml0KHZvaWQpDQogew0KZGlmZiAtTnVyIC14 IEJpdEtlZXBlciAteCBTQ0NTIC14IENoYW5nZVNldCAteCBpZGUgLXggc2Nz aSBsaW51eC0yLjUtdmlyZ2luL2RyaXZlcnMvYWNwaS9idXMuYyBsaW51eC0y LjUvZHJpdmVycy9hY3BpL2J1cy5jDQotLS0gbGludXgtMi41LXZpcmdpbi9k cml2ZXJzL2FjcGkvYnVzLmMJVHVlIFNlcCAxMCAxNjoyNjoxMCAyMDAyDQor KysgbGludXgtMi41L2RyaXZlcnMvYWNwaS9idXMuYwlXZWQgU2VwIDE4IDEx OjE1OjI4IDIwMDINCkBAIC05NSwxMjQgKzk1LDYgQEANCiAgICAgICAgICAg ICAgICAgICAgICAgICAgIExpbnV4IERyaXZlciBNb2RlbCAoTERNKSBTdXBw b3J0DQogICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8NCiAN Ci0jaWZkZWYgQ09ORklHX0xETQ0KLQ0KLXN0YXRpYyBpbnQgYWNwaV9kZXZp Y2VfcHJvYmUoc3RydWN0IGRldmljZSAqZGV2KTsNCi1zdGF0aWMgaW50IGFj cGlfZGV2aWNlX3JlbW92ZShzdHJ1Y3QgZGV2aWNlICpkZXYpOw0KLXN0YXRp YyBpbnQgYWNwaV9kZXZpY2Vfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYs IHUzMiBzdGF0ZSwgdTMyIHN0YWdlKTsNCi1zdGF0aWMgaW50IGFjcGlfZGV2 aWNlX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHUzMiBzdGFnZSk7DQot DQotc3RhdGljIHN0cnVjdCBkZXZpY2VfZHJpdmVyIGFjcGlfYnVzX2RyaXZl ciA9IHsNCi0JLnByb2JlID0gYWNwaV9kZXZpY2VfcHJvYmUsDQotCS5yZW1v dmUgPSBhY3BpX2RldmljZV9yZW1vdmUsCQ0KLQkuc3VzcGVuZCA9IGFjcGlf ZGV2aWNlX3N1c3BlbmQsDQotCS5yZXN1bWUgPSBhY3BpX2RldmljZV9yZXN1 bWUsDQotfTsNCi0NCi0NCi1zdGF0aWMgaW50DQotYWNwaV9kZXZpY2VfcHJv YmUgKA0KLQlzdHJ1Y3QgZGV2aWNlCQkqZGV2KQ0KLXsNCi0JQUNQSV9GVU5D VElPTl9UUkFDRSgiYWNwaV9kZXZpY2VfcHJvYmUiKTsNCi0NCi0JaWYgKCFk ZXYpDQotCQlyZXR1cm5fVkFMVUUoLUVJTlZBTCk7DQotDQotCS8qIFRCRCAq Lw0KLQ0KLQlyZXR1cm5fVkFMVUUoMCk7DQotfQ0KLQ0KLQ0KLXN0YXRpYyBp bnQNCi1hY3BpX2RldmljZV9yZW1vdmUgKA0KLQlzdHJ1Y3QgZGV2aWNlCQkq ZGV2KQ0KLXsNCi0JQUNQSV9GVU5DVElPTl9UUkFDRSgiYWNwaV9kZXZpY2Vf cmVtb3ZlIik7DQotDQotCWlmICghZGV2KQ0KLQkJcmV0dXJuX1ZBTFVFKC1F SU5WQUwpOw0KLQ0KLQkvKiBUQkQgKi8NCi0NCi0JcmV0dXJuX1ZBTFVFKDAp Ow0KLX0NCi0NCi0NCi1zdGF0aWMgaW50DQotYWNwaV9kZXZpY2Vfc3VzcGVu ZCAoDQotCXN0cnVjdCBkZXZpY2UJCSpkZXYsDQotCXUzMgkJCXN0YXRlLA0K LQl1MzIJCQlzdGFnZSkNCi17DQotCUFDUElfRlVOQ1RJT05fVFJBQ0UoImFj cGlfZGV2aWNlX3N1c3BlbmQiKTsNCi0NCi0JaWYgKCFkZXYpDQotCQlyZXR1 cm5fVkFMVUUoLUVJTlZBTCk7DQotDQotCS8qIFRCRCAqLw0KLQ0KLQlyZXR1 cm5fVkFMVUUoMCk7DQotfQ0KLQ0KLQ0KLXN0YXRpYyBpbnQNCi1hY3BpX2Rl dmljZV9yZXN1bWUgKA0KLQlzdHJ1Y3QgZGV2aWNlCQkqZGV2LA0KLQl1MzIJ CQlzdGFnZSkNCi17DQotCUFDUElfRlVOQ1RJT05fVFJBQ0UoImFjcGlfZGV2 aWNlX3Jlc3VtZSIpOw0KLQ0KLQlpZiAoIWRldikNCi0JCXJldHVybl9WQUxV RSgtRUlOVkFMKTsNCi0NCi0JLyogVEJEICovDQotDQotCXJldHVybl9WQUxV RSgwKTsNCi19DQotDQotI2lmIDAgLyogbm90IHVzZWQgQVRNICovDQotc3Rh dGljIGludA0KLWFjcGlfcGxhdGZvcm1fYWRkICgNCi0Jc3RydWN0IGRldmlj ZQkJKmRldikNCi17DQotCUFDUElfRlVOQ1RJT05fVFJBQ0UoImFjcGlfcGxh dGZvcm1fYWRkIik7DQotDQotCWlmICghZGV2KQ0KLQkJcmV0dXJuIC1FSU5W QUw7DQotDQotCUFDUElfREVCVUdfUFJJTlQoKEFDUElfREJfSU5GTywgIkRl dmljZSAlcyAoJXMpIGFkZGVkXG4iLA0KLQkJZGV2LT5uYW1lLCBkZXYtPmJ1 c19pZCkpOw0KLQ0KLQkvKiBUQkQgKi8NCi0NCi0JcmV0dXJuX1ZBTFVFKDAp Ow0KLX0NCi0NCi0NCi1zdGF0aWMgaW50DQotYWNwaV9wbGF0Zm9ybV9yZW1v dmUgKA0KLQlzdHJ1Y3QgZGV2aWNlCQkqZGV2KQ0KLXsNCi0JQUNQSV9GVU5D VElPTl9UUkFDRSgiYWNwaV9wbGF0Zm9ybV9hZGQiKTsNCi0NCi0JaWYgKCFk ZXYpDQotCQlyZXR1cm4gLUVJTlZBTDsNCi0NCi0JQUNQSV9ERUJVR19QUklO VCgoQUNQSV9EQl9JTkZPLCAiRGV2aWNlICVzICglcykgcmVtb3ZlZFxuIiwN Ci0JCWRldi0+bmFtZSwgZGV2LT5idXNfaWQpKTsNCi0NCi0JLyogVEJEICov DQotDQotCXJldHVybl9WQUxVRSgwKTsNCi19DQotI2VuZGlmIC8qIHVudXNl ZCAqLw0KLQ0KLQ0KLSNlbmRpZiAvKkNPTkZJR19MRE0qLw0KLQ0KLQ0KIHN0 YXRpYyBpbnQNCiBhY3BpX2RldmljZV9yZWdpc3RlciAoDQogCXN0cnVjdCBh Y3BpX2RldmljZQkqZGV2aWNlLA0KQEAgLTIzMSw4ICsxMTMsNiBAQA0KIAlz dHJuY3B5KGRldmljZS0+ZGV2LmJ1c19pZCwgZGV2aWNlLT5wbnAuYnVzX2lk LCBzaXplb2YoYWNwaV9idXNfaWQpKTsNCiAJaWYgKHBhcmVudCkNCiAJCWRl dmljZS0+ZGV2LnBhcmVudCA9ICZwYXJlbnQtPmRldjsNCi0JZGV2aWNlLT5k ZXYuZHJpdmVyID0gJmFjcGlfYnVzX2RyaXZlcjsNCi0NCiAJcmVzdWx0ID0g ZGV2aWNlX3JlZ2lzdGVyKCZkZXZpY2UtPmRldik7DQogI2VuZGlmIC8qQ09O RklHX0xETSovDQogDQpkaWZmIC1OdXIgLXggQml0S2VlcGVyIC14IFNDQ1Mg LXggQ2hhbmdlU2V0IC14IGlkZSAteCBzY3NpIGxpbnV4LTIuNS12aXJnaW4v ZHJpdmVycy9iYXNlL01ha2VmaWxlIGxpbnV4LTIuNS9kcml2ZXJzL2Jhc2Uv TWFrZWZpbGUNCi0tLSBsaW51eC0yLjUtdmlyZ2luL2RyaXZlcnMvYmFzZS9N YWtlZmlsZQlXZWQgU2VwIDE4IDA5OjM3OjQyIDIwMDINCisrKyBsaW51eC0y LjUvZHJpdmVycy9iYXNlL01ha2VmaWxlCVdlZCBTZXAgMTggMTM6MzQ6MzAg MjAwMg0KQEAgLTEsMTEgKzEsMTIgQEANCiAjIE1ha2VmaWxlIGZvciB0aGUg TGludXggZGV2aWNlIHRyZWUNCiANCiBvYmoteQkJOj0gY29yZS5vIHN5cy5v IGludGVyZmFjZS5vIHBvd2VyLm8gYnVzLm8gXA0KLQkJCWRyaXZlci5vIGNs YXNzLm8gaW50Zi5vIHBsYXRmb3JtLm8NCisJCQlkcml2ZXIubyBjbGFzcy5v IGludGYubyBwbGF0Zm9ybS5vIFwNCisJCQljcHUubw0KIA0KIG9iai15CQkr PSBmcy8NCiANCiBleHBvcnQtb2Jqcwk6PSBjb3JlLm8gcG93ZXIubyBzeXMu byBidXMubyBkcml2ZXIubyBcDQotCQkJY2xhc3MubyBpbnRmLm8NCisJCQlj bGFzcy5vIGludGYubyBjcHUubw0KIA0KIGluY2x1ZGUgJChUT1BESVIpL1J1 bGVzLm1ha2UNCmRpZmYgLU51ciAteCBCaXRLZWVwZXIgLXggU0NDUyAteCBD aGFuZ2VTZXQgLXggaWRlIC14IHNjc2kgbGludXgtMi41LXZpcmdpbi9kcml2 ZXJzL2Jhc2UvY29yZS5jIGxpbnV4LTIuNS9kcml2ZXJzL2Jhc2UvY29yZS5j DQotLS0gbGludXgtMi41LXZpcmdpbi9kcml2ZXJzL2Jhc2UvY29yZS5jCVdl ZCBTZXAgMTggMDk6Mzc6NDIgMjAwMg0KKysrIGxpbnV4LTIuNS9kcml2ZXJz L2Jhc2UvY29yZS5jCVdlZCBTZXAgMTggMTE6MjM6NTYgMjAwMg0KQEAgLTY2 LDcgKzY2LDcgQEANCiB9DQogDQogLyoqDQotICogZGV2aWNlX2F0dGFjaCAt IHRyeSB0byBhc3NvY2lhdGVkIGRldmljZSB3aXRoIGEgZHJpdmVyDQorICog ZG9fZGV2aWNlX2F0dGFjaCAtIHRyeSB0byBhc3NvY2lhdGVkIGRldmljZSB3 aXRoIGEgZHJpdmVyDQogICogQGRydjoJY3VycmVudCBkcml2ZXIgdG8gdHJ5 DQogICogQGRhdGE6CWRldmljZSBpbiBkaXNndWlzZQ0KICAqDQpAQCAtODAs MTggKzgwLDQwIEBADQogCXN0cnVjdCBkZXZpY2UgKiBkZXYgPSAoc3RydWN0 IGRldmljZSAqKWRhdGE7DQogCWludCBlcnJvciA9IDA7DQogDQotCWlmICgh ZGV2LT5kcml2ZXIpIHsNCi0JCWlmIChkcnYtPmJ1cy0+bWF0Y2ggJiYgZHJ2 LT5idXMtPm1hdGNoKGRldixkcnYpKQ0KLQkJCWVycm9yID0gZm91bmRfbWF0 Y2goZGV2LGRydik7DQotCX0NCisJaWYgKGRydi0+YnVzLT5tYXRjaCAmJiBk cnYtPmJ1cy0+bWF0Y2goZGV2LGRydikpDQorCQllcnJvciA9IGZvdW5kX21h dGNoKGRldixkcnYpOw0KIAlyZXR1cm4gZXJyb3I7DQogfQ0KIA0KKy8qKg0K KyAqIGRldmljZV9hdHRhY2ggLSBmaW5kIGEgZHJpdmVyIGZvciBhIGRldmlj ZQ0KKyAqIEBkZXY6CWRldmljZSB3ZSdyZSB0cnlpbmcgdG8gZHJpdmUNCisg Kg0KKyAqIEEgZGV2aWNlIGhhcyBiZWVuIHJlZ2lzdGVyZWQgYW5kIHdlIHdh bnQgdG8gYmluZCBpdCB0byBhIGRyaXZlci4NCisgKiBUaGUgY29tbW9uIGNh c2UgaXMgdGhhdCB0aGUgZGV2aWNlIGRvZXNuJ3QgaGF2ZSBhIGRyaXZlciwg c28gd2UgDQorICogbWFrZSB0aGUgY2FsbCB0byBpdGVyYXRlIG92ZXIgYWxs IHRoZSBkcml2ZXJzIG9uIHRoZSBidXMgdG8gZmluZCBhDQorICogbWF0Y2gg Zm9yIHRoZSBkZXZpY2UuDQorICoNCisgKiBUaGUgZGV2aWNlIG1heSBhbHJl YWR5IGhhdmUgYSBkcml2ZXIsIHRob3VnaCwgc28gd2UgdHJ5IHRvIG1ha2Ug DQorICogdGhpbmdzIGVhc3kgZm9yIHRob3NlIGNhc2VzICh0eXBpY2FsbHkg c3lzdGVtIG9yIGxlZ2FjeSBkZXZpY2VzKS4NCisgKiBXZSBjaGVjayB0aGUg cmVmY291bnQgb2YgdGhlIGRyaXZlci4gSWYgaXQncyAwLCB0aGVuIGl0IGhh c24ndCBiZWVuDQorICogcmVnaXN0ZXJlZCB5ZXQsIHNvIHdlIGRvIHRoYXQg Zm9yIHRoZSBkcml2ZXIgdG8gaW5pdGlhbGl6ZSBldmVyeXRoaW5nDQorICog aW4gdGhlIHN0cnVjdHVyZS4gV2UgdGhlbiBjYWxsIGZvdW5kX21hdGNoKCkg dG8gZG8gdGhlIGFjdHVhbCANCisgKiBiZXR3ZWVuIHRoZSB0d28uDQorICov DQogc3RhdGljIGludCBkZXZpY2VfYXR0YWNoKHN0cnVjdCBkZXZpY2UgKiBk ZXYpDQogew0KIAlpbnQgZXJyb3IgPSAwOw0KLQlpZiAoZGV2LT5idXMpDQot CQllcnJvciA9IGJ1c19mb3JfZWFjaF9kcnYoZGV2LT5idXMsZGV2LGRvX2Rl dmljZV9hdHRhY2gpOw0KKwlpZiAoIWRldi0+ZHJpdmVyKSB7DQorCQlpZiAo ZGV2LT5idXMpDQorCQkJZXJyb3IgPSBidXNfZm9yX2VhY2hfZHJ2KGRldi0+ YnVzLGRldixkb19kZXZpY2VfYXR0YWNoKTsNCisJfSBlbHNlIHsNCisJCXN0 cnVjdCBkZXZpY2VfZHJpdmVyICogZHJ2ID0gZ2V0X2RyaXZlcihkZXYtPmRy aXZlcik7DQorCQlpZiAoIWRydikNCisJCQllcnJvciA9IGRyaXZlcl9yZWdp c3RlcihkZXYtPmRyaXZlcik7DQorCQlpZiAoIWVycm9yKQ0KKwkJCWVycm9y ID0gZm91bmRfbWF0Y2goZGV2LGRldi0+ZHJpdmVyKTsNCisJfQ0KIAlyZXR1 cm4gZXJyb3I7DQogfQ0KIA0KZGlmZiAtTnVyIC14IEJpdEtlZXBlciAteCBT Q0NTIC14IENoYW5nZVNldCAteCBpZGUgLXggc2NzaSBsaW51eC0yLjUtdmly Z2luL2RyaXZlcnMvYmFzZS9jcHUuYyBsaW51eC0yLjUvZHJpdmVycy9iYXNl L2NwdS5jDQotLS0gbGludXgtMi41LXZpcmdpbi9kcml2ZXJzL2Jhc2UvY3B1 LmMJV2VkIERlYyAzMSAxNjowMDowMCAxOTY5DQorKysgbGludXgtMi41L2Ry aXZlcnMvYmFzZS9jcHUuYwlXZWQgU2VwIDE4IDEzOjM0OjMwIDIwMDINCkBA IC0wLDAgKzEsMjggQEANCisvKg0KKyAqIGNwdS5jIC0gYmFzaWMgY3B1IGNs YXNzIHN1cHBvcnQNCisgKi8NCisNCisjaW5jbHVkZSA8bGludXgvZGV2aWNl Lmg+DQorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPg0KKyNpbmNsdWRlIDxs aW51eC9pbml0Lmg+DQorI2luY2x1ZGUgPGxpbnV4L2NwdS5oPg0KKw0KK3N0 YXRpYyBpbnQgY3B1X2FkZF9kZXZpY2Uoc3RydWN0IGRldmljZSAqIGRldikN Cit7DQorCXJldHVybiAwOw0KK30NCisNCitzdHJ1Y3QgZGV2aWNlX2NsYXNz IGNwdV9kZXZjbGFzcyA9IHsNCisJLm5hbWUJCT0gImNwdSIsDQorCS5hZGRf ZGV2aWNlCT0gY3B1X2FkZF9kZXZpY2UsDQorfTsNCisNCisNCitzdGF0aWMg aW50IF9faW5pdCBjcHVfZGV2Y2xhc3NfaW5pdCh2b2lkKQ0KK3sNCisJcmV0 dXJuIGRldmNsYXNzX3JlZ2lzdGVyKCZjcHVfZGV2Y2xhc3MpOw0KK30NCisN Citwb3N0Y29yZV9pbml0Y2FsbChjcHVfZGV2Y2xhc3NfaW5pdCk7DQorDQor RVhQT1JUX1NZTUJPTChjcHVfZGV2Y2xhc3MpOw0KZGlmZiAtTnVyIC14IEJp dEtlZXBlciAteCBTQ0NTIC14IENoYW5nZVNldCAteCBpZGUgLXggc2NzaSBs aW51eC0yLjUtdmlyZ2luL2RyaXZlcnMvYmFzZS9kcml2ZXIuYyBsaW51eC0y LjUvZHJpdmVycy9iYXNlL2RyaXZlci5jDQotLS0gbGludXgtMi41LXZpcmdp bi9kcml2ZXJzL2Jhc2UvZHJpdmVyLmMJRnJpIEF1ZyAxNiAxMzoyMDoyMCAy MDAyDQorKysgbGludXgtMi41L2RyaXZlcnMvYmFzZS9kcml2ZXIuYwlXZWQg U2VwIDE4IDExOjIzOjU2IDIwMDINCkBAIC04NCw2ICs4NCwxNiBAQA0KIAlf X3JlbW92ZV9kcml2ZXIoZHJ2KTsNCiB9DQogDQorc3RydWN0IGRldmljZV9k cml2ZXIgKiBnZXRfZHJpdmVyKHN0cnVjdCBkZXZpY2VfZHJpdmVyICogZHJ2 KQ0KK3sNCisJc3RydWN0IGRldmljZV9kcml2ZXIgKiByZXQgPSBkcnY7DQor CWlmIChhdG9taWNfcmVhZCgmZHJ2LT5yZWZjb3VudCkpDQorCQlhdG9taWNf aW5jKCZkcnYtPnJlZmNvdW50KTsNCisJZWxzZQ0KKwkJcmV0ID0gTlVMTDsN CisJcmV0dXJuIHJldDsNCit9DQorDQogLyoqDQogICogcHV0X2RyaXZlciAt IGRlY3JlbWVudCBkcml2ZXIncyByZWZjb3VudCBhbmQgY2xlYW4gdXAgaWYg bmVjZXNzYXJ5DQogICogQGRydjoJZHJpdmVyIGluIHF1ZXN0aW9uDQpAQCAt OTksNSArMTA5LDYgQEANCiANCiBFWFBPUlRfU1lNQk9MKGRyaXZlcl9mb3Jf ZWFjaF9kZXYpOw0KIEVYUE9SVF9TWU1CT0woZHJpdmVyX3JlZ2lzdGVyKTsN CitFWFBPUlRfU1lNQk9MKGdldF9kcml2ZXIpOw0KIEVYUE9SVF9TWU1CT0wo cHV0X2RyaXZlcik7DQogRVhQT1JUX1NZTUJPTChyZW1vdmVfZHJpdmVyKTsN CmRpZmYgLU51ciAteCBCaXRLZWVwZXIgLXggU0NDUyAteCBDaGFuZ2VTZXQg LXggaWRlIC14IHNjc2kgbGludXgtMi41LXZpcmdpbi9kcml2ZXJzL2Jhc2Uv c3lzLmMgbGludXgtMi41L2RyaXZlcnMvYmFzZS9zeXMuYw0KLS0tIGxpbnV4 LTIuNS12aXJnaW4vZHJpdmVycy9iYXNlL3N5cy5jCUZyaSBBdWcgMTYgMTM6 MjA6MjAgMjAwMg0KKysrIGxpbnV4LTIuNS9kcml2ZXJzL2Jhc2Uvc3lzLmMJ V2VkIFNlcCAxOCAxMzozNDozMCAyMDAyDQpAQCAtMTAsNDAgKzEwLDE1NCBA QA0KICAqIGFkZCB0aGVtc2VsdmVzIGFzIGNoaWxkcmVuIG9mIHRoZSBzeXN0 ZW0gYnVzLg0KICAqLw0KIA0KKyNkZWZpbmUgREVCVUcgMQ0KKw0KICNpbmNs dWRlIDxsaW51eC9kZXZpY2UuaD4NCiAjaW5jbHVkZSA8bGludXgvbW9kdWxl Lmg+DQorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPg0KICNpbmNsdWRlIDxs aW51eC9pbml0Lmg+DQogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4NCi0jaW5j bHVkZSA8bGludXgvZXJybm8uaD4NCisjaW5jbHVkZSA8bGludXgvZXJyLmg+ DQogDQorLyogVGhlIGRlZmF1bHQgc3lzdGVtIGRldmljZSBwYXJlbnQuICov DQogc3RhdGljIHN0cnVjdCBkZXZpY2Ugc3lzdGVtX2J1cyA9IHsNCiAgICAg ICAgLm5hbWUgICAgICAgICAgID0gIlN5c3RlbSBCdXMiLA0KICAgICAgICAu YnVzX2lkICAgICAgICAgPSAic3lzIiwNCiB9Ow0KIA0KLWludCByZWdpc3Rl cl9zeXNfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKiBkZXYpDQorLyoqDQorICoJ c3lzX3JlZ2lzdGVyX3Jvb3QgLSBhZGQgYSBzdWJvcmRpbmF0ZSBzeXN0ZW0g cm9vdA0KKyAqCUByb290OgluZXcgcm9vdA0KKyAqCQ0KKyAqCVRoaXMgaXMg Zm9yIE5VTUEtbGlrZSBzeXN0ZW1zIHNvIHRoZXkgY2FuIGFjY3VyYXRlbHkg DQorICoJcmVwcmVzZW50IHRoZSB0b3BvbG9neSBvZiB0aGUgZW50aXJlIHN5 c3RlbS4NCisgKglBcyBib2FyZHMgYXJlIGRpc2NvdmVyZWQsIGEgbmV3IHN0 cnVjdCBzeXNfcm9vdCBzaG91bGQgDQorICoJYmUgYWxsb2NhdGVkIGFuZCBy ZWdpc3RlcmVkLiANCisgKglUaGUgZGlzY292ZXJ5IG1lY2hhbmlzbSBzaG91 bGQgaW5pdGlhbGl6ZSB0aGUgaWQgZmllbGQNCisgKglvZiB0aGUgc3RydXR1 cmUsIGFzIHdlbGwgYXMgbXVjaCBvZiB0aGUgZW1iZWRkZWQgZGV2aWNlDQor ICoJc3RydWN0dXJlIGFzIHBvc3NpYmxlLCBpbmxjdWRpbmcgdGhlIG5hbWUs IHRoZSBidXNfaWQNCisgKglhbmQgcGFyZW50IGZpZWxkcy4NCisgKg0KKyAq CVRoaXMgc2ltcGx5IGNhbGxzIGRldmljZV9yZWdpc3RlciBvbiB0aGUgZW1i ZWRkZWQgZGV2aWNlLg0KKyAqCU9uIHN1Y2Nlc3MsIGl0IHdpbGwgdXNlIHRo ZSBzdHJ1Y3QgQHJvb3QtPnN5c2RldiANCisgKglkZXZpY2UgdG8gY3JlYXRl IGEgcHNldWRvLXBhcmVudCBmb3Igc3lzdGVtIGRldmljZXMNCisgKglvbiB0 aGF0IGJvYXJkLg0KKyAqDQorICoJVGhlIHBsYXRmb3JtIGNvZGUgY2FuIHRo ZW4gdXNlIEByb290IHRvIHNwZWNpZml5IHRoZQ0KKyAqCWNvbnRyb2xsaW5n IGJvYXJkIHdoZW4gZGlzY292ZXJpbmcgYW5kIHJlZ2lzdGVyaW5nIA0KKyAq CXN5c3RlbSBkZXZpY2VzLg0KKyAqLw0KK2ludCBzeXNfcmVnaXN0ZXJfcm9v dChzdHJ1Y3Qgc3lzX3Jvb3QgKiByb290KQ0KK3sNCisJaW50IGVycm9yID0g MDsNCisNCisJaWYgKCFyb290KQ0KKwkJcmV0dXJuIC1FSU5WQUw7DQorDQor CXByX2RlYnVnKCJSZWdpc3RlcmluZyBzeXN0ZW0gYm9hcmQgJWRcbiIscm9v dC0+aWQpOw0KKw0KKwllcnJvciA9IGRldmljZV9yZWdpc3Rlcigmcm9vdC0+ ZGV2KTsNCisJaWYgKCFlcnJvcikgew0KKwkJc3RybmNweShyb290LT5zeXNk ZXYuYnVzX2lkLCJzeXMiLEJVU19JRF9TSVpFKTsNCisJCXN0cm5jcHkocm9v dC0+c3lzZGV2Lm5hbWUsIlN5c3RlbSBCdXMiLERFVklDRV9OQU1FX1NJWkUp Ow0KKwkJcm9vdC0+c3lzZGV2LnBhcmVudCA9ICZyb290LT5kZXY7DQorCQll cnJvciA9IGRldmljZV9yZWdpc3Rlcigmcm9vdC0+c3lzZGV2KTsNCisJfTsN CisNCisJcmV0dXJuIGVycm9yOw0KK30NCisNCisvKioNCisgKglzeXNfdW5y ZWdpc3Rlcl9yb290IC0gcmVtb3ZlIHN1Ym9yZGluYXRlIHJvb3QgZnJvbSB0 cmVlDQorICoJQHJvb3Q6CXN1Ym9yZGluYXRlIHJvb3QgaW4gcXVlc3Rpb24u DQorICoNCisgKglXZSBvbmx5IGRlY3JlbWVudCB0aGUgcmVmZXJlbmNlIGNv dW50IG9uIEByb290LT5zeXNkZXYgDQorICoJYW5kIEByb290LT5kZXYuDQor ICoJSWYgYm90aCBhcmUgMCwgdGhleSB3aWxsIGJlIGNsZWFuZWQgdXAgYnkg dGhlIGNvcmUuDQorICovDQordm9pZCBzeXNfdW5lZ2lzdGVyX3Jvb3Qoc3Ry dWN0IHN5c19yb290ICogIHJvb3QpDQorew0KKwlwdXRfZGV2aWNlKCZyb290 LT5zeXNkZXYpOw0KKwlwdXRfZGV2aWNlKCZyb290LT5kZXYpOw0KK30NCisN CitzdGF0aWMgc3NpemVfdCANCitzaG93X2JvYXJkaWQoc3RydWN0IGRldmlj ZSAqIGRldiwgY2hhciAqIGJ1Ziwgc2l6ZV90IGNvdW50LCBsb2ZmX3Qgb2Zm KQ0KIHsNCi0gICAgICAgaW50IGVycm9yID0gLUVJTlZBTDsNCisJc3RydWN0 IHN5c19kZXZpY2UgKiBzeXNkZXYgPSBjb250YWluZXJfb2YoZGV2LHN0cnVj dCBzeXNfZGV2aWNlLGRldik7DQorCXJldHVybiBvZmYgPyAwOiANCisJCXNw cmludGYoYnVmLCIldSIsIHN5c2Rldi0+cm9vdCA/IHN5c2Rldi0+cm9vdC0+ aWQgOiAwKTsNCit9DQogDQotICAgICAgIGlmIChkZXYpIHsNCi0gICAgICAg ICAgICAgICBpZiAoIWRldi0+cGFyZW50KQ0KLSAgICAgICAgICAgICAgICAg ICAgICAgZGV2LT5wYXJlbnQgPSAmc3lzdGVtX2J1czsNCi0gICAgICAgICAg ICAgICBlcnJvciA9IGRldmljZV9yZWdpc3RlcihkZXYpOw0KLSAgICAgICB9 DQotICAgICAgIHJldHVybiBlcnJvcjsNCitzdGF0aWMgREVWSUNFX0FUVFIo Ym9hcmRpZCwwNDQ0LHNob3dfYm9hcmRpZCxOVUxMKTsNCisNCisvKioNCisg KglzeXNfcmVnaXN0ZXJfZGV2aWNlIC0gYWRkIGEgc3lzdGVtIGRldmljZSB0 byB0aGUgdHJlZQ0KKyAqCUBzeXNkZXY6CWRldmljZSBpbiBxdWVzdGlvbg0K KyAqDQorICoJVGhlIGhhcmRlc3QgcGFydCBhYm91dCB0aGlzIGlzIGdldHRp bmcgdGhlIGFuY2VzdHJ5IHJpZ2h0Lg0KKyAqCUlmIHRoZSBkZXZpY2UgaGFz IGEgcGFyZW50IC0gc3VwZXIhIFdlIGRvIG5vdGhpbmcuDQorICoJSWYgdGhl IGRldmljZSBkb2Vzbid0LCBidXQgQGRldi0+cm9vdCBpcyBzZXQsIHRoZW4g d2UncmUNCisgKglkZWFsaW5nIHdpdGggYSBOVU1BIGxpa2UgYXJjaGl0ZWN0 dXJlIHdoZXJlIGVhY2ggcm9vdA0KKyAqCWhhcyBhIHN5c3RlbSBwc2V1ZG8t YnVzIHRvIGZvc3RlciB0aGUgZGV2aWNlLg0KKyAqCUlmIG5vdCwgdGhlbiB3 ZSBmYWxsYmFjayB0byBzeXN0ZW1fYnVzIChhdCB0aGUgdG9wIG9mIA0KKyAq CXRoaXMgZmlsZSkuIA0KKyAqDQorICoJT25lIHdheSBvciBhbm90aGVyLCB3 ZSBjYWxsIGRldmljZV9yZWdpc3RlcigpIG9uIGl0IGFuZCANCisgKglhcmUg ZG9uZS4NCisgKg0KKyAqCVRoZSBjYWxsZXIgaXMgYWxzbyByZXNwb25zaWJs ZSBmb3IgaW5pdGlhbGl6aW5nIHRoZSBidXNfaWQgDQorICoJYW5kIG5hbWUg ZmllbGRzIG9mIEBzeXNkZXYtPmRldi4NCisgKi8NCitpbnQgc3lzX3JlZ2lz dGVyX2RldmljZShzdHJ1Y3Qgc3lzX2RldmljZSAqIHN5c2RldikNCit7DQor CWludCBlcnJvciA9IDA7DQorDQorCWlmICghc3lzZGV2KQ0KKwkJcmV0dXJu IC1FSU5WQUw7DQorDQorCWlmIChzeXNkZXYtPmRldi5wYXJlbnQpDQorCQln b3RvIFJlZ2lzdGVyOw0KKw0KKwlpZiAoc3lzZGV2LT5yb290KQ0KKwkJc3lz ZGV2LT5kZXYucGFyZW50ID0gJnN5c2Rldi0+cm9vdC0+c3lzZGV2Ow0KKwll bHNlDQorCQlzeXNkZXYtPmRldi5wYXJlbnQgPSAmc3lzdGVtX2J1czsNCisg UmVnaXN0ZXI6DQorCXByaW50aygiUmVnaXN0ZXJpbmcgc3lzdGVtIGRldmlj ZSAldTolczoldVxuIiwNCisJICAgICAgIHN5c2Rldi0+cm9vdCA/IHN5c2Rl di0+cm9vdC0+aWQgOiAwLCBzeXNkZXYtPm5hbWUsIHN5c2Rldi0+aWQpOw0K Kw0KKwkvKiBjb25zdHJ1Y3QgYnVzX2lkICovDQorCXNucHJpbnRmKHN5c2Rl di0+ZGV2LmJ1c19pZCxCVVNfSURfU0laRSwiJXMldSIsc3lzZGV2LT5uYW1l LHN5c2Rldi0+aWQpOw0KKw0KKwkvKiBtYWtlIHN1cmUgYnVzIHR5cGUgaXMg c2V0ICovDQorCWlmICghc3lzZGV2LT5kZXYuYnVzKQ0KKwkJc3lzZGV2LT5k ZXYuYnVzID0gJnN5c3RlbV9idXNfdHlwZTsNCisNCisJZXJyb3IgPSBkZXZp Y2VfcmVnaXN0ZXIoJnN5c2Rldi0+ZGV2KTsNCisNCisJaWYgKCFlcnJvcikN CisJCWRldmljZV9jcmVhdGVfZmlsZSgmc3lzZGV2LT5kZXYsJmRldl9hdHRy X2JvYXJkaWQpOw0KKwlyZXR1cm4gZXJyb3I7DQogfQ0KIA0KLXZvaWQgdW5y ZWdpc3Rlcl9zeXNfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKiBkZXYpDQordm9p ZCBzeXNfdW5yZWdpc3Rlcl9kZXZpY2Uoc3RydWN0IHN5c19kZXZpY2UgKiBz eXNkZXYpDQogew0KLSAgICAgICBpZiAoZGV2KQ0KLSAgICAgICAgICAgICAg IHB1dF9kZXZpY2UoZGV2KTsNCisJaWYgKHN5c2RldikNCisJCXB1dF9kZXZp Y2UoJnN5c2Rldi0+ZGV2KTsNCiB9DQogDQorc3RydWN0IGJ1c190eXBlIHN5 c3RlbV9idXNfdHlwZSA9IHsNCisJLm5hbWUJCT0gInN5c3RlbSIsDQorfTsN CisNCiBzdGF0aWMgaW50IHN5c19idXNfaW5pdCh2b2lkKQ0KIHsNCi0gICAg ICAgcmV0dXJuIGRldmljZV9yZWdpc3Rlcigmc3lzdGVtX2J1cyk7DQorCWJ1 c19yZWdpc3Rlcigmc3lzdGVtX2J1c190eXBlKTsNCisJcmV0dXJuIGRldmlj ZV9yZWdpc3Rlcigmc3lzdGVtX2J1cyk7DQogfQ0KIA0KIHBvc3Rjb3JlX2lu aXRjYWxsKHN5c19idXNfaW5pdCk7DQotRVhQT1JUX1NZTUJPTChyZWdpc3Rl cl9zeXNfZGV2aWNlKTsNCi1FWFBPUlRfU1lNQk9MKHVucmVnaXN0ZXJfc3lz X2RldmljZSk7DQorRVhQT1JUX1NZTUJPTChzeXN0ZW1fYnVzX3R5cGUpOw0K K0VYUE9SVF9TWU1CT0woc3lzX3JlZ2lzdGVyX2RldmljZSk7DQorRVhQT1JU X1NZTUJPTChzeXNfdW5yZWdpc3Rlcl9kZXZpY2UpOw0KZGlmZiAtTnVyIC14 IEJpdEtlZXBlciAteCBTQ0NTIC14IENoYW5nZVNldCAteCBpZGUgLXggc2Nz aSBsaW51eC0yLjUtdmlyZ2luL2luY2x1ZGUvbGludXgvZGV2aWNlLmggbGlu dXgtMi41L2luY2x1ZGUvbGludXgvZGV2aWNlLmgNCi0tLSBsaW51eC0yLjUt dmlyZ2luL2luY2x1ZGUvbGludXgvZGV2aWNlLmgJV2VkIFNlcCAxOCAwOToz Nzo0MiAyMDAyDQorKysgbGludXgtMi41L2luY2x1ZGUvbGludXgvZGV2aWNl LmgJV2VkIFNlcCAxOCAxMjowMjozMyAyMDAyDQpAQCAtMTMyLDEzICsxMzIs NyBAQA0KIA0KIGV4dGVybiBpbnQgZHJpdmVyX3JlZ2lzdGVyKHN0cnVjdCBk ZXZpY2VfZHJpdmVyICogZHJ2KTsNCiANCi1zdGF0aWMgaW5saW5lIHN0cnVj dCBkZXZpY2VfZHJpdmVyICogZ2V0X2RyaXZlcihzdHJ1Y3QgZGV2aWNlX2Ry aXZlciAqIGRydikNCi17DQotCUJVR19PTighYXRvbWljX3JlYWQoJmRydi0+ cmVmY291bnQpKTsNCi0JYXRvbWljX2luYygmZHJ2LT5yZWZjb3VudCk7DQot CXJldHVybiBkcnY7DQotfQ0KLQ0KK2V4dGVybiBzdHJ1Y3QgZGV2aWNlX2Ry aXZlciAqIGdldF9kcml2ZXIoc3RydWN0IGRldmljZV9kcml2ZXIgKiBkcnYp Ow0KIGV4dGVybiB2b2lkIHB1dF9kcml2ZXIoc3RydWN0IGRldmljZV9kcml2 ZXIgKiBkcnYpOw0KIGV4dGVybiB2b2lkIHJlbW92ZV9kcml2ZXIoc3RydWN0 IGRldmljZV9kcml2ZXIgKiBkcnYpOw0KIA0KQEAgLTM3OCw4ICszNzIsMjcg QEANCiBleHRlcm4gdm9pZCBwdXRfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKiBk ZXYpOw0KIA0KIC8qIGRyaXZlcnMvYmFzZS9zeXMuYyAqLw0KLWV4dGVybiBp bnQgcmVnaXN0ZXJfc3lzX2RldmljZShzdHJ1Y3QgZGV2aWNlICogZGV2KTsN Ci1leHRlcm4gdm9pZCB1bnJlZ2lzdGVyX3N5c19kZXZpY2Uoc3RydWN0IGRl dmljZSAqIGRldik7DQorDQorc3RydWN0IHN5c19yb290IHsNCisJdTMyCQlp ZDsNCisJc3RydWN0IGRldmljZSAJZGV2Ow0KKwlzdHJ1Y3QgZGV2aWNlCXN5 c2RldjsNCit9Ow0KKw0KK3N0cnVjdCBzeXNfZGV2aWNlIHsNCisJY2hhcgkJ KiBuYW1lOw0KKwl1MzIJCWlkOw0KKwlzdHJ1Y3Qgc3lzX3Jvb3QJKiByb290 Ow0KKwlzdHJ1Y3QgZGV2aWNlCWRldjsNCit9Ow0KKw0KK2V4dGVybiBpbnQg c3lzX3JlZ2lzdGVyX3Jvb3Qoc3RydWN0IHN5c19yb290ICopOw0KK2V4dGVy biB2b2lkIHN5c191bnJlZ2lzdGVyX3Jvb3Qoc3RydWN0IHN5c19yb290ICop Ow0KKw0KK2V4dGVybiBpbnQgc3lzX3JlZ2lzdGVyX2RldmljZShzdHJ1Y3Qg c3lzX2RldmljZSAqKTsNCitleHRlcm4gdm9pZCBzeXNfdW5yZWdpc3Rlcl9k ZXZpY2Uoc3RydWN0IHN5c19kZXZpY2UgKik7DQorDQorZXh0ZXJuIHN0cnVj dCBidXNfdHlwZSBzeXN0ZW1fYnVzX3R5cGU7DQogDQogLyogZHJpdmVycy9i YXNlL3BsYXRmb3JtLmMgKi8NCiBleHRlcm4gc3RydWN0IGJ1c190eXBlIHBs YXRmb3JtX2J1czsNCg== --346834433-165056036-1032381605=:968-- - To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/