From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Paul Subject: [PATCH 3/4] drm/nouveau: dispnv50: Use less encoders by making mstos per-head Date: Fri, 13 Sep 2019 18:03:52 -0400 Message-ID: <20190913220355.6883-3-lyude@redhat.com> References: <20190913220355.6883-1-lyude@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190913220355.6883-1-lyude-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: nouveau-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "Nouveau" To: nouveau-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Cc: David Airlie , Maarten Lankhorst , Peteris Rudzusiks , linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, Ben Skeggs , Daniel Vetter , Sam Ravnborg , Laurent Pinchart List-Id: nouveau.vger.kernel.org Q3VycmVudGx5LCBmb3IgZXZlcnkgc2luZ2xlIE1TVCBjYXBhYmxlIERSTSBjb25uZWN0b3Igd2Ug Y3JlYXRlIGEgc2V0IG9mCmZha2UgZW5jb2RlcnMsIG9uZSBmb3IgZWFjaCBwb3NzaWJsZSBoZWFk LiBVbmZvcnR1bmF0ZWx5IHRoaXMgZW5kcyB1cApiZWluZyBhIGh1Z2Ugd2FzdGUgb2YgZW5jb2Rl cnMuIFdoaWxlIHRoaXMgY3VycmVudGx5IGlzbid0IGNhdXNpbmcgdXMKYW55IHByb2JsZW1zLCBp dCdzIGV4dHJlbWVseSBjbG9zZSB0byBkb2luZyBzby4KClRoZSBUaGlua1BhZCBQNzEgaXMgYSBn b29kIGV4YW1wbGUgb2YgdGhpcy4gT3JpZ2luYWxseSB3aGVuIHRyeWluZyB0bwpmaWd1cmUgb3V0 IHdoeSBub3V2ZWF1IHdhcyBmYWlsaW5nIHRvIGxvYWQgb24gdGhpcyBsYXB0b3AsIEkgZGlzY292 ZXJlZAppdCB3YXMgYmVjYXVzZSBub3V2ZWF1IHdhcyBjcmVhdGluZyB0b28gbWFueSBlbmNvZGVy cy4gVGhpcyBlbmRlZCB1cApiZWluZyBiZWNhdXNlIHdlIHdlcmUgbWlzdGFrZW5seSBjcmVhdGlu ZyBNU1QgZW5jb2RlcnMgZm9yIHRoZSBlRFAgcG9ydCwKaG93ZXZlciB3ZSBhcmUgc3RpbGwgZXh0 cmVtZWx5IGNsb3NlIHRvIGhpdHRpbmcgdGhlIGVuY29kZXIgbGltaXQgb24KdGhpcyBtYWNoaW5l IGFzIGl0IGV4cG9zZXMgMSBlRFAgcG9ydCBhbmQgNSBEUCBwb3J0cywgcmVzdWx0aW5nIGluIDMx CmVuY29kZXJzLgoKU28gd2hpbGUgdGhpcyBmaXggZGlkbid0IGVuZCB1cCBiZWluZyBuZWNlc3Nh cnkgdG8gZml4IHRoZSBQNzEsIHdlIHN0aWxsCm5lZWQgdG8gaW1wbGVtZW50IHRoaXMgc28gdGhh dCB3ZSBhdm9pZCBoaXR0aW5nIHRoZSBlbmNvZGVyIGxpbWl0IGZvcgp2YWxpZCBkaXNwbGF5IGNv bmZpZ3VyYXRpb25zIGluIHRoZSBldmVudCB0aGF0IHNvbWUgbWFjaGluZSB3aXRoIG1vcmUKY29u bmVjdG9ycyB0aGVuIHRoaXMgYmVjb21lcyBhdmFpbGFibGUuIFBsdXMsIHdlIGRvbid0IHdhbnQg dG8gbGV0IGdvb2QKY29kZSBnbyB0byB3YXN0ZSA6KQoKU28sIHVzZSBsZXNzIGVuY29kZXJzIGJ5 IG9ubHkgY3JlYXRpbmcgb25lIE1TVE8gcGVyIGhlYWQuIFRoZW4sIGF0dGFjaAplYWNoIG5ldyBN U1RDIHRvIGVhY2ggTVNUTyB3aGljaCBjb3JyZXNwb25kcyB0byBhIGhlYWQgdGhhdCBpdCdzIHBh cmVudApEUCBwb3J0IGlzIGNhcGFibGUgb2YgdXNpbmcuIFRoaXMgYnJpbmdzIHRoZSBudW1iZXIg b2YgZW5jb2RlcnMgd2UKcmVnaXN0ZXIgb24gdGhlIFRoaW5rUGFkIFA3MSBmcm9tIDMxLCBkb3du IHRvIGp1c3QgMTUuIFlheSEKClNpZ25lZC1vZmYtYnk6IEx5dWRlIFBhdWwgPGx5dWRlQHJlZGhh dC5jb20+Ci0tLQogZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvZGlzcG52NTAvZGlzcC5jIHwgOTIg KysrKysrKysrKysrKysrLS0tLS0tLS0tLQogZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvZGlzcG52 NTAvZGlzcC5oIHwgIDIgKwogZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvZGlzcG52NTAvaGVhZC5j IHwgMTcgKysrLS0KIGRyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2Rpc3BudjUwL2hlYWQuaCB8ICAz ICstCiA0IGZpbGVzIGNoYW5nZWQsIDY4IGluc2VydGlvbnMoKyksIDQ2IGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2Rpc3BudjUwL2Rpc3AuYyBiL2Ry aXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2Rpc3BudjUwL2Rpc3AuYwppbmRleCBhM2YzNTBmZGZhOGMu LmQyM2FjMTM3NjNiNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvZGlzcG52 NTAvZGlzcC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2Rpc3BudjUwL2Rpc3AuYwpA QCAtNjUwLDcgKzY1MCw2IEBAIHN0cnVjdCBudjUwX21zdG0gewogCXN0cnVjdCBub3V2ZWF1X2Vu Y29kZXIgKm91dHA7CiAKIAlzdHJ1Y3QgZHJtX2RwX21zdF90b3BvbG9neV9tZ3IgbWdyOwotCXN0 cnVjdCBudjUwX21zdG8gKm1zdG9bNF07CiAKIAlib29sIG1vZGlmaWVkOwogCWJvb2wgZGlzYWJs ZWQ7CkBAIC03MTYsNyArNzE1LDYgQEAgbnY1MF9tc3RvX2NsZWFudXAoc3RydWN0IG52NTBfbXN0 byAqbXN0bykKIAlkcm1fZHBfbXN0X2RlYWxsb2NhdGVfdmNwaSgmbXN0bS0+bWdyLCBtc3RjLT5w b3J0KTsKIAogCW1zdG8tPm1zdGMgPSBOVUxMOwotCW1zdG8tPmhlYWQgPSBOVUxMOwogCW1zdG8t PmRpc2FibGVkID0gZmFsc2U7CiB9CiAKQEAgLTg0Niw3ICs4NDQsNiBAQCBudjUwX21zdG9fZW5h YmxlKHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2RlcikKIAogCW1zdG0tPm91dHAtPnVwZGF0ZSht c3RtLT5vdXRwLCBoZWFkLT5iYXNlLmluZGV4LCBhcm1oLCBwcm90bywgZGVwdGgpOwogCi0JbXN0 by0+aGVhZCA9IGhlYWQ7CiAJbXN0by0+bXN0YyA9IG1zdGM7CiAJbXN0bS0+bW9kaWZpZWQgPSB0 cnVlOwogfQpAQCAtODg3LDM3ICs4ODQsNDAgQEAgbnY1MF9tc3RvID0gewogCS5kZXN0cm95ID0g bnY1MF9tc3RvX2Rlc3Ryb3ksCiB9OwogCi1zdGF0aWMgaW50Ci1udjUwX21zdG9fbmV3KHN0cnVj dCBkcm1fZGV2aWNlICpkZXYsIHUzMiBoZWFkcywgY29uc3QgY2hhciAqbmFtZSwgaW50IGlkLAot CSAgICAgIHN0cnVjdCBudjUwX21zdG8gKipwbXN0bykKK3N0YXRpYyBzdHJ1Y3QgbnY1MF9tc3Rv ICoKK252NTBfbXN0b19uZXcoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgc3RydWN0IG52NTBfaGVh ZCAqaGVhZCwgaW50IGlkKQogewogCXN0cnVjdCBudjUwX21zdG8gKm1zdG87CiAJaW50IHJldDsK IAotCWlmICghKG1zdG8gPSAqcG1zdG8gPSBremFsbG9jKHNpemVvZigqbXN0byksIEdGUF9LRVJO RUwpKSkKLQkJcmV0dXJuIC1FTk9NRU07CisJbXN0byA9IGt6YWxsb2Moc2l6ZW9mKCptc3RvKSwg R0ZQX0tFUk5FTCk7CisJaWYgKCFtc3RvKQorCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKIAog CXJldCA9IGRybV9lbmNvZGVyX2luaXQoZGV2LCAmbXN0by0+ZW5jb2RlciwgJm52NTBfbXN0bywK LQkJCSAgICAgICBEUk1fTU9ERV9FTkNPREVSX0RQTVNULCAiJXMtbXN0LSVkIiwgbmFtZSwgaWQp OworCQkJICAgICAgIERSTV9NT0RFX0VOQ09ERVJfRFBNU1QsICJtc3QtJWQiLCBpZCk7CiAJaWYg KHJldCkgewotCQlrZnJlZSgqcG1zdG8pOwotCQkqcG1zdG8gPSBOVUxMOwotCQlyZXR1cm4gcmV0 OworCQlrZnJlZShtc3RvKTsKKwkJcmV0dXJuIEVSUl9QVFIocmV0KTsKIAl9CiAKIAlkcm1fZW5j b2Rlcl9oZWxwZXJfYWRkKCZtc3RvLT5lbmNvZGVyLCAmbnY1MF9tc3RvX2hlbHApOwotCW1zdG8t PmVuY29kZXIucG9zc2libGVfY3J0Y3MgPSBoZWFkczsKLQlyZXR1cm4gMDsKKwltc3RvLT5lbmNv ZGVyLnBvc3NpYmxlX2NydGNzID0gZHJtX2NydGNfbWFzaygmaGVhZC0+YmFzZS5iYXNlKTsKKwlt c3RvLT5oZWFkID0gaGVhZDsKKwlyZXR1cm4gbXN0bzsKIH0KIAogc3RhdGljIHN0cnVjdCBkcm1f ZW5jb2RlciAqCiBudjUwX21zdGNfYXRvbWljX2Jlc3RfZW5jb2RlcihzdHJ1Y3QgZHJtX2Nvbm5l Y3RvciAqY29ubmVjdG9yLAogCQkJICAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNv bm5lY3Rvcl9zdGF0ZSkKIHsKLQlzdHJ1Y3QgbnY1MF9oZWFkICpoZWFkID0gbnY1MF9oZWFkKGNv bm5lY3Rvcl9zdGF0ZS0+Y3J0Yyk7CiAJc3RydWN0IG52NTBfbXN0YyAqbXN0YyA9IG52NTBfbXN0 Yyhjb25uZWN0b3IpOworCXN0cnVjdCBkcm1fY3J0YyAqY3J0YyA9IGNvbm5lY3Rvcl9zdGF0ZS0+ Y3J0YzsKIAotCXJldHVybiAmbXN0Yy0+bXN0bS0+bXN0b1toZWFkLT5iYXNlLmluZGV4XS0+ZW5j b2RlcjsKKwlpZiAoIShtc3RjLT5tc3RtLT5vdXRwLT5kY2ItPmhlYWRzICYgZHJtX2NydGNfbWFz ayhjcnRjKSkpCisJCXJldHVybiBOVUxMOworCisJcmV0dXJuICZudjUwX2hlYWQoY3J0YyktPm1z dG8tPmVuY29kZXI7CiB9CiAKIHN0YXRpYyBlbnVtIGRybV9tb2RlX3N0YXR1cwpAQCAtMTAzNiw4 ICsxMDM2LDkgQEAgbnY1MF9tc3RjX25ldyhzdHJ1Y3QgbnY1MF9tc3RtICptc3RtLCBzdHJ1Y3Qg ZHJtX2RwX21zdF9wb3J0ICpwb3J0LAogCSAgICAgIGNvbnN0IGNoYXIgKnBhdGgsIHN0cnVjdCBu djUwX21zdGMgKipwbXN0YykKIHsKIAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gbXN0bS0+b3V0 cC0+YmFzZS5iYXNlLmRldjsKKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGM7CiAJc3RydWN0IG52NTBf bXN0YyAqbXN0YzsKLQlpbnQgcmV0LCBpOworCWludCByZXQ7CiAKIAlpZiAoIShtc3RjID0gKnBt c3RjID0ga3phbGxvYyhzaXplb2YoKm1zdGMpLCBHRlBfS0VSTkVMKSkpCiAJCXJldHVybiAtRU5P TUVNOwpAQCAtMTA1Nyw4ICsxMDU4LDEzIEBAIG52NTBfbXN0Y19uZXcoc3RydWN0IG52NTBfbXN0 bSAqbXN0bSwgc3RydWN0IGRybV9kcF9tc3RfcG9ydCAqcG9ydCwKIAltc3RjLT5jb25uZWN0b3Iu ZnVuY3MtPnJlc2V0KCZtc3RjLT5jb25uZWN0b3IpOwogCW5vdXZlYXVfY29ubl9hdHRhY2hfcHJv cGVydGllcygmbXN0Yy0+Y29ubmVjdG9yKTsKIAotCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpF KG1zdG0tPm1zdG8pICYmIG1zdG0tPm1zdG9baV07IGkrKykKLQkJZHJtX2Nvbm5lY3Rvcl9hdHRh Y2hfZW5jb2RlcigmbXN0Yy0+Y29ubmVjdG9yLCAmbXN0bS0+bXN0b1tpXS0+ZW5jb2Rlcik7CisJ ZHJtX2Zvcl9lYWNoX2NydGMoY3J0YywgZGV2KSB7CisJCWlmICghKG1zdG0tPm91dHAtPmRjYi0+ aGVhZHMgJiBkcm1fY3J0Y19tYXNrKGNydGMpKSkKKwkJCWNvbnRpbnVlOworCisJCWRybV9jb25u ZWN0b3JfYXR0YWNoX2VuY29kZXIoJm1zdGMtPmNvbm5lY3RvciwKKwkJCQkJICAgICAmbnY1MF9o ZWFkKGNydGMpLT5tc3RvLT5lbmNvZGVyKTsKKwl9CiAKIAlkcm1fb2JqZWN0X2F0dGFjaF9wcm9w ZXJ0eSgmbXN0Yy0+Y29ubmVjdG9yLmJhc2UsIGRldi0+bW9kZV9jb25maWcucGF0aF9wcm9wZXJ0 eSwgMCk7CiAJZHJtX29iamVjdF9hdHRhY2hfcHJvcGVydHkoJm1zdGMtPmNvbm5lY3Rvci5iYXNl LCBkZXYtPm1vZGVfY29uZmlnLnRpbGVfcHJvcGVydHksIDApOwpAQCAtMTMzMiw3ICsxMzM4LDcg QEAgbnY1MF9tc3RtX25ldyhzdHJ1Y3Qgbm91dmVhdV9lbmNvZGVyICpvdXRwLCBzdHJ1Y3QgZHJt X2RwX2F1eCAqYXV4LCBpbnQgYXV4X21heCwKIAljb25zdCBpbnQgbWF4X3BheWxvYWRzID0gaHdl aWdodDgob3V0cC0+ZGNiLT5oZWFkcyk7CiAJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IG91dHAt PmJhc2UuYmFzZS5kZXY7CiAJc3RydWN0IG52NTBfbXN0bSAqbXN0bTsKLQlpbnQgcmV0LCBpOwor CWludCByZXQ7CiAJdTggZHBjZDsKIAogCS8qIFRoaXMgaXMgYSB3b3JrYXJvdW5kIGZvciBzb21l IG1vbml0b3JzIG5vdCBmdW5jdGlvbmluZwpAQCAtMTM1NSwxMyArMTM2MSw2IEBAIG52NTBfbXN0 bV9uZXcoc3RydWN0IG5vdXZlYXVfZW5jb2RlciAqb3V0cCwgc3RydWN0IGRybV9kcF9hdXggKmF1 eCwgaW50IGF1eF9tYXgsCiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKIAotCWZvciAoaSA9IDA7 IGkgPCBtYXhfcGF5bG9hZHM7IGkrKykgewotCQlyZXQgPSBudjUwX21zdG9fbmV3KGRldiwgb3V0 cC0+ZGNiLT5oZWFkcywgb3V0cC0+YmFzZS5iYXNlLm5hbWUsCi0JCQkJICAgIGksICZtc3RtLT5t c3RvW2ldKTsKLQkJaWYgKHJldCkKLQkJCXJldHVybiByZXQ7Ci0JfQotCiAJcmV0dXJuIDA7CiB9 CiAKQEAgLTE1NDAsMTcgKzE1MzksMjQgQEAgbnY1MF9zb3JfZnVuYyA9IHsKIAkuZGVzdHJveSA9 IG52NTBfc29yX2Rlc3Ryb3ksCiB9OwogCitzdGF0aWMgYm9vbCBudjUwX2hhc19tc3Qoc3RydWN0 IG5vdXZlYXVfZHJtICpkcm0pCit7CisJc3RydWN0IG52a21fYmlvcyAqYmlvcyA9IG52eHhfYmlv cygmZHJtLT5jbGllbnQuZGV2aWNlKTsKKwl1MzIgZGF0YTsKKwl1OCB2ZXIsIGhkciwgY250LCBs ZW47CisKKwlkYXRhID0gbnZiaW9zX2RwX3RhYmxlKGJpb3MsICZ2ZXIsICZoZHIsICZjbnQsICZs ZW4pOworCXJldHVybiBkYXRhICYmIHZlciA+PSAweDQwICYmIChudmJpb3NfcmQwOChiaW9zLCBk YXRhICsgMHgwOCkgJiAweDA0KTsKK30KKwogc3RhdGljIGludAogbnY1MF9zb3JfY3JlYXRlKHN0 cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsIHN0cnVjdCBkY2Jfb3V0cHV0ICpkY2JlKQog ewogCXN0cnVjdCBub3V2ZWF1X2Nvbm5lY3RvciAqbnZfY29ubmVjdG9yID0gbm91dmVhdV9jb25u ZWN0b3IoY29ubmVjdG9yKTsKIAlzdHJ1Y3Qgbm91dmVhdV9kcm0gKmRybSA9IG5vdXZlYXVfZHJt KGNvbm5lY3Rvci0+ZGV2KTsKLQlzdHJ1Y3QgbnZrbV9iaW9zICpiaW9zID0gbnZ4eF9iaW9zKCZk cm0tPmNsaWVudC5kZXZpY2UpOwogCXN0cnVjdCBudmttX2kyYyAqaTJjID0gbnZ4eF9pMmMoJmRy bS0+Y2xpZW50LmRldmljZSk7CiAJc3RydWN0IG5vdXZlYXVfZW5jb2RlciAqbnZfZW5jb2RlcjsK IAlzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXI7Ci0JdTggdmVyLCBoZHIsIGNudCwgbGVuOwot CXUzMiBkYXRhOwogCWludCB0eXBlLCByZXQ7CiAKIAlzd2l0Y2ggKGRjYmUtPnR5cGUpIHsKQEAg LTE1OTUsMTAgKzE2MDEsOSBAQCBudjUwX3Nvcl9jcmVhdGUoc3RydWN0IGRybV9jb25uZWN0b3Ig KmNvbm5lY3Rvciwgc3RydWN0IGRjYl9vdXRwdXQgKmRjYmUpCiAJCX0KIAogCQlpZiAobnZfY29u bmVjdG9yLT50eXBlICE9IERDQl9DT05ORUNUT1JfZURQICYmCi0JCSAgICAoZGF0YSA9IG52Ymlv c19kcF90YWJsZShiaW9zLCAmdmVyLCAmaGRyLCAmY250LCAmbGVuKSkgJiYKLQkJICAgIHZlciA+ PSAweDQwICYmIChudmJpb3NfcmQwOChiaW9zLCBkYXRhICsgMHgwOCkgJiAweDA0KSkgewotCQkJ cmV0ID0gbnY1MF9tc3RtX25ldyhudl9lbmNvZGVyLCAmbnZfY29ubmVjdG9yLT5hdXgsIDE2LAot CQkJCQkgICAgbnZfY29ubmVjdG9yLT5iYXNlLmJhc2UuaWQsCisJCSAgICBudjUwX2hhc19tc3Qo ZHJtKSkgeworCQkJcmV0ID0gbnY1MF9tc3RtX25ldyhudl9lbmNvZGVyLCAmbnZfY29ubmVjdG9y LT5hdXgsCisJCQkJCSAgICAxNiwgbnZfY29ubmVjdG9yLT5iYXNlLmJhc2UuaWQsCiAJCQkJCSAg ICAmbnZfZW5jb2Rlci0+ZHAubXN0bSk7CiAJCQlpZiAocmV0KQogCQkJCXJldHVybiByZXQ7CkBA IC0yMjk0LDYgKzIyOTksNyBAQCBudjUwX2Rpc3BsYXlfY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNl ICpkZXYpCiAJc3RydWN0IG52NTBfZGlzcCAqZGlzcDsKIAlzdHJ1Y3QgZGNiX291dHB1dCAqZGNi ZTsKIAlpbnQgY3J0Y3MsIHJldCwgaTsKKwlib29sIGhhc19tc3QgPSBudjUwX2hhc19tc3QoZHJt KTsKIAogCWRpc3AgPSBremFsbG9jKHNpemVvZigqZGlzcCksIEdGUF9LRVJORUwpOwogCWlmICgh ZGlzcCkKQEAgLTIzNDIsMTEgKzIzNDgsMjUgQEAgbnY1MF9kaXNwbGF5X2NyZWF0ZShzdHJ1Y3Qg ZHJtX2RldmljZSAqZGV2KQogCQljcnRjcyA9IDB4MzsKIAogCWZvciAoaSA9IDA7IGkgPCBmbHMo Y3J0Y3MpOyBpKyspIHsKKwkJc3RydWN0IG52NTBfaGVhZCAqaGVhZDsKKwogCQlpZiAoIShjcnRj cyAmICgxIDw8IGkpKSkKIAkJCWNvbnRpbnVlOwotCQlyZXQgPSBudjUwX2hlYWRfY3JlYXRlKGRl diwgaSk7Ci0JCWlmIChyZXQpCisKKwkJaGVhZCA9IG52NTBfaGVhZF9jcmVhdGUoZGV2LCBpKTsK KwkJaWYgKElTX0VSUihoZWFkKSkgeworCQkJcmV0ID0gUFRSX0VSUihoZWFkKTsKIAkJCWdvdG8g b3V0OworCQl9CisKKwkJaWYgKGhhc19tc3QpIHsKKwkJCWhlYWQtPm1zdG8gPSBudjUwX21zdG9f bmV3KGRldiwgaGVhZCwgaSk7CisJCQlpZiAoSVNfRVJSKGhlYWQtPm1zdG8pKSB7CisJCQkJcmV0 ID0gUFRSX0VSUihoZWFkLT5tc3RvKTsKKwkJCQloZWFkLT5tc3RvID0gTlVMTDsKKwkJCQlnb3Rv IG91dDsKKwkJCX0KKwkJfQogCX0KIAogCS8qIGNyZWF0ZSBlbmNvZGVyL2Nvbm5lY3RvciBvYmpl Y3RzIGJhc2VkIG9uIFZCSU9TIERDQiB0YWJsZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL25vdXZlYXUvZGlzcG52NTAvZGlzcC5oIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvZGlz cG52NTAvZGlzcC5oCmluZGV4IDdjNDFiMDU5OWQxYS4uYjE2ZjRhYTA5ZTAyIDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9kaXNwbnY1MC9kaXNwLmgKKysrIGIvZHJpdmVycy9n cHUvZHJtL25vdXZlYXUvZGlzcG52NTAvZGlzcC5oCkBAIC00LDYgKzQsOCBAQAogCiAjaW5jbHVk ZSAibm91dmVhdV9kaXNwbGF5LmgiCiAKK3N0cnVjdCBudjUwX21zdG87CisKIHN0cnVjdCBudjUw X2Rpc3AgewogCXN0cnVjdCBudmlmX2Rpc3AgKmRpc3A7CiAJc3RydWN0IG52NTBfY29yZSAqY29y ZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2Rpc3BudjUwL2hlYWQuYyBi L2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2Rpc3BudjUwL2hlYWQuYwppbmRleCA3MWMyM2JmMWZl MjUuLmJkMmY2YmY1ZWRmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvZGlz cG52NTAvaGVhZC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2Rpc3BudjUwL2hlYWQu YwpAQCAtNDc0LDcgKzQ3NCw3IEBAIG52NTBfaGVhZF9mdW5jID0gewogCS5hdG9taWNfZGVzdHJv eV9zdGF0ZSA9IG52NTBfaGVhZF9hdG9taWNfZGVzdHJveV9zdGF0ZSwKIH07CiAKLWludAorc3Ry dWN0IG52NTBfaGVhZCAqCiBudjUwX2hlYWRfY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYs IGludCBpbmRleCkKIHsKIAlzdHJ1Y3Qgbm91dmVhdV9kcm0gKmRybSA9IG5vdXZlYXVfZHJtKGRl dik7CkBAIC00ODYsNyArNDg2LDcgQEAgbnY1MF9oZWFkX2NyZWF0ZShzdHJ1Y3QgZHJtX2Rldmlj ZSAqZGV2LCBpbnQgaW5kZXgpCiAKIAloZWFkID0ga3phbGxvYyhzaXplb2YoKmhlYWQpLCBHRlBf S0VSTkVMKTsKIAlpZiAoIWhlYWQpCi0JCXJldHVybiAtRU5PTUVNOworCQlyZXR1cm4gRVJSX1BU UigtRU5PTUVNKTsKIAogCWhlYWQtPmZ1bmMgPSBkaXNwLT5jb3JlLT5mdW5jLT5oZWFkOwogCWhl YWQtPmJhc2UuaW5kZXggPSBpbmRleDsKQEAgLTUwNCw3ICs1MDQsNyBAQCBudjUwX2hlYWRfY3Jl YXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIGludCBpbmRleCkKIAkJcmV0ID0gbnY1MF9jdXJz X25ldyhkcm0sIGhlYWQtPmJhc2UuaW5kZXgsICZjdXJzKTsKIAlpZiAocmV0KSB7CiAJCWtmcmVl KGhlYWQpOwotCQlyZXR1cm4gcmV0OworCQlyZXR1cm4gRVJSX1BUUihyZXQpOwogCX0KIAogCWNy dGMgPSAmaGVhZC0+YmFzZS5iYXNlOwpAQCAtNTE5LDEyICs1MTksMTEgQEAgbnY1MF9oZWFkX2Ny ZWF0ZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBpbnQgaW5kZXgpCiAKIAlpZiAoaGVhZC0+ZnVu Yy0+b2x1dF9zZXQpIHsKIAkJcmV0ID0gbnY1MF9sdXRfaW5pdChkaXNwLCAmZHJtLT5jbGllbnQu bW11LCAmaGVhZC0+b2x1dCk7Ci0JCWlmIChyZXQpCi0JCQlnb3RvIG91dDsKKwkJaWYgKHJldCkg eworCQkJbnY1MF9oZWFkX2Rlc3Ryb3koY3J0Yyk7CisJCQlyZXR1cm4gRVJSX1BUUihyZXQpOwor CQl9CiAJfQogCi1vdXQ6Ci0JaWYgKHJldCkKLQkJbnY1MF9oZWFkX2Rlc3Ryb3koY3J0Yyk7Ci0J cmV0dXJuIHJldDsKKwlyZXR1cm4gaGVhZDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9ub3V2ZWF1L2Rpc3BudjUwL2hlYWQuaCBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2Rpc3Bu djUwL2hlYWQuaAppbmRleCBkMWMwMDJmNTM0ZDQuLmYzMWVmNWUwN2Y0MyAxMDA2NDQKLS0tIGEv ZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvZGlzcG52NTAvaGVhZC5oCisrKyBiL2RyaXZlcnMvZ3B1 L2RybS9ub3V2ZWF1L2Rpc3BudjUwL2hlYWQuaApAQCAtMTEsOSArMTEsMTAgQEAgc3RydWN0IG52 NTBfaGVhZCB7CiAJY29uc3Qgc3RydWN0IG52NTBfaGVhZF9mdW5jICpmdW5jOwogCXN0cnVjdCBu b3V2ZWF1X2NydGMgYmFzZTsKIAlzdHJ1Y3QgbnY1MF9sdXQgb2x1dDsKKwlzdHJ1Y3QgbnY1MF9t c3RvICptc3RvOwogfTsKIAotaW50IG52NTBfaGVhZF9jcmVhdGUoc3RydWN0IGRybV9kZXZpY2Ug KiwgaW50IGluZGV4KTsKK3N0cnVjdCBudjUwX2hlYWQgKm52NTBfaGVhZF9jcmVhdGUoc3RydWN0 IGRybV9kZXZpY2UgKiwgaW50IGluZGV4KTsKIHZvaWQgbnY1MF9oZWFkX2ZsdXNoX3NldChzdHJ1 Y3QgbnY1MF9oZWFkICosIHN0cnVjdCBudjUwX2hlYWRfYXRvbSAqKTsKIHZvaWQgbnY1MF9oZWFk X2ZsdXNoX2NscihzdHJ1Y3QgbnY1MF9oZWFkICosIHN0cnVjdCBudjUwX2hlYWRfYXRvbSAqLCBi b29sIHkpOwogCi0tIAoyLjIxLjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fCk5vdXZlYXUgbWFpbGluZyBsaXN0Ck5vdXZlYXVAbGlzdHMuZnJlZWRlc2t0 b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vbm91 dmVhdQ== 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=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS 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 908E5C49ED7 for ; Fri, 13 Sep 2019 22:05:25 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 5D6BE206A5 for ; Fri, 13 Sep 2019 22:05:25 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2404023AbfIMWFY (ORCPT ); Fri, 13 Sep 2019 18:05:24 -0400 Received: from mx1.redhat.com ([209.132.183.28]:36194 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2389867AbfIMWFX (ORCPT ); Fri, 13 Sep 2019 18:05:23 -0400 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 20B2710CC1EC; Fri, 13 Sep 2019 22:05:23 +0000 (UTC) Received: from malachite.bss.redhat.com (dhcp-10-20-1-34.bss.redhat.com [10.20.1.34]) by smtp.corp.redhat.com (Postfix) with ESMTP id F0E6C600CE; Fri, 13 Sep 2019 22:05:21 +0000 (UTC) From: Lyude Paul To: nouveau@lists.freedesktop.org Cc: Ben Skeggs , David Airlie , Daniel Vetter , Sam Ravnborg , Laurent Pinchart , Ilia Mirkin , Peteris Rudzusiks , Maarten Lankhorst , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [PATCH 3/4] drm/nouveau: dispnv50: Use less encoders by making mstos per-head Date: Fri, 13 Sep 2019 18:03:52 -0400 Message-Id: <20190913220355.6883-3-lyude@redhat.com> In-Reply-To: <20190913220355.6883-1-lyude@redhat.com> References: <20190913220355.6883-1-lyude@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.6.2 (mx1.redhat.com [10.5.110.65]); Fri, 13 Sep 2019 22:05:23 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Currently, for every single MST capable DRM connector we create a set of fake encoders, one for each possible head. Unfortunately this ends up being a huge waste of encoders. While this currently isn't causing us any problems, it's extremely close to doing so. The ThinkPad P71 is a good example of this. Originally when trying to figure out why nouveau was failing to load on this laptop, I discovered it was because nouveau was creating too many encoders. This ended up being because we were mistakenly creating MST encoders for the eDP port, however we are still extremely close to hitting the encoder limit on this machine as it exposes 1 eDP port and 5 DP ports, resulting in 31 encoders. So while this fix didn't end up being necessary to fix the P71, we still need to implement this so that we avoid hitting the encoder limit for valid display configurations in the event that some machine with more connectors then this becomes available. Plus, we don't want to let good code go to waste :) So, use less encoders by only creating one MSTO per head. Then, attach each new MSTC to each MSTO which corresponds to a head that it's parent DP port is capable of using. This brings the number of encoders we register on the ThinkPad P71 from 31, down to just 15. Yay! Signed-off-by: Lyude Paul --- drivers/gpu/drm/nouveau/dispnv50/disp.c | 92 +++++++++++++++---------- drivers/gpu/drm/nouveau/dispnv50/disp.h | 2 + drivers/gpu/drm/nouveau/dispnv50/head.c | 17 +++-- drivers/gpu/drm/nouveau/dispnv50/head.h | 3 +- 4 files changed, 68 insertions(+), 46 deletions(-) diff --git a/drivers/gpu/drm/nouveau/dispnv50/disp.c b/drivers/gpu/drm/nouveau/dispnv50/disp.c index a3f350fdfa8c..d23ac13763b5 100644 --- a/drivers/gpu/drm/nouveau/dispnv50/disp.c +++ b/drivers/gpu/drm/nouveau/dispnv50/disp.c @@ -650,7 +650,6 @@ struct nv50_mstm { struct nouveau_encoder *outp; struct drm_dp_mst_topology_mgr mgr; - struct nv50_msto *msto[4]; bool modified; bool disabled; @@ -716,7 +715,6 @@ nv50_msto_cleanup(struct nv50_msto *msto) drm_dp_mst_deallocate_vcpi(&mstm->mgr, mstc->port); msto->mstc = NULL; - msto->head = NULL; msto->disabled = false; } @@ -846,7 +844,6 @@ nv50_msto_enable(struct drm_encoder *encoder) mstm->outp->update(mstm->outp, head->base.index, armh, proto, depth); - msto->head = head; msto->mstc = mstc; mstm->modified = true; } @@ -887,37 +884,40 @@ nv50_msto = { .destroy = nv50_msto_destroy, }; -static int -nv50_msto_new(struct drm_device *dev, u32 heads, const char *name, int id, - struct nv50_msto **pmsto) +static struct nv50_msto * +nv50_msto_new(struct drm_device *dev, struct nv50_head *head, int id) { struct nv50_msto *msto; int ret; - if (!(msto = *pmsto = kzalloc(sizeof(*msto), GFP_KERNEL))) - return -ENOMEM; + msto = kzalloc(sizeof(*msto), GFP_KERNEL); + if (!msto) + return ERR_PTR(-ENOMEM); ret = drm_encoder_init(dev, &msto->encoder, &nv50_msto, - DRM_MODE_ENCODER_DPMST, "%s-mst-%d", name, id); + DRM_MODE_ENCODER_DPMST, "mst-%d", id); if (ret) { - kfree(*pmsto); - *pmsto = NULL; - return ret; + kfree(msto); + return ERR_PTR(ret); } drm_encoder_helper_add(&msto->encoder, &nv50_msto_help); - msto->encoder.possible_crtcs = heads; - return 0; + msto->encoder.possible_crtcs = drm_crtc_mask(&head->base.base); + msto->head = head; + return msto; } static struct drm_encoder * nv50_mstc_atomic_best_encoder(struct drm_connector *connector, struct drm_connector_state *connector_state) { - struct nv50_head *head = nv50_head(connector_state->crtc); struct nv50_mstc *mstc = nv50_mstc(connector); + struct drm_crtc *crtc = connector_state->crtc; - return &mstc->mstm->msto[head->base.index]->encoder; + if (!(mstc->mstm->outp->dcb->heads & drm_crtc_mask(crtc))) + return NULL; + + return &nv50_head(crtc)->msto->encoder; } static enum drm_mode_status @@ -1036,8 +1036,9 @@ nv50_mstc_new(struct nv50_mstm *mstm, struct drm_dp_mst_port *port, const char *path, struct nv50_mstc **pmstc) { struct drm_device *dev = mstm->outp->base.base.dev; + struct drm_crtc *crtc; struct nv50_mstc *mstc; - int ret, i; + int ret; if (!(mstc = *pmstc = kzalloc(sizeof(*mstc), GFP_KERNEL))) return -ENOMEM; @@ -1057,8 +1058,13 @@ nv50_mstc_new(struct nv50_mstm *mstm, struct drm_dp_mst_port *port, mstc->connector.funcs->reset(&mstc->connector); nouveau_conn_attach_properties(&mstc->connector); - for (i = 0; i < ARRAY_SIZE(mstm->msto) && mstm->msto[i]; i++) - drm_connector_attach_encoder(&mstc->connector, &mstm->msto[i]->encoder); + drm_for_each_crtc(crtc, dev) { + if (!(mstm->outp->dcb->heads & drm_crtc_mask(crtc))) + continue; + + drm_connector_attach_encoder(&mstc->connector, + &nv50_head(crtc)->msto->encoder); + } drm_object_attach_property(&mstc->connector.base, dev->mode_config.path_property, 0); drm_object_attach_property(&mstc->connector.base, dev->mode_config.tile_property, 0); @@ -1332,7 +1338,7 @@ nv50_mstm_new(struct nouveau_encoder *outp, struct drm_dp_aux *aux, int aux_max, const int max_payloads = hweight8(outp->dcb->heads); struct drm_device *dev = outp->base.base.dev; struct nv50_mstm *mstm; - int ret, i; + int ret; u8 dpcd; /* This is a workaround for some monitors not functioning @@ -1355,13 +1361,6 @@ nv50_mstm_new(struct nouveau_encoder *outp, struct drm_dp_aux *aux, int aux_max, if (ret) return ret; - for (i = 0; i < max_payloads; i++) { - ret = nv50_msto_new(dev, outp->dcb->heads, outp->base.base.name, - i, &mstm->msto[i]); - if (ret) - return ret; - } - return 0; } @@ -1540,17 +1539,24 @@ nv50_sor_func = { .destroy = nv50_sor_destroy, }; +static bool nv50_has_mst(struct nouveau_drm *drm) +{ + struct nvkm_bios *bios = nvxx_bios(&drm->client.device); + u32 data; + u8 ver, hdr, cnt, len; + + data = nvbios_dp_table(bios, &ver, &hdr, &cnt, &len); + return data && ver >= 0x40 && (nvbios_rd08(bios, data + 0x08) & 0x04); +} + static int nv50_sor_create(struct drm_connector *connector, struct dcb_output *dcbe) { struct nouveau_connector *nv_connector = nouveau_connector(connector); struct nouveau_drm *drm = nouveau_drm(connector->dev); - struct nvkm_bios *bios = nvxx_bios(&drm->client.device); struct nvkm_i2c *i2c = nvxx_i2c(&drm->client.device); struct nouveau_encoder *nv_encoder; struct drm_encoder *encoder; - u8 ver, hdr, cnt, len; - u32 data; int type, ret; switch (dcbe->type) { @@ -1595,10 +1601,9 @@ nv50_sor_create(struct drm_connector *connector, struct dcb_output *dcbe) } if (nv_connector->type != DCB_CONNECTOR_eDP && - (data = nvbios_dp_table(bios, &ver, &hdr, &cnt, &len)) && - ver >= 0x40 && (nvbios_rd08(bios, data + 0x08) & 0x04)) { - ret = nv50_mstm_new(nv_encoder, &nv_connector->aux, 16, - nv_connector->base.base.id, + nv50_has_mst(drm)) { + ret = nv50_mstm_new(nv_encoder, &nv_connector->aux, + 16, nv_connector->base.base.id, &nv_encoder->dp.mstm); if (ret) return ret; @@ -2294,6 +2299,7 @@ nv50_display_create(struct drm_device *dev) struct nv50_disp *disp; struct dcb_output *dcbe; int crtcs, ret, i; + bool has_mst = nv50_has_mst(drm); disp = kzalloc(sizeof(*disp), GFP_KERNEL); if (!disp) @@ -2342,11 +2348,25 @@ nv50_display_create(struct drm_device *dev) crtcs = 0x3; for (i = 0; i < fls(crtcs); i++) { + struct nv50_head *head; + if (!(crtcs & (1 << i))) continue; - ret = nv50_head_create(dev, i); - if (ret) + + head = nv50_head_create(dev, i); + if (IS_ERR(head)) { + ret = PTR_ERR(head); goto out; + } + + if (has_mst) { + head->msto = nv50_msto_new(dev, head, i); + if (IS_ERR(head->msto)) { + ret = PTR_ERR(head->msto); + head->msto = NULL; + goto out; + } + } } /* create encoder/connector objects based on VBIOS DCB table */ diff --git a/drivers/gpu/drm/nouveau/dispnv50/disp.h b/drivers/gpu/drm/nouveau/dispnv50/disp.h index 7c41b0599d1a..b16f4aa09e02 100644 --- a/drivers/gpu/drm/nouveau/dispnv50/disp.h +++ b/drivers/gpu/drm/nouveau/dispnv50/disp.h @@ -4,6 +4,8 @@ #include "nouveau_display.h" +struct nv50_msto; + struct nv50_disp { struct nvif_disp *disp; struct nv50_core *core; diff --git a/drivers/gpu/drm/nouveau/dispnv50/head.c b/drivers/gpu/drm/nouveau/dispnv50/head.c index 71c23bf1fe25..bd2f6bf5edfd 100644 --- a/drivers/gpu/drm/nouveau/dispnv50/head.c +++ b/drivers/gpu/drm/nouveau/dispnv50/head.c @@ -474,7 +474,7 @@ nv50_head_func = { .atomic_destroy_state = nv50_head_atomic_destroy_state, }; -int +struct nv50_head * nv50_head_create(struct drm_device *dev, int index) { struct nouveau_drm *drm = nouveau_drm(dev); @@ -486,7 +486,7 @@ nv50_head_create(struct drm_device *dev, int index) head = kzalloc(sizeof(*head), GFP_KERNEL); if (!head) - return -ENOMEM; + return ERR_PTR(-ENOMEM); head->func = disp->core->func->head; head->base.index = index; @@ -504,7 +504,7 @@ nv50_head_create(struct drm_device *dev, int index) ret = nv50_curs_new(drm, head->base.index, &curs); if (ret) { kfree(head); - return ret; + return ERR_PTR(ret); } crtc = &head->base.base; @@ -519,12 +519,11 @@ nv50_head_create(struct drm_device *dev, int index) if (head->func->olut_set) { ret = nv50_lut_init(disp, &drm->client.mmu, &head->olut); - if (ret) - goto out; + if (ret) { + nv50_head_destroy(crtc); + return ERR_PTR(ret); + } } -out: - if (ret) - nv50_head_destroy(crtc); - return ret; + return head; } diff --git a/drivers/gpu/drm/nouveau/dispnv50/head.h b/drivers/gpu/drm/nouveau/dispnv50/head.h index d1c002f534d4..f31ef5e07f43 100644 --- a/drivers/gpu/drm/nouveau/dispnv50/head.h +++ b/drivers/gpu/drm/nouveau/dispnv50/head.h @@ -11,9 +11,10 @@ struct nv50_head { const struct nv50_head_func *func; struct nouveau_crtc base; struct nv50_lut olut; + struct nv50_msto *msto; }; -int nv50_head_create(struct drm_device *, int index); +struct nv50_head *nv50_head_create(struct drm_device *, int index); void nv50_head_flush_set(struct nv50_head *, struct nv50_head_atom *); void nv50_head_flush_clr(struct nv50_head *, struct nv50_head_atom *, bool y); -- 2.21.0