From mboxrd@z Thu Jan 1 00:00:00 1970 From: Hai Li Subject: [PATCH 3/3] drm/msm/dsi: Separate PHY to another platform device Date: Fri, 15 May 2015 13:04:06 -0400 Message-ID: <1431709446-31429-4-git-send-email-hali@codeaurora.org> References: <1431709446-31429-1-git-send-email-hali@codeaurora.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1431709446-31429-1-git-send-email-hali@codeaurora.org> 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 Cc: linux-arm-msm@vger.kernel.org, linux-kernel@vger.kernel.org List-Id: linux-arm-msm@vger.kernel.org VGhlcmUgYXJlIGRpZmZlcmVudCB0eXBlcyBvZiBQSFkgZnJvbSBvbmUgY2hpcHNldCB0byBhbm90 aGVyLCB3aGlsZQp0aGUgRFNJIGhvc3QgY29udHJvbGxlciBpcyByZWxhdGl2ZWx5IGNvbnNpc3Rl bnQgYWNyb3NzIHBsYXRmb3Jtcy4KQWxzbywgdGhlIFBMTCBpbnNpZGUgUEhZIGlzIHByb3ZpZGlu ZyB0aGUgc291cmNlIG9mIERTSSBieXRlIGFuZApwaXhlbCBjbG9ja3MsIHdoaWNoIGFyZSB1c2Vk IGJ5IERTSSBob3N0IGNvbnRyb2xsZXIuIFNlcGFyYXRlZCBkZXZpY2VzCmZvciBjbG9jayBwcm92 aWRlciBhbmQgY2xvY2sgY29uc3VtZXIgbWFrZSBEU0kgZHJpdmVyIGJldHRlciBmaXQgaW50bwpj b21tb24gY2xvY2sgZnJhbWV3b3JrLgoKU2lnbmVkLW9mZi1ieTogSGFpIExpIDxoYWxpQGNvZGVh dXJvcmEub3JnPgotLS0KIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9kcm0vbXNt L2RzaS50eHQgfCAgNTkgKysrLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vZHNpL2RzaS5jICAgICAg ICAgICAgICAgICAgICAgfCAgNDUgKysrLQogZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvZHNpLmgg ICAgICAgICAgICAgICAgICAgICB8ICAyNSArLQogZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvZHNp X2hvc3QuYyAgICAgICAgICAgICAgICB8ICAyNSArLQogZHJpdmVycy9ncHUvZHJtL21zbS9kc2kv ZHNpX3BoeS5jICAgICAgICAgICAgICAgICB8IDI2NiArKysrKysrKysrKysrKysrKystLS0tCiA1 IGZpbGVzIGNoYW5nZWQsIDMyNSBpbnNlcnRpb25zKCspLCA5NSBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvZHJtL21zbS9kc2kudHh0 IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2RybS9tc20vZHNpLnR4dAppbmRl eCBiM2NmMzI1Li4yYjE3MjgxIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUv YmluZGluZ3MvZHJtL21zbS9kc2kudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9i aW5kaW5ncy9kcm0vbXNtL2RzaS50eHQKQEAgLTEsMTUgKzEsMTIgQEAKIFF1YWxjb21tIFRlY2hu b2xvZ2llcyBJbmMuIGFkcmVuby9zbmFwZHJhZ29uIERTSSBvdXRwdXQKIAorRFNJIENvbnRyb2xs ZXI6CiBSZXF1aXJlZCBwcm9wZXJ0aWVzOgogLSBjb21wYXRpYmxlOgogICAqICJxY29tLG1kc3Mt ZHNpLWN0cmwiCi0tIHJlZzogUGh5c2ljYWwgYmFzZSBhZGRyZXNzIGFuZCBsZW5ndGggb2YgdGhl IHJlZ2lzdGVycyBvZiBjb250cm9sbGVyLCBQTEwsCi0gIFBIWSBhbmQgUEhZIHJlZ3VsYXRvcgor LSByZWc6IFBoeXNpY2FsIGJhc2UgYWRkcmVzcyBhbmQgbGVuZ3RoIG9mIHRoZSByZWdpc3RlcnMg b2YgY29udHJvbGxlcgogLSByZWctbmFtZXM6IFRoZSBuYW1lcyBvZiByZWdpc3RlciByZWdpb25z LiBUaGUgZm9sbG93aW5nIHJlZ2lvbnMgYXJlIHJlcXVpcmVkOgogICAqICJkc2lfY3RybCIKLSAg KiAiZHNpX3BsbCIKLSAgKiAiZHNpX3BoeSIKLSAgKiAiZHNpX3BoeV9yZWd1bGF0b3IiCiAtIHFj b20sZHNpLWhvc3QtaW5kZXg6IFRoZSBJRCBvZiBEU0kgY29udHJvbGxlciBoYXJkd2FyZSBpbnN0 YW5jZS4gVGhpcyBzaG91bGQKICAgYmUgMCBvciAxLCBzaW5jZSB3ZSBoYXZlIDIgRFNJIGNvbnRy b2xsZXJzIGF0IG1vc3QgZm9yIG5vdy4KIC0gaW50ZXJydXB0czogVGhlIGludGVycnVwdCBzaWdu YWwgZnJvbSB0aGUgRFNJIGJsb2NrLgpAQCAtMjQsMTAgKzIxLDEwIEBAIFJlcXVpcmVkIHByb3Bl cnRpZXM6CiAgICogImlmYWNlX2NsayIKICAgKiAibWRwX2NvcmVfY2xrIgogICAqICJwaXhlbF9j bGsiCi0tICNjbG9jay1jZWxsczogVGhlIHZhbHVlIHNob3VsZCBiZSAxLgogLSB2ZGQtc3VwcGx5 OiBwaGFuZGxlIHRvIHZkZCByZWd1bGF0b3IgZGV2aWNlIG5vZGUKIC0gdmRkaW8tc3VwcGx5OiBw aGFuZGxlIHRvIHZkZC1pbyByZWd1bGF0b3IgZGV2aWNlIG5vZGUKIC0gdmRkYS1zdXBwbHk6IHBo YW5kbGUgdG8gdmRkYSByZWd1bGF0b3IgZGV2aWNlIG5vZGUKKy0gcWNvbSxkc2ktcGh5OiBwaGFu ZGxlIHRvIERTSSBQSFkgZGV2aWNlIG5vZGUKIAogT3B0aW9uYWwgcHJvcGVydGllczoKIC0gcGFu ZWxAMDogTm9kZSBvZiBwYW5lbCBjb25uZWN0ZWQgdG8gdGhpcyBEU0kgY29udHJvbGxlci4KQEAg LTQyLDIyICszOSwzNCBAQCBPcHRpb25hbCBwcm9wZXJ0aWVzOgogLSBpbnRlcnJ1cHQtcGFyZW50 OiBwaGFuZGxlIHRvIHRoZSBNRFAgYmxvY2sgaWYgdGhlIGludGVycnVwdCBzaWduYWwgaXMgcm91 dGVkCiAgIHRocm91Z2ggTURQIGJsb2NrCiAKK0RTSSBQSFk6CitSZXF1aXJlZCBwcm9wZXJ0aWVz OgorLSBjb21wYXRpYmxlOiBDb3VsZCBiZSB0aGUgZm9sbG93aW5nCisgICogInFjb20sZHNpLXBo eS0yOG5tLWhwbSIKKyAgKiAicWNvbSxkc2ktcGh5LTI4bm0tbHAiCistIHJlZzogUGh5c2ljYWwg YmFzZSBhZGRyZXNzIGFuZCBsZW5ndGggb2YgdGhlIHJlZ2lzdGVycyBvZiBQTEwsIFBIWSBhbmQg UEhZCisgIHJlZ3VsYXRvcgorLSByZWctbmFtZXM6IFRoZSBuYW1lcyBvZiByZWdpc3RlciByZWdp b25zLiBUaGUgZm9sbG93aW5nIHJlZ2lvbnMgYXJlIHJlcXVpcmVkOgorICAqICJkc2lfcGxsIgor ICAqICJkc2lfcGh5IgorICAqICJkc2lfcGh5X3JlZ3VsYXRvciIKKy0gcWNvbSxkc2ktcGh5LWlu ZGV4OiBUaGUgSUQgb2YgRFNJIFBIWSBoYXJkd2FyZSBpbnN0YW5jZS4gVGhpcyBzaG91bGQKKyAg YmUgMCBvciAxLCBzaW5jZSB3ZSBoYXZlIDIgRFNJIFBIWXMgYXQgbW9zdCBmb3Igbm93LgorLSBw b3dlci1kb21haW5zOiBTaG91bGQgYmUgPCZtbWNjIE1EU1NfR0RTQz4uCistIGNsb2NrczogZGV2 aWNlIGNsb2NrcworICBTZWUgRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2Nsb2Nr cy9jbG9jay1iaW5kaW5ncy50eHQgZm9yIGRldGFpbHMuCistIGNsb2NrLW5hbWVzOiB0aGUgZm9s bG93aW5nIGNsb2NrcyBhcmUgcmVxdWlyZWQ6CisgICogImlmYWNlX2NsayIKKy0gdmRkaW8tc3Vw cGx5OiBwaGFuZGxlIHRvIHZkZC1pbyByZWd1bGF0b3IgZGV2aWNlIG5vZGUKKwogRXhhbXBsZToK IAltZHNzX2RzaTA6IHFjb20sbWRzc19kc2lAZmQ5MjI4MDAgewogCQljb21wYXRpYmxlID0gInFj b20sbWRzcy1kc2ktY3RybCI7CiAJCXFjb20sZHNpLWhvc3QtaW5kZXggPSA8MD47CiAJCWludGVy cnVwdC1wYXJlbnQgPSA8Jm1kc3NfbWRwPjsKIAkJaW50ZXJydXB0cyA9IDw0IDA+OwotCQlyZWct bmFtZXMgPQotCQkJImRzaV9jdHJsIiwKLQkJCSJkc2lfcGxsIiwKLQkJCSJkc2lfcGh5IiwKLQkJ CSJkc2lfcGh5X3JlZ3VsYXRvciIsCi0JCXJlZyA9CTwweGZkOTIyODAwIDB4MjAwPiwKLQkJCTww eGZkOTIyYTAwIDB4ZDQ+LAotCQkJPDB4ZmQ5MjJiMDAgMHgyYjA+LAotCQkJPDB4ZmQ5MjJkODAg MHg3Yj4sCi0JCQk8MHhmZDgyODAwMCAweDEwOD47CisJCXJlZy1uYW1lcyA9ICJkc2lfY3RybCI7 CisJCXJlZyA9IDwweGZkOTIyODAwIDB4MjAwPjsKIAkJcG93ZXItZG9tYWlucyA9IDwmbW1jYyBN RFNTX0dEU0M+OwogCQljbG9jay1uYW1lcyA9CiAJCQkiYnVzX2NsayIsCkBAIC03NSwxMSArODQs MTIgQEAgRXhhbXBsZToKIAkJCTwmbW1jYyBNRFNTX0FIQl9DTEs+LAogCQkJPCZtbWNjIE1EU1Nf TURQX0NMSz4sCiAJCQk8Jm1tY2MgTURTU19QQ0xLMF9DTEs+OwotCQkjY2xvY2stY2VsbHMgPSA8 MT47CiAJCXZkZGEtc3VwcGx5ID0gPCZwbWE4MDg0X2wyPjsKIAkJdmRkLXN1cHBseSA9IDwmcG1h ODA4NF9sMjI+OwogCQl2ZGRpby1zdXBwbHkgPSA8JnBtYTgwODRfbDEyPjsKIAorCQlxY29tLGRz aS1waHkgPSA8Jm1kc3NfZHNpX3BoeTA+OworCiAJCXFjb20sZHVhbC1wYW5lbC1tb2RlOwogCQlx Y29tLG1hc3Rlci1wYW5lbDsKIAkJcWNvbSxzeW5jLWR1YWwtcGFuZWw7CkBAIC05NCw0ICsxMDQs MTcgQEAgRXhhbXBsZToKIAkJfTsKIAl9OwogCi0KKwltZHNzX2RzaV9waHkwOiBxY29tLG1kc3Nf ZHNpX3BoeUBmZDkyMmEwMCB7CisJCWNvbXBhdGlibGUgPSAicWNvbSxkc2ktcGh5LTI4bm0taHBt IjsKKwkJcWNvbSxkc2ktcGh5LWluZGV4ID0gPDA+OworCQlyZWctbmFtZXMgPQorCQkJImRzaV9w bGwiLAorCQkJImRzaV9waHkiLAorCQkJImRzaV9waHlfcmVndWxhdG9yIjsKKwkJcmVnID0gICA8 MHhmZDkyMmEwMCAweGQ0PiwKKwkJCTwweGZkOTIyYjAwIDB4MmIwPiwKKwkJCTwweGZkOTIyZDgw IDB4N2I+OworCQljbG9jay1uYW1lcyA9ICJpZmFjZV9jbGsiOworCQljbG9ja3MgPSA8Jm1tY2Mg TURTU19BSEJfQ0xLPjsKKwkJdmRkaW8tc3VwcGx5ID0gPCZwbWE4MDg0X2wxMj47CisJfQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvZHNpLmMgYi9kcml2ZXJzL2dwdS9kcm0v bXNtL2RzaS9kc2kuYwppbmRleCBiZWIyNmRmLi4xZjI1NjFlIDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vbXNtL2RzaS9kc2kuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9kc2ku YwpAQCAtMjMsNiArMjMsMzQgQEAgc3RydWN0IGRybV9lbmNvZGVyICptc21fZHNpX2dldF9lbmNv ZGVyKHN0cnVjdCBtc21fZHNpICptc21fZHNpKQogCQltc21fZHNpLT5lbmNvZGVyc1tNU01fRFNJ X0NNRF9FTkNPREVSX0lEXTsKIH0KIAorc3RhdGljIGludCBkc2lfZ2V0X3BoeShzdHJ1Y3QgbXNt X2RzaSAqbXNtX2RzaSkKK3sKKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2ID0gbXNtX2Rz aS0+cGRldjsKKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwaHlfcGRldjsKKwlzdHJ1Y3QgZGV2 aWNlX25vZGUgKnBoeV9ub2RlOworCisJcGh5X25vZGUgPSBvZl9wYXJzZV9waGFuZGxlKHBkZXYt PmRldi5vZl9ub2RlLCAicWNvbSxkc2ktcGh5IiwgMCk7CisJaWYgKCFwaHlfbm9kZSkgeworCQlk ZXZfZXJyKCZwZGV2LT5kZXYsICJjYW5ub3QgZmluZCBwaHkgZGV2aWNlXG4iKTsKKwkJcmV0dXJu IC1FTlhJTzsKKwl9CisKKwlwaHlfcGRldiA9IG9mX2ZpbmRfZGV2aWNlX2J5X25vZGUocGh5X25v ZGUpOworCWlmIChwaHlfcGRldikKKwkJbXNtX2RzaS0+cGh5ID0gcGxhdGZvcm1fZ2V0X2RydmRh dGEocGh5X3BkZXYpOworCisJb2Zfbm9kZV9wdXQocGh5X25vZGUpOworCisJaWYgKCFwaHlfcGRl diB8fCAhbXNtX2RzaS0+cGh5KSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgIiVzOiBwaHkgZHJp dmVyIGlzIG5vdCByZWFkeVxuIiwgX19mdW5jX18pOworCQlyZXR1cm4gLUVQUk9CRV9ERUZFUjsK Kwl9CisKKwltc21fZHNpLT5waHlfZGV2ID0gZ2V0X2RldmljZSgmcGh5X3BkZXYtPmRldik7CisK KwlyZXR1cm4gMDsKK30KKwogc3RhdGljIHZvaWQgZHNpX2Rlc3Ryb3koc3RydWN0IG1zbV9kc2kg Km1zbV9kc2kpCiB7CiAJaWYgKCFtc21fZHNpKQpAQCAtMzAsOSArNTgsMTAgQEAgc3RhdGljIHZv aWQgZHNpX2Rlc3Ryb3koc3RydWN0IG1zbV9kc2kgKm1zbV9kc2kpCiAKIAltc21fZHNpX21hbmFn ZXJfdW5yZWdpc3Rlcihtc21fZHNpKTsKIAotCWlmIChtc21fZHNpLT5waHkpIHsKLQkJbXNtX2Rz aV9waHlfZGVzdHJveShtc21fZHNpLT5waHkpOworCWlmIChtc21fZHNpLT5waHlfZGV2KSB7CisJ CXB1dF9kZXZpY2UobXNtX2RzaS0+cGh5X2Rldik7CiAJCW1zbV9kc2ktPnBoeSA9IE5VTEw7CisJ CW1zbV9kc2ktPnBoeV9kZXYgPSBOVUxMOwogCX0KIAogCWlmIChtc21fZHNpLT5ob3N0KSB7CkBA IC00OSw3ICs3OCw2IEBAIHN0YXRpYyBzdHJ1Y3QgbXNtX2RzaSAqZHNpX2luaXQoc3RydWN0IHBs YXRmb3JtX2RldmljZSAqcGRldikKIAlpbnQgcmV0OwogCiAJaWYgKCFwZGV2KSB7Ci0JCWRldl9l cnIoJnBkZXYtPmRldiwgIm5vIGRzaSBkZXZpY2VcbiIpOwogCQlyZXQgPSAtRU5YSU87CiAJCWdv dG8gZmFpbDsKIAl9CkBAIC02OSwxMyArOTcsMTAgQEAgc3RhdGljIHN0cnVjdCBtc21fZHNpICpk c2lfaW5pdChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCWlmIChyZXQpCiAJCWdvdG8g ZmFpbDsKIAotCS8qIEluaXQgZHNpIFBIWSAqLwotCW1zbV9kc2ktPnBoeSA9IG1zbV9kc2lfcGh5 X2luaXQocGRldiwgbXNtX2RzaS0+cGh5X3R5cGUsIG1zbV9kc2ktPmlkKTsKLQlpZiAoIW1zbV9k c2ktPnBoeSkgewotCQlyZXQgPSAtRU5YSU87Ci0JCXByX2VycigiJXM6IHBoeSBpbml0IGZhaWxl ZFxuIiwgX19mdW5jX18pOworCS8qIEdFVCBkc2kgUEhZICovCisJcmV0ID0gZHNpX2dldF9waHko bXNtX2RzaSk7CisJaWYgKHJldCkKIAkJZ290byBmYWlsOwotCX0KIAogCS8qIFJlZ2lzdGVyIHRv IGRzaSBtYW5hZ2VyICovCiAJcmV0ID0gbXNtX2RzaV9tYW5hZ2VyX3JlZ2lzdGVyKG1zbV9kc2kp OwpAQCAtMTU2LDEyICsxODEsMTQgQEAgc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgZHNp X2RyaXZlciA9IHsKIHZvaWQgX19pbml0IG1zbV9kc2lfcmVnaXN0ZXIodm9pZCkKIHsKIAlEQkco IiIpOworCW1zbV9kc2lfcGh5X2RyaXZlcl9yZWdpc3RlcigpOwogCXBsYXRmb3JtX2RyaXZlcl9y ZWdpc3RlcigmZHNpX2RyaXZlcik7CiB9CiAKIHZvaWQgX19leGl0IG1zbV9kc2lfdW5yZWdpc3Rl cih2b2lkKQogewogCURCRygiIik7CisJbXNtX2RzaV9waHlfZHJpdmVyX3VucmVnaXN0ZXIoKTsK IAlwbGF0Zm9ybV9kcml2ZXJfdW5yZWdpc3RlcigmZHNpX2RyaXZlcik7CiB9CiAKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZHNpL2RzaS5oIGIvZHJpdmVycy9ncHUvZHJtL21zbS9k c2kvZHNpLmgKaW5kZXggODAyMjgxNC4uOTJkNjk3ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUv ZHJtL21zbS9kc2kvZHNpLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvZHNpLmgKQEAg LTE0LDYgKzE0LDcgQEAKICNpZm5kZWYgX19EU0lfQ09OTkVDVE9SX0hfXwogI2RlZmluZSBfX0RT SV9DT05ORUNUT1JfSF9fCiAKKyNpbmNsdWRlIDxsaW51eC9vZl9wbGF0Zm9ybS5oPgogI2luY2x1 ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgogCiAjaW5jbHVkZSAiZHJtX2NydGMuaCIKQEAg LTM5LDEyICs0MCwyNyBAQAogI2RlZmluZSBEU0lfRU5DT0RFUl9TTEFWRQlEU0lfMAogCiBlbnVt IG1zbV9kc2lfcGh5X3R5cGUgewotCU1TTV9EU0lfUEhZX1VOS05PV04sCiAJTVNNX0RTSV9QSFlf MjhOTV9IUE0sCiAJTVNNX0RTSV9QSFlfMjhOTV9MUCwKIAlNU01fRFNJX1BIWV9NQVgKIH07CiAK KyNkZWZpbmUgRFNJX0RFVl9SRUdVTEFUT1JfTUFYCTgKKworLyogUmVndWxhdG9ycyBmb3IgRFNJ IGRldmljZXMgKi8KK3N0cnVjdCBkc2lfcmVnX2VudHJ5IHsKKwljaGFyIG5hbWVbMzJdOworCWlu dCBtaW5fdm9sdGFnZTsKKwlpbnQgbWF4X3ZvbHRhZ2U7CisJaW50IGVuYWJsZV9sb2FkOworCWlu dCBkaXNhYmxlX2xvYWQ7Cit9OworCitzdHJ1Y3QgZHNpX3JlZ19jb25maWcgeworCWludCBudW07 CisJc3RydWN0IGRzaV9yZWdfZW50cnkgcmVnc1tEU0lfREVWX1JFR1VMQVRPUl9NQVhdOworfTsK Kwogc3RydWN0IG1zbV9kc2kgewogCXN0cnVjdCBkcm1fZGV2aWNlICpkZXY7CiAJc3RydWN0IHBs YXRmb3JtX2RldmljZSAqcGRldjsKQEAgLTU3LDcgKzczLDcgQEAgc3RydWN0IG1zbV9kc2kgewog CXN0cnVjdCBkcm1fcGFuZWwgKnBhbmVsOwogCXVuc2lnbmVkIGxvbmcgcGFuZWxfZmxhZ3M7CiAK LQllbnVtIG1zbV9kc2lfcGh5X3R5cGUgcGh5X3R5cGU7CisJc3RydWN0IGRldmljZSAqcGh5X2Rl djsKIAlib29sIHBoeV9lbmFibGVkOwogCiAJLyogdGhlIGVuY29kZXJzIHdlIGFyZSBob29rZWQg dG8gKG91dHNpZGUgb2YgZHNpIGJsb2NrKSAqLwpAQCAtMTM1LDkgKzE1MSw4IEBAIGludCBtc21f ZHNpX2hvc3RfaW5pdChzdHJ1Y3QgbXNtX2RzaSAqbXNtX2RzaSk7CiAKIC8qIGRzaSBwaHkgKi8K IHN0cnVjdCBtc21fZHNpX3BoeTsKLXN0cnVjdCBtc21fZHNpX3BoeSAqbXNtX2RzaV9waHlfaW5p dChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LAotCQkJZW51bSBtc21fZHNpX3BoeV90eXBl IHR5cGUsIGludCBpZCk7Ci12b2lkIG1zbV9kc2lfcGh5X2Rlc3Ryb3koc3RydWN0IG1zbV9kc2lf cGh5ICpwaHkpOwordm9pZCBtc21fZHNpX3BoeV9kcml2ZXJfcmVnaXN0ZXIodm9pZCk7Cit2b2lk IG1zbV9kc2lfcGh5X2RyaXZlcl91bnJlZ2lzdGVyKHZvaWQpOwogaW50IG1zbV9kc2lfcGh5X2Vu YWJsZShzdHJ1Y3QgbXNtX2RzaV9waHkgKnBoeSwgYm9vbCBpc19kdWFsX3BhbmVsLAogCWNvbnN0 IHVuc2lnbmVkIGxvbmcgYml0X3JhdGUsIGNvbnN0IHVuc2lnbmVkIGxvbmcgZXNjX3JhdGUpOwog aW50IG1zbV9kc2lfcGh5X2Rpc2FibGUoc3RydWN0IG1zbV9kc2lfcGh5ICpwaHkpOwpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvZHNpX2hvc3QuYyBiL2RyaXZlcnMvZ3B1L2Ry bS9tc20vZHNpL2RzaV9ob3N0LmMKaW5kZXggMWNmOWYxMS4uNTllNTI0YiAxMDA2NDQKLS0tIGEv ZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvZHNpX2hvc3QuYworKysgYi9kcml2ZXJzL2dwdS9kcm0v bXNtL2RzaS9kc2lfaG9zdC5jCkBAIC0zNiwzNSArMzYsMTkgQEAKIAogI2RlZmluZSBEU0lfNkdf UkVHX1NISUZUCTQKIAotI2RlZmluZSBEU0lfUkVHVUxBVE9SX01BWAk4Ci1zdHJ1Y3QgZHNpX3Jl Z19lbnRyeSB7Ci0JY2hhciBuYW1lWzMyXTsKLQlpbnQgbWluX3ZvbHRhZ2U7Ci0JaW50IG1heF92 b2x0YWdlOwotCWludCBlbmFibGVfbG9hZDsKLQlpbnQgZGlzYWJsZV9sb2FkOwotfTsKLQotc3Ry dWN0IGRzaV9yZWdfY29uZmlnIHsKLQlpbnQgbnVtOwotCXN0cnVjdCBkc2lfcmVnX2VudHJ5IHJl Z3NbRFNJX1JFR1VMQVRPUl9NQVhdOwotfTsKLQogc3RydWN0IGRzaV9jb25maWcgewogCXUzMiBt YWpvcjsKIAl1MzIgbWlub3I7CiAJdTMyIGlvX29mZnNldDsKLQllbnVtIG1zbV9kc2lfcGh5X3R5 cGUgcGh5X3R5cGU7CiAJc3RydWN0IGRzaV9yZWdfY29uZmlnIHJlZ19jZmc7CiB9OwogCiBzdGF0 aWMgY29uc3Qgc3RydWN0IGRzaV9jb25maWcgZHNpX2NmZ3NbXSA9IHsKLQl7TVNNX0RTSV9WRVJf TUFKT1JfVjIsIDAsIDAsIE1TTV9EU0lfUEhZX1VOS05PV059LAorCXtNU01fRFNJX1ZFUl9NQUpP Ul9WMiwgMCwgMCwgezAsfSB9LAogCXsgLyogODk3NCB2MSAqLwogCQkubWFqb3IgPSBNU01fRFNJ X1ZFUl9NQUpPUl82RywKIAkJLm1pbm9yID0gTVNNX0RTSV82R19WRVJfTUlOT1JfVjFfMCwKIAkJ LmlvX29mZnNldCA9IERTSV82R19SRUdfU0hJRlQsCi0JCS5waHlfdHlwZSA9IE1TTV9EU0lfUEhZ XzI4Tk1fSFBNLAogCQkucmVnX2NmZyA9IHsKIAkJCS5udW0gPSA0LAogCQkJLnJlZ3MgPSB7CkBA IC03OSw3ICs2Myw2IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHNpX2NvbmZpZyBkc2lfY2Znc1td ID0gewogCQkubWFqb3IgPSBNU01fRFNJX1ZFUl9NQUpPUl82RywKIAkJLm1pbm9yID0gTVNNX0RT SV82R19WRVJfTUlOT1JfVjFfMSwKIAkJLmlvX29mZnNldCA9IERTSV82R19SRUdfU0hJRlQsCi0J CS5waHlfdHlwZSA9IE1TTV9EU0lfUEhZXzI4Tk1fSFBNLAogCQkucmVnX2NmZyA9IHsKIAkJCS5u dW0gPSA0LAogCQkJLnJlZ3MgPSB7CkBAIC05NCw3ICs3Nyw2IEBAIHN0YXRpYyBjb25zdCBzdHJ1 Y3QgZHNpX2NvbmZpZyBkc2lfY2Znc1tdID0gewogCQkubWFqb3IgPSBNU01fRFNJX1ZFUl9NQUpP Ul82RywKIAkJLm1pbm9yID0gTVNNX0RTSV82R19WRVJfTUlOT1JfVjFfMV8xLAogCQkuaW9fb2Zm c2V0ID0gRFNJXzZHX1JFR19TSElGVCwKLQkJLnBoeV90eXBlID0gTVNNX0RTSV9QSFlfMjhOTV9I UE0sCiAJCS5yZWdfY2ZnID0gewogCQkJLm51bSA9IDQsCiAJCQkucmVncyA9IHsKQEAgLTEwOSw3 ICs5MSw2IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHNpX2NvbmZpZyBkc2lfY2Znc1tdID0gewog CQkubWFqb3IgPSBNU01fRFNJX1ZFUl9NQUpPUl82RywKIAkJLm1pbm9yID0gTVNNX0RTSV82R19W RVJfTUlOT1JfVjFfMiwKIAkJLmlvX29mZnNldCA9IERTSV82R19SRUdfU0hJRlQsCi0JCS5waHlf dHlwZSA9IE1TTV9EU0lfUEhZXzI4Tk1fSFBNLAogCQkucmVnX2NmZyA9IHsKIAkJCS5udW0gPSA0 LAogCQkJLnJlZ3MgPSB7CkBAIC0xMjQsNyArMTA1LDYgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBk c2lfY29uZmlnIGRzaV9jZmdzW10gPSB7CiAJCS5tYWpvciA9IE1TTV9EU0lfVkVSX01BSk9SXzZH LAogCQkubWlub3IgPSBNU01fRFNJXzZHX1ZFUl9NSU5PUl9WMV8zXzEsCiAJCS5pb19vZmZzZXQg PSBEU0lfNkdfUkVHX1NISUZULAotCQkucGh5X3R5cGUgPSBNU01fRFNJX1BIWV8yOE5NX0xQLAog CQkucmVnX2NmZyA9IHsKIAkJCS5udW0gPSA0LAogCQkJLnJlZ3MgPSB7CkBAIC0xOTcsNyArMTc3 LDcgQEAgc3RydWN0IG1zbV9kc2lfaG9zdCB7CiAJaW50IGlkOwogCiAJdm9pZCBfX2lvbWVtICpj dHJsX2Jhc2U7Ci0Jc3RydWN0IHJlZ3VsYXRvcl9idWxrX2RhdGEgc3VwcGxpZXNbRFNJX1JFR1VM QVRPUl9NQVhdOworCXN0cnVjdCByZWd1bGF0b3JfYnVsa19kYXRhIHN1cHBsaWVzW0RTSV9ERVZf UkVHVUxBVE9SX01BWF07CiAJc3RydWN0IGNsayAqbWRwX2NvcmVfY2xrOwogCXN0cnVjdCBjbGsg KmFoYl9jbGs7CiAJc3RydWN0IGNsayAqYXhpX2NsazsKQEAgLTE1MjksNyArMTUwOSw2IEBAIGlu dCBtc21fZHNpX2hvc3RfaW5pdChzdHJ1Y3QgbXNtX2RzaSAqbXNtX2RzaSkKIAogCW1zbV9kc2kt Pmhvc3QgPSAmbXNtX2hvc3QtPmJhc2U7CiAJbXNtX2RzaS0+aWQgPSBtc21faG9zdC0+aWQ7Ci0J bXNtX2RzaS0+cGh5X3R5cGUgPSBtc21faG9zdC0+Y2ZnLT5waHlfdHlwZTsKIAogCURCRygiRHNp IEhvc3QgJWQgaW5pdGlhbGl6ZWQiLCBtc21faG9zdC0+aWQpOwogCXJldHVybiAwOwpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvZHNpX3BoeS5jIGIvZHJpdmVycy9ncHUvZHJt L21zbS9kc2kvZHNpX3BoeS5jCmluZGV4IGUzMTNlNTIuLjNkOWQxMzAgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9tc20vZHNpL2RzaV9waHkuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNt L2RzaS9kc2lfcGh5LmMKQEAgLTExLDEyICsxMSwyNyBAQAogICogR05VIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICAqLwogCisjaW5jbHVkZSA8bGludXgvcGxhdGZv cm1fZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvcmVndWxhdG9yL2NvbnN1bWVyLmg+CisKICNp bmNsdWRlICJkc2kuaCIKICNpbmNsdWRlICJkc2kueG1sLmgiCiAKICNkZWZpbmUgZHNpX3BoeV9y ZWFkKG9mZnNldCkgbXNtX3JlYWRsKChvZmZzZXQpKQogI2RlZmluZSBkc2lfcGh5X3dyaXRlKG9m ZnNldCwgZGF0YSkgbXNtX3dyaXRlbCgoZGF0YSksIChvZmZzZXQpKQogCitzdHJ1Y3QgZHNpX3Bo eV9vcHMgeworCWludCAoKmVuYWJsZSkoc3RydWN0IG1zbV9kc2lfcGh5ICpwaHksIGJvb2wgaXNf ZHVhbF9wYW5lbCwKKwkJY29uc3QgdW5zaWduZWQgbG9uZyBiaXRfcmF0ZSwgY29uc3QgdW5zaWdu ZWQgbG9uZyBlc2NfcmF0ZSk7CisJaW50ICgqZGlzYWJsZSkoc3RydWN0IG1zbV9kc2lfcGh5ICpw aHkpOworfTsKKworc3RydWN0IGRzaV9waHlfY2ZnIHsKKwllbnVtIG1zbV9kc2lfcGh5X3R5cGUg dHlwZTsKKwlzdHJ1Y3QgZHNpX3JlZ19jb25maWcgcmVnX2NmZzsKKwlzdHJ1Y3QgZHNpX3BoeV9v cHMgb3BzOworfTsKKwogc3RydWN0IGRzaV9kcGh5X3RpbWluZyB7CiAJdTMyIGNsa19wcmU7CiAJ dTMyIGNsa19wb3N0OwpAQCAtNDAsMTcgKzU1LDEwMCBAQCBzdHJ1Y3QgbXNtX2RzaV9waHkgewog CWludCBpZDsKIAogCXN0cnVjdCBjbGsgKmFoYl9jbGs7CisJc3RydWN0IHJlZ3VsYXRvcl9idWxr X2RhdGEgc3VwcGxpZXNbRFNJX0RFVl9SRUdVTEFUT1JfTUFYXTsKIAogCXN0cnVjdCBkc2lfZHBo eV90aW1pbmcgdGltaW5nOwotCWVudW0gbXNtX2RzaV9waHlfdHlwZSB0eXBlOworCWNvbnN0IHN0 cnVjdCBkc2lfcGh5X2NmZyAqY2ZnOwogCiAJc3RydWN0IG1zbV9kc2lfcGxsICpwbGw7Ci0KLQlp bnQgKCplbmFibGUpKHN0cnVjdCBtc21fZHNpX3BoeSAqcGh5LCBib29sIGlzX2R1YWxfcGFuZWws Ci0JCWNvbnN0IHVuc2lnbmVkIGxvbmcgYml0X3JhdGUsIGNvbnN0IHVuc2lnbmVkIGxvbmcgZXNj X3JhdGUpOwotCWludCAoKmRpc2FibGUpKHN0cnVjdCBtc21fZHNpX3BoeSAqcGh5KTsKIH07CiAK K3N0YXRpYyBpbnQgZHNpX3BoeV9yZWd1bGF0b3JfaW5pdChzdHJ1Y3QgbXNtX2RzaV9waHkgKnBo eSkKK3sKKwlzdHJ1Y3QgcmVndWxhdG9yX2J1bGtfZGF0YSAqcyA9IHBoeS0+c3VwcGxpZXM7CisJ Y29uc3Qgc3RydWN0IGRzaV9yZWdfZW50cnkgKnJlZ3MgPSBwaHktPmNmZy0+cmVnX2NmZy5yZWdz OworCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZwaHktPnBkZXYtPmRldjsKKwlpbnQgbnVtID0gcGh5 LT5jZmctPnJlZ19jZmcubnVtOworCWludCBpLCByZXQ7CisKKwlmb3IgKGkgPSAwOyBpIDwgbnVt OyBpKyspCisJCXNbaV0uc3VwcGx5ID0gcmVnc1tpXS5uYW1lOworCisJcmV0ID0gZGV2bV9yZWd1 bGF0b3JfYnVsa19nZXQoJnBoeS0+cGRldi0+ZGV2LCBudW0sIHMpOworCWlmIChyZXQgPCAwKSB7 CisJCWRldl9lcnIoZGV2LCAiJXM6IGZhaWxlZCB0byBpbml0IHJlZ3VsYXRvciwgcmV0PSVkXG4i LAorCQkJCQkJX19mdW5jX18sIHJldCk7CisJCXJldHVybiByZXQ7CisJfQorCisJZm9yIChpID0g MDsgaSA8IG51bTsgaSsrKSB7CisJCWlmICgocmVnc1tpXS5taW5fdm9sdGFnZSA+PSAwKSAmJiAo cmVnc1tpXS5tYXhfdm9sdGFnZSA+PSAwKSkgeworCQkJcmV0ID0gcmVndWxhdG9yX3NldF92b2x0 YWdlKHNbaV0uY29uc3VtZXIsCisJCQkJcmVnc1tpXS5taW5fdm9sdGFnZSwgcmVnc1tpXS5tYXhf dm9sdGFnZSk7CisJCQlpZiAocmV0IDwgMCkgeworCQkJCWRldl9lcnIoZGV2LAorCQkJCQkicmVn dWxhdG9yICVkIHNldCB2b2x0YWdlIGZhaWxlZCwgJWRcbiIsCisJCQkJCWksIHJldCk7CisJCQkJ cmV0dXJuIHJldDsKKwkJCX0KKwkJfQorCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9p ZCBkc2lfcGh5X3JlZ3VsYXRvcl9kaXNhYmxlKHN0cnVjdCBtc21fZHNpX3BoeSAqcGh5KQorewor CXN0cnVjdCByZWd1bGF0b3JfYnVsa19kYXRhICpzID0gcGh5LT5zdXBwbGllczsKKwljb25zdCBz dHJ1Y3QgZHNpX3JlZ19lbnRyeSAqcmVncyA9IHBoeS0+Y2ZnLT5yZWdfY2ZnLnJlZ3M7CisJaW50 IG51bSA9IHBoeS0+Y2ZnLT5yZWdfY2ZnLm51bTsKKwlpbnQgaTsKKworCURCRygiIik7CisJZm9y IChpID0gbnVtIC0gMTsgaSA+PSAwOyBpLS0pCisJCWlmIChyZWdzW2ldLmRpc2FibGVfbG9hZCA+ PSAwKQorCQkJcmVndWxhdG9yX3NldF9sb2FkKHNbaV0uY29uc3VtZXIsCisJCQkJCQlyZWdzW2ld LmRpc2FibGVfbG9hZCk7CisKKwlyZWd1bGF0b3JfYnVsa19kaXNhYmxlKG51bSwgcyk7Cit9CisK K3N0YXRpYyBpbnQgZHNpX3BoeV9yZWd1bGF0b3JfZW5hYmxlKHN0cnVjdCBtc21fZHNpX3BoeSAq cGh5KQoreworCXN0cnVjdCByZWd1bGF0b3JfYnVsa19kYXRhICpzID0gcGh5LT5zdXBwbGllczsK Kwljb25zdCBzdHJ1Y3QgZHNpX3JlZ19lbnRyeSAqcmVncyA9IHBoeS0+Y2ZnLT5yZWdfY2ZnLnJl Z3M7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJnBoeS0+cGRldi0+ZGV2OworCWludCBudW0gPSBw aHktPmNmZy0+cmVnX2NmZy5udW07CisJaW50IHJldCwgaTsKKworCURCRygiIik7CisJZm9yIChp ID0gMDsgaSA8IG51bTsgaSsrKSB7CisJCWlmIChyZWdzW2ldLmVuYWJsZV9sb2FkID49IDApIHsK KwkJCXJldCA9IHJlZ3VsYXRvcl9zZXRfbG9hZChzW2ldLmNvbnN1bWVyLAorCQkJCQkJCXJlZ3Nb aV0uZW5hYmxlX2xvYWQpOworCQkJaWYgKHJldCA8IDApIHsKKwkJCQlkZXZfZXJyKGRldiwKKwkJ CQkJInJlZ3VsYXRvciAlZCBzZXQgb3AgbW9kZSBmYWlsZWQsICVkXG4iLAorCQkJCQlpLCByZXQp OworCQkJCWdvdG8gZmFpbDsKKwkJCX0KKwkJfQorCX0KKworCXJldCA9IHJlZ3VsYXRvcl9idWxr X2VuYWJsZShudW0sIHMpOworCWlmIChyZXQgPCAwKSB7CisJCWRldl9lcnIoZGV2LCAicmVndWxh dG9yIGVuYWJsZSBmYWlsZWQsICVkXG4iLCByZXQpOworCQlnb3RvIGZhaWw7CisJfQorCisJcmV0 dXJuIDA7CisKK2ZhaWw6CisJZm9yIChpLS07IGkgPj0gMDsgaS0tKQorCQlyZWd1bGF0b3Jfc2V0 X2xvYWQoc1tpXS5jb25zdW1lciwgcmVnc1tpXS5kaXNhYmxlX2xvYWQpOworCXJldHVybiByZXQ7 Cit9CisKICNkZWZpbmUgU19ESVZfUk9VTkRfVVAobiwgZCkJXAogCSgoKG4pID49IDApID8gKCgo bikgKyAoZCkgLSAxKSAvIChkKSkgOiAoKChuKSAtIChkKSArIDEpIC8gKGQpKSkKIApAQCAtMzEz LDUxICs0MTEsOTQgQEAgc3RhdGljIHZvaWQgZHNpX3BoeV9kaXNhYmxlX3Jlc291cmNlKHN0cnVj dCBtc21fZHNpX3BoeSAqcGh5KQogCXBtX3J1bnRpbWVfcHV0X3N5bmMoJnBoeS0+cGRldi0+ZGV2 KTsKIH0KIAotI2RlZmluZSBkc2lfcGh5X2Z1bmNfaW5pdChuYW1lKQlcCi0JZG8gewlcCi0JCXBo eS0+ZW5hYmxlID0gZHNpXyMjbmFtZSMjX3BoeV9lbmFibGU7CVwKLQkJcGh5LT5kaXNhYmxlID0g ZHNpXyMjbmFtZSMjX3BoeV9kaXNhYmxlOwlcCi0JfSB3aGlsZSAoMCkKK3N0YXRpYyBjb25zdCBz dHJ1Y3QgZHNpX3BoeV9jZmcgZHNpX3BoeV9jZmdzW01TTV9EU0lfUEhZX01BWF0gPSB7CisJW01T TV9EU0lfUEhZXzI4Tk1fSFBNXSA9IHsKKwkJLnR5cGUgPSBNU01fRFNJX1BIWV8yOE5NX0hQTSwK KwkJLnJlZ19jZmcgPSB7CisJCQkubnVtID0gMSwKKwkJCS5yZWdzID0geworCQkJCXsidmRkaW8i LCAxODAwMDAwLCAxODAwMDAwLCAxMDAwMDAsIDEwMH0sCisJCQl9LAorCQl9LAorCQkub3BzID0g eworCQkJLmVuYWJsZSA9IGRzaV8yOG5tX3BoeV9lbmFibGUsCisJCQkuZGlzYWJsZSA9IGRzaV8y OG5tX3BoeV9kaXNhYmxlLAorCQl9CisJfSwKKwlbTVNNX0RTSV9QSFlfMjhOTV9MUF0gPSB7CisJ CS50eXBlID0gTVNNX0RTSV9QSFlfMjhOTV9MUCwKKwkJLnJlZ19jZmcgPSB7CisJCQkubnVtID0g MSwKKwkJCS5yZWdzID0geworCQkJCXsidmRkaW8iLCAxODAwMDAwLCAxODAwMDAwLCAxMDAwMDAs IDEwMH0sCisJCQl9LAorCQl9LAorCQkub3BzID0geworCQkJLmVuYWJsZSA9IGRzaV8yOG5tX3Bo eV9lbmFibGUsCisJCQkuZGlzYWJsZSA9IGRzaV8yOG5tX3BoeV9kaXNhYmxlLAorCQl9CisJfSwK K307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIGRzaV9waHlfZHRfbWF0Y2hb XSA9IHsKKwl7IC5jb21wYXRpYmxlID0gInFjb20sZHNpLXBoeS0yOG5tLWhwbSIsCisJICAuZGF0 YSA9ICZkc2lfcGh5X2NmZ3NbTVNNX0RTSV9QSFlfMjhOTV9IUE1dLH0sCisJeyAuY29tcGF0aWJs ZSA9ICJxY29tLGRzaS1waHktMjhubS1scCIsCisJICAuZGF0YSA9ICZkc2lfcGh5X2NmZ3NbTVNN X0RTSV9QSFlfMjhOTV9MUF0sfSwKKwl7fQorfTsKIAotc3RydWN0IG1zbV9kc2lfcGh5ICptc21f ZHNpX3BoeV9pbml0KHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsCi0JCQllbnVtIG1zbV9k c2lfcGh5X3R5cGUgdHlwZSwgaW50IGlkKQorc3RhdGljIGludCBkc2lfcGh5X2RyaXZlcl9wcm9i ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogewogCXN0cnVjdCBtc21fZHNpX3BoeSAq cGh5OworCWNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgKm1hdGNoOwogCWludCByZXQ7CiAKIAlw aHkgPSBkZXZtX2t6YWxsb2MoJnBkZXYtPmRldiwgc2l6ZW9mKCpwaHkpLCBHRlBfS0VSTkVMKTsK IAlpZiAoIXBoeSkKLQkJcmV0dXJuIE5VTEw7CisJCXJldHVybiAtRU5PTUVNOworCisJbWF0Y2gg PSBvZl9tYXRjaF9ub2RlKGRzaV9waHlfZHRfbWF0Y2gsIHBkZXYtPmRldi5vZl9ub2RlKTsKKwlp ZiAoIW1hdGNoKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCXBoeS0+Y2ZnID0gbWF0Y2gtPmRhdGE7 CisJcGh5LT5wZGV2ID0gcGRldjsKKworCXJldCA9IG9mX3Byb3BlcnR5X3JlYWRfdTMyKHBkZXYt PmRldi5vZl9ub2RlLAorCQkJCSJxY29tLGRzaS1waHktaW5kZXgiLCAmcGh5LT5pZCk7CisJaWYg KHJldCkgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsCisJCQkiJXM6IFBIWSBpbmRleCBub3Qgc3Bl Y2lmaWVkLCByZXQ9JWRcbiIsCisJCQlfX2Z1bmNfXywgcmV0KTsKKwkJZ290byBmYWlsOworCX0K IAogCXBoeS0+YmFzZSA9IG1zbV9pb3JlbWFwKHBkZXYsICJkc2lfcGh5IiwgIkRTSV9QSFkiKTsK IAlpZiAoSVNfRVJSX09SX05VTEwocGh5LT5iYXNlKSkgewotCQlwcl9lcnIoIiVzOiBmYWlsZWQg dG8gbWFwIHBoeSBiYXNlXG4iLCBfX2Z1bmNfXyk7Ci0JCXJldHVybiBOVUxMOworCQlkZXZfZXJy KCZwZGV2LT5kZXYsICIlczogZmFpbGVkIHRvIG1hcCBwaHkgYmFzZVxuIiwgX19mdW5jX18pOwor CQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIGZhaWw7CiAJfQogCXBoeS0+cmVnX2Jhc2UgPSBtc21f aW9yZW1hcChwZGV2LCAiZHNpX3BoeV9yZWd1bGF0b3IiLCAiRFNJX1BIWV9SRUciKTsKIAlpZiAo SVNfRVJSX09SX05VTEwocGh5LT5yZWdfYmFzZSkpIHsKLQkJcHJfZXJyKCIlczogZmFpbGVkIHRv IG1hcCBwaHkgcmVndWxhdG9yIGJhc2VcbiIsIF9fZnVuY19fKTsKLQkJcmV0dXJuIE5VTEw7CisJ CWRldl9lcnIoJnBkZXYtPmRldiwKKwkJCSIlczogZmFpbGVkIHRvIG1hcCBwaHkgcmVndWxhdG9y IGJhc2VcbiIsIF9fZnVuY19fKTsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBmYWlsOwogCX0K IAotCXN3aXRjaCAodHlwZSkgewotCWNhc2UgTVNNX0RTSV9QSFlfMjhOTV9IUE06Ci0JY2FzZSBN U01fRFNJX1BIWV8yOE5NX0xQOgotCQlkc2lfcGh5X2Z1bmNfaW5pdCgyOG5tKTsKLQkJYnJlYWs7 Ci0JZGVmYXVsdDoKLQkJcHJfZXJyKCIlczogdW5zdXBwb3J0ZWQgdHlwZSwgJWRcbiIsIF9fZnVu Y19fLCB0eXBlKTsKLQkJcmV0dXJuIE5VTEw7CisJcmV0ID0gZHNpX3BoeV9yZWd1bGF0b3JfaW5p dChwaHkpOworCWlmIChyZXQpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiJXM6IGZhaWxlZCB0 byBpbml0IHJlZ3VsYXRvclxuIiwgX19mdW5jX18pOworCQlnb3RvIGZhaWw7CiAJfQogCi0JcGh5 LT50eXBlID0gdHlwZTsKLQlwaHktPmlkID0gaWQ7Ci0JcGh5LT5wZGV2ID0gcGRldjsKLQogCXBo eS0+YWhiX2NsayA9IGRldm1fY2xrX2dldCgmcGRldi0+ZGV2LCAiaWZhY2VfY2xrIik7CiAJaWYg KElTX0VSUihwaHktPmFoYl9jbGspKSB7CiAJCXByX2VycigiJXM6IFVuYWJsZSB0byBnZXQgYWhi IGNsa1xuIiwgX19mdW5jX18pOwotCQlyZXR1cm4gTlVMTDsKKwkJcmV0ID0gUFRSX0VSUihwaHkt PmFoYl9jbGspOworCQlnb3RvIGZhaWw7CiAJfQogCiAJLyogUExMIGluaXQgd2lsbCBjYWxsIGlu dG8gY2xrX3JlZ2lzdGVyIHdoaWNoIHJlcXVpcmVzCkBAIC0zNjUsMzkgKzUwNiw4NCBAQCBzdHJ1 Y3QgbXNtX2RzaV9waHkgKm1zbV9kc2lfcGh5X2luaXQoc3RydWN0IHBsYXRmb3JtX2RldmljZSAq cGRldiwKIAkgKi8KIAlyZXQgPSBkc2lfcGh5X2VuYWJsZV9yZXNvdXJjZShwaHkpOwogCWlmIChy ZXQpCi0JCXJldHVybiBOVUxMOworCQlnb3RvIGZhaWw7CiAKLQlwaHktPnBsbCA9IG1zbV9kc2lf cGxsX2luaXQocGRldiwgdHlwZSwgaWQpOworCXBoeS0+cGxsID0gbXNtX2RzaV9wbGxfaW5pdChw ZGV2LCBwaHktPmNmZy0+dHlwZSwgcGh5LT5pZCk7CiAJaWYgKCFwaHktPnBsbCkKLQkJcHJfaW5m bygiJXM6IHBsbCBpbml0IGZhaWxlZCwgbmVlZCBzZXBhcmF0ZSBwbGwgY2xrIGRyaXZlclxuIiwK KwkJZGV2X2luZm8oJnBkZXYtPmRldiwKKwkJCSIlczogcGxsIGluaXQgZmFpbGVkLCBuZWVkIHNl cGFyYXRlIHBsbCBjbGsgZHJpdmVyXG4iLAogCQkJX19mdW5jX18pOwogCiAJZHNpX3BoeV9kaXNh YmxlX3Jlc291cmNlKHBoeSk7CiAKLQlyZXR1cm4gcGh5OworCXBsYXRmb3JtX3NldF9kcnZkYXRh KHBkZXYsIHBoeSk7CisKKwlyZXR1cm4gMDsKKworZmFpbDoKKwlyZXR1cm4gcmV0OwogfQogCi12 b2lkIG1zbV9kc2lfcGh5X2Rlc3Ryb3koc3RydWN0IG1zbV9kc2lfcGh5ICpwaHkpCitzdGF0aWMg aW50IGRzaV9waHlfZHJpdmVyX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQog ewotCWlmIChwaHktPnBsbCkgeworCXN0cnVjdCBtc21fZHNpX3BoeSAqcGh5ID0gcGxhdGZvcm1f Z2V0X2RydmRhdGEocGRldik7CisKKwlpZiAocGh5ICYmIHBoeS0+cGxsKSB7CiAJCW1zbV9kc2lf cGxsX2Rlc3Ryb3kocGh5LT5wbGwpOwogCQlwaHktPnBsbCA9IE5VTEw7CiAJfQorCisJcGxhdGZv cm1fc2V0X2RydmRhdGEocGRldiwgTlVMTCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0 cnVjdCBwbGF0Zm9ybV9kcml2ZXIgZHNpX3BoeV9wbGF0Zm9ybV9kcml2ZXIgPSB7CisJLnByb2Jl ICAgICAgPSBkc2lfcGh5X2RyaXZlcl9wcm9iZSwKKwkucmVtb3ZlICAgICA9IGRzaV9waHlfZHJp dmVyX3JlbW92ZSwKKwkuZHJpdmVyICAgICA9IHsKKwkJLm5hbWUgICA9ICJtc21fZHNpX3BoeSIs CisJCS5vZl9tYXRjaF90YWJsZSA9IGRzaV9waHlfZHRfbWF0Y2gsCisJfSwKK307CisKK3ZvaWQg X19pbml0IG1zbV9kc2lfcGh5X2RyaXZlcl9yZWdpc3Rlcih2b2lkKQoreworCXBsYXRmb3JtX2Ry aXZlcl9yZWdpc3RlcigmZHNpX3BoeV9wbGF0Zm9ybV9kcml2ZXIpOworfQorCit2b2lkIF9fZXhp dCBtc21fZHNpX3BoeV9kcml2ZXJfdW5yZWdpc3Rlcih2b2lkKQoreworCXBsYXRmb3JtX2RyaXZl cl91bnJlZ2lzdGVyKCZkc2lfcGh5X3BsYXRmb3JtX2RyaXZlcik7CiB9CiAKIGludCBtc21fZHNp X3BoeV9lbmFibGUoc3RydWN0IG1zbV9kc2lfcGh5ICpwaHksIGJvb2wgaXNfZHVhbF9wYW5lbCwK IAljb25zdCB1bnNpZ25lZCBsb25nIGJpdF9yYXRlLCBjb25zdCB1bnNpZ25lZCBsb25nIGVzY19y YXRlKQogewotCWlmICghcGh5IHx8ICFwaHktPmVuYWJsZSkKKwlpbnQgcmV0OworCisJaWYgKCFw aHkgfHwgIXBoeS0+Y2ZnLT5vcHMuZW5hYmxlKQogCQlyZXR1cm4gLUVJTlZBTDsKLQlyZXR1cm4g cGh5LT5lbmFibGUocGh5LCBpc19kdWFsX3BhbmVsLCBiaXRfcmF0ZSwgZXNjX3JhdGUpOworCisJ cmV0ID0gZHNpX3BoeV9yZWd1bGF0b3JfZW5hYmxlKHBoeSk7CisJaWYgKHJldCkgeworCQlkZXZf ZXJyKCZwaHktPnBkZXYtPmRldiwgIiVzOiByZWd1bGF0b3IgZW5hYmxlIGZhaWxlZCwgJWRcbiIs CisJCQlfX2Z1bmNfXywgcmV0KTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXR1cm4gcGh5LT5j ZmctPm9wcy5lbmFibGUocGh5LCBpc19kdWFsX3BhbmVsLCBiaXRfcmF0ZSwgZXNjX3JhdGUpOwog fQogCiBpbnQgbXNtX2RzaV9waHlfZGlzYWJsZShzdHJ1Y3QgbXNtX2RzaV9waHkgKnBoeSkKIHsK LQlpZiAoIXBoeSB8fCAhcGh5LT5kaXNhYmxlKQorCWlmICghcGh5IHx8ICFwaHktPmNmZy0+b3Bz LmRpc2FibGUpCiAJCXJldHVybiAtRUlOVkFMOwotCXJldHVybiBwaHktPmRpc2FibGUocGh5KTsK KworCXBoeS0+Y2ZnLT5vcHMuZGlzYWJsZShwaHkpOworCWRzaV9waHlfcmVndWxhdG9yX2Rpc2Fi bGUocGh5KTsKKworCXJldHVybiAwOwogfQogCiB2b2lkIG1zbV9kc2lfcGh5X2dldF9jbGtfcHJl X3Bvc3Qoc3RydWN0IG1zbV9kc2lfcGh5ICpwaHksCi0tIApUaGUgUXVhbGNvbW0gSW5ub3ZhdGlv biBDZW50ZXIsIEluYy4gaXMgYSBtZW1iZXIgb2YgdGhlIENvZGUgQXVyb3JhIEZvcnVtLApob3N0 ZWQgYnkgVGhlIExpbnV4IEZvdW5kYXRpb24KCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3Rz LmZyZWVkZXNrdG9wLm9yZwpodHRwOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlz dGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S934627AbbEORFB (ORCPT ); Fri, 15 May 2015 13:05:01 -0400 Received: from smtp.codeaurora.org ([198.145.29.96]:56611 "EHLO smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S934340AbbEORE4 (ORCPT ); Fri, 15 May 2015 13:04:56 -0400 From: Hai Li To: dri-devel@lists.freedesktop.org Cc: linux-arm-msm@vger.kernel.org, linux-kernel@vger.kernel.org, robdclark@gmail.com, Hai Li Subject: [PATCH 3/3] drm/msm/dsi: Separate PHY to another platform device Date: Fri, 15 May 2015 13:04:06 -0400 Message-Id: <1431709446-31429-4-git-send-email-hali@codeaurora.org> X-Mailer: git-send-email 1.8.2.1 In-Reply-To: <1431709446-31429-1-git-send-email-hali@codeaurora.org> References: <1431709446-31429-1-git-send-email-hali@codeaurora.org> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org There are different types of PHY from one chipset to another, while the DSI host controller is relatively consistent across platforms. Also, the PLL inside PHY is providing the source of DSI byte and pixel clocks, which are used by DSI host controller. Separated devices for clock provider and clock consumer make DSI driver better fit into common clock framework. Signed-off-by: Hai Li --- Documentation/devicetree/bindings/drm/msm/dsi.txt | 59 +++-- drivers/gpu/drm/msm/dsi/dsi.c | 45 +++- drivers/gpu/drm/msm/dsi/dsi.h | 25 +- drivers/gpu/drm/msm/dsi/dsi_host.c | 25 +- drivers/gpu/drm/msm/dsi/dsi_phy.c | 266 ++++++++++++++++++---- 5 files changed, 325 insertions(+), 95 deletions(-) diff --git a/Documentation/devicetree/bindings/drm/msm/dsi.txt b/Documentation/devicetree/bindings/drm/msm/dsi.txt index b3cf325..2b17281 100644 --- a/Documentation/devicetree/bindings/drm/msm/dsi.txt +++ b/Documentation/devicetree/bindings/drm/msm/dsi.txt @@ -1,15 +1,12 @@ Qualcomm Technologies Inc. adreno/snapdragon DSI output +DSI Controller: Required properties: - compatible: * "qcom,mdss-dsi-ctrl" -- reg: Physical base address and length of the registers of controller, PLL, - PHY and PHY regulator +- reg: Physical base address and length of the registers of controller - reg-names: The names of register regions. The following regions are required: * "dsi_ctrl" - * "dsi_pll" - * "dsi_phy" - * "dsi_phy_regulator" - qcom,dsi-host-index: The ID of DSI controller hardware instance. This should be 0 or 1, since we have 2 DSI controllers at most for now. - interrupts: The interrupt signal from the DSI block. @@ -24,10 +21,10 @@ Required properties: * "iface_clk" * "mdp_core_clk" * "pixel_clk" -- #clock-cells: The value should be 1. - vdd-supply: phandle to vdd regulator device node - vddio-supply: phandle to vdd-io regulator device node - vdda-supply: phandle to vdda regulator device node +- qcom,dsi-phy: phandle to DSI PHY device node Optional properties: - panel@0: Node of panel connected to this DSI controller. @@ -42,22 +39,34 @@ Optional properties: - interrupt-parent: phandle to the MDP block if the interrupt signal is routed through MDP block +DSI PHY: +Required properties: +- compatible: Could be the following + * "qcom,dsi-phy-28nm-hpm" + * "qcom,dsi-phy-28nm-lp" +- reg: Physical base address and length of the registers of PLL, PHY and PHY + regulator +- reg-names: The names of register regions. The following regions are required: + * "dsi_pll" + * "dsi_phy" + * "dsi_phy_regulator" +- qcom,dsi-phy-index: The ID of DSI PHY hardware instance. This should + be 0 or 1, since we have 2 DSI PHYs at most for now. +- power-domains: Should be <&mmcc MDSS_GDSC>. +- clocks: device clocks + See Documentation/devicetree/bindings/clocks/clock-bindings.txt for details. +- clock-names: the following clocks are required: + * "iface_clk" +- vddio-supply: phandle to vdd-io regulator device node + Example: mdss_dsi0: qcom,mdss_dsi@fd922800 { compatible = "qcom,mdss-dsi-ctrl"; qcom,dsi-host-index = <0>; interrupt-parent = <&mdss_mdp>; interrupts = <4 0>; - reg-names = - "dsi_ctrl", - "dsi_pll", - "dsi_phy", - "dsi_phy_regulator", - reg = <0xfd922800 0x200>, - <0xfd922a00 0xd4>, - <0xfd922b00 0x2b0>, - <0xfd922d80 0x7b>, - <0xfd828000 0x108>; + reg-names = "dsi_ctrl"; + reg = <0xfd922800 0x200>; power-domains = <&mmcc MDSS_GDSC>; clock-names = "bus_clk", @@ -75,11 +84,12 @@ Example: <&mmcc MDSS_AHB_CLK>, <&mmcc MDSS_MDP_CLK>, <&mmcc MDSS_PCLK0_CLK>; - #clock-cells = <1>; vdda-supply = <&pma8084_l2>; vdd-supply = <&pma8084_l22>; vddio-supply = <&pma8084_l12>; + qcom,dsi-phy = <&mdss_dsi_phy0>; + qcom,dual-panel-mode; qcom,master-panel; qcom,sync-dual-panel; @@ -94,4 +104,17 @@ Example: }; }; - + mdss_dsi_phy0: qcom,mdss_dsi_phy@fd922a00 { + compatible = "qcom,dsi-phy-28nm-hpm"; + qcom,dsi-phy-index = <0>; + reg-names = + "dsi_pll", + "dsi_phy", + "dsi_phy_regulator"; + reg = <0xfd922a00 0xd4>, + <0xfd922b00 0x2b0>, + <0xfd922d80 0x7b>; + clock-names = "iface_clk"; + clocks = <&mmcc MDSS_AHB_CLK>; + vddio-supply = <&pma8084_l12>; + } diff --git a/drivers/gpu/drm/msm/dsi/dsi.c b/drivers/gpu/drm/msm/dsi/dsi.c index beb26df..1f2561e 100644 --- a/drivers/gpu/drm/msm/dsi/dsi.c +++ b/drivers/gpu/drm/msm/dsi/dsi.c @@ -23,6 +23,34 @@ struct drm_encoder *msm_dsi_get_encoder(struct msm_dsi *msm_dsi) msm_dsi->encoders[MSM_DSI_CMD_ENCODER_ID]; } +static int dsi_get_phy(struct msm_dsi *msm_dsi) +{ + struct platform_device *pdev = msm_dsi->pdev; + struct platform_device *phy_pdev; + struct device_node *phy_node; + + phy_node = of_parse_phandle(pdev->dev.of_node, "qcom,dsi-phy", 0); + if (!phy_node) { + dev_err(&pdev->dev, "cannot find phy device\n"); + return -ENXIO; + } + + phy_pdev = of_find_device_by_node(phy_node); + if (phy_pdev) + msm_dsi->phy = platform_get_drvdata(phy_pdev); + + of_node_put(phy_node); + + if (!phy_pdev || !msm_dsi->phy) { + dev_err(&pdev->dev, "%s: phy driver is not ready\n", __func__); + return -EPROBE_DEFER; + } + + msm_dsi->phy_dev = get_device(&phy_pdev->dev); + + return 0; +} + static void dsi_destroy(struct msm_dsi *msm_dsi) { if (!msm_dsi) @@ -30,9 +58,10 @@ static void dsi_destroy(struct msm_dsi *msm_dsi) msm_dsi_manager_unregister(msm_dsi); - if (msm_dsi->phy) { - msm_dsi_phy_destroy(msm_dsi->phy); + if (msm_dsi->phy_dev) { + put_device(msm_dsi->phy_dev); msm_dsi->phy = NULL; + msm_dsi->phy_dev = NULL; } if (msm_dsi->host) { @@ -49,7 +78,6 @@ static struct msm_dsi *dsi_init(struct platform_device *pdev) int ret; if (!pdev) { - dev_err(&pdev->dev, "no dsi device\n"); ret = -ENXIO; goto fail; } @@ -69,13 +97,10 @@ static struct msm_dsi *dsi_init(struct platform_device *pdev) if (ret) goto fail; - /* Init dsi PHY */ - msm_dsi->phy = msm_dsi_phy_init(pdev, msm_dsi->phy_type, msm_dsi->id); - if (!msm_dsi->phy) { - ret = -ENXIO; - pr_err("%s: phy init failed\n", __func__); + /* GET dsi PHY */ + ret = dsi_get_phy(msm_dsi); + if (ret) goto fail; - } /* Register to dsi manager */ ret = msm_dsi_manager_register(msm_dsi); @@ -156,12 +181,14 @@ static struct platform_driver dsi_driver = { void __init msm_dsi_register(void) { DBG(""); + msm_dsi_phy_driver_register(); platform_driver_register(&dsi_driver); } void __exit msm_dsi_unregister(void) { DBG(""); + msm_dsi_phy_driver_unregister(); platform_driver_unregister(&dsi_driver); } diff --git a/drivers/gpu/drm/msm/dsi/dsi.h b/drivers/gpu/drm/msm/dsi/dsi.h index 8022814..92d697d 100644 --- a/drivers/gpu/drm/msm/dsi/dsi.h +++ b/drivers/gpu/drm/msm/dsi/dsi.h @@ -14,6 +14,7 @@ #ifndef __DSI_CONNECTOR_H__ #define __DSI_CONNECTOR_H__ +#include #include #include "drm_crtc.h" @@ -39,12 +40,27 @@ #define DSI_ENCODER_SLAVE DSI_0 enum msm_dsi_phy_type { - MSM_DSI_PHY_UNKNOWN, MSM_DSI_PHY_28NM_HPM, MSM_DSI_PHY_28NM_LP, MSM_DSI_PHY_MAX }; +#define DSI_DEV_REGULATOR_MAX 8 + +/* Regulators for DSI devices */ +struct dsi_reg_entry { + char name[32]; + int min_voltage; + int max_voltage; + int enable_load; + int disable_load; +}; + +struct dsi_reg_config { + int num; + struct dsi_reg_entry regs[DSI_DEV_REGULATOR_MAX]; +}; + struct msm_dsi { struct drm_device *dev; struct platform_device *pdev; @@ -57,7 +73,7 @@ struct msm_dsi { struct drm_panel *panel; unsigned long panel_flags; - enum msm_dsi_phy_type phy_type; + struct device *phy_dev; bool phy_enabled; /* the encoders we are hooked to (outside of dsi block) */ @@ -135,9 +151,8 @@ int msm_dsi_host_init(struct msm_dsi *msm_dsi); /* dsi phy */ struct msm_dsi_phy; -struct msm_dsi_phy *msm_dsi_phy_init(struct platform_device *pdev, - enum msm_dsi_phy_type type, int id); -void msm_dsi_phy_destroy(struct msm_dsi_phy *phy); +void msm_dsi_phy_driver_register(void); +void msm_dsi_phy_driver_unregister(void); int msm_dsi_phy_enable(struct msm_dsi_phy *phy, bool is_dual_panel, const unsigned long bit_rate, const unsigned long esc_rate); int msm_dsi_phy_disable(struct msm_dsi_phy *phy); diff --git a/drivers/gpu/drm/msm/dsi/dsi_host.c b/drivers/gpu/drm/msm/dsi/dsi_host.c index 1cf9f11..59e524b 100644 --- a/drivers/gpu/drm/msm/dsi/dsi_host.c +++ b/drivers/gpu/drm/msm/dsi/dsi_host.c @@ -36,35 +36,19 @@ #define DSI_6G_REG_SHIFT 4 -#define DSI_REGULATOR_MAX 8 -struct dsi_reg_entry { - char name[32]; - int min_voltage; - int max_voltage; - int enable_load; - int disable_load; -}; - -struct dsi_reg_config { - int num; - struct dsi_reg_entry regs[DSI_REGULATOR_MAX]; -}; - struct dsi_config { u32 major; u32 minor; u32 io_offset; - enum msm_dsi_phy_type phy_type; struct dsi_reg_config reg_cfg; }; static const struct dsi_config dsi_cfgs[] = { - {MSM_DSI_VER_MAJOR_V2, 0, 0, MSM_DSI_PHY_UNKNOWN}, + {MSM_DSI_VER_MAJOR_V2, 0, 0, {0,} }, { /* 8974 v1 */ .major = MSM_DSI_VER_MAJOR_6G, .minor = MSM_DSI_6G_VER_MINOR_V1_0, .io_offset = DSI_6G_REG_SHIFT, - .phy_type = MSM_DSI_PHY_28NM_HPM, .reg_cfg = { .num = 4, .regs = { @@ -79,7 +63,6 @@ static const struct dsi_config dsi_cfgs[] = { .major = MSM_DSI_VER_MAJOR_6G, .minor = MSM_DSI_6G_VER_MINOR_V1_1, .io_offset = DSI_6G_REG_SHIFT, - .phy_type = MSM_DSI_PHY_28NM_HPM, .reg_cfg = { .num = 4, .regs = { @@ -94,7 +77,6 @@ static const struct dsi_config dsi_cfgs[] = { .major = MSM_DSI_VER_MAJOR_6G, .minor = MSM_DSI_6G_VER_MINOR_V1_1_1, .io_offset = DSI_6G_REG_SHIFT, - .phy_type = MSM_DSI_PHY_28NM_HPM, .reg_cfg = { .num = 4, .regs = { @@ -109,7 +91,6 @@ static const struct dsi_config dsi_cfgs[] = { .major = MSM_DSI_VER_MAJOR_6G, .minor = MSM_DSI_6G_VER_MINOR_V1_2, .io_offset = DSI_6G_REG_SHIFT, - .phy_type = MSM_DSI_PHY_28NM_HPM, .reg_cfg = { .num = 4, .regs = { @@ -124,7 +105,6 @@ static const struct dsi_config dsi_cfgs[] = { .major = MSM_DSI_VER_MAJOR_6G, .minor = MSM_DSI_6G_VER_MINOR_V1_3_1, .io_offset = DSI_6G_REG_SHIFT, - .phy_type = MSM_DSI_PHY_28NM_LP, .reg_cfg = { .num = 4, .regs = { @@ -197,7 +177,7 @@ struct msm_dsi_host { int id; void __iomem *ctrl_base; - struct regulator_bulk_data supplies[DSI_REGULATOR_MAX]; + struct regulator_bulk_data supplies[DSI_DEV_REGULATOR_MAX]; struct clk *mdp_core_clk; struct clk *ahb_clk; struct clk *axi_clk; @@ -1529,7 +1509,6 @@ int msm_dsi_host_init(struct msm_dsi *msm_dsi) msm_dsi->host = &msm_host->base; msm_dsi->id = msm_host->id; - msm_dsi->phy_type = msm_host->cfg->phy_type; DBG("Dsi Host %d initialized", msm_host->id); return 0; diff --git a/drivers/gpu/drm/msm/dsi/dsi_phy.c b/drivers/gpu/drm/msm/dsi/dsi_phy.c index e313e52..3d9d130 100644 --- a/drivers/gpu/drm/msm/dsi/dsi_phy.c +++ b/drivers/gpu/drm/msm/dsi/dsi_phy.c @@ -11,12 +11,27 @@ * GNU General Public License for more details. */ +#include +#include + #include "dsi.h" #include "dsi.xml.h" #define dsi_phy_read(offset) msm_readl((offset)) #define dsi_phy_write(offset, data) msm_writel((data), (offset)) +struct dsi_phy_ops { + int (*enable)(struct msm_dsi_phy *phy, bool is_dual_panel, + const unsigned long bit_rate, const unsigned long esc_rate); + int (*disable)(struct msm_dsi_phy *phy); +}; + +struct dsi_phy_cfg { + enum msm_dsi_phy_type type; + struct dsi_reg_config reg_cfg; + struct dsi_phy_ops ops; +}; + struct dsi_dphy_timing { u32 clk_pre; u32 clk_post; @@ -40,17 +55,100 @@ struct msm_dsi_phy { int id; struct clk *ahb_clk; + struct regulator_bulk_data supplies[DSI_DEV_REGULATOR_MAX]; struct dsi_dphy_timing timing; - enum msm_dsi_phy_type type; + const struct dsi_phy_cfg *cfg; struct msm_dsi_pll *pll; - - int (*enable)(struct msm_dsi_phy *phy, bool is_dual_panel, - const unsigned long bit_rate, const unsigned long esc_rate); - int (*disable)(struct msm_dsi_phy *phy); }; +static int dsi_phy_regulator_init(struct msm_dsi_phy *phy) +{ + struct regulator_bulk_data *s = phy->supplies; + const struct dsi_reg_entry *regs = phy->cfg->reg_cfg.regs; + struct device *dev = &phy->pdev->dev; + int num = phy->cfg->reg_cfg.num; + int i, ret; + + for (i = 0; i < num; i++) + s[i].supply = regs[i].name; + + ret = devm_regulator_bulk_get(&phy->pdev->dev, num, s); + if (ret < 0) { + dev_err(dev, "%s: failed to init regulator, ret=%d\n", + __func__, ret); + return ret; + } + + for (i = 0; i < num; i++) { + if ((regs[i].min_voltage >= 0) && (regs[i].max_voltage >= 0)) { + ret = regulator_set_voltage(s[i].consumer, + regs[i].min_voltage, regs[i].max_voltage); + if (ret < 0) { + dev_err(dev, + "regulator %d set voltage failed, %d\n", + i, ret); + return ret; + } + } + } + + return 0; +} + +static void dsi_phy_regulator_disable(struct msm_dsi_phy *phy) +{ + struct regulator_bulk_data *s = phy->supplies; + const struct dsi_reg_entry *regs = phy->cfg->reg_cfg.regs; + int num = phy->cfg->reg_cfg.num; + int i; + + DBG(""); + for (i = num - 1; i >= 0; i--) + if (regs[i].disable_load >= 0) + regulator_set_load(s[i].consumer, + regs[i].disable_load); + + regulator_bulk_disable(num, s); +} + +static int dsi_phy_regulator_enable(struct msm_dsi_phy *phy) +{ + struct regulator_bulk_data *s = phy->supplies; + const struct dsi_reg_entry *regs = phy->cfg->reg_cfg.regs; + struct device *dev = &phy->pdev->dev; + int num = phy->cfg->reg_cfg.num; + int ret, i; + + DBG(""); + for (i = 0; i < num; i++) { + if (regs[i].enable_load >= 0) { + ret = regulator_set_load(s[i].consumer, + regs[i].enable_load); + if (ret < 0) { + dev_err(dev, + "regulator %d set op mode failed, %d\n", + i, ret); + goto fail; + } + } + } + + ret = regulator_bulk_enable(num, s); + if (ret < 0) { + dev_err(dev, "regulator enable failed, %d\n", ret); + goto fail; + } + + return 0; + +fail: + for (i--; i >= 0; i--) + regulator_set_load(s[i].consumer, regs[i].disable_load); + return ret; +} + #define S_DIV_ROUND_UP(n, d) \ (((n) >= 0) ? (((n) + (d) - 1) / (d)) : (((n) - (d) + 1) / (d))) @@ -313,51 +411,94 @@ static void dsi_phy_disable_resource(struct msm_dsi_phy *phy) pm_runtime_put_sync(&phy->pdev->dev); } -#define dsi_phy_func_init(name) \ - do { \ - phy->enable = dsi_##name##_phy_enable; \ - phy->disable = dsi_##name##_phy_disable; \ - } while (0) +static const struct dsi_phy_cfg dsi_phy_cfgs[MSM_DSI_PHY_MAX] = { + [MSM_DSI_PHY_28NM_HPM] = { + .type = MSM_DSI_PHY_28NM_HPM, + .reg_cfg = { + .num = 1, + .regs = { + {"vddio", 1800000, 1800000, 100000, 100}, + }, + }, + .ops = { + .enable = dsi_28nm_phy_enable, + .disable = dsi_28nm_phy_disable, + } + }, + [MSM_DSI_PHY_28NM_LP] = { + .type = MSM_DSI_PHY_28NM_LP, + .reg_cfg = { + .num = 1, + .regs = { + {"vddio", 1800000, 1800000, 100000, 100}, + }, + }, + .ops = { + .enable = dsi_28nm_phy_enable, + .disable = dsi_28nm_phy_disable, + } + }, +}; + +static const struct of_device_id dsi_phy_dt_match[] = { + { .compatible = "qcom,dsi-phy-28nm-hpm", + .data = &dsi_phy_cfgs[MSM_DSI_PHY_28NM_HPM],}, + { .compatible = "qcom,dsi-phy-28nm-lp", + .data = &dsi_phy_cfgs[MSM_DSI_PHY_28NM_LP],}, + {} +}; -struct msm_dsi_phy *msm_dsi_phy_init(struct platform_device *pdev, - enum msm_dsi_phy_type type, int id) +static int dsi_phy_driver_probe(struct platform_device *pdev) { struct msm_dsi_phy *phy; + const struct of_device_id *match; int ret; phy = devm_kzalloc(&pdev->dev, sizeof(*phy), GFP_KERNEL); if (!phy) - return NULL; + return -ENOMEM; + + match = of_match_node(dsi_phy_dt_match, pdev->dev.of_node); + if (!match) + return -ENODEV; + + phy->cfg = match->data; + phy->pdev = pdev; + + ret = of_property_read_u32(pdev->dev.of_node, + "qcom,dsi-phy-index", &phy->id); + if (ret) { + dev_err(&pdev->dev, + "%s: PHY index not specified, ret=%d\n", + __func__, ret); + goto fail; + } phy->base = msm_ioremap(pdev, "dsi_phy", "DSI_PHY"); if (IS_ERR_OR_NULL(phy->base)) { - pr_err("%s: failed to map phy base\n", __func__); - return NULL; + dev_err(&pdev->dev, "%s: failed to map phy base\n", __func__); + ret = -ENOMEM; + goto fail; } phy->reg_base = msm_ioremap(pdev, "dsi_phy_regulator", "DSI_PHY_REG"); if (IS_ERR_OR_NULL(phy->reg_base)) { - pr_err("%s: failed to map phy regulator base\n", __func__); - return NULL; + dev_err(&pdev->dev, + "%s: failed to map phy regulator base\n", __func__); + ret = -ENOMEM; + goto fail; } - switch (type) { - case MSM_DSI_PHY_28NM_HPM: - case MSM_DSI_PHY_28NM_LP: - dsi_phy_func_init(28nm); - break; - default: - pr_err("%s: unsupported type, %d\n", __func__, type); - return NULL; + ret = dsi_phy_regulator_init(phy); + if (ret) { + dev_err(&pdev->dev, "%s: failed to init regulator\n", __func__); + goto fail; } - phy->type = type; - phy->id = id; - phy->pdev = pdev; - phy->ahb_clk = devm_clk_get(&pdev->dev, "iface_clk"); if (IS_ERR(phy->ahb_clk)) { pr_err("%s: Unable to get ahb clk\n", __func__); - return NULL; + ret = PTR_ERR(phy->ahb_clk); + goto fail; } /* PLL init will call into clk_register which requires @@ -365,39 +506,84 @@ struct msm_dsi_phy *msm_dsi_phy_init(struct platform_device *pdev, */ ret = dsi_phy_enable_resource(phy); if (ret) - return NULL; + goto fail; - phy->pll = msm_dsi_pll_init(pdev, type, id); + phy->pll = msm_dsi_pll_init(pdev, phy->cfg->type, phy->id); if (!phy->pll) - pr_info("%s: pll init failed, need separate pll clk driver\n", + dev_info(&pdev->dev, + "%s: pll init failed, need separate pll clk driver\n", __func__); dsi_phy_disable_resource(phy); - return phy; + platform_set_drvdata(pdev, phy); + + return 0; + +fail: + return ret; } -void msm_dsi_phy_destroy(struct msm_dsi_phy *phy) +static int dsi_phy_driver_remove(struct platform_device *pdev) { - if (phy->pll) { + struct msm_dsi_phy *phy = platform_get_drvdata(pdev); + + if (phy && phy->pll) { msm_dsi_pll_destroy(phy->pll); phy->pll = NULL; } + + platform_set_drvdata(pdev, NULL); + + return 0; +} + +static struct platform_driver dsi_phy_platform_driver = { + .probe = dsi_phy_driver_probe, + .remove = dsi_phy_driver_remove, + .driver = { + .name = "msm_dsi_phy", + .of_match_table = dsi_phy_dt_match, + }, +}; + +void __init msm_dsi_phy_driver_register(void) +{ + platform_driver_register(&dsi_phy_platform_driver); +} + +void __exit msm_dsi_phy_driver_unregister(void) +{ + platform_driver_unregister(&dsi_phy_platform_driver); } int msm_dsi_phy_enable(struct msm_dsi_phy *phy, bool is_dual_panel, const unsigned long bit_rate, const unsigned long esc_rate) { - if (!phy || !phy->enable) + int ret; + + if (!phy || !phy->cfg->ops.enable) return -EINVAL; - return phy->enable(phy, is_dual_panel, bit_rate, esc_rate); + + ret = dsi_phy_regulator_enable(phy); + if (ret) { + dev_err(&phy->pdev->dev, "%s: regulator enable failed, %d\n", + __func__, ret); + return ret; + } + + return phy->cfg->ops.enable(phy, is_dual_panel, bit_rate, esc_rate); } int msm_dsi_phy_disable(struct msm_dsi_phy *phy) { - if (!phy || !phy->disable) + if (!phy || !phy->cfg->ops.disable) return -EINVAL; - return phy->disable(phy); + + phy->cfg->ops.disable(phy); + dsi_phy_regulator_disable(phy); + + return 0; } void msm_dsi_phy_get_clk_pre_post(struct msm_dsi_phy *phy, -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, hosted by The Linux Foundation