1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for MegaChips STDP4028 with GE B850v3 firmware (LVDS-DP) 4 * Driver for MegaChips STDP2690 with GE B850v3 firmware (DP-DP++) 5 6 * Copyright (c) 2017, Collabora Ltd. 7 * Copyright (c) 2017, General Electric Company 8 9 10 * This driver creates a drm_bridge and a drm_connector for the LVDS to DP++ 11 * display bridge of the GE B850v3. There are two physical bridges on the video 12 * signal pipeline: a STDP4028(LVDS to DP) and a STDP2690(DP to DP++). The 13 * physical bridges are automatically configured by the input video signal, and 14 * the driver has no access to the video processing pipeline. The driver is 15 * only needed to read EDID from the STDP2690 and to handle HPD events from the 16 * STDP4028. The driver communicates with both bridges over i2c. The video 17 * signal pipeline is as follows: 18 * 19 * Host -> LVDS|--(STDP4028)--|DP -> DP|--(STDP2690)--|DP++ -> Video output 20 */ 21 22 #include <linux/i2c.h> 23 #include <linux/module.h> 24 #include <linux/of.h> 25 26 #include <drm/drm_atomic.h> 27 #include <drm/drm_atomic_helper.h> 28 #include <drm/drm_bridge.h> 29 #include <drm/drm_edid.h> 30 #include <drm/drm_print.h> 31 #include <drm/drm_probe_helper.h> 32 33 #define EDID_EXT_BLOCK_CNT 0x7E 34 35 #define STDP4028_IRQ_OUT_CONF_REG 0x02 36 #define STDP4028_DPTX_IRQ_EN_REG 0x3C 37 #define STDP4028_DPTX_IRQ_STS_REG 0x3D 38 #define STDP4028_DPTX_STS_REG 0x3E 39 40 #define STDP4028_DPTX_DP_IRQ_EN 0x1000 41 42 #define STDP4028_DPTX_HOTPLUG_IRQ_EN 0x0400 43 #define STDP4028_DPTX_LINK_CH_IRQ_EN 0x2000 44 #define STDP4028_DPTX_IRQ_CONFIG \ 45 (STDP4028_DPTX_LINK_CH_IRQ_EN | STDP4028_DPTX_HOTPLUG_IRQ_EN) 46 47 #define STDP4028_DPTX_HOTPLUG_STS 0x0200 48 #define STDP4028_DPTX_LINK_STS 0x1000 49 #define STDP4028_CON_STATE_CONNECTED \ 50 (STDP4028_DPTX_HOTPLUG_STS | STDP4028_DPTX_LINK_STS) 51 52 #define STDP4028_DPTX_HOTPLUG_CH_STS 0x0400 53 #define STDP4028_DPTX_LINK_CH_STS 0x2000 54 #define STDP4028_DPTX_IRQ_CLEAR \ 55 (STDP4028_DPTX_LINK_CH_STS | STDP4028_DPTX_HOTPLUG_CH_STS) 56 57 static DEFINE_MUTEX(ge_b850v3_lvds_dev_mutex); 58 59 struct ge_b850v3_lvds { 60 struct drm_connector connector; 61 struct drm_bridge bridge; 62 struct i2c_client *stdp4028_i2c; 63 struct i2c_client *stdp2690_i2c; 64 }; 65 66 static struct ge_b850v3_lvds *ge_b850v3_lvds_ptr; 67 68 static u8 *stdp2690_get_edid(struct i2c_client *client) 69 { 70 struct i2c_adapter *adapter = client->adapter; 71 unsigned char start = 0x00; 72 unsigned int total_size; 73 u8 *block = kmalloc(EDID_LENGTH, GFP_KERNEL); 74 75 struct i2c_msg msgs[] = { 76 { 77 .addr = client->addr, 78 .flags = 0, 79 .len = 1, 80 .buf = &start, 81 }, { 82 .addr = client->addr, 83 .flags = I2C_M_RD, 84 .len = EDID_LENGTH, 85 .buf = block, 86 } 87 }; 88 89 if (!block) 90 return NULL; 91 92 if (i2c_transfer(adapter, msgs, 2) != 2) { 93 DRM_ERROR("Unable to read EDID.\n"); 94 goto err; 95 } 96 97 if (!drm_edid_block_valid(block, 0, false, NULL)) { 98 DRM_ERROR("Invalid EDID data\n"); 99 goto err; 100 } 101 102 total_size = (block[EDID_EXT_BLOCK_CNT] + 1) * EDID_LENGTH; 103 if (total_size > EDID_LENGTH) { 104 kfree(block); 105 block = kmalloc(total_size, GFP_KERNEL); 106 if (!block) 107 return NULL; 108 109 /* Yes, read the entire buffer, and do not skip the first 110 * EDID_LENGTH bytes. 111 */ 112 start = 0x00; 113 msgs[1].len = total_size; 114 msgs[1].buf = block; 115 116 if (i2c_transfer(adapter, msgs, 2) != 2) { 117 DRM_ERROR("Unable to read EDID extension blocks.\n"); 118 goto err; 119 } 120 if (!drm_edid_block_valid(block, 1, false, NULL)) { 121 DRM_ERROR("Invalid EDID data\n"); 122 goto err; 123 } 124 } 125 126 return block; 127 128 err: 129 kfree(block); 130 return NULL; 131 } 132 133 static struct edid *ge_b850v3_lvds_get_edid(struct drm_bridge *bridge, 134 struct drm_connector *connector) 135 { 136 struct i2c_client *client; 137 138 client = ge_b850v3_lvds_ptr->stdp2690_i2c; 139 140 return (struct edid *)stdp2690_get_edid(client); 141 } 142 143 static int ge_b850v3_lvds_get_modes(struct drm_connector *connector) 144 { 145 struct edid *edid; 146 int num_modes; 147 148 edid = ge_b850v3_lvds_get_edid(&ge_b850v3_lvds_ptr->bridge, connector); 149 150 drm_connector_update_edid_property(connector, edid); 151 num_modes = drm_add_edid_modes(connector, edid); 152 kfree(edid); 153 154 return num_modes; 155 } 156 157 static enum drm_mode_status ge_b850v3_lvds_mode_valid( 158 struct drm_connector *connector, struct drm_display_mode *mode) 159 { 160 return MODE_OK; 161 } 162 163 static const struct 164 drm_connector_helper_funcs ge_b850v3_lvds_connector_helper_funcs = { 165 .get_modes = ge_b850v3_lvds_get_modes, 166 .mode_valid = ge_b850v3_lvds_mode_valid, 167 }; 168 169 static enum drm_connector_status ge_b850v3_lvds_bridge_detect(struct drm_bridge *bridge) 170 { 171 struct i2c_client *stdp4028_i2c = 172 ge_b850v3_lvds_ptr->stdp4028_i2c; 173 s32 link_state; 174 175 link_state = i2c_smbus_read_word_data(stdp4028_i2c, 176 STDP4028_DPTX_STS_REG); 177 178 if (link_state == STDP4028_CON_STATE_CONNECTED) 179 return connector_status_connected; 180 181 if (link_state == 0) 182 return connector_status_disconnected; 183 184 return connector_status_unknown; 185 } 186 187 static enum drm_connector_status ge_b850v3_lvds_detect(struct drm_connector *connector, 188 bool force) 189 { 190 return ge_b850v3_lvds_bridge_detect(&ge_b850v3_lvds_ptr->bridge); 191 } 192 193 static const struct drm_connector_funcs ge_b850v3_lvds_connector_funcs = { 194 .fill_modes = drm_helper_probe_single_connector_modes, 195 .detect = ge_b850v3_lvds_detect, 196 .destroy = drm_connector_cleanup, 197 .reset = drm_atomic_helper_connector_reset, 198 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 199 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 200 }; 201 202 static int ge_b850v3_lvds_create_connector(struct drm_bridge *bridge) 203 { 204 struct drm_connector *connector = &ge_b850v3_lvds_ptr->connector; 205 int ret; 206 207 if (!bridge->encoder) { 208 DRM_ERROR("Parent encoder object not found"); 209 return -ENODEV; 210 } 211 212 connector->polled = DRM_CONNECTOR_POLL_HPD; 213 214 drm_connector_helper_add(connector, 215 &ge_b850v3_lvds_connector_helper_funcs); 216 217 ret = drm_connector_init(bridge->dev, connector, 218 &ge_b850v3_lvds_connector_funcs, 219 DRM_MODE_CONNECTOR_DisplayPort); 220 if (ret) { 221 DRM_ERROR("Failed to initialize connector with drm\n"); 222 return ret; 223 } 224 225 return drm_connector_attach_encoder(connector, bridge->encoder); 226 } 227 228 static irqreturn_t ge_b850v3_lvds_irq_handler(int irq, void *dev_id) 229 { 230 struct i2c_client *stdp4028_i2c 231 = ge_b850v3_lvds_ptr->stdp4028_i2c; 232 233 i2c_smbus_write_word_data(stdp4028_i2c, 234 STDP4028_DPTX_IRQ_STS_REG, 235 STDP4028_DPTX_IRQ_CLEAR); 236 237 if (ge_b850v3_lvds_ptr->bridge.dev) 238 drm_kms_helper_hotplug_event(ge_b850v3_lvds_ptr->bridge.dev); 239 240 return IRQ_HANDLED; 241 } 242 243 static int ge_b850v3_lvds_attach(struct drm_bridge *bridge, 244 enum drm_bridge_attach_flags flags) 245 { 246 struct i2c_client *stdp4028_i2c 247 = ge_b850v3_lvds_ptr->stdp4028_i2c; 248 249 /* Configures the bridge to re-enable interrupts after each ack. */ 250 i2c_smbus_write_word_data(stdp4028_i2c, 251 STDP4028_IRQ_OUT_CONF_REG, 252 STDP4028_DPTX_DP_IRQ_EN); 253 254 /* Enable interrupts */ 255 i2c_smbus_write_word_data(stdp4028_i2c, 256 STDP4028_DPTX_IRQ_EN_REG, 257 STDP4028_DPTX_IRQ_CONFIG); 258 259 if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR) 260 return 0; 261 262 return ge_b850v3_lvds_create_connector(bridge); 263 } 264 265 static const struct drm_bridge_funcs ge_b850v3_lvds_funcs = { 266 .attach = ge_b850v3_lvds_attach, 267 .detect = ge_b850v3_lvds_bridge_detect, 268 .get_edid = ge_b850v3_lvds_get_edid, 269 }; 270 271 static int ge_b850v3_lvds_init(struct device *dev) 272 { 273 mutex_lock(&ge_b850v3_lvds_dev_mutex); 274 275 if (ge_b850v3_lvds_ptr) 276 goto success; 277 278 ge_b850v3_lvds_ptr = devm_kzalloc(dev, 279 sizeof(*ge_b850v3_lvds_ptr), 280 GFP_KERNEL); 281 282 if (!ge_b850v3_lvds_ptr) { 283 mutex_unlock(&ge_b850v3_lvds_dev_mutex); 284 return -ENOMEM; 285 } 286 287 success: 288 mutex_unlock(&ge_b850v3_lvds_dev_mutex); 289 return 0; 290 } 291 292 static void ge_b850v3_lvds_remove(void) 293 { 294 mutex_lock(&ge_b850v3_lvds_dev_mutex); 295 /* 296 * This check is to avoid both the drivers 297 * removing the bridge in their remove() function 298 */ 299 if (!ge_b850v3_lvds_ptr || 300 !ge_b850v3_lvds_ptr->stdp2690_i2c || 301 !ge_b850v3_lvds_ptr->stdp4028_i2c) 302 goto out; 303 304 drm_bridge_remove(&ge_b850v3_lvds_ptr->bridge); 305 306 ge_b850v3_lvds_ptr = NULL; 307 out: 308 mutex_unlock(&ge_b850v3_lvds_dev_mutex); 309 } 310 311 static int ge_b850v3_register(void) 312 { 313 struct i2c_client *stdp4028_i2c = ge_b850v3_lvds_ptr->stdp4028_i2c; 314 struct device *dev = &stdp4028_i2c->dev; 315 316 /* drm bridge initialization */ 317 ge_b850v3_lvds_ptr->bridge.funcs = &ge_b850v3_lvds_funcs; 318 ge_b850v3_lvds_ptr->bridge.ops = DRM_BRIDGE_OP_DETECT | 319 DRM_BRIDGE_OP_EDID; 320 ge_b850v3_lvds_ptr->bridge.type = DRM_MODE_CONNECTOR_DisplayPort; 321 ge_b850v3_lvds_ptr->bridge.of_node = dev->of_node; 322 drm_bridge_add(&ge_b850v3_lvds_ptr->bridge); 323 324 /* Clear pending interrupts since power up. */ 325 i2c_smbus_write_word_data(stdp4028_i2c, 326 STDP4028_DPTX_IRQ_STS_REG, 327 STDP4028_DPTX_IRQ_CLEAR); 328 329 if (!stdp4028_i2c->irq) 330 return 0; 331 332 return devm_request_threaded_irq(&stdp4028_i2c->dev, 333 stdp4028_i2c->irq, NULL, 334 ge_b850v3_lvds_irq_handler, 335 IRQF_TRIGGER_HIGH | IRQF_ONESHOT, 336 "ge-b850v3-lvds-dp", ge_b850v3_lvds_ptr); 337 } 338 339 static int stdp4028_ge_b850v3_fw_probe(struct i2c_client *stdp4028_i2c, 340 const struct i2c_device_id *id) 341 { 342 struct device *dev = &stdp4028_i2c->dev; 343 int ret; 344 345 ret = ge_b850v3_lvds_init(dev); 346 347 if (ret) 348 return ret; 349 350 ge_b850v3_lvds_ptr->stdp4028_i2c = stdp4028_i2c; 351 i2c_set_clientdata(stdp4028_i2c, ge_b850v3_lvds_ptr); 352 353 /* Only register after both bridges are probed */ 354 if (!ge_b850v3_lvds_ptr->stdp2690_i2c) 355 return 0; 356 357 return ge_b850v3_register(); 358 } 359 360 static int stdp4028_ge_b850v3_fw_remove(struct i2c_client *stdp4028_i2c) 361 { 362 ge_b850v3_lvds_remove(); 363 364 return 0; 365 } 366 367 static const struct i2c_device_id stdp4028_ge_b850v3_fw_i2c_table[] = { 368 {"stdp4028_ge_fw", 0}, 369 {}, 370 }; 371 MODULE_DEVICE_TABLE(i2c, stdp4028_ge_b850v3_fw_i2c_table); 372 373 static const struct of_device_id stdp4028_ge_b850v3_fw_match[] = { 374 { .compatible = "megachips,stdp4028-ge-b850v3-fw" }, 375 {}, 376 }; 377 MODULE_DEVICE_TABLE(of, stdp4028_ge_b850v3_fw_match); 378 379 static struct i2c_driver stdp4028_ge_b850v3_fw_driver = { 380 .id_table = stdp4028_ge_b850v3_fw_i2c_table, 381 .probe = stdp4028_ge_b850v3_fw_probe, 382 .remove = stdp4028_ge_b850v3_fw_remove, 383 .driver = { 384 .name = "stdp4028-ge-b850v3-fw", 385 .of_match_table = stdp4028_ge_b850v3_fw_match, 386 }, 387 }; 388 389 static int stdp2690_ge_b850v3_fw_probe(struct i2c_client *stdp2690_i2c, 390 const struct i2c_device_id *id) 391 { 392 struct device *dev = &stdp2690_i2c->dev; 393 int ret; 394 395 ret = ge_b850v3_lvds_init(dev); 396 397 if (ret) 398 return ret; 399 400 ge_b850v3_lvds_ptr->stdp2690_i2c = stdp2690_i2c; 401 i2c_set_clientdata(stdp2690_i2c, ge_b850v3_lvds_ptr); 402 403 /* Only register after both bridges are probed */ 404 if (!ge_b850v3_lvds_ptr->stdp4028_i2c) 405 return 0; 406 407 return ge_b850v3_register(); 408 } 409 410 static int stdp2690_ge_b850v3_fw_remove(struct i2c_client *stdp2690_i2c) 411 { 412 ge_b850v3_lvds_remove(); 413 414 return 0; 415 } 416 417 static const struct i2c_device_id stdp2690_ge_b850v3_fw_i2c_table[] = { 418 {"stdp2690_ge_fw", 0}, 419 {}, 420 }; 421 MODULE_DEVICE_TABLE(i2c, stdp2690_ge_b850v3_fw_i2c_table); 422 423 static const struct of_device_id stdp2690_ge_b850v3_fw_match[] = { 424 { .compatible = "megachips,stdp2690-ge-b850v3-fw" }, 425 {}, 426 }; 427 MODULE_DEVICE_TABLE(of, stdp2690_ge_b850v3_fw_match); 428 429 static struct i2c_driver stdp2690_ge_b850v3_fw_driver = { 430 .id_table = stdp2690_ge_b850v3_fw_i2c_table, 431 .probe = stdp2690_ge_b850v3_fw_probe, 432 .remove = stdp2690_ge_b850v3_fw_remove, 433 .driver = { 434 .name = "stdp2690-ge-b850v3-fw", 435 .of_match_table = stdp2690_ge_b850v3_fw_match, 436 }, 437 }; 438 439 static int __init stdpxxxx_ge_b850v3_init(void) 440 { 441 int ret; 442 443 ret = i2c_add_driver(&stdp4028_ge_b850v3_fw_driver); 444 if (ret) 445 return ret; 446 447 return i2c_add_driver(&stdp2690_ge_b850v3_fw_driver); 448 } 449 module_init(stdpxxxx_ge_b850v3_init); 450 451 static void __exit stdpxxxx_ge_b850v3_exit(void) 452 { 453 i2c_del_driver(&stdp2690_ge_b850v3_fw_driver); 454 i2c_del_driver(&stdp4028_ge_b850v3_fw_driver); 455 } 456 module_exit(stdpxxxx_ge_b850v3_exit); 457 458 MODULE_AUTHOR("Peter Senna Tschudin <peter.senna@collabora.com>"); 459 MODULE_AUTHOR("Martyn Welch <martyn.welch@collabora.co.uk>"); 460 MODULE_DESCRIPTION("GE LVDS to DP++ display bridge)"); 461 MODULE_LICENSE("GPL v2"); 462