1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (c) 2016 MediaTek Inc.
6 #include <linux/delay.h>
8 #include <linux/gpio/consumer.h>
10 #include <linux/module.h>
11 #include <linux/of_graph.h>
12 #include <linux/regulator/consumer.h>
14 #include <drm/drm_bridge.h>
15 #include <drm/drm_mipi_dsi.h>
16 #include <drm/drm_of.h>
17 #include <drm/drm_panel.h>
18 #include <drm/drm_print.h>
20 #define PAGE2_GPIO_H 0xa7
21 #define PS_GPIO9 BIT(1)
22 #define PAGE2_I2C_BYPASS 0xea
23 #define I2C_BYPASS_EN 0xd0
24 #define PAGE2_MCS_EN 0xf3
26 #define PAGE3_SET_ADD 0xfe
27 #define VDO_CTL_ADD 0x13
30 #define DP_NUM_LANES 4
33 * PS8640 uses multiple addresses:
34 * page[0]: for DP control
35 * page[1]: for VIDEO Bridge
36 * page[2]: for control top
37 * page[3]: for DSI Link Control1
38 * page[4]: for MIPI Phy
40 * page[6]: for DSI Link Control2
41 * page[7]: for SPI ROM mapping
43 enum page_addr_offset {
55 enum ps8640_vdo_control {
61 struct drm_bridge bridge;
62 struct drm_bridge *panel_bridge;
63 struct mipi_dsi_device *dsi;
64 struct i2c_client *page[MAX_DEVS];
65 struct regulator_bulk_data supplies[2];
66 struct gpio_desc *gpio_reset;
67 struct gpio_desc *gpio_powerdown;
70 static inline struct ps8640 *bridge_to_ps8640(struct drm_bridge *e)
72 return container_of(e, struct ps8640, bridge);
75 static int ps8640_bridge_vdo_control(struct ps8640 *ps_bridge,
76 const enum ps8640_vdo_control ctrl)
78 struct i2c_client *client = ps_bridge->page[PAGE3_DSI_CNTL1];
79 u8 vdo_ctrl_buf[] = { VDO_CTL_ADD, ctrl };
82 ret = i2c_smbus_write_i2c_block_data(client, PAGE3_SET_ADD,
86 DRM_ERROR("failed to %sable VDO: %d\n",
87 ctrl == ENABLE ? "en" : "dis", ret);
94 static void ps8640_pre_enable(struct drm_bridge *bridge)
96 struct ps8640 *ps_bridge = bridge_to_ps8640(bridge);
97 struct i2c_client *client = ps_bridge->page[PAGE2_TOP_CNTL];
98 unsigned long timeout;
101 ret = regulator_bulk_enable(ARRAY_SIZE(ps_bridge->supplies),
102 ps_bridge->supplies);
104 DRM_ERROR("cannot enable regulators %d\n", ret);
108 gpiod_set_value(ps_bridge->gpio_powerdown, 0);
109 gpiod_set_value(ps_bridge->gpio_reset, 1);
110 usleep_range(2000, 2500);
111 gpiod_set_value(ps_bridge->gpio_reset, 0);
114 * Wait for the ps8640 embedded MCU to be ready
115 * First wait 200ms and then check the MCU ready flag every 20ms
119 timeout = jiffies + msecs_to_jiffies(200) + 1;
121 while (time_is_after_jiffies(timeout)) {
122 status = i2c_smbus_read_byte_data(client, PAGE2_GPIO_H);
124 DRM_ERROR("failed read PAGE2_GPIO_H: %d\n", status);
125 goto err_regulators_disable;
127 if ((status & PS_GPIO9) == PS_GPIO9)
136 * The Manufacturer Command Set (MCS) is a device dependent interface
137 * intended for factory programming of the display module default
138 * parameters. Once the display module is configured, the MCS shall be
139 * disabled by the manufacturer. Once disabled, all MCS commands are
140 * ignored by the display interface.
142 status = i2c_smbus_read_byte_data(client, PAGE2_MCS_EN);
144 DRM_ERROR("failed read PAGE2_MCS_EN: %d\n", status);
145 goto err_regulators_disable;
148 ret = i2c_smbus_write_byte_data(client, PAGE2_MCS_EN,
151 DRM_ERROR("failed write PAGE2_MCS_EN: %d\n", ret);
152 goto err_regulators_disable;
155 ret = ps8640_bridge_vdo_control(ps_bridge, ENABLE);
157 goto err_regulators_disable;
159 /* Switch access edp panel's edid through i2c */
160 ret = i2c_smbus_write_byte_data(client, PAGE2_I2C_BYPASS,
163 DRM_ERROR("failed write PAGE2_I2C_BYPASS: %d\n", ret);
164 goto err_regulators_disable;
169 err_regulators_disable:
170 regulator_bulk_disable(ARRAY_SIZE(ps_bridge->supplies),
171 ps_bridge->supplies);
174 static void ps8640_post_disable(struct drm_bridge *bridge)
176 struct ps8640 *ps_bridge = bridge_to_ps8640(bridge);
179 ps8640_bridge_vdo_control(ps_bridge, DISABLE);
181 gpiod_set_value(ps_bridge->gpio_reset, 1);
182 gpiod_set_value(ps_bridge->gpio_powerdown, 1);
183 ret = regulator_bulk_disable(ARRAY_SIZE(ps_bridge->supplies),
184 ps_bridge->supplies);
186 DRM_ERROR("cannot disable regulators %d\n", ret);
189 static int ps8640_bridge_attach(struct drm_bridge *bridge,
190 enum drm_bridge_attach_flags flags)
192 struct ps8640 *ps_bridge = bridge_to_ps8640(bridge);
193 struct device *dev = &ps_bridge->page[0]->dev;
194 struct device_node *in_ep, *dsi_node;
195 struct mipi_dsi_device *dsi;
196 struct mipi_dsi_host *host;
198 const struct mipi_dsi_device_info info = { .type = "ps8640",
203 if (!(flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR))
206 /* port@0 is ps8640 dsi input port */
207 in_ep = of_graph_get_endpoint_by_regs(dev->of_node, 0, -1);
211 dsi_node = of_graph_get_remote_port_parent(in_ep);
216 host = of_find_mipi_dsi_host_by_node(dsi_node);
217 of_node_put(dsi_node);
221 dsi = mipi_dsi_device_register_full(host, &info);
223 dev_err(dev, "failed to create dsi device\n");
228 ps_bridge->dsi = dsi;
231 dsi->mode_flags = MIPI_DSI_MODE_VIDEO |
232 MIPI_DSI_MODE_VIDEO_SYNC_PULSE;
233 dsi->format = MIPI_DSI_FMT_RGB888;
234 dsi->lanes = DP_NUM_LANES;
235 ret = mipi_dsi_attach(dsi);
239 /* Attach the panel-bridge to the dsi bridge */
240 return drm_bridge_attach(bridge->encoder, ps_bridge->panel_bridge,
241 &ps_bridge->bridge, flags);
244 mipi_dsi_device_unregister(dsi);
248 static struct edid *ps8640_bridge_get_edid(struct drm_bridge *bridge,
249 struct drm_connector *connector)
251 struct ps8640 *ps_bridge = bridge_to_ps8640(bridge);
253 return drm_get_edid(connector,
254 ps_bridge->page[PAGE0_DP_CNTL]->adapter);
257 static const struct drm_bridge_funcs ps8640_bridge_funcs = {
258 .attach = ps8640_bridge_attach,
259 .get_edid = ps8640_bridge_get_edid,
260 .post_disable = ps8640_post_disable,
261 .pre_enable = ps8640_pre_enable,
264 static int ps8640_probe(struct i2c_client *client)
266 struct device *dev = &client->dev;
267 struct device_node *np = dev->of_node;
268 struct ps8640 *ps_bridge;
269 struct drm_panel *panel;
273 ps_bridge = devm_kzalloc(dev, sizeof(*ps_bridge), GFP_KERNEL);
277 /* port@1 is ps8640 output port */
278 ret = drm_of_find_panel_or_bridge(np, 1, 0, &panel, NULL);
284 ps_bridge->panel_bridge = devm_drm_panel_bridge_add(dev, panel);
285 if (IS_ERR(ps_bridge->panel_bridge))
286 return PTR_ERR(ps_bridge->panel_bridge);
288 ps_bridge->supplies[0].supply = "vdd33";
289 ps_bridge->supplies[1].supply = "vdd12";
290 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(ps_bridge->supplies),
291 ps_bridge->supplies);
295 ps_bridge->gpio_powerdown = devm_gpiod_get(&client->dev, "powerdown",
297 if (IS_ERR(ps_bridge->gpio_powerdown))
298 return PTR_ERR(ps_bridge->gpio_powerdown);
301 * Assert the reset to avoid the bridge being initialized prematurely
303 ps_bridge->gpio_reset = devm_gpiod_get(&client->dev, "reset",
305 if (IS_ERR(ps_bridge->gpio_reset))
306 return PTR_ERR(ps_bridge->gpio_reset);
308 ps_bridge->bridge.funcs = &ps8640_bridge_funcs;
309 ps_bridge->bridge.of_node = dev->of_node;
310 ps_bridge->bridge.ops = DRM_BRIDGE_OP_EDID;
311 ps_bridge->bridge.type = DRM_MODE_CONNECTOR_eDP;
313 ps_bridge->page[PAGE0_DP_CNTL] = client;
315 for (i = 1; i < ARRAY_SIZE(ps_bridge->page); i++) {
316 ps_bridge->page[i] = devm_i2c_new_dummy_device(&client->dev,
319 if (IS_ERR(ps_bridge->page[i])) {
320 dev_err(dev, "failed i2c dummy device, address %02x\n",
322 return PTR_ERR(ps_bridge->page[i]);
326 i2c_set_clientdata(client, ps_bridge);
328 drm_bridge_add(&ps_bridge->bridge);
333 static int ps8640_remove(struct i2c_client *client)
335 struct ps8640 *ps_bridge = i2c_get_clientdata(client);
337 drm_bridge_remove(&ps_bridge->bridge);
342 static const struct of_device_id ps8640_match[] = {
343 { .compatible = "parade,ps8640" },
346 MODULE_DEVICE_TABLE(of, ps8640_match);
348 static struct i2c_driver ps8640_driver = {
349 .probe_new = ps8640_probe,
350 .remove = ps8640_remove,
353 .of_match_table = ps8640_match,
356 module_i2c_driver(ps8640_driver);
358 MODULE_AUTHOR("Jitao Shi <jitao.shi@mediatek.com>");
359 MODULE_AUTHOR("CK Hu <ck.hu@mediatek.com>");
360 MODULE_AUTHOR("Enric Balletbo i Serra <enric.balletbo@collabora.com>");
361 MODULE_DESCRIPTION("PARADE ps8640 DSI-eDP converter driver");
362 MODULE_LICENSE("GPL v2");