Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 1 | /* |
| 2 | * NXP PTN3460 DP/LVDS bridge driver |
| 3 | * |
| 4 | * Copyright (C) 2013 Google, Inc. |
| 5 | * |
| 6 | * This software is licensed under the terms of the GNU General Public |
| 7 | * License version 2, as published by the Free Software Foundation, and |
| 8 | * may be copied, distributed, and modified under those terms. |
| 9 | * |
| 10 | * This program is distributed in the hope that it will be useful, |
| 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 13 | * GNU General Public License for more details. |
| 14 | */ |
| 15 | |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 16 | #include <linux/delay.h> |
| 17 | #include <linux/gpio.h> |
Geert Uytterhoeven | dad3c35 | 2015-05-05 18:32:17 +0200 | [diff] [blame^] | 18 | #include <linux/gpio/consumer.h> |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 19 | #include <linux/i2c.h> |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 20 | #include <linux/module.h> |
| 21 | #include <linux/of.h> |
| 22 | #include <linux/of_gpio.h> |
Ajay Kumar | 5bbb9a2 | 2015-01-20 22:08:47 +0530 | [diff] [blame] | 23 | #include <linux/of_graph.h> |
| 24 | |
| 25 | #include <drm/drm_panel.h> |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 26 | |
| 27 | #include "bridge/ptn3460.h" |
| 28 | |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 29 | #include "drm_crtc.h" |
| 30 | #include "drm_crtc_helper.h" |
| 31 | #include "drm_edid.h" |
| 32 | #include "drmP.h" |
| 33 | |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 34 | #define PTN3460_EDID_ADDR 0x0 |
| 35 | #define PTN3460_EDID_EMULATION_ADDR 0x84 |
| 36 | #define PTN3460_EDID_ENABLE_EMULATION 0 |
| 37 | #define PTN3460_EDID_EMULATION_SELECTION 1 |
| 38 | #define PTN3460_EDID_SRAM_LOAD_ADDR 0x85 |
| 39 | |
| 40 | struct ptn3460_bridge { |
| 41 | struct drm_connector connector; |
| 42 | struct i2c_client *client; |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 43 | struct drm_bridge bridge; |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 44 | struct edid *edid; |
Ajay Kumar | 5bbb9a2 | 2015-01-20 22:08:47 +0530 | [diff] [blame] | 45 | struct drm_panel *panel; |
Ajay Kumar | af478d8 | 2015-01-20 22:08:49 +0530 | [diff] [blame] | 46 | struct gpio_desc *gpio_pd_n; |
| 47 | struct gpio_desc *gpio_rst_n; |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 48 | u32 edid_emulation; |
| 49 | bool enabled; |
| 50 | }; |
| 51 | |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 52 | static inline struct ptn3460_bridge * |
| 53 | bridge_to_ptn3460(struct drm_bridge *bridge) |
| 54 | { |
| 55 | return container_of(bridge, struct ptn3460_bridge, bridge); |
| 56 | } |
| 57 | |
| 58 | static inline struct ptn3460_bridge * |
| 59 | connector_to_ptn3460(struct drm_connector *connector) |
| 60 | { |
| 61 | return container_of(connector, struct ptn3460_bridge, connector); |
| 62 | } |
| 63 | |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 64 | static int ptn3460_read_bytes(struct ptn3460_bridge *ptn_bridge, char addr, |
| 65 | u8 *buf, int len) |
| 66 | { |
| 67 | int ret; |
| 68 | |
| 69 | ret = i2c_master_send(ptn_bridge->client, &addr, 1); |
| 70 | if (ret <= 0) { |
| 71 | DRM_ERROR("Failed to send i2c command, ret=%d\n", ret); |
| 72 | return ret; |
| 73 | } |
| 74 | |
| 75 | ret = i2c_master_recv(ptn_bridge->client, buf, len); |
| 76 | if (ret <= 0) { |
| 77 | DRM_ERROR("Failed to recv i2c data, ret=%d\n", ret); |
| 78 | return ret; |
| 79 | } |
| 80 | |
| 81 | return 0; |
| 82 | } |
| 83 | |
| 84 | static int ptn3460_write_byte(struct ptn3460_bridge *ptn_bridge, char addr, |
| 85 | char val) |
| 86 | { |
| 87 | int ret; |
| 88 | char buf[2]; |
| 89 | |
| 90 | buf[0] = addr; |
| 91 | buf[1] = val; |
| 92 | |
| 93 | ret = i2c_master_send(ptn_bridge->client, buf, ARRAY_SIZE(buf)); |
| 94 | if (ret <= 0) { |
| 95 | DRM_ERROR("Failed to send i2c command, ret=%d\n", ret); |
| 96 | return ret; |
| 97 | } |
| 98 | |
| 99 | return 0; |
| 100 | } |
| 101 | |
| 102 | static int ptn3460_select_edid(struct ptn3460_bridge *ptn_bridge) |
| 103 | { |
| 104 | int ret; |
| 105 | char val; |
| 106 | |
| 107 | /* Load the selected edid into SRAM (accessed at PTN3460_EDID_ADDR) */ |
| 108 | ret = ptn3460_write_byte(ptn_bridge, PTN3460_EDID_SRAM_LOAD_ADDR, |
| 109 | ptn_bridge->edid_emulation); |
| 110 | if (ret) { |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 111 | DRM_ERROR("Failed to transfer EDID to sram, ret=%d\n", ret); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 112 | return ret; |
| 113 | } |
| 114 | |
| 115 | /* Enable EDID emulation and select the desired EDID */ |
| 116 | val = 1 << PTN3460_EDID_ENABLE_EMULATION | |
| 117 | ptn_bridge->edid_emulation << PTN3460_EDID_EMULATION_SELECTION; |
| 118 | |
| 119 | ret = ptn3460_write_byte(ptn_bridge, PTN3460_EDID_EMULATION_ADDR, val); |
| 120 | if (ret) { |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 121 | DRM_ERROR("Failed to write EDID value, ret=%d\n", ret); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 122 | return ret; |
| 123 | } |
| 124 | |
| 125 | return 0; |
| 126 | } |
| 127 | |
| 128 | static void ptn3460_pre_enable(struct drm_bridge *bridge) |
| 129 | { |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 130 | struct ptn3460_bridge *ptn_bridge = bridge_to_ptn3460(bridge); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 131 | int ret; |
| 132 | |
| 133 | if (ptn_bridge->enabled) |
| 134 | return; |
| 135 | |
Ajay Kumar | af478d8 | 2015-01-20 22:08:49 +0530 | [diff] [blame] | 136 | gpiod_set_value(ptn_bridge->gpio_pd_n, 1); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 137 | |
Ajay Kumar | af478d8 | 2015-01-20 22:08:49 +0530 | [diff] [blame] | 138 | gpiod_set_value(ptn_bridge->gpio_rst_n, 0); |
| 139 | usleep_range(10, 20); |
| 140 | gpiod_set_value(ptn_bridge->gpio_rst_n, 1); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 141 | |
Ajay Kumar | 5bbb9a2 | 2015-01-20 22:08:47 +0530 | [diff] [blame] | 142 | if (drm_panel_prepare(ptn_bridge->panel)) { |
| 143 | DRM_ERROR("failed to prepare panel\n"); |
| 144 | return; |
| 145 | } |
| 146 | |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 147 | /* |
| 148 | * There's a bug in the PTN chip where it falsely asserts hotplug before |
| 149 | * it is fully functional. We're forced to wait for the maximum start up |
| 150 | * time specified in the chip's datasheet to make sure we're really up. |
| 151 | */ |
| 152 | msleep(90); |
| 153 | |
| 154 | ret = ptn3460_select_edid(ptn_bridge); |
| 155 | if (ret) |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 156 | DRM_ERROR("Select EDID failed ret=%d\n", ret); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 157 | |
| 158 | ptn_bridge->enabled = true; |
| 159 | } |
| 160 | |
| 161 | static void ptn3460_enable(struct drm_bridge *bridge) |
| 162 | { |
Ajay Kumar | 5bbb9a2 | 2015-01-20 22:08:47 +0530 | [diff] [blame] | 163 | struct ptn3460_bridge *ptn_bridge = bridge_to_ptn3460(bridge); |
| 164 | |
| 165 | if (drm_panel_enable(ptn_bridge->panel)) { |
| 166 | DRM_ERROR("failed to enable panel\n"); |
| 167 | return; |
| 168 | } |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 169 | } |
| 170 | |
| 171 | static void ptn3460_disable(struct drm_bridge *bridge) |
| 172 | { |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 173 | struct ptn3460_bridge *ptn_bridge = bridge_to_ptn3460(bridge); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 174 | |
| 175 | if (!ptn_bridge->enabled) |
| 176 | return; |
| 177 | |
| 178 | ptn_bridge->enabled = false; |
| 179 | |
Ajay Kumar | 5bbb9a2 | 2015-01-20 22:08:47 +0530 | [diff] [blame] | 180 | if (drm_panel_disable(ptn_bridge->panel)) { |
| 181 | DRM_ERROR("failed to disable panel\n"); |
| 182 | return; |
| 183 | } |
| 184 | |
Ajay Kumar | af478d8 | 2015-01-20 22:08:49 +0530 | [diff] [blame] | 185 | gpiod_set_value(ptn_bridge->gpio_rst_n, 1); |
| 186 | gpiod_set_value(ptn_bridge->gpio_pd_n, 0); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 187 | } |
| 188 | |
| 189 | static void ptn3460_post_disable(struct drm_bridge *bridge) |
| 190 | { |
Ajay Kumar | 5bbb9a2 | 2015-01-20 22:08:47 +0530 | [diff] [blame] | 191 | struct ptn3460_bridge *ptn_bridge = bridge_to_ptn3460(bridge); |
| 192 | |
| 193 | if (drm_panel_unprepare(ptn_bridge->panel)) { |
| 194 | DRM_ERROR("failed to unprepare panel\n"); |
| 195 | return; |
| 196 | } |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 197 | } |
| 198 | |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 199 | static int ptn3460_get_modes(struct drm_connector *connector) |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 200 | { |
| 201 | struct ptn3460_bridge *ptn_bridge; |
| 202 | u8 *edid; |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 203 | int ret, num_modes = 0; |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 204 | bool power_off; |
| 205 | |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 206 | ptn_bridge = connector_to_ptn3460(connector); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 207 | |
| 208 | if (ptn_bridge->edid) |
| 209 | return drm_add_edid_modes(connector, ptn_bridge->edid); |
| 210 | |
| 211 | power_off = !ptn_bridge->enabled; |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 212 | ptn3460_pre_enable(&ptn_bridge->bridge); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 213 | |
| 214 | edid = kmalloc(EDID_LENGTH, GFP_KERNEL); |
| 215 | if (!edid) { |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 216 | DRM_ERROR("Failed to allocate EDID\n"); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 217 | return 0; |
| 218 | } |
| 219 | |
| 220 | ret = ptn3460_read_bytes(ptn_bridge, PTN3460_EDID_ADDR, edid, |
| 221 | EDID_LENGTH); |
| 222 | if (ret) { |
| 223 | kfree(edid); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 224 | goto out; |
| 225 | } |
| 226 | |
| 227 | ptn_bridge->edid = (struct edid *)edid; |
| 228 | drm_mode_connector_update_edid_property(connector, ptn_bridge->edid); |
| 229 | |
| 230 | num_modes = drm_add_edid_modes(connector, ptn_bridge->edid); |
| 231 | |
| 232 | out: |
| 233 | if (power_off) |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 234 | ptn3460_disable(&ptn_bridge->bridge); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 235 | |
| 236 | return num_modes; |
| 237 | } |
| 238 | |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 239 | static struct drm_encoder *ptn3460_best_encoder(struct drm_connector *connector) |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 240 | { |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 241 | struct ptn3460_bridge *ptn_bridge = connector_to_ptn3460(connector); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 242 | |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 243 | return ptn_bridge->bridge.encoder; |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 244 | } |
| 245 | |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 246 | static struct drm_connector_helper_funcs ptn3460_connector_helper_funcs = { |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 247 | .get_modes = ptn3460_get_modes, |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 248 | .best_encoder = ptn3460_best_encoder, |
| 249 | }; |
| 250 | |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 251 | static enum drm_connector_status ptn3460_detect(struct drm_connector *connector, |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 252 | bool force) |
| 253 | { |
| 254 | return connector_status_connected; |
| 255 | } |
| 256 | |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 257 | static void ptn3460_connector_destroy(struct drm_connector *connector) |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 258 | { |
| 259 | drm_connector_cleanup(connector); |
| 260 | } |
| 261 | |
Ajay Kumar | 94d50d5 | 2015-01-20 22:08:42 +0530 | [diff] [blame] | 262 | static struct drm_connector_funcs ptn3460_connector_funcs = { |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 263 | .dpms = drm_helper_connector_dpms, |
| 264 | .fill_modes = drm_helper_probe_single_connector_modes, |
| 265 | .detect = ptn3460_detect, |
| 266 | .destroy = ptn3460_connector_destroy, |
| 267 | }; |
| 268 | |
Thierry Reding | df1d306 | 2015-01-30 12:33:58 +0100 | [diff] [blame] | 269 | static int ptn3460_bridge_attach(struct drm_bridge *bridge) |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 270 | { |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 271 | struct ptn3460_bridge *ptn_bridge = bridge_to_ptn3460(bridge); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 272 | int ret; |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 273 | |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 274 | if (!bridge->encoder) { |
| 275 | DRM_ERROR("Parent encoder object not found"); |
| 276 | return -ENODEV; |
| 277 | } |
| 278 | |
Ajay Kumar | a189995 | 2015-01-20 22:08:48 +0530 | [diff] [blame] | 279 | ptn_bridge->connector.polled = DRM_CONNECTOR_POLL_HPD; |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 280 | ret = drm_connector_init(bridge->dev, &ptn_bridge->connector, |
| 281 | &ptn3460_connector_funcs, DRM_MODE_CONNECTOR_LVDS); |
| 282 | if (ret) { |
| 283 | DRM_ERROR("Failed to initialize connector with drm\n"); |
| 284 | return ret; |
| 285 | } |
| 286 | drm_connector_helper_add(&ptn_bridge->connector, |
| 287 | &ptn3460_connector_helper_funcs); |
| 288 | drm_connector_register(&ptn_bridge->connector); |
| 289 | drm_mode_connector_attach_encoder(&ptn_bridge->connector, |
| 290 | bridge->encoder); |
| 291 | |
Ajay Kumar | 5bbb9a2 | 2015-01-20 22:08:47 +0530 | [diff] [blame] | 292 | if (ptn_bridge->panel) |
| 293 | drm_panel_attach(ptn_bridge->panel, &ptn_bridge->connector); |
| 294 | |
Ajay Kumar | a189995 | 2015-01-20 22:08:48 +0530 | [diff] [blame] | 295 | drm_helper_hpd_irq_event(ptn_bridge->connector.dev); |
| 296 | |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 297 | return ret; |
| 298 | } |
| 299 | |
| 300 | static struct drm_bridge_funcs ptn3460_bridge_funcs = { |
| 301 | .pre_enable = ptn3460_pre_enable, |
| 302 | .enable = ptn3460_enable, |
| 303 | .disable = ptn3460_disable, |
| 304 | .post_disable = ptn3460_post_disable, |
| 305 | .attach = ptn3460_bridge_attach, |
| 306 | }; |
| 307 | |
| 308 | static int ptn3460_probe(struct i2c_client *client, |
| 309 | const struct i2c_device_id *id) |
| 310 | { |
| 311 | struct device *dev = &client->dev; |
| 312 | struct ptn3460_bridge *ptn_bridge; |
Ajay Kumar | 5bbb9a2 | 2015-01-20 22:08:47 +0530 | [diff] [blame] | 313 | struct device_node *endpoint, *panel_node; |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 314 | int ret; |
| 315 | |
| 316 | ptn_bridge = devm_kzalloc(dev, sizeof(*ptn_bridge), GFP_KERNEL); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 317 | if (!ptn_bridge) { |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 318 | return -ENOMEM; |
| 319 | } |
| 320 | |
Ajay Kumar | 5bbb9a2 | 2015-01-20 22:08:47 +0530 | [diff] [blame] | 321 | endpoint = of_graph_get_next_endpoint(dev->of_node, NULL); |
| 322 | if (endpoint) { |
| 323 | panel_node = of_graph_get_remote_port_parent(endpoint); |
| 324 | if (panel_node) { |
| 325 | ptn_bridge->panel = of_drm_find_panel(panel_node); |
| 326 | of_node_put(panel_node); |
| 327 | if (!ptn_bridge->panel) |
| 328 | return -EPROBE_DEFER; |
| 329 | } |
| 330 | } |
| 331 | |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 332 | ptn_bridge->client = client; |
Ajay Kumar | af478d8 | 2015-01-20 22:08:49 +0530 | [diff] [blame] | 333 | |
Uwe Kleine-König | c06ea0a | 2015-05-19 09:15:56 +0200 | [diff] [blame] | 334 | ptn_bridge->gpio_pd_n = devm_gpiod_get(&client->dev, "powerdown", |
| 335 | GPIOD_OUT_HIGH); |
Ajay Kumar | af478d8 | 2015-01-20 22:08:49 +0530 | [diff] [blame] | 336 | if (IS_ERR(ptn_bridge->gpio_pd_n)) { |
| 337 | ret = PTR_ERR(ptn_bridge->gpio_pd_n); |
| 338 | dev_err(dev, "cannot get gpio_pd_n %d\n", ret); |
| 339 | return ret; |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 340 | } |
| 341 | |
Ajay Kumar | af478d8 | 2015-01-20 22:08:49 +0530 | [diff] [blame] | 342 | /* |
| 343 | * Request the reset pin low to avoid the bridge being |
| 344 | * initialized prematurely |
| 345 | */ |
Uwe Kleine-König | c06ea0a | 2015-05-19 09:15:56 +0200 | [diff] [blame] | 346 | ptn_bridge->gpio_rst_n = devm_gpiod_get(&client->dev, "reset", |
| 347 | GPIOD_OUT_LOW); |
| 348 | if (IS_ERR(ptn_bridge->gpio_rst_n)) { |
| 349 | ret = PTR_ERR(ptn_bridge->gpio_rst_n); |
| 350 | DRM_ERROR("cannot get gpio_rst_n %d\n", ret); |
Ajay Kumar | af478d8 | 2015-01-20 22:08:49 +0530 | [diff] [blame] | 351 | return ret; |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 352 | } |
| 353 | |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 354 | ret = of_property_read_u32(dev->of_node, "edid-emulation", |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 355 | &ptn_bridge->edid_emulation); |
| 356 | if (ret) { |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 357 | dev_err(dev, "Can't read EDID emulation value\n"); |
Ajay Kumar | af478d8 | 2015-01-20 22:08:49 +0530 | [diff] [blame] | 358 | return ret; |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 359 | } |
| 360 | |
Ajay Kumar | b07b90f | 2015-01-20 22:08:43 +0530 | [diff] [blame] | 361 | ptn_bridge->bridge.funcs = &ptn3460_bridge_funcs; |
Ajay Kumar | 5bbb9a2 | 2015-01-20 22:08:47 +0530 | [diff] [blame] | 362 | ptn_bridge->bridge.of_node = dev->of_node; |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 363 | ret = drm_bridge_add(&ptn_bridge->bridge); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 364 | if (ret) { |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 365 | DRM_ERROR("Failed to add bridge\n"); |
Ajay Kumar | af478d8 | 2015-01-20 22:08:49 +0530 | [diff] [blame] | 366 | return ret; |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 367 | } |
| 368 | |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 369 | i2c_set_clientdata(client, ptn_bridge); |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 370 | |
| 371 | return 0; |
Sean Paul | a9fe713 | 2014-02-24 19:31:24 +0900 | [diff] [blame] | 372 | } |
Ajay Kumar | 3d3f8b1 | 2015-01-20 22:08:44 +0530 | [diff] [blame] | 373 | |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 374 | static int ptn3460_remove(struct i2c_client *client) |
Ajay Kumar | 3d3f8b1 | 2015-01-20 22:08:44 +0530 | [diff] [blame] | 375 | { |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 376 | struct ptn3460_bridge *ptn_bridge = i2c_get_clientdata(client); |
| 377 | |
| 378 | drm_bridge_remove(&ptn_bridge->bridge); |
Ajay Kumar | 3d3f8b1 | 2015-01-20 22:08:44 +0530 | [diff] [blame] | 379 | |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 380 | return 0; |
Ajay Kumar | 3d3f8b1 | 2015-01-20 22:08:44 +0530 | [diff] [blame] | 381 | } |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 382 | |
| 383 | static const struct i2c_device_id ptn3460_i2c_table[] = { |
Javier Martinez Canillas | 394e5b6 | 2015-05-14 16:31:29 +0200 | [diff] [blame] | 384 | {"ptn3460", 0}, |
Ajay Kumar | 6a1688a | 2015-01-20 22:08:45 +0530 | [diff] [blame] | 385 | {}, |
| 386 | }; |
| 387 | MODULE_DEVICE_TABLE(i2c, ptn3460_i2c_table); |
| 388 | |
| 389 | static const struct of_device_id ptn3460_match[] = { |
| 390 | { .compatible = "nxp,ptn3460" }, |
| 391 | {}, |
| 392 | }; |
| 393 | MODULE_DEVICE_TABLE(of, ptn3460_match); |
| 394 | |
| 395 | static struct i2c_driver ptn3460_driver = { |
| 396 | .id_table = ptn3460_i2c_table, |
| 397 | .probe = ptn3460_probe, |
| 398 | .remove = ptn3460_remove, |
| 399 | .driver = { |
| 400 | .name = "nxp,ptn3460", |
| 401 | .owner = THIS_MODULE, |
| 402 | .of_match_table = ptn3460_match, |
| 403 | }, |
| 404 | }; |
| 405 | module_i2c_driver(ptn3460_driver); |
| 406 | |
| 407 | MODULE_AUTHOR("Sean Paul <seanpaul@chromium.org>"); |
| 408 | MODULE_DESCRIPTION("NXP ptn3460 eDP-LVDS converter driver"); |
| 409 | MODULE_LICENSE("GPL v2"); |