panel-olimex-lcd-olinuxino.c 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * LCD-OLinuXino support for panel driver
  4. *
  5. * Copyright (C) 2018 Olimex Ltd.
  6. * Author: Stefan Mavrodiev <stefan@olimex.com>
  7. */
  8. #include <linux/crc32.h>
  9. #include <linux/gpio/consumer.h>
  10. #include <linux/i2c.h>
  11. #include <linux/module.h>
  12. #include <linux/mutex.h>
  13. #include <linux/of.h>
  14. #include <linux/regulator/consumer.h>
  15. #include <video/videomode.h>
  16. #include <video/display_timing.h>
  17. #include <drm/drm_device.h>
  18. #include <drm/drm_modes.h>
  19. #include <drm/drm_panel.h>
  20. #define LCD_OLINUXINO_HEADER_MAGIC 0x4F4CB727
  21. #define LCD_OLINUXINO_DATA_LEN 256
  22. struct lcd_olinuxino_mode {
  23. u32 pixelclock;
  24. u32 hactive;
  25. u32 hfp;
  26. u32 hbp;
  27. u32 hpw;
  28. u32 vactive;
  29. u32 vfp;
  30. u32 vbp;
  31. u32 vpw;
  32. u32 refresh;
  33. u32 flags;
  34. };
  35. struct lcd_olinuxino_info {
  36. char name[32];
  37. u32 width_mm;
  38. u32 height_mm;
  39. u32 bpc;
  40. u32 bus_format;
  41. u32 bus_flag;
  42. } __attribute__((__packed__));
  43. struct lcd_olinuxino_eeprom {
  44. u32 header;
  45. u32 id;
  46. char revision[4];
  47. u32 serial;
  48. struct lcd_olinuxino_info info;
  49. u32 num_modes;
  50. u8 reserved[180];
  51. u32 checksum;
  52. } __attribute__((__packed__));
  53. struct lcd_olinuxino {
  54. struct drm_panel panel;
  55. struct device *dev;
  56. struct i2c_client *client;
  57. struct mutex mutex;
  58. bool prepared;
  59. bool enabled;
  60. struct regulator *supply;
  61. struct gpio_desc *enable_gpio;
  62. struct lcd_olinuxino_eeprom eeprom;
  63. };
  64. static inline struct lcd_olinuxino *to_lcd_olinuxino(struct drm_panel *panel)
  65. {
  66. return container_of(panel, struct lcd_olinuxino, panel);
  67. }
  68. static int lcd_olinuxino_disable(struct drm_panel *panel)
  69. {
  70. struct lcd_olinuxino *lcd = to_lcd_olinuxino(panel);
  71. if (!lcd->enabled)
  72. return 0;
  73. lcd->enabled = false;
  74. return 0;
  75. }
  76. static int lcd_olinuxino_unprepare(struct drm_panel *panel)
  77. {
  78. struct lcd_olinuxino *lcd = to_lcd_olinuxino(panel);
  79. if (!lcd->prepared)
  80. return 0;
  81. gpiod_set_value_cansleep(lcd->enable_gpio, 0);
  82. regulator_disable(lcd->supply);
  83. lcd->prepared = false;
  84. return 0;
  85. }
  86. static int lcd_olinuxino_prepare(struct drm_panel *panel)
  87. {
  88. struct lcd_olinuxino *lcd = to_lcd_olinuxino(panel);
  89. int ret;
  90. if (lcd->prepared)
  91. return 0;
  92. ret = regulator_enable(lcd->supply);
  93. if (ret < 0)
  94. return ret;
  95. gpiod_set_value_cansleep(lcd->enable_gpio, 1);
  96. lcd->prepared = true;
  97. return 0;
  98. }
  99. static int lcd_olinuxino_enable(struct drm_panel *panel)
  100. {
  101. struct lcd_olinuxino *lcd = to_lcd_olinuxino(panel);
  102. if (lcd->enabled)
  103. return 0;
  104. lcd->enabled = true;
  105. return 0;
  106. }
  107. static int lcd_olinuxino_get_modes(struct drm_panel *panel,
  108. struct drm_connector *connector)
  109. {
  110. struct lcd_olinuxino *lcd = to_lcd_olinuxino(panel);
  111. struct lcd_olinuxino_info *lcd_info = &lcd->eeprom.info;
  112. struct lcd_olinuxino_mode *lcd_mode;
  113. struct drm_display_mode *mode;
  114. u32 i, num = 0;
  115. for (i = 0; i < lcd->eeprom.num_modes; i++) {
  116. lcd_mode = (struct lcd_olinuxino_mode *)
  117. &lcd->eeprom.reserved[i * sizeof(*lcd_mode)];
  118. mode = drm_mode_create(connector->dev);
  119. if (!mode) {
  120. dev_err(panel->dev, "failed to add mode %ux%u@%u\n",
  121. lcd_mode->hactive,
  122. lcd_mode->vactive,
  123. lcd_mode->refresh);
  124. continue;
  125. }
  126. mode->clock = lcd_mode->pixelclock;
  127. mode->hdisplay = lcd_mode->hactive;
  128. mode->hsync_start = lcd_mode->hactive + lcd_mode->hfp;
  129. mode->hsync_end = lcd_mode->hactive + lcd_mode->hfp +
  130. lcd_mode->hpw;
  131. mode->htotal = lcd_mode->hactive + lcd_mode->hfp +
  132. lcd_mode->hpw + lcd_mode->hbp;
  133. mode->vdisplay = lcd_mode->vactive;
  134. mode->vsync_start = lcd_mode->vactive + lcd_mode->vfp;
  135. mode->vsync_end = lcd_mode->vactive + lcd_mode->vfp +
  136. lcd_mode->vpw;
  137. mode->vtotal = lcd_mode->vactive + lcd_mode->vfp +
  138. lcd_mode->vpw + lcd_mode->vbp;
  139. /* Always make the first mode preferred */
  140. if (i == 0)
  141. mode->type |= DRM_MODE_TYPE_PREFERRED;
  142. mode->type |= DRM_MODE_TYPE_DRIVER;
  143. drm_mode_set_name(mode);
  144. drm_mode_probed_add(connector, mode);
  145. num++;
  146. }
  147. connector->display_info.width_mm = lcd_info->width_mm;
  148. connector->display_info.height_mm = lcd_info->height_mm;
  149. connector->display_info.bpc = lcd_info->bpc;
  150. if (lcd_info->bus_format)
  151. drm_display_info_set_bus_formats(&connector->display_info,
  152. &lcd_info->bus_format, 1);
  153. connector->display_info.bus_flags = lcd_info->bus_flag;
  154. return num;
  155. }
  156. static const struct drm_panel_funcs lcd_olinuxino_funcs = {
  157. .disable = lcd_olinuxino_disable,
  158. .unprepare = lcd_olinuxino_unprepare,
  159. .prepare = lcd_olinuxino_prepare,
  160. .enable = lcd_olinuxino_enable,
  161. .get_modes = lcd_olinuxino_get_modes,
  162. };
  163. static int lcd_olinuxino_probe(struct i2c_client *client,
  164. const struct i2c_device_id *id)
  165. {
  166. struct device *dev = &client->dev;
  167. struct lcd_olinuxino *lcd;
  168. u32 checksum, i;
  169. int ret = 0;
  170. if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
  171. I2C_FUNC_SMBUS_READ_I2C_BLOCK))
  172. return -ENODEV;
  173. lcd = devm_kzalloc(dev, sizeof(*lcd), GFP_KERNEL);
  174. if (!lcd)
  175. return -ENOMEM;
  176. i2c_set_clientdata(client, lcd);
  177. lcd->dev = dev;
  178. lcd->client = client;
  179. mutex_init(&lcd->mutex);
  180. /* Copy data into buffer */
  181. for (i = 0; i < LCD_OLINUXINO_DATA_LEN; i += I2C_SMBUS_BLOCK_MAX) {
  182. mutex_lock(&lcd->mutex);
  183. ret = i2c_smbus_read_i2c_block_data(client,
  184. i,
  185. I2C_SMBUS_BLOCK_MAX,
  186. (u8 *)&lcd->eeprom + i);
  187. mutex_unlock(&lcd->mutex);
  188. if (ret < 0) {
  189. dev_err(dev, "error reading from device at %02x\n", i);
  190. return ret;
  191. }
  192. }
  193. /* Check configuration checksum */
  194. checksum = ~crc32(~0, (u8 *)&lcd->eeprom, 252);
  195. if (checksum != lcd->eeprom.checksum) {
  196. dev_err(dev, "configuration checksum does not match!\n");
  197. return -EINVAL;
  198. }
  199. /* Check magic header */
  200. if (lcd->eeprom.header != LCD_OLINUXINO_HEADER_MAGIC) {
  201. dev_err(dev, "magic header does not match\n");
  202. return -EINVAL;
  203. }
  204. dev_info(dev, "Detected %s, Rev. %s, Serial: %08x\n",
  205. lcd->eeprom.info.name,
  206. lcd->eeprom.revision,
  207. lcd->eeprom.serial);
  208. /*
  209. * The eeprom can hold up to 4 modes.
  210. * If the stored value is bigger, overwrite it.
  211. */
  212. if (lcd->eeprom.num_modes > 4) {
  213. dev_warn(dev, "invalid number of modes, falling back to 4\n");
  214. lcd->eeprom.num_modes = 4;
  215. }
  216. lcd->enabled = false;
  217. lcd->prepared = false;
  218. lcd->supply = devm_regulator_get(dev, "power");
  219. if (IS_ERR(lcd->supply))
  220. return PTR_ERR(lcd->supply);
  221. lcd->enable_gpio = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW);
  222. if (IS_ERR(lcd->enable_gpio))
  223. return PTR_ERR(lcd->enable_gpio);
  224. drm_panel_init(&lcd->panel, dev, &lcd_olinuxino_funcs,
  225. DRM_MODE_CONNECTOR_DPI);
  226. ret = drm_panel_of_backlight(&lcd->panel);
  227. if (ret)
  228. return ret;
  229. drm_panel_add(&lcd->panel);
  230. return 0;
  231. }
  232. static int lcd_olinuxino_remove(struct i2c_client *client)
  233. {
  234. struct lcd_olinuxino *panel = i2c_get_clientdata(client);
  235. drm_panel_remove(&panel->panel);
  236. drm_panel_disable(&panel->panel);
  237. drm_panel_unprepare(&panel->panel);
  238. return 0;
  239. }
  240. static const struct of_device_id lcd_olinuxino_of_ids[] = {
  241. { .compatible = "olimex,lcd-olinuxino" },
  242. { }
  243. };
  244. MODULE_DEVICE_TABLE(of, lcd_olinuxino_of_ids);
  245. static struct i2c_driver lcd_olinuxino_driver = {
  246. .driver = {
  247. .name = "lcd_olinuxino",
  248. .of_match_table = lcd_olinuxino_of_ids,
  249. },
  250. .probe = lcd_olinuxino_probe,
  251. .remove = lcd_olinuxino_remove,
  252. };
  253. module_i2c_driver(lcd_olinuxino_driver);
  254. MODULE_AUTHOR("Stefan Mavrodiev <stefan@olimex.com>");
  255. MODULE_DESCRIPTION("LCD-OLinuXino driver");
  256. MODULE_LICENSE("GPL");