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