rcar_lvds.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * rcar_lvds.c -- R-Car LVDS Encoder
  4. *
  5. * Copyright (C) 2013-2018 Renesas Electronics Corporation
  6. *
  7. * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
  8. */
  9. #include <linux/clk.h>
  10. #include <linux/delay.h>
  11. #include <linux/io.h>
  12. #include <linux/of.h>
  13. #include <linux/of_device.h>
  14. #include <linux/of_graph.h>
  15. #include <linux/platform_device.h>
  16. #include <linux/slab.h>
  17. #include <drm/drm_atomic.h>
  18. #include <drm/drm_atomic_helper.h>
  19. #include <drm/drm_bridge.h>
  20. #include <drm/drm_crtc_helper.h>
  21. #include <drm/drm_panel.h>
  22. #include "rcar_lvds_regs.h"
  23. /* Keep in sync with the LVDCR0.LVMD hardware register values. */
  24. enum rcar_lvds_mode {
  25. RCAR_LVDS_MODE_JEIDA = 0,
  26. RCAR_LVDS_MODE_MIRROR = 1,
  27. RCAR_LVDS_MODE_VESA = 4,
  28. };
  29. #define RCAR_LVDS_QUIRK_LANES (1 << 0) /* LVDS lanes 1 and 3 inverted */
  30. #define RCAR_LVDS_QUIRK_GEN2_PLLCR (1 << 1) /* LVDPLLCR has gen2 layout */
  31. #define RCAR_LVDS_QUIRK_GEN3_LVEN (1 << 2) /* LVEN bit needs to be set */
  32. /* on R8A77970/R8A7799x */
  33. struct rcar_lvds_device_info {
  34. unsigned int gen;
  35. unsigned int quirks;
  36. };
  37. struct rcar_lvds {
  38. struct device *dev;
  39. const struct rcar_lvds_device_info *info;
  40. struct drm_bridge bridge;
  41. struct drm_bridge *next_bridge;
  42. struct drm_connector connector;
  43. struct drm_panel *panel;
  44. void __iomem *mmio;
  45. struct clk *clock;
  46. bool enabled;
  47. struct drm_display_mode display_mode;
  48. enum rcar_lvds_mode mode;
  49. };
  50. #define bridge_to_rcar_lvds(bridge) \
  51. container_of(bridge, struct rcar_lvds, bridge)
  52. #define connector_to_rcar_lvds(connector) \
  53. container_of(connector, struct rcar_lvds, connector)
  54. static void rcar_lvds_write(struct rcar_lvds *lvds, u32 reg, u32 data)
  55. {
  56. iowrite32(data, lvds->mmio + reg);
  57. }
  58. /* -----------------------------------------------------------------------------
  59. * Connector & Panel
  60. */
  61. static int rcar_lvds_connector_get_modes(struct drm_connector *connector)
  62. {
  63. struct rcar_lvds *lvds = connector_to_rcar_lvds(connector);
  64. return drm_panel_get_modes(lvds->panel);
  65. }
  66. static int rcar_lvds_connector_atomic_check(struct drm_connector *connector,
  67. struct drm_connector_state *state)
  68. {
  69. struct rcar_lvds *lvds = connector_to_rcar_lvds(connector);
  70. const struct drm_display_mode *panel_mode;
  71. struct drm_crtc_state *crtc_state;
  72. if (list_empty(&connector->modes)) {
  73. dev_dbg(lvds->dev, "connector: empty modes list\n");
  74. return -EINVAL;
  75. }
  76. panel_mode = list_first_entry(&connector->modes,
  77. struct drm_display_mode, head);
  78. /* We're not allowed to modify the resolution. */
  79. crtc_state = drm_atomic_get_crtc_state(state->state, state->crtc);
  80. if (IS_ERR(crtc_state))
  81. return PTR_ERR(crtc_state);
  82. if (crtc_state->mode.hdisplay != panel_mode->hdisplay ||
  83. crtc_state->mode.vdisplay != panel_mode->vdisplay)
  84. return -EINVAL;
  85. /* The flat panel mode is fixed, just copy it to the adjusted mode. */
  86. drm_mode_copy(&crtc_state->adjusted_mode, panel_mode);
  87. return 0;
  88. }
  89. static const struct drm_connector_helper_funcs rcar_lvds_conn_helper_funcs = {
  90. .get_modes = rcar_lvds_connector_get_modes,
  91. .atomic_check = rcar_lvds_connector_atomic_check,
  92. };
  93. static const struct drm_connector_funcs rcar_lvds_conn_funcs = {
  94. .reset = drm_atomic_helper_connector_reset,
  95. .fill_modes = drm_helper_probe_single_connector_modes,
  96. .destroy = drm_connector_cleanup,
  97. .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
  98. .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
  99. };
  100. /* -----------------------------------------------------------------------------
  101. * Bridge
  102. */
  103. static u32 rcar_lvds_lvdpllcr_gen2(unsigned int freq)
  104. {
  105. if (freq < 39000)
  106. return LVDPLLCR_CEEN | LVDPLLCR_COSEL | LVDPLLCR_PLLDLYCNT_38M;
  107. else if (freq < 61000)
  108. return LVDPLLCR_CEEN | LVDPLLCR_COSEL | LVDPLLCR_PLLDLYCNT_60M;
  109. else if (freq < 121000)
  110. return LVDPLLCR_CEEN | LVDPLLCR_COSEL | LVDPLLCR_PLLDLYCNT_121M;
  111. else
  112. return LVDPLLCR_PLLDLYCNT_150M;
  113. }
  114. static u32 rcar_lvds_lvdpllcr_gen3(unsigned int freq)
  115. {
  116. if (freq < 42000)
  117. return LVDPLLCR_PLLDIVCNT_42M;
  118. else if (freq < 85000)
  119. return LVDPLLCR_PLLDIVCNT_85M;
  120. else if (freq < 128000)
  121. return LVDPLLCR_PLLDIVCNT_128M;
  122. else
  123. return LVDPLLCR_PLLDIVCNT_148M;
  124. }
  125. static void rcar_lvds_enable(struct drm_bridge *bridge)
  126. {
  127. struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);
  128. const struct drm_display_mode *mode = &lvds->display_mode;
  129. /*
  130. * FIXME: We should really retrieve the CRTC through the state, but how
  131. * do we get a state pointer?
  132. */
  133. struct drm_crtc *crtc = lvds->bridge.encoder->crtc;
  134. u32 lvdpllcr;
  135. u32 lvdhcr;
  136. u32 lvdcr0;
  137. int ret;
  138. WARN_ON(lvds->enabled);
  139. ret = clk_prepare_enable(lvds->clock);
  140. if (ret < 0)
  141. return;
  142. /*
  143. * Hardcode the channels and control signals routing for now.
  144. *
  145. * HSYNC -> CTRL0
  146. * VSYNC -> CTRL1
  147. * DISP -> CTRL2
  148. * 0 -> CTRL3
  149. */
  150. rcar_lvds_write(lvds, LVDCTRCR, LVDCTRCR_CTR3SEL_ZERO |
  151. LVDCTRCR_CTR2SEL_DISP | LVDCTRCR_CTR1SEL_VSYNC |
  152. LVDCTRCR_CTR0SEL_HSYNC);
  153. if (lvds->info->quirks & RCAR_LVDS_QUIRK_LANES)
  154. lvdhcr = LVDCHCR_CHSEL_CH(0, 0) | LVDCHCR_CHSEL_CH(1, 3)
  155. | LVDCHCR_CHSEL_CH(2, 2) | LVDCHCR_CHSEL_CH(3, 1);
  156. else
  157. lvdhcr = LVDCHCR_CHSEL_CH(0, 0) | LVDCHCR_CHSEL_CH(1, 1)
  158. | LVDCHCR_CHSEL_CH(2, 2) | LVDCHCR_CHSEL_CH(3, 3);
  159. rcar_lvds_write(lvds, LVDCHCR, lvdhcr);
  160. /* PLL clock configuration. */
  161. if (lvds->info->quirks & RCAR_LVDS_QUIRK_GEN2_PLLCR)
  162. lvdpllcr = rcar_lvds_lvdpllcr_gen2(mode->clock);
  163. else
  164. lvdpllcr = rcar_lvds_lvdpllcr_gen3(mode->clock);
  165. rcar_lvds_write(lvds, LVDPLLCR, lvdpllcr);
  166. /* Set the LVDS mode and select the input. */
  167. lvdcr0 = lvds->mode << LVDCR0_LVMD_SHIFT;
  168. if (drm_crtc_index(crtc) == 2)
  169. lvdcr0 |= LVDCR0_DUSEL;
  170. rcar_lvds_write(lvds, LVDCR0, lvdcr0);
  171. /* Turn all the channels on. */
  172. rcar_lvds_write(lvds, LVDCR1,
  173. LVDCR1_CHSTBY(3) | LVDCR1_CHSTBY(2) |
  174. LVDCR1_CHSTBY(1) | LVDCR1_CHSTBY(0) | LVDCR1_CLKSTBY);
  175. if (lvds->info->gen < 3) {
  176. /* Enable LVDS operation and turn the bias circuitry on. */
  177. lvdcr0 |= LVDCR0_BEN | LVDCR0_LVEN;
  178. rcar_lvds_write(lvds, LVDCR0, lvdcr0);
  179. }
  180. /* Turn the PLL on. */
  181. lvdcr0 |= LVDCR0_PLLON;
  182. rcar_lvds_write(lvds, LVDCR0, lvdcr0);
  183. if (lvds->info->gen > 2) {
  184. /* Set LVDS normal mode. */
  185. lvdcr0 |= LVDCR0_PWD;
  186. rcar_lvds_write(lvds, LVDCR0, lvdcr0);
  187. }
  188. if (lvds->info->quirks & RCAR_LVDS_QUIRK_GEN3_LVEN) {
  189. /* Turn on the LVDS PHY. */
  190. lvdcr0 |= LVDCR0_LVEN;
  191. rcar_lvds_write(lvds, LVDCR0, lvdcr0);
  192. }
  193. /* Wait for the startup delay. */
  194. usleep_range(100, 150);
  195. /* Turn the output on. */
  196. lvdcr0 |= LVDCR0_LVRES;
  197. rcar_lvds_write(lvds, LVDCR0, lvdcr0);
  198. if (lvds->panel) {
  199. drm_panel_prepare(lvds->panel);
  200. drm_panel_enable(lvds->panel);
  201. }
  202. lvds->enabled = true;
  203. }
  204. static void rcar_lvds_disable(struct drm_bridge *bridge)
  205. {
  206. struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);
  207. WARN_ON(!lvds->enabled);
  208. if (lvds->panel) {
  209. drm_panel_disable(lvds->panel);
  210. drm_panel_unprepare(lvds->panel);
  211. }
  212. rcar_lvds_write(lvds, LVDCR0, 0);
  213. rcar_lvds_write(lvds, LVDCR1, 0);
  214. clk_disable_unprepare(lvds->clock);
  215. lvds->enabled = false;
  216. }
  217. static bool rcar_lvds_mode_fixup(struct drm_bridge *bridge,
  218. const struct drm_display_mode *mode,
  219. struct drm_display_mode *adjusted_mode)
  220. {
  221. /*
  222. * The internal LVDS encoder has a restricted clock frequency operating
  223. * range (31MHz to 148.5MHz). Clamp the clock accordingly.
  224. */
  225. adjusted_mode->clock = clamp(adjusted_mode->clock, 31000, 148500);
  226. return true;
  227. }
  228. static void rcar_lvds_get_lvds_mode(struct rcar_lvds *lvds)
  229. {
  230. struct drm_display_info *info = &lvds->connector.display_info;
  231. enum rcar_lvds_mode mode;
  232. /*
  233. * There is no API yet to retrieve LVDS mode from a bridge, only panels
  234. * are supported.
  235. */
  236. if (!lvds->panel)
  237. return;
  238. if (!info->num_bus_formats || !info->bus_formats) {
  239. dev_err(lvds->dev, "no LVDS bus format reported\n");
  240. return;
  241. }
  242. switch (info->bus_formats[0]) {
  243. case MEDIA_BUS_FMT_RGB666_1X7X3_SPWG:
  244. case MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA:
  245. mode = RCAR_LVDS_MODE_JEIDA;
  246. break;
  247. case MEDIA_BUS_FMT_RGB888_1X7X4_SPWG:
  248. mode = RCAR_LVDS_MODE_VESA;
  249. break;
  250. default:
  251. dev_err(lvds->dev, "unsupported LVDS bus format 0x%04x\n",
  252. info->bus_formats[0]);
  253. return;
  254. }
  255. if (info->bus_flags & DRM_BUS_FLAG_DATA_LSB_TO_MSB)
  256. mode |= RCAR_LVDS_MODE_MIRROR;
  257. lvds->mode = mode;
  258. }
  259. static void rcar_lvds_mode_set(struct drm_bridge *bridge,
  260. struct drm_display_mode *mode,
  261. struct drm_display_mode *adjusted_mode)
  262. {
  263. struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);
  264. WARN_ON(lvds->enabled);
  265. lvds->display_mode = *adjusted_mode;
  266. rcar_lvds_get_lvds_mode(lvds);
  267. }
  268. static int rcar_lvds_attach(struct drm_bridge *bridge)
  269. {
  270. struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);
  271. struct drm_connector *connector = &lvds->connector;
  272. struct drm_encoder *encoder = bridge->encoder;
  273. int ret;
  274. /* If we have a next bridge just attach it. */
  275. if (lvds->next_bridge)
  276. return drm_bridge_attach(bridge->encoder, lvds->next_bridge,
  277. bridge);
  278. /* Otherwise we have a panel, create a connector. */
  279. ret = drm_connector_init(bridge->dev, connector, &rcar_lvds_conn_funcs,
  280. DRM_MODE_CONNECTOR_LVDS);
  281. if (ret < 0)
  282. return ret;
  283. drm_connector_helper_add(connector, &rcar_lvds_conn_helper_funcs);
  284. ret = drm_mode_connector_attach_encoder(connector, encoder);
  285. if (ret < 0)
  286. return ret;
  287. return drm_panel_attach(lvds->panel, connector);
  288. }
  289. static void rcar_lvds_detach(struct drm_bridge *bridge)
  290. {
  291. struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);
  292. if (lvds->panel)
  293. drm_panel_detach(lvds->panel);
  294. }
  295. static const struct drm_bridge_funcs rcar_lvds_bridge_ops = {
  296. .attach = rcar_lvds_attach,
  297. .detach = rcar_lvds_detach,
  298. .enable = rcar_lvds_enable,
  299. .disable = rcar_lvds_disable,
  300. .mode_fixup = rcar_lvds_mode_fixup,
  301. .mode_set = rcar_lvds_mode_set,
  302. };
  303. /* -----------------------------------------------------------------------------
  304. * Probe & Remove
  305. */
  306. static int rcar_lvds_parse_dt(struct rcar_lvds *lvds)
  307. {
  308. struct device_node *local_output = NULL;
  309. struct device_node *remote_input = NULL;
  310. struct device_node *remote = NULL;
  311. struct device_node *node;
  312. bool is_bridge = false;
  313. int ret = 0;
  314. local_output = of_graph_get_endpoint_by_regs(lvds->dev->of_node, 1, 0);
  315. if (!local_output) {
  316. dev_dbg(lvds->dev, "unconnected port@1\n");
  317. return -ENODEV;
  318. }
  319. /*
  320. * Locate the connected entity and infer its type from the number of
  321. * endpoints.
  322. */
  323. remote = of_graph_get_remote_port_parent(local_output);
  324. if (!remote) {
  325. dev_dbg(lvds->dev, "unconnected endpoint %pOF\n", local_output);
  326. ret = -ENODEV;
  327. goto done;
  328. }
  329. if (!of_device_is_available(remote)) {
  330. dev_dbg(lvds->dev, "connected entity %pOF is disabled\n",
  331. remote);
  332. ret = -ENODEV;
  333. goto done;
  334. }
  335. remote_input = of_graph_get_remote_endpoint(local_output);
  336. for_each_endpoint_of_node(remote, node) {
  337. if (node != remote_input) {
  338. /*
  339. * We've found one endpoint other than the input, this
  340. * must be a bridge.
  341. */
  342. is_bridge = true;
  343. of_node_put(node);
  344. break;
  345. }
  346. }
  347. if (is_bridge) {
  348. lvds->next_bridge = of_drm_find_bridge(remote);
  349. if (!lvds->next_bridge)
  350. ret = -EPROBE_DEFER;
  351. } else {
  352. lvds->panel = of_drm_find_panel(remote);
  353. if (!lvds->panel)
  354. ret = -EPROBE_DEFER;
  355. }
  356. done:
  357. of_node_put(local_output);
  358. of_node_put(remote_input);
  359. of_node_put(remote);
  360. return ret;
  361. }
  362. static int rcar_lvds_probe(struct platform_device *pdev)
  363. {
  364. struct rcar_lvds *lvds;
  365. struct resource *mem;
  366. int ret;
  367. lvds = devm_kzalloc(&pdev->dev, sizeof(*lvds), GFP_KERNEL);
  368. if (lvds == NULL)
  369. return -ENOMEM;
  370. platform_set_drvdata(pdev, lvds);
  371. lvds->dev = &pdev->dev;
  372. lvds->info = of_device_get_match_data(&pdev->dev);
  373. lvds->enabled = false;
  374. ret = rcar_lvds_parse_dt(lvds);
  375. if (ret < 0)
  376. return ret;
  377. lvds->bridge.driver_private = lvds;
  378. lvds->bridge.funcs = &rcar_lvds_bridge_ops;
  379. lvds->bridge.of_node = pdev->dev.of_node;
  380. mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  381. lvds->mmio = devm_ioremap_resource(&pdev->dev, mem);
  382. if (IS_ERR(lvds->mmio))
  383. return PTR_ERR(lvds->mmio);
  384. lvds->clock = devm_clk_get(&pdev->dev, NULL);
  385. if (IS_ERR(lvds->clock)) {
  386. dev_err(&pdev->dev, "failed to get clock\n");
  387. return PTR_ERR(lvds->clock);
  388. }
  389. drm_bridge_add(&lvds->bridge);
  390. return 0;
  391. }
  392. static int rcar_lvds_remove(struct platform_device *pdev)
  393. {
  394. struct rcar_lvds *lvds = platform_get_drvdata(pdev);
  395. drm_bridge_remove(&lvds->bridge);
  396. return 0;
  397. }
  398. static const struct rcar_lvds_device_info rcar_lvds_gen2_info = {
  399. .gen = 2,
  400. .quirks = RCAR_LVDS_QUIRK_GEN2_PLLCR,
  401. };
  402. static const struct rcar_lvds_device_info rcar_lvds_r8a7790_info = {
  403. .gen = 2,
  404. .quirks = RCAR_LVDS_QUIRK_GEN2_PLLCR | RCAR_LVDS_QUIRK_LANES,
  405. };
  406. static const struct rcar_lvds_device_info rcar_lvds_gen3_info = {
  407. .gen = 3,
  408. };
  409. static const struct rcar_lvds_device_info rcar_lvds_r8a77970_info = {
  410. .gen = 3,
  411. .quirks = RCAR_LVDS_QUIRK_GEN2_PLLCR | RCAR_LVDS_QUIRK_GEN3_LVEN,
  412. };
  413. static const struct of_device_id rcar_lvds_of_table[] = {
  414. { .compatible = "renesas,r8a7743-lvds", .data = &rcar_lvds_gen2_info },
  415. { .compatible = "renesas,r8a7790-lvds", .data = &rcar_lvds_r8a7790_info },
  416. { .compatible = "renesas,r8a7791-lvds", .data = &rcar_lvds_gen2_info },
  417. { .compatible = "renesas,r8a7793-lvds", .data = &rcar_lvds_gen2_info },
  418. { .compatible = "renesas,r8a7795-lvds", .data = &rcar_lvds_gen3_info },
  419. { .compatible = "renesas,r8a7796-lvds", .data = &rcar_lvds_gen3_info },
  420. { .compatible = "renesas,r8a77970-lvds", .data = &rcar_lvds_r8a77970_info },
  421. { }
  422. };
  423. MODULE_DEVICE_TABLE(of, rcar_lvds_of_table);
  424. static struct platform_driver rcar_lvds_platform_driver = {
  425. .probe = rcar_lvds_probe,
  426. .remove = rcar_lvds_remove,
  427. .driver = {
  428. .name = "rcar-lvds",
  429. .of_match_table = rcar_lvds_of_table,
  430. },
  431. };
  432. module_platform_driver(rcar_lvds_platform_driver);
  433. MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
  434. MODULE_DESCRIPTION("Renesas R-Car LVDS Encoder Driver");
  435. MODULE_LICENSE("GPL");