From mboxrd@z Thu Jan 1 00:00:00 1970 From: Sean Paul Subject: [PATCH v2 1/6] drm/msm: Use drm_private_obj/state instead of subclassing Date: Wed, 28 Mar 2018 15:06:47 -0400 Message-ID: <20180328190657.218661-2-seanpaul@chromium.org> References: <20180328190657.218661-1-seanpaul@chromium.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180328190657.218661-1-seanpaul@chromium.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: freedreno@lists.freedesktop.org, linux-arm-msm@vger.kernel.org, dri-devel@lists.freedesktop.org Cc: linux-kernel@vger.kernel.org, abhinavk@codeaurora.org, hoegsberg@chromium.org List-Id: linux-arm-msm@vger.kernel.org Tm93IHRoYXQgd2UgaGF2ZSBwcml2YXRlIHN0YXRlIGhhbmRsZWQgYnkgdGhlIGNvcmUsIHdlIGNh biB1c2UgdGhvc2UKaW5zdGVhZCBvZiByb2xsaW5nIG91ciBvd24gc3dhcF9zdGF0ZSBmb3IgcHJp dmF0ZSBkYXRhLgoKT3JpZ2luYWxseSBwb3N0ZWQgaGVyZTogaHR0cHM6Ly9wYXRjaHdvcmsuZnJl ZWRlc2t0b3Aub3JnL3BhdGNoLzIxMTM2MS8KCkNoYW5nZXMgaW4gdjI6CiAtIFVzZSBzdGF0ZS0+ c3RhdGUgaW4gZGlzcCBkdXBsaWNhdGVfc3RhdGUgY2FsbGJhY2sgKEpleWt1bWFyKQpDaGFuZ2Vz IGluIHYzOgogLSBVcGRhdGUgY29tbWVudCBkZXNjcmliaW5nIG1zbV9rbXNfc3RhdGUgKEpleWt1 bWFyKQpDaGFuZ2VzIGluIHY0OgogLSBSZWJhc2VkIG9uIG1zbS1uZXh0CiAtIERvbid0IGFsd2F5 cyB1c2UgcHJpdmF0ZSBzdGF0ZSBmcm9tIGF0b21pYyBzdGF0ZSAoQXJjaGl0KQogLSBSZW5hbWVk IHNvbWUgb2YgdGhlIHN0YXRlIGFjY2Vzc29ycwogLSBUZXN0ZWQgb24gbWRwNSBkYjQxMGMKQ2hh bmdlcyBpbiB2NToKIC0gTm9uZQoKQ2M6IEpleWt1bWFyIFNhbmthcmFuIDxqc2Fua2FAY29kZWF1 cm9yYS5vcmc+CkNjOiBBcmNoaXQgVGFuZWphIDxhcmNoaXR0QGNvZGVhdXJvcmEub3JnPgpTaWdu ZWQtb2ZmLWJ5OiBTZWFuIFBhdWwgPHNlYW5wYXVsQGNocm9taXVtLm9yZz4KLS0tCiBkcml2ZXJz L2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2ttcy5jICAgfCA3NyArKysrKysrKysrLS0tLS0t LS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2ttcy5oICAgfCAxMSArLS0K IGRyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVfbWl4ZXIuYyB8IDEyICsrLQogZHJp dmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9waXBlLmMgIHwgMjggKysrKy0tLQogZHJp dmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9zbXAuYyAgIHwgMTkgKysrLS0KIGRyaXZl cnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVfc21wLmggICB8ICA0ICstCiBkcml2ZXJzL2dw dS9kcm0vbXNtL21zbV9hdG9taWMuYyAgICAgICAgICAgfCAzNyAtLS0tLS0tLS0KIGRyaXZlcnMv Z3B1L2RybS9tc20vbXNtX2Rydi5jICAgICAgICAgICAgICB8IDg3ICsrKysrKysrKysrKysrKysr KysrKy0KIGRyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2Rydi5oICAgICAgICAgICAgICB8ICAzIC0K IGRyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2ttcy5oICAgICAgICAgICAgICB8IDIxICsrKystLQog MTAgZmlsZXMgY2hhbmdlZCwgMTgzIGluc2VydGlvbnMoKyksIDExNiBkZWxldGlvbnMoLSkKCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2ttcy5jIGIvZHJp dmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9rbXMuYwppbmRleCA2ZDhlM2E5YTZmYzAu LjM2NjY3MDA0MzE5MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUv bWRwNV9rbXMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2ttcy5j CkBAIC03MCw2MCArNzAsNjIgQEAgc3RhdGljIGludCBtZHA1X2h3X2luaXQoc3RydWN0IG1zbV9r bXMgKmttcykKIAlyZXR1cm4gMDsKIH0KIAotc3RydWN0IG1kcDVfc3RhdGUgKm1kcDVfZ2V0X3N0 YXRlKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzKQorc3RydWN0IG1kcDVfc3RhdGUgKm1kcDVf c3RhdGVfZnJvbV9hdG9taWMoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQogewotCXN0 cnVjdCBtc21fZHJtX3ByaXZhdGUgKnByaXYgPSBzLT5kZXYtPmRldl9wcml2YXRlOwotCXN0cnVj dCBtZHA1X2ttcyAqbWRwNV9rbXMgPSB0b19tZHA1X2ttcyh0b19tZHBfa21zKHByaXYtPmttcykp OwotCXN0cnVjdCBtc21fa21zX3N0YXRlICpzdGF0ZSA9IHRvX2ttc19zdGF0ZShzKTsKLQlzdHJ1 Y3QgbWRwNV9zdGF0ZSAqbmV3X3N0YXRlOwotCWludCByZXQ7CisJc3RydWN0IG1zbV9rbXNfc3Rh dGUgKmttc19zdGF0ZSA9IG1zbV9rbXNfc3RhdGVfZnJvbV9hdG9taWMoc3RhdGUpOwogCi0JaWYg KHN0YXRlLT5zdGF0ZSkKLQkJcmV0dXJuIHN0YXRlLT5zdGF0ZTsKKwlpZiAoSVNfRVJSX09SX05V TEwoa21zX3N0YXRlKSkKKwkJcmV0dXJuIChzdHJ1Y3QgbWRwNV9zdGF0ZSAqKWttc19zdGF0ZTsg LyogY2FzdGluZyBFUlJfUFRSICovCiAKLQlyZXQgPSBkcm1fbW9kZXNldF9sb2NrKCZtZHA1X2tt cy0+c3RhdGVfbG9jaywgcy0+YWNxdWlyZV9jdHgpOwotCWlmIChyZXQpCi0JCXJldHVybiBFUlJf UFRSKHJldCk7CisJcmV0dXJuIGttc19zdGF0ZS0+c3RhdGU7Cit9CiAKLQluZXdfc3RhdGUgPSBr bWFsbG9jKHNpemVvZigqbWRwNV9rbXMtPnN0YXRlKSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFuZXdf c3RhdGUpCi0JCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworc3RydWN0IG1kcDVfc3RhdGUgKm1k cDVfc3RhdGVfZnJvbV9kZXYoc3RydWN0IGRybV9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgbXNt X2ttc19zdGF0ZSAqa21zX3N0YXRlID0gbXNtX2ttc19zdGF0ZV9mcm9tX2RldihkZXYpOwogCi0J LyogQ29weSBzdGF0ZTogKi8KLQluZXdfc3RhdGUtPmh3cGlwZSA9IG1kcDVfa21zLT5zdGF0ZS0+ aHdwaXBlOwotCW5ld19zdGF0ZS0+aHdtaXhlciA9IG1kcDVfa21zLT5zdGF0ZS0+aHdtaXhlcjsK LQlpZiAobWRwNV9rbXMtPnNtcCkKLQkJbmV3X3N0YXRlLT5zbXAgPSBtZHA1X2ttcy0+c3RhdGUt PnNtcDsKKwlpZiAoSVNfRVJSX09SX05VTEwoa21zX3N0YXRlKSkKKwkJcmV0dXJuIChzdHJ1Y3Qg bWRwNV9zdGF0ZSAqKWttc19zdGF0ZTsgLyogY2FzdGluZyBFUlJfUFRSICovCiAKLQlzdGF0ZS0+ c3RhdGUgPSBuZXdfc3RhdGU7CisJcmV0dXJuIGttc19zdGF0ZS0+c3RhdGU7Cit9CisKK3N0YXRp YyB2b2lkICptZHA1X2R1cGxpY2F0ZV9zdGF0ZSh2b2lkICpzdGF0ZSkKK3sKKwlpZiAoIXN0YXRl KQorCQlyZXR1cm4ga3phbGxvYyhzaXplb2Yoc3RydWN0IG1kcDVfc3RhdGUpLCBHRlBfS0VSTkVM KTsKIAotCXJldHVybiBuZXdfc3RhdGU7CisJcmV0dXJuIGttZW1kdXAoc3RhdGUsIHNpemVvZihz dHJ1Y3QgbWRwNV9zdGF0ZSksIEdGUF9LRVJORUwpOwogfQogCi1zdGF0aWMgdm9pZCBtZHA1X3N3 YXBfc3RhdGUoc3RydWN0IG1zbV9rbXMgKmttcywgc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0 YXRlKQorc3RhdGljIHZvaWQgbWRwNV9kZXN0cm95X3N0YXRlKHZvaWQgKnN0YXRlKQogewotCXN0 cnVjdCBtZHA1X2ttcyAqbWRwNV9rbXMgPSB0b19tZHA1X2ttcyh0b19tZHBfa21zKGttcykpOwot CXN3YXAodG9fa21zX3N0YXRlKHN0YXRlKS0+c3RhdGUsIG1kcDVfa21zLT5zdGF0ZSk7CisJc3Ry dWN0IG1kcDVfc3RhdGUgKm1kcF9zdGF0ZSA9IChzdHJ1Y3QgbWRwNV9zdGF0ZSAqKXN0YXRlOwor CWtmcmVlKG1kcF9zdGF0ZSk7CiB9CiAKLXN0YXRpYyB2b2lkIG1kcDVfcHJlcGFyZV9jb21taXQo c3RydWN0IG1zbV9rbXMgKmttcywgc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQorc3Rh dGljIHZvaWQgbWRwNV9wcmVwYXJlX2NvbW1pdChzdHJ1Y3QgbXNtX2ttcyAqa21zLAorCQkJCXN0 cnVjdCBkcm1fYXRvbWljX3N0YXRlICpvbGRfc3RhdGUpCiB7CiAJc3RydWN0IG1kcDVfa21zICpt ZHA1X2ttcyA9IHRvX21kcDVfa21zKHRvX21kcF9rbXMoa21zKSk7CisJc3RydWN0IG1kcDVfc3Rh dGUgKm1kcDVfc3RhdGUgPSBtZHA1X3N0YXRlX2Zyb21fZGV2KG1kcDVfa21zLT5kZXYpOwogCXN0 cnVjdCBkZXZpY2UgKmRldiA9ICZtZHA1X2ttcy0+cGRldi0+ZGV2OwogCiAJcG1fcnVudGltZV9n ZXRfc3luYyhkZXYpOwogCiAJaWYgKG1kcDVfa21zLT5zbXApCi0JCW1kcDVfc21wX3ByZXBhcmVf Y29tbWl0KG1kcDVfa21zLT5zbXAsICZtZHA1X2ttcy0+c3RhdGUtPnNtcCk7CisJCW1kcDVfc21w X3ByZXBhcmVfY29tbWl0KG1kcDVfa21zLT5zbXAsICZtZHA1X3N0YXRlLT5zbXApOwogfQogCi1z dGF0aWMgdm9pZCBtZHA1X2NvbXBsZXRlX2NvbW1pdChzdHJ1Y3QgbXNtX2ttcyAqa21zLCBzdHJ1 Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpCitzdGF0aWMgdm9pZCBtZHA1X2NvbXBsZXRlX2Nv bW1pdChzdHJ1Y3QgbXNtX2ttcyAqa21zLAorCQkJCSBzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAq b2xkX3N0YXRlKQogewogCXN0cnVjdCBtZHA1X2ttcyAqbWRwNV9rbXMgPSB0b19tZHA1X2ttcyh0 b19tZHBfa21zKGttcykpOworCXN0cnVjdCBtZHA1X3N0YXRlICptZHA1X3N0YXRlID0gbWRwNV9z dGF0ZV9mcm9tX2RldihtZHA1X2ttcy0+ZGV2KTsKIAlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmbWRw NV9rbXMtPnBkZXYtPmRldjsKIAogCWlmIChtZHA1X2ttcy0+c21wKQotCQltZHA1X3NtcF9jb21w bGV0ZV9jb21taXQobWRwNV9rbXMtPnNtcCwgJm1kcDVfa21zLT5zdGF0ZS0+c21wKTsKKwkJbWRw NV9zbXBfY29tcGxldGVfY29tbWl0KG1kcDVfa21zLT5zbXAsICZtZHA1X3N0YXRlLT5zbXApOwog CiAJcG1fcnVudGltZV9wdXRfc3luYyhkZXYpOwogfQpAQCAtMjI5LDcgKzIzMSw4IEBAIHN0YXRp YyBjb25zdCBzdHJ1Y3QgbWRwX2ttc19mdW5jcyBrbXNfZnVuY3MgPSB7CiAJCS5pcnEgICAgICAg ICAgICAgPSBtZHA1X2lycSwKIAkJLmVuYWJsZV92YmxhbmsgICA9IG1kcDVfZW5hYmxlX3ZibGFu aywKIAkJLmRpc2FibGVfdmJsYW5rICA9IG1kcDVfZGlzYWJsZV92YmxhbmssCi0JCS5zd2FwX3N0 YXRlICAgICAgPSBtZHA1X3N3YXBfc3RhdGUsCisJCS5kdXBsaWNhdGVfc3RhdGUgPSBtZHA1X2R1 cGxpY2F0ZV9zdGF0ZSwKKwkJLmRlc3Ryb3lfc3RhdGUJID0gbWRwNV9kZXN0cm95X3N0YXRlLAog CQkucHJlcGFyZV9jb21taXQgID0gbWRwNV9wcmVwYXJlX2NvbW1pdCwKIAkJLmNvbXBsZXRlX2Nv bW1pdCA9IG1kcDVfY29tcGxldGVfY29tbWl0LAogCQkud2FpdF9mb3JfY3J0Y19jb21taXRfZG9u ZSA9IG1kcDVfd2FpdF9mb3JfY3J0Y19jb21taXRfZG9uZSwKQEAgLTcyNiw4ICs3MjksNiBAQCBz dGF0aWMgdm9pZCBtZHA1X2Rlc3Ryb3koc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAog CWlmIChtZHA1X2ttcy0+cnBtX2VuYWJsZWQpCiAJCXBtX3J1bnRpbWVfZGlzYWJsZSgmcGRldi0+ ZGV2KTsKLQotCWtmcmVlKG1kcDVfa21zLT5zdGF0ZSk7CiB9CiAKIHN0YXRpYyBpbnQgY29uc3Ry dWN0X3BpcGVzKHN0cnVjdCBtZHA1X2ttcyAqbWRwNV9rbXMsIGludCBjbnQsCkBAIC04NTksNyAr ODYwLDggQEAgc3RhdGljIGludCBpbnRlcmZhY2VfaW5pdChzdHJ1Y3QgbWRwNV9rbXMgKm1kcDVf a21zKQogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IG1kcDVfaW5pdChzdHJ1Y3QgcGxhdGZv cm1fZGV2aWNlICpwZGV2LCBzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQorc3RhdGljIGludCBtZHA1 X2luaXQoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwgc3RydWN0IGRybV9kZXZpY2UgKmRl diwKKwkJICAgICBzdHJ1Y3QgbXNtX2ttc19zdGF0ZSAqaW5pdGlhbF9zdGF0ZSkKIHsKIAlzdHJ1 Y3QgbXNtX2RybV9wcml2YXRlICpwcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKIAlzdHJ1Y3QgbWRw NV9rbXMgKm1kcDVfa21zOwpAQCAtODgwLDkgKzg4Miw4IEBAIHN0YXRpYyBpbnQgbWRwNV9pbml0 KHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsIHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAJ bWRwNV9rbXMtPmRldiA9IGRldjsKIAltZHA1X2ttcy0+cGRldiA9IHBkZXY7CiAKLQlkcm1fbW9k ZXNldF9sb2NrX2luaXQoJm1kcDVfa21zLT5zdGF0ZV9sb2NrKTsKLQltZHA1X2ttcy0+c3RhdGUg PSBremFsbG9jKHNpemVvZigqbWRwNV9rbXMtPnN0YXRlKSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFt ZHA1X2ttcy0+c3RhdGUpIHsKKwlpbml0aWFsX3N0YXRlLT5zdGF0ZSA9IG1kcDVfZHVwbGljYXRl X3N0YXRlKE5VTEwpOworCWlmICghaW5pdGlhbF9zdGF0ZS0+c3RhdGUpIHsKIAkJcmV0ID0gLUVO T01FTTsKIAkJZ290byBmYWlsOwogCX0KQEAgLTk0MCw3ICs5NDEsOCBAQCBzdGF0aWMgaW50IG1k cDVfaW5pdChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LCBzdHJ1Y3QgZHJtX2RldmljZSAq ZGV2KQogCSAqIHRoaXMgc2VjdGlvbiBpbml0aWFsaXplcyB0aGUgU01QOgogCSAqLwogCWlmICht ZHA1X2ttcy0+Y2FwcyAmIE1EUF9DQVBfU01QKSB7Ci0JCW1kcDVfa21zLT5zbXAgPSBtZHA1X3Nt cF9pbml0KG1kcDVfa21zLCAmY29uZmlnLT5ody0+c21wKTsKKwkJbWRwNV9rbXMtPnNtcCA9IG1k cDVfc21wX2luaXQobWRwNV9rbXMsICZjb25maWctPmh3LT5zbXAsCisJCQkJCSAgICAgIGluaXRp YWxfc3RhdGUtPnN0YXRlKTsKIAkJaWYgKElTX0VSUihtZHA1X2ttcy0+c21wKSkgewogCQkJcmV0 ID0gUFRSX0VSUihtZHA1X2ttcy0+c21wKTsKIAkJCW1kcDVfa21zLT5zbXAgPSBOVUxMOwpAQCAt OTgwLDEwICs5ODIsMTEgQEAgc3RhdGljIGludCBtZHA1X2JpbmQoc3RydWN0IGRldmljZSAqZGV2 LCBzdHJ1Y3QgZGV2aWNlICptYXN0ZXIsIHZvaWQgKmRhdGEpCiB7CiAJc3RydWN0IGRybV9kZXZp Y2UgKmRkZXYgPSBkZXZfZ2V0X2RydmRhdGEobWFzdGVyKTsKIAlzdHJ1Y3QgcGxhdGZvcm1fZGV2 aWNlICpwZGV2ID0gdG9fcGxhdGZvcm1fZGV2aWNlKGRldik7CisJc3RydWN0IG1zbV9rbXNfc3Rh dGUgKmluaXRpYWxfc3RhdGUgPSAoc3RydWN0IG1zbV9rbXNfc3RhdGUgKilkYXRhOwogCiAJREJH KCIiKTsKIAotCXJldHVybiBtZHA1X2luaXQocGRldiwgZGRldik7CisJcmV0dXJuIG1kcDVfaW5p dChwZGV2LCBkZGV2LCBpbml0aWFsX3N0YXRlKTsKIH0KIAogc3RhdGljIHZvaWQgbWRwNV91bmJp bmQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlICptYXN0ZXIsCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2ttcy5oIGIvZHJpdmVycy9ncHUv ZHJtL21zbS9kaXNwL21kcDUvbWRwNV9rbXMuaAppbmRleCA0MjVhMDNkMjEzZTUuLmUyMzExN2I4 MmFhZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9rbXMu aAorKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2ttcy5oCkBAIC0yOCw4 ICsyOCw2IEBACiAjaW5jbHVkZSAibWRwNV9jdGwuaCIKICNpbmNsdWRlICJtZHA1X3NtcC5oIgog Ci1zdHJ1Y3QgbWRwNV9zdGF0ZTsKLQogc3RydWN0IG1kcDVfa21zIHsKIAlzdHJ1Y3QgbWRwX2tt cyBiYXNlOwogCkBAIC00OSwxMiArNDcsNiBAQCBzdHJ1Y3QgbWRwNV9rbXMgewogCXN0cnVjdCBt ZHA1X2NmZ19oYW5kbGVyICpjZmc7CiAJdWludDMyX3QgY2FwczsJLyogTURQIGNhcGFiaWxpdGll cyAoTURQX0NBUF9YWFggYml0cykgKi8KIAotCS8qKgotCSAqIEdsb2JhbCBhdG9taWMgc3RhdGUu ICBEbyBub3QgYWNjZXNzIGRpcmVjdGx5LCB1c2UgbWRwNV9nZXRfc3RhdGUoKQotCSAqLwotCXN0 cnVjdCBtZHA1X3N0YXRlICpzdGF0ZTsKLQlzdHJ1Y3QgZHJtX21vZGVzZXRfbG9jayBzdGF0ZV9s b2NrOwotCiAJc3RydWN0IG1kcDVfc21wICpzbXA7CiAJc3RydWN0IG1kcDVfY3RsX21hbmFnZXIg KmN0bG07CiAKQEAgLTkzLDcgKzg1LDggQEAgc3RydWN0IG1kcDVfc3RhdGUgewogfTsKIAogc3Ry dWN0IG1kcDVfc3RhdGUgKl9fbXVzdF9jaGVjawotbWRwNV9nZXRfc3RhdGUoc3RydWN0IGRybV9h dG9taWNfc3RhdGUgKnMpOworbWRwNV9zdGF0ZV9mcm9tX2F0b21pYyhzdHJ1Y3QgZHJtX2F0b21p Y19zdGF0ZSAqcyk7CitzdHJ1Y3QgbWRwNV9zdGF0ZSAqX19tdXN0X2NoZWNrIG1kcDVfc3RhdGVf ZnJvbV9kZXYoc3RydWN0IGRybV9kZXZpY2UgKmRldik7CiAKIC8qIEF0b21pYyBwbGFuZSBzdGF0 ZS4gIFN1YmNsYXNzZXMgdGhlIGJhc2UgZHJtX3BsYW5lX3N0YXRlIGluIG9yZGVyIHRvCiAgKiB0 cmFjayBhc3NpZ25lZCBod3BpcGUgYW5kIGh3IHNwZWNpZmljIHN0YXRlLgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9taXhlci5jIGIvZHJpdmVycy9ncHUv ZHJtL21zbS9kaXNwL21kcDUvbWRwNV9taXhlci5jCmluZGV4IDhhMDA5OTFmMDNjNy4uZmRkNWUx MmE5ZDU2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X21p eGVyLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9taXhlci5jCkBA IC01MiwxMCArNTIsMTEgQEAgaW50IG1kcDVfbWl4ZXJfYXNzaWduKHN0cnVjdCBkcm1fYXRvbWlj X3N0YXRlICpzLCBzdHJ1Y3QgZHJtX2NydGMgKmNydGMsCiB7CiAJc3RydWN0IG1zbV9kcm1fcHJp dmF0ZSAqcHJpdiA9IHMtPmRldi0+ZGV2X3ByaXZhdGU7CiAJc3RydWN0IG1kcDVfa21zICptZHA1 X2ttcyA9IHRvX21kcDVfa21zKHRvX21kcF9rbXMocHJpdi0+a21zKSk7Ci0Jc3RydWN0IG1kcDVf c3RhdGUgKnN0YXRlID0gbWRwNV9nZXRfc3RhdGUocyk7CisJc3RydWN0IG1kcDVfc3RhdGUgKnN0 YXRlOwogCXN0cnVjdCBtZHA1X2h3X21peGVyX3N0YXRlICpuZXdfc3RhdGU7CiAJaW50IGk7CiAK KwlzdGF0ZSA9IG1kcDVfc3RhdGVfZnJvbV9hdG9taWMocyk7CiAJaWYgKElTX0VSUihzdGF0ZSkp CiAJCXJldHVybiBQVFJfRVJSKHN0YXRlKTsKIApAQCAtMTI5LDEyICsxMzAsMTcgQEAgaW50IG1k cDVfbWl4ZXJfYXNzaWduKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzLCBzdHJ1Y3QgZHJtX2Ny dGMgKmNydGMsCiAKIHZvaWQgbWRwNV9taXhlcl9yZWxlYXNlKHN0cnVjdCBkcm1fYXRvbWljX3N0 YXRlICpzLCBzdHJ1Y3QgbWRwNV9od19taXhlciAqbWl4ZXIpCiB7Ci0Jc3RydWN0IG1kcDVfc3Rh dGUgKnN0YXRlID0gbWRwNV9nZXRfc3RhdGUocyk7Ci0Jc3RydWN0IG1kcDVfaHdfbWl4ZXJfc3Rh dGUgKm5ld19zdGF0ZSA9ICZzdGF0ZS0+aHdtaXhlcjsKKwlzdHJ1Y3QgbWRwNV9zdGF0ZSAqc3Rh dGU7CisJc3RydWN0IG1kcDVfaHdfbWl4ZXJfc3RhdGUgKm5ld19zdGF0ZTsKIAogCWlmICghbWl4 ZXIpCiAJCXJldHVybjsKIAorCXN0YXRlID0gbWRwNV9zdGF0ZV9mcm9tX2F0b21pYyhzKTsKKwlp ZiAoSVNfRVJSKHN0YXRlKSkKKwkJcmV0dXJuOworCisJbmV3X3N0YXRlID0gJnN0YXRlLT5od21p eGVyOwogCWlmIChXQVJOX09OKCFuZXdfc3RhdGUtPmh3bWl4ZXJfdG9fY3J0Y1ttaXhlci0+aWR4 XSkpCiAJCXJldHVybjsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21k cDUvbWRwNV9waXBlLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X3BpcGUu YwppbmRleCBmZjUyYzQ5MDk1ZjkuLmRjNjZhYjlmZGQ1MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9waXBlLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21z bS9kaXNwL21kcDUvbWRwNV9waXBlLmMKQEAgLTI0LDE3ICsyNCwyMCBAQCBpbnQgbWRwNV9waXBl X2Fzc2lnbihzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqcywgc3RydWN0IGRybV9wbGFuZSAqcGxh bmUsCiB7CiAJc3RydWN0IG1zbV9kcm1fcHJpdmF0ZSAqcHJpdiA9IHMtPmRldi0+ZGV2X3ByaXZh dGU7CiAJc3RydWN0IG1kcDVfa21zICptZHA1X2ttcyA9IHRvX21kcDVfa21zKHRvX21kcF9rbXMo cHJpdi0+a21zKSk7Ci0Jc3RydWN0IG1kcDVfc3RhdGUgKnN0YXRlOworCXN0cnVjdCBtZHA1X3N0 YXRlICpvbGRfbWRwNV9zdGF0ZSwgKm5ld19tZHA1X3N0YXRlOwogCXN0cnVjdCBtZHA1X2h3X3Bp cGVfc3RhdGUgKm9sZF9zdGF0ZSwgKm5ld19zdGF0ZTsKIAlpbnQgaSwgajsKIAotCXN0YXRlID0g bWRwNV9nZXRfc3RhdGUocyk7Ci0JaWYgKElTX0VSUihzdGF0ZSkpCi0JCXJldHVybiBQVFJfRVJS KHN0YXRlKTsKKwluZXdfbWRwNV9zdGF0ZSA9IG1kcDVfc3RhdGVfZnJvbV9hdG9taWMocyk7CisJ aWYgKElTX0VSUihuZXdfbWRwNV9zdGF0ZSkpCisJCXJldHVybiBQVFJfRVJSKG5ld19tZHA1X3N0 YXRlKTsKIAotCS8qIGdyYWIgb2xkX3N0YXRlIGFmdGVyIG1kcDVfZ2V0X3N0YXRlKCksIHNpbmNl IG5vdyB3ZSBob2xkIGxvY2s6ICovCi0Jb2xkX3N0YXRlID0gJm1kcDVfa21zLT5zdGF0ZS0+aHdw aXBlOwotCW5ld19zdGF0ZSA9ICZzdGF0ZS0+aHdwaXBlOworCW9sZF9tZHA1X3N0YXRlID0gbWRw NV9zdGF0ZV9mcm9tX2RldihzLT5kZXYpOworCWlmIChJU19FUlIob2xkX21kcDVfc3RhdGUpKQor CQlyZXR1cm4gUFRSX0VSUihvbGRfbWRwNV9zdGF0ZSk7CisKKwlvbGRfc3RhdGUgPSAmb2xkX21k cDVfc3RhdGUtPmh3cGlwZTsKKwluZXdfc3RhdGUgPSAmbmV3X21kcDVfc3RhdGUtPmh3cGlwZTsK IAogCWZvciAoaSA9IDA7IGkgPCBtZHA1X2ttcy0+bnVtX2h3cGlwZXM7IGkrKykgewogCQlzdHJ1 Y3QgbWRwNV9od19waXBlICpjdXIgPSBtZHA1X2ttcy0+aHdwaXBlc1tpXTsKQEAgLTEwNyw3ICsx MTAsNyBAQCBpbnQgbWRwNV9waXBlX2Fzc2lnbihzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqcywg c3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCiAJCVdBUk5fT04ocl9od3BpcGUpOwogCiAJCURCRygi JXM6IGFsbG9jIFNNUCBibG9ja3MiLCAoKmh3cGlwZSktPm5hbWUpOwotCQlyZXQgPSBtZHA1X3Nt cF9hc3NpZ24obWRwNV9rbXMtPnNtcCwgJnN0YXRlLT5zbXAsCisJCXJldCA9IG1kcDVfc21wX2Fz c2lnbihtZHA1X2ttcy0+c21wLCAmbmV3X21kcDVfc3RhdGUtPnNtcCwKIAkJCQkoKmh3cGlwZSkt PnBpcGUsIGJsa2NmZyk7CiAJCWlmIChyZXQpCiAJCQlyZXR1cm4gLUVOT01FTTsKQEAgLTEzMiwx MiArMTM1LDE3IEBAIHZvaWQgbWRwNV9waXBlX3JlbGVhc2Uoc3RydWN0IGRybV9hdG9taWNfc3Rh dGUgKnMsIHN0cnVjdCBtZHA1X2h3X3BpcGUgKmh3cGlwZSkKIHsKIAlzdHJ1Y3QgbXNtX2RybV9w cml2YXRlICpwcml2ID0gcy0+ZGV2LT5kZXZfcHJpdmF0ZTsKIAlzdHJ1Y3QgbWRwNV9rbXMgKm1k cDVfa21zID0gdG9fbWRwNV9rbXModG9fbWRwX2ttcyhwcml2LT5rbXMpKTsKLQlzdHJ1Y3QgbWRw NV9zdGF0ZSAqc3RhdGUgPSBtZHA1X2dldF9zdGF0ZShzKTsKLQlzdHJ1Y3QgbWRwNV9od19waXBl X3N0YXRlICpuZXdfc3RhdGUgPSAmc3RhdGUtPmh3cGlwZTsKKwlzdHJ1Y3QgbWRwNV9zdGF0ZSAq c3RhdGU7CisJc3RydWN0IG1kcDVfaHdfcGlwZV9zdGF0ZSAqbmV3X3N0YXRlOwogCiAJaWYgKCFo d3BpcGUpCiAJCXJldHVybjsKIAorCXN0YXRlID0gbWRwNV9zdGF0ZV9mcm9tX2F0b21pYyhzKTsK KwlpZiAoSVNfRVJSKHN0YXRlKSkKKwkJcmV0dXJuOworCisJbmV3X3N0YXRlID0gJnN0YXRlLT5o d3BpcGU7CiAJaWYgKFdBUk5fT04oIW5ld19zdGF0ZS0+aHdwaXBlX3RvX3BsYW5lW2h3cGlwZS0+ aWR4XSkpCiAJCXJldHVybjsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNw L21kcDUvbWRwNV9zbXAuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVfc21w LmMKaW5kZXggYWU0OTgzZDlkMGE1Li45MThlNDEyM2U3ODEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVfc21wLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21z bS9kaXNwL21kcDUvbWRwNV9zbXAuYwpAQCAtMzM4LDYgKzMzOCw3IEBAIHZvaWQgbWRwNV9zbXBf Y29tcGxldGVfY29tbWl0KHN0cnVjdCBtZHA1X3NtcCAqc21wLCBzdHJ1Y3QgbWRwNV9zbXBfc3Rh dGUgKnN0YXRlCiB2b2lkIG1kcDVfc21wX2R1bXAoc3RydWN0IG1kcDVfc21wICpzbXAsIHN0cnVj dCBkcm1fcHJpbnRlciAqcCkKIHsKIAlzdHJ1Y3QgbWRwNV9rbXMgKm1kcDVfa21zID0gZ2V0X2tt cyhzbXApOworCXN0cnVjdCBtZHA1X3N0YXRlICptZHA1X3N0YXRlOwogCXN0cnVjdCBtZHA1X2h3 X3BpcGVfc3RhdGUgKmh3cHN0YXRlOwogCXN0cnVjdCBtZHA1X3NtcF9zdGF0ZSAqc3RhdGU7CiAJ aW50IHRvdGFsID0gMCwgaSwgajsKQEAgLTM0NiwxMSArMzQ3LDEyIEBAIHZvaWQgbWRwNV9zbXBf ZHVtcChzdHJ1Y3QgbWRwNV9zbXAgKnNtcCwgc3RydWN0IGRybV9wcmludGVyICpwKQogCWRybV9w cmludGYocCwgIi0tLS1cdC0tLS0tXHQtLS0tLVxuIik7CiAKIAlpZiAoZHJtX2Nhbl9zbGVlcCgp KQotCQlkcm1fbW9kZXNldF9sb2NrKCZtZHA1X2ttcy0+c3RhdGVfbG9jaywgTlVMTCk7CisJCWRy bV9tb2Rlc2V0X2xvY2tfYWxsKG1kcDVfa21zLT5kZXYpOwogCi0JLyogZ3JhYiB0aGVzZSAqYWZ0 ZXIqIHdlIGhvbGQgdGhlIHN0YXRlX2xvY2sgKi8KLQlod3BzdGF0ZSA9ICZtZHA1X2ttcy0+c3Rh dGUtPmh3cGlwZTsKLQlzdGF0ZSA9ICZtZHA1X2ttcy0+c3RhdGUtPnNtcDsKKwkvKiBncmFiIHRo ZXNlICphZnRlciogd2UgaG9sZCB0aGUgbW9kZXNldF9sb2NrICovCisJbWRwNV9zdGF0ZSA9IG1k cDVfc3RhdGVfZnJvbV9kZXYobWRwNV9rbXMtPmRldik7CisJaHdwc3RhdGUgPSAmbWRwNV9zdGF0 ZS0+aHdwaXBlOworCXN0YXRlID0gJm1kcDVfc3RhdGUtPnNtcDsKIAogCWZvciAoaSA9IDA7IGkg PCBtZHA1X2ttcy0+bnVtX2h3cGlwZXM7IGkrKykgewogCQlzdHJ1Y3QgbWRwNV9od19waXBlICpo d3BpcGUgPSBtZHA1X2ttcy0+aHdwaXBlc1tpXTsKQEAgLTM3NCw3ICszNzYsNyBAQCB2b2lkIG1k cDVfc21wX2R1bXAoc3RydWN0IG1kcDVfc21wICpzbXAsIHN0cnVjdCBkcm1fcHJpbnRlciAqcCkK IAkJCWJpdG1hcF93ZWlnaHQoc3RhdGUtPnN0YXRlLCBzbXAtPmJsa19jbnQpKTsKIAogCWlmIChk cm1fY2FuX3NsZWVwKCkpCi0JCWRybV9tb2Rlc2V0X3VubG9jaygmbWRwNV9rbXMtPnN0YXRlX2xv Y2spOworCQlkcm1fbW9kZXNldF91bmxvY2tfYWxsKG1kcDVfa21zLT5kZXYpOwogfQogCiB2b2lk IG1kcDVfc21wX2Rlc3Ryb3koc3RydWN0IG1kcDVfc21wICpzbXApCkBAIC0zODIsMTIgKzM4NCwx NSBAQCB2b2lkIG1kcDVfc21wX2Rlc3Ryb3koc3RydWN0IG1kcDVfc21wICpzbXApCiAJa2ZyZWUo c21wKTsKIH0KIAotc3RydWN0IG1kcDVfc21wICptZHA1X3NtcF9pbml0KHN0cnVjdCBtZHA1X2tt cyAqbWRwNV9rbXMsIGNvbnN0IHN0cnVjdCBtZHA1X3NtcF9ibG9jayAqY2ZnKQorc3RydWN0IG1k cDVfc21wICptZHA1X3NtcF9pbml0KHN0cnVjdCBtZHA1X2ttcyAqbWRwNV9rbXMsCisJCQkgICAg ICAgY29uc3Qgc3RydWN0IG1kcDVfc21wX2Jsb2NrICpjZmcsCisJCQkgICAgICAgc3RydWN0IG1k cDVfc3RhdGUgKm1kcDVfc3RhdGUpCiB7Ci0Jc3RydWN0IG1kcDVfc21wX3N0YXRlICpzdGF0ZSA9 ICZtZHA1X2ttcy0+c3RhdGUtPnNtcDsKKwlzdHJ1Y3QgbWRwNV9zbXBfc3RhdGUgKnN0YXRlOwog CXN0cnVjdCBtZHA1X3NtcCAqc21wID0gTlVMTDsKIAlpbnQgcmV0OwogCisJc3RhdGUgPSAmbWRw NV9zdGF0ZS0+c21wOwogCXNtcCA9IGt6YWxsb2Moc2l6ZW9mKCpzbXApLCBHRlBfS0VSTkVMKTsK IAlpZiAodW5saWtlbHkoIXNtcCkpIHsKIAkJcmV0ID0gLUVOT01FTTsKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVfc21wLmggYi9kcml2ZXJzL2dwdS9kcm0v bXNtL2Rpc3AvbWRwNS9tZHA1X3NtcC5oCmluZGV4IGI0MWQwNDQ4ZmJlOC4uMWJmYTIyYjYzYTJk IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X3NtcC5oCisr KyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVfc21wLmgKQEAgLTY5LDYgKzY5 LDcgQEAgc3RydWN0IG1kcDVfc21wX3N0YXRlIHsKIH07CiAKIHN0cnVjdCBtZHA1X2ttczsKK3N0 cnVjdCBtZHA1X3N0YXRlOwogc3RydWN0IG1kcDVfc21wOwogCiAvKgpAQCAtNzgsNyArNzksOCBA QCBzdHJ1Y3QgbWRwNV9zbXA7CiAgKi8KIAogc3RydWN0IG1kcDVfc21wICptZHA1X3NtcF9pbml0 KHN0cnVjdCBtZHA1X2ttcyAqbWRwNV9rbXMsCi0JCWNvbnN0IHN0cnVjdCBtZHA1X3NtcF9ibG9j ayAqY2ZnKTsKKwkJY29uc3Qgc3RydWN0IG1kcDVfc21wX2Jsb2NrICpjZmcsCisJCXN0cnVjdCBt ZHA1X3N0YXRlICptZHA1X3N0YXRlKTsKIHZvaWQgIG1kcDVfc21wX2Rlc3Ryb3koc3RydWN0IG1k cDVfc21wICpzbXApOwogCiB2b2lkIG1kcDVfc21wX2R1bXAoc3RydWN0IG1kcDVfc21wICpzbXAs IHN0cnVjdCBkcm1fcHJpbnRlciAqcCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNt L21zbV9hdG9taWMuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2F0b21pYy5jCmluZGV4IGJm NWY4YzM5ZjM0ZC4uZTc5MjE1ODY3NmFhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNt L21zbV9hdG9taWMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9hdG9taWMuYwpAQCAt MjIwLDE2ICsyMjAsNiBAQCBpbnQgbXNtX2F0b21pY19jb21taXQoc3RydWN0IGRybV9kZXZpY2Ug KmRldiwKIAogCUJVR19PTihkcm1fYXRvbWljX2hlbHBlcl9zd2FwX3N0YXRlKHN0YXRlLCBmYWxz ZSkgPCAwKTsKIAotCS8qCi0JICogVGhpcyBpcyB0aGUgcG9pbnQgb2Ygbm8gcmV0dXJuIC0gZXZl cnl0aGluZyBiZWxvdyBuZXZlciBmYWlscyBleGNlcHQKLQkgKiB3aGVuIHRoZSBodyBnb2VzIGJv bmdoaXRzLiBXaGljaCBtZWFucyB3ZSBjYW4gY29tbWl0IHRoZSBuZXcgc3RhdGUgb24KLQkgKiB0 aGUgc29mdHdhcmUgc2lkZSBub3cuCi0JICoKLQkgKiBzd2FwIGRyaXZlciBwcml2YXRlIHN0YXRl IHdoaWxlIHN0aWxsIGhvbGRpbmcgc3RhdGVfbG9jawotCSAqLwotCWlmICh0b19rbXNfc3RhdGUo c3RhdGUpLT5zdGF0ZSkKLQkJcHJpdi0+a21zLT5mdW5jcy0+c3dhcF9zdGF0ZShwcml2LT5rbXMs IHN0YXRlKTsKLQogCS8qCiAJICogRXZlcnl0aGluZyBiZWxvdyBjYW4gYmUgcnVuIGFzeW5jaHJv bm91c2x5IHdpdGhvdXQgdGhlIG5lZWQgdG8gZ3JhYgogCSAqIGFueSBtb2Rlc2V0IGxvY2tzIGF0 IGFsbCB1bmRlciBvbmUgY29uZGl0aW9uczogSXQgbXVzdCBiZSBndWFyYW50ZWVkCkBAIC0yNjIs MzAgKzI1MiwzIEBAIGludCBtc21fYXRvbWljX2NvbW1pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 LAogCWRybV9hdG9taWNfaGVscGVyX2NsZWFudXBfcGxhbmVzKGRldiwgc3RhdGUpOwogCXJldHVy biByZXQ7CiB9Ci0KLXN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICptc21fYXRvbWljX3N0YXRlX2Fs bG9jKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCi17Ci0Jc3RydWN0IG1zbV9rbXNfc3RhdGUgKnN0 YXRlID0ga3phbGxvYyhzaXplb2YoKnN0YXRlKSwgR0ZQX0tFUk5FTCk7Ci0KLQlpZiAoIXN0YXRl IHx8IGRybV9hdG9taWNfc3RhdGVfaW5pdChkZXYsICZzdGF0ZS0+YmFzZSkgPCAwKSB7Ci0JCWtm cmVlKHN0YXRlKTsKLQkJcmV0dXJuIE5VTEw7Ci0JfQotCi0JcmV0dXJuICZzdGF0ZS0+YmFzZTsK LX0KLQotdm9pZCBtc21fYXRvbWljX3N0YXRlX2NsZWFyKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRl ICpzKQotewotCXN0cnVjdCBtc21fa21zX3N0YXRlICpzdGF0ZSA9IHRvX2ttc19zdGF0ZShzKTsK LQlkcm1fYXRvbWljX3N0YXRlX2RlZmF1bHRfY2xlYXIoJnN0YXRlLT5iYXNlKTsKLQlrZnJlZShz dGF0ZS0+c3RhdGUpOwotCXN0YXRlLT5zdGF0ZSA9IE5VTEw7Ci19Ci0KLXZvaWQgbXNtX2F0b21p Y19zdGF0ZV9mcmVlKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSkKLXsKLQlrZnJlZSh0 b19rbXNfc3RhdGUoc3RhdGUpLT5zdGF0ZSk7Ci0JZHJtX2F0b21pY19zdGF0ZV9kZWZhdWx0X3Jl bGVhc2Uoc3RhdGUpOwotCWtmcmVlKHN0YXRlKTsKLX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9tc20vbXNtX2Rydi5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZHJ2LmMKaW5kZXgg MzBjZDUxNGQ4ZjdjLi43ZThmNjQwMDYyZWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9t c20vbXNtX2Rydi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2Rydi5jCkBAIC00Miwx MSArNDIsNzkgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fbW9kZV9jb25maWdfZnVuY3MgbW9k ZV9jb25maWdfZnVuY3MgPSB7CiAJLm91dHB1dF9wb2xsX2NoYW5nZWQgPSBkcm1fZmJfaGVscGVy X291dHB1dF9wb2xsX2NoYW5nZWQsCiAJLmF0b21pY19jaGVjayA9IGRybV9hdG9taWNfaGVscGVy X2NoZWNrLAogCS5hdG9taWNfY29tbWl0ID0gbXNtX2F0b21pY19jb21taXQsCi0JLmF0b21pY19z dGF0ZV9hbGxvYyA9IG1zbV9hdG9taWNfc3RhdGVfYWxsb2MsCi0JLmF0b21pY19zdGF0ZV9jbGVh ciA9IG1zbV9hdG9taWNfc3RhdGVfY2xlYXIsCi0JLmF0b21pY19zdGF0ZV9mcmVlID0gbXNtX2F0 b21pY19zdGF0ZV9mcmVlLAogfTsKIAorc3RhdGljIGlubGluZQorc3RydWN0IG1zbV9rbXMgKm1z bV9rbXNfZnJvbV9vYmooc3RydWN0IGRybV9wcml2YXRlX29iaiAqb2JqKQoreworCXJldHVybiBj b250YWluZXJfb2Yob2JqLCBzdHJ1Y3QgbXNtX2ttcywgYmFzZSk7Cit9CisKK3N0YXRpYyBpbmxp bmUKK3N0cnVjdCBtc21fa21zX3N0YXRlICptc21fa21zX3N0YXRlX2Zyb21fcHJpdihzdHJ1Y3Qg ZHJtX3ByaXZhdGVfc3RhdGUgKnByaXYpCit7CisJcmV0dXJuIGNvbnRhaW5lcl9vZihwcml2LCBz dHJ1Y3QgbXNtX2ttc19zdGF0ZSwgYmFzZSk7Cit9CisKKworc3RydWN0IG1zbV9rbXNfc3RhdGUg Km1zbV9rbXNfc3RhdGVfZnJvbV9hdG9taWMoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRl KQoreworCXN0cnVjdCBtc21fZHJtX3ByaXZhdGUgKnByaXYgPSBzdGF0ZS0+ZGV2LT5kZXZfcHJp dmF0ZTsKKwlzdHJ1Y3QgZHJtX3ByaXZhdGVfb2JqICpvYmogPSAmcHJpdi0+a21zLT5iYXNlOwor CXN0cnVjdCBkcm1fcHJpdmF0ZV9zdGF0ZSAqcHJpdl9zdGF0ZTsKKworCXByaXZfc3RhdGUgPSBk cm1fYXRvbWljX2dldF9wcml2YXRlX29ial9zdGF0ZShzdGF0ZSwgb2JqKTsKKwlpZiAoSVNfRVJS X09SX05VTEwocHJpdl9zdGF0ZSkpCisJCXJldHVybiAoc3RydWN0IG1zbV9rbXNfc3RhdGUgKilz dGF0ZTsgLyogY2FzdGluZyBFUlJfUFRSICovCisKKwlyZXR1cm4gbXNtX2ttc19zdGF0ZV9mcm9t X3ByaXYocHJpdl9zdGF0ZSk7Cit9CisKK3N0cnVjdCBtc21fa21zX3N0YXRlICptc21fa21zX3N0 YXRlX2Zyb21fZGV2KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCit7CisJc3RydWN0IG1zbV9kcm1f cHJpdmF0ZSAqcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7CisJc3RydWN0IGRybV9wcml2YXRlX29i aiAqb2JqID0gJnByaXYtPmttcy0+YmFzZTsKKwlzdHJ1Y3QgZHJtX3ByaXZhdGVfc3RhdGUgKnBy aXZfc3RhdGUgPSBvYmotPnN0YXRlOworCisJcmV0dXJuIG1zbV9rbXNfc3RhdGVfZnJvbV9wcml2 KHByaXZfc3RhdGUpOworfQorCitzdGF0aWMgc3RydWN0IGRybV9wcml2YXRlX3N0YXRlICoKK21z bV9rbXNfZHVwbGljYXRlX3N0YXRlKHN0cnVjdCBkcm1fcHJpdmF0ZV9vYmogKm9iaikKK3sKKwlz dHJ1Y3QgbXNtX2ttcyAqa21zID0gbXNtX2ttc19mcm9tX29iaihvYmopOworCXN0cnVjdCBtc21f a21zX3N0YXRlICpzdGF0ZSA9IG1zbV9rbXNfc3RhdGVfZnJvbV9wcml2KG9iai0+c3RhdGUpOwor CXN0cnVjdCBtc21fa21zX3N0YXRlICpuZXdfc3RhdGU7CisKKwluZXdfc3RhdGUgPSBremFsbG9j KHNpemVvZigqbmV3X3N0YXRlKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFuZXdfc3RhdGUpCisJCXJl dHVybiBOVUxMOworCisJaWYgKGttcy0+ZnVuY3MtPmR1cGxpY2F0ZV9zdGF0ZSkKKwkJbmV3X3N0 YXRlLT5zdGF0ZSA9IGttcy0+ZnVuY3MtPmR1cGxpY2F0ZV9zdGF0ZShzdGF0ZS0+c3RhdGUpOwor CisJX19kcm1fYXRvbWljX2hlbHBlcl9wcml2YXRlX29ial9kdXBsaWNhdGVfc3RhdGUob2JqLCAm bmV3X3N0YXRlLT5iYXNlKTsKKworCXJldHVybiAmbmV3X3N0YXRlLT5iYXNlOworfQorCitzdGF0 aWMgdm9pZCBtc21fa21zX2Rlc3Ryb3lfc3RhdGUoc3RydWN0IGRybV9wcml2YXRlX29iaiAqb2Jq LAorCQkJCSAgc3RydWN0IGRybV9wcml2YXRlX3N0YXRlICpwcml2X3N0YXRlKQoreworCXN0cnVj dCBtc21fa21zICprbXMgPSBtc21fa21zX2Zyb21fb2JqKG9iaik7CisJc3RydWN0IG1zbV9rbXNf c3RhdGUgKnN0YXRlID0gbXNtX2ttc19zdGF0ZV9mcm9tX3ByaXYocHJpdl9zdGF0ZSk7CisKKwlp ZiAoa21zLT5mdW5jcy0+ZGVzdHJveV9zdGF0ZSkKKwkJa21zLT5mdW5jcy0+ZGVzdHJveV9zdGF0 ZShzdGF0ZS0+c3RhdGUpOworCWtmcmVlKHN0YXRlKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVj dCBkcm1fcHJpdmF0ZV9zdGF0ZV9mdW5jcyBrbXNfc3RhdGVfZnVuY3MgPSB7CisJLmF0b21pY19k dXBsaWNhdGVfc3RhdGUgPSBtc21fa21zX2R1cGxpY2F0ZV9zdGF0ZSwKKwkuYXRvbWljX2Rlc3Ry b3lfc3RhdGUgPSBtc21fa21zX2Rlc3Ryb3lfc3RhdGUsCit9OworCisKICNpZmRlZiBDT05GSUdf RFJNX01TTV9SRUdJU1RFUl9MT0dHSU5HCiBzdGF0aWMgYm9vbCByZWdsb2cgPSBmYWxzZTsKIE1P RFVMRV9QQVJNX0RFU0MocmVnbG9nLCAiRW5hYmxlIHJlZ2lzdGVyIHJlYWQvd3JpdGUgbG9nZ2lu ZyIpOwpAQCAtMjQ1LDYgKzMxMyw4IEBAIHN0YXRpYyBpbnQgbXNtX2RybV91bmluaXQoc3RydWN0 IGRldmljZSAqZGV2KQogCWZsdXNoX3dvcmtxdWV1ZShwcml2LT5hdG9taWNfd3EpOwogCWRlc3Ry b3lfd29ya3F1ZXVlKHByaXYtPmF0b21pY193cSk7CiAKKwlkcm1fYXRvbWljX3ByaXZhdGVfb2Jq X2ZpbmkoJmttcy0+YmFzZSk7CisKIAlpZiAoa21zICYmIGttcy0+ZnVuY3MpCiAJCWttcy0+ZnVu Y3MtPmRlc3Ryb3koa21zKTsKIApAQCAtMzU2LDYgKzQyNiw3IEBAIHN0YXRpYyBpbnQgbXNtX2Ry bV9pbml0KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRybV9kcml2ZXIgKmRydikKIAlzdHJ1 Y3QgZHJtX2RldmljZSAqZGRldjsKIAlzdHJ1Y3QgbXNtX2RybV9wcml2YXRlICpwcml2OwogCXN0 cnVjdCBtc21fa21zICprbXM7CisJc3RydWN0IG1zbV9rbXNfc3RhdGUgKmluaXRpYWxfc3RhdGU7 CiAJaW50IHJldDsKIAogCWRkZXYgPSBkcm1fZGV2X2FsbG9jKGRydiwgZGV2KTsKQEAgLTM2NCw2 ICs0MzUsMTAgQEAgc3RhdGljIGludCBtc21fZHJtX2luaXQoc3RydWN0IGRldmljZSAqZGV2LCBz dHJ1Y3QgZHJtX2RyaXZlciAqZHJ2KQogCQlyZXR1cm4gUFRSX0VSUihkZGV2KTsKIAl9CiAKKwlp bml0aWFsX3N0YXRlID0ga3phbGxvYyhzaXplb2YoKmluaXRpYWxfc3RhdGUpLCBHRlBfS0VSTkVM KTsKKwlpZiAoIWluaXRpYWxfc3RhdGUpCisJCXJldHVybiAtRU5PTUVNOworCiAJcGxhdGZvcm1f c2V0X2RydmRhdGEocGRldiwgZGRldik7CiAKIAlwcml2ID0ga3phbGxvYyhzaXplb2YoKnByaXYp LCBHRlBfS0VSTkVMKTsKQEAgLTM5NCw3ICs0NjksNyBAQCBzdGF0aWMgaW50IG1zbV9kcm1faW5p dChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkcm1fZHJpdmVyICpkcnYpCiAJZHJtX21vZGVf Y29uZmlnX2luaXQoZGRldik7CiAKIAkvKiBCaW5kIGFsbCBvdXIgc3ViLWNvbXBvbmVudHM6ICov Ci0JcmV0ID0gY29tcG9uZW50X2JpbmRfYWxsKGRldiwgZGRldik7CisJcmV0ID0gY29tcG9uZW50 X2JpbmRfYWxsKGRldiwgaW5pdGlhbF9zdGF0ZSk7CiAJaWYgKHJldCkgewogCQltc21fbWRzc19k ZXN0cm95KGRkZXYpOwogCQlrZnJlZShwcml2KTsKQEAgLTQzMyw2ICs1MDgsMTAgQEAgc3RhdGlj IGludCBtc21fZHJtX2luaXQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZHJtX2RyaXZlciAq ZHJ2KQogCQlnb3RvIGZhaWw7CiAJfQogCisJZHJtX2F0b21pY19wcml2YXRlX29ial9pbml0KCZr bXMtPmJhc2UsCisJCQkJICAgICZpbml0aWFsX3N0YXRlLT5iYXNlLAorCQkJCSAgICAma21zX3N0 YXRlX2Z1bmNzKTsKKwogCWlmIChrbXMpIHsKIAkJcmV0ID0ga21zLT5mdW5jcy0+aHdfaW5pdChr bXMpOwogCQlpZiAocmV0KSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9k cnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2Rydi5oCmluZGV4IDQ4ZWQ1YjlhODU4MC4u YzViOGM5ODliODU5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9kcnYuaAor KysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9kcnYuaApAQCAtMTYyLDkgKzE2Miw2IEBAIHN0 cnVjdCBtc21fZm9ybWF0IHsKIAogaW50IG1zbV9hdG9taWNfY29tbWl0KHN0cnVjdCBkcm1fZGV2 aWNlICpkZXYsCiAJCXN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSwgYm9vbCBub25ibG9j ayk7Ci1zdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqbXNtX2F0b21pY19zdGF0ZV9hbGxvYyhzdHJ1 Y3QgZHJtX2RldmljZSAqZGV2KTsKLXZvaWQgbXNtX2F0b21pY19zdGF0ZV9jbGVhcihzdHJ1Y3Qg ZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpOwotdm9pZCBtc21fYXRvbWljX3N0YXRlX2ZyZWUoc3Ry dWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKTsKIAogdm9pZCBtc21fZ2VtX3VubWFwX3ZtYShz dHJ1Y3QgbXNtX2dlbV9hZGRyZXNzX3NwYWNlICphc3BhY2UsCiAJCXN0cnVjdCBtc21fZ2VtX3Zt YSAqdm1hLCBzdHJ1Y3Qgc2dfdGFibGUgKnNndCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vbXNtL21zbV9rbXMuaCBiL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2ttcy5oCmluZGV4IDE3 ZDU4MjQ0MTdhZC4uMjRkMDlmY2ViZjE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNt L21zbV9rbXMuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9rbXMuaApAQCAtNDIsNiAr NDIsOCBAQCBzdHJ1Y3QgbXNtX2ttc19mdW5jcyB7CiAJdm9pZCAoKmRpc2FibGVfdmJsYW5rKShz dHJ1Y3QgbXNtX2ttcyAqa21zLCBzdHJ1Y3QgZHJtX2NydGMgKmNydGMpOwogCS8qIHN3YXAgZ2xv YmFsIGF0b21pYyBzdGF0ZTogKi8KIAl2b2lkICgqc3dhcF9zdGF0ZSkoc3RydWN0IG1zbV9rbXMg Kmttcywgc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKTsKKwl2b2lkICooKmR1cGxpY2F0 ZV9zdGF0ZSkodm9pZCAqc3RhdGUpOworCXZvaWQgKCpkZXN0cm95X3N0YXRlKSh2b2lkICpzdGF0 ZSk7CiAJLyogbW9kZXNldCwgYnJhY2tldGluZyBhdG9taWNfY29tbWl0KCk6ICovCiAJdm9pZCAo KnByZXBhcmVfY29tbWl0KShzdHJ1Y3QgbXNtX2ttcyAqa21zLCBzdHJ1Y3QgZHJtX2F0b21pY19z dGF0ZSAqc3RhdGUpOwogCXZvaWQgKCpjb21wbGV0ZV9jb21taXQpKHN0cnVjdCBtc21fa21zICpr bXMsIHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSk7CkBAIC02OCw2ICs3MCw4IEBAIHN0 cnVjdCBtc21fa21zX2Z1bmNzIHsKIH07CiAKIHN0cnVjdCBtc21fa21zIHsKKwlzdHJ1Y3QgZHJt X3ByaXZhdGVfb2JqIGJhc2U7CisKIAljb25zdCBzdHJ1Y3QgbXNtX2ttc19mdW5jcyAqZnVuY3M7 CiAKIAkvKiBpcnEgbnVtYmVyIHRvIGJlIHBhc3NlZCBvbiB0byBkcm1faXJxX2luc3RhbGwgKi8K QEAgLTc4LDE2ICs4MiwyMyBAQCBzdHJ1Y3QgbXNtX2ttcyB7CiB9OwogCiAvKioKLSAqIFN1YmNs YXNzIG9mIGRybV9hdG9taWNfc3RhdGUsIHRvIGFsbG93IGttcyBiYWNrZW5kIHRvIGhhdmUgZHJp dmVyCisgKiBTdWJjbGFzcyBvZiBkcm1fcHJpdmF0ZV9zdGF0ZSwgdG8gYWxsb3cga21zIGJhY2tl bmQgdG8gaGF2ZSBkcml2ZXIKICAqIHByaXZhdGUgZ2xvYmFsIHN0YXRlLiAgVGhlIGttcyBiYWNr ZW5kIGNhbiBkbyB3aGF0ZXZlciBpdCB3YW50cwotICogd2l0aCB0aGUgLT5zdGF0ZSBwdHIuICBP biAtPmF0b21pY19zdGF0ZV9jbGVhcigpIHRoZSAtPnN0YXRlIHB0cgotICogaXMga2ZyZWUnZCBh bmQgc2V0IGJhY2sgdG8gTlVMTC4KKyAqIHdpdGggdGhlIC0+c3RhdGUgcHRyLgogICovCiBzdHJ1 Y3QgbXNtX2ttc19zdGF0ZSB7Ci0Jc3RydWN0IGRybV9hdG9taWNfc3RhdGUgYmFzZTsKKwlzdHJ1 Y3QgZHJtX3ByaXZhdGVfc3RhdGUgYmFzZTsKIAl2b2lkICpzdGF0ZTsKIH07Ci0jZGVmaW5lIHRv X2ttc19zdGF0ZSh4KSBjb250YWluZXJfb2YoeCwgc3RydWN0IG1zbV9rbXNfc3RhdGUsIGJhc2Up CisKKy8qKgorICogRXh0cmFjdHMgdGhlIG1zbV9rbXNfc3RhdGUgZnJvbSBlaXRoZXIgYW4gYXRv bWljIHN0YXRlLCBvciB0aGUgY3VycmVudAorICogZGV2aWNlLiBPbmUgb3IgdGhlIG90aGVyIG1p Z2h0IGJlIGRlc2lyYWJsZSBkZXBlbmRpbmcgb24gd2hldGhlciB5b3Ugd2FudCB0aGUKKyAqIGN1 cnJlbnRseSBjb25maWd1cmVkIG1zbV9rbXNfc3RhdGUgKGZyb21fZGV2KSwgb3IgeW91IHdvdWxk IGxpa2UgdGhlIHN0YXRlCisgKiB3aGljaCBpcyBhYm91dCB0byBiZSBhcHBsaWVkIChmcm9tX2F0 b21pYykuCisgKi8KK3N0cnVjdCBtc21fa21zX3N0YXRlICptc21fa21zX3N0YXRlX2Zyb21fZGV2 KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpOworc3RydWN0IG1zbV9rbXNfc3RhdGUgKm1zbV9rbXNf c3RhdGVfZnJvbV9hdG9taWMoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKTsKIAogc3Rh dGljIGlubGluZSB2b2lkIG1zbV9rbXNfaW5pdChzdHJ1Y3QgbXNtX2ttcyAqa21zLAogCQljb25z dCBzdHJ1Y3QgbXNtX2ttc19mdW5jcyAqZnVuY3MpCi0tIApTZWFuIFBhdWwsIFNvZnR3YXJlIEVu Z2luZWVyLCBHb29nbGUgLyBDaHJvbWl1bSBPUwoKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlz dHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4v bGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753778AbeC1TIM (ORCPT ); Wed, 28 Mar 2018 15:08:12 -0400 Received: from mail-yw0-f194.google.com ([209.85.161.194]:45434 "EHLO mail-yw0-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753096AbeC1TIK (ORCPT ); Wed, 28 Mar 2018 15:08:10 -0400 X-Google-Smtp-Source: AIpwx4/D9WW/VY8xJBfRkqE6LSztx1ctkpZKEhjMxUw/NwAgm76AfdrehmBoLIA2wNyEfijmFheC3Q== From: Sean Paul To: freedreno@lists.freedesktop.org, linux-arm-msm@vger.kernel.org, dri-devel@lists.freedesktop.org Cc: robdclark@gmail.com, hoegsberg@chromium.org, jsanka@codeaurora.org, abhinavk@codeaurora.org, architt@codeaurora.org, Sean Paul , linux-kernel@vger.kernel.org Subject: [PATCH v2 1/6] drm/msm: Use drm_private_obj/state instead of subclassing Date: Wed, 28 Mar 2018 15:06:47 -0400 Message-Id: <20180328190657.218661-2-seanpaul@chromium.org> X-Mailer: git-send-email 2.17.0.rc1.321.gba9d0f2565-goog In-Reply-To: <20180328190657.218661-1-seanpaul@chromium.org> References: <20180328190657.218661-1-seanpaul@chromium.org> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Now that we have private state handled by the core, we can use those instead of rolling our own swap_state for private data. Originally posted here: https://patchwork.freedesktop.org/patch/211361/ Changes in v2: - Use state->state in disp duplicate_state callback (Jeykumar) Changes in v3: - Update comment describing msm_kms_state (Jeykumar) Changes in v4: - Rebased on msm-next - Don't always use private state from atomic state (Archit) - Renamed some of the state accessors - Tested on mdp5 db410c Changes in v5: - None Cc: Jeykumar Sankaran Cc: Archit Taneja Signed-off-by: Sean Paul --- drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c | 77 ++++++++++--------- drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.h | 11 +-- drivers/gpu/drm/msm/disp/mdp5/mdp5_mixer.c | 12 ++- drivers/gpu/drm/msm/disp/mdp5/mdp5_pipe.c | 28 ++++--- drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.c | 19 +++-- drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.h | 4 +- drivers/gpu/drm/msm/msm_atomic.c | 37 --------- drivers/gpu/drm/msm/msm_drv.c | 87 +++++++++++++++++++++- drivers/gpu/drm/msm/msm_drv.h | 3 - drivers/gpu/drm/msm/msm_kms.h | 21 ++++-- 10 files changed, 183 insertions(+), 116 deletions(-) diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c index 6d8e3a9a6fc0..366670043190 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c @@ -70,60 +70,62 @@ static int mdp5_hw_init(struct msm_kms *kms) return 0; } -struct mdp5_state *mdp5_get_state(struct drm_atomic_state *s) +struct mdp5_state *mdp5_state_from_atomic(struct drm_atomic_state *state) { - struct msm_drm_private *priv = s->dev->dev_private; - struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(priv->kms)); - struct msm_kms_state *state = to_kms_state(s); - struct mdp5_state *new_state; - int ret; + struct msm_kms_state *kms_state = msm_kms_state_from_atomic(state); - if (state->state) - return state->state; + if (IS_ERR_OR_NULL(kms_state)) + return (struct mdp5_state *)kms_state; /* casting ERR_PTR */ - ret = drm_modeset_lock(&mdp5_kms->state_lock, s->acquire_ctx); - if (ret) - return ERR_PTR(ret); + return kms_state->state; +} - new_state = kmalloc(sizeof(*mdp5_kms->state), GFP_KERNEL); - if (!new_state) - return ERR_PTR(-ENOMEM); +struct mdp5_state *mdp5_state_from_dev(struct drm_device *dev) +{ + struct msm_kms_state *kms_state = msm_kms_state_from_dev(dev); - /* Copy state: */ - new_state->hwpipe = mdp5_kms->state->hwpipe; - new_state->hwmixer = mdp5_kms->state->hwmixer; - if (mdp5_kms->smp) - new_state->smp = mdp5_kms->state->smp; + if (IS_ERR_OR_NULL(kms_state)) + return (struct mdp5_state *)kms_state; /* casting ERR_PTR */ - state->state = new_state; + return kms_state->state; +} + +static void *mdp5_duplicate_state(void *state) +{ + if (!state) + return kzalloc(sizeof(struct mdp5_state), GFP_KERNEL); - return new_state; + return kmemdup(state, sizeof(struct mdp5_state), GFP_KERNEL); } -static void mdp5_swap_state(struct msm_kms *kms, struct drm_atomic_state *state) +static void mdp5_destroy_state(void *state) { - struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(kms)); - swap(to_kms_state(state)->state, mdp5_kms->state); + struct mdp5_state *mdp_state = (struct mdp5_state *)state; + kfree(mdp_state); } -static void mdp5_prepare_commit(struct msm_kms *kms, struct drm_atomic_state *state) +static void mdp5_prepare_commit(struct msm_kms *kms, + struct drm_atomic_state *old_state) { struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(kms)); + struct mdp5_state *mdp5_state = mdp5_state_from_dev(mdp5_kms->dev); struct device *dev = &mdp5_kms->pdev->dev; pm_runtime_get_sync(dev); if (mdp5_kms->smp) - mdp5_smp_prepare_commit(mdp5_kms->smp, &mdp5_kms->state->smp); + mdp5_smp_prepare_commit(mdp5_kms->smp, &mdp5_state->smp); } -static void mdp5_complete_commit(struct msm_kms *kms, struct drm_atomic_state *state) +static void mdp5_complete_commit(struct msm_kms *kms, + struct drm_atomic_state *old_state) { struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(kms)); + struct mdp5_state *mdp5_state = mdp5_state_from_dev(mdp5_kms->dev); struct device *dev = &mdp5_kms->pdev->dev; if (mdp5_kms->smp) - mdp5_smp_complete_commit(mdp5_kms->smp, &mdp5_kms->state->smp); + mdp5_smp_complete_commit(mdp5_kms->smp, &mdp5_state->smp); pm_runtime_put_sync(dev); } @@ -229,7 +231,8 @@ static const struct mdp_kms_funcs kms_funcs = { .irq = mdp5_irq, .enable_vblank = mdp5_enable_vblank, .disable_vblank = mdp5_disable_vblank, - .swap_state = mdp5_swap_state, + .duplicate_state = mdp5_duplicate_state, + .destroy_state = mdp5_destroy_state, .prepare_commit = mdp5_prepare_commit, .complete_commit = mdp5_complete_commit, .wait_for_crtc_commit_done = mdp5_wait_for_crtc_commit_done, @@ -726,8 +729,6 @@ static void mdp5_destroy(struct platform_device *pdev) if (mdp5_kms->rpm_enabled) pm_runtime_disable(&pdev->dev); - - kfree(mdp5_kms->state); } static int construct_pipes(struct mdp5_kms *mdp5_kms, int cnt, @@ -859,7 +860,8 @@ static int interface_init(struct mdp5_kms *mdp5_kms) return 0; } -static int mdp5_init(struct platform_device *pdev, struct drm_device *dev) +static int mdp5_init(struct platform_device *pdev, struct drm_device *dev, + struct msm_kms_state *initial_state) { struct msm_drm_private *priv = dev->dev_private; struct mdp5_kms *mdp5_kms; @@ -880,9 +882,8 @@ static int mdp5_init(struct platform_device *pdev, struct drm_device *dev) mdp5_kms->dev = dev; mdp5_kms->pdev = pdev; - drm_modeset_lock_init(&mdp5_kms->state_lock); - mdp5_kms->state = kzalloc(sizeof(*mdp5_kms->state), GFP_KERNEL); - if (!mdp5_kms->state) { + initial_state->state = mdp5_duplicate_state(NULL); + if (!initial_state->state) { ret = -ENOMEM; goto fail; } @@ -940,7 +941,8 @@ static int mdp5_init(struct platform_device *pdev, struct drm_device *dev) * this section initializes the SMP: */ if (mdp5_kms->caps & MDP_CAP_SMP) { - mdp5_kms->smp = mdp5_smp_init(mdp5_kms, &config->hw->smp); + mdp5_kms->smp = mdp5_smp_init(mdp5_kms, &config->hw->smp, + initial_state->state); if (IS_ERR(mdp5_kms->smp)) { ret = PTR_ERR(mdp5_kms->smp); mdp5_kms->smp = NULL; @@ -980,10 +982,11 @@ static int mdp5_bind(struct device *dev, struct device *master, void *data) { struct drm_device *ddev = dev_get_drvdata(master); struct platform_device *pdev = to_platform_device(dev); + struct msm_kms_state *initial_state = (struct msm_kms_state *)data; DBG(""); - return mdp5_init(pdev, ddev); + return mdp5_init(pdev, ddev, initial_state); } static void mdp5_unbind(struct device *dev, struct device *master, diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.h b/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.h index 425a03d213e5..e23117b82aad 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.h +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.h @@ -28,8 +28,6 @@ #include "mdp5_ctl.h" #include "mdp5_smp.h" -struct mdp5_state; - struct mdp5_kms { struct mdp_kms base; @@ -49,12 +47,6 @@ struct mdp5_kms { struct mdp5_cfg_handler *cfg; uint32_t caps; /* MDP capabilities (MDP_CAP_XXX bits) */ - /** - * Global atomic state. Do not access directly, use mdp5_get_state() - */ - struct mdp5_state *state; - struct drm_modeset_lock state_lock; - struct mdp5_smp *smp; struct mdp5_ctl_manager *ctlm; @@ -93,7 +85,8 @@ struct mdp5_state { }; struct mdp5_state *__must_check -mdp5_get_state(struct drm_atomic_state *s); +mdp5_state_from_atomic(struct drm_atomic_state *s); +struct mdp5_state *__must_check mdp5_state_from_dev(struct drm_device *dev); /* Atomic plane state. Subclasses the base drm_plane_state in order to * track assigned hwpipe and hw specific state. diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_mixer.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_mixer.c index 8a00991f03c7..fdd5e12a9d56 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_mixer.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_mixer.c @@ -52,10 +52,11 @@ int mdp5_mixer_assign(struct drm_atomic_state *s, struct drm_crtc *crtc, { struct msm_drm_private *priv = s->dev->dev_private; struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(priv->kms)); - struct mdp5_state *state = mdp5_get_state(s); + struct mdp5_state *state; struct mdp5_hw_mixer_state *new_state; int i; + state = mdp5_state_from_atomic(s); if (IS_ERR(state)) return PTR_ERR(state); @@ -129,12 +130,17 @@ int mdp5_mixer_assign(struct drm_atomic_state *s, struct drm_crtc *crtc, void mdp5_mixer_release(struct drm_atomic_state *s, struct mdp5_hw_mixer *mixer) { - struct mdp5_state *state = mdp5_get_state(s); - struct mdp5_hw_mixer_state *new_state = &state->hwmixer; + struct mdp5_state *state; + struct mdp5_hw_mixer_state *new_state; if (!mixer) return; + state = mdp5_state_from_atomic(s); + if (IS_ERR(state)) + return; + + new_state = &state->hwmixer; if (WARN_ON(!new_state->hwmixer_to_crtc[mixer->idx])) return; diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_pipe.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_pipe.c index ff52c49095f9..dc66ab9fdd50 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_pipe.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_pipe.c @@ -24,17 +24,20 @@ int mdp5_pipe_assign(struct drm_atomic_state *s, struct drm_plane *plane, { struct msm_drm_private *priv = s->dev->dev_private; struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(priv->kms)); - struct mdp5_state *state; + struct mdp5_state *old_mdp5_state, *new_mdp5_state; struct mdp5_hw_pipe_state *old_state, *new_state; int i, j; - state = mdp5_get_state(s); - if (IS_ERR(state)) - return PTR_ERR(state); + new_mdp5_state = mdp5_state_from_atomic(s); + if (IS_ERR(new_mdp5_state)) + return PTR_ERR(new_mdp5_state); - /* grab old_state after mdp5_get_state(), since now we hold lock: */ - old_state = &mdp5_kms->state->hwpipe; - new_state = &state->hwpipe; + old_mdp5_state = mdp5_state_from_dev(s->dev); + if (IS_ERR(old_mdp5_state)) + return PTR_ERR(old_mdp5_state); + + old_state = &old_mdp5_state->hwpipe; + new_state = &new_mdp5_state->hwpipe; for (i = 0; i < mdp5_kms->num_hwpipes; i++) { struct mdp5_hw_pipe *cur = mdp5_kms->hwpipes[i]; @@ -107,7 +110,7 @@ int mdp5_pipe_assign(struct drm_atomic_state *s, struct drm_plane *plane, WARN_ON(r_hwpipe); DBG("%s: alloc SMP blocks", (*hwpipe)->name); - ret = mdp5_smp_assign(mdp5_kms->smp, &state->smp, + ret = mdp5_smp_assign(mdp5_kms->smp, &new_mdp5_state->smp, (*hwpipe)->pipe, blkcfg); if (ret) return -ENOMEM; @@ -132,12 +135,17 @@ void mdp5_pipe_release(struct drm_atomic_state *s, struct mdp5_hw_pipe *hwpipe) { struct msm_drm_private *priv = s->dev->dev_private; struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(priv->kms)); - struct mdp5_state *state = mdp5_get_state(s); - struct mdp5_hw_pipe_state *new_state = &state->hwpipe; + struct mdp5_state *state; + struct mdp5_hw_pipe_state *new_state; if (!hwpipe) return; + state = mdp5_state_from_atomic(s); + if (IS_ERR(state)) + return; + + new_state = &state->hwpipe; if (WARN_ON(!new_state->hwpipe_to_plane[hwpipe->idx])) return; diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.c index ae4983d9d0a5..918e4123e781 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.c @@ -338,6 +338,7 @@ void mdp5_smp_complete_commit(struct mdp5_smp *smp, struct mdp5_smp_state *state void mdp5_smp_dump(struct mdp5_smp *smp, struct drm_printer *p) { struct mdp5_kms *mdp5_kms = get_kms(smp); + struct mdp5_state *mdp5_state; struct mdp5_hw_pipe_state *hwpstate; struct mdp5_smp_state *state; int total = 0, i, j; @@ -346,11 +347,12 @@ void mdp5_smp_dump(struct mdp5_smp *smp, struct drm_printer *p) drm_printf(p, "----\t-----\t-----\n"); if (drm_can_sleep()) - drm_modeset_lock(&mdp5_kms->state_lock, NULL); + drm_modeset_lock_all(mdp5_kms->dev); - /* grab these *after* we hold the state_lock */ - hwpstate = &mdp5_kms->state->hwpipe; - state = &mdp5_kms->state->smp; + /* grab these *after* we hold the modeset_lock */ + mdp5_state = mdp5_state_from_dev(mdp5_kms->dev); + hwpstate = &mdp5_state->hwpipe; + state = &mdp5_state->smp; for (i = 0; i < mdp5_kms->num_hwpipes; i++) { struct mdp5_hw_pipe *hwpipe = mdp5_kms->hwpipes[i]; @@ -374,7 +376,7 @@ void mdp5_smp_dump(struct mdp5_smp *smp, struct drm_printer *p) bitmap_weight(state->state, smp->blk_cnt)); if (drm_can_sleep()) - drm_modeset_unlock(&mdp5_kms->state_lock); + drm_modeset_unlock_all(mdp5_kms->dev); } void mdp5_smp_destroy(struct mdp5_smp *smp) @@ -382,12 +384,15 @@ void mdp5_smp_destroy(struct mdp5_smp *smp) kfree(smp); } -struct mdp5_smp *mdp5_smp_init(struct mdp5_kms *mdp5_kms, const struct mdp5_smp_block *cfg) +struct mdp5_smp *mdp5_smp_init(struct mdp5_kms *mdp5_kms, + const struct mdp5_smp_block *cfg, + struct mdp5_state *mdp5_state) { - struct mdp5_smp_state *state = &mdp5_kms->state->smp; + struct mdp5_smp_state *state; struct mdp5_smp *smp = NULL; int ret; + state = &mdp5_state->smp; smp = kzalloc(sizeof(*smp), GFP_KERNEL); if (unlikely(!smp)) { ret = -ENOMEM; diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.h b/drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.h index b41d0448fbe8..1bfa22b63a2d 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.h +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.h @@ -69,6 +69,7 @@ struct mdp5_smp_state { }; struct mdp5_kms; +struct mdp5_state; struct mdp5_smp; /* @@ -78,7 +79,8 @@ struct mdp5_smp; */ struct mdp5_smp *mdp5_smp_init(struct mdp5_kms *mdp5_kms, - const struct mdp5_smp_block *cfg); + const struct mdp5_smp_block *cfg, + struct mdp5_state *mdp5_state); void mdp5_smp_destroy(struct mdp5_smp *smp); void mdp5_smp_dump(struct mdp5_smp *smp, struct drm_printer *p); diff --git a/drivers/gpu/drm/msm/msm_atomic.c b/drivers/gpu/drm/msm/msm_atomic.c index bf5f8c39f34d..e792158676aa 100644 --- a/drivers/gpu/drm/msm/msm_atomic.c +++ b/drivers/gpu/drm/msm/msm_atomic.c @@ -220,16 +220,6 @@ int msm_atomic_commit(struct drm_device *dev, BUG_ON(drm_atomic_helper_swap_state(state, false) < 0); - /* - * This is the point of no return - everything below never fails except - * when the hw goes bonghits. Which means we can commit the new state on - * the software side now. - * - * swap driver private state while still holding state_lock - */ - if (to_kms_state(state)->state) - priv->kms->funcs->swap_state(priv->kms, state); - /* * Everything below can be run asynchronously without the need to grab * any modeset locks at all under one conditions: It must be guaranteed @@ -262,30 +252,3 @@ int msm_atomic_commit(struct drm_device *dev, drm_atomic_helper_cleanup_planes(dev, state); return ret; } - -struct drm_atomic_state *msm_atomic_state_alloc(struct drm_device *dev) -{ - struct msm_kms_state *state = kzalloc(sizeof(*state), GFP_KERNEL); - - if (!state || drm_atomic_state_init(dev, &state->base) < 0) { - kfree(state); - return NULL; - } - - return &state->base; -} - -void msm_atomic_state_clear(struct drm_atomic_state *s) -{ - struct msm_kms_state *state = to_kms_state(s); - drm_atomic_state_default_clear(&state->base); - kfree(state->state); - state->state = NULL; -} - -void msm_atomic_state_free(struct drm_atomic_state *state) -{ - kfree(to_kms_state(state)->state); - drm_atomic_state_default_release(state); - kfree(state); -} diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c index 30cd514d8f7c..7e8f640062ef 100644 --- a/drivers/gpu/drm/msm/msm_drv.c +++ b/drivers/gpu/drm/msm/msm_drv.c @@ -42,11 +42,79 @@ static const struct drm_mode_config_funcs mode_config_funcs = { .output_poll_changed = drm_fb_helper_output_poll_changed, .atomic_check = drm_atomic_helper_check, .atomic_commit = msm_atomic_commit, - .atomic_state_alloc = msm_atomic_state_alloc, - .atomic_state_clear = msm_atomic_state_clear, - .atomic_state_free = msm_atomic_state_free, }; +static inline +struct msm_kms *msm_kms_from_obj(struct drm_private_obj *obj) +{ + return container_of(obj, struct msm_kms, base); +} + +static inline +struct msm_kms_state *msm_kms_state_from_priv(struct drm_private_state *priv) +{ + return container_of(priv, struct msm_kms_state, base); +} + + +struct msm_kms_state *msm_kms_state_from_atomic(struct drm_atomic_state *state) +{ + struct msm_drm_private *priv = state->dev->dev_private; + struct drm_private_obj *obj = &priv->kms->base; + struct drm_private_state *priv_state; + + priv_state = drm_atomic_get_private_obj_state(state, obj); + if (IS_ERR_OR_NULL(priv_state)) + return (struct msm_kms_state *)state; /* casting ERR_PTR */ + + return msm_kms_state_from_priv(priv_state); +} + +struct msm_kms_state *msm_kms_state_from_dev(struct drm_device *dev) +{ + struct msm_drm_private *priv = dev->dev_private; + struct drm_private_obj *obj = &priv->kms->base; + struct drm_private_state *priv_state = obj->state; + + return msm_kms_state_from_priv(priv_state); +} + +static struct drm_private_state * +msm_kms_duplicate_state(struct drm_private_obj *obj) +{ + struct msm_kms *kms = msm_kms_from_obj(obj); + struct msm_kms_state *state = msm_kms_state_from_priv(obj->state); + struct msm_kms_state *new_state; + + new_state = kzalloc(sizeof(*new_state), GFP_KERNEL); + if (!new_state) + return NULL; + + if (kms->funcs->duplicate_state) + new_state->state = kms->funcs->duplicate_state(state->state); + + __drm_atomic_helper_private_obj_duplicate_state(obj, &new_state->base); + + return &new_state->base; +} + +static void msm_kms_destroy_state(struct drm_private_obj *obj, + struct drm_private_state *priv_state) +{ + struct msm_kms *kms = msm_kms_from_obj(obj); + struct msm_kms_state *state = msm_kms_state_from_priv(priv_state); + + if (kms->funcs->destroy_state) + kms->funcs->destroy_state(state->state); + kfree(state); +} + +static const struct drm_private_state_funcs kms_state_funcs = { + .atomic_duplicate_state = msm_kms_duplicate_state, + .atomic_destroy_state = msm_kms_destroy_state, +}; + + #ifdef CONFIG_DRM_MSM_REGISTER_LOGGING static bool reglog = false; MODULE_PARM_DESC(reglog, "Enable register read/write logging"); @@ -245,6 +313,8 @@ static int msm_drm_uninit(struct device *dev) flush_workqueue(priv->atomic_wq); destroy_workqueue(priv->atomic_wq); + drm_atomic_private_obj_fini(&kms->base); + if (kms && kms->funcs) kms->funcs->destroy(kms); @@ -356,6 +426,7 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv) struct drm_device *ddev; struct msm_drm_private *priv; struct msm_kms *kms; + struct msm_kms_state *initial_state; int ret; ddev = drm_dev_alloc(drv, dev); @@ -364,6 +435,10 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv) return PTR_ERR(ddev); } + initial_state = kzalloc(sizeof(*initial_state), GFP_KERNEL); + if (!initial_state) + return -ENOMEM; + platform_set_drvdata(pdev, ddev); priv = kzalloc(sizeof(*priv), GFP_KERNEL); @@ -394,7 +469,7 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv) drm_mode_config_init(ddev); /* Bind all our sub-components: */ - ret = component_bind_all(dev, ddev); + ret = component_bind_all(dev, initial_state); if (ret) { msm_mdss_destroy(ddev); kfree(priv); @@ -433,6 +508,10 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv) goto fail; } + drm_atomic_private_obj_init(&kms->base, + &initial_state->base, + &kms_state_funcs); + if (kms) { ret = kms->funcs->hw_init(kms); if (ret) { diff --git a/drivers/gpu/drm/msm/msm_drv.h b/drivers/gpu/drm/msm/msm_drv.h index 48ed5b9a8580..c5b8c989b859 100644 --- a/drivers/gpu/drm/msm/msm_drv.h +++ b/drivers/gpu/drm/msm/msm_drv.h @@ -162,9 +162,6 @@ struct msm_format { int msm_atomic_commit(struct drm_device *dev, struct drm_atomic_state *state, bool nonblock); -struct drm_atomic_state *msm_atomic_state_alloc(struct drm_device *dev); -void msm_atomic_state_clear(struct drm_atomic_state *state); -void msm_atomic_state_free(struct drm_atomic_state *state); void msm_gem_unmap_vma(struct msm_gem_address_space *aspace, struct msm_gem_vma *vma, struct sg_table *sgt); diff --git a/drivers/gpu/drm/msm/msm_kms.h b/drivers/gpu/drm/msm/msm_kms.h index 17d5824417ad..24d09fcebf16 100644 --- a/drivers/gpu/drm/msm/msm_kms.h +++ b/drivers/gpu/drm/msm/msm_kms.h @@ -42,6 +42,8 @@ struct msm_kms_funcs { void (*disable_vblank)(struct msm_kms *kms, struct drm_crtc *crtc); /* swap global atomic state: */ void (*swap_state)(struct msm_kms *kms, struct drm_atomic_state *state); + void *(*duplicate_state)(void *state); + void (*destroy_state)(void *state); /* modeset, bracketing atomic_commit(): */ void (*prepare_commit)(struct msm_kms *kms, struct drm_atomic_state *state); void (*complete_commit)(struct msm_kms *kms, struct drm_atomic_state *state); @@ -68,6 +70,8 @@ struct msm_kms_funcs { }; struct msm_kms { + struct drm_private_obj base; + const struct msm_kms_funcs *funcs; /* irq number to be passed on to drm_irq_install */ @@ -78,16 +82,23 @@ struct msm_kms { }; /** - * Subclass of drm_atomic_state, to allow kms backend to have driver + * Subclass of drm_private_state, to allow kms backend to have driver * private global state. The kms backend can do whatever it wants - * with the ->state ptr. On ->atomic_state_clear() the ->state ptr - * is kfree'd and set back to NULL. + * with the ->state ptr. */ struct msm_kms_state { - struct drm_atomic_state base; + struct drm_private_state base; void *state; }; -#define to_kms_state(x) container_of(x, struct msm_kms_state, base) + +/** + * Extracts the msm_kms_state from either an atomic state, or the current + * device. One or the other might be desirable depending on whether you want the + * currently configured msm_kms_state (from_dev), or you would like the state + * which is about to be applied (from_atomic). + */ +struct msm_kms_state *msm_kms_state_from_dev(struct drm_device *dev); +struct msm_kms_state *msm_kms_state_from_atomic(struct drm_atomic_state *state); static inline void msm_kms_init(struct msm_kms *kms, const struct msm_kms_funcs *funcs) -- Sean Paul, Software Engineer, Google / Chromium OS