API tools faq
paste
Guest User

Untitled

a guest
Oct 25th, 2023
201
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 16.87 KB | Source Code | 0 0
raw download clone embed print report
  1. #include <drm/drm_mipi_dsi.h>
  2. #include <drm/drm_modes.h>
  3. #include <drm/drm_panel.h>
  4. #include <drm/drm_print.h>
  5.  
  6. #include <linux/gpio/consumer.h>
  7. #include <linux/delay.h>
  8. #include <linux/module.h>
  9. #include <linux/of_device.h>
  10. #include <linux/regulator/consumer.h>
  11.  
  12. #include <linux/device.h>
  13. #include <linux/i2c.h>
  14. #include <linux/kernel.h>
  15. #include <linux/of.h>
  16. #include <linux/of_graph.h>
  17. #include <drm/drm_crtc.h>
  18. #include <drm/drm_device.h>
  19. #include <video/display_timing.h>
  20. #include <video/videomode.h>
  21. #include <linux/backlight.h>
  22.  
  23. #define DSI_DRIVER_NAME "panel-er88577b"
  24.  
  25. enum cmd_type {
  26.     CMD_TYPE_DCS,
  27.     CMD_TYPE_DELAY,
  28. };
  29.  
  30. struct er88577b_init_cmd {
  31.     enum cmd_type type;
  32.     const char *data;
  33.     size_t len;
  34. };
  35.  
  36. #define _INIT_CMD_DCS(...)                  \
  37.     {                           \
  38.         .type   = CMD_TYPE_DCS,             \
  39.         .data   = (char[]){__VA_ARGS__},        \
  40.         .len    = sizeof((char[]){__VA_ARGS__})     \
  41.     }                           \
  42.  
  43. #define _INIT_CMD_DELAY(...)                    \
  44.     {                           \
  45.         .type   = CMD_TYPE_DELAY,           \
  46.         .data   = (char[]){__VA_ARGS__},        \
  47.         .len    = sizeof((char[]){__VA_ARGS__})     \
  48.     }                           \
  49.  
  50. struct er88577b_panel_desc {
  51.     const struct drm_display_mode mode;
  52.     unsigned int lanes;
  53.     enum mipi_dsi_pixel_format format;
  54.     const struct er88577b_init_cmd *init_cmds;
  55.     u32 num_init_cmds;
  56.     const struct display_timing *timings;
  57.     unsigned int num_timings;
  58. };
  59.  
  60. struct er88577b {
  61.     struct drm_panel panel;
  62.     struct mipi_dsi_device *dsi;
  63.     const struct er88577b_panel_desc *desc;
  64.  
  65.     struct gpio_desc *reset; //30
  66. //  struct backlight_device *backlight;
  67.  
  68. //  bool enable_initialized;
  69. };
  70.  
  71. static inline struct er88577b *panel_to_er88577b(struct drm_panel *panel)
  72. {
  73.     return container_of(panel, struct er88577b, panel);
  74. }
  75.  
  76. static int show_reg(struct mipi_dsi_device *dsi, uint8_t cmd, size_t len)
  77. {
  78.     uint8_t buf[4] = {0};
  79.     int err;
  80.     ssize_t count;
  81.     struct device *dev = &dsi->dev;
  82.     char result_str[16];
  83.  
  84.     err = mipi_dsi_set_maximum_return_packet_size(dsi, len);
  85.     if (err<0) DRM_DEV_ERROR(dev, "failed to set max return packet size for cmd 0x%02x, ret = %d\n", cmd, err);
  86.  
  87.     count= mipi_dsi_dcs_read(dsi, cmd, buf, len);
  88.     if (count<0) {
  89.         DRM_DEV_ERROR(dev, "failed to read cmd 0x%02x, ret = %ld\n", cmd, count);
  90.         return count;
  91.     }
  92.     sprintf(result_str, "%02x %02x %02x %02x", buf[0], buf[1], buf[2], buf[3]);
  93.     if ((count>0)&&(count<4)) result_str[3*count-1]=0;
  94.     DRM_DEV_INFO(dev, "cmd 0x%02x returned %ld bytes: %s\n", cmd, count, result_str);
  95.     return 0;
  96. }
  97.  
  98. static void show_regs(struct mipi_dsi_device *dsi)
  99. {
  100.     int i;
  101.     static const uint8_t read_commands[]= {0x05, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  102.         0x52, 0x54, 0x56, 0xda, 0xdb, 0xdc, 0x04, 0x09, 0x45, 0x0a};
  103.     static const uint8_t read_len[]= {1, 1, 1, 1, 1, 1, 1,
  104.         1, 1, 1, 1, 1, 1, 3, 4, 2, 1};
  105.  
  106.     for (i=0; i<sizeof(read_commands); i++) show_reg(dsi, read_commands[i], read_len[i]);
  107. }
  108.  
  109. static void toggle_display(struct mipi_dsi_device *dsi)
  110. {
  111.     int i;
  112.     int err;
  113.     struct device *dev = &dsi->dev;
  114.  
  115.     DRM_DEV_INFO(dev, "Toggling pixels on-off\n");
  116.     for (i=0; i<20; i++) {
  117.         err = mipi_dsi_dcs_write(dsi, 0x23, NULL, 0);
  118.         if (err < 0)
  119.             DRM_DEV_ERROR(dev, "failed to set all pixels ON, ret = %d\n", err);
  120.         msleep(500);
  121.         err = mipi_dsi_dcs_write(dsi, 0x22, NULL, 0);
  122.         if (err < 0)
  123.             DRM_DEV_ERROR(dev, "failed to set all pixels OFF, ret = %d\n", err);
  124.         msleep(500);
  125.     }
  126.  
  127.  
  128.     DRM_DEV_INFO(dev, "Returning normal mode\n");
  129.     err = mipi_dsi_dcs_write(dsi, 0x13, NULL, 0);
  130.     if (err < 0)
  131.         DRM_DEV_ERROR(dev, "failed to set Normal ON, ret = %d\n", err);
  132.     msleep(10);
  133. }
  134.  
  135. static int set_brightness(struct mipi_dsi_device *dsi, uint8_t param)
  136. {
  137.     struct device *dev = &dsi->dev;
  138.     int err;
  139.  
  140.     DRM_DEV_INFO(dev, "Setting brightness to %d in %s mode\n", param,
  141.         dsi->mode_flags&MIPI_DSI_MODE_LPM?"LP":"HS");
  142.  
  143.     err = mipi_dsi_dcs_write(dsi, 0x51, &param, 1);;
  144.     if (err < 0) {
  145.         DRM_DEV_ERROR(dev, "failed to set brightness ret = %d\n", err);
  146.         return err;
  147.     }
  148.     msleep(10);
  149.     return 0;
  150. }
  151.  
  152. static int exit_sleep(struct drm_panel *panel)
  153. {
  154.     struct er88577b *er88577b = panel_to_er88577b(panel);
  155.     struct mipi_dsi_device *dsi = er88577b->dsi;
  156.     struct device *dev = &dsi->dev;
  157.     int err;
  158.     uint8_t param;
  159.  
  160.     DRM_DEV_INFO(dev, "Exiting sleep mode\n");
  161.     err = mipi_dsi_dcs_exit_sleep_mode(dsi);
  162.     if (err < 0) {
  163.         DRM_DEV_ERROR(dev, "failed to exit sleep mode ret = %d\n", err);
  164.         return err;
  165.     }
  166.     msleep(150);
  167.  
  168.     DRM_DEV_INFO(dev, "Setting display ON\n");
  169.     err =  mipi_dsi_dcs_set_display_on(dsi);
  170.     if (err < 0) {
  171.         DRM_DEV_ERROR(dev, "failed to set display on ret = %d\n", err);
  172.         return err;
  173.     }
  174.     msleep(10);
  175.  
  176.     DRM_DEV_INFO(dev, "Enabling brightness control\n");
  177.     param=0x24;
  178.     err = mipi_dsi_dcs_write(dsi, 0x53, &param, 1);
  179.     if (err < 0) {
  180.         DRM_DEV_ERROR(dev, "failed to write display control ret = %d\n", err);
  181.         return err;
  182.     }
  183.     msleep(10);
  184.  
  185.     set_brightness(dsi,255);
  186.  
  187.     show_regs(dsi);
  188.  
  189.     msleep(10);
  190.     toggle_display(dsi);
  191. /*
  192.     DRM_DEV_INFO(dev, "Reading power mode\n");
  193.     err =  mipi_dsi_dcs_get_power_mode(dsi, &mode);
  194.     if (err < 0) {
  195.         DRM_DEV_ERROR(dev, "failed to read power mode ret = %d\n", err);
  196. //      return err;
  197.     }
  198.     DRM_DEV_INFO(dev, "Mode=0x%02x\n", mode);
  199. */
  200.     msleep(150);
  201.  
  202.     return 0;
  203. }
  204.  
  205. static int init_display(struct drm_panel *panel)
  206. {
  207.     struct er88577b *er88577b = panel_to_er88577b(panel);
  208.     const struct er88577b_panel_desc *desc = er88577b->desc;
  209.     struct mipi_dsi_device *dsi = er88577b->dsi;
  210.     struct device *dev = &dsi->dev;
  211.     unsigned int i;
  212.     int err;
  213.  
  214.     DRM_DEV_INFO(dev, "In init_display\n");
  215.     DRM_DEV_INFO(dev, "Toggling reset\n");
  216.  
  217. //  gpiod_direction_output(er88577b->reset, 0);
  218. //  mdelay(100);
  219.     gpiod_set_value(er88577b->reset, 1);
  220.     mdelay(150);
  221.     gpiod_set_value(er88577b->reset, 0);
  222.     mdelay(200);
  223. /*
  224.     DRM_DEV_INFO(dev, "Exiting sleep mode\n");
  225.     err = mipi_dsi_dcs_exit_sleep_mode(dsi);
  226.     if (err < 0) {
  227.         DRM_DEV_ERROR(dev, "failed to exit sleep mode ret = %d\n", err);
  228.         return err;
  229.     }
  230.     msleep(150);
  231. */
  232.  
  233.     for (i = 0; i < desc->num_init_cmds; i++) {
  234.         const struct er88577b_init_cmd *cmd = &desc->init_cmds[i];
  235.  
  236.         switch (cmd->type) {
  237.         case CMD_TYPE_DELAY:
  238.             DRM_DEV_INFO(dev, "Waiting %d ms\n", cmd->data[0]);
  239.             msleep(cmd->data[0]);
  240.             err = 0;
  241.             break;
  242.         case CMD_TYPE_DCS:
  243.             /*err = mipi_dsi_dcs_write(dsi, cmd->data[0],
  244.                          cmd->len <= 1 ? NULL : &cmd->data[1],
  245.                          cmd->len - 1);
  246.             */
  247.             DRM_DEV_INFO(dev, "Writing command starting with 0x%02x\n", cmd->data[0]);
  248.             err = mipi_dsi_dcs_write_buffer(dsi, cmd->data, cmd->len);
  249.             break;
  250.         default:
  251.             err = -EINVAL;
  252.         }
  253.  
  254.         if (err < 0) {
  255.             DRM_DEV_ERROR(dev, "failed to write CMD#0x%x, err=%d\n", cmd->data[0], err);
  256.             //msleep(120);
  257.             return err;
  258.         }
  259.  
  260.     }
  261.  
  262.  
  263.     return exit_sleep(panel);
  264. }
  265.  
  266. static int er88577b_enable(struct drm_panel *panel)
  267. {
  268.     struct er88577b *er88577b = panel_to_er88577b(panel);
  269. //  const struct er88577b_panel_desc *desc = er88577b->desc;
  270.     struct mipi_dsi_device *dsi = er88577b->dsi;
  271.     struct device *dev = &dsi->dev;
  272.     unsigned int i;
  273. //  int err;
  274.  
  275.     DRM_DEV_INFO(dev, "In er88577b_enable\n");
  276. //  dsi->mode_flags &= ~MIPI_DSI_MODE_LPM;
  277. //  DRM_DEV_INFO(dev, "Enabling display\n");
  278. //  if (er88577b->enable_initialized == true)
  279. //      return 0;
  280.  
  281. //  exit_sleep(panel);
  282. //  backlight_enable(er88577b->backlight);
  283.  
  284. //  er88577b->enable_initialized = true ;
  285.     DRM_DEV_INFO(dev, "Reading registers in LP mode:\n");
  286.     show_regs(dsi);
  287.  
  288.     DRM_DEV_INFO(dev, "Trying to set brightness in HS mode, then read it back in LP:\n");
  289.     for(i=0; i<255; i+=15) {
  290.         dsi->mode_flags &= ~MIPI_DSI_MODE_LPM;
  291.         set_brightness(dsi, i);
  292.         dsi->mode_flags |= MIPI_DSI_MODE_LPM;
  293.         show_reg(dsi, 0x52, 1);
  294.     }
  295.  
  296.     dsi->mode_flags &= ~MIPI_DSI_MODE_LPM;
  297.     DRM_DEV_INFO(dev, "Reading registers in HS mode:\n");
  298.     show_regs(dsi);
  299.  
  300. //  toggle_display(dsi);
  301.  
  302.     return 0;
  303. }
  304.  
  305. static int er88577b_disable(struct drm_panel *panel)
  306. {
  307.     struct device *dev = panel->dev;
  308. //  struct er88577b *er88577b = panel_to_er88577b(panel);
  309. //  int ret;
  310.  
  311.     DRM_DEV_INFO(dev, "In er88577b_disable\n");
  312. //  backlight_disable(er88577b->backlight);
  313.  
  314. //  DRM_DEV_INFO(dev, "Disabling display\n");
  315. //  ret = mipi_dsi_dcs_set_display_off(er88577b->dsi);
  316. //  if (ret < 0)
  317. //      DRM_DEV_ERROR(dev, "failed to set display off: %d\n", ret);
  318.  
  319. //  ret = mipi_dsi_dcs_enter_sleep_mode(er88577b->dsi);
  320. //  if (ret < 0)
  321. //      DRM_DEV_ERROR(dev, "failed to enter sleep mode: %d\n", ret);
  322.  
  323. //  er88577b->enable_initialized = false;
  324.  
  325.     return 0;
  326. }
  327.  
  328. static int er88577b_prepare(struct drm_panel *panel)
  329. {
  330. //  struct er88577b *er88577b = panel_to_er88577b(panel);
  331. //  const struct er88577b_panel_desc *desc = er88577b->desc;
  332. //  struct mipi_dsi_device *dsi = er88577b->dsi;
  333.     struct device *dev = panel->dev;
  334.     unsigned int i;
  335. //  int err;
  336.  
  337.     DRM_DEV_INFO(dev, "In er88577b_prepare\n");
  338.  
  339. //  if (er88577b->enable_initialized == true)
  340. //      return 0;
  341.  
  342.     for (i=0; i<20; i++) if (init_display(panel)>=0) break;
  343.  
  344. /*
  345.     gpiod_direction_output(er88577b->enable, 0);
  346.     gpiod_set_value(er88577b->enable, 1);
  347.     mdelay(100);
  348. */
  349. /*
  350.     DRM_DEV_INFO(dev, "Toggling reset\n");
  351.  
  352.     gpiod_direction_output(er88577b->reset, 0);
  353.     mdelay(100);
  354.     gpiod_set_value(er88577b->reset, 1);
  355.     mdelay(150);
  356.     gpiod_set_value(er88577b->reset, 0);
  357.     mdelay(150);
  358. */
  359.     return 0;
  360. }
  361.  
  362. static int er88577b_unprepare(struct drm_panel *panel)
  363. {
  364.     struct er88577b *er88577b = panel_to_er88577b(panel);
  365.     struct device *dev = panel->dev;
  366.  
  367.     DRM_DEV_INFO(dev, "Unpreparing - asserting reset\r\n");
  368.     gpiod_set_value(er88577b->reset, 1);
  369.     msleep(120);
  370. #if 0
  371.     regulator_disable(er88577b->vdd);
  372.     regulator_disable(er88577b->vccio);
  373. #endif
  374.     return 0;
  375. }
  376.  
  377. static int er88577b_get_modes(struct drm_panel *panel,
  378.                 struct drm_connector *connector)
  379. {
  380.     struct er88577b *er88577b = panel_to_er88577b(panel);
  381.     const struct drm_display_mode *desc_mode = &er88577b->desc->mode;
  382.     struct drm_display_mode *mode;
  383.  
  384.     DRM_DEV_INFO(panel->dev, "In er88577b_get_modes\n");
  385.     mode = drm_mode_duplicate(connector->dev, desc_mode);
  386.     if (!mode) {
  387.         DRM_DEV_ERROR(&er88577b->dsi->dev, "failed to add mode %ux%ux@%u\n",
  388.                   desc_mode->hdisplay, desc_mode->vdisplay,
  389.                   drm_mode_vrefresh(desc_mode));
  390.         return -ENOMEM;
  391.     }
  392.  
  393.     drm_mode_set_name(mode);
  394.     drm_mode_probed_add(connector, mode);
  395.  
  396.     connector->display_info.width_mm = mode->width_mm;
  397.     connector->display_info.height_mm = mode->height_mm;
  398.  
  399.     return 1;
  400. }
  401.  
  402. static int er88577b_get_timings(struct drm_panel *panel,
  403.                     unsigned int num_timings,
  404.                     struct display_timing *timings)
  405. {
  406.     struct er88577b *er88577b = panel_to_er88577b(panel);
  407.     unsigned int i;
  408.  
  409.     DRM_DEV_INFO(panel->dev, "In er88577b_get_timings\n");
  410.  
  411.     if (er88577b->desc->num_timings < num_timings)
  412.         num_timings = er88577b->desc->num_timings;
  413.  
  414.     if (timings)
  415.         for (i = 0; i < num_timings; i++)
  416.             timings[i] = er88577b->desc->timings[i];
  417.  
  418.     return er88577b->desc->num_timings;
  419. }
  420.  
  421. static const struct drm_panel_funcs er88577b_funcs = {
  422.     .disable = er88577b_disable,
  423.     .unprepare = er88577b_unprepare,
  424.     .prepare = er88577b_prepare,
  425.     .enable = er88577b_enable,
  426.     .get_modes = er88577b_get_modes,
  427.     .get_timings = er88577b_get_timings,
  428. };
  429.  
  430. static const struct er88577b_init_cmd eqt700hky008p_init_cmds[] = {
  431. _INIT_CMD_DCS(0xE0,0xAB,0xBA),
  432. _INIT_CMD_DCS(0xE1,0xBA,0xAB),
  433. _INIT_CMD_DCS(0xB1,0x10,0x01,0x47,0xFF),
  434. _INIT_CMD_DCS(0xB2,0x0C,0x14,0x04,0x50,0x50,0x14),
  435. _INIT_CMD_DCS(0xB3,0x56,0xD3,0x00),
  436. _INIT_CMD_DCS(0xB4,0x22,0x30,0x04),
  437. _INIT_CMD_DCS(0xB6,0xB0,0x00,0x00,0x10,0x00,0x10,0x00),
  438. _INIT_CMD_DCS(0xB7,0x0E,0x00,0xFF,0x08,0x08,0xFF,0xFF,0x00),
  439. _INIT_CMD_DCS(0xB8,0x05,0x12,0x29,0x49,0x48),
  440. _INIT_CMD_DCS(0xB9,0x7F,0x69,0x57,0x4C,0x47,0x37,0x3C,0x25,0x3E,0x3C,0x3B,0x58,0x45,0x4D,0x40,0x3F,0x35,0x27,0x06,0x7F,0x69,0x57,0x4C,0x47,0x37,0x3C,0x25,0x3E,0x3C,0x3B,0x58,0x45,0x4D,0x40,0x3F,0x35,0x27,0x06),
  441. _INIT_CMD_DCS(0xC0,0x98,0x76,0x12,0x34,0x33,0x33,0x44,0x44,0x06,0x04,0x8A,0x04,0x0F,0x00,0x00,0x00),
  442. _INIT_CMD_DCS(0xC1,0x53,0x94,0x02,0x85,0x06,0x04,0x8A,0x04,0x54,0x00),
  443. _INIT_CMD_DCS(0xC2,0x37,0x09,0x08,0x89,0x08,0x11,0x22,0x21,0x44,0xBB,0x18,0x00),
  444. _INIT_CMD_DCS(0xC3,0x9C,0x1D,0x1E,0x1F,0x10,0x12,0x0C,0x0E,0x05,0x24,0x24,0x24,0x24,0x24,0x24,0x07,0x24,0x24,0x24,0x24,0x24,0x24),
  445. _INIT_CMD_DCS(0xC4,0x1C,0x1D,0x1E,0x1F,0x11,0x13,0x0D,0x0F,0x04,0x24,0x24,0x24,0x24,0x24,0x24,0x06,0x24,0x24,0x24,0x24,0x24,0x24),
  446. _INIT_CMD_DCS(0xC6,0x28,0x28),
  447. _INIT_CMD_DCS(0xC7,0x41,0x01,0x0D,0x11,0x09,0x15,0x19,0x4F,0x10,0xD7,0xCF,0x19,0x1B,0x1D,0x03,0x02,0x25,0x30,0x00,0x03,0xFF,0x00),
  448. _INIT_CMD_DCS(0xC8,0x61,0x00,0x31,0x42,0x54,0x16),
  449. _INIT_CMD_DCS(0xCA,0xCB,0x43),
  450. _INIT_CMD_DCS(0xCD,0x0E,0x64,0x64,0x20,0x1E,0x6B,0x06,0x83),
  451. _INIT_CMD_DCS(0xD2,0xE3,0x2B,0x38,0x00),
  452. _INIT_CMD_DCS(0xD4,0x00,0x01,0x00,0x0E,0x04,0x44,0x08,0x10,0x00,0x07,0x00),
  453. _INIT_CMD_DCS(0xE6,0x00,0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF),
  454. _INIT_CMD_DCS(0xE7,0x00,0x00,0x00),
  455. _INIT_CMD_DCS(0xF0,0x12,0x03,0x20,0x00,0xFF),
  456. _INIT_CMD_DCS(0xF3,0x00),
  457. //_INIT_CMD_DCS(0x35,0x00),
  458. //_INIT_CMD_DCS(0x36,0x00),
  459.  
  460.     _INIT_CMD_DELAY(150),
  461. };
  462.  
  463. static const struct display_timing er88577b_timing = {
  464.     .pixelclock = { 77000000, 77000000, 77000000},
  465.     .hactive = { 800, 800, 800 },
  466.     .hfront_porch = {  80, 80, 80},
  467.     .hback_porch = { 80, 80, 80},
  468.     .hsync_len = { 20, 20, 20 },
  469.     .vactive = { 1280, 1280, 1280 },
  470.     .vfront_porch = { 20, 20, 20},
  471.     .vback_porch = { 12, 12, 12 },
  472.     .vsync_len = { 4, 4, 4 },
  473.     .flags = DISPLAY_FLAGS_DE_LOW,
  474. };
  475.  
  476. static const struct er88577b_panel_desc eqt700hky008p_desc = {
  477.     .mode = {
  478.         .clock      = 77000,
  479. //      .clock      = 66000,
  480.  
  481.         .hdisplay   = 800,
  482.         .hsync_start    = 800 + 80,
  483.         .hsync_end  = 800 + 80 + 20,
  484.         .htotal     = 800 + 80 + 20 + 80,
  485.  
  486.         .vdisplay   = 1280,
  487.         .vsync_start    = 1280 + 20,
  488.         .vsync_end  = 1280 + 20 + 4,
  489.         .vtotal     = 1280 + 20 + 4 + 12,
  490.  
  491.         .width_mm   = 94,
  492.         .height_mm  = 151,
  493.         .type       = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
  494.     },
  495.     .lanes = 4,
  496.     .format = MIPI_DSI_FMT_RGB888,
  497.     .init_cmds = eqt700hky008p_init_cmds,
  498.     .num_init_cmds = ARRAY_SIZE(eqt700hky008p_init_cmds),
  499.     .timings = &er88577b_timing,
  500.     .num_timings = 1,
  501. };
  502.  
  503. static int er88577b_dsi_probe(struct mipi_dsi_device *dsi)
  504. {
  505. //  u8 reg_value = 0;
  506.     struct er88577b *er_panel;
  507.     const struct er88577b_panel_desc *desc;
  508.  
  509.     struct device *dev = &dsi->dev;
  510.     int ret = 0;
  511.    
  512. #if 0
  513.     struct mipi_dsi_device_info info = {
  514.         .type = DSI_DRIVER_NAME,
  515.         .channel = 1, //0,
  516.         .node = NULL,
  517.     };
  518. #endif
  519.  
  520.     DRM_DEV_INFO(dev, "In er88577b_dsi_probe\n");
  521.     er_panel = devm_kzalloc(dev, sizeof(struct er88577b), GFP_KERNEL);
  522.     if (!er_panel )
  523.         return -ENOMEM;
  524.     desc = of_device_get_match_data(dev);
  525.  
  526. //  er_panel->enable_initialized = false;
  527.  
  528.     mipi_dsi_set_drvdata(dsi, er_panel);
  529.  
  530.     er_panel->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
  531.     if (IS_ERR(er_panel->reset)) {
  532.         DRM_DEV_ERROR(dev, "failed to get our reset GPIO\n");
  533.         goto error;
  534.         //return PTR_ERR(panel->reset);
  535.     }
  536.  
  537.     DRM_DEV_INFO(dev, "Calling drm_panel_init\n");
  538.     er_panel->panel.prepare_upstream_first = true;
  539.     drm_panel_init(&er_panel->panel, dev, &er88577b_funcs,
  540.                DRM_MODE_CONNECTOR_DSI);
  541.  
  542.     drm_panel_add(&er_panel->panel);
  543.  
  544.     er_panel->desc = desc;
  545.  
  546.     er_panel->dsi = dsi;
  547.  
  548. //  dsi->mode_flags = MIPI_DSI_MODE_LPM | MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_SYNC_PULSE | MIPI_DSI_CLOCK_NON_CONTINUOUS;
  549.     dsi->mode_flags = MIPI_DSI_MODE_LPM | MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_SYNC_PULSE;
  550. //  dsi->mode_flags = MIPI_DSI_MODE_LPM | MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_BURST;
  551. //  dsi->mode_flags = MIPI_DSI_MODE_LPM | MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_BURST | MIPI_DSI_CLOCK_NON_CONTINUOUS;
  552. //  dsi->mode_flags = MIPI_DSI_MODE_LPM | MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_SYNC_PULSE | MIPI_DSI_MODE_VIDEO_HSE;
  553. //  dsi->mode_flags = MIPI_DSI_MODE_LPM | MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_SYNC_PULSE | MIPI_DSI_MODE_VIDEO_HSE | MIPI_DSI_CLOCK_NON_CONTINUOUS;
  554. //  dsi->mode_flags = MIPI_DSI_MODE_LPM | MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_BURST | MIPI_DSI_MODE_VIDEO_HSE | MIPI_DSI_CLOCK_NON_CONTINUOUS;
  555.     dsi->format = MIPI_DSI_FMT_RGB888;
  556.     dsi->lanes = 4;
  557.     dsi->channel = 0;
  558.  
  559.     DRM_DEV_INFO(dev, "Calling mipi_dsi_attach\n");
  560.     ret = mipi_dsi_attach(dsi);
  561.     if (ret < 0) {
  562.         return ret;
  563.     }
  564.  
  565.     return 0;
  566.  
  567. error:
  568.     return -ENODEV;
  569.  
  570. }
  571.  
  572. static void er88577b_dsi_remove(struct mipi_dsi_device *dsi)
  573. {
  574.     struct er88577b *er88577b = mipi_dsi_get_drvdata(dsi);
  575.  
  576.     DRM_DEV_INFO(&dsi->dev, "In er88577b_remove\n");
  577.     mipi_dsi_detach(dsi);
  578.     drm_panel_remove(&er88577b->panel);
  579. }
  580.  
  581. static const struct of_device_id panel_dt_ids[] = {
  582.     { .compatible = "easy_quick_eqt700hky008p", .data = &eqt700hky008p_desc},
  583.     { /* sentinel */ }
  584. };
  585. MODULE_DEVICE_TABLE(of, panel_dt_ids);
  586.  
  587. static struct mipi_dsi_driver er88577b_mipi_driver = {
  588.     .driver = {
  589.         .name = DSI_DRIVER_NAME,
  590.         .of_match_table = panel_dt_ids,
  591.     },
  592.     .probe = er88577b_dsi_probe,
  593.     .remove = er88577b_dsi_remove,
  594. };
  595. module_mipi_dsi_driver(er88577b_mipi_driver);
  596.  
  597. MODULE_AUTHOR("Ivan Maximov <[email protected]>");
  598. MODULE_DESCRIPTION("er88577b-based Easy Quick EQT700HKY008P WUXGA DSI panel");
  599. MODULE_LICENSE("GPL");
  600.  
  601.  
Tags: RPi MIPI DSI ER88577B
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!