From mboxrd@z Thu Jan 1 00:00:00 1970 From: Brian Starkey Subject: [PATCH 2/6] drm: writeback: Add out-fences for writeback connectors Date: Fri, 25 Nov 2016 16:49:00 +0000 Message-ID: <1480092544-1725-3-git-send-email-brian.starkey@arm.com> References: <1480092544-1725-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 foss.arm.com (foss.arm.com [217.140.101.70]) by gabe.freedesktop.org (Postfix) with ESMTP id 724146E8CA for ; Fri, 25 Nov 2016 16:49:25 +0000 (UTC) In-Reply-To: <1480092544-1725-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: dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Cc: liviu.dudau@arm.com, laurent.pinchart@ideasonboard.com, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org QWRkIHRoZSBPVVRfRkVOQ0VfUFRSIHByb3BlcnR5IHRvIHdyaXRlYmFjayBjb25uZWN0b3JzLCB0 byBlbmFibGUKdXNlcnNwYWNlIHRvIGdldCBhIGZlbmNlIHdoaWNoIHdpbGwgc2lnbmFsIG9uY2Ug dGhlIHdyaXRlYmFjayBpcwpjb21wbGV0ZS4gSXQgaXMgbm90IGFsbG93ZWQgdG8gcmVxdWVzdCBh biBvdXQtZmVuY2Ugd2l0aG91dCBhCmZyYW1lYnVmZmVyIGF0dGFjaGVkIHRvIHRoZSBjb25uZWN0 b3IuCgpBIHRpbWVsaW5lIGlzIGFkZGVkIHRvIGRybV93cml0ZWJhY2tfY29ubmVjdG9yIGZvciB1 c2UgYnkgdGhlIHdyaXRlYmFjawpvdXQtZmVuY2VzLgoKSW4gdGhlIGNhc2Ugb2YgYSBjb21taXQg ZmFpbHVyZSBvciBEUk1fTU9ERV9BVE9NSUNfVEVTVF9PTkxZLCB0aGUgZmVuY2UKaXMgc2V0IHRv IC0xLgoKQ2hhbmdlcyBmcm9tIHYyOgogLSBSZWJhc2Ugb250byBHdXN0YXZvIFBhZG92YW4ncyB2 OSBleHBsaWNpdCBzeW5jIHNlcmllcwogLSBDaGFuZ2Ugb3V0X2ZlbmNlX3B0ciB0eXBlIHRvIHMz MiBfX3VzZXIgKgogLSBTZXQgKm91dF9mZW5jZV9wdHIgdG8gLTEgaW4gZHJtX2F0b21pY19jb25u ZWN0b3Jfc2V0X3Byb3BlcnR5CiAtIFN0b3JlIGZlbmNlIGluIGRybV93cml0ZWJhY2tfam9iCiBH dXN0YXZvIFBhZG92YW46CiAtIE1vdmUgb3V0X2ZlbmNlX3B0ciBvdXQgb2YgY29ubmVjdG9yX3N0 YXRlCiAtIFNpZ25hbCBmZW5jZSBmcm9tIGRybV93cml0ZWJhY2tfc2lnbmFsX2NvbXBsZXRpb24g aW5zdGVhZCBvZgogICBpbiBkcml2ZXIgZGlyZWN0bHkKClNpZ25lZC1vZmYtYnk6IEJyaWFuIFN0 YXJrZXkgPGJyaWFuLnN0YXJrZXlAYXJtLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vZHJtX2F0 b21pYy5jICAgIHwgICA5NiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tCiBk cml2ZXJzL2dwdS9kcm0vZHJtX3dyaXRlYmFjay5jIHwgICA5OSArKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKy0KIGluY2x1ZGUvZHJtL2RybV9hdG9taWMuaCAgICAgICAgfCAg ICA4ICsrKysKIGluY2x1ZGUvZHJtL2RybV9jb25uZWN0b3IuaCAgICAgfCAgICA4ICsrLS0KIGlu Y2x1ZGUvZHJtL2RybV93cml0ZWJhY2suaCAgICAgfCAgIDM5ICsrKysrKysrKysrKysrLQogNSBm aWxlcyBjaGFuZ2VkLCAyMzQgaW5zZXJ0aW9ucygrKSwgMTYgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1f YXRvbWljLmMKaW5kZXggMzQzZTJiNy4uMGUzYzkwMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUv ZHJtL2RybV9hdG9taWMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pYy5jCkBAIC0z MDgsNiArMzA4LDMyIEBAIHN0YXRpYyBzNjQgX191c2VyICpnZXRfb3V0X2ZlbmNlX2Zvcl9jcnRj KHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSwKIAlyZXR1cm4gZmVuY2VfcHRyOwogfQog CitzdGF0aWMgaW50IHNldF9vdXRfZmVuY2VfZm9yX2Nvbm5lY3RvcihzdHJ1Y3QgZHJtX2F0b21p Y19zdGF0ZSAqc3RhdGUsCisJCQkJCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCisJ CQkJCXM2NCBfX3VzZXIgKmZlbmNlX3B0cikKK3sKKwl1bnNpZ25lZCBpbnQgaW5kZXggPSBkcm1f Y29ubmVjdG9yX2luZGV4KGNvbm5lY3Rvcik7CisKKwlpZiAoZmVuY2VfcHRyICYmIHB1dF91c2Vy KC0xLCBmZW5jZV9wdHIpKQorCQlyZXR1cm4gLUVGQVVMVDsKKworCXN0YXRlLT5jb25uZWN0b3Jz W2luZGV4XS5vdXRfZmVuY2VfcHRyID0gZmVuY2VfcHRyOworCisJcmV0dXJuIDA7Cit9CisKK3N0 YXRpYyBzNjQgX191c2VyICpnZXRfb3V0X2ZlbmNlX2Zvcl9jb25uZWN0b3Ioc3RydWN0IGRybV9h dG9taWNfc3RhdGUgKnN0YXRlLAorCQkJCQkgICAgICAgc3RydWN0IGRybV9jb25uZWN0b3IgKmNv bm5lY3RvcikKK3sKKwl1bnNpZ25lZCBpbnQgaW5kZXggPSBkcm1fY29ubmVjdG9yX2luZGV4KGNv bm5lY3Rvcik7CisJczY0IF9fdXNlciAqZmVuY2VfcHRyOworCisJZmVuY2VfcHRyID0gc3RhdGUt PmNvbm5lY3RvcnNbaW5kZXhdLm91dF9mZW5jZV9wdHI7CisJc3RhdGUtPmNvbm5lY3RvcnNbaW5k ZXhdLm91dF9mZW5jZV9wdHIgPSBOVUxMOworCisJcmV0dXJuIGZlbmNlX3B0cjsKK30KKwogLyoq CiAgKiBkcm1fYXRvbWljX3NldF9tb2RlX2Zvcl9jcnRjIC0gc2V0IG1vZGUgZm9yIENSVEMKICAq IEBzdGF0ZTogdGhlIENSVEMgd2hvc2UgaW5jb21pbmcgc3RhdGUgdG8gdXBkYXRlCkBAIC02OTYs NiArNzIyLDEyIEBAIHN0YXRpYyBpbnQgZHJtX2F0b21pY19jb25uZWN0b3JfY2hlY2soc3RydWN0 IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCisJaWYg KHdyaXRlYmFja19qb2ItPm91dF9mZW5jZSAmJiAhd3JpdGViYWNrX2pvYi0+ZmIpIHsKKwkJRFJN X0RFQlVHX0FUT01JQygiW0NPTk5FQ1RPUjolZDolc10gcmVxdWVzdGluZyBvdXQtZmVuY2Ugd2l0 aG91dCBmcmFtZWJ1ZmZlclxuIiwKKwkJCQkgY29ubmVjdG9yLT5iYXNlLmlkLCBjb25uZWN0b3It Pm5hbWUpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtMTEz NCw2ICsxMTY2LDExIEBAIGludCBkcm1fYXRvbWljX2Nvbm5lY3Rvcl9zZXRfcHJvcGVydHkoc3Ry dWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwKIAkJaWYgKGZiKQogCQkJZHJtX2ZyYW1lYnVm ZmVyX3VucmVmZXJlbmNlKGZiKTsKIAkJcmV0dXJuIHJldDsKKwl9IGVsc2UgaWYgKHByb3BlcnR5 ID09IGNvbmZpZy0+cHJvcF9vdXRfZmVuY2VfcHRyKSB7CisJCXM2NCBfX3VzZXIgKmZlbmNlX3B0 ciA9IHU2NF90b191c2VyX3B0cih2YWwpOworCisJCXJldHVybiBzZXRfb3V0X2ZlbmNlX2Zvcl9j b25uZWN0b3Ioc3RhdGUtPnN0YXRlLCBjb25uZWN0b3IsCisJCQkJCQkgICBmZW5jZV9wdHIpOwog CX0gZWxzZSBpZiAoY29ubmVjdG9yLT5mdW5jcy0+YXRvbWljX3NldF9wcm9wZXJ0eSkgewogCQly ZXR1cm4gY29ubmVjdG9yLT5mdW5jcy0+YXRvbWljX3NldF9wcm9wZXJ0eShjb25uZWN0b3IsCiAJ CQkJc3RhdGUsIHByb3BlcnR5LCB2YWwpOwpAQCAtMTE4NSw2ICsxMjIyLDggQEAgc3RhdGljIHZv aWQgZHJtX2F0b21pY19jb25uZWN0b3JfcHJpbnRfc3RhdGUoc3RydWN0IGRybV9wcmludGVyICpw LAogCX0gZWxzZSBpZiAocHJvcGVydHkgPT0gY29uZmlnLT53cml0ZWJhY2tfZmJfaWRfcHJvcGVy dHkpIHsKIAkJLyogV3JpdGViYWNrIGZyYW1lYnVmZmVyIGlzIG9uZS1zaG90LCB3cml0ZSBhbmQg Zm9yZ2V0ICovCiAJCSp2YWwgPSAwOworCX0gZWxzZSBpZiAocHJvcGVydHkgPT0gY29uZmlnLT5w cm9wX291dF9mZW5jZV9wdHIpIHsKKwkJKnZhbCA9IDA7CiAJfSBlbHNlIGlmIChjb25uZWN0b3It PmZ1bmNzLT5hdG9taWNfZ2V0X3Byb3BlcnR5KSB7CiAJCXJldHVybiBjb25uZWN0b3ItPmZ1bmNz LT5hdG9taWNfZ2V0X3Byb3BlcnR5KGNvbm5lY3RvciwKIAkJCQlzdGF0ZSwgcHJvcGVydHksIHZh bCk7CkBAIC0xOTc2LDcgKzIwMTUsNyBAQCBzdGF0aWMgaW50IHNldHVwX291dF9mZW5jZShzdHJ1 Y3QgZHJtX291dF9mZW5jZV9zdGF0ZSAqZmVuY2Vfc3RhdGUsCiAJcmV0dXJuIDA7CiB9CiAKLXN0 YXRpYyBpbnQgcHJlcGFyZV9jcnRjX3NpZ25hbGluZyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAor c3RhdGljIGludCBwcmVwYXJlX3NpZ25hbGluZyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCQkJ CSAgc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAogCQkJCSAgc3RydWN0IGRybV9tb2Rl X2F0b21pYyAqYXJnLAogCQkJCSAgc3RydWN0IGRybV9maWxlICpmaWxlX3ByaXYsCkBAIC0xOTg1 LDYgKzIwMjQsOCBAQCBzdGF0aWMgaW50IHByZXBhcmVfY3J0Y19zaWduYWxpbmcoc3RydWN0IGRy bV9kZXZpY2UgKmRldiwKIHsKIAlzdHJ1Y3QgZHJtX2NydGMgKmNydGM7CiAJc3RydWN0IGRybV9j cnRjX3N0YXRlICpjcnRjX3N0YXRlOworCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uOworCXN0 cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlOwogCWludCBpLCByZXQ7CiAKIAlp ZiAoYXJnLT5mbGFncyAmIERSTV9NT0RFX0FUT01JQ19URVNUX09OTFkpCkBAIC0yMDQ4LDE0ICsy MDg5LDUxIEBAIHN0YXRpYyBpbnQgcHJlcGFyZV9jcnRjX3NpZ25hbGluZyhzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2LAogCQl9CiAJfQogCisJZm9yX2VhY2hfY29ubmVjdG9yX2luX3N0YXRlKHN0YXRl LCBjb25uLCBjb25uX3N0YXRlLCBpKSB7CisJCXN0cnVjdCBkcm1fd3JpdGViYWNrX2pvYiAqam9i OworCQlzdHJ1Y3QgZHJtX291dF9mZW5jZV9zdGF0ZSAqZjsKKwkJc3RydWN0IGRtYV9mZW5jZSAq ZmVuY2U7CisJCXM2NCBfX3VzZXIgKmZlbmNlX3B0cjsKKworCQlmZW5jZV9wdHIgPSBnZXRfb3V0 X2ZlbmNlX2Zvcl9jb25uZWN0b3Ioc3RhdGUsIGNvbm4pOworCQlpZiAoIWZlbmNlX3B0cikKKwkJ CWNvbnRpbnVlOworCisJCWpvYiA9IGRybV9hdG9taWNfZ2V0X3dyaXRlYmFja19qb2IoY29ubl9z dGF0ZSk7CisJCWlmICgham9iKQorCQkJcmV0dXJuIC1FTk9NRU07CisKKwkJZiA9IGtyZWFsbG9j KCpmZW5jZV9zdGF0ZSwgc2l6ZW9mKCoqZmVuY2Vfc3RhdGUpICoKKwkJCSAgICAgKCpudW1fZmVu Y2VzICsgMSksIEdGUF9LRVJORUwpOworCQlpZiAoIWYpCisJCQlyZXR1cm4gLUVOT01FTTsKKwor CQltZW1zZXQoJmZbKm51bV9mZW5jZXNdLCAwLCBzaXplb2YoKmYpKTsKKworCQlmWypudW1fZmVu Y2VzXS5vdXRfZmVuY2VfcHRyID0gZmVuY2VfcHRyOworCQkqZmVuY2Vfc3RhdGUgPSBmOworCisJ CWZlbmNlID0gZHJtX3dyaXRlYmFja19nZXRfb3V0X2ZlbmNlKChzdHJ1Y3QgZHJtX3dyaXRlYmFj a19jb25uZWN0b3IgKiljb25uKTsKKwkJaWYgKCFmZW5jZSkKKwkJCXJldHVybiAtRU5PTUVNOwor CisJCXJldCA9IHNldHVwX291dF9mZW5jZSgmZlsoKm51bV9mZW5jZXMpKytdLCBmZW5jZSk7CisJ CWlmIChyZXQpIHsKKwkJCWRtYV9mZW5jZV9wdXQoZmVuY2UpOworCQkJcmV0dXJuIHJldDsKKwkJ fQorCisJCWpvYi0+b3V0X2ZlbmNlID0gZmVuY2U7CisJfQorCiAJcmV0dXJuIDA7CiB9CiAKLXN0 YXRpYyB2b2lkIGNvbXBsZXRlX2NydGNfc2lnbmFsaW5nKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYs Ci0JCQkJICAgIHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSwKLQkJCQkgICAgc3RydWN0 IGRybV9vdXRfZmVuY2Vfc3RhdGUgKmZlbmNlX3N0YXRlLAotCQkJCSAgICB1bnNpZ25lZCBpbnQg bnVtX2ZlbmNlcywKLQkJCQkgICAgYm9vbCBpbnN0YWxsX2ZkcykKK3N0YXRpYyB2b2lkIGNvbXBs ZXRlX3NpZ25hbGluZyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAorCQkJICAgICAgIHN0cnVjdCBk cm1fYXRvbWljX3N0YXRlICpzdGF0ZSwKKwkJCSAgICAgICBzdHJ1Y3QgZHJtX291dF9mZW5jZV9z dGF0ZSAqZmVuY2Vfc3RhdGUsCisJCQkgICAgICAgdW5zaWduZWQgaW50IG51bV9mZW5jZXMsCisJ CQkgICAgICAgYm9vbCBpbnN0YWxsX2ZkcykKIHsKIAlzdHJ1Y3QgZHJtX2NydGMgKmNydGM7CiAJ c3RydWN0IGRybV9jcnRjX3N0YXRlICpjcnRjX3N0YXRlOwpAQCAtMjIyOCw4ICsyMzA2LDggQEAg aW50IGRybV9tb2RlX2F0b21pY19pb2N0bChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCQlkcm1f bW9kZV9vYmplY3RfdW5yZWZlcmVuY2Uob2JqKTsKIAl9CiAKLQlyZXQgPSBwcmVwYXJlX2NydGNf c2lnbmFsaW5nKGRldiwgc3RhdGUsIGFyZywgZmlsZV9wcml2LCAmZmVuY2Vfc3RhdGUsCi0JCQkJ ICAgICAmbnVtX2ZlbmNlcyk7CisJcmV0ID0gcHJlcGFyZV9zaWduYWxpbmcoZGV2LCBzdGF0ZSwg YXJnLCBmaWxlX3ByaXYsICZmZW5jZV9zdGF0ZSwKKwkJCQkmbnVtX2ZlbmNlcyk7CiAJaWYgKHJl dCkKIAkJZ290byBvdXQ7CiAKQEAgLTIyNTEsNyArMjMyOSw3IEBAIGludCBkcm1fbW9kZV9hdG9t aWNfaW9jdGwoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKIG91dDoKIAlkcm1fYXRvbWljX2NsZWFu X29sZF9mYihkZXYsIHBsYW5lX21hc2ssIHJldCk7CiAKLQljb21wbGV0ZV9jcnRjX3NpZ25hbGlu ZyhkZXYsIHN0YXRlLCBmZW5jZV9zdGF0ZSwgbnVtX2ZlbmNlcywgIXJldCk7CisJY29tcGxldGVf c2lnbmFsaW5nKGRldiwgc3RhdGUsIGZlbmNlX3N0YXRlLCBudW1fZmVuY2VzLCAhcmV0KTsKIAog CWlmIChyZXQgPT0gLUVERUFETEspIHsKIAkJZHJtX2F0b21pY19zdGF0ZV9jbGVhcihzdGF0ZSk7 CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX3dyaXRlYmFjay5jIGIvZHJpdmVycy9n cHUvZHJtL2RybV93cml0ZWJhY2suYwppbmRleCA3NWExZGJmLi4zNjM3YjlhIDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vZHJtX3dyaXRlYmFjay5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9k cm1fd3JpdGViYWNrLmMKQEAgLTEyLDYgKzEyLDcgQEAKICNpbmNsdWRlIDxkcm0vZHJtX3Byb3Bl cnR5Lmg+CiAjaW5jbHVkZSA8ZHJtL2RybV93cml0ZWJhY2suaD4KICNpbmNsdWRlIDxkcm0vZHJt UC5oPgorI2luY2x1ZGUgPGxpbnV4L2RtYS1mZW5jZS5oPgogCiAvKioKICAqIERPQzogb3ZlcnZp ZXcKQEAgLTI5LDYgKzMwLDE2IEBACiAgKiBmcmFtZWJ1ZmZlciBhcHBsaWVzIG9ubHkgdG8gYSBz aW5nbGUgY29tbWl0IChzZWUgYmVsb3cpLiBBIGZyYW1lYnVmZmVyIG1heQogICogbm90IGJlIGF0 dGFjaGVkIHdoaWxlIHRoZSBDUlRDIGlzIG9mZi4KICAqCisgKiBVbmxpa2Ugd2l0aCBwbGFuZXMs IHdoZW4gYSB3cml0ZWJhY2sgZnJhbWVidWZmZXIgaXMgcmVtb3ZlZCBieSB1c2Vyc3BhY2UgRFJN CisgKiBtYWtlcyBubyBhdHRlbXB0IHRvIHJlbW92ZSBpdCBmcm9tIGFjdGl2ZSB1c2UgYnkgdGhl IGNvbm5lY3Rvci4gVGhpcyBpcworICogYmVjYXVzZSBubyBtZXRob2QgaXMgcHJvdmlkZWQgdG8g YWJvcnQgYSB3cml0ZWJhY2sgb3BlcmF0aW9uLCBhbmQgaW4gYW55CisgKiBjYXNlIG1ha2luZyBh IG5ldyBjb21taXQgd2hpbHN0IGEgd3JpdGViYWNrIGlzIG9uZ29pbmcgaXMgdW5kZWZpbmVkIChz ZWUKKyAqIE9VVF9GRU5DRV9QVFIgYmVsb3cpLiBBcyBzb29uIGFzIHRoZSBjdXJyZW50IHdyaXRl YmFjayBpcyBmaW5pc2hlZCwgdGhlCisgKiBmcmFtZWJ1ZmZlciB3aWxsIGF1dG9tYXRpY2FsbHkg bm8gbG9uZ2VyIGJlIGluIGFjdGl2ZSB1c2UuIEFzIGl0IHdpbGwgYWxzbworICogaGF2ZSBhbHJl YWR5IGJlZW4gcmVtb3ZlZCBmcm9tIHRoZSBmcmFtZWJ1ZmZlciBsaXN0LCB0aGVyZSB3aWxsIGJl IG5vIHdheSBmb3IKKyAqIGFueSB1c2Vyc3BhY2UgYXBwbGljYXRpb24gdG8gcmV0cmlldmUgYSBy ZWZlcmVuY2UgdG8gaXQgaW4gdGhlIGludGVydmVuaW5nCisgKiBwZXJpb2QuCisgKgogICogV3Jp dGViYWNrIGNvbm5lY3RvcnMgaGF2ZSBzb21lIGFkZGl0aW9uYWwgcHJvcGVydGllcywgd2hpY2gg dXNlcnNwYWNlCiAgKiBjYW4gdXNlIHRvIHF1ZXJ5IGFuZCBjb250cm9sIHRoZW06CiAgKgpAQCAt NDUsOCArNTYsNTQgQEAKICAqCWRhdGEgaXMgYW4gYXJyYXkgb2YgdTMyIERSTV9GT1JNQVRfKiBm b3VyY2MgdmFsdWVzLgogICoJVXNlcnNwYWNlIGNhbiB1c2UgdGhpcyBibG9iIHRvIGZpbmQgb3V0 IHdoYXQgcGl4ZWwgZm9ybWF0cyBhcmUgc3VwcG9ydGVkCiAgKglieSB0aGUgY29ubmVjdG9yJ3Mg d3JpdGViYWNrIGVuZ2luZS4KKyAqCisgKiAgIk9VVF9GRU5DRV9QVFIiOgorICoJVXNlcnNwYWNl IGNhbiB1c2UgdGhpcyBwcm9wZXJ0eSB0byBwcm92aWRlIGEgcG9pbnRlciBmb3IgdGhlIGtlcm5l bCB0bworICoJZmlsbCB3aXRoIGEgc3luY19maWxlIGZpbGUgZGVzY3JpcHRvciwgd2hpY2ggd2ls bCBzaWduYWwgb25jZSB0aGUKKyAqCXdyaXRlYmFjayBpcyBmaW5pc2hlZC4gVGhlIHZhbHVlIHNo b3VsZCBiZSB0aGUgYWRkcmVzcyBvZiBhIDY0LWJpdAorICoJc2lnbmVkIGludGVnZXIsIGNhc3Qg dG8gYSB1NjQuCisgKglVc2Vyc3BhY2Ugc2hvdWxkIHdhaXQgZm9yIHRoaXMgZmVuY2UgdG8gc2ln bmFsIGJlZm9yZSBtYWtpbmcgYW5vdGhlcgorICoJY29tbWl0IGFmZmVjdGluZyBhbnkgb2YgdGhl IHNhbWUgQ1JUQ3MsIFBsYW5lcyBvciBDb25uZWN0b3JzLgorICoJKipGYWlsdXJlIHRvIGRvIHNv IHdpbGwgcmVzdWx0IGluIHVuZGVmaW5lZCBiZWhhdmlvdXIuKioKKyAqCUZvciB0aGlzIHJlYXNv biBpdCBpcyBzdHJvbmdseSByZWNvbW1lbmRlZCB0aGF0IGFsbCB1c2Vyc3BhY2UKKyAqCWFwcGxp Y2F0aW9ucyBtYWtpbmcgdXNlIG9mIHdyaXRlYmFjayBjb25uZWN0b3JzICphbHdheXMqIHJldHJp ZXZlIGFuCisgKglvdXQtZmVuY2UgZm9yIHRoZSBjb21taXQgYW5kIHVzZSBpdCBhcHByb3ByaWF0 ZWx5LgorICoJRnJvbSB1c2Vyc3BhY2UsIHRoaXMgcHJvcGVydHkgd2lsbCBhbHdheXMgcmVhZCBh cyB6ZXJvLgogICovCiAKKyNkZWZpbmUgZmVuY2VfdG9fd2JfY29ubmVjdG9yKHgpIGNvbnRhaW5l cl9vZih4LT5sb2NrLCBcCisJCQkJCSAgICAgIHN0cnVjdCBkcm1fd3JpdGViYWNrX2Nvbm5lY3Rv ciwgXAorCQkJCQkgICAgICBmZW5jZV9sb2NrKQorCitzdGF0aWMgY29uc3QgY2hhciAqZHJtX3dy aXRlYmFja19mZW5jZV9nZXRfZHJpdmVyX25hbWUoc3RydWN0IGRtYV9mZW5jZSAqZmVuY2UpCit7 CisJc3RydWN0IGRybV93cml0ZWJhY2tfY29ubmVjdG9yICp3Yl9jb25uZWN0b3IgPQorCQlmZW5j ZV90b193Yl9jb25uZWN0b3IoZmVuY2UpOworCisJcmV0dXJuIHdiX2Nvbm5lY3Rvci0+YmFzZS5k ZXYtPmRyaXZlci0+bmFtZTsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKgorZHJtX3dyaXRlYmFj a19mZW5jZV9nZXRfdGltZWxpbmVfbmFtZShzdHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSkKK3sKKwlz dHJ1Y3QgZHJtX3dyaXRlYmFja19jb25uZWN0b3IgKndiX2Nvbm5lY3RvciA9CisJCWZlbmNlX3Rv X3diX2Nvbm5lY3RvcihmZW5jZSk7CisKKwlyZXR1cm4gd2JfY29ubmVjdG9yLT50aW1lbGluZV9u YW1lOworfQorCitzdGF0aWMgYm9vbCBkcm1fd3JpdGViYWNrX2ZlbmNlX2VuYWJsZV9zaWduYWxp bmcoc3RydWN0IGRtYV9mZW5jZSAqZmVuY2UpCit7CisJcmV0dXJuIHRydWU7Cit9CisKK3N0YXRp YyBjb25zdCBzdHJ1Y3QgZG1hX2ZlbmNlX29wcyBkcm1fd3JpdGViYWNrX2ZlbmNlX29wcyA9IHsK KwkuZ2V0X2RyaXZlcl9uYW1lID0gZHJtX3dyaXRlYmFja19mZW5jZV9nZXRfZHJpdmVyX25hbWUs CisJLmdldF90aW1lbGluZV9uYW1lID0gZHJtX3dyaXRlYmFja19mZW5jZV9nZXRfdGltZWxpbmVf bmFtZSwKKwkuZW5hYmxlX3NpZ25hbGluZyA9IGRybV93cml0ZWJhY2tfZmVuY2VfZW5hYmxlX3Np Z25hbGluZywKKwkud2FpdCA9IGRtYV9mZW5jZV9kZWZhdWx0X3dhaXQsCit9OworCiBzdGF0aWMg Ym9vbCBjcmVhdGVfd3JpdGViYWNrX3Byb3BlcnRpZXMoc3RydWN0IGRybV9kZXZpY2UgKmRldikK IHsKIAlzdHJ1Y3QgZHJtX3Byb3BlcnR5ICpwcm9wOwpAQCAtMTE1LDYgKzE3MiwxNSBAQCBpbnQg ZHJtX3dyaXRlYmFja19jb25uZWN0b3JfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCUlO SVRfTElTVF9IRUFEKCZ3Yl9jb25uZWN0b3ItPmpvYl9xdWV1ZSk7CiAJc3Bpbl9sb2NrX2luaXQo JndiX2Nvbm5lY3Rvci0+am9iX2xvY2spOwogCisJd2JfY29ubmVjdG9yLT5mZW5jZV9jb250ZXh0 ID0gZG1hX2ZlbmNlX2NvbnRleHRfYWxsb2MoMSk7CisJc3Bpbl9sb2NrX2luaXQoJndiX2Nvbm5l Y3Rvci0+ZmVuY2VfbG9jayk7CisJc25wcmludGYod2JfY29ubmVjdG9yLT50aW1lbGluZV9uYW1l LAorCQkgc2l6ZW9mKHdiX2Nvbm5lY3Rvci0+dGltZWxpbmVfbmFtZSksCisJCSAiQ09OTkVDVE9S OiVkLSVzIiwgY29ubmVjdG9yLT5iYXNlLmlkLCBjb25uZWN0b3ItPm5hbWUpOworCisJZHJtX29i amVjdF9hdHRhY2hfcHJvcGVydHkoJmNvbm5lY3Rvci0+YmFzZSwKKwkJCQkgICBjb25maWctPnBy b3Bfb3V0X2ZlbmNlX3B0ciwgMCk7CisKIAlkcm1fb2JqZWN0X2F0dGFjaF9wcm9wZXJ0eSgmY29u bmVjdG9yLT5iYXNlLAogCQkJCSAgIGNvbmZpZy0+d3JpdGViYWNrX2ZiX2lkX3Byb3BlcnR5LCAw KTsKIApAQCAtMTczLDYgKzIzOSw3IEBAIHZvaWQgZHJtX3dyaXRlYmFja19jbGVhbnVwX2pvYihz dHJ1Y3QgZHJtX3dyaXRlYmFja19qb2IgKmpvYikKIAogCWlmIChqb2ItPmZiKQogCQlkcm1fZnJh bWVidWZmZXJfdW5yZWZlcmVuY2Uoam9iLT5mYik7CisJZG1hX2ZlbmNlX3B1dChqb2ItPm91dF9m ZW5jZSk7CiAJa2ZyZWUoam9iKTsKIH0KIEVYUE9SVF9TWU1CT0woZHJtX3dyaXRlYmFja19jbGVh bnVwX2pvYik7CkBAIC0xOTUsNiArMjYyLDcgQEAgc3RhdGljIHZvaWQgY2xlYW51cF93b3JrKHN0 cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKIC8qKgogICogQGRybV93cml0ZWJhY2tfc2lnbmFsX2Nv bXBsZXRpb246IFNpZ25hbCB0aGUgY29tcGxldGlvbiBvZiBhIHdyaXRlYmFjayBqb2IKICAqIEB3 Yl9jb25uZWN0b3I6IFRoZSB3cml0ZWJhY2sgY29ubmVjdG9yIHdob3NlIGpvYiBpcyBjb21wbGV0 ZQorICogQHN0YXR1czogU3RhdHVzIGNvZGUgdG8gc2V0IGluIHRoZSB3cml0ZWJhY2sgb3V0X2Zl bmNlICgwIGZvciBzdWNjZXNzKQogICoKICAqIERyaXZlcnMgc2hvdWxkIGNhbGwgdGhpcyB0byBz aWduYWwgdGhlIGNvbXBsZXRpb24gb2YgYSBwcmV2aW91c2x5IHF1ZXVlZAogICogd3JpdGViYWNr IGpvYi4gSXQgc2hvdWxkIGJlIGNhbGxlZCBhcyBzb29uIGFzIHBvc3NpYmxlIGFmdGVyIHRoZSBo YXJkd2FyZQpAQCAtMjA4LDcgKzI3Niw4IEBAIHN0YXRpYyB2b2lkIGNsZWFudXBfd29yayhzdHJ1 Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiAgKiBTZWUgYWxzbzogZHJtX3dyaXRlYmFja19xdWV1ZV9q b2IoKQogICovCiB2b2lkCi1kcm1fd3JpdGViYWNrX3NpZ25hbF9jb21wbGV0aW9uKHN0cnVjdCBk cm1fd3JpdGViYWNrX2Nvbm5lY3RvciAqd2JfY29ubmVjdG9yKQorZHJtX3dyaXRlYmFja19zaWdu YWxfY29tcGxldGlvbihzdHJ1Y3QgZHJtX3dyaXRlYmFja19jb25uZWN0b3IgKndiX2Nvbm5lY3Rv ciwKKwkJCQlpbnQgc3RhdHVzKQogewogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJc3RydWN0IGRy bV93cml0ZWJhY2tfam9iICpqb2I7CkBAIC0yMTcsOCArMjg2LDEzIEBAIHN0YXRpYyB2b2lkIGNs ZWFudXBfd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiAJam9iID0gbGlzdF9maXJzdF9l bnRyeV9vcl9udWxsKCZ3Yl9jb25uZWN0b3ItPmpvYl9xdWV1ZSwKIAkJCQkgICAgICAgc3RydWN0 IGRybV93cml0ZWJhY2tfam9iLAogCQkJCSAgICAgICBsaXN0X2VudHJ5KTsKLQlpZiAoam9iKQor CWlmIChqb2IpIHsKIAkJbGlzdF9kZWwoJmpvYi0+bGlzdF9lbnRyeSk7CisJCWlmIChqb2ItPm91 dF9mZW5jZSkgeworCQkJam9iLT5vdXRfZmVuY2UtPnN0YXR1cyA9IHN0YXR1czsKKwkJCWRtYV9m ZW5jZV9zaWduYWwoam9iLT5vdXRfZmVuY2UpOworCQl9CisJfQogCXNwaW5fdW5sb2NrX2lycXJl c3RvcmUoJndiX2Nvbm5lY3Rvci0+am9iX2xvY2ssIGZsYWdzKTsKIAogCWlmIChXQVJOX09OKCFq b2IpKQpAQCAtMjI4LDMgKzMwMiwyNCBAQCBzdGF0aWMgdm9pZCBjbGVhbnVwX3dvcmsoc3RydWN0 IHdvcmtfc3RydWN0ICp3b3JrKQogCXF1ZXVlX3dvcmsoc3lzdGVtX2xvbmdfd3EsICZqb2ItPmNs ZWFudXBfd29yayk7CiB9CiBFWFBPUlRfU1lNQk9MKGRybV93cml0ZWJhY2tfc2lnbmFsX2NvbXBs ZXRpb24pOworCitzdHJ1Y3QgZG1hX2ZlbmNlICoKK2RybV93cml0ZWJhY2tfZ2V0X291dF9mZW5j ZShzdHJ1Y3QgZHJtX3dyaXRlYmFja19jb25uZWN0b3IgKndiX2Nvbm5lY3RvcikKK3sKKwlzdHJ1 Y3QgZG1hX2ZlbmNlICpmZW5jZTsKKworCWlmIChXQVJOX09OKHdiX2Nvbm5lY3Rvci0+YmFzZS5j b25uZWN0b3JfdHlwZSAhPQorCQkgICAgRFJNX01PREVfQ09OTkVDVE9SX1dSSVRFQkFDSykpCisJ CXJldHVybiBOVUxMOworCisJZmVuY2UgPSBremFsbG9jKHNpemVvZigqZmVuY2UpLCBHRlBfS0VS TkVMKTsKKwlpZiAoIWZlbmNlKQorCQlyZXR1cm4gTlVMTDsKKworCWRtYV9mZW5jZV9pbml0KGZl bmNlLCAmZHJtX3dyaXRlYmFja19mZW5jZV9vcHMsCisJCSAgICAgICAmd2JfY29ubmVjdG9yLT5m ZW5jZV9sb2NrLCB3Yl9jb25uZWN0b3ItPmZlbmNlX2NvbnRleHQsCisJCSAgICAgICArK3diX2Nv bm5lY3Rvci0+ZmVuY2Vfc2Vxbm8pOworCisJcmV0dXJuIGZlbmNlOworfQorRVhQT1JUX1NZTUJP TChkcm1fd3JpdGViYWNrX2dldF9vdXRfZmVuY2UpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0v ZHJtX2F0b21pYy5oIGIvaW5jbHVkZS9kcm0vZHJtX2F0b21pYy5oCmluZGV4IDQ3NjU2MWQuLjdj NGFkMGIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL2RybV9hdG9taWMuaAorKysgYi9pbmNsdWRl L2RybS9kcm1fYXRvbWljLmgKQEAgLTE1MCw2ICsxNTAsMTQgQEAgc3RydWN0IF9fZHJtX2NydGNz X3N0YXRlIHsKIHN0cnVjdCBfX2RybV9jb25ubmVjdG9yc19zdGF0ZSB7CiAJc3RydWN0IGRybV9j b25uZWN0b3IgKnB0cjsKIAlzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqc3RhdGU7CisJLyoq CisJICogQG91dF9mZW5jZV9wdHI6CisJICoKKwkgKiBVc2VyLXByb3ZpZGVkIHBvaW50ZXIgd2hp Y2ggdGhlIGtlcm5lbCB1c2VzIHRvIHJldHVybiBhIHN5bmNfZmlsZQorCSAqIGZpbGUgZGVzY3Jp cHRvci4gVXNlZCBieSB3cml0ZWJhY2sgY29ubmVjdG9ycyB0byBzaWduYWwgY29tcGxldGlvbiBv ZgorCSAqIHRoZSB3cml0ZWJhY2suCisJICovCisJczY0IF9fdXNlciAqb3V0X2ZlbmNlX3B0cjsK IH07CiAKIC8qKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX2Nvbm5lY3Rvci5oIGIvaW5j bHVkZS9kcm0vZHJtX2Nvbm5lY3Rvci5oCmluZGV4IGRjNDkxMGQ2Li5hMDQ5Y2VjIDEwMDY0NAot LS0gYS9pbmNsdWRlL2RybS9kcm1fY29ubmVjdG9yLmgKKysrIGIvaW5jbHVkZS9kcm0vZHJtX2Nv bm5lY3Rvci5oCkBAIC0yMTgsMTAgKzIxOCwxMCBAQCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0 ZSB7CiAJLyoqCiAJICogQHdyaXRlYmFja19qb2I6IFdyaXRlYmFjayBqb2IgZm9yIHdyaXRlYmFj ayBjb25uZWN0b3JzCiAJICoKLQkgKiBIb2xkcyB0aGUgZnJhbWVidWZmZXIgZm9yIGEgd3JpdGVi YWNrIGNvbm5lY3Rvci4gQXMgdGhlIHdyaXRlYmFjawotCSAqIGNvbXBsZXRpb24gbWF5IGJlIGFz eW5jaHJvbm91cyB0byB0aGUgbm9ybWFsIGNvbW1pdCBjeWNsZSwgdGhlCi0JICogd3JpdGViYWNr IGpvYiBsaWZldGltZSBpcyBtYW5hZ2VkIHNlcGFyYXRlbHkgZnJvbSB0aGUgbm9ybWFsIGF0b21p YwotCSAqIHN0YXRlIGJ5IHRoaXMgb2JqZWN0LgorCSAqIEhvbGRzIHRoZSBmcmFtZWJ1ZmZlciBh bmQgb3V0LWZlbmNlIGZvciBhIHdyaXRlYmFjayBjb25uZWN0b3IuIEFzCisJICogdGhlIHdyaXRl YmFjayBjb21wbGV0aW9uIG1heSBiZSBhc3luY2hyb25vdXMgdG8gdGhlIG5vcm1hbCBjb21taXQK KwkgKiBjeWNsZSwgdGhlIHdyaXRlYmFjayBqb2IgbGlmZXRpbWUgaXMgbWFuYWdlZCBzZXBhcmF0 ZWx5IGZyb20gdGhlCisJICogbm9ybWFsIGF0b21pYyBzdGF0ZSBieSB0aGlzIG9iamVjdC4KIAkg KgogCSAqIFNlZSBhbHNvOiBkcm1fd3JpdGViYWNrX3F1ZXVlX2pvYigpIGFuZAogCSAqIGRybV93 cml0ZWJhY2tfc2lnbmFsX2NvbXBsZXRpb24oKQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJt X3dyaXRlYmFjay5oIGIvaW5jbHVkZS9kcm0vZHJtX3dyaXRlYmFjay5oCmluZGV4IDZiMmFjNDUu Ljk4OWNlZGQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL2RybV93cml0ZWJhY2suaAorKysgYi9p bmNsdWRlL2RybS9kcm1fd3JpdGViYWNrLmgKQEAgLTM4LDYgKzM4LDMyIEBAIHN0cnVjdCBkcm1f d3JpdGViYWNrX2Nvbm5lY3RvciB7CiAJICogZHJtX3dyaXRlYmFja19zaWduYWxfY29tcGxldGlv bigpCiAJICovCiAJc3RydWN0IGxpc3RfaGVhZCBqb2JfcXVldWU7CisKKwkvKioKKwkgKiBAZmVu Y2VfY29udGV4dDoKKwkgKgorCSAqIHRpbWVsaW5lIGNvbnRleHQgdXNlZCBmb3IgZmVuY2Ugb3Bl cmF0aW9ucy4KKwkgKi8KKwl1bnNpZ25lZCBpbnQgZmVuY2VfY29udGV4dDsKKwkvKioKKwkgKiBA ZmVuY2VfbG9jazoKKwkgKgorCSAqIHNwaW5sb2NrIHRvIHByb3RlY3QgdGhlIGZlbmNlcyBpbiB0 aGUgZmVuY2VfY29udGV4dC4KKwkgKi8KKwlzcGlubG9ja190IGZlbmNlX2xvY2s7CisJLyoqCisJ ICogQGZlbmNlX3NlcW5vOgorCSAqCisJICogU2Vxbm8gdmFyaWFibGUgdXNlZCBhcyBtb25vdG9u aWMgY291bnRlciBmb3IgdGhlIGZlbmNlcworCSAqIGNyZWF0ZWQgb24gdGhlIGNvbm5lY3Rvcidz IHRpbWVsaW5lLgorCSAqLworCXVuc2lnbmVkIGxvbmcgZmVuY2Vfc2Vxbm87CisJLyoqCisJICog QHRpbWVsaW5lX25hbWU6CisJICoKKwkgKiBUaGUgbmFtZSBvZiB0aGUgY29ubmVjdG9yJ3MgZmVu Y2UgdGltZWxpbmUuCisJICovCisJY2hhciB0aW1lbGluZV9uYW1lWzMyXTsKIH07CiAKIHN0cnVj dCBkcm1fd3JpdGViYWNrX2pvYiB7CkBAIC02MSw2ICs4NywxMyBAQCBzdHJ1Y3QgZHJtX3dyaXRl YmFja19qb2IgewogCSAqIGRpcmVjdGx5LCB1c2UgZHJtX2F0b21pY19zZXRfd3JpdGViYWNrX2Zi X2Zvcl9jb25uZWN0b3IoKQogCSAqLwogCXN0cnVjdCBkcm1fZnJhbWVidWZmZXIgKmZiOworCisJ LyoqCisJICogQG91dF9mZW5jZToKKwkgKgorCSAqIEZlbmNlIHdoaWNoIHdpbGwgc2lnbmFsIG9u Y2UgdGhlIHdyaXRlYmFjayBoYXMgY29tcGxldGVkCisJICovCisJc3RydWN0IGRtYV9mZW5jZSAq b3V0X2ZlbmNlOwogfTsKIAogaW50IGRybV93cml0ZWJhY2tfY29ubmVjdG9yX2luaXQoc3RydWN0 IGRybV9kZXZpY2UgKmRldiwKQEAgLTc0LDUgKzEwNyw5IEBAIHZvaWQgZHJtX3dyaXRlYmFja19x dWV1ZV9qb2Ioc3RydWN0IGRybV93cml0ZWJhY2tfY29ubmVjdG9yICp3Yl9jb25uZWN0b3IsCiB2 b2lkIGRybV93cml0ZWJhY2tfY2xlYW51cF9qb2Ioc3RydWN0IGRybV93cml0ZWJhY2tfam9iICpq b2IpOwogCiB2b2lkCi1kcm1fd3JpdGViYWNrX3NpZ25hbF9jb21wbGV0aW9uKHN0cnVjdCBkcm1f d3JpdGViYWNrX2Nvbm5lY3RvciAqd2JfY29ubmVjdG9yKTsKK2RybV93cml0ZWJhY2tfc2lnbmFs X2NvbXBsZXRpb24oc3RydWN0IGRybV93cml0ZWJhY2tfY29ubmVjdG9yICp3Yl9jb25uZWN0b3Is CisJCQkJaW50IHN0YXR1cyk7CisKK3N0cnVjdCBkbWFfZmVuY2UgKgorZHJtX3dyaXRlYmFja19n ZXRfb3V0X2ZlbmNlKHN0cnVjdCBkcm1fd3JpdGViYWNrX2Nvbm5lY3RvciAqd2JfY29ubmVjdG9y KTsKICNlbmRpZgotLSAKMS43LjkuNQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJl ZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGlu Zm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from foss.arm.com ([217.140.101.70]:51142 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753052AbcKYQtZ (ORCPT ); Fri, 25 Nov 2016 11:49:25 -0500 From: Brian Starkey To: dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Cc: linux-media@vger.kernel.org, daniel@ffwll.ch, gustavo@padovan.org, laurent.pinchart@ideasonboard.com, eric@anholt.net, ville.syrjala@linux.intel.com, liviu.dudau@arm.com Subject: [PATCH 2/6] drm: writeback: Add out-fences for writeback connectors Date: Fri, 25 Nov 2016 16:49:00 +0000 Message-Id: <1480092544-1725-3-git-send-email-brian.starkey@arm.com> In-Reply-To: <1480092544-1725-1-git-send-email-brian.starkey@arm.com> References: <1480092544-1725-1-git-send-email-brian.starkey@arm.com> Sender: linux-media-owner@vger.kernel.org List-ID: Add the OUT_FENCE_PTR property to writeback connectors, to enable userspace to get a fence which will signal once the writeback is complete. It is not allowed to request an out-fence without a framebuffer attached to the connector. A timeline is added to drm_writeback_connector for use by the writeback out-fences. In the case of a commit failure or DRM_MODE_ATOMIC_TEST_ONLY, the fence is set to -1. Changes from v2: - Rebase onto Gustavo Padovan's v9 explicit sync series - Change out_fence_ptr type to s32 __user * - Set *out_fence_ptr to -1 in drm_atomic_connector_set_property - Store fence in drm_writeback_job Gustavo Padovan: - Move out_fence_ptr out of connector_state - Signal fence from drm_writeback_signal_completion instead of in driver directly Signed-off-by: Brian Starkey --- drivers/gpu/drm/drm_atomic.c | 96 +++++++++++++++++++++++++++++++++---- drivers/gpu/drm/drm_writeback.c | 99 ++++++++++++++++++++++++++++++++++++++- include/drm/drm_atomic.h | 8 ++++ include/drm/drm_connector.h | 8 ++-- include/drm/drm_writeback.h | 39 ++++++++++++++- 5 files changed, 234 insertions(+), 16 deletions(-) diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index 343e2b7..0e3c900 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -308,6 +308,32 @@ static s64 __user *get_out_fence_for_crtc(struct drm_atomic_state *state, return fence_ptr; } +static int set_out_fence_for_connector(struct drm_atomic_state *state, + struct drm_connector *connector, + s64 __user *fence_ptr) +{ + unsigned int index = drm_connector_index(connector); + + if (fence_ptr && put_user(-1, fence_ptr)) + return -EFAULT; + + state->connectors[index].out_fence_ptr = fence_ptr; + + return 0; +} + +static s64 __user *get_out_fence_for_connector(struct drm_atomic_state *state, + struct drm_connector *connector) +{ + unsigned int index = drm_connector_index(connector); + s64 __user *fence_ptr; + + fence_ptr = state->connectors[index].out_fence_ptr; + state->connectors[index].out_fence_ptr = NULL; + + return fence_ptr; +} + /** * drm_atomic_set_mode_for_crtc - set mode for CRTC * @state: the CRTC whose incoming state to update @@ -696,6 +722,12 @@ static int drm_atomic_connector_check(struct drm_connector *connector, return -EINVAL; } + if (writeback_job->out_fence && !writeback_job->fb) { + DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] requesting out-fence without framebuffer\n", + connector->base.id, connector->name); + return -EINVAL; + } + return 0; } @@ -1134,6 +1166,11 @@ int drm_atomic_connector_set_property(struct drm_connector *connector, if (fb) drm_framebuffer_unreference(fb); return ret; + } else if (property == config->prop_out_fence_ptr) { + s64 __user *fence_ptr = u64_to_user_ptr(val); + + return set_out_fence_for_connector(state->state, connector, + fence_ptr); } else if (connector->funcs->atomic_set_property) { return connector->funcs->atomic_set_property(connector, state, property, val); @@ -1185,6 +1222,8 @@ static void drm_atomic_connector_print_state(struct drm_printer *p, } else if (property == config->writeback_fb_id_property) { /* Writeback framebuffer is one-shot, write and forget */ *val = 0; + } else if (property == config->prop_out_fence_ptr) { + *val = 0; } else if (connector->funcs->atomic_get_property) { return connector->funcs->atomic_get_property(connector, state, property, val); @@ -1976,7 +2015,7 @@ static int setup_out_fence(struct drm_out_fence_state *fence_state, return 0; } -static int prepare_crtc_signaling(struct drm_device *dev, +static int prepare_signaling(struct drm_device *dev, struct drm_atomic_state *state, struct drm_mode_atomic *arg, struct drm_file *file_priv, @@ -1985,6 +2024,8 @@ static int prepare_crtc_signaling(struct drm_device *dev, { struct drm_crtc *crtc; struct drm_crtc_state *crtc_state; + struct drm_connector *conn; + struct drm_connector_state *conn_state; int i, ret; if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) @@ -2048,14 +2089,51 @@ static int prepare_crtc_signaling(struct drm_device *dev, } } + for_each_connector_in_state(state, conn, conn_state, i) { + struct drm_writeback_job *job; + struct drm_out_fence_state *f; + struct dma_fence *fence; + s64 __user *fence_ptr; + + fence_ptr = get_out_fence_for_connector(state, conn); + if (!fence_ptr) + continue; + + job = drm_atomic_get_writeback_job(conn_state); + if (!job) + return -ENOMEM; + + f = krealloc(*fence_state, sizeof(**fence_state) * + (*num_fences + 1), GFP_KERNEL); + if (!f) + return -ENOMEM; + + memset(&f[*num_fences], 0, sizeof(*f)); + + f[*num_fences].out_fence_ptr = fence_ptr; + *fence_state = f; + + fence = drm_writeback_get_out_fence((struct drm_writeback_connector *)conn); + if (!fence) + return -ENOMEM; + + ret = setup_out_fence(&f[(*num_fences)++], fence); + if (ret) { + dma_fence_put(fence); + return ret; + } + + job->out_fence = fence; + } + return 0; } -static void complete_crtc_signaling(struct drm_device *dev, - struct drm_atomic_state *state, - struct drm_out_fence_state *fence_state, - unsigned int num_fences, - bool install_fds) +static void complete_signaling(struct drm_device *dev, + struct drm_atomic_state *state, + struct drm_out_fence_state *fence_state, + unsigned int num_fences, + bool install_fds) { struct drm_crtc *crtc; struct drm_crtc_state *crtc_state; @@ -2228,8 +2306,8 @@ int drm_mode_atomic_ioctl(struct drm_device *dev, drm_mode_object_unreference(obj); } - ret = prepare_crtc_signaling(dev, state, arg, file_priv, &fence_state, - &num_fences); + ret = prepare_signaling(dev, state, arg, file_priv, &fence_state, + &num_fences); if (ret) goto out; @@ -2251,7 +2329,7 @@ int drm_mode_atomic_ioctl(struct drm_device *dev, out: drm_atomic_clean_old_fb(dev, plane_mask, ret); - complete_crtc_signaling(dev, state, fence_state, num_fences, !ret); + complete_signaling(dev, state, fence_state, num_fences, !ret); if (ret == -EDEADLK) { drm_atomic_state_clear(state); diff --git a/drivers/gpu/drm/drm_writeback.c b/drivers/gpu/drm/drm_writeback.c index 75a1dbf..3637b9a 100644 --- a/drivers/gpu/drm/drm_writeback.c +++ b/drivers/gpu/drm/drm_writeback.c @@ -12,6 +12,7 @@ #include #include #include +#include /** * DOC: overview @@ -29,6 +30,16 @@ * framebuffer applies only to a single commit (see below). A framebuffer may * not be attached while the CRTC is off. * + * Unlike with planes, when a writeback framebuffer is removed by userspace DRM + * makes no attempt to remove it from active use by the connector. This is + * because no method is provided to abort a writeback operation, and in any + * case making a new commit whilst a writeback is ongoing is undefined (see + * OUT_FENCE_PTR below). As soon as the current writeback is finished, the + * framebuffer will automatically no longer be in active use. As it will also + * have already been removed from the framebuffer list, there will be no way for + * any userspace application to retrieve a reference to it in the intervening + * period. + * * Writeback connectors have some additional properties, which userspace * can use to query and control them: * @@ -45,8 +56,54 @@ * data is an array of u32 DRM_FORMAT_* fourcc values. * Userspace can use this blob to find out what pixel formats are supported * by the connector's writeback engine. + * + * "OUT_FENCE_PTR": + * Userspace can use this property to provide a pointer for the kernel to + * fill with a sync_file file descriptor, which will signal once the + * writeback is finished. The value should be the address of a 64-bit + * signed integer, cast to a u64. + * Userspace should wait for this fence to signal before making another + * commit affecting any of the same CRTCs, Planes or Connectors. + * **Failure to do so will result in undefined behaviour.** + * For this reason it is strongly recommended that all userspace + * applications making use of writeback connectors *always* retrieve an + * out-fence for the commit and use it appropriately. + * From userspace, this property will always read as zero. */ +#define fence_to_wb_connector(x) container_of(x->lock, \ + struct drm_writeback_connector, \ + fence_lock) + +static const char *drm_writeback_fence_get_driver_name(struct dma_fence *fence) +{ + struct drm_writeback_connector *wb_connector = + fence_to_wb_connector(fence); + + return wb_connector->base.dev->driver->name; +} + +static const char * +drm_writeback_fence_get_timeline_name(struct dma_fence *fence) +{ + struct drm_writeback_connector *wb_connector = + fence_to_wb_connector(fence); + + return wb_connector->timeline_name; +} + +static bool drm_writeback_fence_enable_signaling(struct dma_fence *fence) +{ + return true; +} + +static const struct dma_fence_ops drm_writeback_fence_ops = { + .get_driver_name = drm_writeback_fence_get_driver_name, + .get_timeline_name = drm_writeback_fence_get_timeline_name, + .enable_signaling = drm_writeback_fence_enable_signaling, + .wait = dma_fence_default_wait, +}; + static bool create_writeback_properties(struct drm_device *dev) { struct drm_property *prop; @@ -115,6 +172,15 @@ int drm_writeback_connector_init(struct drm_device *dev, INIT_LIST_HEAD(&wb_connector->job_queue); spin_lock_init(&wb_connector->job_lock); + wb_connector->fence_context = dma_fence_context_alloc(1); + spin_lock_init(&wb_connector->fence_lock); + snprintf(wb_connector->timeline_name, + sizeof(wb_connector->timeline_name), + "CONNECTOR:%d-%s", connector->base.id, connector->name); + + drm_object_attach_property(&connector->base, + config->prop_out_fence_ptr, 0); + drm_object_attach_property(&connector->base, config->writeback_fb_id_property, 0); @@ -173,6 +239,7 @@ void drm_writeback_cleanup_job(struct drm_writeback_job *job) if (job->fb) drm_framebuffer_unreference(job->fb); + dma_fence_put(job->out_fence); kfree(job); } EXPORT_SYMBOL(drm_writeback_cleanup_job); @@ -195,6 +262,7 @@ static void cleanup_work(struct work_struct *work) /** * @drm_writeback_signal_completion: Signal the completion of a writeback job * @wb_connector: The writeback connector whose job is complete + * @status: Status code to set in the writeback out_fence (0 for success) * * Drivers should call this to signal the completion of a previously queued * writeback job. It should be called as soon as possible after the hardware @@ -208,7 +276,8 @@ static void cleanup_work(struct work_struct *work) * See also: drm_writeback_queue_job() */ void -drm_writeback_signal_completion(struct drm_writeback_connector *wb_connector) +drm_writeback_signal_completion(struct drm_writeback_connector *wb_connector, + int status) { unsigned long flags; struct drm_writeback_job *job; @@ -217,8 +286,13 @@ static void cleanup_work(struct work_struct *work) job = list_first_entry_or_null(&wb_connector->job_queue, struct drm_writeback_job, list_entry); - if (job) + if (job) { list_del(&job->list_entry); + if (job->out_fence) { + job->out_fence->status = status; + dma_fence_signal(job->out_fence); + } + } spin_unlock_irqrestore(&wb_connector->job_lock, flags); if (WARN_ON(!job)) @@ -228,3 +302,24 @@ static void cleanup_work(struct work_struct *work) queue_work(system_long_wq, &job->cleanup_work); } EXPORT_SYMBOL(drm_writeback_signal_completion); + +struct dma_fence * +drm_writeback_get_out_fence(struct drm_writeback_connector *wb_connector) +{ + struct dma_fence *fence; + + if (WARN_ON(wb_connector->base.connector_type != + DRM_MODE_CONNECTOR_WRITEBACK)) + return NULL; + + fence = kzalloc(sizeof(*fence), GFP_KERNEL); + if (!fence) + return NULL; + + dma_fence_init(fence, &drm_writeback_fence_ops, + &wb_connector->fence_lock, wb_connector->fence_context, + ++wb_connector->fence_seqno); + + return fence; +} +EXPORT_SYMBOL(drm_writeback_get_out_fence); diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h index 476561d..7c4ad0b 100644 --- a/include/drm/drm_atomic.h +++ b/include/drm/drm_atomic.h @@ -150,6 +150,14 @@ struct __drm_crtcs_state { struct __drm_connnectors_state { struct drm_connector *ptr; struct drm_connector_state *state; + /** + * @out_fence_ptr: + * + * User-provided pointer which the kernel uses to return a sync_file + * file descriptor. Used by writeback connectors to signal completion of + * the writeback. + */ + s64 __user *out_fence_ptr; }; /** diff --git a/include/drm/drm_connector.h b/include/drm/drm_connector.h index dc4910d6..a049cec 100644 --- a/include/drm/drm_connector.h +++ b/include/drm/drm_connector.h @@ -218,10 +218,10 @@ struct drm_connector_state { /** * @writeback_job: Writeback job for writeback connectors * - * Holds the framebuffer for a writeback connector. As the writeback - * completion may be asynchronous to the normal commit cycle, the - * writeback job lifetime is managed separately from the normal atomic - * state by this object. + * Holds the framebuffer and out-fence for a writeback connector. As + * the writeback completion may be asynchronous to the normal commit + * cycle, the writeback job lifetime is managed separately from the + * normal atomic state by this object. * * See also: drm_writeback_queue_job() and * drm_writeback_signal_completion() diff --git a/include/drm/drm_writeback.h b/include/drm/drm_writeback.h index 6b2ac45..989cedd 100644 --- a/include/drm/drm_writeback.h +++ b/include/drm/drm_writeback.h @@ -38,6 +38,32 @@ struct drm_writeback_connector { * drm_writeback_signal_completion() */ struct list_head job_queue; + + /** + * @fence_context: + * + * timeline context used for fence operations. + */ + unsigned int fence_context; + /** + * @fence_lock: + * + * spinlock to protect the fences in the fence_context. + */ + spinlock_t fence_lock; + /** + * @fence_seqno: + * + * Seqno variable used as monotonic counter for the fences + * created on the connector's timeline. + */ + unsigned long fence_seqno; + /** + * @timeline_name: + * + * The name of the connector's fence timeline. + */ + char timeline_name[32]; }; struct drm_writeback_job { @@ -61,6 +87,13 @@ struct drm_writeback_job { * directly, use drm_atomic_set_writeback_fb_for_connector() */ struct drm_framebuffer *fb; + + /** + * @out_fence: + * + * Fence which will signal once the writeback has completed + */ + struct dma_fence *out_fence; }; int drm_writeback_connector_init(struct drm_device *dev, @@ -74,5 +107,9 @@ void drm_writeback_queue_job(struct drm_writeback_connector *wb_connector, void drm_writeback_cleanup_job(struct drm_writeback_job *job); void -drm_writeback_signal_completion(struct drm_writeback_connector *wb_connector); +drm_writeback_signal_completion(struct drm_writeback_connector *wb_connector, + int status); + +struct dma_fence * +drm_writeback_get_out_fence(struct drm_writeback_connector *wb_connector); #endif -- 1.7.9.5