tilcdc_slave.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406
  1. /*
  2. * Copyright (C) 2012 Texas Instruments
  3. * Author: Rob Clark <robdclark@gmail.com>
  4. *
  5. * This program is free software; you can redistribute it and/or modify it
  6. * under the terms of the GNU General Public License version 2 as published by
  7. * the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope that it will be useful, but WITHOUT
  10. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12. * more details.
  13. *
  14. * You should have received a copy of the GNU General Public License along with
  15. * this program. If not, see <http://www.gnu.org/licenses/>.
  16. */
  17. #include <linux/i2c.h>
  18. #include <linux/pinctrl/pinmux.h>
  19. #include <linux/pinctrl/consumer.h>
  20. #include <drm/drm_encoder_slave.h>
  21. #include "tilcdc_drv.h"
  22. struct slave_module {
  23. struct tilcdc_module base;
  24. struct i2c_adapter *i2c;
  25. };
  26. #define to_slave_module(x) container_of(x, struct slave_module, base)
  27. static const struct tilcdc_panel_info slave_info = {
  28. .bpp = 16,
  29. .ac_bias = 255,
  30. .ac_bias_intrpt = 0,
  31. .dma_burst_sz = 16,
  32. .fdd = 0x80,
  33. .tft_alt_mode = 0,
  34. .sync_edge = 0,
  35. .sync_ctrl = 1,
  36. .raster_order = 0,
  37. };
  38. /*
  39. * Encoder:
  40. */
  41. struct slave_encoder {
  42. struct drm_encoder_slave base;
  43. struct slave_module *mod;
  44. };
  45. #define to_slave_encoder(x) container_of(to_encoder_slave(x), struct slave_encoder, base)
  46. static inline struct drm_encoder_slave_funcs *
  47. get_slave_funcs(struct drm_encoder *enc)
  48. {
  49. return to_encoder_slave(enc)->slave_funcs;
  50. }
  51. static void slave_encoder_destroy(struct drm_encoder *encoder)
  52. {
  53. struct slave_encoder *slave_encoder = to_slave_encoder(encoder);
  54. if (get_slave_funcs(encoder))
  55. get_slave_funcs(encoder)->destroy(encoder);
  56. drm_encoder_cleanup(encoder);
  57. kfree(slave_encoder);
  58. }
  59. static void slave_encoder_prepare(struct drm_encoder *encoder)
  60. {
  61. drm_i2c_encoder_prepare(encoder);
  62. tilcdc_crtc_set_panel_info(encoder->crtc, &slave_info);
  63. }
  64. static bool slave_encoder_fixup(struct drm_encoder *encoder,
  65. const struct drm_display_mode *mode,
  66. struct drm_display_mode *adjusted_mode)
  67. {
  68. /*
  69. * tilcdc does not generate VESA-complient sync but aligns
  70. * VS on the second edge of HS instead of first edge.
  71. * We use adjusted_mode, to fixup sync by aligning both rising
  72. * edges and add HSKEW offset to let the slave encoder fix it up.
  73. */
  74. adjusted_mode->hskew = mode->hsync_end - mode->hsync_start;
  75. adjusted_mode->flags |= DRM_MODE_FLAG_HSKEW;
  76. if (mode->flags & DRM_MODE_FLAG_NHSYNC) {
  77. adjusted_mode->flags |= DRM_MODE_FLAG_PHSYNC;
  78. adjusted_mode->flags &= ~DRM_MODE_FLAG_NHSYNC;
  79. } else {
  80. adjusted_mode->flags |= DRM_MODE_FLAG_NHSYNC;
  81. adjusted_mode->flags &= ~DRM_MODE_FLAG_PHSYNC;
  82. }
  83. return drm_i2c_encoder_mode_fixup(encoder, mode, adjusted_mode);
  84. }
  85. static const struct drm_encoder_funcs slave_encoder_funcs = {
  86. .destroy = slave_encoder_destroy,
  87. };
  88. static const struct drm_encoder_helper_funcs slave_encoder_helper_funcs = {
  89. .dpms = drm_i2c_encoder_dpms,
  90. .mode_fixup = slave_encoder_fixup,
  91. .prepare = slave_encoder_prepare,
  92. .commit = drm_i2c_encoder_commit,
  93. .mode_set = drm_i2c_encoder_mode_set,
  94. .save = drm_i2c_encoder_save,
  95. .restore = drm_i2c_encoder_restore,
  96. };
  97. static const struct i2c_board_info info = {
  98. I2C_BOARD_INFO("tda998x", 0x70)
  99. };
  100. static struct drm_encoder *slave_encoder_create(struct drm_device *dev,
  101. struct slave_module *mod)
  102. {
  103. struct slave_encoder *slave_encoder;
  104. struct drm_encoder *encoder;
  105. int ret;
  106. slave_encoder = kzalloc(sizeof(*slave_encoder), GFP_KERNEL);
  107. if (!slave_encoder) {
  108. dev_err(dev->dev, "allocation failed\n");
  109. return NULL;
  110. }
  111. slave_encoder->mod = mod;
  112. encoder = &slave_encoder->base.base;
  113. encoder->possible_crtcs = 1;
  114. ret = drm_encoder_init(dev, encoder, &slave_encoder_funcs,
  115. DRM_MODE_ENCODER_TMDS);
  116. if (ret)
  117. goto fail;
  118. drm_encoder_helper_add(encoder, &slave_encoder_helper_funcs);
  119. ret = drm_i2c_encoder_init(dev, to_encoder_slave(encoder), mod->i2c, &info);
  120. if (ret)
  121. goto fail;
  122. return encoder;
  123. fail:
  124. slave_encoder_destroy(encoder);
  125. return NULL;
  126. }
  127. /*
  128. * Connector:
  129. */
  130. struct slave_connector {
  131. struct drm_connector base;
  132. struct drm_encoder *encoder; /* our connected encoder */
  133. struct slave_module *mod;
  134. };
  135. #define to_slave_connector(x) container_of(x, struct slave_connector, base)
  136. static void slave_connector_destroy(struct drm_connector *connector)
  137. {
  138. struct slave_connector *slave_connector = to_slave_connector(connector);
  139. drm_connector_cleanup(connector);
  140. kfree(slave_connector);
  141. }
  142. static enum drm_connector_status slave_connector_detect(
  143. struct drm_connector *connector,
  144. bool force)
  145. {
  146. struct drm_encoder *encoder = to_slave_connector(connector)->encoder;
  147. return get_slave_funcs(encoder)->detect(encoder, connector);
  148. }
  149. static int slave_connector_get_modes(struct drm_connector *connector)
  150. {
  151. struct drm_encoder *encoder = to_slave_connector(connector)->encoder;
  152. return get_slave_funcs(encoder)->get_modes(encoder, connector);
  153. }
  154. static int slave_connector_mode_valid(struct drm_connector *connector,
  155. struct drm_display_mode *mode)
  156. {
  157. struct drm_encoder *encoder = to_slave_connector(connector)->encoder;
  158. struct tilcdc_drm_private *priv = connector->dev->dev_private;
  159. int ret;
  160. ret = tilcdc_crtc_mode_valid(priv->crtc, mode);
  161. if (ret != MODE_OK)
  162. return ret;
  163. return get_slave_funcs(encoder)->mode_valid(encoder, mode);
  164. }
  165. static struct drm_encoder *slave_connector_best_encoder(
  166. struct drm_connector *connector)
  167. {
  168. struct slave_connector *slave_connector = to_slave_connector(connector);
  169. return slave_connector->encoder;
  170. }
  171. static int slave_connector_set_property(struct drm_connector *connector,
  172. struct drm_property *property, uint64_t value)
  173. {
  174. struct drm_encoder *encoder = to_slave_connector(connector)->encoder;
  175. return get_slave_funcs(encoder)->set_property(encoder,
  176. connector, property, value);
  177. }
  178. static const struct drm_connector_funcs slave_connector_funcs = {
  179. .destroy = slave_connector_destroy,
  180. .dpms = drm_helper_connector_dpms,
  181. .detect = slave_connector_detect,
  182. .fill_modes = drm_helper_probe_single_connector_modes,
  183. .set_property = slave_connector_set_property,
  184. };
  185. static const struct drm_connector_helper_funcs slave_connector_helper_funcs = {
  186. .get_modes = slave_connector_get_modes,
  187. .mode_valid = slave_connector_mode_valid,
  188. .best_encoder = slave_connector_best_encoder,
  189. };
  190. static struct drm_connector *slave_connector_create(struct drm_device *dev,
  191. struct slave_module *mod, struct drm_encoder *encoder)
  192. {
  193. struct slave_connector *slave_connector;
  194. struct drm_connector *connector;
  195. int ret;
  196. slave_connector = kzalloc(sizeof(*slave_connector), GFP_KERNEL);
  197. if (!slave_connector) {
  198. dev_err(dev->dev, "allocation failed\n");
  199. return NULL;
  200. }
  201. slave_connector->encoder = encoder;
  202. slave_connector->mod = mod;
  203. connector = &slave_connector->base;
  204. drm_connector_init(dev, connector, &slave_connector_funcs,
  205. DRM_MODE_CONNECTOR_HDMIA);
  206. drm_connector_helper_add(connector, &slave_connector_helper_funcs);
  207. connector->polled = DRM_CONNECTOR_POLL_CONNECT |
  208. DRM_CONNECTOR_POLL_DISCONNECT;
  209. connector->interlace_allowed = 0;
  210. connector->doublescan_allowed = 0;
  211. get_slave_funcs(encoder)->create_resources(encoder, connector);
  212. ret = drm_mode_connector_attach_encoder(connector, encoder);
  213. if (ret)
  214. goto fail;
  215. drm_sysfs_connector_add(connector);
  216. return connector;
  217. fail:
  218. slave_connector_destroy(connector);
  219. return NULL;
  220. }
  221. /*
  222. * Module:
  223. */
  224. static int slave_modeset_init(struct tilcdc_module *mod, struct drm_device *dev)
  225. {
  226. struct slave_module *slave_mod = to_slave_module(mod);
  227. struct tilcdc_drm_private *priv = dev->dev_private;
  228. struct drm_encoder *encoder;
  229. struct drm_connector *connector;
  230. encoder = slave_encoder_create(dev, slave_mod);
  231. if (!encoder)
  232. return -ENOMEM;
  233. connector = slave_connector_create(dev, slave_mod, encoder);
  234. if (!connector)
  235. return -ENOMEM;
  236. priv->encoders[priv->num_encoders++] = encoder;
  237. priv->connectors[priv->num_connectors++] = connector;
  238. return 0;
  239. }
  240. static void slave_destroy(struct tilcdc_module *mod)
  241. {
  242. struct slave_module *slave_mod = to_slave_module(mod);
  243. tilcdc_module_cleanup(mod);
  244. kfree(slave_mod);
  245. }
  246. static const struct tilcdc_module_ops slave_module_ops = {
  247. .modeset_init = slave_modeset_init,
  248. .destroy = slave_destroy,
  249. };
  250. /*
  251. * Device:
  252. */
  253. static struct of_device_id slave_of_match[];
  254. static int slave_probe(struct platform_device *pdev)
  255. {
  256. struct device_node *node = pdev->dev.of_node;
  257. struct device_node *i2c_node;
  258. struct slave_module *slave_mod;
  259. struct tilcdc_module *mod;
  260. struct pinctrl *pinctrl;
  261. uint32_t i2c_phandle;
  262. struct i2c_adapter *slavei2c;
  263. int ret = -EINVAL;
  264. /* bail out early if no DT data: */
  265. if (!node) {
  266. dev_err(&pdev->dev, "device-tree data is missing\n");
  267. return -ENXIO;
  268. }
  269. /* Bail out early if i2c not specified */
  270. if (of_property_read_u32(node, "i2c", &i2c_phandle)) {
  271. dev_err(&pdev->dev, "could not get i2c bus phandle\n");
  272. return ret;
  273. }
  274. i2c_node = of_find_node_by_phandle(i2c_phandle);
  275. if (!i2c_node) {
  276. dev_err(&pdev->dev, "could not get i2c bus node\n");
  277. return ret;
  278. }
  279. /* but defer the probe if it can't be initialized it might come later */
  280. slavei2c = of_find_i2c_adapter_by_node(i2c_node);
  281. of_node_put(i2c_node);
  282. if (!slavei2c) {
  283. ret = -EPROBE_DEFER;
  284. tilcdc_slave_probedefer(true);
  285. dev_err(&pdev->dev, "could not get i2c\n");
  286. return ret;
  287. }
  288. slave_mod = kzalloc(sizeof(*slave_mod), GFP_KERNEL);
  289. if (!slave_mod)
  290. return -ENOMEM;
  291. mod = &slave_mod->base;
  292. mod->preferred_bpp = slave_info.bpp;
  293. slave_mod->i2c = slavei2c;
  294. tilcdc_module_init(mod, "slave", &slave_module_ops);
  295. pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
  296. if (IS_ERR(pinctrl))
  297. dev_warn(&pdev->dev, "pins are not configured\n");
  298. tilcdc_slave_probedefer(false);
  299. return 0;
  300. }
  301. static int slave_remove(struct platform_device *pdev)
  302. {
  303. return 0;
  304. }
  305. static struct of_device_id slave_of_match[] = {
  306. { .compatible = "ti,tilcdc,slave", },
  307. { },
  308. };
  309. struct platform_driver slave_driver = {
  310. .probe = slave_probe,
  311. .remove = slave_remove,
  312. .driver = {
  313. .owner = THIS_MODULE,
  314. .name = "slave",
  315. .of_match_table = slave_of_match,
  316. },
  317. };
  318. int __init tilcdc_slave_init(void)
  319. {
  320. return platform_driver_register(&slave_driver);
  321. }
  322. void __exit tilcdc_slave_fini(void)
  323. {
  324. platform_driver_unregister(&slave_driver);
  325. }