sti_dvo.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) STMicroelectronics SA 2014
  4. * Author: Vincent Abriou <vincent.abriou@st.com> for STMicroelectronics.
  5. */
  6. #include <linux/clk.h>
  7. #include <linux/component.h>
  8. #include <linux/debugfs.h>
  9. #include <linux/module.h>
  10. #include <linux/of_gpio.h>
  11. #include <linux/platform_device.h>
  12. #include <drm/drm_atomic_helper.h>
  13. #include <drm/drm_bridge.h>
  14. #include <drm/drm_device.h>
  15. #include <drm/drm_panel.h>
  16. #include <drm/drm_print.h>
  17. #include <drm/drm_probe_helper.h>
  18. #include "sti_awg_utils.h"
  19. #include "sti_drv.h"
  20. #include "sti_mixer.h"
  21. /* DVO registers */
  22. #define DVO_AWG_DIGSYNC_CTRL 0x0000
  23. #define DVO_DOF_CFG 0x0004
  24. #define DVO_LUT_PROG_LOW 0x0008
  25. #define DVO_LUT_PROG_MID 0x000C
  26. #define DVO_LUT_PROG_HIGH 0x0010
  27. #define DVO_DIGSYNC_INSTR_I 0x0100
  28. #define DVO_AWG_CTRL_EN BIT(0)
  29. #define DVO_AWG_FRAME_BASED_SYNC BIT(2)
  30. #define DVO_DOF_EN_LOWBYTE BIT(0)
  31. #define DVO_DOF_EN_MIDBYTE BIT(1)
  32. #define DVO_DOF_EN_HIGHBYTE BIT(2)
  33. #define DVO_DOF_EN BIT(6)
  34. #define DVO_DOF_MOD_COUNT_SHIFT 8
  35. #define DVO_LUT_ZERO 0
  36. #define DVO_LUT_Y_G 1
  37. #define DVO_LUT_Y_G_DEL 2
  38. #define DVO_LUT_CB_B 3
  39. #define DVO_LUT_CB_B_DEL 4
  40. #define DVO_LUT_CR_R 5
  41. #define DVO_LUT_CR_R_DEL 6
  42. #define DVO_LUT_HOLD 7
  43. struct dvo_config {
  44. u32 flags;
  45. u32 lowbyte;
  46. u32 midbyte;
  47. u32 highbyte;
  48. int (*awg_fwgen_fct)(
  49. struct awg_code_generation_params *fw_gen_params,
  50. struct awg_timing *timing);
  51. };
  52. static struct dvo_config rgb_24bit_de_cfg = {
  53. .flags = (0L << DVO_DOF_MOD_COUNT_SHIFT),
  54. .lowbyte = DVO_LUT_CR_R,
  55. .midbyte = DVO_LUT_Y_G,
  56. .highbyte = DVO_LUT_CB_B,
  57. .awg_fwgen_fct = sti_awg_generate_code_data_enable_mode,
  58. };
  59. /*
  60. * STI digital video output structure
  61. *
  62. * @dev: driver device
  63. * @drm_dev: pointer to drm device
  64. * @mode: current display mode selected
  65. * @regs: dvo registers
  66. * @clk_pix: pixel clock for dvo
  67. * @clk: clock for dvo
  68. * @clk_main_parent: dvo parent clock if main path used
  69. * @clk_aux_parent: dvo parent clock if aux path used
  70. * @panel_node: panel node reference from device tree
  71. * @panel: reference to the panel connected to the dvo
  72. * @enabled: true if dvo is enabled else false
  73. * @encoder: drm_encoder it is bound
  74. */
  75. struct sti_dvo {
  76. struct device dev;
  77. struct drm_device *drm_dev;
  78. struct drm_display_mode mode;
  79. void __iomem *regs;
  80. struct clk *clk_pix;
  81. struct clk *clk;
  82. struct clk *clk_main_parent;
  83. struct clk *clk_aux_parent;
  84. struct device_node *panel_node;
  85. struct drm_panel *panel;
  86. struct dvo_config *config;
  87. bool enabled;
  88. struct drm_encoder *encoder;
  89. struct drm_bridge *bridge;
  90. };
  91. struct sti_dvo_connector {
  92. struct drm_connector drm_connector;
  93. struct drm_encoder *encoder;
  94. struct sti_dvo *dvo;
  95. };
  96. #define to_sti_dvo_connector(x) \
  97. container_of(x, struct sti_dvo_connector, drm_connector)
  98. #define BLANKING_LEVEL 16
  99. static int dvo_awg_generate_code(struct sti_dvo *dvo, u8 *ram_size, u32 *ram_code)
  100. {
  101. struct drm_display_mode *mode = &dvo->mode;
  102. struct dvo_config *config = dvo->config;
  103. struct awg_code_generation_params fw_gen_params;
  104. struct awg_timing timing;
  105. fw_gen_params.ram_code = ram_code;
  106. fw_gen_params.instruction_offset = 0;
  107. timing.total_lines = mode->vtotal;
  108. timing.active_lines = mode->vdisplay;
  109. timing.blanking_lines = mode->vsync_start - mode->vdisplay;
  110. timing.trailing_lines = mode->vtotal - mode->vsync_start;
  111. timing.total_pixels = mode->htotal;
  112. timing.active_pixels = mode->hdisplay;
  113. timing.blanking_pixels = mode->hsync_start - mode->hdisplay;
  114. timing.trailing_pixels = mode->htotal - mode->hsync_start;
  115. timing.blanking_level = BLANKING_LEVEL;
  116. if (config->awg_fwgen_fct(&fw_gen_params, &timing)) {
  117. DRM_ERROR("AWG firmware not properly generated\n");
  118. return -EINVAL;
  119. }
  120. *ram_size = fw_gen_params.instruction_offset;
  121. return 0;
  122. }
  123. /* Configure AWG, writing instructions
  124. *
  125. * @dvo: pointer to DVO structure
  126. * @awg_ram_code: pointer to AWG instructions table
  127. * @nb: nb of AWG instructions
  128. */
  129. static void dvo_awg_configure(struct sti_dvo *dvo, u32 *awg_ram_code, int nb)
  130. {
  131. int i;
  132. DRM_DEBUG_DRIVER("\n");
  133. for (i = 0; i < nb; i++)
  134. writel(awg_ram_code[i],
  135. dvo->regs + DVO_DIGSYNC_INSTR_I + i * 4);
  136. for (i = nb; i < AWG_MAX_INST; i++)
  137. writel(0, dvo->regs + DVO_DIGSYNC_INSTR_I + i * 4);
  138. writel(DVO_AWG_CTRL_EN, dvo->regs + DVO_AWG_DIGSYNC_CTRL);
  139. }
  140. #define DBGFS_DUMP(reg) seq_printf(s, "\n %-25s 0x%08X", #reg, \
  141. readl(dvo->regs + reg))
  142. static void dvo_dbg_awg_microcode(struct seq_file *s, void __iomem *reg)
  143. {
  144. unsigned int i;
  145. seq_puts(s, "\n\n");
  146. seq_puts(s, " DVO AWG microcode:");
  147. for (i = 0; i < AWG_MAX_INST; i++) {
  148. if (i % 8 == 0)
  149. seq_printf(s, "\n %04X:", i);
  150. seq_printf(s, " %04X", readl(reg + i * 4));
  151. }
  152. }
  153. static int dvo_dbg_show(struct seq_file *s, void *data)
  154. {
  155. struct drm_info_node *node = s->private;
  156. struct sti_dvo *dvo = (struct sti_dvo *)node->info_ent->data;
  157. seq_printf(s, "DVO: (vaddr = 0x%p)", dvo->regs);
  158. DBGFS_DUMP(DVO_AWG_DIGSYNC_CTRL);
  159. DBGFS_DUMP(DVO_DOF_CFG);
  160. DBGFS_DUMP(DVO_LUT_PROG_LOW);
  161. DBGFS_DUMP(DVO_LUT_PROG_MID);
  162. DBGFS_DUMP(DVO_LUT_PROG_HIGH);
  163. dvo_dbg_awg_microcode(s, dvo->regs + DVO_DIGSYNC_INSTR_I);
  164. seq_putc(s, '\n');
  165. return 0;
  166. }
  167. static struct drm_info_list dvo_debugfs_files[] = {
  168. { "dvo", dvo_dbg_show, 0, NULL },
  169. };
  170. static void dvo_debugfs_init(struct sti_dvo *dvo, struct drm_minor *minor)
  171. {
  172. unsigned int i;
  173. for (i = 0; i < ARRAY_SIZE(dvo_debugfs_files); i++)
  174. dvo_debugfs_files[i].data = dvo;
  175. drm_debugfs_create_files(dvo_debugfs_files,
  176. ARRAY_SIZE(dvo_debugfs_files),
  177. minor->debugfs_root, minor);
  178. }
  179. static void sti_dvo_disable(struct drm_bridge *bridge)
  180. {
  181. struct sti_dvo *dvo = bridge->driver_private;
  182. if (!dvo->enabled)
  183. return;
  184. DRM_DEBUG_DRIVER("\n");
  185. if (dvo->config->awg_fwgen_fct)
  186. writel(0x00000000, dvo->regs + DVO_AWG_DIGSYNC_CTRL);
  187. writel(0x00000000, dvo->regs + DVO_DOF_CFG);
  188. drm_panel_disable(dvo->panel);
  189. /* Disable/unprepare dvo clock */
  190. clk_disable_unprepare(dvo->clk_pix);
  191. clk_disable_unprepare(dvo->clk);
  192. dvo->enabled = false;
  193. }
  194. static void sti_dvo_pre_enable(struct drm_bridge *bridge)
  195. {
  196. struct sti_dvo *dvo = bridge->driver_private;
  197. struct dvo_config *config = dvo->config;
  198. u32 val;
  199. DRM_DEBUG_DRIVER("\n");
  200. if (dvo->enabled)
  201. return;
  202. /* Make sure DVO is disabled */
  203. writel(0x00000000, dvo->regs + DVO_DOF_CFG);
  204. writel(0x00000000, dvo->regs + DVO_AWG_DIGSYNC_CTRL);
  205. if (config->awg_fwgen_fct) {
  206. u8 nb_instr;
  207. u32 awg_ram_code[AWG_MAX_INST];
  208. /* Configure AWG */
  209. if (!dvo_awg_generate_code(dvo, &nb_instr, awg_ram_code))
  210. dvo_awg_configure(dvo, awg_ram_code, nb_instr);
  211. else
  212. return;
  213. }
  214. /* Prepare/enable clocks */
  215. if (clk_prepare_enable(dvo->clk_pix))
  216. DRM_ERROR("Failed to prepare/enable dvo_pix clk\n");
  217. if (clk_prepare_enable(dvo->clk))
  218. DRM_ERROR("Failed to prepare/enable dvo clk\n");
  219. drm_panel_enable(dvo->panel);
  220. /* Set LUT */
  221. writel(config->lowbyte, dvo->regs + DVO_LUT_PROG_LOW);
  222. writel(config->midbyte, dvo->regs + DVO_LUT_PROG_MID);
  223. writel(config->highbyte, dvo->regs + DVO_LUT_PROG_HIGH);
  224. /* Digital output formatter config */
  225. val = (config->flags | DVO_DOF_EN);
  226. writel(val, dvo->regs + DVO_DOF_CFG);
  227. dvo->enabled = true;
  228. }
  229. static void sti_dvo_set_mode(struct drm_bridge *bridge,
  230. const struct drm_display_mode *mode,
  231. const struct drm_display_mode *adjusted_mode)
  232. {
  233. struct sti_dvo *dvo = bridge->driver_private;
  234. struct sti_mixer *mixer = to_sti_mixer(dvo->encoder->crtc);
  235. int rate = mode->clock * 1000;
  236. struct clk *clkp;
  237. int ret;
  238. DRM_DEBUG_DRIVER("\n");
  239. memcpy(&dvo->mode, mode, sizeof(struct drm_display_mode));
  240. /* According to the path used (main or aux), the dvo clocks should
  241. * have a different parent clock. */
  242. if (mixer->id == STI_MIXER_MAIN)
  243. clkp = dvo->clk_main_parent;
  244. else
  245. clkp = dvo->clk_aux_parent;
  246. if (clkp) {
  247. clk_set_parent(dvo->clk_pix, clkp);
  248. clk_set_parent(dvo->clk, clkp);
  249. }
  250. /* DVO clocks = compositor clock */
  251. ret = clk_set_rate(dvo->clk_pix, rate);
  252. if (ret < 0) {
  253. DRM_ERROR("Cannot set rate (%dHz) for dvo_pix clk\n", rate);
  254. return;
  255. }
  256. ret = clk_set_rate(dvo->clk, rate);
  257. if (ret < 0) {
  258. DRM_ERROR("Cannot set rate (%dHz) for dvo clk\n", rate);
  259. return;
  260. }
  261. /* For now, we only support 24bit data enable (DE) synchro format */
  262. dvo->config = &rgb_24bit_de_cfg;
  263. }
  264. static void sti_dvo_bridge_nope(struct drm_bridge *bridge)
  265. {
  266. /* do nothing */
  267. }
  268. static const struct drm_bridge_funcs sti_dvo_bridge_funcs = {
  269. .pre_enable = sti_dvo_pre_enable,
  270. .enable = sti_dvo_bridge_nope,
  271. .disable = sti_dvo_disable,
  272. .post_disable = sti_dvo_bridge_nope,
  273. .mode_set = sti_dvo_set_mode,
  274. };
  275. static int sti_dvo_connector_get_modes(struct drm_connector *connector)
  276. {
  277. struct sti_dvo_connector *dvo_connector
  278. = to_sti_dvo_connector(connector);
  279. struct sti_dvo *dvo = dvo_connector->dvo;
  280. if (dvo->panel)
  281. return drm_panel_get_modes(dvo->panel, connector);
  282. return 0;
  283. }
  284. #define CLK_TOLERANCE_HZ 50
  285. static int sti_dvo_connector_mode_valid(struct drm_connector *connector,
  286. struct drm_display_mode *mode)
  287. {
  288. int target = mode->clock * 1000;
  289. int target_min = target - CLK_TOLERANCE_HZ;
  290. int target_max = target + CLK_TOLERANCE_HZ;
  291. int result;
  292. struct sti_dvo_connector *dvo_connector
  293. = to_sti_dvo_connector(connector);
  294. struct sti_dvo *dvo = dvo_connector->dvo;
  295. result = clk_round_rate(dvo->clk_pix, target);
  296. DRM_DEBUG_DRIVER("target rate = %d => available rate = %d\n",
  297. target, result);
  298. if ((result < target_min) || (result > target_max)) {
  299. DRM_DEBUG_DRIVER("dvo pixclk=%d not supported\n", target);
  300. return MODE_BAD;
  301. }
  302. return MODE_OK;
  303. }
  304. static const
  305. struct drm_connector_helper_funcs sti_dvo_connector_helper_funcs = {
  306. .get_modes = sti_dvo_connector_get_modes,
  307. .mode_valid = sti_dvo_connector_mode_valid,
  308. };
  309. static enum drm_connector_status
  310. sti_dvo_connector_detect(struct drm_connector *connector, bool force)
  311. {
  312. struct sti_dvo_connector *dvo_connector
  313. = to_sti_dvo_connector(connector);
  314. struct sti_dvo *dvo = dvo_connector->dvo;
  315. DRM_DEBUG_DRIVER("\n");
  316. if (!dvo->panel) {
  317. dvo->panel = of_drm_find_panel(dvo->panel_node);
  318. if (IS_ERR(dvo->panel))
  319. dvo->panel = NULL;
  320. }
  321. if (dvo->panel)
  322. return connector_status_connected;
  323. return connector_status_disconnected;
  324. }
  325. static int sti_dvo_late_register(struct drm_connector *connector)
  326. {
  327. struct sti_dvo_connector *dvo_connector
  328. = to_sti_dvo_connector(connector);
  329. struct sti_dvo *dvo = dvo_connector->dvo;
  330. dvo_debugfs_init(dvo, dvo->drm_dev->primary);
  331. return 0;
  332. }
  333. static const struct drm_connector_funcs sti_dvo_connector_funcs = {
  334. .fill_modes = drm_helper_probe_single_connector_modes,
  335. .detect = sti_dvo_connector_detect,
  336. .destroy = drm_connector_cleanup,
  337. .reset = drm_atomic_helper_connector_reset,
  338. .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
  339. .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
  340. .late_register = sti_dvo_late_register,
  341. };
  342. static struct drm_encoder *sti_dvo_find_encoder(struct drm_device *dev)
  343. {
  344. struct drm_encoder *encoder;
  345. list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  346. if (encoder->encoder_type == DRM_MODE_ENCODER_LVDS)
  347. return encoder;
  348. }
  349. return NULL;
  350. }
  351. static int sti_dvo_bind(struct device *dev, struct device *master, void *data)
  352. {
  353. struct sti_dvo *dvo = dev_get_drvdata(dev);
  354. struct drm_device *drm_dev = data;
  355. struct drm_encoder *encoder;
  356. struct sti_dvo_connector *connector;
  357. struct drm_connector *drm_connector;
  358. struct drm_bridge *bridge;
  359. int err;
  360. /* Set the drm device handle */
  361. dvo->drm_dev = drm_dev;
  362. encoder = sti_dvo_find_encoder(drm_dev);
  363. if (!encoder)
  364. return -ENOMEM;
  365. connector = devm_kzalloc(dev, sizeof(*connector), GFP_KERNEL);
  366. if (!connector)
  367. return -ENOMEM;
  368. connector->dvo = dvo;
  369. bridge = devm_kzalloc(dev, sizeof(*bridge), GFP_KERNEL);
  370. if (!bridge)
  371. return -ENOMEM;
  372. bridge->driver_private = dvo;
  373. bridge->funcs = &sti_dvo_bridge_funcs;
  374. bridge->of_node = dvo->dev.of_node;
  375. drm_bridge_add(bridge);
  376. err = drm_bridge_attach(encoder, bridge, NULL, 0);
  377. if (err) {
  378. DRM_ERROR("Failed to attach bridge\n");
  379. return err;
  380. }
  381. dvo->bridge = bridge;
  382. connector->encoder = encoder;
  383. dvo->encoder = encoder;
  384. drm_connector = (struct drm_connector *)connector;
  385. drm_connector->polled = DRM_CONNECTOR_POLL_HPD;
  386. drm_connector_init(drm_dev, drm_connector,
  387. &sti_dvo_connector_funcs, DRM_MODE_CONNECTOR_LVDS);
  388. drm_connector_helper_add(drm_connector,
  389. &sti_dvo_connector_helper_funcs);
  390. err = drm_connector_attach_encoder(drm_connector, encoder);
  391. if (err) {
  392. DRM_ERROR("Failed to attach a connector to a encoder\n");
  393. goto err_sysfs;
  394. }
  395. return 0;
  396. err_sysfs:
  397. drm_bridge_remove(bridge);
  398. return -EINVAL;
  399. }
  400. static void sti_dvo_unbind(struct device *dev,
  401. struct device *master, void *data)
  402. {
  403. struct sti_dvo *dvo = dev_get_drvdata(dev);
  404. drm_bridge_remove(dvo->bridge);
  405. }
  406. static const struct component_ops sti_dvo_ops = {
  407. .bind = sti_dvo_bind,
  408. .unbind = sti_dvo_unbind,
  409. };
  410. static int sti_dvo_probe(struct platform_device *pdev)
  411. {
  412. struct device *dev = &pdev->dev;
  413. struct sti_dvo *dvo;
  414. struct resource *res;
  415. struct device_node *np = dev->of_node;
  416. DRM_INFO("%s\n", __func__);
  417. dvo = devm_kzalloc(dev, sizeof(*dvo), GFP_KERNEL);
  418. if (!dvo) {
  419. DRM_ERROR("Failed to allocate memory for DVO\n");
  420. return -ENOMEM;
  421. }
  422. dvo->dev = pdev->dev;
  423. res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dvo-reg");
  424. if (!res) {
  425. DRM_ERROR("Invalid dvo resource\n");
  426. return -ENOMEM;
  427. }
  428. dvo->regs = devm_ioremap(dev, res->start,
  429. resource_size(res));
  430. if (!dvo->regs)
  431. return -ENOMEM;
  432. dvo->clk_pix = devm_clk_get(dev, "dvo_pix");
  433. if (IS_ERR(dvo->clk_pix)) {
  434. DRM_ERROR("Cannot get dvo_pix clock\n");
  435. return PTR_ERR(dvo->clk_pix);
  436. }
  437. dvo->clk = devm_clk_get(dev, "dvo");
  438. if (IS_ERR(dvo->clk)) {
  439. DRM_ERROR("Cannot get dvo clock\n");
  440. return PTR_ERR(dvo->clk);
  441. }
  442. dvo->clk_main_parent = devm_clk_get(dev, "main_parent");
  443. if (IS_ERR(dvo->clk_main_parent)) {
  444. DRM_DEBUG_DRIVER("Cannot get main_parent clock\n");
  445. dvo->clk_main_parent = NULL;
  446. }
  447. dvo->clk_aux_parent = devm_clk_get(dev, "aux_parent");
  448. if (IS_ERR(dvo->clk_aux_parent)) {
  449. DRM_DEBUG_DRIVER("Cannot get aux_parent clock\n");
  450. dvo->clk_aux_parent = NULL;
  451. }
  452. dvo->panel_node = of_parse_phandle(np, "sti,panel", 0);
  453. if (!dvo->panel_node)
  454. DRM_ERROR("No panel associated to the dvo output\n");
  455. of_node_put(dvo->panel_node);
  456. platform_set_drvdata(pdev, dvo);
  457. return component_add(&pdev->dev, &sti_dvo_ops);
  458. }
  459. static int sti_dvo_remove(struct platform_device *pdev)
  460. {
  461. component_del(&pdev->dev, &sti_dvo_ops);
  462. return 0;
  463. }
  464. static const struct of_device_id dvo_of_match[] = {
  465. { .compatible = "st,stih407-dvo", },
  466. { /* end node */ }
  467. };
  468. MODULE_DEVICE_TABLE(of, dvo_of_match);
  469. struct platform_driver sti_dvo_driver = {
  470. .driver = {
  471. .name = "sti-dvo",
  472. .owner = THIS_MODULE,
  473. .of_match_table = dvo_of_match,
  474. },
  475. .probe = sti_dvo_probe,
  476. .remove = sti_dvo_remove,
  477. };
  478. MODULE_AUTHOR("Benjamin Gaignard <benjamin.gaignard@st.com>");
  479. MODULE_DESCRIPTION("STMicroelectronics SoC DRM driver");
  480. MODULE_LICENSE("GPL");