2 * NXP PTN3460 DP/LVDS bridge driver
4 * Copyright (C) 2013 Google, Inc.
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.
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.
16 #include <linux/delay.h>
17 #include <linux/gpio.h>
18 #include <linux/gpio/consumer.h>
19 #include <linux/i2c.h>
20 #include <linux/module.h>
22 #include <linux/of_gpio.h>
23 #include <linux/of_graph.h>
25 #include <drm/drm_panel.h>
28 #include "drm_crtc_helper.h"
32 #define PTN3460_EDID_ADDR 0x0
33 #define PTN3460_EDID_EMULATION_ADDR 0x84
34 #define PTN3460_EDID_ENABLE_EMULATION 0
35 #define PTN3460_EDID_EMULATION_SELECTION 1
36 #define PTN3460_EDID_SRAM_LOAD_ADDR 0x85
38 struct ptn3460_bridge
{
39 struct drm_connector connector
;
40 struct i2c_client
*client
;
41 struct drm_bridge bridge
;
43 struct drm_panel
*panel
;
44 struct gpio_desc
*gpio_pd_n
;
45 struct gpio_desc
*gpio_rst_n
;
50 static inline struct ptn3460_bridge
*
51 bridge_to_ptn3460(struct drm_bridge
*bridge
)
53 return container_of(bridge
, struct ptn3460_bridge
, bridge
);
56 static inline struct ptn3460_bridge
*
57 connector_to_ptn3460(struct drm_connector
*connector
)
59 return container_of(connector
, struct ptn3460_bridge
, connector
);
62 static int ptn3460_read_bytes(struct ptn3460_bridge
*ptn_bridge
, char addr
,
67 ret
= i2c_master_send(ptn_bridge
->client
, &addr
, 1);
69 DRM_ERROR("Failed to send i2c command, ret=%d\n", ret
);
73 ret
= i2c_master_recv(ptn_bridge
->client
, buf
, len
);
75 DRM_ERROR("Failed to recv i2c data, ret=%d\n", ret
);
82 static int ptn3460_write_byte(struct ptn3460_bridge
*ptn_bridge
, char addr
,
91 ret
= i2c_master_send(ptn_bridge
->client
, buf
, ARRAY_SIZE(buf
));
93 DRM_ERROR("Failed to send i2c command, ret=%d\n", ret
);
100 static int ptn3460_select_edid(struct ptn3460_bridge
*ptn_bridge
)
105 /* Load the selected edid into SRAM (accessed at PTN3460_EDID_ADDR) */
106 ret
= ptn3460_write_byte(ptn_bridge
, PTN3460_EDID_SRAM_LOAD_ADDR
,
107 ptn_bridge
->edid_emulation
);
109 DRM_ERROR("Failed to transfer EDID to sram, ret=%d\n", ret
);
113 /* Enable EDID emulation and select the desired EDID */
114 val
= 1 << PTN3460_EDID_ENABLE_EMULATION
|
115 ptn_bridge
->edid_emulation
<< PTN3460_EDID_EMULATION_SELECTION
;
117 ret
= ptn3460_write_byte(ptn_bridge
, PTN3460_EDID_EMULATION_ADDR
, val
);
119 DRM_ERROR("Failed to write EDID value, ret=%d\n", ret
);
126 static void ptn3460_pre_enable(struct drm_bridge
*bridge
)
128 struct ptn3460_bridge
*ptn_bridge
= bridge_to_ptn3460(bridge
);
131 if (ptn_bridge
->enabled
)
134 gpiod_set_value(ptn_bridge
->gpio_pd_n
, 1);
136 gpiod_set_value(ptn_bridge
->gpio_rst_n
, 0);
137 usleep_range(10, 20);
138 gpiod_set_value(ptn_bridge
->gpio_rst_n
, 1);
140 if (drm_panel_prepare(ptn_bridge
->panel
)) {
141 DRM_ERROR("failed to prepare panel\n");
146 * There's a bug in the PTN chip where it falsely asserts hotplug before
147 * it is fully functional. We're forced to wait for the maximum start up
148 * time specified in the chip's datasheet to make sure we're really up.
152 ret
= ptn3460_select_edid(ptn_bridge
);
154 DRM_ERROR("Select EDID failed ret=%d\n", ret
);
156 ptn_bridge
->enabled
= true;
159 static void ptn3460_enable(struct drm_bridge
*bridge
)
161 struct ptn3460_bridge
*ptn_bridge
= bridge_to_ptn3460(bridge
);
163 if (drm_panel_enable(ptn_bridge
->panel
)) {
164 DRM_ERROR("failed to enable panel\n");
169 static void ptn3460_disable(struct drm_bridge
*bridge
)
171 struct ptn3460_bridge
*ptn_bridge
= bridge_to_ptn3460(bridge
);
173 if (!ptn_bridge
->enabled
)
176 ptn_bridge
->enabled
= false;
178 if (drm_panel_disable(ptn_bridge
->panel
)) {
179 DRM_ERROR("failed to disable panel\n");
183 gpiod_set_value(ptn_bridge
->gpio_rst_n
, 1);
184 gpiod_set_value(ptn_bridge
->gpio_pd_n
, 0);
187 static void ptn3460_post_disable(struct drm_bridge
*bridge
)
189 struct ptn3460_bridge
*ptn_bridge
= bridge_to_ptn3460(bridge
);
191 if (drm_panel_unprepare(ptn_bridge
->panel
)) {
192 DRM_ERROR("failed to unprepare panel\n");
197 static int ptn3460_get_modes(struct drm_connector
*connector
)
199 struct ptn3460_bridge
*ptn_bridge
;
201 int ret
, num_modes
= 0;
204 ptn_bridge
= connector_to_ptn3460(connector
);
206 if (ptn_bridge
->edid
)
207 return drm_add_edid_modes(connector
, ptn_bridge
->edid
);
209 power_off
= !ptn_bridge
->enabled
;
210 ptn3460_pre_enable(&ptn_bridge
->bridge
);
212 edid
= kmalloc(EDID_LENGTH
, GFP_KERNEL
);
214 DRM_ERROR("Failed to allocate EDID\n");
218 ret
= ptn3460_read_bytes(ptn_bridge
, PTN3460_EDID_ADDR
, edid
,
225 ptn_bridge
->edid
= (struct edid
*)edid
;
226 drm_mode_connector_update_edid_property(connector
, ptn_bridge
->edid
);
228 num_modes
= drm_add_edid_modes(connector
, ptn_bridge
->edid
);
232 ptn3460_disable(&ptn_bridge
->bridge
);
237 static struct drm_encoder
*ptn3460_best_encoder(struct drm_connector
*connector
)
239 struct ptn3460_bridge
*ptn_bridge
= connector_to_ptn3460(connector
);
241 return ptn_bridge
->bridge
.encoder
;
244 static struct drm_connector_helper_funcs ptn3460_connector_helper_funcs
= {
245 .get_modes
= ptn3460_get_modes
,
246 .best_encoder
= ptn3460_best_encoder
,
249 static enum drm_connector_status
ptn3460_detect(struct drm_connector
*connector
,
252 return connector_status_connected
;
255 static void ptn3460_connector_destroy(struct drm_connector
*connector
)
257 drm_connector_cleanup(connector
);
260 static struct drm_connector_funcs ptn3460_connector_funcs
= {
261 .dpms
= drm_helper_connector_dpms
,
262 .fill_modes
= drm_helper_probe_single_connector_modes
,
263 .detect
= ptn3460_detect
,
264 .destroy
= ptn3460_connector_destroy
,
267 static int ptn3460_bridge_attach(struct drm_bridge
*bridge
)
269 struct ptn3460_bridge
*ptn_bridge
= bridge_to_ptn3460(bridge
);
272 if (!bridge
->encoder
) {
273 DRM_ERROR("Parent encoder object not found");
277 ptn_bridge
->connector
.polled
= DRM_CONNECTOR_POLL_HPD
;
278 ret
= drm_connector_init(bridge
->dev
, &ptn_bridge
->connector
,
279 &ptn3460_connector_funcs
, DRM_MODE_CONNECTOR_LVDS
);
281 DRM_ERROR("Failed to initialize connector with drm\n");
284 drm_connector_helper_add(&ptn_bridge
->connector
,
285 &ptn3460_connector_helper_funcs
);
286 drm_connector_register(&ptn_bridge
->connector
);
287 drm_mode_connector_attach_encoder(&ptn_bridge
->connector
,
290 if (ptn_bridge
->panel
)
291 drm_panel_attach(ptn_bridge
->panel
, &ptn_bridge
->connector
);
293 drm_helper_hpd_irq_event(ptn_bridge
->connector
.dev
);
298 static struct drm_bridge_funcs ptn3460_bridge_funcs
= {
299 .pre_enable
= ptn3460_pre_enable
,
300 .enable
= ptn3460_enable
,
301 .disable
= ptn3460_disable
,
302 .post_disable
= ptn3460_post_disable
,
303 .attach
= ptn3460_bridge_attach
,
306 static int ptn3460_probe(struct i2c_client
*client
,
307 const struct i2c_device_id
*id
)
309 struct device
*dev
= &client
->dev
;
310 struct ptn3460_bridge
*ptn_bridge
;
311 struct device_node
*endpoint
, *panel_node
;
314 ptn_bridge
= devm_kzalloc(dev
, sizeof(*ptn_bridge
), GFP_KERNEL
);
319 endpoint
= of_graph_get_next_endpoint(dev
->of_node
, NULL
);
321 panel_node
= of_graph_get_remote_port_parent(endpoint
);
323 ptn_bridge
->panel
= of_drm_find_panel(panel_node
);
324 of_node_put(panel_node
);
325 if (!ptn_bridge
->panel
)
326 return -EPROBE_DEFER
;
330 ptn_bridge
->client
= client
;
332 ptn_bridge
->gpio_pd_n
= devm_gpiod_get(&client
->dev
, "powerdown",
334 if (IS_ERR(ptn_bridge
->gpio_pd_n
)) {
335 ret
= PTR_ERR(ptn_bridge
->gpio_pd_n
);
336 dev_err(dev
, "cannot get gpio_pd_n %d\n", ret
);
341 * Request the reset pin low to avoid the bridge being
342 * initialized prematurely
344 ptn_bridge
->gpio_rst_n
= devm_gpiod_get(&client
->dev
, "reset",
346 if (IS_ERR(ptn_bridge
->gpio_rst_n
)) {
347 ret
= PTR_ERR(ptn_bridge
->gpio_rst_n
);
348 DRM_ERROR("cannot get gpio_rst_n %d\n", ret
);
352 ret
= of_property_read_u32(dev
->of_node
, "edid-emulation",
353 &ptn_bridge
->edid_emulation
);
355 dev_err(dev
, "Can't read EDID emulation value\n");
359 ptn_bridge
->bridge
.funcs
= &ptn3460_bridge_funcs
;
360 ptn_bridge
->bridge
.of_node
= dev
->of_node
;
361 ret
= drm_bridge_add(&ptn_bridge
->bridge
);
363 DRM_ERROR("Failed to add bridge\n");
367 i2c_set_clientdata(client
, ptn_bridge
);
372 static int ptn3460_remove(struct i2c_client
*client
)
374 struct ptn3460_bridge
*ptn_bridge
= i2c_get_clientdata(client
);
376 drm_bridge_remove(&ptn_bridge
->bridge
);
381 static const struct i2c_device_id ptn3460_i2c_table
[] = {
385 MODULE_DEVICE_TABLE(i2c
, ptn3460_i2c_table
);
387 static const struct of_device_id ptn3460_match
[] = {
388 { .compatible
= "nxp,ptn3460" },
391 MODULE_DEVICE_TABLE(of
, ptn3460_match
);
393 static struct i2c_driver ptn3460_driver
= {
394 .id_table
= ptn3460_i2c_table
,
395 .probe
= ptn3460_probe
,
396 .remove
= ptn3460_remove
,
398 .name
= "nxp,ptn3460",
399 .owner
= THIS_MODULE
,
400 .of_match_table
= ptn3460_match
,
403 module_i2c_driver(ptn3460_driver
);
405 MODULE_AUTHOR("Sean Paul <seanpaul@chromium.org>");
406 MODULE_DESCRIPTION("NXP ptn3460 eDP-LVDS converter driver");
407 MODULE_LICENSE("GPL v2");