From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [PATCH 2/4] components: multiple components for a device Date: Fri, 8 Feb 2019 16:23:25 +0100 Message-ID: <20190208152325.GL23159@phenom.ffwll.local> References: <20190207232759.14553-1-daniel.vetter@ffwll.ch> <20190207232759.14553-2-daniel.vetter@ffwll.ch> <20190208102849.qpozfixt77727ojx@shell.armlinux.org.uk> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-ed1-x543.google.com (mail-ed1-x543.google.com [IPv6:2a00:1450:4864:20::543]) by gabe.freedesktop.org (Postfix) with ESMTPS id 00CE26EE1A for ; Fri, 8 Feb 2019 15:23:29 +0000 (UTC) Received: by mail-ed1-x543.google.com with SMTP id y56so3035780edd.11 for ; Fri, 08 Feb 2019 07:23:29 -0800 (PST) Content-Disposition: inline In-Reply-To: <20190208102849.qpozfixt77727ojx@shell.armlinux.org.uk> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Russell King - ARM Linux admin Cc: "Rafael J . Wysocki" , Daniel Vetter , Intel Graphics Development , Takashi Iwai , LKML , DRI Development , Jaroslav Kysela , Rodrigo Vivi , Greg Kroah-Hartman List-Id: dri-devel@lists.freedesktop.org T24gRnJpLCBGZWIgMDgsIDIwMTkgYXQgMTA6Mjg6NDlBTSArMDAwMCwgUnVzc2VsbCBLaW5nIC0g QVJNIExpbnV4IGFkbWluIHdyb3RlOgo+IE9uIEZyaSwgRmViIDA4LCAyMDE5IGF0IDEyOjI3OjU3 QU0gKzAxMDAsIERhbmllbCBWZXR0ZXIgd3JvdGU6Cj4gPiBDb21wb25lbnQgZnJhbWV3b3JrIGlz IGV4dGVuZGVkIHRvIHN1cHBvcnQgbXVsdGlwbGUgY29tcG9uZW50cyBmb3IKPiA+IGEgc3RydWN0 IGRldmljZS4gVGhlc2Ugd2lsbCBiZSBtYXRjaGVkIHdpdGggZGlmZmVyZW50IG1hc3RlcnMgYmFz ZWQgb24KPiA+IGl0cyBzdWIgY29tcG9uZW50IHZhbHVlLgo+ID4gCj4gPiBXZSBhcmUgaW50cm9k dWNpbmcgdGhpcywgYXMgSTkxNSBuZWVkcyB0d28gZGlmZmVyZW50IGNvbXBvbmVudHMKPiA+IHdp dGggZGlmZmVyZW50IHN1YmNvbXBvbmVudCB2YWx1ZSwgd2hpY2ggd2lsbCBiZSBtYXRjaGVkIHRv IHR3bwo+ID4gZGlmZmVyZW50IGNvbXBvbmVudCBtYXN0ZXJzKEF1ZGlvIGFuZCBIRENQKSBiYXNl ZCBvbiB0aGUgc3ViY29tcG9uZW50Cj4gPiB2YWx1ZXMuCj4gPiAKPiA+IHYyOiBBZGQgZG9jdW1l bmF0aW9uLgo+ID4gCj4gPiB2MzogUmViYXNlIG9uIHRvcCBvZiB1cGRhdGVkIGRvY3VtZW5hdGlv bi4KPiA+IAo+ID4gdjQ6IFJldmlldyBmcm9tIFJhZmFlbDoKPiA+IC0gUmVtb3ZlIHJlZHVuZGFu dCAiVGhpcyIgZnJvbSBrZXJuZWxkb2MgKGFsc28gaW4gdGhlIHByZXZpb3VzIHBhdGNoKQo+ID4g LSBTdHJlYW1saW5lIHRoZSBsb2dpYyBpbiBmaW5kX2NvbXBvbmVudCgpIGEgYml0Lgo+ID4gCj4g PiBTaWduZWQtb2ZmLWJ5OiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGZmd2xsLmNoPiAo djEgY29kZSkKPiA+IFNpZ25lZC1vZmYtYnk6IFJhbWFsaW5nYW0gQyA8cmFtYWxpbmdhbS5jQGlu dGVsLmNvbT4gKHYxIGNvbW1pdCBtZXNzYWdlKQo+ID4gQ2M6IFJhbWFsaW5nYW0gQyA8cmFtYWxp bmdhbS5jQGludGVsLmNvbT4KPiA+IENjOiBHcmVnIEtyb2FoLUhhcnRtYW4gPGdyZWdraEBsaW51 eGZvdW5kYXRpb24ub3JnPgo+ID4gQ2M6IFJ1c3NlbGwgS2luZyA8cm1rK2tlcm5lbEBhcm0ubGlu dXgub3JnLnVrPgo+ID4gQ2M6IFJhZmFlbCBKLiBXeXNvY2tpIDxyYWZhZWxAa2VybmVsLm9yZz4K PiA+IENjOiBKYXJvc2xhdiBLeXNlbGEgPHBlcmV4QHBlcmV4LmN6Pgo+ID4gQ2M6IFRha2FzaGkg SXdhaSA8dGl3YWlAc3VzZS5jb20+Cj4gPiBDYzogUm9kcmlnbyBWaXZpIDxyb2RyaWdvLnZpdmlA aW50ZWwuY29tPgo+ID4gQ2M6IEphbmkgTmlrdWxhIDxqYW5pLm5pa3VsYUBsaW51eC5pbnRlbC5j b20+Cj4gPiBTaWduZWQtb2ZmLWJ5OiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGZmd2xs LmNoPgo+ID4gLS0tCj4gPiAgZHJpdmVycy9iYXNlL2NvbXBvbmVudC5jICB8IDE1OCArKysrKysr KysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLQo+ID4gIGluY2x1ZGUvbGludXgvY29tcG9u ZW50LmggfCAgMTAgKystCj4gPiAgMiBmaWxlcyBjaGFuZ2VkLCAxMjkgaW5zZXJ0aW9ucygrKSwg MzkgZGVsZXRpb25zKC0pCj4gPiAKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2Jhc2UvY29tcG9u ZW50LmMgYi9kcml2ZXJzL2Jhc2UvY29tcG9uZW50LmMKPiA+IGluZGV4IDE2MjRjMmE4OTJhNS4u N2RiYzQxY2NjZDU4IDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9iYXNlL2NvbXBvbmVudC5jCj4g PiArKysgYi9kcml2ZXJzL2Jhc2UvY29tcG9uZW50LmMKPiA+IEBAIC00Nyw2ICs0Nyw3IEBAIHN0 cnVjdCBjb21wb25lbnQ7Cj4gPiAgc3RydWN0IGNvbXBvbmVudF9tYXRjaF9hcnJheSB7Cj4gPiAg CXZvaWQgKmRhdGE7Cj4gPiAgCWludCAoKmNvbXBhcmUpKHN0cnVjdCBkZXZpY2UgKiwgdm9pZCAq KTsKPiA+ICsJaW50ICgqY29tcGFyZV90eXBlZCkoc3RydWN0IGRldmljZSAqLCBpbnQsIHZvaWQg Kik7Cj4gPiAgCXZvaWQgKCpyZWxlYXNlKShzdHJ1Y3QgZGV2aWNlICosIHZvaWQgKik7Cj4gPiAg CXN0cnVjdCBjb21wb25lbnQgKmNvbXBvbmVudDsKPiA+ICAJYm9vbCBkdXBsaWNhdGU7Cj4gPiBA QCAtNzQsNiArNzUsNyBAQCBzdHJ1Y3QgY29tcG9uZW50IHsKPiA+ICAJYm9vbCBib3VuZDsKPiA+ ICAKPiA+ICAJY29uc3Qgc3RydWN0IGNvbXBvbmVudF9vcHMgKm9wczsKPiA+ICsJaW50IHN1YmNv bXBvbmVudDsKPiA+ICAJc3RydWN0IGRldmljZSAqZGV2Owo+ID4gIH07Cj4gPiAgCj4gPiBAQCAt MTU4LDcgKzE2MCw3IEBAIHN0YXRpYyBzdHJ1Y3QgbWFzdGVyICpfX21hc3Rlcl9maW5kKHN0cnVj dCBkZXZpY2UgKmRldiwKPiA+ICB9Cj4gPiAgCj4gPiAgc3RhdGljIHN0cnVjdCBjb21wb25lbnQg KmZpbmRfY29tcG9uZW50KHN0cnVjdCBtYXN0ZXIgKm1hc3RlciwKPiA+IC0JaW50ICgqY29tcGFy ZSkoc3RydWN0IGRldmljZSAqLCB2b2lkICopLCB2b2lkICpjb21wYXJlX2RhdGEpCj4gPiArCXN0 cnVjdCBjb21wb25lbnRfbWF0Y2hfYXJyYXkgKm1jKQo+ID4gIHsKPiA+ICAJc3RydWN0IGNvbXBv bmVudCAqYzsKPiA+ICAKPiA+IEBAIC0xNjYsNyArMTY4LDExIEBAIHN0YXRpYyBzdHJ1Y3QgY29t cG9uZW50ICpmaW5kX2NvbXBvbmVudChzdHJ1Y3QgbWFzdGVyICptYXN0ZXIsCj4gPiAgCQlpZiAo Yy0+bWFzdGVyICYmIGMtPm1hc3RlciAhPSBtYXN0ZXIpCj4gPiAgCQkJY29udGludWU7Cj4gPiAg Cj4gPiAtCQlpZiAoY29tcGFyZShjLT5kZXYsIGNvbXBhcmVfZGF0YSkpCj4gPiArCQlpZiAobWMt PmNvbXBhcmUgJiYgbWMtPmNvbXBhcmUoYy0+ZGV2LCBtYy0+ZGF0YSkpCj4gPiArCQkJcmV0dXJu IGM7Cj4gPiArCj4gPiArCQlpZiAobWMtPmNvbXBhcmVfdHlwZWQgJiYKPiA+ICsJCSAgICBtYy0+ Y29tcGFyZV90eXBlZChjLT5kZXYsIGMtPnN1YmNvbXBvbmVudCwgbWMtPmRhdGEpKQo+ID4gIAkJ CXJldHVybiBjOwo+ID4gIAl9Cj4gPiAgCj4gPiBAQCAtMTkyLDcgKzE5OCw3IEBAIHN0YXRpYyBp bnQgZmluZF9jb21wb25lbnRzKHN0cnVjdCBtYXN0ZXIgKm1hc3RlcikKPiA+ICAJCWlmIChtYXRj aC0+Y29tcGFyZVtpXS5jb21wb25lbnQpCj4gPiAgCQkJY29udGludWU7Cj4gPiAgCj4gPiAtCQlj ID0gZmluZF9jb21wb25lbnQobWFzdGVyLCBtYy0+Y29tcGFyZSwgbWMtPmRhdGEpOwo+ID4gKwkJ YyA9IGZpbmRfY29tcG9uZW50KG1hc3RlciwgbWMpOwo+ID4gIAkJaWYgKCFjKSB7Cj4gPiAgCQkJ cmV0ID0gLUVOWElPOwo+ID4gIAkJCWJyZWFrOwo+ID4gQEAgLTMyNywyOSArMzMzLDEyIEBAIHN0 YXRpYyBpbnQgY29tcG9uZW50X21hdGNoX3JlYWxsb2Moc3RydWN0IGRldmljZSAqZGV2LAo+ID4g IAlyZXR1cm4gMDsKPiA+ICB9Cj4gPiAgCj4gPiAtLyoqCj4gPiAtICogY29tcG9uZW50X21hdGNo X2FkZF9yZWxlYXNlIC0gYWRkIGEgY29tcG9uZW50IG1hdGNoIHdpdGggcmVsZWFzZSBjYWxsYmFj awo+ID4gLSAqIEBtYXN0ZXI6IGRldmljZSB3aXRoIHRoZSBhZ2dyZWdhdGUgZHJpdmVyCj4gPiAt ICogQG1hdGNocHRyOiBwb2ludGVyIHRvIHRoZSBsaXN0IG9mIGNvbXBvbmVudCBtYXRjaGVzCj4g PiAtICogQHJlbGVhc2U6IHJlbGVhc2UgZnVuY3Rpb24gZm9yIEBjb21wYXJlX2RhdGEKPiA+IC0g KiBAY29tcGFyZTogY29tcGFyZSBmdW5jdGlvbiB0byBtYXRjaCBhZ2FpbnN0IGFsbCBjb21wb25l bnRzCj4gPiAtICogQGNvbXBhcmVfZGF0YTogb3BhcXVlIHBvaW50ZXIgcGFzc2VkIHRvIHRoZSBA Y29tcGFyZSBmdW5jdGlvbgo+ID4gLSAqCj4gPiAtICogQWRkcyBhIG5ldyBjb21wb25lbnQgbWF0 Y2ggdG8gdGhlIGxpc3Qgc3RvcmVkIGluIEBtYXRjaHB0ciwgd2hpY2ggdGhlIEBtYXN0ZXIKPiA+ IC0gKiBhZ2dyZWdhdGUgZHJpdmVyIG5lZWRzIHRvIGZ1bmN0aW9uLiBUaGUgbGlzdCBvZiBjb21w b25lbnQgbWF0Y2hlcyBwb2ludGVkIHRvCj4gPiAtICogYnkgQG1hdGNocHRyIG11c3QgYmUgaW5p dGlhbGl6ZWQgdG8gTlVMTCBiZWZvcmUgYWRkaW5nIHRoZSBmaXJzdCBtYXRjaC4KPiA+IC0gKgo+ ID4gLSAqIFRoZSBhbGxvY2F0ZWQgbWF0Y2ggbGlzdCBpbiBAbWF0Y2hwdHIgaXMgYXV0b21hdGlj YWxseSByZWxlYXNlZCB1c2luZyBkZXZtCj4gPiAtICogYWN0aW9ucywgd2hlcmUgdXBvbiBAcmVs ZWFzZSB3aWxsIGJlIGNhbGxlZCB0byBmcmVlIGFueSByZWZlcmVuY2VzIGhlbGQgYnkKPiA+IC0g KiBAY29tcGFyZV9kYXRhLCBlLmcuIHdoZW4gQGNvbXBhcmVfZGF0YSBpcyBhICZkZXZpY2Vfbm9k ZSB0aGF0IG11c3QgYmUKPiA+IC0gKiByZWxlYXNlZCB3aXRoIG9mX25vZGVfcHV0KCkuCj4gPiAt ICoKPiA+IC0gKiBTZWUgYWxzbyBjb21wb25lbnRfbWF0Y2hfYWRkKCkuCj4gPiAtICovCj4gPiAt dm9pZCBjb21wb25lbnRfbWF0Y2hfYWRkX3JlbGVhc2Uoc3RydWN0IGRldmljZSAqbWFzdGVyLAo+ ID4gK3N0YXRpYyB2b2lkIF9fY29tcG9uZW50X21hdGNoX2FkZChzdHJ1Y3QgZGV2aWNlICptYXN0 ZXIsCj4gPiAgCXN0cnVjdCBjb21wb25lbnRfbWF0Y2ggKiptYXRjaHB0ciwKPiA+ICAJdm9pZCAo KnJlbGVhc2UpKHN0cnVjdCBkZXZpY2UgKiwgdm9pZCAqKSwKPiA+IC0JaW50ICgqY29tcGFyZSko c3RydWN0IGRldmljZSAqLCB2b2lkICopLCB2b2lkICpjb21wYXJlX2RhdGEpCj4gPiArCWludCAo KmNvbXBhcmUpKHN0cnVjdCBkZXZpY2UgKiwgdm9pZCAqKSwKPiA+ICsJaW50ICgqY29tcGFyZV90 eXBlZCkoc3RydWN0IGRldmljZSAqLCBpbnQsIHZvaWQgKiksCj4gPiArCXZvaWQgKmNvbXBhcmVf ZGF0YSkKPiA+ICB7Cj4gPiAgCXN0cnVjdCBjb21wb25lbnRfbWF0Y2ggKm1hdGNoID0gKm1hdGNo cHRyOwo+ID4gIAo+ID4gQEAgLTM4MSwxMyArMzcwLDY5IEBAIHZvaWQgY29tcG9uZW50X21hdGNo X2FkZF9yZWxlYXNlKHN0cnVjdCBkZXZpY2UgKm1hc3RlciwKPiA+ICAJfQo+ID4gIAo+ID4gIAlt YXRjaC0+Y29tcGFyZVttYXRjaC0+bnVtXS5jb21wYXJlID0gY29tcGFyZTsKPiA+ICsJbWF0Y2gt PmNvbXBhcmVbbWF0Y2gtPm51bV0uY29tcGFyZV90eXBlZCA9IGNvbXBhcmVfdHlwZWQ7Cj4gPiAg CW1hdGNoLT5jb21wYXJlW21hdGNoLT5udW1dLnJlbGVhc2UgPSByZWxlYXNlOwo+ID4gIAltYXRj aC0+Y29tcGFyZVttYXRjaC0+bnVtXS5kYXRhID0gY29tcGFyZV9kYXRhOwo+ID4gIAltYXRjaC0+ Y29tcGFyZVttYXRjaC0+bnVtXS5jb21wb25lbnQgPSBOVUxMOwo+ID4gIAltYXRjaC0+bnVtKys7 Cj4gPiAgfQo+ID4gKwo+ID4gKy8qKgo+ID4gKyAqIGNvbXBvbmVudF9tYXRjaF9hZGRfcmVsZWFz ZSAtIGFkZCBhIGNvbXBvbmVudCBtYXRjaCB3aXRoIHJlbGVhc2UgY2FsbGJhY2sKPiA+ICsgKiBA bWFzdGVyOiBkZXZpY2Ugd2l0aCB0aGUgYWdncmVnYXRlIGRyaXZlcgo+ID4gKyAqIEBtYXRjaHB0 cjogcG9pbnRlciB0byB0aGUgbGlzdCBvZiBjb21wb25lbnQgbWF0Y2hlcwo+ID4gKyAqIEByZWxl YXNlOiByZWxlYXNlIGZ1bmN0aW9uIGZvciBAY29tcGFyZV9kYXRhCj4gPiArICogQGNvbXBhcmU6 IGNvbXBhcmUgZnVuY3Rpb24gdG8gbWF0Y2ggYWdhaW5zdCBhbGwgY29tcG9uZW50cwo+ID4gKyAq IEBjb21wYXJlX2RhdGE6IG9wYXF1ZSBwb2ludGVyIHBhc3NlZCB0byB0aGUgQGNvbXBhcmUgZnVu Y3Rpb24KPiA+ICsgKgo+ID4gKyAqIEFkZHMgYSBuZXcgY29tcG9uZW50IG1hdGNoIHRvIHRoZSBs aXN0IHN0b3JlZCBpbiBAbWF0Y2hwdHIsIHdoaWNoIHRoZSBAbWFzdGVyCj4gPiArICogYWdncmVn YXRlIGRyaXZlciBuZWVkcyB0byBmdW5jdGlvbi4gVGhlIGxpc3Qgb2YgY29tcG9uZW50IG1hdGNo ZXMgcG9pbnRlZCB0bwo+ID4gKyAqIGJ5IEBtYXRjaHB0ciBtdXN0IGJlIGluaXRpYWxpemVkIHRv IE5VTEwgYmVmb3JlIGFkZGluZyB0aGUgZmlyc3QgbWF0Y2guIFRoaXMKPiA+ICsgKiBvbmx5IG1h dGNoZXMgYWdhaW5zdCBjb21wb25lbnRzIGFkZGVkIHdpdGggY29tcG9uZW50X2FkZCgpLgo+ID4g KyAqCj4gPiArICogVGhlIGFsbG9jYXRlZCBtYXRjaCBsaXN0IGluIEBtYXRjaHB0ciBpcyBhdXRv bWF0aWNhbGx5IHJlbGVhc2VkIHVzaW5nIGRldm0KPiA+ICsgKiBhY3Rpb25zLCB3aGVyZSB1cG9u IEByZWxlYXNlIHdpbGwgYmUgY2FsbGVkIHRvIGZyZWUgYW55IHJlZmVyZW5jZXMgaGVsZCBieQo+ ID4gKyAqIEBjb21wYXJlX2RhdGEsIGUuZy4gd2hlbiBAY29tcGFyZV9kYXRhIGlzIGEgJmRldmlj ZV9ub2RlIHRoYXQgbXVzdCBiZQo+ID4gKyAqIHJlbGVhc2VkIHdpdGggb2Zfbm9kZV9wdXQoKS4K PiA+ICsgKgo+ID4gKyAqIFNlZSBhbHNvIGNvbXBvbmVudF9tYXRjaF9hZGQoKSBhbmQgY29tcG9u ZW50X21hdGNoX2FkZF90eXBlZCgpLgo+ID4gKyAqLwo+ID4gK3ZvaWQgY29tcG9uZW50X21hdGNo X2FkZF9yZWxlYXNlKHN0cnVjdCBkZXZpY2UgKm1hc3RlciwKPiA+ICsJc3RydWN0IGNvbXBvbmVu dF9tYXRjaCAqKm1hdGNocHRyLAo+ID4gKwl2b2lkICgqcmVsZWFzZSkoc3RydWN0IGRldmljZSAq LCB2b2lkICopLAo+ID4gKwlpbnQgKCpjb21wYXJlKShzdHJ1Y3QgZGV2aWNlICosIHZvaWQgKiks IHZvaWQgKmNvbXBhcmVfZGF0YSkKPiA+ICt7Cj4gPiArCV9fY29tcG9uZW50X21hdGNoX2FkZCht YXN0ZXIsIG1hdGNocHRyLCByZWxlYXNlLCBjb21wYXJlLCBOVUxMLAo+ID4gKwkJCSAgICAgIGNv bXBhcmVfZGF0YSk7Cj4gPiArfQo+ID4gIEVYUE9SVF9TWU1CT0woY29tcG9uZW50X21hdGNoX2Fk ZF9yZWxlYXNlKTsKPiA+ICAKPiA+ICsvKioKPiA+ICsgKiBjb21wb25lbnRfbWF0Y2hfYWRkX3R5 cGVkIC0gYWRkIGEgY29tcGVudCBtYXRjaCBmb3IgYSB0eXBlZCBjb21wb25lbnQKPiA+ICsgKiBA bWFzdGVyOiBkZXZpY2Ugd2l0aCB0aGUgYWdncmVnYXRlIGRyaXZlcgo+ID4gKyAqIEBtYXRjaHB0 cjogcG9pbnRlciB0byB0aGUgbGlzdCBvZiBjb21wb25lbnQgbWF0Y2hlcwo+ID4gKyAqIEBjb21w YXJlX3R5cGVkOiBjb21wYXJlIGZ1bmN0aW9uIHRvIG1hdGNoIGFnYWluc3QgYWxsIHR5cGVkIGNv bXBvbmVudHMKPiA+ICsgKiBAY29tcGFyZV9kYXRhOiBvcGFxdWUgcG9pbnRlciBwYXNzZWQgdG8g dGhlIEBjb21wYXJlIGZ1bmN0aW9uCj4gPiArICoKPiA+ICsgKiBBZGRzIGEgbmV3IGNvbXBvbmVu dCBtYXRjaCB0byB0aGUgbGlzdCBzdG9yZWQgaW4gQG1hdGNocHRyLCB3aGljaCB0aGUgQG1hc3Rl cgo+ID4gKyAqIGFnZ3JlZ2F0ZSBkcml2ZXIgbmVlZHMgdG8gZnVuY3Rpb24uIFRoZSBsaXN0IG9m IGNvbXBvbmVudCBtYXRjaGVzIHBvaW50ZWQgdG8KPiA+ICsgKiBieSBAbWF0Y2hwdHIgbXVzdCBi ZSBpbml0aWFsaXplZCB0byBOVUxMIGJlZm9yZSBhZGRpbmcgdGhlIGZpcnN0IG1hdGNoLiBUaGlz Cj4gPiArICogb25seSBtYXRjaGVzIGFnYWluc3QgY29tcG9uZW50cyBhZGRlZCB3aXRoIGNvbXBv bmVudF9hZGRfdHlwZWQoKS4KPiA+ICsgKgo+ID4gKyAqIFRoZSBhbGxvY2F0ZWQgbWF0Y2ggbGlz dCBpbiBAbWF0Y2hwdHIgaXMgYXV0b21hdGljYWxseSByZWxlYXNlZCB1c2luZyBkZXZtCj4gPiAr ICogYWN0aW9ucy4KPiA+ICsgKgo+ID4gKyAqIFNlZSBhbHNvIGNvbXBvbmVudF9tYXRjaF9hZGRf cmVsZWFzZSgpIGFuZCBjb21wb25lbnRfbWF0Y2hfYWRkX3R5cGVkKCkuCj4gPiArICovCj4gPiAr dm9pZCBjb21wb25lbnRfbWF0Y2hfYWRkX3R5cGVkKHN0cnVjdCBkZXZpY2UgKm1hc3RlciwKPiA+ ICsJc3RydWN0IGNvbXBvbmVudF9tYXRjaCAqKm1hdGNocHRyLAo+ID4gKwlpbnQgKCpjb21wYXJl X3R5cGVkKShzdHJ1Y3QgZGV2aWNlICosIGludCwgdm9pZCAqKSwgdm9pZCAqY29tcGFyZV9kYXRh KQo+ID4gK3sKPiA+ICsJX19jb21wb25lbnRfbWF0Y2hfYWRkKG1hc3RlciwgbWF0Y2hwdHIsIE5V TEwsIE5VTEwsIGNvbXBhcmVfdHlwZWQsCj4gPiArCQkJICAgICAgY29tcGFyZV9kYXRhKTsKPiAK PiBZb3UncmUgc3RpbGwgcGFzc2luZyBzb21lIGNvbXBhcmUgZGF0YSBpbiB0aGF0IG1heSBuZWVk IHRvIGJlIHJlbGVhc2VkLAo+IGJ1dCB5b3UgYXJlIGV4cGxpY2l0bHkgZGVueWluZyB0aGUgYWJp bGl0eSB0byBwcm92aWRlIGEgcmVsZWFzZQo+IGZ1bmN0aW9uIHBvaW50ZXIgaGVyZS4gIFdoYXQg d2FzIHRoZSByZWFzb25pbmcgYmVoaW5kIHRoYXQgZGVjaXNpb24/Cj4gSWYgc29tZW9uZSB3YW50 ZWQgdG8gdXNlIHRoaXMgd2l0aCBjb21wYXJlX2RhdGEgYmVpbmcgYSBkZXZpY2Vfbm9kZSwKPiBo b3cgc2hvdWxkIHRoYXQgYmUgaGFuZGxlZD8KClNhbWUgd2F5IHdlJ3ZlIGhhbmRsZWQgaXQgb3Jp Z2luYWxseSwgYWRkaW5nIHRoZSBuZXcgdmFyaWFudC4gSSdtIG5vdCBhCmh1Z2UgZmFuIG9mIGFk ZGluZyBhcGkgcHJlZW1wdGl2ZWx5LCB3aXRob3V0IGEgdXNlci4gQW5kIHRoZSBkYXRhIHBvaW50 ZXIKd2UgcGFzcyBhcm91bmQgaW4gaTkxNSBmb3IgbWVpX2hkY3AgYW5kIHNuZC1oZGEtaW50ZWwg ZG9uJ3QgaG9sZApyZWZlcmVuY2VzICh3ZSBkb24ndCBldmVuIHVzZSB0aGVtLCB3ZSBqdXN0IGNv bXBhcmUgdGhlIGRldmljZSBhZ2FpbnN0CmhhcmRjb2RlZCBleHBlY3RhdGlvbnMpLiBTaW5jZSB0 aGUgbmV3IGNvbXBhcmVfdHlwZWQgaXMgZW50aXJlbHkKb3J0aG9nb25hbCB0byB3aGV0aGVyIHlv dSBoYXZlIGEgcmVsZWFzZSBmdW5jdGlvbiBvciBub3QsIHRoYXQgc2hvdWxkIGJlCnNpbXBsZSB0 byBkby4KLURhbmllbAoKPiAKPiBUaGFua3MuCj4gCj4gPiArfQo+ID4gK0VYUE9SVF9TWU1CT0wo Y29tcG9uZW50X21hdGNoX2FkZF90eXBlZCk7Cj4gPiArCj4gPiAgc3RhdGljIHZvaWQgZnJlZV9t YXN0ZXIoc3RydWN0IG1hc3RlciAqbWFzdGVyKQo+ID4gIHsKPiA+ICAJc3RydWN0IGNvbXBvbmVu dF9tYXRjaCAqbWF0Y2ggPSBtYXN0ZXItPm1hdGNoOwo+ID4gQEAgLTYxNiwxOSArNjYxLDggQEAg aW50IGNvbXBvbmVudF9iaW5kX2FsbChzdHJ1Y3QgZGV2aWNlICptYXN0ZXJfZGV2LCB2b2lkICpk YXRhKQo+ID4gIH0KPiA+ICBFWFBPUlRfU1lNQk9MX0dQTChjb21wb25lbnRfYmluZF9hbGwpOwo+ ID4gIAo+ID4gLS8qKgo+ID4gLSAqIGNvbXBvbmVudF9hZGQgLSByZWdpc3RlciBhIGNvbXBvbmVu dAo+ID4gLSAqIEBkZXY6IGNvbXBvbmVudCBkZXZpY2UKPiA+IC0gKiBAb3BzOiBjb21wb25lbnQg Y2FsbGJhY2tzCj4gPiAtICoKPiA+IC0gKiBSZWdpc3RlciBhIG5ldyBjb21wb25lbnQgZm9yIEBk ZXYuIEZ1bmN0aW9ucyBpbiBAb3BzIHdpbGwgYmUgY2FsbGVkIHdoZW4gdGhlCj4gPiAtICogYWdn cmVnYXRlIGRyaXZlciBpcyByZWFkeSB0byBiaW5kIHRoZSBvdmVyYWxsIGRyaXZlciBieSBjYWxs aW5nCj4gPiAtICogY29tcG9uZW50X2JpbmRfYWxsKCkuIFNlZSBhbHNvICZzdHJ1Y3QgY29tcG9u ZW50X29wcy4KPiA+IC0gKgo+ID4gLSAqIFRoZSBjb21wb25lbnQgbmVlZHMgdG8gYmUgdW5yZWdp c3RlcmVkIGF0IGRyaXZlciB1bmxvYWQvZGlzY29ubmVjdCBieSBjYWxsaW5nCj4gPiAtICogY29t cG9uZW50X2RlbCgpLgo+ID4gLSAqLwo+ID4gLWludCBjb21wb25lbnRfYWRkKHN0cnVjdCBkZXZp Y2UgKmRldiwgY29uc3Qgc3RydWN0IGNvbXBvbmVudF9vcHMgKm9wcykKPiA+ICtzdGF0aWMgaW50 IF9fY29tcG9uZW50X2FkZChzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IHN0cnVjdCBjb21wb25l bnRfb3BzICpvcHMsCj4gPiArCWludCBzdWJjb21wb25lbnQpCj4gPiAgewo+ID4gIAlzdHJ1Y3Qg Y29tcG9uZW50ICpjb21wb25lbnQ7Cj4gPiAgCWludCByZXQ7Cj4gPiBAQCAtNjM5LDYgKzY3Myw3 IEBAIGludCBjb21wb25lbnRfYWRkKHN0cnVjdCBkZXZpY2UgKmRldiwgY29uc3Qgc3RydWN0IGNv bXBvbmVudF9vcHMgKm9wcykKPiA+ICAKPiA+ICAJY29tcG9uZW50LT5vcHMgPSBvcHM7Cj4gPiAg CWNvbXBvbmVudC0+ZGV2ID0gZGV2Owo+ID4gKwljb21wb25lbnQtPnN1YmNvbXBvbmVudCA9IHN1 YmNvbXBvbmVudDsKPiA+ICAKPiA+ICAJZGV2X2RiZyhkZXYsICJhZGRpbmcgY29tcG9uZW50IChv cHMgJXBzKVxuIiwgb3BzKTsKPiA+ICAKPiA+IEBAIC02NTcsNiArNjkyLDU1IEBAIGludCBjb21w b25lbnRfYWRkKHN0cnVjdCBkZXZpY2UgKmRldiwgY29uc3Qgc3RydWN0IGNvbXBvbmVudF9vcHMg Km9wcykKPiA+ICAKPiA+ICAJcmV0dXJuIHJldCA8IDAgPyByZXQgOiAwOwo+ID4gIH0KPiA+ICsK PiA+ICsvKioKPiA+ICsgKiBjb21wb25lbnRfYWRkX3R5cGVkIC0gcmVnaXN0ZXIgYSBjb21wb25l bnQKPiA+ICsgKiBAZGV2OiBjb21wb25lbnQgZGV2aWNlCj4gPiArICogQG9wczogY29tcG9uZW50 IGNhbGxiYWNrcwo+ID4gKyAqIEBzdWJjb21wb25lbnQ6IG5vbnplcm8gaWRlbnRpZmllciBmb3Ig c3ViY29tcG9uZW50cwo+ID4gKyAqCj4gPiArICogUmVnaXN0ZXIgYSBuZXcgY29tcG9uZW50IGZv ciBAZGV2LiBGdW5jdGlvbnMgaW4gQG9wcyB3aWxsIGJlIGNhbGwgd2hlbiB0aGUKPiA+ICsgKiBh Z2dyZWdhdGUgZHJpdmVyIGlzIHJlYWR5IHRvIGJpbmQgdGhlIG92ZXJhbGwgZHJpdmVyIGJ5IGNh bGxpbmcKPiA+ICsgKiBjb21wb25lbnRfYmluZF9hbGwoKS4gU2VlIGFsc28gJnN0cnVjdCBjb21w b25lbnRfb3BzLgo+ID4gKyAqCj4gPiArICogQHN1YmNvbXBvbmVudCBtdXN0IGJlIG5vbnplcm8g YW5kIGlzIHVzZWQgdG8gZGlmZmVyZW50aWF0ZSBiZXR3ZWVuIG11bHRpcGxlCj4gPiArICogY29t cG9uZW50cyByZWdpc3RlcmQgb24gdGhlIHNhbWUgZGV2aWNlIEBkZXYuIFRoZXNlIGNvbXBvbmVu dHMgYXJlIG1hdGNoCj4gPiArICogdXNpbmcgY29tcG9uZW50X21hdGNoX2FkZF90eXBlZCgpLgo+ ID4gKyAqCj4gPiArICogVGhlIGNvbXBvbmVudCBuZWVkcyB0byBiZSB1bnJlZ2lzdGVyZWQgYXQg ZHJpdmVyIHVubG9hZC9kaXNjb25uZWN0IGJ5Cj4gPiArICogY2FsbGluZyBjb21wb25lbnRfZGVs KCkuCj4gPiArICoKPiA+ICsgKiBTZWUgYWxzbyBjb21wb25lbnRfYWRkKCkuCj4gPiArICovCj4g PiAraW50IGNvbXBvbmVudF9hZGRfdHlwZWQoc3RydWN0IGRldmljZSAqZGV2LCBjb25zdCBzdHJ1 Y3QgY29tcG9uZW50X29wcyAqb3BzLAo+ID4gKwlpbnQgc3ViY29tcG9uZW50KQo+ID4gK3sKPiA+ ICsJaWYgKFdBUk5fT04oc3ViY29tcG9uZW50ID09IDApKQo+ID4gKwkJcmV0dXJuIC1FSU5WQUw7 Cj4gPiArCj4gPiArCXJldHVybiBfX2NvbXBvbmVudF9hZGQoZGV2LCBvcHMsIHN1YmNvbXBvbmVu dCk7Cj4gPiArfQo+ID4gK0VYUE9SVF9TWU1CT0xfR1BMKGNvbXBvbmVudF9hZGRfdHlwZWQpOwo+ ID4gKwo+ID4gKy8qKgo+ID4gKyAqIGNvbXBvbmVudF9hZGQgLSByZWdpc3RlciBhIGNvbXBvbmVu dAo+ID4gKyAqIEBkZXY6IGNvbXBvbmVudCBkZXZpY2UKPiA+ICsgKiBAb3BzOiBjb21wb25lbnQg Y2FsbGJhY2tzCj4gPiArICoKPiA+ICsgKiBSZWdpc3RlciBhIG5ldyBjb21wb25lbnQgZm9yIEBk ZXYuIEZ1bmN0aW9ucyBpbiBAb3BzIHdpbGwgYmUgY2FsbGVkIHdoZW4gdGhlCj4gPiArICogYWdn cmVnYXRlIGRyaXZlciBpcyByZWFkeSB0byBiaW5kIHRoZSBvdmVyYWxsIGRyaXZlciBieSBjYWxs aW5nCj4gPiArICogY29tcG9uZW50X2JpbmRfYWxsKCkuIFNlZSBhbHNvICZzdHJ1Y3QgY29tcG9u ZW50X29wcy4KPiA+ICsgKgo+ID4gKyAqIFRoZSBjb21wb25lbnQgbmVlZHMgdG8gYmUgdW5yZWdp c3RlcmVkIGF0IGRyaXZlciB1bmxvYWQvZGlzY29ubmVjdCBieQo+ID4gKyAqIGNhbGxpbmcgY29t cG9uZW50X2RlbCgpLgo+ID4gKyAqCj4gPiArICogU2VlIGFsc28gY29tcG9uZW50X2FkZF90eXBl ZCgpIGZvciBhIHZhcmlhbnQgdGhhdCBhbGxvd3MgbXVsdGlwbGVkIGRpZmZlcmVudAo+ID4gKyAq IGNvbXBvbmVudHMgb24gdGhlIHNhbWUgZGV2aWNlLgo+ID4gKyAqLwo+ID4gK2ludCBjb21wb25l bnRfYWRkKHN0cnVjdCBkZXZpY2UgKmRldiwgY29uc3Qgc3RydWN0IGNvbXBvbmVudF9vcHMgKm9w cykKPiA+ICt7Cj4gPiArCXJldHVybiBfX2NvbXBvbmVudF9hZGQoZGV2LCBvcHMsIDApOwo+ID4g K30KPiA+ICBFWFBPUlRfU1lNQk9MX0dQTChjb21wb25lbnRfYWRkKTsKPiA+ICAKPiA+ICAvKioK PiA+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2NvbXBvbmVudC5oIGIvaW5jbHVkZS9saW51 eC9jb21wb25lbnQuaAo+ID4gaW5kZXggODNkYTI1YmRmNTljLi4zMGJjYzdlNTkwZWIgMTAwNjQ0 Cj4gPiAtLS0gYS9pbmNsdWRlL2xpbnV4L2NvbXBvbmVudC5oCj4gPiArKysgYi9pbmNsdWRlL2xp bnV4L2NvbXBvbmVudC5oCj4gPiBAQCAtMzQsNiArMzQsOCBAQCBzdHJ1Y3QgY29tcG9uZW50X29w cyB7Cj4gPiAgfTsKPiA+ICAKPiA+ICBpbnQgY29tcG9uZW50X2FkZChzdHJ1Y3QgZGV2aWNlICos IGNvbnN0IHN0cnVjdCBjb21wb25lbnRfb3BzICopOwo+ID4gK2ludCBjb21wb25lbnRfYWRkX3R5 cGVkKHN0cnVjdCBkZXZpY2UgKmRldiwgY29uc3Qgc3RydWN0IGNvbXBvbmVudF9vcHMgKm9wcywK PiA+ICsJaW50IHN1YmNvbXBvbmVudCk7Cj4gPiAgdm9pZCBjb21wb25lbnRfZGVsKHN0cnVjdCBk ZXZpY2UgKiwgY29uc3Qgc3RydWN0IGNvbXBvbmVudF9vcHMgKik7Cj4gPiAgCj4gPiAgaW50IGNv bXBvbmVudF9iaW5kX2FsbChzdHJ1Y3QgZGV2aWNlICptYXN0ZXIsIHZvaWQgKm1hc3Rlcl9kYXRh KTsKPiA+IEBAIC05MSw2ICs5Myw5IEBAIHZvaWQgY29tcG9uZW50X21hdGNoX2FkZF9yZWxlYXNl KHN0cnVjdCBkZXZpY2UgKm1hc3RlciwKPiA+ICAJc3RydWN0IGNvbXBvbmVudF9tYXRjaCAqKm1h dGNocHRyLAo+ID4gIAl2b2lkICgqcmVsZWFzZSkoc3RydWN0IGRldmljZSAqLCB2b2lkICopLAo+ ID4gIAlpbnQgKCpjb21wYXJlKShzdHJ1Y3QgZGV2aWNlICosIHZvaWQgKiksIHZvaWQgKmNvbXBh cmVfZGF0YSk7Cj4gPiArdm9pZCBjb21wb25lbnRfbWF0Y2hfYWRkX3R5cGVkKHN0cnVjdCBkZXZp Y2UgKm1hc3RlciwKPiA+ICsJc3RydWN0IGNvbXBvbmVudF9tYXRjaCAqKm1hdGNocHRyLAo+ID4g KwlpbnQgKCpjb21wYXJlX3R5cGVkKShzdHJ1Y3QgZGV2aWNlICosIGludCwgdm9pZCAqKSwgdm9p ZCAqY29tcGFyZV9kYXRhKTsKPiA+ICAKPiA+ICAvKioKPiA+ICAgKiBjb21wb25lbnRfbWF0Y2hf YWRkIC0gYWRkIGEgY29tcGVudCBtYXRjaAo+ID4gQEAgLTEwMSwxMiArMTA2LDEzIEBAIHZvaWQg Y29tcG9uZW50X21hdGNoX2FkZF9yZWxlYXNlKHN0cnVjdCBkZXZpY2UgKm1hc3RlciwKPiA+ICAg Kgo+ID4gICAqIEFkZHMgYSBuZXcgY29tcG9uZW50IG1hdGNoIHRvIHRoZSBsaXN0IHN0b3JlZCBp biBAbWF0Y2hwdHIsIHdoaWNoIHRoZSBAbWFzdGVyCj4gPiAgICogYWdncmVnYXRlIGRyaXZlciBu ZWVkcyB0byBmdW5jdGlvbi4gVGhlIGxpc3Qgb2YgY29tcG9uZW50IG1hdGNoZXMgcG9pbnRlZCB0 bwo+ID4gLSAqIGJ5IEBtYXRjaHB0ciBtdXN0IGJlIGluaXRpYWxpemVkIHRvIE5VTEwgYmVmb3Jl IGFkZGluZyB0aGUgZmlyc3QgbWF0Y2guCj4gPiArICogYnkgQG1hdGNocHRyIG11c3QgYmUgaW5p dGlhbGl6ZWQgdG8gTlVMTCBiZWZvcmUgYWRkaW5nIHRoZSBmaXJzdCBtYXRjaC4gVGhpcwo+ID4g KyAqIG9ubHkgbWF0Y2hlcyBhZ2FpbnN0IGNvbXBvbmVudHMgYWRkZWQgd2l0aCBjb21wb25lbnRf YWRkKCkuCj4gPiAgICoKPiA+ICAgKiBUaGUgYWxsb2NhdGVkIG1hdGNoIGxpc3QgaW4gQG1hdGNo cHRyIGlzIGF1dG9tYXRpY2FsbHkgcmVsZWFzZWQgdXNpbmcgZGV2bQo+ID4gICAqIGFjdGlvbnMu Cj4gPiAgICoKPiA+IC0gKiBTZWUgYWxzbyBjb21wb25lbnRfbWF0Y2hfYWRkX3JlbGVhc2UoKS4K PiA+ICsgKiBTZWUgYWxzbyBjb21wb25lbnRfbWF0Y2hfYWRkX3JlbGVhc2UoKSBhbmQgY29tcG9u ZW50X21hdGNoX2FkZF90eXBlZCgpLgo+ID4gICAqLwo+ID4gIHN0YXRpYyBpbmxpbmUgdm9pZCBj b21wb25lbnRfbWF0Y2hfYWRkKHN0cnVjdCBkZXZpY2UgKm1hc3RlciwKPiA+ICAJc3RydWN0IGNv bXBvbmVudF9tYXRjaCAqKm1hdGNocHRyLAo+ID4gLS0gCj4gPiAyLjIwLjEKPiA+IAo+ID4gCj4g Cj4gLS0gCj4gUk1LJ3MgUGF0Y2ggc3lzdGVtOiBodHRwczovL3d3dy5hcm1saW51eC5vcmcudWsv ZGV2ZWxvcGVyL3BhdGNoZXMvCj4gRlRUQyBicm9hZGJhbmQgZm9yIDAuOG1pbGUgbGluZSBpbiBz dWJ1cmJpYTogc3luYyBhdCAxMi4xTWJwcyBkb3duIDYyMmticHMgdXAKPiBBY2NvcmRpbmcgdG8g c3BlZWR0ZXN0Lm5ldDogMTEuOU1icHMgZG93biA1MDBrYnBzIHVwCgotLSAKRGFuaWVsIFZldHRl cgpTb2Z0d2FyZSBFbmdpbmVlciwgSW50ZWwgQ29ycG9yYXRpb24KaHR0cDovL2Jsb2cuZmZ3bGwu Y2gKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRl dmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8v bGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.3 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,USER_AGENT_MUTT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5DBBCC169C4 for ; Fri, 8 Feb 2019 15:23:34 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 00F702146E for ; Fri, 8 Feb 2019 15:23:34 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=ffwll.ch header.i=@ffwll.ch header.b="kj7WStdt" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727950AbfBHPXc (ORCPT ); Fri, 8 Feb 2019 10:23:32 -0500 Received: from mail-ed1-f67.google.com ([209.85.208.67]:42350 "EHLO mail-ed1-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727479AbfBHPXb (ORCPT ); Fri, 8 Feb 2019 10:23:31 -0500 Received: by mail-ed1-f67.google.com with SMTP id r15so3043595eds.9 for ; Fri, 08 Feb 2019 07:23:29 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=sender:date:from:to:cc:subject:message-id:mail-followup-to :references:mime-version:content-disposition:in-reply-to:user-agent; bh=EHTr0RB9ZdzNKt00ELomTTS3xhMSfRUrzRC2DiCFv5k=; b=kj7WStdtoN8HuOdjFDr7VU8uWudfaY7/4NXNAuadJITPvLXNod94TZNkullMXHeGiy xKuZXr5JfduA/l1hUpN7eccceAFvFmM7Jd/BD/jCEKawY+Ywu7cB7yhfRT3Et+mX4ndF rIVYcekK4YueMhwZLA3srZT0Dc17G2NFHCQ80= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:from:to:cc:subject:message-id :mail-followup-to:references:mime-version:content-disposition :in-reply-to:user-agent; bh=EHTr0RB9ZdzNKt00ELomTTS3xhMSfRUrzRC2DiCFv5k=; b=qfA4oiD1CWaXZCvDMyD0QcSGrgQrceLKVQQSGHr8aIOF0dQvNgSgQGUF6kuerB04vG Ypeo3N3/lwXphH9fIqvD7CWW3e+nDVdHp4UN0A+ZJOhOna5Pzs7+0Ugq0MK8NPS8CMRP fg9PB298wi4GFuvUaf6lbK+qgY1sugGMVVNPcnzN4R+cDia4AKhoBmmIUTYYGLcsY6J3 cOstdx/I3oWhosCWQoDfrrFc69N/JTIO6Lb9Rn09Ov3X+CxK9NnSmXdRfXZJvYJZWkXI BRzX/GKziVhW6eQAJKryDPeyjZHqm8UquDEDtqCxOsn2TZxoWhw0D5dEeW0s+Bt4BrwU n9Qg== X-Gm-Message-State: AHQUAuY7+vwt1zh2z1Bah7dTV+Irqp4bxH+dhxBGCs3a9au6zzjsKEjw mZvkQWXhB2x8/agsWmNyplR9zQ== X-Google-Smtp-Source: AHgI3IZrdXWitiPZ3fEikVXBIQDkDbyyQgudXBltyqEjbrviN8lrM9UYbQvsbAqb7YrvWIoZLPiL4A== X-Received: by 2002:a17:906:64d:: with SMTP id t13mr15865843ejb.53.1549639408458; Fri, 08 Feb 2019 07:23:28 -0800 (PST) Received: from phenom.ffwll.local ([2a02:168:569e:0:3106:d637:d723:e855]) by smtp.gmail.com with ESMTPSA id s46sm697227edd.9.2019.02.08.07.23.26 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Fri, 08 Feb 2019 07:23:27 -0800 (PST) Date: Fri, 8 Feb 2019 16:23:25 +0100 From: Daniel Vetter To: Russell King - ARM Linux admin Cc: Daniel Vetter , DRI Development , Intel Graphics Development , LKML , Ramalingam C , Greg Kroah-Hartman , "Rafael J . Wysocki" , Jaroslav Kysela , Takashi Iwai , Rodrigo Vivi , Jani Nikula Subject: Re: [PATCH 2/4] components: multiple components for a device Message-ID: <20190208152325.GL23159@phenom.ffwll.local> Mail-Followup-To: Russell King - ARM Linux admin , DRI Development , Intel Graphics Development , LKML , Ramalingam C , Greg Kroah-Hartman , "Rafael J . Wysocki" , Jaroslav Kysela , Takashi Iwai , Rodrigo Vivi , Jani Nikula References: <20190207232759.14553-1-daniel.vetter@ffwll.ch> <20190207232759.14553-2-daniel.vetter@ffwll.ch> <20190208102849.qpozfixt77727ojx@shell.armlinux.org.uk> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20190208102849.qpozfixt77727ojx@shell.armlinux.org.uk> X-Operating-System: Linux phenom 4.19.0-1-amd64 User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Fri, Feb 08, 2019 at 10:28:49AM +0000, Russell King - ARM Linux admin wrote: > On Fri, Feb 08, 2019 at 12:27:57AM +0100, Daniel Vetter wrote: > > Component framework is extended to support multiple components for > > a struct device. These will be matched with different masters based on > > its sub component value. > > > > We are introducing this, as I915 needs two different components > > with different subcomponent value, which will be matched to two > > different component masters(Audio and HDCP) based on the subcomponent > > values. > > > > v2: Add documenation. > > > > v3: Rebase on top of updated documenation. > > > > v4: Review from Rafael: > > - Remove redundant "This" from kerneldoc (also in the previous patch) > > - Streamline the logic in find_component() a bit. > > > > Signed-off-by: Daniel Vetter (v1 code) > > Signed-off-by: Ramalingam C (v1 commit message) > > Cc: Ramalingam C > > Cc: Greg Kroah-Hartman > > Cc: Russell King > > Cc: Rafael J. Wysocki > > Cc: Jaroslav Kysela > > Cc: Takashi Iwai > > Cc: Rodrigo Vivi > > Cc: Jani Nikula > > Signed-off-by: Daniel Vetter > > --- > > drivers/base/component.c | 158 +++++++++++++++++++++++++++++--------- > > include/linux/component.h | 10 ++- > > 2 files changed, 129 insertions(+), 39 deletions(-) > > > > diff --git a/drivers/base/component.c b/drivers/base/component.c > > index 1624c2a892a5..7dbc41cccd58 100644 > > --- a/drivers/base/component.c > > +++ b/drivers/base/component.c > > @@ -47,6 +47,7 @@ struct component; > > struct component_match_array { > > void *data; > > int (*compare)(struct device *, void *); > > + int (*compare_typed)(struct device *, int, void *); > > void (*release)(struct device *, void *); > > struct component *component; > > bool duplicate; > > @@ -74,6 +75,7 @@ struct component { > > bool bound; > > > > const struct component_ops *ops; > > + int subcomponent; > > struct device *dev; > > }; > > > > @@ -158,7 +160,7 @@ static struct master *__master_find(struct device *dev, > > } > > > > static struct component *find_component(struct master *master, > > - int (*compare)(struct device *, void *), void *compare_data) > > + struct component_match_array *mc) > > { > > struct component *c; > > > > @@ -166,7 +168,11 @@ static struct component *find_component(struct master *master, > > if (c->master && c->master != master) > > continue; > > > > - if (compare(c->dev, compare_data)) > > + if (mc->compare && mc->compare(c->dev, mc->data)) > > + return c; > > + > > + if (mc->compare_typed && > > + mc->compare_typed(c->dev, c->subcomponent, mc->data)) > > return c; > > } > > > > @@ -192,7 +198,7 @@ static int find_components(struct master *master) > > if (match->compare[i].component) > > continue; > > > > - c = find_component(master, mc->compare, mc->data); > > + c = find_component(master, mc); > > if (!c) { > > ret = -ENXIO; > > break; > > @@ -327,29 +333,12 @@ static int component_match_realloc(struct device *dev, > > return 0; > > } > > > > -/** > > - * component_match_add_release - add a component match with release callback > > - * @master: device with the aggregate driver > > - * @matchptr: pointer to the list of component matches > > - * @release: release function for @compare_data > > - * @compare: compare function to match against all components > > - * @compare_data: opaque pointer passed to the @compare function > > - * > > - * Adds a new component match to the list stored in @matchptr, which the @master > > - * aggregate driver needs to function. The list of component matches pointed to > > - * by @matchptr must be initialized to NULL before adding the first match. > > - * > > - * The allocated match list in @matchptr is automatically released using devm > > - * actions, where upon @release will be called to free any references held by > > - * @compare_data, e.g. when @compare_data is a &device_node that must be > > - * released with of_node_put(). > > - * > > - * See also component_match_add(). > > - */ > > -void component_match_add_release(struct device *master, > > +static void __component_match_add(struct device *master, > > struct component_match **matchptr, > > void (*release)(struct device *, void *), > > - int (*compare)(struct device *, void *), void *compare_data) > > + int (*compare)(struct device *, void *), > > + int (*compare_typed)(struct device *, int, void *), > > + void *compare_data) > > { > > struct component_match *match = *matchptr; > > > > @@ -381,13 +370,69 @@ void component_match_add_release(struct device *master, > > } > > > > match->compare[match->num].compare = compare; > > + match->compare[match->num].compare_typed = compare_typed; > > match->compare[match->num].release = release; > > match->compare[match->num].data = compare_data; > > match->compare[match->num].component = NULL; > > match->num++; > > } > > + > > +/** > > + * component_match_add_release - add a component match with release callback > > + * @master: device with the aggregate driver > > + * @matchptr: pointer to the list of component matches > > + * @release: release function for @compare_data > > + * @compare: compare function to match against all components > > + * @compare_data: opaque pointer passed to the @compare function > > + * > > + * Adds a new component match to the list stored in @matchptr, which the @master > > + * aggregate driver needs to function. The list of component matches pointed to > > + * by @matchptr must be initialized to NULL before adding the first match. This > > + * only matches against components added with component_add(). > > + * > > + * The allocated match list in @matchptr is automatically released using devm > > + * actions, where upon @release will be called to free any references held by > > + * @compare_data, e.g. when @compare_data is a &device_node that must be > > + * released with of_node_put(). > > + * > > + * See also component_match_add() and component_match_add_typed(). > > + */ > > +void component_match_add_release(struct device *master, > > + struct component_match **matchptr, > > + void (*release)(struct device *, void *), > > + int (*compare)(struct device *, void *), void *compare_data) > > +{ > > + __component_match_add(master, matchptr, release, compare, NULL, > > + compare_data); > > +} > > EXPORT_SYMBOL(component_match_add_release); > > > > +/** > > + * component_match_add_typed - add a compent match for a typed component > > + * @master: device with the aggregate driver > > + * @matchptr: pointer to the list of component matches > > + * @compare_typed: compare function to match against all typed components > > + * @compare_data: opaque pointer passed to the @compare function > > + * > > + * Adds a new component match to the list stored in @matchptr, which the @master > > + * aggregate driver needs to function. The list of component matches pointed to > > + * by @matchptr must be initialized to NULL before adding the first match. This > > + * only matches against components added with component_add_typed(). > > + * > > + * The allocated match list in @matchptr is automatically released using devm > > + * actions. > > + * > > + * See also component_match_add_release() and component_match_add_typed(). > > + */ > > +void component_match_add_typed(struct device *master, > > + struct component_match **matchptr, > > + int (*compare_typed)(struct device *, int, void *), void *compare_data) > > +{ > > + __component_match_add(master, matchptr, NULL, NULL, compare_typed, > > + compare_data); > > You're still passing some compare data in that may need to be released, > but you are explicitly denying the ability to provide a release > function pointer here. What was the reasoning behind that decision? > If someone wanted to use this with compare_data being a device_node, > how should that be handled? Same way we've handled it originally, adding the new variant. I'm not a huge fan of adding api preemptively, without a user. And the data pointer we pass around in i915 for mei_hdcp and snd-hda-intel don't hold references (we don't even use them, we just compare the device against hardcoded expectations). Since the new compare_typed is entirely orthogonal to whether you have a release function or not, that should be simple to do. -Daniel > > Thanks. > > > +} > > +EXPORT_SYMBOL(component_match_add_typed); > > + > > static void free_master(struct master *master) > > { > > struct component_match *match = master->match; > > @@ -616,19 +661,8 @@ int component_bind_all(struct device *master_dev, void *data) > > } > > EXPORT_SYMBOL_GPL(component_bind_all); > > > > -/** > > - * component_add - register a component > > - * @dev: component device > > - * @ops: component callbacks > > - * > > - * Register a new component for @dev. Functions in @ops will be called when the > > - * aggregate driver is ready to bind the overall driver by calling > > - * component_bind_all(). See also &struct component_ops. > > - * > > - * The component needs to be unregistered at driver unload/disconnect by calling > > - * component_del(). > > - */ > > -int component_add(struct device *dev, const struct component_ops *ops) > > +static int __component_add(struct device *dev, const struct component_ops *ops, > > + int subcomponent) > > { > > struct component *component; > > int ret; > > @@ -639,6 +673,7 @@ int component_add(struct device *dev, const struct component_ops *ops) > > > > component->ops = ops; > > component->dev = dev; > > + component->subcomponent = subcomponent; > > > > dev_dbg(dev, "adding component (ops %ps)\n", ops); > > > > @@ -657,6 +692,55 @@ int component_add(struct device *dev, const struct component_ops *ops) > > > > return ret < 0 ? ret : 0; > > } > > + > > +/** > > + * component_add_typed - register a component > > + * @dev: component device > > + * @ops: component callbacks > > + * @subcomponent: nonzero identifier for subcomponents > > + * > > + * Register a new component for @dev. Functions in @ops will be call when the > > + * aggregate driver is ready to bind the overall driver by calling > > + * component_bind_all(). See also &struct component_ops. > > + * > > + * @subcomponent must be nonzero and is used to differentiate between multiple > > + * components registerd on the same device @dev. These components are match > > + * using component_match_add_typed(). > > + * > > + * The component needs to be unregistered at driver unload/disconnect by > > + * calling component_del(). > > + * > > + * See also component_add(). > > + */ > > +int component_add_typed(struct device *dev, const struct component_ops *ops, > > + int subcomponent) > > +{ > > + if (WARN_ON(subcomponent == 0)) > > + return -EINVAL; > > + > > + return __component_add(dev, ops, subcomponent); > > +} > > +EXPORT_SYMBOL_GPL(component_add_typed); > > + > > +/** > > + * component_add - register a component > > + * @dev: component device > > + * @ops: component callbacks > > + * > > + * Register a new component for @dev. Functions in @ops will be called when the > > + * aggregate driver is ready to bind the overall driver by calling > > + * component_bind_all(). See also &struct component_ops. > > + * > > + * The component needs to be unregistered at driver unload/disconnect by > > + * calling component_del(). > > + * > > + * See also component_add_typed() for a variant that allows multipled different > > + * components on the same device. > > + */ > > +int component_add(struct device *dev, const struct component_ops *ops) > > +{ > > + return __component_add(dev, ops, 0); > > +} > > EXPORT_SYMBOL_GPL(component_add); > > > > /** > > diff --git a/include/linux/component.h b/include/linux/component.h > > index 83da25bdf59c..30bcc7e590eb 100644 > > --- a/include/linux/component.h > > +++ b/include/linux/component.h > > @@ -34,6 +34,8 @@ struct component_ops { > > }; > > > > int component_add(struct device *, const struct component_ops *); > > +int component_add_typed(struct device *dev, const struct component_ops *ops, > > + int subcomponent); > > void component_del(struct device *, const struct component_ops *); > > > > int component_bind_all(struct device *master, void *master_data); > > @@ -91,6 +93,9 @@ void component_match_add_release(struct device *master, > > struct component_match **matchptr, > > void (*release)(struct device *, void *), > > int (*compare)(struct device *, void *), void *compare_data); > > +void component_match_add_typed(struct device *master, > > + struct component_match **matchptr, > > + int (*compare_typed)(struct device *, int, void *), void *compare_data); > > > > /** > > * component_match_add - add a compent match > > @@ -101,12 +106,13 @@ void component_match_add_release(struct device *master, > > * > > * Adds a new component match to the list stored in @matchptr, which the @master > > * aggregate driver needs to function. The list of component matches pointed to > > - * by @matchptr must be initialized to NULL before adding the first match. > > + * by @matchptr must be initialized to NULL before adding the first match. This > > + * only matches against components added with component_add(). > > * > > * The allocated match list in @matchptr is automatically released using devm > > * actions. > > * > > - * See also component_match_add_release(). > > + * See also component_match_add_release() and component_match_add_typed(). > > */ > > static inline void component_match_add(struct device *master, > > struct component_match **matchptr, > > -- > > 2.20.1 > > > > > > -- > RMK's Patch system: https://www.armlinux.org.uk/developer/patches/ > FTTC broadband for 0.8mile line in suburbia: sync at 12.1Mbps down 622kbps up > According to speedtest.net: 11.9Mbps down 500kbps up -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch