drm/bridge/nxp-ptn3460.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * NXP PTN3460 DP/LVDS bridge driver
0004  *
0005  * Copyright (C) 2013 Google, Inc.
0006  */
0007
0008 #include <linux/delay.h>
0009 #include <linux/gpio/consumer.h>
0010 #include <linux/i2c.h>
0011 #include <linux/module.h>
0012 #include <linux/of.h>
0013 #include <drm/drm_atomic_helper.h>
0014 #include <drm/drm_bridge.h>
0015 #include <drm/drm_crtc.h>
0016 #include <drm/drm_edid.h>
0017 #include <drm/drm_of.h>
0018 #include <drm/drm_panel.h>
0019 #include <drm/drm_print.h>
0020 #include <drm/drm_probe_helper.h>
0021
0022 #define PTN3460_EDID_ADDR           0x0
0023 #define PTN3460_EDID_EMULATION_ADDR     0x84
0024 #define PTN3460_EDID_ENABLE_EMULATION       0
0025 #define PTN3460_EDID_EMULATION_SELECTION    1
0026 #define PTN3460_EDID_SRAM_LOAD_ADDR     0x85
0027
0028 struct ptn3460_bridge {
0029     struct drm_connector connector;
0030     struct i2c_client *client;
0031     struct drm_bridge bridge;
0032     struct drm_bridge *panel_bridge;
0033     struct gpio_desc *gpio_pd_n;
0034     struct gpio_desc *gpio_rst_n;
0035     u32 edid_emulation;
0036     bool enabled;
0037 };
0038
0039 static inline struct ptn3460_bridge *
0040         bridge_to_ptn3460(struct drm_bridge *bridge)
0041 {
0042     return container_of(bridge, struct ptn3460_bridge, bridge);
0043 }
0044
0045 static inline struct ptn3460_bridge *
0046         connector_to_ptn3460(struct drm_connector *connector)
0047 {
0048     return container_of(connector, struct ptn3460_bridge, connector);
0049 }
0050
0051 static int ptn3460_read_bytes(struct ptn3460_bridge *ptn_bridge, char addr,
0052         u8 *buf, int len)
0053 {
0054     int ret;
0055
0056     ret = i2c_master_send(ptn_bridge->client, &addr, 1);
0057     if (ret <= 0) {
0058         DRM_ERROR("Failed to send i2c command, ret=%d\n", ret);
0059         return ret;
0060     }
0061
0062     ret = i2c_master_recv(ptn_bridge->client, buf, len);
0063     if (ret <= 0) {
0064         DRM_ERROR("Failed to recv i2c data, ret=%d\n", ret);
0065         return ret;
0066     }
0067
0068     return 0;
0069 }
0070
0071 static int ptn3460_write_byte(struct ptn3460_bridge *ptn_bridge, char addr,
0072         char val)
0073 {
0074     int ret;
0075     char buf[2];
0076
0077     buf[0] = addr;
0078     buf[1] = val;
0079
0080     ret = i2c_master_send(ptn_bridge->client, buf, ARRAY_SIZE(buf));
0081     if (ret <= 0) {
0082         DRM_ERROR("Failed to send i2c command, ret=%d\n", ret);
0083         return ret;
0084     }
0085
0086     return 0;
0087 }
0088
0089 static int ptn3460_select_edid(struct ptn3460_bridge *ptn_bridge)
0090 {
0091     int ret;
0092     char val;
0093
0094     /* Load the selected edid into SRAM (accessed at PTN3460_EDID_ADDR) */
0095     ret = ptn3460_write_byte(ptn_bridge, PTN3460_EDID_SRAM_LOAD_ADDR,
0096             ptn_bridge->edid_emulation);
0097     if (ret) {
0098         DRM_ERROR("Failed to transfer EDID to sram, ret=%d\n", ret);
0099         return ret;
0100     }
0101
0102     /* Enable EDID emulation and select the desired EDID */
0103     val = 1 << PTN3460_EDID_ENABLE_EMULATION |
0104         ptn_bridge->edid_emulation << PTN3460_EDID_EMULATION_SELECTION;
0105
0106     ret = ptn3460_write_byte(ptn_bridge, PTN3460_EDID_EMULATION_ADDR, val);
0107     if (ret) {
0108         DRM_ERROR("Failed to write EDID value, ret=%d\n", ret);
0109         return ret;
0110     }
0111
0112     return 0;
0113 }
0114
0115 static void ptn3460_pre_enable(struct drm_bridge *bridge)
0116 {
0117     struct ptn3460_bridge *ptn_bridge = bridge_to_ptn3460(bridge);
0118     int ret;
0119
0120     if (ptn_bridge->enabled)
0121         return;
0122
0123     gpiod_set_value(ptn_bridge->gpio_pd_n, 1);
0124
0125     gpiod_set_value(ptn_bridge->gpio_rst_n, 0);
0126     usleep_range(10, 20);
0127     gpiod_set_value(ptn_bridge->gpio_rst_n, 1);
0128
0129     /*
0130      * There's a bug in the PTN chip where it falsely asserts hotplug before
0131      * it is fully functional. We're forced to wait for the maximum start up
0132      * time specified in the chip's datasheet to make sure we're really up.
0133      */
0134     msleep(90);
0135
0136     ret = ptn3460_select_edid(ptn_bridge);
0137     if (ret)
0138         DRM_ERROR("Select EDID failed ret=%d\n", ret);
0139
0140     ptn_bridge->enabled = true;
0141 }
0142
0143 static void ptn3460_disable(struct drm_bridge *bridge)
0144 {
0145     struct ptn3460_bridge *ptn_bridge = bridge_to_ptn3460(bridge);
0146
0147     if (!ptn_bridge->enabled)
0148         return;
0149
0150     ptn_bridge->enabled = false;
0151
0152     gpiod_set_value(ptn_bridge->gpio_rst_n, 1);
0153     gpiod_set_value(ptn_bridge->gpio_pd_n, 0);
0154 }
0155
0156
0157 static struct edid *ptn3460_get_edid(struct drm_bridge *bridge,
0158                      struct drm_connector *connector)
0159 {
0160     struct ptn3460_bridge *ptn_bridge = bridge_to_ptn3460(bridge);
0161     bool power_off;
0162     u8 *edid;
0163     int ret;
0164
0165     power_off = !ptn_bridge->enabled;
0166     ptn3460_pre_enable(&ptn_bridge->bridge);
0167
0168     edid = kmalloc(EDID_LENGTH, GFP_KERNEL);
0169     if (!edid) {
0170         DRM_ERROR("Failed to allocate EDID\n");
0171         goto out;
0172     }
0173
0174     ret = ptn3460_read_bytes(ptn_bridge, PTN3460_EDID_ADDR, edid,
0175                  EDID_LENGTH);
0176     if (ret) {
0177         kfree(edid);
0178         edid = NULL;
0179         goto out;
0180     }
0181
0182 out:
0183     if (power_off)
0184         ptn3460_disable(&ptn_bridge->bridge);
0185
0186     return (struct edid *)edid;
0187 }
0188
0189 static int ptn3460_connector_get_modes(struct drm_connector *connector)
0190 {
0191     struct ptn3460_bridge *ptn_bridge = connector_to_ptn3460(connector);
0192     struct edid *edid;
0193     int num_modes;
0194
0195     edid = ptn3460_get_edid(&ptn_bridge->bridge, connector);
0196     drm_connector_update_edid_property(connector, edid);
0197     num_modes = drm_add_edid_modes(connector, edid);
0198     kfree(edid);
0199
0200     return num_modes;
0201 }
0202
0203 static const struct drm_connector_helper_funcs ptn3460_connector_helper_funcs = {
0204     .get_modes = ptn3460_connector_get_modes,
0205 };
0206
0207 static const struct drm_connector_funcs ptn3460_connector_funcs = {
0208     .fill_modes = drm_helper_probe_single_connector_modes,
0209     .destroy = drm_connector_cleanup,
0210     .reset = drm_atomic_helper_connector_reset,
0211     .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
0212     .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
0213 };
0214
0215 static int ptn3460_bridge_attach(struct drm_bridge *bridge,
0216                  enum drm_bridge_attach_flags flags)
0217 {
0218     struct ptn3460_bridge *ptn_bridge = bridge_to_ptn3460(bridge);
0219     int ret;
0220
0221     /* Let this driver create connector if requested */
0222     ret = drm_bridge_attach(bridge->encoder, ptn_bridge->panel_bridge,
0223                 bridge, flags | DRM_BRIDGE_ATTACH_NO_CONNECTOR);
0224     if (ret < 0)
0225         return ret;
0226
0227     if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
0228         return 0;
0229
0230     if (!bridge->encoder) {
0231         DRM_ERROR("Parent encoder object not found");
0232         return -ENODEV;
0233     }
0234
0235     ptn_bridge->connector.polled = DRM_CONNECTOR_POLL_HPD;
0236     ret = drm_connector_init(bridge->dev, &ptn_bridge->connector,
0237             &ptn3460_connector_funcs, DRM_MODE_CONNECTOR_LVDS);
0238     if (ret) {
0239         DRM_ERROR("Failed to initialize connector with drm\n");
0240         return ret;
0241     }
0242     drm_connector_helper_add(&ptn_bridge->connector,
0243                     &ptn3460_connector_helper_funcs);
0244     drm_connector_register(&ptn_bridge->connector);
0245     drm_connector_attach_encoder(&ptn_bridge->connector,
0246                             bridge->encoder);
0247
0248     drm_helper_hpd_irq_event(ptn_bridge->connector.dev);
0249
0250     return ret;
0251 }
0252
0253 static const struct drm_bridge_funcs ptn3460_bridge_funcs = {
0254     .pre_enable = ptn3460_pre_enable,
0255     .disable = ptn3460_disable,
0256     .attach = ptn3460_bridge_attach,
0257     .get_edid = ptn3460_get_edid,
0258 };
0259
0260 static int ptn3460_probe(struct i2c_client *client,
0261                 const struct i2c_device_id *id)
0262 {
0263     struct device *dev = &client->dev;
0264     struct ptn3460_bridge *ptn_bridge;
0265     struct drm_bridge *panel_bridge;
0266     int ret;
0267
0268     ptn_bridge = devm_kzalloc(dev, sizeof(*ptn_bridge), GFP_KERNEL);
0269     if (!ptn_bridge) {
0270         return -ENOMEM;
0271     }
0272
0273     panel_bridge = devm_drm_of_get_bridge(dev, dev->of_node, 0, 0);
0274     if (IS_ERR(panel_bridge))
0275         return PTR_ERR(panel_bridge);
0276
0277     ptn_bridge->panel_bridge = panel_bridge;
0278     ptn_bridge->client = client;
0279
0280     ptn_bridge->gpio_pd_n = devm_gpiod_get(&client->dev, "powerdown",
0281                            GPIOD_OUT_HIGH);
0282     if (IS_ERR(ptn_bridge->gpio_pd_n)) {
0283         ret = PTR_ERR(ptn_bridge->gpio_pd_n);
0284         dev_err(dev, "cannot get gpio_pd_n %d\n", ret);
0285         return ret;
0286     }
0287
0288     /*
0289      * Request the reset pin low to avoid the bridge being
0290      * initialized prematurely
0291      */
0292     ptn_bridge->gpio_rst_n = devm_gpiod_get(&client->dev, "reset",
0293                         GPIOD_OUT_LOW);
0294     if (IS_ERR(ptn_bridge->gpio_rst_n)) {
0295         ret = PTR_ERR(ptn_bridge->gpio_rst_n);
0296         DRM_ERROR("cannot get gpio_rst_n %d\n", ret);
0297         return ret;
0298     }
0299
0300     ret = of_property_read_u32(dev->of_node, "edid-emulation",
0301             &ptn_bridge->edid_emulation);
0302     if (ret) {
0303         dev_err(dev, "Can't read EDID emulation value\n");
0304         return ret;
0305     }
0306
0307     ptn_bridge->bridge.funcs = &ptn3460_bridge_funcs;
0308     ptn_bridge->bridge.ops = DRM_BRIDGE_OP_EDID;
0309     ptn_bridge->bridge.type = DRM_MODE_CONNECTOR_LVDS;
0310     ptn_bridge->bridge.of_node = dev->of_node;
0311     drm_bridge_add(&ptn_bridge->bridge);
0312
0313     i2c_set_clientdata(client, ptn_bridge);
0314
0315     return 0;
0316 }
0317
0318 static int ptn3460_remove(struct i2c_client *client)
0319 {
0320     struct ptn3460_bridge *ptn_bridge = i2c_get_clientdata(client);
0321
0322     drm_bridge_remove(&ptn_bridge->bridge);
0323
0324     return 0;
0325 }
0326
0327 static const struct i2c_device_id ptn3460_i2c_table[] = {
0328     {"ptn3460", 0},
0329     {},
0330 };
0331 MODULE_DEVICE_TABLE(i2c, ptn3460_i2c_table);
0332
0333 static const struct of_device_id ptn3460_match[] = {
0334     { .compatible = "nxp,ptn3460" },
0335     {},
0336 };
0337 MODULE_DEVICE_TABLE(of, ptn3460_match);
0338
0339 static struct i2c_driver ptn3460_driver = {
0340     .id_table   = ptn3460_i2c_table,
0341     .probe      = ptn3460_probe,
0342     .remove     = ptn3460_remove,
0343     .driver     = {
0344         .name   = "nxp,ptn3460",
0345         .of_match_table = ptn3460_match,
0346     },
0347 };
0348 module_i2c_driver(ptn3460_driver);
0349
0350 MODULE_AUTHOR("Sean Paul <seanpaul@chromium.org>");
0351 MODULE_DESCRIPTION("NXP ptn3460 eDP-LVDS converter driver");
0352 MODULE_LICENSE("GPL v2");