Commit | Line | Data |
---|---|---|
b2ea8772 VP |
1 | /* |
2 | * Parade PS8622 eDP/LVDS bridge driver | |
3 | * | |
4 | * Copyright (C) 2014 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/backlight.h> | |
17 | #include <linux/delay.h> | |
18 | #include <linux/err.h> | |
19 | #include <linux/fb.h> | |
20 | #include <linux/gpio.h> | |
dcd43d64 | 21 | #include <linux/gpio/consumer.h> |
b2ea8772 VP |
22 | #include <linux/i2c.h> |
23 | #include <linux/module.h> | |
24 | #include <linux/of.h> | |
25 | #include <linux/of_device.h> | |
26 | #include <linux/of_graph.h> | |
27 | #include <linux/pm.h> | |
28 | #include <linux/regulator/consumer.h> | |
29 | ||
30 | #include <drm/drm_panel.h> | |
31 | ||
32 | #include "drmP.h" | |
33 | #include "drm_crtc.h" | |
34 | #include "drm_crtc_helper.h" | |
35 | ||
36 | /* Brightness scale on the Parade chip */ | |
37 | #define PS8622_MAX_BRIGHTNESS 0xff | |
38 | ||
39 | /* Timings taken from the version 1.7 datasheet for the PS8622/PS8625 */ | |
40 | #define PS8622_POWER_RISE_T1_MIN_US 10 | |
41 | #define PS8622_POWER_RISE_T1_MAX_US 10000 | |
42 | #define PS8622_RST_HIGH_T2_MIN_US 3000 | |
43 | #define PS8622_RST_HIGH_T2_MAX_US 30000 | |
44 | #define PS8622_PWMO_END_T12_MS 200 | |
45 | #define PS8622_POWER_FALL_T16_MAX_US 10000 | |
46 | #define PS8622_POWER_OFF_T17_MS 500 | |
47 | ||
48 | #if ((PS8622_RST_HIGH_T2_MIN_US + PS8622_POWER_RISE_T1_MAX_US) > \ | |
49 | (PS8622_RST_HIGH_T2_MAX_US + PS8622_POWER_RISE_T1_MIN_US)) | |
50 | #error "T2.min + T1.max must be less than T2.max + T1.min" | |
51 | #endif | |
52 | ||
53 | struct ps8622_bridge { | |
54 | struct drm_connector connector; | |
55 | struct i2c_client *client; | |
56 | struct drm_bridge bridge; | |
57 | struct drm_panel *panel; | |
58 | struct regulator *v12; | |
59 | struct backlight_device *bl; | |
60 | ||
61 | struct gpio_desc *gpio_slp; | |
62 | struct gpio_desc *gpio_rst; | |
63 | ||
64 | u32 max_lane_count; | |
65 | u32 lane_count; | |
66 | ||
67 | bool enabled; | |
68 | }; | |
69 | ||
70 | static inline struct ps8622_bridge * | |
71 | bridge_to_ps8622(struct drm_bridge *bridge) | |
72 | { | |
73 | return container_of(bridge, struct ps8622_bridge, bridge); | |
74 | } | |
75 | ||
76 | static inline struct ps8622_bridge * | |
77 | connector_to_ps8622(struct drm_connector *connector) | |
78 | { | |
79 | return container_of(connector, struct ps8622_bridge, connector); | |
80 | } | |
81 | ||
82 | static int ps8622_set(struct i2c_client *client, u8 page, u8 reg, u8 val) | |
83 | { | |
84 | int ret; | |
85 | struct i2c_adapter *adap = client->adapter; | |
86 | struct i2c_msg msg; | |
87 | u8 data[] = {reg, val}; | |
88 | ||
89 | msg.addr = client->addr + page; | |
90 | msg.flags = 0; | |
91 | msg.len = sizeof(data); | |
92 | msg.buf = data; | |
93 | ||
94 | ret = i2c_transfer(adap, &msg, 1); | |
95 | if (ret != 1) | |
96 | pr_warn("PS8622 I2C write (0x%02x,0x%02x,0x%02x) failed: %d\n", | |
97 | client->addr + page, reg, val, ret); | |
98 | return !(ret == 1); | |
99 | } | |
100 | ||
101 | static int ps8622_send_config(struct ps8622_bridge *ps8622) | |
102 | { | |
103 | struct i2c_client *cl = ps8622->client; | |
104 | int err = 0; | |
105 | ||
106 | /* HPD low */ | |
107 | err = ps8622_set(cl, 0x02, 0xa1, 0x01); | |
108 | if (err) | |
109 | goto error; | |
110 | ||
111 | /* SW setting: [1:0] SW output 1.2V voltage is lower to 96% */ | |
112 | err = ps8622_set(cl, 0x04, 0x14, 0x01); | |
113 | if (err) | |
114 | goto error; | |
115 | ||
116 | /* RCO SS setting: [5:4] = b01 0.5%, b10 1%, b11 1.5% */ | |
117 | err = ps8622_set(cl, 0x04, 0xe3, 0x20); | |
118 | if (err) | |
119 | goto error; | |
120 | ||
121 | /* [7] RCO SS enable */ | |
122 | err = ps8622_set(cl, 0x04, 0xe2, 0x80); | |
123 | if (err) | |
124 | goto error; | |
125 | ||
126 | /* RPHY Setting | |
127 | * [3:2] CDR tune wait cycle before measure for fine tune | |
128 | * b00: 1us b01: 0.5us b10:2us, b11: 4us | |
129 | */ | |
130 | err = ps8622_set(cl, 0x04, 0x8a, 0x0c); | |
131 | if (err) | |
132 | goto error; | |
133 | ||
134 | /* [3] RFD always on */ | |
135 | err = ps8622_set(cl, 0x04, 0x89, 0x08); | |
136 | if (err) | |
137 | goto error; | |
138 | ||
139 | /* CTN lock in/out: 20000ppm/80000ppm. Lock out 2 times. */ | |
140 | err = ps8622_set(cl, 0x04, 0x71, 0x2d); | |
141 | if (err) | |
142 | goto error; | |
143 | ||
144 | /* 2.7G CDR settings: NOF=40LSB for HBR CDR setting */ | |
145 | err = ps8622_set(cl, 0x04, 0x7d, 0x07); | |
146 | if (err) | |
147 | goto error; | |
148 | ||
149 | /* [1:0] Fmin=+4bands */ | |
150 | err = ps8622_set(cl, 0x04, 0x7b, 0x00); | |
151 | if (err) | |
152 | goto error; | |
153 | ||
154 | /* [7:5] DCO_FTRNG=+-40% */ | |
155 | err = ps8622_set(cl, 0x04, 0x7a, 0xfd); | |
156 | if (err) | |
157 | goto error; | |
158 | ||
159 | /* 1.62G CDR settings: [5:2]NOF=64LSB [1:0]DCO scale is 2/5 */ | |
160 | err = ps8622_set(cl, 0x04, 0xc0, 0x12); | |
161 | if (err) | |
162 | goto error; | |
163 | ||
164 | /* Gitune=-37% */ | |
165 | err = ps8622_set(cl, 0x04, 0xc1, 0x92); | |
166 | if (err) | |
167 | goto error; | |
168 | ||
169 | /* Fbstep=100% */ | |
170 | err = ps8622_set(cl, 0x04, 0xc2, 0x1c); | |
171 | if (err) | |
172 | goto error; | |
173 | ||
174 | /* [7] LOS signal disable */ | |
175 | err = ps8622_set(cl, 0x04, 0x32, 0x80); | |
176 | if (err) | |
177 | goto error; | |
178 | ||
179 | /* RPIO Setting: [7:4] LVDS driver bias current : 75% (250mV swing) */ | |
180 | err = ps8622_set(cl, 0x04, 0x00, 0xb0); | |
181 | if (err) | |
182 | goto error; | |
183 | ||
184 | /* [7:6] Right-bar GPIO output strength is 8mA */ | |
185 | err = ps8622_set(cl, 0x04, 0x15, 0x40); | |
186 | if (err) | |
187 | goto error; | |
188 | ||
189 | /* EQ Training State Machine Setting, RCO calibration start */ | |
190 | err = ps8622_set(cl, 0x04, 0x54, 0x10); | |
191 | if (err) | |
192 | goto error; | |
193 | ||
194 | /* Logic, needs more than 10 I2C command */ | |
195 | /* [4:0] MAX_LANE_COUNT set to max supported lanes */ | |
196 | err = ps8622_set(cl, 0x01, 0x02, 0x80 | ps8622->max_lane_count); | |
197 | if (err) | |
198 | goto error; | |
199 | ||
200 | /* [4:0] LANE_COUNT_SET set to chosen lane count */ | |
201 | err = ps8622_set(cl, 0x01, 0x21, 0x80 | ps8622->lane_count); | |
202 | if (err) | |
203 | goto error; | |
204 | ||
205 | err = ps8622_set(cl, 0x00, 0x52, 0x20); | |
206 | if (err) | |
207 | goto error; | |
208 | ||
209 | /* HPD CP toggle enable */ | |
210 | err = ps8622_set(cl, 0x00, 0xf1, 0x03); | |
211 | if (err) | |
212 | goto error; | |
213 | ||
214 | err = ps8622_set(cl, 0x00, 0x62, 0x41); | |
215 | if (err) | |
216 | goto error; | |
217 | ||
218 | /* Counter number, add 1ms counter delay */ | |
219 | err = ps8622_set(cl, 0x00, 0xf6, 0x01); | |
220 | if (err) | |
221 | goto error; | |
222 | ||
223 | /* [6]PWM function control by DPCD0040f[7], default is PWM block */ | |
224 | err = ps8622_set(cl, 0x00, 0x77, 0x06); | |
225 | if (err) | |
226 | goto error; | |
227 | ||
228 | /* 04h Adjust VTotal toleranceto fix the 30Hz no display issue */ | |
229 | err = ps8622_set(cl, 0x00, 0x4c, 0x04); | |
230 | if (err) | |
231 | goto error; | |
232 | ||
233 | /* DPCD00400='h00, Parade OUI ='h001cf8 */ | |
234 | err = ps8622_set(cl, 0x01, 0xc0, 0x00); | |
235 | if (err) | |
236 | goto error; | |
237 | ||
238 | /* DPCD00401='h1c */ | |
239 | err = ps8622_set(cl, 0x01, 0xc1, 0x1c); | |
240 | if (err) | |
241 | goto error; | |
242 | ||
243 | /* DPCD00402='hf8 */ | |
244 | err = ps8622_set(cl, 0x01, 0xc2, 0xf8); | |
245 | if (err) | |
246 | goto error; | |
247 | ||
248 | /* DPCD403~408 = ASCII code, D2SLV5='h4432534c5635 */ | |
249 | err = ps8622_set(cl, 0x01, 0xc3, 0x44); | |
250 | if (err) | |
251 | goto error; | |
252 | ||
253 | /* DPCD404 */ | |
254 | err = ps8622_set(cl, 0x01, 0xc4, 0x32); | |
255 | if (err) | |
256 | goto error; | |
257 | ||
258 | /* DPCD405 */ | |
259 | err = ps8622_set(cl, 0x01, 0xc5, 0x53); | |
260 | if (err) | |
261 | goto error; | |
262 | ||
263 | /* DPCD406 */ | |
264 | err = ps8622_set(cl, 0x01, 0xc6, 0x4c); | |
265 | if (err) | |
266 | goto error; | |
267 | ||
268 | /* DPCD407 */ | |
269 | err = ps8622_set(cl, 0x01, 0xc7, 0x56); | |
270 | if (err) | |
271 | goto error; | |
272 | ||
273 | /* DPCD408 */ | |
274 | err = ps8622_set(cl, 0x01, 0xc8, 0x35); | |
275 | if (err) | |
276 | goto error; | |
277 | ||
278 | /* DPCD40A, Initial Code major revision '01' */ | |
279 | err = ps8622_set(cl, 0x01, 0xca, 0x01); | |
280 | if (err) | |
281 | goto error; | |
282 | ||
283 | /* DPCD40B, Initial Code minor revision '05' */ | |
284 | err = ps8622_set(cl, 0x01, 0xcb, 0x05); | |
285 | if (err) | |
286 | goto error; | |
287 | ||
288 | ||
289 | if (ps8622->bl) { | |
290 | /* DPCD720, internal PWM */ | |
291 | err = ps8622_set(cl, 0x01, 0xa5, 0xa0); | |
292 | if (err) | |
293 | goto error; | |
294 | ||
295 | /* FFh for 100% brightness, 0h for 0% brightness */ | |
296 | err = ps8622_set(cl, 0x01, 0xa7, | |
297 | ps8622->bl->props.brightness); | |
298 | if (err) | |
299 | goto error; | |
300 | } else { | |
301 | /* DPCD720, external PWM */ | |
302 | err = ps8622_set(cl, 0x01, 0xa5, 0x80); | |
303 | if (err) | |
304 | goto error; | |
305 | } | |
306 | ||
307 | /* Set LVDS output as 6bit-VESA mapping, single LVDS channel */ | |
308 | err = ps8622_set(cl, 0x01, 0xcc, 0x13); | |
309 | if (err) | |
310 | goto error; | |
311 | ||
312 | /* Enable SSC set by register */ | |
313 | err = ps8622_set(cl, 0x02, 0xb1, 0x20); | |
314 | if (err) | |
315 | goto error; | |
316 | ||
317 | /* Set SSC enabled and +/-1% central spreading */ | |
318 | err = ps8622_set(cl, 0x04, 0x10, 0x16); | |
319 | if (err) | |
320 | goto error; | |
321 | ||
322 | /* Logic end */ | |
323 | /* MPU Clock source: LC => RCO */ | |
324 | err = ps8622_set(cl, 0x04, 0x59, 0x60); | |
325 | if (err) | |
326 | goto error; | |
327 | ||
328 | /* LC -> RCO */ | |
329 | err = ps8622_set(cl, 0x04, 0x54, 0x14); | |
330 | if (err) | |
331 | goto error; | |
332 | ||
333 | /* HPD high */ | |
334 | err = ps8622_set(cl, 0x02, 0xa1, 0x91); | |
335 | ||
336 | error: | |
337 | return err ? -EIO : 0; | |
338 | } | |
339 | ||
340 | static int ps8622_backlight_update(struct backlight_device *bl) | |
341 | { | |
342 | struct ps8622_bridge *ps8622 = dev_get_drvdata(&bl->dev); | |
343 | int ret, brightness = bl->props.brightness; | |
344 | ||
345 | if (bl->props.power != FB_BLANK_UNBLANK || | |
346 | bl->props.state & (BL_CORE_SUSPENDED | BL_CORE_FBBLANK)) | |
347 | brightness = 0; | |
348 | ||
349 | if (!ps8622->enabled) | |
350 | return -EINVAL; | |
351 | ||
352 | ret = ps8622_set(ps8622->client, 0x01, 0xa7, brightness); | |
353 | ||
354 | return ret; | |
355 | } | |
356 | ||
357 | static const struct backlight_ops ps8622_backlight_ops = { | |
358 | .update_status = ps8622_backlight_update, | |
359 | }; | |
360 | ||
361 | static void ps8622_pre_enable(struct drm_bridge *bridge) | |
362 | { | |
363 | struct ps8622_bridge *ps8622 = bridge_to_ps8622(bridge); | |
364 | int ret; | |
365 | ||
366 | if (ps8622->enabled) | |
367 | return; | |
368 | ||
369 | gpiod_set_value(ps8622->gpio_rst, 0); | |
370 | ||
371 | if (ps8622->v12) { | |
372 | ret = regulator_enable(ps8622->v12); | |
373 | if (ret) | |
374 | DRM_ERROR("fails to enable ps8622->v12"); | |
375 | } | |
376 | ||
377 | if (drm_panel_prepare(ps8622->panel)) { | |
378 | DRM_ERROR("failed to prepare panel\n"); | |
379 | return; | |
380 | } | |
381 | ||
382 | gpiod_set_value(ps8622->gpio_slp, 1); | |
383 | ||
384 | /* | |
385 | * T1 is the range of time that it takes for the power to rise after we | |
386 | * enable the lcd/ps8622 fet. T2 is the range of time in which the | |
387 | * data sheet specifies we should deassert the reset pin. | |
388 | * | |
389 | * If it takes T1.max for the power to rise, we need to wait atleast | |
390 | * T2.min before deasserting the reset pin. If it takes T1.min for the | |
391 | * power to rise, we need to wait at most T2.max before deasserting the | |
392 | * reset pin. | |
393 | */ | |
394 | usleep_range(PS8622_RST_HIGH_T2_MIN_US + PS8622_POWER_RISE_T1_MAX_US, | |
395 | PS8622_RST_HIGH_T2_MAX_US + PS8622_POWER_RISE_T1_MIN_US); | |
396 | ||
397 | gpiod_set_value(ps8622->gpio_rst, 1); | |
398 | ||
399 | /* wait 20ms after RST high */ | |
400 | usleep_range(20000, 30000); | |
401 | ||
402 | ret = ps8622_send_config(ps8622); | |
403 | if (ret) { | |
404 | DRM_ERROR("Failed to send config to bridge (%d)\n", ret); | |
405 | return; | |
406 | } | |
407 | ||
408 | ps8622->enabled = true; | |
409 | } | |
410 | ||
411 | static void ps8622_enable(struct drm_bridge *bridge) | |
412 | { | |
413 | struct ps8622_bridge *ps8622 = bridge_to_ps8622(bridge); | |
414 | ||
415 | if (drm_panel_enable(ps8622->panel)) { | |
416 | DRM_ERROR("failed to enable panel\n"); | |
417 | return; | |
418 | } | |
419 | } | |
420 | ||
421 | static void ps8622_disable(struct drm_bridge *bridge) | |
422 | { | |
423 | struct ps8622_bridge *ps8622 = bridge_to_ps8622(bridge); | |
424 | ||
425 | if (drm_panel_disable(ps8622->panel)) { | |
426 | DRM_ERROR("failed to disable panel\n"); | |
427 | return; | |
428 | } | |
429 | msleep(PS8622_PWMO_END_T12_MS); | |
430 | } | |
431 | ||
432 | static void ps8622_post_disable(struct drm_bridge *bridge) | |
433 | { | |
434 | struct ps8622_bridge *ps8622 = bridge_to_ps8622(bridge); | |
435 | ||
436 | if (!ps8622->enabled) | |
437 | return; | |
438 | ||
439 | ps8622->enabled = false; | |
440 | ||
441 | /* | |
442 | * This doesn't matter if the regulators are turned off, but something | |
443 | * else might keep them on. In that case, we want to assert the slp gpio | |
444 | * to lower power. | |
445 | */ | |
446 | gpiod_set_value(ps8622->gpio_slp, 0); | |
447 | ||
448 | if (drm_panel_unprepare(ps8622->panel)) { | |
449 | DRM_ERROR("failed to unprepare panel\n"); | |
450 | return; | |
451 | } | |
452 | ||
453 | if (ps8622->v12) | |
454 | regulator_disable(ps8622->v12); | |
455 | ||
456 | /* | |
457 | * Sleep for at least the amount of time that it takes the power rail to | |
458 | * fall to prevent asserting the rst gpio from doing anything. | |
459 | */ | |
460 | usleep_range(PS8622_POWER_FALL_T16_MAX_US, | |
461 | 2 * PS8622_POWER_FALL_T16_MAX_US); | |
462 | gpiod_set_value(ps8622->gpio_rst, 0); | |
463 | ||
464 | msleep(PS8622_POWER_OFF_T17_MS); | |
465 | } | |
466 | ||
467 | static int ps8622_get_modes(struct drm_connector *connector) | |
468 | { | |
469 | struct ps8622_bridge *ps8622; | |
470 | ||
471 | ps8622 = connector_to_ps8622(connector); | |
472 | ||
473 | return drm_panel_get_modes(ps8622->panel); | |
474 | } | |
475 | ||
476 | static struct drm_encoder *ps8622_best_encoder(struct drm_connector *connector) | |
477 | { | |
478 | struct ps8622_bridge *ps8622; | |
479 | ||
480 | ps8622 = connector_to_ps8622(connector); | |
481 | ||
482 | return ps8622->bridge.encoder; | |
483 | } | |
484 | ||
485 | static const struct drm_connector_helper_funcs ps8622_connector_helper_funcs = { | |
486 | .get_modes = ps8622_get_modes, | |
487 | .best_encoder = ps8622_best_encoder, | |
488 | }; | |
489 | ||
490 | static enum drm_connector_status ps8622_detect(struct drm_connector *connector, | |
491 | bool force) | |
492 | { | |
493 | return connector_status_connected; | |
494 | } | |
495 | ||
496 | static void ps8622_connector_destroy(struct drm_connector *connector) | |
497 | { | |
498 | drm_connector_cleanup(connector); | |
499 | } | |
500 | ||
501 | static const struct drm_connector_funcs ps8622_connector_funcs = { | |
502 | .dpms = drm_helper_connector_dpms, | |
503 | .fill_modes = drm_helper_probe_single_connector_modes, | |
504 | .detect = ps8622_detect, | |
505 | .destroy = ps8622_connector_destroy, | |
506 | }; | |
507 | ||
8a7d56b3 | 508 | static int ps8622_attach(struct drm_bridge *bridge) |
b2ea8772 VP |
509 | { |
510 | struct ps8622_bridge *ps8622 = bridge_to_ps8622(bridge); | |
511 | int ret; | |
512 | ||
513 | if (!bridge->encoder) { | |
514 | DRM_ERROR("Parent encoder object not found"); | |
515 | return -ENODEV; | |
516 | } | |
517 | ||
518 | ps8622->connector.polled = DRM_CONNECTOR_POLL_HPD; | |
519 | ret = drm_connector_init(bridge->dev, &ps8622->connector, | |
520 | &ps8622_connector_funcs, DRM_MODE_CONNECTOR_LVDS); | |
521 | if (ret) { | |
522 | DRM_ERROR("Failed to initialize connector with drm\n"); | |
523 | return ret; | |
524 | } | |
525 | drm_connector_helper_add(&ps8622->connector, | |
526 | &ps8622_connector_helper_funcs); | |
527 | drm_connector_register(&ps8622->connector); | |
528 | drm_mode_connector_attach_encoder(&ps8622->connector, | |
529 | bridge->encoder); | |
530 | ||
531 | if (ps8622->panel) | |
532 | drm_panel_attach(ps8622->panel, &ps8622->connector); | |
533 | ||
534 | drm_helper_hpd_irq_event(ps8622->connector.dev); | |
535 | ||
536 | return ret; | |
537 | } | |
538 | ||
539 | static const struct drm_bridge_funcs ps8622_bridge_funcs = { | |
540 | .pre_enable = ps8622_pre_enable, | |
541 | .enable = ps8622_enable, | |
542 | .disable = ps8622_disable, | |
543 | .post_disable = ps8622_post_disable, | |
544 | .attach = ps8622_attach, | |
545 | }; | |
546 | ||
547 | static const struct of_device_id ps8622_devices[] = { | |
548 | {.compatible = "parade,ps8622",}, | |
549 | {.compatible = "parade,ps8625",}, | |
550 | {} | |
551 | }; | |
552 | MODULE_DEVICE_TABLE(of, ps8622_devices); | |
553 | ||
554 | static int ps8622_probe(struct i2c_client *client, | |
555 | const struct i2c_device_id *id) | |
556 | { | |
557 | struct device *dev = &client->dev; | |
558 | struct device_node *endpoint, *panel_node; | |
559 | struct ps8622_bridge *ps8622; | |
560 | int ret; | |
561 | ||
562 | ps8622 = devm_kzalloc(dev, sizeof(*ps8622), GFP_KERNEL); | |
563 | if (!ps8622) | |
564 | return -ENOMEM; | |
565 | ||
566 | endpoint = of_graph_get_next_endpoint(dev->of_node, NULL); | |
567 | if (endpoint) { | |
568 | panel_node = of_graph_get_remote_port_parent(endpoint); | |
569 | if (panel_node) { | |
570 | ps8622->panel = of_drm_find_panel(panel_node); | |
571 | of_node_put(panel_node); | |
572 | if (!ps8622->panel) | |
573 | return -EPROBE_DEFER; | |
574 | } | |
575 | } | |
576 | ||
577 | ps8622->client = client; | |
578 | ||
579 | ps8622->v12 = devm_regulator_get(dev, "vdd12"); | |
580 | if (IS_ERR(ps8622->v12)) { | |
581 | dev_info(dev, "no 1.2v regulator found for PS8622\n"); | |
582 | ps8622->v12 = NULL; | |
583 | } | |
584 | ||
a92bf307 | 585 | ps8622->gpio_slp = devm_gpiod_get(dev, "sleep", GPIOD_OUT_HIGH); |
b2ea8772 VP |
586 | if (IS_ERR(ps8622->gpio_slp)) { |
587 | ret = PTR_ERR(ps8622->gpio_slp); | |
588 | dev_err(dev, "cannot get gpio_slp %d\n", ret); | |
589 | return ret; | |
590 | } | |
b2ea8772 | 591 | |
b2ea8772 VP |
592 | /* |
593 | * Assert the reset pin high to avoid the bridge being | |
594 | * initialized prematurely | |
595 | */ | |
a92bf307 UKK |
596 | ps8622->gpio_rst = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); |
597 | if (IS_ERR(ps8622->gpio_rst)) { | |
598 | ret = PTR_ERR(ps8622->gpio_rst); | |
599 | dev_err(dev, "cannot get gpio_rst %d\n", ret); | |
b2ea8772 VP |
600 | return ret; |
601 | } | |
602 | ||
603 | ps8622->max_lane_count = id->driver_data; | |
604 | ||
605 | if (of_property_read_u32(dev->of_node, "lane-count", | |
606 | &ps8622->lane_count)) { | |
607 | ps8622->lane_count = ps8622->max_lane_count; | |
608 | } else if (ps8622->lane_count > ps8622->max_lane_count) { | |
609 | dev_info(dev, "lane-count property is too high," | |
610 | "using max_lane_count\n"); | |
611 | ps8622->lane_count = ps8622->max_lane_count; | |
612 | } | |
613 | ||
614 | if (!of_find_property(dev->of_node, "use-external-pwm", NULL)) { | |
615 | ps8622->bl = backlight_device_register("ps8622-backlight", | |
616 | dev, ps8622, &ps8622_backlight_ops, | |
617 | NULL); | |
618 | if (IS_ERR(ps8622->bl)) { | |
619 | DRM_ERROR("failed to register backlight\n"); | |
620 | ret = PTR_ERR(ps8622->bl); | |
621 | ps8622->bl = NULL; | |
622 | return ret; | |
623 | } | |
624 | ps8622->bl->props.max_brightness = PS8622_MAX_BRIGHTNESS; | |
625 | ps8622->bl->props.brightness = PS8622_MAX_BRIGHTNESS; | |
626 | } | |
627 | ||
628 | ps8622->bridge.funcs = &ps8622_bridge_funcs; | |
629 | ps8622->bridge.of_node = dev->of_node; | |
630 | ret = drm_bridge_add(&ps8622->bridge); | |
631 | if (ret) { | |
632 | DRM_ERROR("Failed to add bridge\n"); | |
633 | return ret; | |
634 | } | |
635 | ||
636 | i2c_set_clientdata(client, ps8622); | |
637 | ||
638 | return 0; | |
639 | } | |
640 | ||
641 | static int ps8622_remove(struct i2c_client *client) | |
642 | { | |
643 | struct ps8622_bridge *ps8622 = i2c_get_clientdata(client); | |
644 | ||
645 | if (ps8622->bl) | |
646 | backlight_device_unregister(ps8622->bl); | |
647 | ||
648 | drm_bridge_remove(&ps8622->bridge); | |
649 | ||
650 | return 0; | |
651 | } | |
652 | ||
653 | static const struct i2c_device_id ps8622_i2c_table[] = { | |
654 | /* Device type, max_lane_count */ | |
655 | {"ps8622", 1}, | |
656 | {"ps8625", 2}, | |
657 | {}, | |
658 | }; | |
659 | MODULE_DEVICE_TABLE(i2c, ps8622_i2c_table); | |
660 | ||
8a7d56b3 | 661 | static struct i2c_driver ps8622_driver = { |
b2ea8772 VP |
662 | .id_table = ps8622_i2c_table, |
663 | .probe = ps8622_probe, | |
664 | .remove = ps8622_remove, | |
665 | .driver = { | |
666 | .name = "ps8622", | |
667 | .owner = THIS_MODULE, | |
668 | .of_match_table = ps8622_devices, | |
669 | }, | |
670 | }; | |
671 | module_i2c_driver(ps8622_driver); | |
672 | ||
673 | MODULE_AUTHOR("Vincent Palatin <vpalatin@chromium.org>"); | |
674 | MODULE_DESCRIPTION("Parade ps8622/ps8625 eDP-LVDS converter driver"); | |
675 | MODULE_LICENSE("GPL v2"); |