From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH 3/3] drm: Add CRTC_GET_SEQUENCE and CRTC_QUEUE_SEQUENCE ioctls Date: Thu, 6 Jul 2017 13:16:04 +0300 Message-ID: <20170706101604.GY12629@intel.com> References: <20170705221013.27940-1-keithp@keithp.com> <20170705221013.27940-4-keithp@keithp.com> <20170706075313.bn2exiklfabgc25t@phenom.ffwll.local> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mga06.intel.com (mga06.intel.com [134.134.136.31]) by gabe.freedesktop.org (Postfix) with ESMTPS id 042CD6E00F for ; Thu, 6 Jul 2017 10:16:08 +0000 (UTC) Content-Disposition: inline In-Reply-To: <20170706075313.bn2exiklfabgc25t@phenom.ffwll.local> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Keith Packard , linux-kernel@vger.kernel.org, Dave Airlie , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org T24gVGh1LCBKdWwgMDYsIDIwMTcgYXQgMDk6NTM6MTNBTSArMDIwMCwgRGFuaWVsIFZldHRlciB3 cm90ZToKPiBPbiBXZWQsIEp1bCAwNSwgMjAxNyBhdCAwMzoxMDoxM1BNIC0wNzAwLCBLZWl0aCBQ YWNrYXJkIHdyb3RlOgo+ID4gVGhlc2UgcHJvdmlkZSBjcnRjLWlkIGJhc2VkIGZ1bmN0aW9ucyBp bnN0ZWFkIG9mIHBpcGUtbnVtYmVyLCB3aGlsZQo+ID4gYWxzbyBvZmZlcmluZyBoaWdoZXIgcmVz b2x1dGlvbiB0aW1lIChucykgYW5kIHdpZGVyIGZyYW1lIGNvdW50ICg2NCkKPiA+IGFzIHJlcXVp cmVkIGJ5IHRoZSBWdWxrYW4gQVBJLgo+ID4gCj4gPiBTaWduZWQtb2ZmLWJ5OiBLZWl0aCBQYWNr YXJkIDxrZWl0aHBAa2VpdGhwLmNvbT4KPiAKPiBJIHZlcnkgbXVjaCBsaWtlIHRoaXMgc2luY2Ug dGhlIG9sZCBpb2N0bCByZWFsbHkgaXMgYSByYXRoZXIgYmFkIGhvcnJvcgo+IHNob3cuIEFuZCBz aW5jZSBpdCdzIHRpZWQgaW4gd2l0aCB1bXMgZHJpdmVycyBldmVyeXRoaW5nIGlzIGNvbXBsaWNh dGVkLgo+IAo+IFxvLyBmb3IgbXVjaCBjbGVhbmVyIGlvY3Rscy4KPiAKPiBCdW5jaCBvZiBjb21t ZW50cyBiZWxvdywgYnV0IGxvb2tzIGdvb2Qgb3ZlcmFsbC4KPiAtRGFuaWVsCj4gCj4gPiAtLS0K PiA+ICBkcml2ZXJzL2dwdS9kcm0vZHJtX2ludGVybmFsLmggfCAgIDYgKysKPiA+ICBkcml2ZXJz L2dwdS9kcm0vZHJtX2lvY3RsLmMgICAgfCAgIDIgKwo+ID4gIGRyaXZlcnMvZ3B1L2RybS9kcm1f dmJsYW5rLmMgICB8IDE0OCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr Kwo+ID4gIGluY2x1ZGUvZHJtL2RybV92YmxhbmsuaCAgICAgICB8ICAgMSArCj4gPiAgaW5jbHVk ZS91YXBpL2RybS9kcm0uaCAgICAgICAgIHwgIDMyICsrKysrKysrKwo+ID4gIDUgZmlsZXMgY2hh bmdlZCwgMTg5IGluc2VydGlvbnMoKykKPiA+IAo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9kcm1faW50ZXJuYWwuaCBiL2RyaXZlcnMvZ3B1L2RybS9kcm1faW50ZXJuYWwuaAo+ID4g aW5kZXggNWNlY2M5NzRkMmY5Li5iNjhhMTkzYjc5MDcgMTAwNjQ0Cj4gPiAtLS0gYS9kcml2ZXJz L2dwdS9kcm0vZHJtX2ludGVybmFsLmgKPiA+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1faW50 ZXJuYWwuaAo+ID4gQEAgLTY1LDYgKzY1LDEyIEBAIGludCBkcm1fbGVnYWN5X2lycV9jb250cm9s KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCj4gPiAgaW50IGRybV9sZWdhY3lf bW9kZXNldF9jdGwoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgdm9pZCAqZGF0YSwKPiA+ICAJCQkg ICBzdHJ1Y3QgZHJtX2ZpbGUgKmZpbGVfcHJpdik7Cj4gPiAgCj4gPiAraW50IGRybV9jcnRjX2dl dF9zZXF1ZW5jZV9pb2N0bChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2b2lkICpkYXRhLAo+ID4g KwkJCQlzdHJ1Y3QgZHJtX2ZpbGUgKmZpbHApOwo+ID4gKwo+ID4gK2ludCBkcm1fY3J0Y19xdWV1 ZV9zZXF1ZW5jZV9pb2N0bChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2b2lkICpkYXRhLAo+ID4g KwkJCQkgIHN0cnVjdCBkcm1fZmlsZSAqZmlscCk7Cj4gPiArCj4gPiAgLyogZHJtX2F1dGguYyAq Lwo+ID4gIGludCBkcm1fZ2V0bWFnaWMoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgdm9pZCAqZGF0 YSwKPiA+ICAJCSBzdHJ1Y3QgZHJtX2ZpbGUgKmZpbGVfcHJpdik7Cj4gPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2RybV9pb2N0bC5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9pb2N0bC5j Cj4gPiBpbmRleCBmMWU1NjgxNzZkYTkuLjYzMDE2Y2YzZTIyNCAxMDA2NDQKPiA+IC0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9kcm1faW9jdGwuYwo+ID4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9p b2N0bC5jCj4gPiBAQCAtNjU3LDYgKzY1Nyw4IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2lv Y3RsX2Rlc2MgZHJtX2lvY3Rsc1tdID0gewo+ID4gIAkJICAgICAgRFJNX1VOTE9DS0VEfERSTV9S RU5ERVJfQUxMT1cpLAo+ID4gIAlEUk1fSU9DVExfREVGKERSTV9JT0NUTF9TWU5DT0JKX0ZEX1RP X0hBTkRMRSwgZHJtX3N5bmNvYmpfZmRfdG9faGFuZGxlX2lvY3RsLAo+ID4gIAkJICAgICAgRFJN X1VOTE9DS0VEfERSTV9SRU5ERVJfQUxMT1cpLAo+ID4gKwlEUk1fSU9DVExfREVGKERSTV9JT0NU TF9DUlRDX0dFVF9TRVFVRU5DRSwgZHJtX2NydGNfZ2V0X3NlcXVlbmNlX2lvY3RsLCBEUk1fVU5M T0NLRUQpLAo+ID4gKwlEUk1fSU9DVExfREVGKERSTV9JT0NUTF9DUlRDX1FVRVVFX1NFUVVFTkNF LCBkcm1fY3J0Y19xdWV1ZV9zZXF1ZW5jZV9pb2N0bCwgRFJNX1VOTE9DS0VEKSwKPiAKPiBJIHN0 YXJ0ZWQgYSBkaXNjdXNzaW9uIGEgd2hpbGUgYmFjayB3aGV0aGVyIHRoZXNlIHNob3VsZCBiZSBy ZXN0cmljdGVkIHRvCj4gRFJNX01BU1RFUiAoaS5lLiB0aGUgbW9kZXNldCByZXNvdXJjZSBvd25l cikgb3IgYXZhaWxhYmxlIHRvIGV2ZXJ5b25lLgo+IFNpbmNlIGl0J3MgcmVhZC1vbmx5IEkgZ3Vl c3Mgd2UgY2FuIGtlZXAgaXQgYWNjZXNzaWJsZSB0byBldmVyeW9uZSwgYnV0IGl0Cj4gaGFzIGEg Yml0IHRoZSBwcm9ibGVtIHRoYXQgY2xpZW50IGFwcCBkZXZlbG9wZXJzIHNlZSB0aGlzLCB0aGlu ayBpdCBkb2VzCj4gd2hhdCBpdCBkb2VzIGFuZCB0aGVuIHVzZSBpdCB0byBzY2hlZHVsZSBmcmFt ZXMgd2l0aG91dCBhc2tpbmcgdGhlCj4gY29tcG9zaXRvci4gV2hpY2ggc29tZXRpbWVzIGV2ZW4g d29ya3MsIGJ1dCBpc24ndCByZWFsbHkgcHJvcGVyIGRlc2lnbi4KPiBUaGUgcmVhc29ucyBzZWVt cyB0byBiZSB0aGF0IG9uIFgxMSB0aGVyZSdzIG5vIEVHTCBleHRlbnNpb24gZm9yIGFjY3VyYXRl Cj4gdGltaW5nIGZyYW1lIHVwZGF0ZXMgKERSSTIvMyBjYW4gZG8gaXQgb2ZjLCBhbmQgZ2x4IGV4 cG9zZXMgaXQsIGJ1dCBnbHggaXMKPiB1bmNvb2wgb3Igc29tZXRoaW5nIGxpa2UgdGhhdCkuCj4g Cj4gPiAgfTsKPiA+ICAKPiA+ICAjZGVmaW5lIERSTV9DT1JFX0lPQ1RMX0NPVU5UCUFSUkFZX1NJ WkUoIGRybV9pb2N0bHMgKQo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fdmJs YW5rLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX3ZibGFuay5jCj4gPiBpbmRleCA5YWUxNzA4NTdl ZjYuLjkzMDA0YjFiZjg0YyAxMDA2NDQKPiA+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fdmJs YW5rLmMKPiA+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fdmJsYW5rLmMKPiA+IEBAIC04MTcs NiArODE3LDEyIEBAIHN0YXRpYyB2b2lkIHNlbmRfdmJsYW5rX2V2ZW50KHN0cnVjdCBkcm1fZGV2 aWNlICpkZXYsCj4gPiAgCQkJZS0+ZXZlbnQudmJsLnR2X3VzZWMgPSBub3ctPnR2X25zZWMgLyAx MDAwOwo+ID4gIAkJfQo+ID4gIAkJYnJlYWs7Cj4gPiArCWNhc2UgRFJNX0VWRU5UX0NSVENfU0VR VUVOQ0U6Cj4gPiArCQlpZiAoc2VxKQo+ID4gKwkJCWUtPmV2ZW50LnNlcS5zZXF1ZW5jZSA9IHNl cTsKPiA+ICsJCWlmIChub3cpCj4gPiArCQkJZS0+ZXZlbnQuc2VxLnRpbWVfbnMgPSB0aW1lc3Bl Y190b19ucyhub3cpOwo+ID4gKwkJYnJlYWs7Cj4gPiAgCX0KPiA+ICAJdHJhY2VfZHJtX3ZibGFu a19ldmVudF9kZWxpdmVyZWQoZS0+YmFzZS5maWxlX3ByaXYsIGUtPnBpcGUsIHNlcSk7Cj4gPiAg CWRybV9zZW5kX2V2ZW50X2xvY2tlZChkZXYsICZlLT5iYXNlKTsKPiA+IEBAIC0xNTE2LDYgKzE1 MjIsNyBAQCBpbnQgZHJtX3dhaXRfdmJsYW5rKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHZvaWQg KmRhdGEsCj4gPiAgCQlEUk1fREVCVUcoImNydGMgJWQgZmFpbGVkIHRvIGFjcXVpcmUgdmJsYW5r IGNvdW50ZXIsICVkXG4iLCBwaXBlLCByZXQpOwo+ID4gIAkJcmV0dXJuIHJldDsKPiA+ICAJfQo+ ID4gKwo+ID4gIAlzZXEgPSBkcm1fdmJsYW5rX2NvdW50KGRldiwgcGlwZSk7Cj4gPiAgCj4gPiAg CXN3aXRjaCAodmJsd2FpdC0+cmVxdWVzdC50eXBlICYgX0RSTV9WQkxBTktfVFlQRVNfTUFTSykg ewo+ID4gQEAgLTE2NzYsMyArMTY4MywxNDQgQEAgYm9vbCBkcm1fY3J0Y19oYW5kbGVfdmJsYW5r KHN0cnVjdCBkcm1fY3J0YyAqY3J0YykKPiA+ICAJcmV0dXJuIGRybV9oYW5kbGVfdmJsYW5rKGNy dGMtPmRldiwgZHJtX2NydGNfaW5kZXgoY3J0YykpOwo+ID4gIH0KPiA+ICBFWFBPUlRfU1lNQk9M KGRybV9jcnRjX2hhbmRsZV92YmxhbmspOwo+ID4gKwo+ID4gKy8qCj4gPiArICogR2V0IGNydGMg VkJMQU5LIGNvdW50Lgo+ID4gKyAqCj4gPiArICogXHBhcmFtIGRldiBEUk0gZGV2aWNlCj4gPiAr ICogXHBhcmFtIGRhdGEgdXNlciBhcmd1ZW1lbnQsIHBvaW50aW5nIHRvIGEgZHJtX2NydGNfZ2V0 X3NlcXVlbmNlIHN0cnVjdHVyZS4KPiA+ICsgKiBccGFyYW0gZmlsZV9wcml2IGRybSBmaWxlIHBy aXZhdGUgZm9yIHRoZSB1c2VyJ3Mgb3BlbiBmaWxlIGRlc2NyaXB0b3IKPiA+ICsgKi8KPiAKPiBT aW5jZSB0aGlzIHN0dWZmIGlzbid0IHBhcnNlZCBieSBrZXJuZWxkb2MgSSB0ZW5kIHRvIGp1c3Qg ZnJlZS1mb3JtIGlvY3RsCj4gY29tbWVudHMgY29tcGxldGVseS4gU29tZWRheSBtYXliZSBzb21l b25lIGV2ZW4gZ2V0cyBhcm91bmQgdG8gZG9pbmcKPiBwcm9wZXIgdWFiaSBkb2N1bWVudGF0aW9u IDotKSBKdXN0IGFuIGFzaWRlLgo+ID4gKwo+ID4gK2ludCBkcm1fY3J0Y19nZXRfc2VxdWVuY2Vf aW9jdGwoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgdm9pZCAqZGF0YSwKPiA+ICsJCQkJc3RydWN0 IGRybV9maWxlICpmaWxlX3ByaXYpCj4gPiArewo+ID4gKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGM7 Cj4gPiArCWludCBwaXBlOwo+ID4gKwlzdHJ1Y3QgZHJtX2NydGNfZ2V0X3NlcXVlbmNlICpnZXRf c2VxID0gZGF0YTsKPiA+ICsJc3RydWN0IHRpbWVzcGVjIG5vdzsKPiA+ICsKPiAKPiBZb3UgbmVl ZCBhIERSSVZFUl9NT0RFU0VUIGNoZWNrIGhlcmUgb3IgdGhlIGRybV9jcnRjX2ZpbmQgd2lsbCBv b3BzLiBTYW1lCj4gYmVsb3cuCj4gCj4gPiArCWlmICghZGV2LT5pcnFfZW5hYmxlZCkKPiA+ICsJ CXJldHVybiAtRUlOVkFMOwo+ID4gKwo+ID4gKwljcnRjID0gZHJtX2NydGNfZmluZChkZXYsIGdl dF9zZXEtPmNydGNfaWQpOwo+ID4gKwlpZiAoIWNydGMpCj4gPiArCQlyZXR1cm4gLUVOT0VOVDsK PiA+ICsKPiA+ICsJcGlwZSA9IGRybV9jcnRjX2luZGV4KGNydGMpOwo+ID4gKwo+ID4gKwlnZXRf c2VxLT5zZXF1ZW5jZSA9IGRybV92YmxhbmtfY291bnRfYW5kX3RpbWUoZGV2LCBwaXBlLCAmbm93 KTsKPiAKPiBUaGlzIGNhbiBnaXZlIHlvdSBhbmQgb2xkIHZibGFuayBpZiB0aGUgdmJsYW5rIGlz IG9mZiAoaS5lLiBzdyBzdGF0ZQo+IGhhc24ndCBiZSByZWd1bGFybHkgdXBkYXRlZCkuIEkgdGhp bmsgd2Ugd2FudCBhIG5ldwo+IGRybV9jcnRjX2FjY3VyYXRlX3ZibGFua19jb3VudF9hbmRfdGlt ZSB2YXJpYW50LgoKT3IgYmV0dGVyIHlldCBqdXN0IGRvIHdoYXQgQ2hyaXMgZGlkIGZvciB0aGUg b2xkIGlvY3RsIGluIGNvbW1pdApiMzNiMDI3MDdiYTMgKCJkcm06IFBlZWsgYXQgdGhlIGN1cnJl bnQgY291bnRlci90aW1lc3RhbXAgZm9yIHZibGFuayBxdWVyaWVzIikKCj4gCj4gQW5vdGhlciB0 aGluZyB0aGF0IGlzIHZlcnkgaWxsLWRlZmluZWQgaW4gdGhlIG9sZCB2YmxhbmsgaW9jdGwgYW5k IHRoYXQgd2UKPiBjb3VsZCBmaXggaGVyZTogQXNraW5nIGZvciB2YmxhbmtzIHdoZW4gdGhlIENS VEMgaXMgb2ZmIGlzIGEgYml0IHNpbGx5Lgo+IEFza2luZyBmb3IgdGhlIHNlcXVlbmNlIHdoZW4g aXQncyBvZmYgbWFrZXMgc29tZSBzZW5zZSwgYnV0IG1pZ2h0IHN0aWxsIGJlCj4gZ29vZCB0byBn aXZlIHVzZXJzcGFjZSBzb21lIGluZGljYXRpb24gaW4gdGhlIG5ldyBzdHJ1Y3Q/IFRoaXMgYWxz byBmcm9tCj4gdGhlIHBvdiBvZiB0aGUgdW5wcml2aWxlZGdlIHZibGFuayB3YWl0ZXIgdXNlLWNh c2UgdGhhdCBJIHdvbmRlcmVkIGFib3V0Cj4gZWFybGllci4KPiAKPiA+ICsJZ2V0X3NlcS0+c2Vx dWVuY2VfbnMgPSB0aW1lc3BlY190b19ucygmbm93KTsKPiA+ICsJcmV0dXJuIDA7Cj4gPiArfQo+ ID4gKwo+ID4gKy8qCj4gPiArICogUXVldWUgYSBldmVudCBmb3IgVkJMQU5LIHNlcXVlbmNlCj4g PiArICoKPiA+ICsgKiBccGFyYW0gZGV2IERSTSBkZXZpY2UKPiA+ICsgKiBccGFyYW0gZGF0YSB1 c2VyIGFyZ3VlbWVudCwgcG9pbnRpbmcgdG8gYSBkcm1fY3J0Y19xdWV1ZV9zZXF1ZW5jZSBzdHJ1 Y3R1cmUuCj4gPiArICogXHBhcmFtIGZpbGVfcHJpdiBkcm0gZmlsZSBwcml2YXRlIGZvciB0aGUg dXNlcidzIG9wZW4gZmlsZSBkZXNjcmlwdG9yCj4gPiArICovCj4gPiArCj4gPiAraW50IGRybV9j cnRjX3F1ZXVlX3NlcXVlbmNlX2lvY3RsKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHZvaWQgKmRh dGEsCj4gPiArCQkJCSAgc3RydWN0IGRybV9maWxlICpmaWxlX3ByaXYpCj4gPiArewo+ID4gKwlz dHJ1Y3QgZHJtX2NydGMgKmNydGM7Cj4gPiArCXN0cnVjdCBkcm1fdmJsYW5rX2NydGMgKnZibGFu azsKPiA+ICsJaW50IHBpcGU7Cj4gPiArCXN0cnVjdCBkcm1fY3J0Y19xdWV1ZV9zZXF1ZW5jZSAq cXVldWVfc2VxID0gZGF0YTsKPiA+ICsJc3RydWN0IHRpbWVzcGVjIG5vdzsKPiA+ICsJc3RydWN0 IGRybV9wZW5kaW5nX3ZibGFua19ldmVudCAqZTsKPiA+ICsJdTMyIGZsYWdzOwo+ID4gKwl1NjQg c2VxOwo+ID4gKwl1NjQgcmVxX3NlcTsKPiA+ICsJaW50IHJldDsKPiA+ICsJdW5zaWduZWQgbG9u ZyBzcGluX2ZsYWdzOwo+ID4gKwo+ID4gKwlpZiAoIWRldi0+aXJxX2VuYWJsZWQpCj4gPiArCQly ZXR1cm4gLUVJTlZBTDsKPiA+ICsKPiA+ICsJY3J0YyA9IGRybV9jcnRjX2ZpbmQoZGV2LCBxdWV1 ZV9zZXEtPmNydGNfaWQpOwo+ID4gKwlpZiAoIWNydGMpCj4gPiArCQlyZXR1cm4gLUVOT0VOVDsK PiA+ICsKPiA+ICsJZmxhZ3MgPSBxdWV1ZV9zZXEtPmZsYWdzOwo+ID4gKwkvKiBDaGVjayB2YWxp ZCBmbGFnIGJpdHMgKi8KPiA+ICsJaWYgKGZsYWdzICYgfihEUk1fQ1JUQ19TRVFVRU5DRV9SRUxB VElWRXwKPiA+ICsJCSAgICAgIERSTV9DUlRDX1NFUVVFTkNFX05FWFRfT05fTUlTU3wKPiA+ICsJ CSAgICAgIERSTV9DUlRDX1NFUVVFTkNFX0ZJUlNUX1BJWEVMX09VVCkpCj4gPiArCQlyZXR1cm4g LUVJTlZBTDsKPiA+ICsKPiA+ICsJLyogQ2hlY2sgZm9yIHZhbGlkIHNpZ25hbCBlZGdlICovCj4g PiArCWlmICghKGZsYWdzICYgRFJNX0NSVENfU0VRVUVOQ0VfRklSU1RfUElYRUxfT1VUKSkKPiA+ ICsJCXJldHVybiAtRUlOVkFMOwo+IAo+IFRoaXMgc2VlbXMgbmV3LCBtYXliZSBkcm9wIGl0IHVu dGlsIHdlIG5lZWQgaXQ/Cj4gCj4gPiArCj4gPiArCXBpcGUgPSBkcm1fY3J0Y19pbmRleChjcnRj KTsKPiA+ICsKPiA+ICsJdmJsYW5rID0gJmRldi0+dmJsYW5rW3BpcGVdOwo+ID4gKwo+ID4gKwll ID0ga3phbGxvYyhzaXplb2YoKmUpLCBHRlBfS0VSTkVMKTsKPiA+ICsJaWYgKGUgPT0gTlVMTCkK PiA+ICsJCXJldHVybiAtRU5PTUVNOwo+ID4gKwo+ID4gKwlyZXQgPSBkcm1fdmJsYW5rX2dldChk ZXYsIHBpcGUpOwo+IAo+IGRybV9jcnRjX3ZibGFua19nZXQgcGxzLCB3b3VsZCBiZSBzd2VldCBp ZiB3ZSBjYW4gYXZvaWQgdGhlIChkZXYsIHBpcGUpCj4gcGFpcnMgYXMgbXVjaCBhcyBwb3NzaWJs ZS4gU2FtZSBmb3IgYWxsIHRoZSBvdGhlcnMuCj4gCj4gPiArCWlmIChyZXQpIHsKPiA+ICsJCURS TV9ERUJVRygiY3J0YyAlZCBmYWlsZWQgdG8gYWNxdWlyZSB2YmxhbmsgY291bnRlciwgJWRcbiIs IHBpcGUsIHJldCk7Cj4gPiArCQlnb3RvIGVycl9mcmVlOwo+ID4gKwl9Cj4gPiArCj4gPiArCXNl cSA9IGRybV92YmxhbmtfY291bnRfYW5kX3RpbWUoZGV2LCBwaXBlLCAmbm93KTsKPiAKPiBJIHRo aW5rIGhlcmUgdGhlcmUncyBubyBuZWVkIGZvciB0aGUgYWNjdXJhdGUgdmVyc2lvbiwgc2luY2Ug d2UKPiBmb3JjZS1lbmFibGUgdGhlIHZibGFua3MgYWxyZWFkeS4KPiAKPiA+ICsJcmVxX3NlcSA9 IHF1ZXVlX3NlcS0+c2VxdWVuY2U7Cj4gPiArCj4gPiArCWlmIChmbGFncyAmIERSTV9DUlRDX1NF UVVFTkNFX1JFTEFUSVZFKQo+ID4gKwkJcmVxX3NlcSArPSBzZXE7Cj4gPiArCj4gPiArCWlmICgo ZmxhZ3MgJiBEUk1fQ1JUQ19TRVFVRU5DRV9ORVhUX09OX01JU1MpICYmIHZibGFua19wYXNzZWQo c2VxLCByZXFfc2VxKSkKPiA+ICsJCXJlcV9zZXEgPSBzZXEgKyAxOwo+ID4gKwo+ID4gKwllLT5w aXBlID0gcGlwZTsKPiA+ICsJZS0+ZXZlbnQuYmFzZS50eXBlID0gRFJNX0VWRU5UX0NSVENfU0VR VUVOQ0U7Cj4gPiArCWUtPmV2ZW50LmJhc2UubGVuZ3RoID0gc2l6ZW9mKGUtPmV2ZW50LnNlcSk7 Cj4gPiArCWUtPmV2ZW50LnNlcS51c2VyX2RhdGEgPSBxdWV1ZV9zZXEtPnVzZXJfZGF0YTsKPiAK PiBObyBuZWVkIGZvciBjcnRjX2lkIGluIHRoaXMgZXZlbnQ/IE9yIGRvIHdlIGV4cGVjdCB1c2Vy c3BhY2UgdG8gZW5jb2RlCj4gdGhhdCBpbiB0aGUgdXNlcl9kYXRhIHNvbWVob3c/IEkgZG9uJ3Qg dGhpbmsgaXQncyBhIHJlYWwgcHJvYmxlbSBzaW5jZQo+IHdlJ2xsIG9ubHkgZGVsaXZlciBvbmUg ZXZlbnQgcGVyIHJlcXVlc3QsIHNvIGNsZWFyIGZvciB3aGljaCBjcnRjIGl0IGlzLgo+IEluIGF0 b21pYyB3ZSBtaWdodCBkZWxpdmVyIG11bHRpcGxlIGV2ZW50cyAob25lIGZvciBlYWNoIGNydGMp IHNvIHRoYXQncwo+IHdoeSBpdCdzIG5lZWRlZCB0aGVyZS4KPiAKPiBCdXQgbWlnaHQgYmUgdXNl ZnVsIGp1c3QgZm9yIGNvbnNpc3RlbmN5Lgo+IAo+ID4gKwo+ID4gKwlzcGluX2xvY2tfaXJxc2F2 ZSgmZGV2LT5ldmVudF9sb2NrLCBzcGluX2ZsYWdzKTsKPiA+ICsKPiA+ICsJLyoKPiA+ICsJICog ZHJtX2NydGNfdmJsYW5rX29mZigpIG1pZ2h0IGhhdmUgYmVlbiBjYWxsZWQgYWZ0ZXIgd2UgY2Fs bGVkCj4gPiArCSAqIGRybV92YmxhbmtfZ2V0KCkuIGRybV9jcnRjX3ZibGFua19vZmYoKSBob2xk cyBldmVudF9sb2NrIGFyb3VuZCB0aGUKPiA+ICsJICogdmJsYW5rIGRpc2FibGUsIHNvIG5vIG5l ZWQgZm9yIGZ1cnRoZXIgbG9ja2luZy4gIFRoZSByZWZlcmVuY2UgZnJvbQo+ID4gKwkgKiBkcm1f dmJsYW5rX2dldCgpIHByb3RlY3RzIGFnYWluc3QgdmJsYW5rIGRpc2FibGUgZnJvbSBhbm90aGVy IHNvdXJjZS4KPiA+ICsJICovCj4gPiArCWlmICghUkVBRF9PTkNFKHZibGFuay0+ZW5hYmxlZCkp IHsKPiA+ICsJCXJldCA9IC1FSU5WQUw7Cj4gPiArCQlnb3RvIGVycl91bmxvY2s7Cj4gPiArCX0K PiA+ICsKPiA+ICsJcmV0ID0gZHJtX2V2ZW50X3Jlc2VydmVfaW5pdF9sb2NrZWQoZGV2LCBmaWxl X3ByaXYsICZlLT5iYXNlLAo+ID4gKwkJCQkJICAgICZlLT5ldmVudC5iYXNlKTsKPiA+ICsKPiA+ ICsJaWYgKHJldCkKPiA+ICsJCWdvdG8gZXJyX3VubG9jazsKPiA+ICsKPiA+ICsJZS0+c2VxdWVu Y2UgPSByZXFfc2VxOwo+ID4gKwo+ID4gKwlpZiAodmJsYW5rX3Bhc3NlZChzZXEsIHJlcV9zZXEp KSB7Cj4gPiArCQlkcm1fdmJsYW5rX3B1dChkZXYsIHBpcGUpOwo+ID4gKwkJc2VuZF92Ymxhbmtf ZXZlbnQoZGV2LCBlLCBzZXEsICZub3cpOwo+ID4gKwkJcXVldWVfc2VxLT5zZXF1ZW5jZSA9IHNl cTsKPiA+ICsJfSBlbHNlIHsKPiA+ICsJCS8qIGRybV9oYW5kbGVfdmJsYW5rX2V2ZW50cyB3aWxs IGNhbGwgZHJtX3ZibGFua19wdXQgKi8KPiA+ICsJCWxpc3RfYWRkX3RhaWwoJmUtPmJhc2UubGlu aywgJmRldi0+dmJsYW5rX2V2ZW50X2xpc3QpOwo+ID4gKwkJcXVldWVfc2VxLT5zZXF1ZW5jZSA9 IHJlcV9zZXE7Cj4gPiArCX0KPiA+ICsKPiA+ICsJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGV2 LT5ldmVudF9sb2NrLCBzcGluX2ZsYWdzKTsKPiA+ICsJcmV0dXJuIDA7Cj4gPiArCj4gPiArZXJy X3VubG9jazoKPiA+ICsJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGV2LT5ldmVudF9sb2NrLCBz cGluX2ZsYWdzKTsKPiA+ICsJZHJtX3ZibGFua19wdXQoZGV2LCBwaXBlKTsKPiA+ICtlcnJfZnJl ZToKPiA+ICsJa2ZyZWUoZSk7Cj4gPiArCXJldHVybiByZXQ7Cj4gPiArfQo+ID4gZGlmZiAtLWdp dCBhL2luY2x1ZGUvZHJtL2RybV92YmxhbmsuaCBiL2luY2x1ZGUvZHJtL2RybV92YmxhbmsuaAo+ ID4gaW5kZXggM2VmN2RkYzVkYjVmLi44YTVlMWRmZTNiZTcgMTAwNjQ0Cj4gPiAtLS0gYS9pbmNs dWRlL2RybS9kcm1fdmJsYW5rLmgKPiA+ICsrKyBiL2luY2x1ZGUvZHJtL2RybV92YmxhbmsuaAo+ ID4gQEAgLTU3LDYgKzU3LDcgQEAgc3RydWN0IGRybV9wZW5kaW5nX3ZibGFua19ldmVudCB7Cj4g PiAgCXVuaW9uIHsKPiA+ICAJCXN0cnVjdCBkcm1fZXZlbnQgYmFzZTsKPiA+ICAJCXN0cnVjdCBk cm1fZXZlbnRfdmJsYW5rIHZibDsKPiA+ICsJCXN0cnVjdCBkcm1fZXZlbnRfY3J0Y19zZXF1ZW5j ZSBzZXE7Cj4gPiAgCX0gZXZlbnQ7Cj4gPiAgfTsKPiA+ICAKPiA+IGRpZmYgLS1naXQgYS9pbmNs dWRlL3VhcGkvZHJtL2RybS5oIGIvaW5jbHVkZS91YXBpL2RybS9kcm0uaAo+ID4gaW5kZXggMTAx NTkzYWIxMGFjLi5kYzE2ZDQyYTg4YzcgMTAwNjQ0Cj4gPiAtLS0gYS9pbmNsdWRlL3VhcGkvZHJt L2RybS5oCj4gPiArKysgYi9pbmNsdWRlL3VhcGkvZHJtL2RybS5oCj4gPiBAQCAtNzE4LDYgKzcx OCwyNyBAQCBzdHJ1Y3QgZHJtX3N5bmNvYmpfaGFuZGxlIHsKPiA+ICAJX191MzIgcGFkOwo+ID4g IH07Cj4gPiAgCj4gPiArLyogUXVlcnkgY3VycmVudCBzY2Fub3V0IHNlcXVlbmNlIG51bWJlciAq Lwo+ID4gK3N0cnVjdCBkcm1fY3J0Y19nZXRfc2VxdWVuY2Ugewo+ID4gKwlfX3UzMiBjcnRjX2lk Owo+ID4gKwlfX3UzMiBwYWQ7Cj4gPiArCV9fdTY0IHNlcXVlbmNlOwo+ID4gKwlfX3U2NCBzZXF1 ZW5jZV9uczsKPiA+ICt9Owo+ID4gKwo+ID4gKy8qIFF1ZXVlIGV2ZW50IHRvIGJlIGRlbGl2ZXJl ZCBhdCBzcGVjaWZpZWQgc2VxdWVuY2UgKi8KPiA+ICsKPiA+ICsjZGVmaW5lIERSTV9DUlRDX1NF UVVFTkNFX1JFTEFUSVZFCQkweDAwMDAwMDAxCS8qIHNlcXVlbmNlIGlzIHJlbGF0aXZlIHRvIGN1 cnJlbnQgKi8KPiA+ICsjZGVmaW5lIERSTV9DUlRDX1NFUVVFTkNFX05FWFRfT05fTUlTUwkJMHgw MDAwMDAwMgkvKiBVc2UgbmV4dCBzZXF1ZW5jZSBpZiB3ZSd2ZSBtaXNzZWQgKi8KPiA+ICsjZGVm aW5lIERSTV9DUlRDX1NFUVVFTkNFX0ZJUlNUX1BJWEVMX09VVAkweDAwMDAwMDA0CS8qIFNpZ25h bCB3aGVuIGZpcnN0IHBpeGVsIGlzIGRpc3BsYXllZCAqLwo+IAo+IEkgdGhvdWdodCB0aGlzIGlz IGFscmVhZHkgdGhlIHNlbWFudGljcyBvdXIgY3VycmVudCB2YmxhbmsgZXZlbnRzIGhhdmUgKGlu Cj4gdGhlIHRpbWVzdGFtcCwgd2hlbiBleGFjdGx5IHRoZSBldmVudCBjb21lcyBvdXQgaXNuJ3Qg ZGVmaW5lZCBmdXJ0aGVyIHRoYW4KPiAic29tZXdoZXJlIGFyb3VuZCB2YmxhbmsiKS4gU2luY2Ug aXQncyB1bnNlZCBJJ2QganVzdCByZW1vdmUgdGhpcyAjZGVmaW5lLgo+IAo+ID4gKwo+ID4gK3N0 cnVjdCBkcm1fY3J0Y19xdWV1ZV9zZXF1ZW5jZSB7Cj4gPiArCV9fdTMyIGNydGNfaWQ7Cj4gPiAr CV9fdTMyIGZsYWdzOwo+ID4gKwlfX3U2NCBzZXF1ZW5jZTsJCS8qIG9uIGlucHV0LCB0YXJnZXQg c2VxdWVuY2UuIG9uIG91dHB1dCwgYWN0dWFsIHNlcXVlbmNlICovCj4gPiArCV9fdTY0IHVzZXJf ZGF0YTsJLyogdXNlciBkYXRhIHBhc3NlZCB0byBldmVudCAqLwo+ID4gK307Cj4gCj4gSW4gYm90 aCBpb2N0bCBoYW5kbGVycyBwbHMgbWFrZSBzdXJlIGV2ZXJ5dGhpbmcgeW91IGRvbid0IGxvb2sg YXQgaXMgMCwKPiBpbmNsdWRpbmcgdW51c2VkIHN0dWZmIGxpa2UgcGFkLiBPdGhlcndpc2UgdXNl cnNwYWNlIG1pZ2h0IGZhaWwgdG8gY2xlYXIKPiB0aGVtLCBhbmQgd2UgY2FuIG5ldmVyIHVzZSB0 aGVtIGluIHRoZSBmdXR1cmUuIE1heWJlIGp1c3QgcmVuYW1lIHBhZCB0bwo+IGZsYWdzIHJpZ2h0 IGF3YXkuCj4gCj4gPiArCj4gPiAgI2lmIGRlZmluZWQoX19jcGx1c3BsdXMpCj4gPiAgfQo+ID4g ICNlbmRpZgo+ID4gQEAgLTgwMCw2ICs4MjEsOSBAQCBleHRlcm4gIkMiIHsKPiA+ICAKPiA+ICAj ZGVmaW5lIERSTV9JT0NUTF9XQUlUX1ZCTEFOSwkJRFJNX0lPV1IoMHgzYSwgdW5pb24gZHJtX3dh aXRfdmJsYW5rKQo+ID4gIAo+ID4gKyNkZWZpbmUgRFJNX0lPQ1RMX0NSVENfR0VUX1NFUVVFTkNF CURSTV9JT1dSKDB4M2IsIHN0cnVjdCBkcm1fY3J0Y19nZXRfc2VxdWVuY2UpCj4gPiArI2RlZmlu ZSBEUk1fSU9DVExfQ1JUQ19RVUVVRV9TRVFVRU5DRQlEUk1fSU9XUigweDNjLCBzdHJ1Y3QgZHJt X2NydGNfcXVldWVfc2VxdWVuY2UpCj4gPiArCj4gPiAgI2RlZmluZSBEUk1fSU9DVExfVVBEQVRF X0RSQVcJCURSTV9JT1coMHgzZiwgc3RydWN0IGRybV91cGRhdGVfZHJhdykKPiA+ICAKPiA+ICAj ZGVmaW5lIERSTV9JT0NUTF9NT0RFX0dFVFJFU09VUkNFUwlEUk1fSU9XUigweEEwLCBzdHJ1Y3Qg ZHJtX21vZGVfY2FyZF9yZXMpCj4gPiBAQCAtODcxLDYgKzg5NSw3IEBAIHN0cnVjdCBkcm1fZXZl bnQgewo+ID4gIAo+ID4gICNkZWZpbmUgRFJNX0VWRU5UX1ZCTEFOSyAweDAxCj4gPiAgI2RlZmlu ZSBEUk1fRVZFTlRfRkxJUF9DT01QTEVURSAweDAyCj4gPiArI2RlZmluZSBEUk1fRVZFTlRfQ1JU Q19TRVFVRU5DRQkweDAzCj4gPiAgCj4gPiAgc3RydWN0IGRybV9ldmVudF92Ymxhbmsgewo+ID4g IAlzdHJ1Y3QgZHJtX2V2ZW50IGJhc2U7Cj4gPiBAQCAtODgxLDYgKzkwNiwxMyBAQCBzdHJ1Y3Qg ZHJtX2V2ZW50X3ZibGFuayB7Cj4gPiAgCV9fdTMyIGNydGNfaWQ7IC8qIDAgb24gb2xkZXIga2Vy bmVscyB0aGF0IGRvIG5vdCBzdXBwb3J0IHRoaXMgKi8KPiA+ICB9Owo+ID4gIAo+ID4gK3N0cnVj dCBkcm1fZXZlbnRfY3J0Y19zZXF1ZW5jZSB7Cj4gPiArCXN0cnVjdCBkcm1fZXZlbnQJYmFzZTsK PiA+ICsJX191NjQJCQl1c2VyX2RhdGE7Cj4gPiArCV9fdTY0CQkJdGltZV9uczsKPiA+ICsJX191 NjQJCQlzZXF1ZW5jZTsKPiA+ICt9Owo+ID4gKwo+ID4gIC8qIHR5cGVkZWYgYXJlYSAqLwo+ID4g ICNpZm5kZWYgX19LRVJORUxfXwo+ID4gIHR5cGVkZWYgc3RydWN0IGRybV9jbGlwX3JlY3QgZHJt X2NsaXBfcmVjdF90Owo+ID4gLS0gCj4gPiAyLjExLjAKPiA+IAo+IAo+IC0tIAo+IERhbmllbCBW ZXR0ZXIKPiBTb2Z0d2FyZSBFbmdpbmVlciwgSW50ZWwgQ29ycG9yYXRpb24KPiBodHRwOi8vYmxv Zy5mZndsbC5jaAo+IF9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCj4gZHJpLWRldmVsIG1haWxpbmcgbGlzdAo+IGRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3Rv cC5vcmcKPiBodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2Ry aS1kZXZlbAoKLS0gClZpbGxlIFN5cmrDpGzDpApJbnRlbCBPVEMKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmkt ZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3Jn L21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752010AbdGFKQL (ORCPT ); Thu, 6 Jul 2017 06:16:11 -0400 Received: from mga07.intel.com ([134.134.136.100]:60261 "EHLO mga07.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751059AbdGFKQJ (ORCPT ); Thu, 6 Jul 2017 06:16:09 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.40,316,1496127600"; d="scan'208";a="107759091" Date: Thu, 6 Jul 2017 13:16:04 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Keith Packard , linux-kernel@vger.kernel.org, Dave Airlie , dri-devel@lists.freedesktop.org Subject: Re: [PATCH 3/3] drm: Add CRTC_GET_SEQUENCE and CRTC_QUEUE_SEQUENCE ioctls Message-ID: <20170706101604.GY12629@intel.com> References: <20170705221013.27940-1-keithp@keithp.com> <20170705221013.27940-4-keithp@keithp.com> <20170706075313.bn2exiklfabgc25t@phenom.ffwll.local> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20170706075313.bn2exiklfabgc25t@phenom.ffwll.local> User-Agent: Mutt/1.5.24 (2015-08-30) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Thu, Jul 06, 2017 at 09:53:13AM +0200, Daniel Vetter wrote: > On Wed, Jul 05, 2017 at 03:10:13PM -0700, Keith Packard wrote: > > These provide crtc-id based functions instead of pipe-number, while > > also offering higher resolution time (ns) and wider frame count (64) > > as required by the Vulkan API. > > > > Signed-off-by: Keith Packard > > I very much like this since the old ioctl really is a rather bad horror > show. And since it's tied in with ums drivers everything is complicated. > > \o/ for much cleaner ioctls. > > Bunch of comments below, but looks good overall. > -Daniel > > > --- > > drivers/gpu/drm/drm_internal.h | 6 ++ > > drivers/gpu/drm/drm_ioctl.c | 2 + > > drivers/gpu/drm/drm_vblank.c | 148 +++++++++++++++++++++++++++++++++++++++++ > > include/drm/drm_vblank.h | 1 + > > include/uapi/drm/drm.h | 32 +++++++++ > > 5 files changed, 189 insertions(+) > > > > diff --git a/drivers/gpu/drm/drm_internal.h b/drivers/gpu/drm/drm_internal.h > > index 5cecc974d2f9..b68a193b7907 100644 > > --- a/drivers/gpu/drm/drm_internal.h > > +++ b/drivers/gpu/drm/drm_internal.h > > @@ -65,6 +65,12 @@ int drm_legacy_irq_control(struct drm_device *dev, void *data, > > int drm_legacy_modeset_ctl(struct drm_device *dev, void *data, > > struct drm_file *file_priv); > > > > +int drm_crtc_get_sequence_ioctl(struct drm_device *dev, void *data, > > + struct drm_file *filp); > > + > > +int drm_crtc_queue_sequence_ioctl(struct drm_device *dev, void *data, > > + struct drm_file *filp); > > + > > /* drm_auth.c */ > > int drm_getmagic(struct drm_device *dev, void *data, > > struct drm_file *file_priv); > > diff --git a/drivers/gpu/drm/drm_ioctl.c b/drivers/gpu/drm/drm_ioctl.c > > index f1e568176da9..63016cf3e224 100644 > > --- a/drivers/gpu/drm/drm_ioctl.c > > +++ b/drivers/gpu/drm/drm_ioctl.c > > @@ -657,6 +657,8 @@ static const struct drm_ioctl_desc drm_ioctls[] = { > > DRM_UNLOCKED|DRM_RENDER_ALLOW), > > DRM_IOCTL_DEF(DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE, drm_syncobj_fd_to_handle_ioctl, > > DRM_UNLOCKED|DRM_RENDER_ALLOW), > > + DRM_IOCTL_DEF(DRM_IOCTL_CRTC_GET_SEQUENCE, drm_crtc_get_sequence_ioctl, DRM_UNLOCKED), > > + DRM_IOCTL_DEF(DRM_IOCTL_CRTC_QUEUE_SEQUENCE, drm_crtc_queue_sequence_ioctl, DRM_UNLOCKED), > > I started a discussion a while back whether these should be restricted to > DRM_MASTER (i.e. the modeset resource owner) or available to everyone. > Since it's read-only I guess we can keep it accessible to everyone, but it > has a bit the problem that client app developers see this, think it does > what it does and then use it to schedule frames without asking the > compositor. Which sometimes even works, but isn't really proper design. > The reasons seems to be that on X11 there's no EGL extension for accurate > timing frame updates (DRI2/3 can do it ofc, and glx exposes it, but glx is > uncool or something like that). > > > }; > > > > #define DRM_CORE_IOCTL_COUNT ARRAY_SIZE( drm_ioctls ) > > diff --git a/drivers/gpu/drm/drm_vblank.c b/drivers/gpu/drm/drm_vblank.c > > index 9ae170857ef6..93004b1bf84c 100644 > > --- a/drivers/gpu/drm/drm_vblank.c > > +++ b/drivers/gpu/drm/drm_vblank.c > > @@ -817,6 +817,12 @@ static void send_vblank_event(struct drm_device *dev, > > e->event.vbl.tv_usec = now->tv_nsec / 1000; > > } > > break; > > + case DRM_EVENT_CRTC_SEQUENCE: > > + if (seq) > > + e->event.seq.sequence = seq; > > + if (now) > > + e->event.seq.time_ns = timespec_to_ns(now); > > + break; > > } > > trace_drm_vblank_event_delivered(e->base.file_priv, e->pipe, seq); > > drm_send_event_locked(dev, &e->base); > > @@ -1516,6 +1522,7 @@ int drm_wait_vblank(struct drm_device *dev, void *data, > > DRM_DEBUG("crtc %d failed to acquire vblank counter, %d\n", pipe, ret); > > return ret; > > } > > + > > seq = drm_vblank_count(dev, pipe); > > > > switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) { > > @@ -1676,3 +1683,144 @@ bool drm_crtc_handle_vblank(struct drm_crtc *crtc) > > return drm_handle_vblank(crtc->dev, drm_crtc_index(crtc)); > > } > > EXPORT_SYMBOL(drm_crtc_handle_vblank); > > + > > +/* > > + * Get crtc VBLANK count. > > + * > > + * \param dev DRM device > > + * \param data user arguement, pointing to a drm_crtc_get_sequence structure. > > + * \param file_priv drm file private for the user's open file descriptor > > + */ > > Since this stuff isn't parsed by kerneldoc I tend to just free-form ioctl > comments completely. Someday maybe someone even gets around to doing > proper uabi documentation :-) Just an aside. > > + > > +int drm_crtc_get_sequence_ioctl(struct drm_device *dev, void *data, > > + struct drm_file *file_priv) > > +{ > > + struct drm_crtc *crtc; > > + int pipe; > > + struct drm_crtc_get_sequence *get_seq = data; > > + struct timespec now; > > + > > You need a DRIVER_MODESET check here or the drm_crtc_find will oops. Same > below. > > > + if (!dev->irq_enabled) > > + return -EINVAL; > > + > > + crtc = drm_crtc_find(dev, get_seq->crtc_id); > > + if (!crtc) > > + return -ENOENT; > > + > > + pipe = drm_crtc_index(crtc); > > + > > + get_seq->sequence = drm_vblank_count_and_time(dev, pipe, &now); > > This can give you and old vblank if the vblank is off (i.e. sw state > hasn't be regularly updated). I think we want a new > drm_crtc_accurate_vblank_count_and_time variant. Or better yet just do what Chris did for the old ioctl in commit b33b02707ba3 ("drm: Peek at the current counter/timestamp for vblank queries") > > Another thing that is very ill-defined in the old vblank ioctl and that we > could fix here: Asking for vblanks when the CRTC is off is a bit silly. > Asking for the sequence when it's off makes some sense, but might still be > good to give userspace some indication in the new struct? This also from > the pov of the unpriviledge vblank waiter use-case that I wondered about > earlier. > > > + get_seq->sequence_ns = timespec_to_ns(&now); > > + return 0; > > +} > > + > > +/* > > + * Queue a event for VBLANK sequence > > + * > > + * \param dev DRM device > > + * \param data user arguement, pointing to a drm_crtc_queue_sequence structure. > > + * \param file_priv drm file private for the user's open file descriptor > > + */ > > + > > +int drm_crtc_queue_sequence_ioctl(struct drm_device *dev, void *data, > > + struct drm_file *file_priv) > > +{ > > + struct drm_crtc *crtc; > > + struct drm_vblank_crtc *vblank; > > + int pipe; > > + struct drm_crtc_queue_sequence *queue_seq = data; > > + struct timespec now; > > + struct drm_pending_vblank_event *e; > > + u32 flags; > > + u64 seq; > > + u64 req_seq; > > + int ret; > > + unsigned long spin_flags; > > + > > + if (!dev->irq_enabled) > > + return -EINVAL; > > + > > + crtc = drm_crtc_find(dev, queue_seq->crtc_id); > > + if (!crtc) > > + return -ENOENT; > > + > > + flags = queue_seq->flags; > > + /* Check valid flag bits */ > > + if (flags & ~(DRM_CRTC_SEQUENCE_RELATIVE| > > + DRM_CRTC_SEQUENCE_NEXT_ON_MISS| > > + DRM_CRTC_SEQUENCE_FIRST_PIXEL_OUT)) > > + return -EINVAL; > > + > > + /* Check for valid signal edge */ > > + if (!(flags & DRM_CRTC_SEQUENCE_FIRST_PIXEL_OUT)) > > + return -EINVAL; > > This seems new, maybe drop it until we need it? > > > + > > + pipe = drm_crtc_index(crtc); > > + > > + vblank = &dev->vblank[pipe]; > > + > > + e = kzalloc(sizeof(*e), GFP_KERNEL); > > + if (e == NULL) > > + return -ENOMEM; > > + > > + ret = drm_vblank_get(dev, pipe); > > drm_crtc_vblank_get pls, would be sweet if we can avoid the (dev, pipe) > pairs as much as possible. Same for all the others. > > > + if (ret) { > > + DRM_DEBUG("crtc %d failed to acquire vblank counter, %d\n", pipe, ret); > > + goto err_free; > > + } > > + > > + seq = drm_vblank_count_and_time(dev, pipe, &now); > > I think here there's no need for the accurate version, since we > force-enable the vblanks already. > > > + req_seq = queue_seq->sequence; > > + > > + if (flags & DRM_CRTC_SEQUENCE_RELATIVE) > > + req_seq += seq; > > + > > + if ((flags & DRM_CRTC_SEQUENCE_NEXT_ON_MISS) && vblank_passed(seq, req_seq)) > > + req_seq = seq + 1; > > + > > + e->pipe = pipe; > > + e->event.base.type = DRM_EVENT_CRTC_SEQUENCE; > > + e->event.base.length = sizeof(e->event.seq); > > + e->event.seq.user_data = queue_seq->user_data; > > No need for crtc_id in this event? Or do we expect userspace to encode > that in the user_data somehow? I don't think it's a real problem since > we'll only deliver one event per request, so clear for which crtc it is. > In atomic we might deliver multiple events (one for each crtc) so that's > why it's needed there. > > But might be useful just for consistency. > > > + > > + spin_lock_irqsave(&dev->event_lock, spin_flags); > > + > > + /* > > + * drm_crtc_vblank_off() might have been called after we called > > + * drm_vblank_get(). drm_crtc_vblank_off() holds event_lock around the > > + * vblank disable, so no need for further locking. The reference from > > + * drm_vblank_get() protects against vblank disable from another source. > > + */ > > + if (!READ_ONCE(vblank->enabled)) { > > + ret = -EINVAL; > > + goto err_unlock; > > + } > > + > > + ret = drm_event_reserve_init_locked(dev, file_priv, &e->base, > > + &e->event.base); > > + > > + if (ret) > > + goto err_unlock; > > + > > + e->sequence = req_seq; > > + > > + if (vblank_passed(seq, req_seq)) { > > + drm_vblank_put(dev, pipe); > > + send_vblank_event(dev, e, seq, &now); > > + queue_seq->sequence = seq; > > + } else { > > + /* drm_handle_vblank_events will call drm_vblank_put */ > > + list_add_tail(&e->base.link, &dev->vblank_event_list); > > + queue_seq->sequence = req_seq; > > + } > > + > > + spin_unlock_irqrestore(&dev->event_lock, spin_flags); > > + return 0; > > + > > +err_unlock: > > + spin_unlock_irqrestore(&dev->event_lock, spin_flags); > > + drm_vblank_put(dev, pipe); > > +err_free: > > + kfree(e); > > + return ret; > > +} > > diff --git a/include/drm/drm_vblank.h b/include/drm/drm_vblank.h > > index 3ef7ddc5db5f..8a5e1dfe3be7 100644 > > --- a/include/drm/drm_vblank.h > > +++ b/include/drm/drm_vblank.h > > @@ -57,6 +57,7 @@ struct drm_pending_vblank_event { > > union { > > struct drm_event base; > > struct drm_event_vblank vbl; > > + struct drm_event_crtc_sequence seq; > > } event; > > }; > > > > diff --git a/include/uapi/drm/drm.h b/include/uapi/drm/drm.h > > index 101593ab10ac..dc16d42a88c7 100644 > > --- a/include/uapi/drm/drm.h > > +++ b/include/uapi/drm/drm.h > > @@ -718,6 +718,27 @@ struct drm_syncobj_handle { > > __u32 pad; > > }; > > > > +/* Query current scanout sequence number */ > > +struct drm_crtc_get_sequence { > > + __u32 crtc_id; > > + __u32 pad; > > + __u64 sequence; > > + __u64 sequence_ns; > > +}; > > + > > +/* Queue event to be delivered at specified sequence */ > > + > > +#define DRM_CRTC_SEQUENCE_RELATIVE 0x00000001 /* sequence is relative to current */ > > +#define DRM_CRTC_SEQUENCE_NEXT_ON_MISS 0x00000002 /* Use next sequence if we've missed */ > > +#define DRM_CRTC_SEQUENCE_FIRST_PIXEL_OUT 0x00000004 /* Signal when first pixel is displayed */ > > I thought this is already the semantics our current vblank events have (in > the timestamp, when exactly the event comes out isn't defined further than > "somewhere around vblank"). Since it's unsed I'd just remove this #define. > > > + > > +struct drm_crtc_queue_sequence { > > + __u32 crtc_id; > > + __u32 flags; > > + __u64 sequence; /* on input, target sequence. on output, actual sequence */ > > + __u64 user_data; /* user data passed to event */ > > +}; > > In both ioctl handlers pls make sure everything you don't look at is 0, > including unused stuff like pad. Otherwise userspace might fail to clear > them, and we can never use them in the future. Maybe just rename pad to > flags right away. > > > + > > #if defined(__cplusplus) > > } > > #endif > > @@ -800,6 +821,9 @@ extern "C" { > > > > #define DRM_IOCTL_WAIT_VBLANK DRM_IOWR(0x3a, union drm_wait_vblank) > > > > +#define DRM_IOCTL_CRTC_GET_SEQUENCE DRM_IOWR(0x3b, struct drm_crtc_get_sequence) > > +#define DRM_IOCTL_CRTC_QUEUE_SEQUENCE DRM_IOWR(0x3c, struct drm_crtc_queue_sequence) > > + > > #define DRM_IOCTL_UPDATE_DRAW DRM_IOW(0x3f, struct drm_update_draw) > > > > #define DRM_IOCTL_MODE_GETRESOURCES DRM_IOWR(0xA0, struct drm_mode_card_res) > > @@ -871,6 +895,7 @@ struct drm_event { > > > > #define DRM_EVENT_VBLANK 0x01 > > #define DRM_EVENT_FLIP_COMPLETE 0x02 > > +#define DRM_EVENT_CRTC_SEQUENCE 0x03 > > > > struct drm_event_vblank { > > struct drm_event base; > > @@ -881,6 +906,13 @@ struct drm_event_vblank { > > __u32 crtc_id; /* 0 on older kernels that do not support this */ > > }; > > > > +struct drm_event_crtc_sequence { > > + struct drm_event base; > > + __u64 user_data; > > + __u64 time_ns; > > + __u64 sequence; > > +}; > > + > > /* typedef area */ > > #ifndef __KERNEL__ > > typedef struct drm_clip_rect drm_clip_rect_t; > > -- > > 2.11.0 > > > > -- > Daniel Vetter > Software Engineer, Intel Corporation > http://blog.ffwll.ch > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- Ville Syrjälä Intel OTC