From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [RFC PATCH 00/11] Introduce writeback connectors Date: Tue, 11 Oct 2016 17:43:59 +0200 Message-ID: <20161011154359.GD20761@phenom.ffwll.local> References: <1476197648-24918-1-git-send-email-brian.starkey@arm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x244.google.com (mail-lf0-x244.google.com [IPv6:2a00:1450:4010:c07::244]) by gabe.freedesktop.org (Postfix) with ESMTPS id 9EE816E10A for ; Tue, 11 Oct 2016 15:44:04 +0000 (UTC) Received: by mail-lf0-x244.google.com with SMTP id x79so4448843lff.2 for ; Tue, 11 Oct 2016 08:44:04 -0700 (PDT) Content-Disposition: inline In-Reply-To: <1476197648-24918-1-git-send-email-brian.starkey@arm.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Brian Starkey Cc: liviu.dudau@arm.com, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, hverkuil@xs4all.nl, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org T24gVHVlLCBPY3QgMTEsIDIwMTYgYXQgMDM6NTM6NTdQTSArMDEwMCwgQnJpYW4gU3RhcmtleSB3 cm90ZToKPiBIaSwKPiAKPiBUaGlzIFJGQyBzZXJpZXMgaW50cm9kdWNlcyBhIG5ldyBjb25uZWN0 b3IgdHlwZToKPiAgRFJNX01PREVfQ09OTkVDVE9SX1dSSVRFQkFDSwo+IEl0IGlzIGEgZm9sbG93 LW9uIGZyb20gYSBwcmV2aW91cyBkaXNjdXNzaW9uOiBbMV0KPiAKPiBXcml0ZWJhY2sgY29ubmVj dG9ycyBhcmUgdXNlZCB0byBleHBvc2UgdGhlIG1lbW9yeSB3cml0ZWJhY2sgZW5naW5lcwo+IGZv dW5kIGluIHNvbWUgZGlzcGxheSBjb250cm9sbGVycywgd2hpY2ggY2FuIHdyaXRlIGEgQ1JUQydz Cj4gY29tcG9zaXRpb24gcmVzdWx0IHRvIGEgbWVtb3J5IGJ1ZmZlci4KPiBUaGlzIGlzIHVzZWZ1 bCBlLmcuIGZvciB0ZXN0aW5nLCBzY3JlZW4tcmVjb3JkaW5nLCBzY3JlZW5zaG90cywKPiB3aXJl bGVzcyBkaXNwbGF5LCBkaXNwbGF5IGNsb25pbmcsIG1lbW9yeS10by1tZW1vcnkgY29tcG9zaXRp b24uCj4gCj4gUGF0Y2hlcyAxLTcgaW5jbHVkZSB0aGUgY29yZSBmcmFtZXdvcmsgY2hhbmdlcyBy ZXF1aXJlZCwgYW5kIHBhdGNoZXMKPiA4LTExIGltcGxlbWVudCBhIHdyaXRlYmFjayBjb25uZWN0 b3IgZm9yIHRoZSBNYWxpLURQIHdyaXRlYmFjayBlbmdpbmUuCj4gVGhlIE1hbGktRFAgcGF0Y2hl cyBkZXBlbmQgb24gdGhpcyBvdGhlciBzZXJpZXM6IFsyXS4KPiAKPiBUaGUgY29ubmVjdG9yIGlz IGdpdmVuIHRoZSBGQl9JRCBwcm9wZXJ0eSBmb3IgdGhlIG91dHB1dCBmcmFtZWJ1ZmZlciwKPiBh bmQgdHdvIG5ldyByZWFkLW9ubHkgcHJvcGVydGllczogUElYRUxfRk9STUFUUyBhbmQKPiBQSVhF TF9GT1JNQVRTX1NJWkUsIHdoaWNoIGV4cG9zZSB0aGUgc3VwcG9ydGVkIGZyYW1lYnVmZmVyIHBp eGVsCj4gZm9ybWF0cyBvZiB0aGUgZW5naW5lLgo+IAo+IFRoZSBFRElEIHByb3BlcnR5IGlzIG5v dCBleHBvc2VkIGZvciB3cml0ZWJhY2sgY29ubmVjdG9ycy4KPiAKPiBXcml0ZWJhY2sgY29ubmVj dG9yIHVzYWdlOgo+IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gRHVlIHRvIGNvbm5lY3Rv ciByb3V0aW5nIGNoYW5nZXMgYmVpbmcgdHJlYXRlZCBhcyAiZnVsbCBtb2Rlc2V0Igo+IG9wZXJh dGlvbnMsIGFueSBjbGllbnQgd2hpY2ggd2lzaGVzIHRvIHVzZSBhIHdyaXRlYmFjayBjb25uZWN0 b3IKPiBzaG91bGQgaW5jbHVkZSB0aGUgY29ubmVjdG9yIGluIGV2ZXJ5IG1vZGVzZXQuIFRoZSB3 cml0ZWJhY2sgd2lsbCBub3QKPiBhY3R1YWxseSBiZWNvbWUgYWN0aXZlIHVudGlsIGEgZnJhbWVi dWZmZXIgaXMgYXR0YWNoZWQuCgpFcmhtLCB0aGlzIGlzIGp1c3QgdGhlIGRlZmF1bHQsIGRyaXZl cnMgY2FuIG92ZXJyaWRlIHRoaXMuIEFuZCB3ZSBjb3VsZApjaGFuZ2UgdGhlIGF0b21pYyBoZWxw ZXJzIHRvIG5vdCBtYXJrIGEgbW9kZXNldCBhcyBhIG1vZGVzZXQgaWYgdGhlCmNvbm5lY3RvciB0 aGF0IGNoYW5nZWQgaXMgYSB3cml0ZWJhY2sgb25lLgoKPiBUaGUgd3JpdGViYWNrIGl0c2VsZiBp cyBlbmFibGVkIGJ5IGF0dGFjaGluZyBhIGZyYW1lYnVmZmVyIHRvIHRoZQo+IEZCX0lEIHByb3Bl cnR5IG9mIHRoZSBjb25uZWN0b3IuIFRoZSBkcml2ZXIgbXVzdCB0aGVuIGVuc3VyZSB0aGF0IHRo ZQo+IENSVEMgY29udGVudCBvZiB0aGF0IGF0b21pYyBjb21taXQgaXMgd3JpdHRlbiBpbnRvIHRo ZSBmcmFtZWJ1ZmZlci4KPiAKPiBUaGUgd3JpdGViYWNrIHdvcmtzIGluIGEgb25lLXNob3QgbW9k ZSB3aXRoIGVhY2ggYXRvbWljIGNvbW1pdC4gVGhpcwo+IHByZXZlbnRzIHRoZSBzYW1lIGNvbnRl bnQgZnJvbSBiZWluZyB3cml0dGVuIG11bHRpcGxlIHRpbWVzLgo+IEluIHNvbWUgY2FzZXMgKGZy b250LWJ1ZmZlciByZW5kZXJpbmcpIHRoZXJlIG1pZ2h0IGJlIGEgZGVzaXJlIGZvcgo+IGNvbnRp bnVvdXMgb3BlcmF0aW9uIC0gSSB0aGluayBhIHByb3BlcnR5IGNvdWxkIGJlIGFkZGVkIGxhdGVy IGZvcgo+IHRoaXMga2luZCBvZiBjb250cm9sLgo+IAo+IFdyaXRlYmFjayBjYW4gYmUgZGlzYWJs ZWQgYnkgc2V0dGluZyBGQl9JRCB0byB6ZXJvLgoKVGhpcyBzZWVtcyB0byBjb250cmFkaWN0IGl0 c2VsZjogSWYgaXQncyBvbmUtc2hvdCwgdGhlcmUncyBubyBuZWVkIHRvCmRpc2FibGUgaXQgLSBp dCB3aWxsIGF1dG8tZGlzYWJsZS4KCkluIG90aGVyIGNhc2VzIHdoZXJlIHdlIHdyaXRlIGEgcHJv cGVydHkgYXMgYSBvbmUtc2hvdCB0aGluZyAoZmVuY2VzIGZvcgphbmRyb2lkKS4gSW4gdGhhdCBj YXNlIHdoZW4geW91IHJlYWQgdGhhdCBwcm9wZXJ0eSBpdCdzIGFsd2F5cyAwICh3ZWxsLCAtMQpm b3IgZmVuY2VzIHNpbmNlIGZpbGUgZGVzY3JpcHRvcikuIFRoYXQgYWxzbyBhdm9pZHMgdGhlIGlz c3VlcyB3aGVuCnVzZXJzcGFjZSB1bmNvbmRpdGlvbmFsbHkgc2F2ZXMvcmVzdG9yZXMgYWxsIHBy b3BlcnRpZXMgKHRoaXMgaXMgbmVlZGVkCmZvciBnZW5lcmljIGNvbXBvc2l0b3Igc3dpdGNoaW5n KS4KCkkgdGhpbmsgYSBiZXR0ZXIgYmVoYXZpb3VyIHdvdWxkIGJlIHRvIGRvIHRoZSBzYW1lIHRy aWNrLCB3aXRoIEZCX0lEIG9uCnRoZSBjb25uZWN0b3IgYWx3YXlzIHJldHVybmluZyAwIGFzIHRo ZSBjdXJyZW50IHZhbHVlLiBUaGF0IGVuY29kZXMgdGhlCm9uZS1zaG90IGJlaGF2aW91ciBkaXJl Y3RseS4KCkZvciBvbmUtc2hvdCB2cyBjb250aW51b3VzOiBNYXliZSB3ZSB3YW50IHRvIHNpbXBs eSBoYXZlIGEgc2VwYXJhdGUKd3JpdGViYWNrIHByb3BlcnR5IGZvciBjb250aW51ZXMsIGUuZy4g RkJfV1JJVEVCQUNLX09ORV9TSE9UX0lEIGFuZApGQl9XUklURUJBQ0tfQ09OVElOVU9VU19JRC4K Cj4gS25vd24gaXNzdWVzOgo+IC0tLS0tLS0tLS0tLS0KPiAgKiBJJ20gbm90IHN1cmUgd2hhdCAi RFBNUyIgc2hvdWxkIG1lYW4gZm9yIHdyaXRlYmFjayBjb25uZWN0b3JzLgo+ICAgIEl0IGNvdWxk IGJlIHVzZWQgdG8gZGlzYWJsZSB3cml0ZWJhY2sgKGV2ZW4gd2hlbiBhIGZyYW1lYnVmZmVyIGlz Cj4gICAgYXR0YWNoZWQpLCBvciBpdCBjb3VsZCBiZSBoaWRkZW4gZW50aXJlbHkgKHdoaWNoIHdv dWxkIGJyZWFrIHRoZQo+ICAgIGxlZ2FjeSBEUE1TIGNhbGwgZm9yIHdyaXRlYmFjayBjb25uZWN0 b3JzKS4KCmRwbXMgaXMgbGVnYWN5LCBpbiBhdG9taWMgbGFuZCB0aGUgb25seSB0aGluZyB5b3Ug aGF2ZSBpcyAiQUNUSVZFIiBvbiB0aGUKY3J0Yy4gaXQgZGlzYWJsZXMgZXZlcnl0aGluZywgaS5l LiBhbHNvIHdyaXRlYmFjay4KCj4gICogV2l0aCBEYW5pZWwncyByZWNlbnQgcmUtaXRlcmF0aW9u IG9mIHRoZSB1c2Vyc3BhY2UgQVBJIHJ1bGVzLCBJCj4gICAgZnVsbHkgZXhwZWN0IHRvIHByb3Zp ZGUgc29tZSB1c2Vyc3BhY2UgY29kZSB0byBzdXBwb3J0IHRoaXMuIFRoZQo+ICAgIHF1ZXN0aW9u IGlzIHdoYXQsIGFuZCB3aGVyZT8gV2Ugd2FudCB0byB1c2Ugd3JpdGViYWNrIGZvciB0ZXN0aW5n LAo+ICAgIHNvIHBlcmhhcHMgc29tZSB0ZXN0cyBpbiBpZ3QgaXMgc3VpdGFibGUuCgpIbSwgdGVz dGluZyB3b3VsZCBiZSBiZXR0ZXIgYXMgYSBkZWJ1Z2ZzIGludGVyZmFjZSwgYnV0IEkgdW5kZXJz dGFuZCB0aGUKYXBwZWFsIG9mIGRvaW5nIHRoaXMgd2l0aCBhdG9taWMgKHNpbmNlIHNlbWFudGlj cyBmaXQgc28gd2VsbCkuIEFub3RoZXIKdXNlLWNhc2Ugb2YgdGhpcyBpcyBjb21wb3NpdGluZywg YnV0IGlmIHRoZSBtYWluIGdvYWwgaXMgaWd0IGFuZCB0ZXN0aW5nLApJIHRoaW5rIGludGVncmF0 aW9uIGludG8gaWd0IGNyYyBiYXNlZCB0ZXN0Y2FzZXMgaXMgYSBwZXJmZWN0bHkgZmluZQp1c2Vy c3BhY2UuCgo+ICAqIERvY3VtZW50YXRpb24uIFByb2JhYmx5IHNvbWUgcG9ydGlvbiBvZiB0aGlz IGNvdmVyIGxldHRlciBuZWVkcyB0bwo+ICAgIG1ha2UgaXQgaW50byBEb2N1bWVudGF0aW9uLwoK WWVhaCwgYW4gb3ZlcnZpZXcgRE9DOiBzZWN0aW9uIGluIGEgc2VwYXJhdGUgc291cmNlIGZpbGUg KHdpdGggYWxsIHRoZSB0aGUKaW5mcmFzdHJ1Y3R1cmUgd29yaykgd291bGQgYmUgZ3JlYXQgLSBh a2EgbmVlZGVkIGZyb20gbXkgcG92IDstKQoKPiAgKiBTeW5jaHJvbmlzYXRpb24uIE91ciBoYXJk d2FyZSB3aWxsIGZpbmlzaCB0aGUgd3JpdGViYWNrIGJ5IHRoZSBuZXh0Cj4gICAgdnN5bmMuIEkn dmUgbm90IGltcGxlbWVudGVkIGZlbmNlIHN1cHBvcnQgaGVyZSwgYnV0IGl0IHdvdWxkIGJlIGFu Cj4gICAgb2J2aW91cyBhZGRpdGlvbi4KClByb2JhYmx5IGp1c3Qgd2FudCBhbiBhZGRpdGlvbmFs IFdSSVRFQkFDS19GRU5DRV9JRCBwcm9wZXJ0eSB0byBzaWduYWwKY29tcGxldGlvbi4gU29tZSBo dyBkZWZpbml0ZWx5IHdpbGwgdGFrZSBsb25nZXIgdG8gd3JpdGUgYmFjayB0aGFuIGp1c3QgYQp2 YmxhbmsuIEJ1dCB3ZSBjYW4gZGVsYXkgdGhhdCB1bnRpbCBpdCdzIG5lZWRlZC4KLURhbmllbAoK PiAKPiBTZWUgQWxzbzoKPiAtLS0tLS0tLS0KPiBbMV0gaHR0cHM6Ly9saXN0cy5mcmVlZGVza3Rv cC5vcmcvYXJjaGl2ZXMvZHJpLWRldmVsLzIwMTYtSnVseS8xMTMxOTcuaHRtbAo+IFsyXSBodHRw czovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9hcmNoaXZlcy9kcmktZGV2ZWwvMjAxNi1PY3RvYmVy LzEyMDQ4Ni5odG1sCj4gCj4gSSB3ZWxjb21lIGFueSBjb21tZW50cywgZXNwZWNpYWxseSBpZiB0 aGlzIGFwcHJvYWNoIGRvZXMvZG9lc24ndCBmaXQKPiB3ZWxsIHdpdGggYW55b25lIGVsc2UncyBo YXJkd2FyZS4KPiAKPiBUaGFua3MsCj4gCj4gLUJyaWFuCj4gCj4gLS0tCj4gCj4gQnJpYW4gU3Rh cmtleSAoMTApOgo+ICAgZHJtOiBhZGQgd3JpdGViYWNrIGNvbm5lY3RvciB0eXBlCj4gICBkcm0v ZmItaGVscGVyOiBza2lwIHdyaXRlYmFjayBjb25uZWN0b3JzCj4gICBkcm06IGV4dHJhY3QgQ1JU Qy9wbGFuZSBkaXNhYmxlIGZyb20gZHJtX2ZyYW1lYnVmZmVyX3JlbW92ZQo+ICAgZHJtOiBhZGQg X19kcm1fZnJhbWVidWZmZXJfcmVtb3ZlX2F0b21pYwo+ICAgZHJtOiBhZGQgZmIgdG8gY29ubmVj dG9yIHN0YXRlCj4gICBkcm06IGV4cG9zZSBmYl9pZCBwcm9wZXJ0eSBmb3Igd3JpdGViYWNrIGNv bm5lY3RvcnMKPiAgIGRybTogYWRkIHdyaXRlYmFjay1jb25uZWN0b3IgcGl4ZWwgZm9ybWF0IHBy b3BlcnRpZXMKPiAgIGRybTogbWFsaS1kcDogcmVuYW1lIG1hbGlkcF9pbnB1dF9mb3JtYXQKPiAg IGRybTogbWFsaS1kcDogYWRkIFJHQiB3cml0ZWJhY2sgZm9ybWF0cyBmb3IgRFA1NTAvRFA2NTAK PiAgIGRybTogbWFsaS1kcDogYWRkIHdyaXRlYmFjayBjb25uZWN0b3IKPiAKPiBMaXZpdSBEdWRh dSAoMSk6Cj4gICBkcm06IG1hbGktZHA6IEFkZCBzdXBwb3J0IGZvciB3cml0ZWJhY2sgb24gRFA1 NTAvRFA2NTAKPiAKPiAgZHJpdmVycy9ncHUvZHJtL2FybS9NYWtlZmlsZSAgICAgICAgfCAgICAx ICsKPiAgZHJpdmVycy9ncHUvZHJtL2FybS9tYWxpZHBfY3J0Yy5jICAgfCAgIDEwICsrCj4gIGRy aXZlcnMvZ3B1L2RybS9hcm0vbWFsaWRwX2Rydi5jICAgIHwgICAyNSArKystCj4gIGRyaXZlcnMv Z3B1L2RybS9hcm0vbWFsaWRwX2Rydi5oICAgIHwgICAgNSArCj4gIGRyaXZlcnMvZ3B1L2RybS9h cm0vbWFsaWRwX2h3LmMgICAgIHwgIDEwNCArKysrKysrKysrLS0tLQo+ICBkcml2ZXJzL2dwdS9k cm0vYXJtL21hbGlkcF9ody5oICAgICB8ICAgMjcgKysrLQo+ICBkcml2ZXJzL2dwdS9kcm0vYXJt L21hbGlkcF9tdy5jICAgICB8ICAyNjggKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysKPiAgZHJpdmVycy9ncHUvZHJtL2FybS9tYWxpZHBfcGxhbmVzLmMgfCAgICA4ICstCj4gIGRy aXZlcnMvZ3B1L2RybS9hcm0vbWFsaWRwX3JlZ3MuaCAgIHwgICAxNSArKwo+ICBkcml2ZXJzL2dw dS9kcm0vZHJtX2F0b21pYy5jICAgICAgICB8ICAgNDAgKysrKysrCj4gIGRyaXZlcnMvZ3B1L2Ry bS9kcm1fYXRvbWljX2hlbHBlci5jIHwgICAgNCArCj4gIGRyaXZlcnMvZ3B1L2RybS9kcm1fY29u bmVjdG9yLmMgICAgIHwgICA3OSArKysrKysrKysrLQo+ICBkcml2ZXJzL2dwdS9kcm0vZHJtX2Ny dGMuYyAgICAgICAgICB8ICAgMTQgKy0KPiAgZHJpdmVycy9ncHUvZHJtL2RybV9mYl9oZWxwZXIu YyAgICAgfCAgICA0ICsKPiAgZHJpdmVycy9ncHUvZHJtL2RybV9mcmFtZWJ1ZmZlci5jICAgfCAg MjQ5ICsrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9k cm1faW9jdGwuYyAgICAgICAgIHwgICAgNyArCj4gIGluY2x1ZGUvZHJtL2RybVAuaCAgICAgICAg ICAgICAgICAgIHwgICAgMiArCj4gIGluY2x1ZGUvZHJtL2RybV9hdG9taWMuaCAgICAgICAgICAg IHwgICAgMyArCj4gIGluY2x1ZGUvZHJtL2RybV9jb25uZWN0b3IuaCAgICAgICAgIHwgICAxNSAr Kwo+ICBpbmNsdWRlL2RybS9kcm1fY3J0Yy5oICAgICAgICAgICAgICB8ICAgMTIgKysKPiAgaW5j bHVkZS91YXBpL2RybS9kcm0uaCAgICAgICAgICAgICAgfCAgIDEwICsrCj4gIGluY2x1ZGUvdWFw aS9kcm0vZHJtX21vZGUuaCAgICAgICAgIHwgICAgMSArCj4gIDIyIGZpbGVzIGNoYW5nZWQsIDgz MCBpbnNlcnRpb25zKCspLCA3MyBkZWxldGlvbnMoLSkKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRy aXZlcnMvZ3B1L2RybS9hcm0vbWFsaWRwX213LmMKPiAKPiAtLSAKPiAxLjcuOS41Cj4gCgotLSAK RGFuaWVsIFZldHRlcgpTb2Z0d2FyZSBFbmdpbmVlciwgSW50ZWwgQ29ycG9yYXRpb24KaHR0cDov L2Jsb2cuZmZ3bGwuY2gKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRl dmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-lf0-f67.google.com ([209.85.215.67]:34647 "EHLO mail-lf0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752185AbcJKPou (ORCPT ); Tue, 11 Oct 2016 11:44:50 -0400 Received: by mail-lf0-f67.google.com with SMTP id p80so4431006lfp.1 for ; Tue, 11 Oct 2016 08:44:04 -0700 (PDT) Date: Tue, 11 Oct 2016 17:43:59 +0200 From: Daniel Vetter To: Brian Starkey Cc: dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, linux-media@vger.kernel.org, liviu.dudau@arm.com, robdclark@gmail.com, hverkuil@xs4all.nl, eric@anholt.net, ville.syrjala@linux.intel.com, daniel@ffwll.ch Subject: Re: [RFC PATCH 00/11] Introduce writeback connectors Message-ID: <20161011154359.GD20761@phenom.ffwll.local> References: <1476197648-24918-1-git-send-email-brian.starkey@arm.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1476197648-24918-1-git-send-email-brian.starkey@arm.com> Sender: linux-media-owner@vger.kernel.org List-ID: On Tue, Oct 11, 2016 at 03:53:57PM +0100, Brian Starkey wrote: > Hi, > > This RFC series introduces a new connector type: > DRM_MODE_CONNECTOR_WRITEBACK > It is a follow-on from a previous discussion: [1] > > Writeback connectors are used to expose the memory writeback engines > found in some display controllers, which can write a CRTC's > composition result to a memory buffer. > This is useful e.g. for testing, screen-recording, screenshots, > wireless display, display cloning, memory-to-memory composition. > > Patches 1-7 include the core framework changes required, and patches > 8-11 implement a writeback connector for the Mali-DP writeback engine. > The Mali-DP patches depend on this other series: [2]. > > The connector is given the FB_ID property for the output framebuffer, > and two new read-only properties: PIXEL_FORMATS and > PIXEL_FORMATS_SIZE, which expose the supported framebuffer pixel > formats of the engine. > > The EDID property is not exposed for writeback connectors. > > Writeback connector usage: > -------------------------- > Due to connector routing changes being treated as "full modeset" > operations, any client which wishes to use a writeback connector > should include the connector in every modeset. The writeback will not > actually become active until a framebuffer is attached. Erhm, this is just the default, drivers can override this. And we could change the atomic helpers to not mark a modeset as a modeset if the connector that changed is a writeback one. > The writeback itself is enabled by attaching a framebuffer to the > FB_ID property of the connector. The driver must then ensure that the > CRTC content of that atomic commit is written into the framebuffer. > > The writeback works in a one-shot mode with each atomic commit. This > prevents the same content from being written multiple times. > In some cases (front-buffer rendering) there might be a desire for > continuous operation - I think a property could be added later for > this kind of control. > > Writeback can be disabled by setting FB_ID to zero. This seems to contradict itself: If it's one-shot, there's no need to disable it - it will auto-disable. In other cases where we write a property as a one-shot thing (fences for android). In that case when you read that property it's always 0 (well, -1 for fences since file descriptor). That also avoids the issues when userspace unconditionally saves/restores all properties (this is needed for generic compositor switching). I think a better behaviour would be to do the same trick, with FB_ID on the connector always returning 0 as the current value. That encodes the one-shot behaviour directly. For one-shot vs continuous: Maybe we want to simply have a separate writeback property for continues, e.g. FB_WRITEBACK_ONE_SHOT_ID and FB_WRITEBACK_CONTINUOUS_ID. > Known issues: > ------------- > * I'm not sure what "DPMS" should mean for writeback connectors. > It could be used to disable writeback (even when a framebuffer is > attached), or it could be hidden entirely (which would break the > legacy DPMS call for writeback connectors). dpms is legacy, in atomic land the only thing you have is "ACTIVE" on the crtc. it disables everything, i.e. also writeback. > * With Daniel's recent re-iteration of the userspace API rules, I > fully expect to provide some userspace code to support this. The > question is what, and where? We want to use writeback for testing, > so perhaps some tests in igt is suitable. Hm, testing would be better as a debugfs interface, but I understand the appeal of doing this with atomic (since semantics fit so well). Another use-case of this is compositing, but if the main goal is igt and testing, I think integration into igt crc based testcases is a perfectly fine userspace. > * Documentation. Probably some portion of this cover letter needs to > make it into Documentation/ Yeah, an overview DOC: section in a separate source file (with all the the infrastructure work) would be great - aka needed from my pov ;-) > * Synchronisation. Our hardware will finish the writeback by the next > vsync. I've not implemented fence support here, but it would be an > obvious addition. Probably just want an additional WRITEBACK_FENCE_ID property to signal completion. Some hw definitely will take longer to write back than just a vblank. But we can delay that until it's needed. -Daniel > > See Also: > --------- > [1] https://lists.freedesktop.org/archives/dri-devel/2016-July/113197.html > [2] https://lists.freedesktop.org/archives/dri-devel/2016-October/120486.html > > I welcome any comments, especially if this approach does/doesn't fit > well with anyone else's hardware. > > Thanks, > > -Brian > > --- > > Brian Starkey (10): > drm: add writeback connector type > drm/fb-helper: skip writeback connectors > drm: extract CRTC/plane disable from drm_framebuffer_remove > drm: add __drm_framebuffer_remove_atomic > drm: add fb to connector state > drm: expose fb_id property for writeback connectors > drm: add writeback-connector pixel format properties > drm: mali-dp: rename malidp_input_format > drm: mali-dp: add RGB writeback formats for DP550/DP650 > drm: mali-dp: add writeback connector > > Liviu Dudau (1): > drm: mali-dp: Add support for writeback on DP550/DP650 > > drivers/gpu/drm/arm/Makefile | 1 + > drivers/gpu/drm/arm/malidp_crtc.c | 10 ++ > drivers/gpu/drm/arm/malidp_drv.c | 25 +++- > drivers/gpu/drm/arm/malidp_drv.h | 5 + > drivers/gpu/drm/arm/malidp_hw.c | 104 ++++++++++---- > drivers/gpu/drm/arm/malidp_hw.h | 27 +++- > drivers/gpu/drm/arm/malidp_mw.c | 268 +++++++++++++++++++++++++++++++++++ > drivers/gpu/drm/arm/malidp_planes.c | 8 +- > drivers/gpu/drm/arm/malidp_regs.h | 15 ++ > drivers/gpu/drm/drm_atomic.c | 40 ++++++ > drivers/gpu/drm/drm_atomic_helper.c | 4 + > drivers/gpu/drm/drm_connector.c | 79 ++++++++++- > drivers/gpu/drm/drm_crtc.c | 14 +- > drivers/gpu/drm/drm_fb_helper.c | 4 + > drivers/gpu/drm/drm_framebuffer.c | 249 ++++++++++++++++++++++++++++---- > drivers/gpu/drm/drm_ioctl.c | 7 + > include/drm/drmP.h | 2 + > include/drm/drm_atomic.h | 3 + > include/drm/drm_connector.h | 15 ++ > include/drm/drm_crtc.h | 12 ++ > include/uapi/drm/drm.h | 10 ++ > include/uapi/drm/drm_mode.h | 1 + > 22 files changed, 830 insertions(+), 73 deletions(-) > create mode 100644 drivers/gpu/drm/arm/malidp_mw.c > > -- > 1.7.9.5 > -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch