megachips-stdpxxxx-ge-b850v3-fw.c 12 KB

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