Loading...
Note: File does not exist in v4.6.
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
16#include <linux/module.h>
17#include <linux/of.h>
18#include <linux/of_gpio.h>
19#include <linux/i2c.h>
20#include <linux/gpio.h>
21#include <linux/delay.h>
22
23#include "drmP.h"
24#include "drm_edid.h"
25#include "drm_crtc.h"
26#include "drm_crtc_helper.h"
27
28#include "bridge/ptn3460.h"
29
30#define PTN3460_EDID_ADDR 0x0
31#define PTN3460_EDID_EMULATION_ADDR 0x84
32#define PTN3460_EDID_ENABLE_EMULATION 0
33#define PTN3460_EDID_EMULATION_SELECTION 1
34#define PTN3460_EDID_SRAM_LOAD_ADDR 0x85
35
36struct ptn3460_bridge {
37 struct drm_connector connector;
38 struct i2c_client *client;
39 struct drm_encoder *encoder;
40 struct drm_bridge *bridge;
41 struct edid *edid;
42 int gpio_pd_n;
43 int gpio_rst_n;
44 u32 edid_emulation;
45 bool enabled;
46};
47
48static int ptn3460_read_bytes(struct ptn3460_bridge *ptn_bridge, char addr,
49 u8 *buf, int len)
50{
51 int ret;
52
53 ret = i2c_master_send(ptn_bridge->client, &addr, 1);
54 if (ret <= 0) {
55 DRM_ERROR("Failed to send i2c command, ret=%d\n", ret);
56 return ret;
57 }
58
59 ret = i2c_master_recv(ptn_bridge->client, buf, len);
60 if (ret <= 0) {
61 DRM_ERROR("Failed to recv i2c data, ret=%d\n", ret);
62 return ret;
63 }
64
65 return 0;
66}
67
68static int ptn3460_write_byte(struct ptn3460_bridge *ptn_bridge, char addr,
69 char val)
70{
71 int ret;
72 char buf[2];
73
74 buf[0] = addr;
75 buf[1] = val;
76
77 ret = i2c_master_send(ptn_bridge->client, buf, ARRAY_SIZE(buf));
78 if (ret <= 0) {
79 DRM_ERROR("Failed to send i2c command, ret=%d\n", ret);
80 return ret;
81 }
82
83 return 0;
84}
85
86static int ptn3460_select_edid(struct ptn3460_bridge *ptn_bridge)
87{
88 int ret;
89 char val;
90
91 /* Load the selected edid into SRAM (accessed at PTN3460_EDID_ADDR) */
92 ret = ptn3460_write_byte(ptn_bridge, PTN3460_EDID_SRAM_LOAD_ADDR,
93 ptn_bridge->edid_emulation);
94 if (ret) {
95 DRM_ERROR("Failed to transfer edid to sram, ret=%d\n", ret);
96 return ret;
97 }
98
99 /* Enable EDID emulation and select the desired EDID */
100 val = 1 << PTN3460_EDID_ENABLE_EMULATION |
101 ptn_bridge->edid_emulation << PTN3460_EDID_EMULATION_SELECTION;
102
103 ret = ptn3460_write_byte(ptn_bridge, PTN3460_EDID_EMULATION_ADDR, val);
104 if (ret) {
105 DRM_ERROR("Failed to write edid value, ret=%d\n", ret);
106 return ret;
107 }
108
109 return 0;
110}
111
112static void ptn3460_pre_enable(struct drm_bridge *bridge)
113{
114 struct ptn3460_bridge *ptn_bridge = bridge->driver_private;
115 int ret;
116
117 if (ptn_bridge->enabled)
118 return;
119
120 if (gpio_is_valid(ptn_bridge->gpio_pd_n))
121 gpio_set_value(ptn_bridge->gpio_pd_n, 1);
122
123 if (gpio_is_valid(ptn_bridge->gpio_rst_n)) {
124 gpio_set_value(ptn_bridge->gpio_rst_n, 0);
125 udelay(10);
126 gpio_set_value(ptn_bridge->gpio_rst_n, 1);
127 }
128
129 /*
130 * There's a bug in the PTN chip where it falsely asserts hotplug before
131 * it is fully functional. We're forced to wait for the maximum start up
132 * time specified in the chip's datasheet to make sure we're really up.
133 */
134 msleep(90);
135
136 ret = ptn3460_select_edid(ptn_bridge);
137 if (ret)
138 DRM_ERROR("Select edid failed ret=%d\n", ret);
139
140 ptn_bridge->enabled = true;
141}
142
143static void ptn3460_enable(struct drm_bridge *bridge)
144{
145}
146
147static void ptn3460_disable(struct drm_bridge *bridge)
148{
149 struct ptn3460_bridge *ptn_bridge = bridge->driver_private;
150
151 if (!ptn_bridge->enabled)
152 return;
153
154 ptn_bridge->enabled = false;
155
156 if (gpio_is_valid(ptn_bridge->gpio_rst_n))
157 gpio_set_value(ptn_bridge->gpio_rst_n, 1);
158
159 if (gpio_is_valid(ptn_bridge->gpio_pd_n))
160 gpio_set_value(ptn_bridge->gpio_pd_n, 0);
161}
162
163static void ptn3460_post_disable(struct drm_bridge *bridge)
164{
165}
166
167void ptn3460_bridge_destroy(struct drm_bridge *bridge)
168{
169 struct ptn3460_bridge *ptn_bridge = bridge->driver_private;
170
171 drm_bridge_cleanup(bridge);
172 if (gpio_is_valid(ptn_bridge->gpio_pd_n))
173 gpio_free(ptn_bridge->gpio_pd_n);
174 if (gpio_is_valid(ptn_bridge->gpio_rst_n))
175 gpio_free(ptn_bridge->gpio_rst_n);
176 /* Nothing else to free, we've got devm allocated memory */
177}
178
179struct drm_bridge_funcs ptn3460_bridge_funcs = {
180 .pre_enable = ptn3460_pre_enable,
181 .enable = ptn3460_enable,
182 .disable = ptn3460_disable,
183 .post_disable = ptn3460_post_disable,
184 .destroy = ptn3460_bridge_destroy,
185};
186
187int ptn3460_get_modes(struct drm_connector *connector)
188{
189 struct ptn3460_bridge *ptn_bridge;
190 u8 *edid;
191 int ret, num_modes;
192 bool power_off;
193
194 ptn_bridge = container_of(connector, struct ptn3460_bridge, connector);
195
196 if (ptn_bridge->edid)
197 return drm_add_edid_modes(connector, ptn_bridge->edid);
198
199 power_off = !ptn_bridge->enabled;
200 ptn3460_pre_enable(ptn_bridge->bridge);
201
202 edid = kmalloc(EDID_LENGTH, GFP_KERNEL);
203 if (!edid) {
204 DRM_ERROR("Failed to allocate edid\n");
205 return 0;
206 }
207
208 ret = ptn3460_read_bytes(ptn_bridge, PTN3460_EDID_ADDR, edid,
209 EDID_LENGTH);
210 if (ret) {
211 kfree(edid);
212 num_modes = 0;
213 goto out;
214 }
215
216 ptn_bridge->edid = (struct edid *)edid;
217 drm_mode_connector_update_edid_property(connector, ptn_bridge->edid);
218
219 num_modes = drm_add_edid_modes(connector, ptn_bridge->edid);
220
221out:
222 if (power_off)
223 ptn3460_disable(ptn_bridge->bridge);
224
225 return num_modes;
226}
227
228static int ptn3460_mode_valid(struct drm_connector *connector,
229 struct drm_display_mode *mode)
230{
231 return MODE_OK;
232}
233
234struct drm_encoder *ptn3460_best_encoder(struct drm_connector *connector)
235{
236 struct ptn3460_bridge *ptn_bridge;
237
238 ptn_bridge = container_of(connector, struct ptn3460_bridge, connector);
239
240 return ptn_bridge->encoder;
241}
242
243struct drm_connector_helper_funcs ptn3460_connector_helper_funcs = {
244 .get_modes = ptn3460_get_modes,
245 .mode_valid = ptn3460_mode_valid,
246 .best_encoder = ptn3460_best_encoder,
247};
248
249enum drm_connector_status ptn3460_detect(struct drm_connector *connector,
250 bool force)
251{
252 return connector_status_connected;
253}
254
255void ptn3460_connector_destroy(struct drm_connector *connector)
256{
257 drm_connector_cleanup(connector);
258}
259
260struct 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,
265};
266
267int ptn3460_init(struct drm_device *dev, struct drm_encoder *encoder,
268 struct i2c_client *client, struct device_node *node)
269{
270 int ret;
271 struct drm_bridge *bridge;
272 struct ptn3460_bridge *ptn_bridge;
273
274 bridge = devm_kzalloc(dev->dev, sizeof(*bridge), GFP_KERNEL);
275 if (!bridge) {
276 DRM_ERROR("Failed to allocate drm bridge\n");
277 return -ENOMEM;
278 }
279
280 ptn_bridge = devm_kzalloc(dev->dev, sizeof(*ptn_bridge), GFP_KERNEL);
281 if (!ptn_bridge) {
282 DRM_ERROR("Failed to allocate ptn bridge\n");
283 return -ENOMEM;
284 }
285
286 ptn_bridge->client = client;
287 ptn_bridge->encoder = encoder;
288 ptn_bridge->bridge = bridge;
289 ptn_bridge->gpio_pd_n = of_get_named_gpio(node, "powerdown-gpio", 0);
290 if (gpio_is_valid(ptn_bridge->gpio_pd_n)) {
291 ret = gpio_request_one(ptn_bridge->gpio_pd_n,
292 GPIOF_OUT_INIT_HIGH, "PTN3460_PD_N");
293 if (ret) {
294 DRM_ERROR("Request powerdown-gpio failed (%d)\n", ret);
295 return ret;
296 }
297 }
298
299 ptn_bridge->gpio_rst_n = of_get_named_gpio(node, "reset-gpio", 0);
300 if (gpio_is_valid(ptn_bridge->gpio_rst_n)) {
301 /*
302 * Request the reset pin low to avoid the bridge being
303 * initialized prematurely
304 */
305 ret = gpio_request_one(ptn_bridge->gpio_rst_n,
306 GPIOF_OUT_INIT_LOW, "PTN3460_RST_N");
307 if (ret) {
308 DRM_ERROR("Request reset-gpio failed (%d)\n", ret);
309 gpio_free(ptn_bridge->gpio_pd_n);
310 return ret;
311 }
312 }
313
314 ret = of_property_read_u32(node, "edid-emulation",
315 &ptn_bridge->edid_emulation);
316 if (ret) {
317 DRM_ERROR("Can't read edid emulation value\n");
318 goto err;
319 }
320
321 ret = drm_bridge_init(dev, bridge, &ptn3460_bridge_funcs);
322 if (ret) {
323 DRM_ERROR("Failed to initialize bridge with drm\n");
324 goto err;
325 }
326
327 bridge->driver_private = ptn_bridge;
328 encoder->bridge = bridge;
329
330 ret = drm_connector_init(dev, &ptn_bridge->connector,
331 &ptn3460_connector_funcs, DRM_MODE_CONNECTOR_LVDS);
332 if (ret) {
333 DRM_ERROR("Failed to initialize connector with drm\n");
334 goto err;
335 }
336 drm_connector_helper_add(&ptn_bridge->connector,
337 &ptn3460_connector_helper_funcs);
338 drm_sysfs_connector_add(&ptn_bridge->connector);
339 drm_mode_connector_attach_encoder(&ptn_bridge->connector, encoder);
340
341 return 0;
342
343err:
344 if (gpio_is_valid(ptn_bridge->gpio_pd_n))
345 gpio_free(ptn_bridge->gpio_pd_n);
346 if (gpio_is_valid(ptn_bridge->gpio_rst_n))
347 gpio_free(ptn_bridge->gpio_rst_n);
348 return ret;
349}
350EXPORT_SYMBOL(ptn3460_init);