From mboxrd@z Thu Jan 1 00:00:00 1970 From: linus.walleij@linaro.org (Linus Walleij) Date: Tue, 17 Oct 2017 12:19:04 +0200 Subject: [PATCH 2/2 v2] drm: bridge: Add THS8134A/B support to dumb VGA DAC In-Reply-To: <20171017101904.22308-1-linus.walleij@linaro.org> References: <20171017101904.22308-1-linus.walleij@linaro.org> Message-ID: <20171017101904.22308-2-linus.walleij@linaro.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org This extends the dumb VGA DAC bridge to handle the THS8134A and THS8134B VGA DACs in addition to those already handled. The THS8134A, THS8134B and as it turns out also THS8135 need to have data clocked out at the negative edge of the clock pulse, since they clock it into the DAC at the positive edge (so by then it needs to be stable) so we need some extra logic to flag this on the connector to the driver. The semantics of the flag DRM_BUS_FLAG_PIXDATA_NEGEDGE in clearly indicates that this flag tells when to *drive* the data, not when the receiver *reads* it, so the TI variants needs to be handled like this. Introduce a variant struct and contain the information there, and add a bit of helpful comments about how this works so people will get it right when adding new DACs or connectiong new display drivers to DACs. The fact that THS8135 might be working on some systems today is probably due to the fact that the display driver cannot configure when the data is clocked out and the electronics have simply been designed around it so it works anyways. The phenomenon is very real on the ARM reference designs using PL111 where the hardware can control which edge to push out the data. Cc: Laurent Pinchart Cc: Bartosz Golaszewski Cc: Maxime Ripard Signed-off-by: Linus Walleij --- ChangeLog v1->v2: - Alphabetize includes - Use a u32 with the bus polarity flags and just encode the polarity using the DRM define directly. - Rename vendor_data to vendor_info. - Simplify assignment of the flag as it is just a simple u32 now. - Probe all TI variants on the "ti,ths813x" wildcard for now, we only need to know that the device is in this family to set the clock edge flag right. --- drivers/gpu/drm/bridge/dumb-vga-dac.c | 51 ++++++++++++++++++++++++++++++++--- 1 file changed, 47 insertions(+), 4 deletions(-) diff --git a/drivers/gpu/drm/bridge/dumb-vga-dac.c b/drivers/gpu/drm/bridge/dumb-vga-dac.c index 831a606c4706..9cd19e4c33c9 100644 --- a/drivers/gpu/drm/bridge/dumb-vga-dac.c +++ b/drivers/gpu/drm/bridge/dumb-vga-dac.c @@ -11,6 +11,7 @@ */ #include +#include #include #include @@ -19,9 +20,18 @@ #include #include +/** + * struct vga_dac_info - characteristics of the DAC + * @clk_edge_latch: this defines the clock edge latch for the variant + */ +struct vga_dac_info { + u32 clk_edge_latch; +}; + struct dumb_vga { struct drm_bridge bridge; struct drm_connector connector; + struct vga_dac_info const *variant; struct i2c_adapter *ddc; struct regulator *vdd; @@ -55,7 +65,9 @@ static int dumb_vga_get_modes(struct drm_connector *connector) } drm_mode_connector_update_edid_property(connector, edid); - return drm_add_edid_modes(connector, edid); + ret = drm_add_edid_modes(connector, edid); + connector->display_info.bus_flags |= vga->variant->clk_edge_latch; + return ret; fallback: /* @@ -67,6 +79,8 @@ static int dumb_vga_get_modes(struct drm_connector *connector) /* And prefer a mode pretty much anyone can handle */ drm_set_preferred_mode(connector, 1024, 768); + connector->display_info.bus_flags |= vga->variant->clk_edge_latch; + return ret; } @@ -183,6 +197,7 @@ static int dumb_vga_probe(struct platform_device *pdev) if (!vga) return -ENOMEM; platform_set_drvdata(pdev, vga); + vga->variant = of_device_get_match_data(&pdev->dev); vga->vdd = devm_regulator_get_optional(&pdev->dev, "vdd"); if (IS_ERR(vga->vdd)) { @@ -226,10 +241,38 @@ static int dumb_vga_remove(struct platform_device *pdev) return 0; } +static const struct vga_dac_info default_dac_variant = { + /* + * These DACs read data on the negative edge. For example in the + * ADV7123 datasheet (revision D, page 8) there is a timing diagram + * making this clear. So consequently we need to latch the data + * on the positive edge. + */ + .clk_edge_latch = DRM_BUS_FLAG_PIXDATA_POSEDGE, +}; + +static const struct vga_dac_info ti_ths_dac_variant = { + /* + * The TI DACs read the data on the positive edge of the CLK, + * so consequently we need to latch the data on the negative + * edge. + */ + .clk_edge_latch = DRM_BUS_FLAG_PIXDATA_NEGEDGE, +}; + static const struct of_device_id dumb_vga_match[] = { - { .compatible = "dumb-vga-dac" }, - { .compatible = "adi,adv7123" }, - { .compatible = "ti,ths8135" }, + { + .compatible = "dumb-vga-dac", + .data = &default_dac_variant, + }, + { + .compatible = "adi,adv7123", + .data = &default_dac_variant, + }, + { + .compatible = "ti,ths813x", + .data = &ti_ths_dac_variant, + }, {}, }; MODULE_DEVICE_TABLE(of, dumb_vga_match); -- 2.13.5 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Linus Walleij Subject: [PATCH 2/2 v2] drm: bridge: Add THS8134A/B support to dumb VGA DAC Date: Tue, 17 Oct 2017 12:19:04 +0200 Message-ID: <20171017101904.22308-2-linus.walleij@linaro.org> References: <20171017101904.22308-1-linus.walleij@linaro.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x234.google.com (mail-lf0-x234.google.com [IPv6:2a00:1450:4010:c07::234]) by gabe.freedesktop.org (Postfix) with ESMTPS id 054AF6E5FA for ; Tue, 17 Oct 2017 10:19:13 +0000 (UTC) Received: by mail-lf0-x234.google.com with SMTP id r129so1372162lff.8 for ; Tue, 17 Oct 2017 03:19:13 -0700 (PDT) In-Reply-To: <20171017101904.22308-1-linus.walleij@linaro.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Archit Taneja , Andrzej Hajda , Laurent Pinchart Cc: Laurent Pinchart , dri-devel@lists.freedesktop.org, Bartosz Golaszewski , Maxime Ripard , linux-arm-kernel@lists.infradead.org List-Id: dri-devel@lists.freedesktop.org VGhpcyBleHRlbmRzIHRoZSBkdW1iIFZHQSBEQUMgYnJpZGdlIHRvIGhhbmRsZSB0aGUgVEhTODEz NEEKYW5kIFRIUzgxMzRCIFZHQSBEQUNzIGluIGFkZGl0aW9uIHRvIHRob3NlIGFscmVhZHkgaGFu ZGxlZC4KClRoZSBUSFM4MTM0QSwgVEhTODEzNEIgYW5kIGFzIGl0IHR1cm5zIG91dCBhbHNvIFRI UzgxMzUgbmVlZCB0bwpoYXZlIGRhdGEgY2xvY2tlZCBvdXQgYXQgdGhlIG5lZ2F0aXZlIGVkZ2Ug b2YgdGhlIGNsb2NrIHB1bHNlLApzaW5jZSB0aGV5IGNsb2NrIGl0IGludG8gdGhlIERBQyBhdCB0 aGUgcG9zaXRpdmUgZWRnZSAoc28gYnkKdGhlbiBpdCBuZWVkcyB0byBiZSBzdGFibGUpIHNvIHdl IG5lZWQgc29tZSBleHRyYSBsb2dpYyB0byBmbGFnCnRoaXMgb24gdGhlIGNvbm5lY3RvciB0byB0 aGUgZHJpdmVyLgoKVGhlIHNlbWFudGljcyBvZiB0aGUgZmxhZyBEUk1fQlVTX0ZMQUdfUElYREFU QV9ORUdFREdFIGluCjxkcm0vZHJtX2Nvbm5lY3Rvci5oPiBjbGVhcmx5IGluZGljYXRlcyB0aGF0 IHRoaXMgZmxhZyB0ZWxscwp3aGVuIHRvICpkcml2ZSogdGhlIGRhdGEsIG5vdCB3aGVuIHRoZSBy ZWNlaXZlciAqcmVhZHMqIGl0LApzbyB0aGUgVEkgdmFyaWFudHMgbmVlZHMgdG8gYmUgaGFuZGxl ZCBsaWtlIHRoaXMuCgpJbnRyb2R1Y2UgYSB2YXJpYW50IHN0cnVjdCBhbmQgY29udGFpbiB0aGUg aW5mb3JtYXRpb24gdGhlcmUsCmFuZCBhZGQgYSBiaXQgb2YgaGVscGZ1bCBjb21tZW50cyBhYm91 dCBob3cgdGhpcyB3b3JrcyBzbwpwZW9wbGUgd2lsbCBnZXQgaXQgcmlnaHQgd2hlbiBhZGRpbmcg bmV3IERBQ3Mgb3IgY29ubmVjdGlvbmcKbmV3IGRpc3BsYXkgZHJpdmVycyB0byBEQUNzLgoKVGhl IGZhY3QgdGhhdCBUSFM4MTM1IG1pZ2h0IGJlIHdvcmtpbmcgb24gc29tZSBzeXN0ZW1zIHRvZGF5 CmlzIHByb2JhYmx5IGR1ZSB0byB0aGUgZmFjdCB0aGF0IHRoZSBkaXNwbGF5IGRyaXZlciBjYW5u b3QKY29uZmlndXJlIHdoZW4gdGhlIGRhdGEgaXMgY2xvY2tlZCBvdXQgYW5kIHRoZSBlbGVjdHJv bmljcwpoYXZlIHNpbXBseSBiZWVuIGRlc2lnbmVkIGFyb3VuZCBpdCBzbyBpdCB3b3JrcyBhbnl3 YXlzLgoKVGhlIHBoZW5vbWVub24gaXMgdmVyeSByZWFsIG9uIHRoZSBBUk0gcmVmZXJlbmNlIGRl c2lnbnMgdXNpbmcKUEwxMTEgd2hlcmUgdGhlIGhhcmR3YXJlIGNhbiBjb250cm9sIHdoaWNoIGVk Z2UgdG8gcHVzaCBvdXQKdGhlIGRhdGEuCgpDYzogTGF1cmVudCBQaW5jaGFydCA8bGF1cmVudC5w aW5jaGFydCtyZW5lc2FzQGlkZWFzb25ib2FyZC5jb20+CkNjOiBCYXJ0b3N6IEdvbGFzemV3c2tp IDxiZ29sYXN6ZXdza2lAYmF5bGlicmUuY29tPgpDYzogTWF4aW1lIFJpcGFyZCA8bWF4aW1lLnJp cGFyZEBmcmVlLWVsZWN0cm9ucy5jb20+ClNpZ25lZC1vZmYtYnk6IExpbnVzIFdhbGxlaWogPGxp bnVzLndhbGxlaWpAbGluYXJvLm9yZz4KLS0tCkNoYW5nZUxvZyB2MS0+djI6Ci0gQWxwaGFiZXRp emUgaW5jbHVkZXMKLSBVc2UgYSB1MzIgd2l0aCB0aGUgYnVzIHBvbGFyaXR5IGZsYWdzIGFuZCBq dXN0IGVuY29kZSB0aGUKICBwb2xhcml0eSB1c2luZyB0aGUgRFJNIGRlZmluZSBkaXJlY3RseS4K LSBSZW5hbWUgdmVuZG9yX2RhdGEgdG8gdmVuZG9yX2luZm8uCi0gU2ltcGxpZnkgYXNzaWdubWVu dCBvZiB0aGUgZmxhZyBhcyBpdCBpcyBqdXN0IGEgc2ltcGxlCiAgdTMyIG5vdy4KLSBQcm9iZSBh bGwgVEkgdmFyaWFudHMgb24gdGhlICJ0aSx0aHM4MTN4IiB3aWxkY2FyZCBmb3Igbm93LAogIHdl IG9ubHkgbmVlZCB0byBrbm93IHRoYXQgdGhlIGRldmljZSBpcyBpbiB0aGlzIGZhbWlseSB0bwog IHNldCB0aGUgY2xvY2sgZWRnZSBmbGFnIHJpZ2h0LgotLS0KIGRyaXZlcnMvZ3B1L2RybS9icmlk Z2UvZHVtYi12Z2EtZGFjLmMgfCA1MSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0t LQogMSBmaWxlIGNoYW5nZWQsIDQ3IGluc2VydGlvbnMoKyksIDQgZGVsZXRpb25zKC0pCgpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9kdW1iLXZnYS1kYWMuYyBiL2RyaXZlcnMv Z3B1L2RybS9icmlkZ2UvZHVtYi12Z2EtZGFjLmMKaW5kZXggODMxYTYwNmM0NzA2Li45Y2QxOWU0 YzMzYzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvZHVtYi12Z2EtZGFjLmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9kdW1iLXZnYS1kYWMuYwpAQCAtMTEsNiArMTEs NyBAQAogICovCiAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9v Zl9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9vZl9ncmFwaC5oPgogI2luY2x1ZGUgPGxpbnV4 L3JlZ3VsYXRvci9jb25zdW1lci5oPgogCkBAIC0xOSw5ICsyMCwxOCBAQAogI2luY2x1ZGUgPGRy bS9kcm1fY3J0Yy5oPgogI2luY2x1ZGUgPGRybS9kcm1fY3J0Y19oZWxwZXIuaD4KIAorLyoqCisg KiBzdHJ1Y3QgdmdhX2RhY19pbmZvIC0gY2hhcmFjdGVyaXN0aWNzIG9mIHRoZSBEQUMKKyAqIEBj bGtfZWRnZV9sYXRjaDogdGhpcyBkZWZpbmVzIHRoZSBjbG9jayBlZGdlIGxhdGNoIGZvciB0aGUg dmFyaWFudAorICovCitzdHJ1Y3QgdmdhX2RhY19pbmZvIHsKKwl1MzIgY2xrX2VkZ2VfbGF0Y2g7 Cit9OworCiBzdHJ1Y3QgZHVtYl92Z2EgewogCXN0cnVjdCBkcm1fYnJpZGdlCWJyaWRnZTsKIAlz dHJ1Y3QgZHJtX2Nvbm5lY3Rvcgljb25uZWN0b3I7CisJc3RydWN0IHZnYV9kYWNfaW5mbyBjb25z dCAqdmFyaWFudDsKIAogCXN0cnVjdCBpMmNfYWRhcHRlcgkqZGRjOwogCXN0cnVjdCByZWd1bGF0 b3IJKnZkZDsKQEAgLTU1LDcgKzY1LDkgQEAgc3RhdGljIGludCBkdW1iX3ZnYV9nZXRfbW9kZXMo c3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKIAl9CiAKIAlkcm1fbW9kZV9jb25uZWN0 b3JfdXBkYXRlX2VkaWRfcHJvcGVydHkoY29ubmVjdG9yLCBlZGlkKTsKLQlyZXR1cm4gZHJtX2Fk ZF9lZGlkX21vZGVzKGNvbm5lY3RvciwgZWRpZCk7CisJcmV0ID0gZHJtX2FkZF9lZGlkX21vZGVz KGNvbm5lY3RvciwgZWRpZCk7CisJY29ubmVjdG9yLT5kaXNwbGF5X2luZm8uYnVzX2ZsYWdzIHw9 IHZnYS0+dmFyaWFudC0+Y2xrX2VkZ2VfbGF0Y2g7CisJcmV0dXJuIHJldDsKIAogZmFsbGJhY2s6 CiAJLyoKQEAgLTY3LDYgKzc5LDggQEAgc3RhdGljIGludCBkdW1iX3ZnYV9nZXRfbW9kZXMoc3Ry dWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKIAkvKiBBbmQgcHJlZmVyIGEgbW9kZSBwcmV0 dHkgbXVjaCBhbnlvbmUgY2FuIGhhbmRsZSAqLwogCWRybV9zZXRfcHJlZmVycmVkX21vZGUoY29u bmVjdG9yLCAxMDI0LCA3NjgpOwogCisJY29ubmVjdG9yLT5kaXNwbGF5X2luZm8uYnVzX2ZsYWdz IHw9IHZnYS0+dmFyaWFudC0+Y2xrX2VkZ2VfbGF0Y2g7CisKIAlyZXR1cm4gcmV0OwogfQogCkBA IC0xODMsNiArMTk3LDcgQEAgc3RhdGljIGludCBkdW1iX3ZnYV9wcm9iZShzdHJ1Y3QgcGxhdGZv cm1fZGV2aWNlICpwZGV2KQogCWlmICghdmdhKQogCQlyZXR1cm4gLUVOT01FTTsKIAlwbGF0Zm9y bV9zZXRfZHJ2ZGF0YShwZGV2LCB2Z2EpOworCXZnYS0+dmFyaWFudCA9IG9mX2RldmljZV9nZXRf bWF0Y2hfZGF0YSgmcGRldi0+ZGV2KTsKIAogCXZnYS0+dmRkID0gZGV2bV9yZWd1bGF0b3JfZ2V0 X29wdGlvbmFsKCZwZGV2LT5kZXYsICJ2ZGQiKTsKIAlpZiAoSVNfRVJSKHZnYS0+dmRkKSkgewpA QCAtMjI2LDEwICsyNDEsMzggQEAgc3RhdGljIGludCBkdW1iX3ZnYV9yZW1vdmUoc3RydWN0IHBs YXRmb3JtX2RldmljZSAqcGRldikKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIGNvbnN0IHN0cnVj dCB2Z2FfZGFjX2luZm8gZGVmYXVsdF9kYWNfdmFyaWFudCA9IHsKKwkvKgorCSAqIFRoZXNlIERB Q3MgcmVhZCBkYXRhIG9uIHRoZSBuZWdhdGl2ZSBlZGdlLiBGb3IgZXhhbXBsZSBpbiB0aGUKKwkg KiBBRFY3MTIzIGRhdGFzaGVldCAocmV2aXNpb24gRCwgcGFnZSA4KSB0aGVyZSBpcyBhIHRpbWlu ZyBkaWFncmFtCisJICogbWFraW5nIHRoaXMgY2xlYXIuIFNvIGNvbnNlcXVlbnRseSB3ZSBuZWVk IHRvIGxhdGNoIHRoZSBkYXRhCisJICogb24gdGhlIHBvc2l0aXZlIGVkZ2UuCisJICovCisJLmNs a19lZGdlX2xhdGNoID0gRFJNX0JVU19GTEFHX1BJWERBVEFfUE9TRURHRSwKK307CisKK3N0YXRp YyBjb25zdCBzdHJ1Y3QgdmdhX2RhY19pbmZvIHRpX3Roc19kYWNfdmFyaWFudCA9IHsKKwkvKgor CSAqIFRoZSBUSSBEQUNzIHJlYWQgdGhlIGRhdGEgb24gdGhlIHBvc2l0aXZlIGVkZ2Ugb2YgdGhl IENMSywKKwkgKiBzbyBjb25zZXF1ZW50bHkgd2UgbmVlZCB0byBsYXRjaCB0aGUgZGF0YSBvbiB0 aGUgbmVnYXRpdmUKKwkgKiBlZGdlLgorCSAqLworCS5jbGtfZWRnZV9sYXRjaCA9IERSTV9CVVNf RkxBR19QSVhEQVRBX05FR0VER0UsCit9OworCiBzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2Rldmlj ZV9pZCBkdW1iX3ZnYV9tYXRjaFtdID0gewotCXsgLmNvbXBhdGlibGUgPSAiZHVtYi12Z2EtZGFj IiB9LAotCXsgLmNvbXBhdGlibGUgPSAiYWRpLGFkdjcxMjMiIH0sCi0JeyAuY29tcGF0aWJsZSA9 ICJ0aSx0aHM4MTM1IiB9LAorCXsKKwkJLmNvbXBhdGlibGUgPSAiZHVtYi12Z2EtZGFjIiwKKwkJ LmRhdGEgPSAmZGVmYXVsdF9kYWNfdmFyaWFudCwKKwl9LAorCXsKKwkJLmNvbXBhdGlibGUgPSAi YWRpLGFkdjcxMjMiLAorCQkuZGF0YSA9ICZkZWZhdWx0X2RhY192YXJpYW50LAorCX0sCisJewor CQkuY29tcGF0aWJsZSA9ICJ0aSx0aHM4MTN4IiwKKwkJLmRhdGEgPSAmdGlfdGhzX2RhY192YXJp YW50LAorCX0sCiAJe30sCiB9OwogTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgZHVtYl92Z2FfbWF0 Y2gpOwotLSAKMi4xMy41CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3Rv cC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmkt ZGV2ZWwK