From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [PATCH 2/2] components: multiple components for a device Date: Mon, 4 Feb 2019 17:00:25 +0100 Message-ID: <20190204160025.GV3271@phenom.ffwll.local> References: <1548917996-28081-2-git-send-email-ramalingam.c@intel.com> <20190131144640.17896-1-daniel.vetter@ffwll.ch> <20190131144640.17896-2-daniel.vetter@ffwll.ch> 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 BF3126E55D for ; Mon, 4 Feb 2019 16:00:30 +0000 (UTC) Received: by mail-ed1-x543.google.com with SMTP id p6so337756eds.0 for ; Mon, 04 Feb 2019 08:00:30 -0800 (PST) Content-Disposition: inline In-Reply-To: <20190131144640.17896-2-daniel.vetter@ffwll.ch> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: DRI Development Cc: "Rafael J . Wysocki" , Daniel Vetter , Takashi Iwai , LKML , Jaroslav Kysela , Rodrigo Vivi , Greg Kroah-Hartman , Russell King List-Id: dri-devel@lists.freedesktop.org T24gVGh1LCBKYW4gMzEsIDIwMTkgYXQgMDM6NDY6NDBQTSArMDEwMCwgRGFuaWVsIFZldHRlciB3 cm90ZToKPiBDb21wb25lbnQgZnJhbWV3b3JrIGlzIGV4dGVuZGVkIHRvIHN1cHBvcnQgbXVsdGlw bGUgY29tcG9uZW50cyBmb3IKPiBhIHN0cnVjdCBkZXZpY2UuIFRoZXNlIHdpbGwgYmUgbWF0Y2hl ZCB3aXRoIGRpZmZlcmVudCBtYXN0ZXJzIGJhc2VkIG9uCj4gaXRzIHN1YiBjb21wb25lbnQgdmFs dWUuCj4gCj4gV2UgYXJlIGludHJvZHVjaW5nIHRoaXMsIGFzIEk5MTUgbmVlZHMgdHdvIGRpZmZl cmVudCBjb21wb25lbnRzCj4gd2l0aCBkaWZmZXJlbnQgc3ViY29tcG9uZW50IHZhbHVlLCB3aGlj aCB3aWxsIGJlIG1hdGNoZWQgdG8gdHdvCj4gZGlmZmVyZW50IGNvbXBvbmVudCBtYXN0ZXJzKEF1 ZGlvIGFuZCBIRENQKSBiYXNlZCBvbiB0aGUgc3ViY29tcG9uZW50Cj4gdmFsdWVzLgo+IAo+IHYy OiBBZGQgZG9jdW1lbmF0aW9uLgo+IAo+IFNpZ25lZC1vZmYtYnk6IERhbmllbCBWZXR0ZXIgPGRh bmllbC52ZXR0ZXJAZmZ3bGwuY2g+ICh2MSBjb2RlKQo+IFNpZ25lZC1vZmYtYnk6IFJhbWFsaW5n YW0gQyA8cmFtYWxpbmdhbS5jQGludGVsLmNvbT4gKHYxIGNvbW1pdCBtZXNzYWdlKQo+IENjOiBS YW1hbGluZ2FtIEMgPHJhbWFsaW5nYW0uY0BpbnRlbC5jb20+Cj4gQ2M6IEdyZWcgS3JvYWgtSGFy dG1hbiA8Z3JlZ2toQGxpbnV4Zm91bmRhdGlvbi5vcmc+Cj4gQ2M6IFJ1c3NlbGwgS2luZyA8cm1r K2tlcm5lbEBhcm0ubGludXgub3JnLnVrPgo+IENjOiBSYWZhZWwgSi4gV3lzb2NraSA8cmFmYWVs QGtlcm5lbC5vcmc+Cj4gQ2M6IEphcm9zbGF2IEt5c2VsYSA8cGVyZXhAcGVyZXguY3o+Cj4gQ2M6 IFRha2FzaGkgSXdhaSA8dGl3YWlAc3VzZS5jb20+Cj4gQ2M6IFJvZHJpZ28gVml2aSA8cm9kcmln by52aXZpQGludGVsLmNvbT4KPiBDYzogSmFuaSBOaWt1bGEgPGphbmkubmlrdWxhQGxpbnV4Lmlu dGVsLmNvbT4KPiBTaWduZWQtb2ZmLWJ5OiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGZm d2xsLmNoPgoKSGkgR3JlZyZSdXNzZWxsLAoKTm93IHRoYXQgdGhlcmUncyBuaWNlIGRvY3VtZW50 YXRpb24gb24gZXZlcnl0aGluZywgYW55IGNvbW1lbnRzIG9uIHRoZXNlCnR3byBwYXRjaGVzPwoK VGhhbmtzLCBEYW5pZWwKCj4gLS0tCj4gIGRyaXZlcnMvYmFzZS9jb21wb25lbnQuYyAgfCAxNTkg KysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0KPiAgaW5jbHVkZS9saW51eC9j b21wb25lbnQuaCB8ICAxMCArKy0KPiAgMiBmaWxlcyBjaGFuZ2VkLCAxMzAgaW5zZXJ0aW9ucygr KSwgMzkgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmFzZS9jb21wb25l bnQuYyBiL2RyaXZlcnMvYmFzZS9jb21wb25lbnQuYwo+IGluZGV4IGU1YjA0YmNlODU0NC4uZWI3 OTE1ZmM1Mjc4IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvYmFzZS9jb21wb25lbnQuYwo+ICsrKyBi L2RyaXZlcnMvYmFzZS9jb21wb25lbnQuYwo+IEBAIC00OCw2ICs0OCw3IEBAIHN0cnVjdCBjb21w b25lbnQ7Cj4gIHN0cnVjdCBjb21wb25lbnRfbWF0Y2hfYXJyYXkgewo+ICAJdm9pZCAqZGF0YTsK PiAgCWludCAoKmNvbXBhcmUpKHN0cnVjdCBkZXZpY2UgKiwgdm9pZCAqKTsKPiArCWludCAoKmNv bXBhcmVfdHlwZWQpKHN0cnVjdCBkZXZpY2UgKiwgaW50LCB2b2lkICopOwo+ICAJdm9pZCAoKnJl bGVhc2UpKHN0cnVjdCBkZXZpY2UgKiwgdm9pZCAqKTsKPiAgCXN0cnVjdCBjb21wb25lbnQgKmNv bXBvbmVudDsKPiAgCWJvb2wgZHVwbGljYXRlOwo+IEBAIC03NSw2ICs3Niw3IEBAIHN0cnVjdCBj b21wb25lbnQgewo+ICAJYm9vbCBib3VuZDsKPiAgCj4gIAljb25zdCBzdHJ1Y3QgY29tcG9uZW50 X29wcyAqb3BzOwo+ICsJaW50IHN1YmNvbXBvbmVudDsKPiAgCXN0cnVjdCBkZXZpY2UgKmRldjsK PiAgfTsKPiAgCj4gQEAgLTE1OSw3ICsxNjEsNyBAQCBzdGF0aWMgc3RydWN0IG1hc3RlciAqX19t YXN0ZXJfZmluZChzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gIH0KPiAgCj4gIHN0YXRpYyBzdHJ1Y3Qg Y29tcG9uZW50ICpmaW5kX2NvbXBvbmVudChzdHJ1Y3QgbWFzdGVyICptYXN0ZXIsCj4gLQlpbnQg KCpjb21wYXJlKShzdHJ1Y3QgZGV2aWNlICosIHZvaWQgKiksIHZvaWQgKmNvbXBhcmVfZGF0YSkK PiArCXN0cnVjdCBjb21wb25lbnRfbWF0Y2hfYXJyYXkgKm1jKQo+ICB7Cj4gIAlzdHJ1Y3QgY29t cG9uZW50ICpjOwo+ICAKPiBAQCAtMTY3LDggKzE2OSwxMyBAQCBzdGF0aWMgc3RydWN0IGNvbXBv bmVudCAqZmluZF9jb21wb25lbnQoc3RydWN0IG1hc3RlciAqbWFzdGVyLAo+ICAJCWlmIChjLT5t YXN0ZXIgJiYgYy0+bWFzdGVyICE9IG1hc3RlcikKPiAgCQkJY29udGludWU7Cj4gIAo+IC0JCWlm IChjb21wYXJlKGMtPmRldiwgY29tcGFyZV9kYXRhKSkKPiArCQlpZiAobWMtPmNvbXBhcmVfdHlw ZWQpIHsKPiArCQkJaWYgKG1jLT5jb21wYXJlX3R5cGVkKGMtPmRldiwgYy0+c3ViY29tcG9uZW50 LAo+ICsJCQkJCSAgICAgIG1jLT5kYXRhKSkKPiArCQkJCXJldHVybiBjOwo+ICsJCX0gZWxzZSBp ZiAobWMtPmNvbXBhcmUoYy0+ZGV2LCBtYy0+ZGF0YSkpIHsKPiAgCQkJcmV0dXJuIGM7Cj4gKwkJ fQo+ICAJfQo+ICAKPiAgCXJldHVybiBOVUxMOwo+IEBAIC0xOTMsNyArMjAwLDcgQEAgc3RhdGlj IGludCBmaW5kX2NvbXBvbmVudHMoc3RydWN0IG1hc3RlciAqbWFzdGVyKQo+ICAJCWlmIChtYXRj aC0+Y29tcGFyZVtpXS5jb21wb25lbnQpCj4gIAkJCWNvbnRpbnVlOwo+ICAKPiAtCQljID0gZmlu ZF9jb21wb25lbnQobWFzdGVyLCBtYy0+Y29tcGFyZSwgbWMtPmRhdGEpOwo+ICsJCWMgPSBmaW5k X2NvbXBvbmVudChtYXN0ZXIsIG1jKTsKPiAgCQlpZiAoIWMpIHsKPiAgCQkJcmV0ID0gLUVOWElP Owo+ICAJCQlicmVhazsKPiBAQCAtMzI4LDI5ICszMzUsMTIgQEAgc3RhdGljIGludCBjb21wb25l bnRfbWF0Y2hfcmVhbGxvYyhzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gIAlyZXR1cm4gMDsKPiAgfQo+ ICAKPiAtLyoqCj4gLSAqIGNvbXBvbmVudF9tYXRjaF9hZGRfcmVsZWFzZSAtIGFkZCBhIGNvbXBl bnQgbWF0Y2ggd2l0aCByZWxlYXNlIGNhbGxiYWNrCj4gLSAqIEBtYXN0ZXI6IGRldmljZSB3aXRo IHRoZSBhZ2dyZWdhdGUgZHJpdmVyCj4gLSAqIEBtYXRjaHB0cjogcG9pbnRlciB0byB0aGUgbGlz dCBvZiBjb21wb25lbnQgbWF0Y2hlcwo+IC0gKiBAcmVsZWFzZTogcmVsZWFzZSBmdW5jdGlvbiBm b3IgQGNvbXBhcmVfZGF0YQo+IC0gKiBAY29tcGFyZTogY29tcGFyZSBmdW5jdGlvbiB0byBtYXRj aCBhZ2FpbnN0IGFsbCBjb21wb25lbnRzCj4gLSAqIEBjb21wYXJlX2RhdGE6IG9wYXF1ZSBwb2lu dGVyIHBhc3NlZCB0byB0aGUgQGNvbXBhcmUgZnVuY3Rpb24KPiAtICoKPiAtICogVGhpcyBhZGRz IGEgbmV3IGNvbXBvbmVudCBtYXRjaCB0byB0aGUgbGlzdCBzdG9yZWQgaW4gQG1hdGNocHRyLCB3 aGljaCB0aGUKPiAtICogQG1hc3RlciBhZ2dyZWdhdGUgZHJpdmVyIG5lZWRzIHRvIGZ1bmN0aW9u LiBAbWF0Y2hwdHIgbXVzdCBiZSBpbml0aWFsaXplZCB0bwo+IC0gKiBOVUxMIGJlZm9yZSBhZGRp bmcgdGhlIGZpcnN0IG1hdGNoLgo+IC0gKgo+IC0gKiBUaGUgYWxsb2NhdGVkIG1hdGNoIGxpc3Qg aW4gQG1hdGNocHRyIGlzIGF1dG9tYXRpY2FsbHkgcmVsZWFzZWQgdXNpbmcgZGV2bQo+IC0gKiBh Y3Rpb25zLiBBdCB0aGF0IHBvaW50IEByZWxlYXNlIHdpbGwgYmUgY2FsbGVkLCB0byBmcmVlIGFu eSByZWZlcmVuY2VzIGhlbGQKPiAtICogYnkgQGNvbXBhcmVfZGF0YSwgZS5nLiB3aGVuIEBjb21w YXJlX2RhdGEgaXMgYSAmZGV2aWNlX25vZGUgdGhhdCBtdXN0IGJlCj4gLSAqIHJlbGVhc2VkIHdp dGggb2Zfbm9kZV9wdXQoKS4KPiAtICoKPiAtICogU2VlIGFsc28gY29tcG9uZW50X21hdGNoX2Fk ZCgpLgo+IC0gKi8KPiAtdm9pZCBjb21wb25lbnRfbWF0Y2hfYWRkX3JlbGVhc2Uoc3RydWN0IGRl dmljZSAqbWFzdGVyLAo+ICtzdGF0aWMgdm9pZCBfX2NvbXBvbmVudF9tYXRjaF9hZGQoc3RydWN0 IGRldmljZSAqbWFzdGVyLAo+ICAJc3RydWN0IGNvbXBvbmVudF9tYXRjaCAqKm1hdGNocHRyLAo+ ICAJdm9pZCAoKnJlbGVhc2UpKHN0cnVjdCBkZXZpY2UgKiwgdm9pZCAqKSwKPiAtCWludCAoKmNv bXBhcmUpKHN0cnVjdCBkZXZpY2UgKiwgdm9pZCAqKSwgdm9pZCAqY29tcGFyZV9kYXRhKQo+ICsJ aW50ICgqY29tcGFyZSkoc3RydWN0IGRldmljZSAqLCB2b2lkICopLAo+ICsJaW50ICgqY29tcGFy ZV90eXBlZCkoc3RydWN0IGRldmljZSAqLCBpbnQsIHZvaWQgKiksCj4gKwl2b2lkICpjb21wYXJl X2RhdGEpCj4gIHsKPiAgCXN0cnVjdCBjb21wb25lbnRfbWF0Y2ggKm1hdGNoID0gKm1hdGNocHRy Owo+ICAKPiBAQCAtMzgyLDEzICszNzIsNjkgQEAgdm9pZCBjb21wb25lbnRfbWF0Y2hfYWRkX3Jl bGVhc2Uoc3RydWN0IGRldmljZSAqbWFzdGVyLAo+ICAJfQo+ICAKPiAgCW1hdGNoLT5jb21wYXJl W21hdGNoLT5udW1dLmNvbXBhcmUgPSBjb21wYXJlOwo+ICsJbWF0Y2gtPmNvbXBhcmVbbWF0Y2gt Pm51bV0uY29tcGFyZV90eXBlZCA9IGNvbXBhcmVfdHlwZWQ7Cj4gIAltYXRjaC0+Y29tcGFyZVtt YXRjaC0+bnVtXS5yZWxlYXNlID0gcmVsZWFzZTsKPiAgCW1hdGNoLT5jb21wYXJlW21hdGNoLT5u dW1dLmRhdGEgPSBjb21wYXJlX2RhdGE7Cj4gIAltYXRjaC0+Y29tcGFyZVttYXRjaC0+bnVtXS5j b21wb25lbnQgPSBOVUxMOwo+ICAJbWF0Y2gtPm51bSsrOwo+ICB9Cj4gKwo+ICsvKioKPiArICog Y29tcG9uZW50X21hdGNoX2FkZF9yZWxlYXNlIC0gYWRkIGEgY29tcGVudCBtYXRjaCB3aXRoIHJl bGVhc2UgY2FsbGJhY2sKPiArICogQG1hc3RlcjogZGV2aWNlIHdpdGggdGhlIGFnZ3JlZ2F0ZSBk cml2ZXIKPiArICogQG1hdGNocHRyOiBwb2ludGVyIHRvIHRoZSBsaXN0IG9mIGNvbXBvbmVudCBt YXRjaGVzCj4gKyAqIEByZWxlYXNlOiByZWxlYXNlIGZ1bmN0aW9uIGZvciBAY29tcGFyZV9kYXRh Cj4gKyAqIEBjb21wYXJlOiBjb21wYXJlIGZ1bmN0aW9uIHRvIG1hdGNoIGFnYWluc3QgYWxsIGNv bXBvbmVudHMKPiArICogQGNvbXBhcmVfZGF0YTogb3BhcXVlIHBvaW50ZXIgcGFzc2VkIHRvIHRo ZSBAY29tcGFyZSBmdW5jdGlvbgo+ICsgKgo+ICsgKiBUaGlzIGFkZHMgYSBuZXcgY29tcG9uZW50 IG1hdGNoIHRvIHRoZSBsaXN0IHN0b3JlZCBpbiBAbWF0Y2hwdHIsIHdoaWNoIHRoZQo+ICsgKiBA bWFzdGVyIGFnZ3JlZ2F0ZSBkcml2ZXIgbmVlZHMgdG8gZnVuY3Rpb24uIEBtYXRjaHB0ciBtdXN0 IGJlIGluaXRpYWxpemVkIHRvCj4gKyAqIE5VTEwgYmVmb3JlIGFkZGluZyB0aGUgZmlyc3QgbWF0 Y2guCj4gKyAqCj4gKyAqIFRoZSBhbGxvY2F0ZWQgbWF0Y2ggbGlzdCBpbiBAbWF0Y2hwdHIgaXMg YXV0b21hdGljYWxseSByZWxlYXNlZCB1c2luZyBkZXZtCj4gKyAqIGFjdGlvbnMuIEF0IHRoYXQg cG9pbnQgQHJlbGVhc2Ugd2lsbCBiZSBjYWxsZWQsIHRvIGZyZWUgYW55IHJlZmVyZW5jZXMgaGVs ZAo+ICsgKiBieSBAY29tcGFyZV9kYXRhLCBlLmcuIHdoZW4gQGNvbXBhcmVfZGF0YSBpcyBhICZk ZXZpY2Vfbm9kZSB0aGF0IG11c3QgYmUKPiArICogcmVsZWFzZWQgd2l0aCBvZl9ub2RlX3B1dCgp LiBUaGlzIG9ubHkgbWF0Y2hlcyBhZ2FpbnN0IGNvbXBvbmVudHMKPiArICogYWRkZWQgd2l0aCBj b21wb25lbnRfYWRkKCkuCj4gKyAqCj4gKyAqIFNlZSBhbHNvIGNvbXBvbmVudF9tYXRjaF9hZGQo KSBhbmQgY29tcG9uZW50X21hdGNoX2FkZF90eXBlZCgpLgo+ICsgKi8KPiArdm9pZCBjb21wb25l bnRfbWF0Y2hfYWRkX3JlbGVhc2Uoc3RydWN0IGRldmljZSAqbWFzdGVyLAo+ICsJc3RydWN0IGNv bXBvbmVudF9tYXRjaCAqKm1hdGNocHRyLAo+ICsJdm9pZCAoKnJlbGVhc2UpKHN0cnVjdCBkZXZp Y2UgKiwgdm9pZCAqKSwKPiArCWludCAoKmNvbXBhcmUpKHN0cnVjdCBkZXZpY2UgKiwgdm9pZCAq KSwgdm9pZCAqY29tcGFyZV9kYXRhKQo+ICt7Cj4gKwlfX2NvbXBvbmVudF9tYXRjaF9hZGQobWFz dGVyLCBtYXRjaHB0ciwgcmVsZWFzZSwgY29tcGFyZSwgTlVMTCwKPiArCQkJICAgICAgY29tcGFy ZV9kYXRhKTsKPiArfQo+ICBFWFBPUlRfU1lNQk9MKGNvbXBvbmVudF9tYXRjaF9hZGRfcmVsZWFz ZSk7Cj4gIAo+ICsvKioKPiArICogY29tcG9uZW50X21hdGNoX2FkZF90eXBlZCAtIGFkZCBhIGNv bXBlbnQgbWF0Y2ggZm9yIGEgdHlwZWQgY29tcG9uZW50Cj4gKyAqIEBtYXN0ZXI6IGRldmljZSB3 aXRoIHRoZSBhZ2dyZWdhdGUgZHJpdmVyCj4gKyAqIEBtYXRjaHB0cjogcG9pbnRlciB0byB0aGUg bGlzdCBvZiBjb21wb25lbnQgbWF0Y2hlcwo+ICsgKiBAY29tcGFyZV90eXBlZDogY29tcGFyZSBm dW5jdGlvbiB0byBtYXRjaCBhZ2FpbnN0IGFsbCB0eXBlZCBjb21wb25lbnRzCj4gKyAqIEBjb21w YXJlX2RhdGE6IG9wYXF1ZSBwb2ludGVyIHBhc3NlZCB0byB0aGUgQGNvbXBhcmUgZnVuY3Rpb24K PiArICoKPiArICogVGhpcyBhZGRzIGEgbmV3IGNvbXBvbmVudCBtYXRjaCB0byB0aGUgbGlzdCBz dG9yZWQgaW4gQG1hdGNocHRyLCB3aGljaCB0aGUKPiArICogQG1hc3RlciBhZ2dyZWdhdGUgZHJp dmVyIG5lZWRzIHRvIGZ1bmN0aW9uLiBAbWF0Y2hwdHIgbXVzdCBiZSBpbml0aWFsaXplZCB0bwo+ ICsgKiBOVUxMIGJlZm9yZSBhZGRpbmcgdGhlIGZpcnN0IG1hdGNoLiBUaGlzIG9ubHkgbWF0Y2hl cyBhZ2FpbnN0IGNvbXBvbmVudHMKPiArICogYWRkZWQgd2l0aCBjb21wb25lbnRfYWRkX3R5cGVk KCkuCj4gKyAqCj4gKyAqIFRoZSBhbGxvY2F0ZWQgbWF0Y2ggbGlzdCBpbiBAbWF0Y2hwdHIgaXMg YXV0b21hdGljYWxseSByZWxlYXNlZCB1c2luZyBkZXZtCj4gKyAqIGFjdGlvbnMuCj4gKyAqCj4g KyAqIFNlZSBhbHNvIGNvbXBvbmVudF9tYXRjaF9hZGRfcmVsZWFzZSgpIGFuZCBjb21wb25lbnRf bWF0Y2hfYWRkX3R5cGVkKCkuCj4gKyAqLwo+ICt2b2lkIGNvbXBvbmVudF9tYXRjaF9hZGRfdHlw ZWQoc3RydWN0IGRldmljZSAqbWFzdGVyLAo+ICsJc3RydWN0IGNvbXBvbmVudF9tYXRjaCAqKm1h dGNocHRyLAo+ICsJaW50ICgqY29tcGFyZV90eXBlZCkoc3RydWN0IGRldmljZSAqLCBpbnQsIHZv aWQgKiksIHZvaWQgKmNvbXBhcmVfZGF0YSkKPiArewo+ICsJX19jb21wb25lbnRfbWF0Y2hfYWRk KG1hc3RlciwgbWF0Y2hwdHIsIE5VTEwsIE5VTEwsIGNvbXBhcmVfdHlwZWQsCj4gKwkJCSAgICAg IGNvbXBhcmVfZGF0YSk7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChjb21wb25lbnRfbWF0Y2hfYWRk X3R5cGVkKTsKPiArCj4gIHN0YXRpYyB2b2lkIGZyZWVfbWFzdGVyKHN0cnVjdCBtYXN0ZXIgKm1h c3RlcikKPiAgewo+ICAJc3RydWN0IGNvbXBvbmVudF9tYXRjaCAqbWF0Y2ggPSBtYXN0ZXItPm1h dGNoOwo+IEBAIC02MTcsMTkgKzY2Myw4IEBAIGludCBjb21wb25lbnRfYmluZF9hbGwoc3RydWN0 IGRldmljZSAqbWFzdGVyX2Rldiwgdm9pZCAqZGF0YSkKPiAgfQo+ICBFWFBPUlRfU1lNQk9MX0dQ TChjb21wb25lbnRfYmluZF9hbGwpOwo+ICAKPiAtLyoqCj4gLSAqIGNvbXBvbmVudF9hZGQgLSBy ZWdpc3RlciBhIGNvbXBvbmVudAo+IC0gKiBAZGV2OiBjb21wb25lbnQgZGV2aWNlCj4gLSAqIEBv cHM6IGNvbXBvbmVudCBjYWxsYmFja3MKPiAtICoKPiAtICogUmVnaXN0ZXIgYSBuZXcgY29tcG9u ZW50IGZvciBAZGV2LiBGdW5jdGlvbnMgaW4gQG9wcyB3aWxsIGJlIGNhbGwgd2hlbiB0aGUKPiAt ICogYWdncmVnYXRlIGRyaXZlciBpcyByZWFkeSB0byBiaW5kIHRoZSBvdmVyYWxsIGRyaXZlciBi eSBjYWxsaW5nCj4gLSAqIGNvbXBvbmVudF9iaW5kX2FsbCgpLiBTZWUgYWxzbyAmc3RydWN0IGNv bXBvbmVudF9vcHMuCj4gLSAqCj4gLSAqIFRoZSBjb21wb25lbnQgbmVlZHMgdG8gYmUgdW5yZWdp c3RlcmVkIGFnYWluIGF0IGRyaXZlciB1bmxvYWQvZGlzY29ubmVjdCBieQo+IC0gKiBjYWxsaW5n IGNvbXBvbmVudF9kZWwoKS4KPiAtICovCj4gLWludCBjb21wb25lbnRfYWRkKHN0cnVjdCBkZXZp Y2UgKmRldiwgY29uc3Qgc3RydWN0IGNvbXBvbmVudF9vcHMgKm9wcykKPiArc3RhdGljIGludCBf X2NvbXBvbmVudF9hZGQoc3RydWN0IGRldmljZSAqZGV2LCBjb25zdCBzdHJ1Y3QgY29tcG9uZW50 X29wcyAqb3BzLAo+ICsJaW50IHN1YmNvbXBvbmVudCkKPiAgewo+ICAJc3RydWN0IGNvbXBvbmVu dCAqY29tcG9uZW50Owo+ICAJaW50IHJldDsKPiBAQCAtNjQwLDYgKzY3NSw3IEBAIGludCBjb21w b25lbnRfYWRkKHN0cnVjdCBkZXZpY2UgKmRldiwgY29uc3Qgc3RydWN0IGNvbXBvbmVudF9vcHMg Km9wcykKPiAgCj4gIAljb21wb25lbnQtPm9wcyA9IG9wczsKPiAgCWNvbXBvbmVudC0+ZGV2ID0g ZGV2Owo+ICsJY29tcG9uZW50LT5zdWJjb21wb25lbnQgPSBzdWJjb21wb25lbnQ7Cj4gIAo+ICAJ ZGV2X2RiZyhkZXYsICJhZGRpbmcgY29tcG9uZW50IChvcHMgJXBzKVxuIiwgb3BzKTsKPiAgCj4g QEAgLTY1OCw2ICs2OTQsNTUgQEAgaW50IGNvbXBvbmVudF9hZGQoc3RydWN0IGRldmljZSAqZGV2 LCBjb25zdCBzdHJ1Y3QgY29tcG9uZW50X29wcyAqb3BzKQo+ICAKPiAgCXJldHVybiByZXQgPCAw ID8gcmV0IDogMDsKPiAgfQo+ICsKPiArLyoqCj4gKyAqIGNvbXBvbmVudF9hZGRfdHlwZWQgLSBy ZWdpc3RlciBhIGNvbXBvbmVudAo+ICsgKiBAZGV2OiBjb21wb25lbnQgZGV2aWNlCj4gKyAqIEBv cHM6IGNvbXBvbmVudCBjYWxsYmFja3MKPiArICogQHN1YmNvbXBvbmVudDogbm9uemVybyBpZGVu dGlmaWVyIGZvciBzdWJjb21wb25lbnRzCj4gKyAqCj4gKyAqIFJlZ2lzdGVyIGEgbmV3IGNvbXBv bmVudCBmb3IgQGRldi4gRnVuY3Rpb25zIGluIEBvcHMgd2lsbCBiZSBjYWxsIHdoZW4gdGhlCj4g KyAqIGFnZ3JlZ2F0ZSBkcml2ZXIgaXMgcmVhZHkgdG8gYmluZCB0aGUgb3ZlcmFsbCBkcml2ZXIg YnkgY2FsbGluZwo+ICsgKiBjb21wb25lbnRfYmluZF9hbGwoKS4gU2VlIGFsc28gJnN0cnVjdCBj b21wb25lbnRfb3BzLgo+ICsgKgo+ICsgKiBAc3ViY29tcG9uZW50IG11c3QgYmUgbm9uemVybyBh bmQgaXMgdXNlZCB0byBkaWZmZXJlbnRpYXRlIGJldHdlZW4gbXVsdGlwbGUKPiArICogY29tcG9u ZW50cyByZWdpc3RlcmQgb24gdGhlIHNhbWUgZGV2aWNlIEBkZXYuIFRoZXNlIGNvbXBvbmVudHMg YXJlIG1hdGNoCj4gKyAqIHVzaW5nIGNvbXBvbmVudF9tYXRjaF9hZGRfdHlwZWQoKS4KPiArICoK PiArICogVGhlIGNvbXBvbmVudCBuZWVkcyB0byBiZSB1bnJlZ2lzdGVyZWQgYWdhaW4gYXQgZHJp dmVyIHVubG9hZC9kaXNjb25uZWN0IGJ5Cj4gKyAqIGNhbGxpbmcgY29tcG9uZW50X2RlbCgpLgo+ ICsgKgo+ICsgKiBTZWUgYWxzbyBjb21wb25lbnRfYWRkKCkuCj4gKyAqLwo+ICtpbnQgY29tcG9u ZW50X2FkZF90eXBlZChzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IHN0cnVjdCBjb21wb25lbnRf b3BzICpvcHMsCj4gKwlpbnQgc3ViY29tcG9uZW50KQo+ICt7Cj4gKwlpZiAoV0FSTl9PTihzdWJj b21wb25lbnQgPT0gMCkpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJcmV0dXJuIF9fY29t cG9uZW50X2FkZChkZXYsIG9wcywgc3ViY29tcG9uZW50KTsKPiArfQo+ICtFWFBPUlRfU1lNQk9M X0dQTChjb21wb25lbnRfYWRkX3R5cGVkKTsKPiArCj4gKy8qKgo+ICsgKiBjb21wb25lbnRfYWRk IC0gcmVnaXN0ZXIgYSBjb21wb25lbnQKPiArICogQGRldjogY29tcG9uZW50IGRldmljZQo+ICsg KiBAb3BzOiBjb21wb25lbnQgY2FsbGJhY2tzCj4gKyAqCj4gKyAqIFJlZ2lzdGVyIGEgbmV3IGNv bXBvbmVudCBmb3IgQGRldi4gRnVuY3Rpb25zIGluIEBvcHMgd2lsbCBiZSBjYWxsIHdoZW4gdGhl Cj4gKyAqIGFnZ3JlZ2F0ZSBkcml2ZXIgaXMgcmVhZHkgdG8gYmluZCB0aGUgb3ZlcmFsbCBkcml2 ZXIgYnkgY2FsbGluZwo+ICsgKiBjb21wb25lbnRfYmluZF9hbGwoKS4gU2VlIGFsc28gJnN0cnVj dCBjb21wb25lbnRfb3BzLgo+ICsgKgo+ICsgKiBUaGUgY29tcG9uZW50IG5lZWRzIHRvIGJlIHVu cmVnaXN0ZXJlZCBhZ2FpbiBhdCBkcml2ZXIgdW5sb2FkL2Rpc2Nvbm5lY3QgYnkKPiArICogY2Fs bGluZyBjb21wb25lbnRfZGVsKCkuCj4gKyAqCj4gKyAqIFNlZSBhbHNvIGNvbXBvbmVudF9hZGRf dHlwZWQoKSBmb3IgYSB2YXJpYW50IHRoYXQgYWxsb3dzIG11bHRpcGxlZCBkaWZmZXJlbnQKPiAr ICogY29tcG9uZW50cyBvbiB0aGUgc2FtZSBkZXZpY2UuCj4gKyAqLwo+ICtpbnQgY29tcG9uZW50 X2FkZChzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IHN0cnVjdCBjb21wb25lbnRfb3BzICpvcHMp Cj4gK3sKPiArCXJldHVybiBfX2NvbXBvbmVudF9hZGQoZGV2LCBvcHMsIDApOwo+ICt9Cj4gIEVY UE9SVF9TWU1CT0xfR1BMKGNvbXBvbmVudF9hZGQpOwo+ICAKPiAgLyoqCj4gZGlmZiAtLWdpdCBh L2luY2x1ZGUvbGludXgvY29tcG9uZW50LmggYi9pbmNsdWRlL2xpbnV4L2NvbXBvbmVudC5oCj4g aW5kZXggNjdhODk5ZGQyZTEwLi45ZTY5ZTIxMTdmMGIgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9s aW51eC9jb21wb25lbnQuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvY29tcG9uZW50LmgKPiBAQCAt MzQsNiArMzQsOCBAQCBzdHJ1Y3QgY29tcG9uZW50X29wcyB7Cj4gIH07Cj4gIAo+ICBpbnQgY29t cG9uZW50X2FkZChzdHJ1Y3QgZGV2aWNlICosIGNvbnN0IHN0cnVjdCBjb21wb25lbnRfb3BzICop Owo+ICtpbnQgY29tcG9uZW50X2FkZF90eXBlZChzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IHN0 cnVjdCBjb21wb25lbnRfb3BzICpvcHMsCj4gKwlpbnQgc3ViY29tcG9uZW50KTsKPiAgdm9pZCBj b21wb25lbnRfZGVsKHN0cnVjdCBkZXZpY2UgKiwgY29uc3Qgc3RydWN0IGNvbXBvbmVudF9vcHMg Kik7Cj4gIAo+ICBpbnQgY29tcG9uZW50X2JpbmRfYWxsKHN0cnVjdCBkZXZpY2UgKm1hc3Rlciwg dm9pZCAqbWFzdGVyX2RhdGEpOwo+IEBAIC05MSw2ICs5Myw5IEBAIHZvaWQgY29tcG9uZW50X21h dGNoX2FkZF9yZWxlYXNlKHN0cnVjdCBkZXZpY2UgKm1hc3RlciwKPiAgCXN0cnVjdCBjb21wb25l bnRfbWF0Y2ggKiptYXRjaHB0ciwKPiAgCXZvaWQgKCpyZWxlYXNlKShzdHJ1Y3QgZGV2aWNlICos IHZvaWQgKiksCj4gIAlpbnQgKCpjb21wYXJlKShzdHJ1Y3QgZGV2aWNlICosIHZvaWQgKiksIHZv aWQgKmNvbXBhcmVfZGF0YSk7Cj4gK3ZvaWQgY29tcG9uZW50X21hdGNoX2FkZF90eXBlZChzdHJ1 Y3QgZGV2aWNlICptYXN0ZXIsCj4gKwlzdHJ1Y3QgY29tcG9uZW50X21hdGNoICoqbWF0Y2hwdHIs Cj4gKwlpbnQgKCpjb21wYXJlX3R5cGVkKShzdHJ1Y3QgZGV2aWNlICosIGludCwgdm9pZCAqKSwg dm9pZCAqY29tcGFyZV9kYXRhKTsKPiAgCj4gIC8qKgo+ICAgKiBjb21wb25lbnRfbWF0Y2hfYWRk IC0gYWRkIGEgY29tcGVudCBtYXRjaAo+IEBAIC0xMDEsMTIgKzEwNiwxMyBAQCB2b2lkIGNvbXBv bmVudF9tYXRjaF9hZGRfcmVsZWFzZShzdHJ1Y3QgZGV2aWNlICptYXN0ZXIsCj4gICAqCj4gICAq IFRoaXMgYWRkcyBhIG5ldyBjb21wb25lbnQgbWF0Y2ggdG8gdGhlIGxpc3Qgc3RvcmVkIGluIEBt YXRjaHB0ciwgd2hpY2ggdGhlCj4gICAqIEBtYXN0ZXIgYWdncmVnYXRlIGRyaXZlciBuZWVkcyB0 byBmdW5jdGlvbi4gQG1hdGNocHRyIG11c3QgYmUgaW5pdGlhbGl6ZWQgdG8KPiAtICogTlVMTCBi ZWZvcmUgYWRkaW5nIHRoZSBmaXJzdCBtYXRjaC4KPiArICogTlVMTCBiZWZvcmUgYWRkaW5nIHRo ZSBmaXJzdCBtYXRjaC4gVGhpcyBvbmx5IG1hdGNoZXMgYWdhaW5zdCBjb21wb25lbnRzCj4gKyAq IGFkZGVkIHdpdGggY29tcG9uZW50X2FkZCgpLgo+ICAgKgo+ICAgKiBUaGUgYWxsb2NhdGVkIG1h dGNoIGxpc3QgaW4gQG1hdGNocHRyIGlzIGF1dG9tYXRpY2FsbHkgcmVsZWFzZWQgdXNpbmcgZGV2 bQo+ICAgKiBhY3Rpb25zLgo+ICAgKgo+IC0gKiBTZWUgYWxzbyBjb21wb25lbnRfbWF0Y2hfYWRk X3JlbGVhc2UoKS4KPiArICogU2VlIGFsc28gY29tcG9uZW50X21hdGNoX2FkZF9yZWxlYXNlKCkg YW5kIGNvbXBvbmVudF9tYXRjaF9hZGRfdHlwZWQoKS4KPiAgICovCj4gIHN0YXRpYyBpbmxpbmUg dm9pZCBjb21wb25lbnRfbWF0Y2hfYWRkKHN0cnVjdCBkZXZpY2UgKm1hc3RlciwKPiAgCXN0cnVj dCBjb21wb25lbnRfbWF0Y2ggKiptYXRjaHB0ciwKPiAtLSAKPiAyLjIwLjEKPiAKCi0tIApEYW5p ZWwgVmV0dGVyClNvZnR3YXJlIEVuZ2luZWVyLCBJbnRlbCBDb3Jwb3JhdGlvbgpodHRwOi8vYmxv Zy5mZndsbC5jaApfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcK aHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK 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 AAD21C282C4 for ; Mon, 4 Feb 2019 16:00:34 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 6672E2082F for ; Mon, 4 Feb 2019 16:00: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="aENnijJV" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730613AbfBDQAc (ORCPT ); Mon, 4 Feb 2019 11:00:32 -0500 Received: from mail-ed1-f67.google.com ([209.85.208.67]:44175 "EHLO mail-ed1-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726928AbfBDQAc (ORCPT ); Mon, 4 Feb 2019 11:00:32 -0500 Received: by mail-ed1-f67.google.com with SMTP id y56so266922edd.11 for ; Mon, 04 Feb 2019 08:00: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=mflHSiJStNNAU4+Jb4KJeMnsQVxuKzMPdqStOrCT6FI=; b=aENnijJVQboPfAIqajwrS/v3HzpRCF8efoIXP2JTKZ3XSqoBaBqOYt+5QqVzSq0KCA /2bjQW0qGEqb3O3U9k9Lvopk9SEUQO1cuDu6ApruyY9TlfkDJZTslNyiGnw8WltYm9Ox D9iHXYdgVSZApnOncsFz8AoOZQab8+Ajw9CGY= 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=mflHSiJStNNAU4+Jb4KJeMnsQVxuKzMPdqStOrCT6FI=; b=NKF+6xQRHHIurxfWxS884aW0hIwVP/EEZGfAFwSqhhJ8PrHP3J8NcDZXvFaH6SnVYo v7xavergt1ud83BBJMnBk49GH+7hVw55Remn13Eb8AHZGhIfNou/Ev0A8JgFr7w02G2f yd+dZDuLwelih0qriGxPiY/t5QYYExxWfRN0BENLI5CFD2K5aY2GCCrY9Kk5RFmi0uAD LCglaiJLUo25J6NRMjy3dUxfdr0smtqskUGik1Ha5ocrtHp+volQKOmsCN8OShAr484C wZtL6suo0lesx2+r8vJgMGM1OpwEguaY4qCqojMX/BfLs+X/dyx6oUlNNoiCR+nvqbT4 8NDw== X-Gm-Message-State: AHQUAubh74PFMu1dNGWTO61c/1G/XWm0zHnHqjl+4NVA3789RZku8LIw mMzym2kP5ao9r7MLgiKLy7osHA== X-Google-Smtp-Source: AHgI3IZtPXFcWnjya4AfV3lUUyQR52KbxlH2qiD9tx5FNp7oCMYtEK7jRIzAAJUs2R1wKO2ISLqQ5g== X-Received: by 2002:a50:9770:: with SMTP id d45mr43114edb.49.1549296029018; Mon, 04 Feb 2019 08:00:29 -0800 (PST) Received: from phenom.ffwll.local ([2a02:168:569e:0:3106:d637:d723:e855]) by smtp.gmail.com with ESMTPSA id e14sm4434840edb.79.2019.02.04.08.00.27 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 04 Feb 2019 08:00:28 -0800 (PST) Date: Mon, 4 Feb 2019 17:00:25 +0100 From: Daniel Vetter To: DRI Development Cc: LKML , Daniel Vetter , Ramalingam C , Greg Kroah-Hartman , Russell King , "Rafael J . Wysocki" , Jaroslav Kysela , Takashi Iwai , Rodrigo Vivi , Jani Nikula Subject: Re: [PATCH 2/2] components: multiple components for a device Message-ID: <20190204160025.GV3271@phenom.ffwll.local> Mail-Followup-To: DRI Development , LKML , Ramalingam C , Greg Kroah-Hartman , Russell King , "Rafael J . Wysocki" , Jaroslav Kysela , Takashi Iwai , Rodrigo Vivi , Jani Nikula References: <1548917996-28081-2-git-send-email-ramalingam.c@intel.com> <20190131144640.17896-1-daniel.vetter@ffwll.ch> <20190131144640.17896-2-daniel.vetter@ffwll.ch> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20190131144640.17896-2-daniel.vetter@ffwll.ch> 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 Thu, Jan 31, 2019 at 03:46:40PM +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. > > 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 Hi Greg&Russell, Now that there's nice documentation on everything, any comments on these two patches? Thanks, Daniel > --- > drivers/base/component.c | 159 +++++++++++++++++++++++++++++--------- > include/linux/component.h | 10 ++- > 2 files changed, 130 insertions(+), 39 deletions(-) > > diff --git a/drivers/base/component.c b/drivers/base/component.c > index e5b04bce8544..eb7915fc5278 100644 > --- a/drivers/base/component.c > +++ b/drivers/base/component.c > @@ -48,6 +48,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; > @@ -75,6 +76,7 @@ struct component { > bool bound; > > const struct component_ops *ops; > + int subcomponent; > struct device *dev; > }; > > @@ -159,7 +161,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; > > @@ -167,8 +169,13 @@ static struct component *find_component(struct master *master, > if (c->master && c->master != master) > continue; > > - if (compare(c->dev, compare_data)) > + if (mc->compare_typed) { > + if (mc->compare_typed(c->dev, c->subcomponent, > + mc->data)) > + return c; > + } else if (mc->compare(c->dev, mc->data)) { > return c; > + } > } > > return NULL; > @@ -193,7 +200,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; > @@ -328,29 +335,12 @@ static int component_match_realloc(struct device *dev, > return 0; > } > > -/** > - * component_match_add_release - add a compent 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 > - * > - * This adds a new component match to the list stored in @matchptr, which the > - * @master aggregate driver needs to function. @matchptr must be initialized to > - * NULL before adding the first match. > - * > - * The allocated match list in @matchptr is automatically released using devm > - * actions. At that point @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; > > @@ -382,13 +372,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 compent 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 > + * > + * This adds a new component match to the list stored in @matchptr, which the > + * @master aggregate driver needs to function. @matchptr must be initialized to > + * NULL before adding the first match. > + * > + * The allocated match list in @matchptr is automatically released using devm > + * actions. At that point @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(). This only matches against components > + * added with component_add(). > + * > + * 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 > + * > + * This adds a new component match to the list stored in @matchptr, which the > + * @master aggregate driver needs to function. @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); > +} > +EXPORT_SYMBOL(component_match_add_typed); > + > static void free_master(struct master *master) > { > struct component_match *match = master->match; > @@ -617,19 +663,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 call 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 again 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; > @@ -640,6 +675,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); > > @@ -658,6 +694,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 again 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 call 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 again 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 67a899dd2e10..9e69e2117f0b 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, > * > * This adds a new component match to the list stored in @matchptr, which the > * @master aggregate driver needs to function. @matchptr must be initialized to > - * NULL before adding the first match. > + * 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 > -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch