ams369fg06.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * ams369fg06 AMOLED LCD panel driver.
  4. *
  5. * Copyright (c) 2011 Samsung Electronics Co., Ltd.
  6. * Author: Jingoo Han <jg1.han@samsung.com>
  7. *
  8. * Derived from drivers/video/s6e63m0.c
  9. */
  10. #include <linux/backlight.h>
  11. #include <linux/delay.h>
  12. #include <linux/fb.h>
  13. #include <linux/lcd.h>
  14. #include <linux/module.h>
  15. #include <linux/spi/spi.h>
  16. #include <linux/wait.h>
  17. #define SLEEPMSEC 0x1000
  18. #define ENDDEF 0x2000
  19. #define DEFMASK 0xFF00
  20. #define COMMAND_ONLY 0xFE
  21. #define DATA_ONLY 0xFF
  22. #define MAX_GAMMA_LEVEL 5
  23. #define GAMMA_TABLE_COUNT 21
  24. #define MIN_BRIGHTNESS 0
  25. #define MAX_BRIGHTNESS 255
  26. #define DEFAULT_BRIGHTNESS 150
  27. struct ams369fg06 {
  28. struct device *dev;
  29. struct spi_device *spi;
  30. unsigned int power;
  31. struct lcd_device *ld;
  32. struct backlight_device *bd;
  33. struct lcd_platform_data *lcd_pd;
  34. };
  35. static const unsigned short seq_display_on[] = {
  36. 0x14, 0x03,
  37. ENDDEF, 0x0000
  38. };
  39. static const unsigned short seq_display_off[] = {
  40. 0x14, 0x00,
  41. ENDDEF, 0x0000
  42. };
  43. static const unsigned short seq_stand_by_on[] = {
  44. 0x1D, 0xA1,
  45. SLEEPMSEC, 200,
  46. ENDDEF, 0x0000
  47. };
  48. static const unsigned short seq_stand_by_off[] = {
  49. 0x1D, 0xA0,
  50. SLEEPMSEC, 250,
  51. ENDDEF, 0x0000
  52. };
  53. static const unsigned short seq_setting[] = {
  54. 0x31, 0x08,
  55. 0x32, 0x14,
  56. 0x30, 0x02,
  57. 0x27, 0x01,
  58. 0x12, 0x08,
  59. 0x13, 0x08,
  60. 0x15, 0x00,
  61. 0x16, 0x00,
  62. 0xef, 0xd0,
  63. DATA_ONLY, 0xe8,
  64. 0x39, 0x44,
  65. 0x40, 0x00,
  66. 0x41, 0x3f,
  67. 0x42, 0x2a,
  68. 0x43, 0x27,
  69. 0x44, 0x27,
  70. 0x45, 0x1f,
  71. 0x46, 0x44,
  72. 0x50, 0x00,
  73. 0x51, 0x00,
  74. 0x52, 0x17,
  75. 0x53, 0x24,
  76. 0x54, 0x26,
  77. 0x55, 0x1f,
  78. 0x56, 0x43,
  79. 0x60, 0x00,
  80. 0x61, 0x3f,
  81. 0x62, 0x2a,
  82. 0x63, 0x25,
  83. 0x64, 0x24,
  84. 0x65, 0x1b,
  85. 0x66, 0x5c,
  86. 0x17, 0x22,
  87. 0x18, 0x33,
  88. 0x19, 0x03,
  89. 0x1a, 0x01,
  90. 0x22, 0xa4,
  91. 0x23, 0x00,
  92. 0x26, 0xa0,
  93. 0x1d, 0xa0,
  94. SLEEPMSEC, 300,
  95. 0x14, 0x03,
  96. ENDDEF, 0x0000
  97. };
  98. /* gamma value: 2.2 */
  99. static const unsigned int ams369fg06_22_250[] = {
  100. 0x00, 0x3f, 0x2a, 0x27, 0x27, 0x1f, 0x44,
  101. 0x00, 0x00, 0x17, 0x24, 0x26, 0x1f, 0x43,
  102. 0x00, 0x3f, 0x2a, 0x25, 0x24, 0x1b, 0x5c,
  103. };
  104. static const unsigned int ams369fg06_22_200[] = {
  105. 0x00, 0x3f, 0x28, 0x29, 0x27, 0x21, 0x3e,
  106. 0x00, 0x00, 0x10, 0x25, 0x27, 0x20, 0x3d,
  107. 0x00, 0x3f, 0x28, 0x27, 0x25, 0x1d, 0x53,
  108. };
  109. static const unsigned int ams369fg06_22_150[] = {
  110. 0x00, 0x3f, 0x2d, 0x29, 0x28, 0x23, 0x37,
  111. 0x00, 0x00, 0x0b, 0x25, 0x28, 0x22, 0x36,
  112. 0x00, 0x3f, 0x2b, 0x28, 0x26, 0x1f, 0x4a,
  113. };
  114. static const unsigned int ams369fg06_22_100[] = {
  115. 0x00, 0x3f, 0x30, 0x2a, 0x2b, 0x24, 0x2f,
  116. 0x00, 0x00, 0x00, 0x25, 0x29, 0x24, 0x2e,
  117. 0x00, 0x3f, 0x2f, 0x29, 0x29, 0x21, 0x3f,
  118. };
  119. static const unsigned int ams369fg06_22_50[] = {
  120. 0x00, 0x3f, 0x3c, 0x2c, 0x2d, 0x27, 0x24,
  121. 0x00, 0x00, 0x00, 0x22, 0x2a, 0x27, 0x23,
  122. 0x00, 0x3f, 0x3b, 0x2c, 0x2b, 0x24, 0x31,
  123. };
  124. struct ams369fg06_gamma {
  125. unsigned int *gamma_22_table[MAX_GAMMA_LEVEL];
  126. };
  127. static struct ams369fg06_gamma gamma_table = {
  128. .gamma_22_table[0] = (unsigned int *)&ams369fg06_22_50,
  129. .gamma_22_table[1] = (unsigned int *)&ams369fg06_22_100,
  130. .gamma_22_table[2] = (unsigned int *)&ams369fg06_22_150,
  131. .gamma_22_table[3] = (unsigned int *)&ams369fg06_22_200,
  132. .gamma_22_table[4] = (unsigned int *)&ams369fg06_22_250,
  133. };
  134. static int ams369fg06_spi_write_byte(struct ams369fg06 *lcd, int addr, int data)
  135. {
  136. u16 buf[1];
  137. struct spi_message msg;
  138. struct spi_transfer xfer = {
  139. .len = 2,
  140. .tx_buf = buf,
  141. };
  142. buf[0] = (addr << 8) | data;
  143. spi_message_init(&msg);
  144. spi_message_add_tail(&xfer, &msg);
  145. return spi_sync(lcd->spi, &msg);
  146. }
  147. static int ams369fg06_spi_write(struct ams369fg06 *lcd, unsigned char address,
  148. unsigned char command)
  149. {
  150. int ret = 0;
  151. if (address != DATA_ONLY)
  152. ret = ams369fg06_spi_write_byte(lcd, 0x70, address);
  153. if (command != COMMAND_ONLY)
  154. ret = ams369fg06_spi_write_byte(lcd, 0x72, command);
  155. return ret;
  156. }
  157. static int ams369fg06_panel_send_sequence(struct ams369fg06 *lcd,
  158. const unsigned short *wbuf)
  159. {
  160. int ret = 0, i = 0;
  161. while ((wbuf[i] & DEFMASK) != ENDDEF) {
  162. if ((wbuf[i] & DEFMASK) != SLEEPMSEC) {
  163. ret = ams369fg06_spi_write(lcd, wbuf[i], wbuf[i+1]);
  164. if (ret)
  165. break;
  166. } else {
  167. msleep(wbuf[i+1]);
  168. }
  169. i += 2;
  170. }
  171. return ret;
  172. }
  173. static int _ams369fg06_gamma_ctl(struct ams369fg06 *lcd,
  174. const unsigned int *gamma)
  175. {
  176. unsigned int i = 0;
  177. int ret = 0;
  178. for (i = 0 ; i < GAMMA_TABLE_COUNT / 3; i++) {
  179. ret = ams369fg06_spi_write(lcd, 0x40 + i, gamma[i]);
  180. ret = ams369fg06_spi_write(lcd, 0x50 + i, gamma[i+7*1]);
  181. ret = ams369fg06_spi_write(lcd, 0x60 + i, gamma[i+7*2]);
  182. if (ret) {
  183. dev_err(lcd->dev, "failed to set gamma table.\n");
  184. goto gamma_err;
  185. }
  186. }
  187. gamma_err:
  188. return ret;
  189. }
  190. static int ams369fg06_gamma_ctl(struct ams369fg06 *lcd, int brightness)
  191. {
  192. int ret = 0;
  193. int gamma = 0;
  194. if ((brightness >= 0) && (brightness <= 50))
  195. gamma = 0;
  196. else if ((brightness > 50) && (brightness <= 100))
  197. gamma = 1;
  198. else if ((brightness > 100) && (brightness <= 150))
  199. gamma = 2;
  200. else if ((brightness > 150) && (brightness <= 200))
  201. gamma = 3;
  202. else if ((brightness > 200) && (brightness <= 255))
  203. gamma = 4;
  204. ret = _ams369fg06_gamma_ctl(lcd, gamma_table.gamma_22_table[gamma]);
  205. return ret;
  206. }
  207. static int ams369fg06_ldi_init(struct ams369fg06 *lcd)
  208. {
  209. int ret, i;
  210. static const unsigned short *init_seq[] = {
  211. seq_setting,
  212. seq_stand_by_off,
  213. };
  214. for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
  215. ret = ams369fg06_panel_send_sequence(lcd, init_seq[i]);
  216. if (ret)
  217. break;
  218. }
  219. return ret;
  220. }
  221. static int ams369fg06_ldi_enable(struct ams369fg06 *lcd)
  222. {
  223. int ret, i;
  224. static const unsigned short *init_seq[] = {
  225. seq_stand_by_off,
  226. seq_display_on,
  227. };
  228. for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
  229. ret = ams369fg06_panel_send_sequence(lcd, init_seq[i]);
  230. if (ret)
  231. break;
  232. }
  233. return ret;
  234. }
  235. static int ams369fg06_ldi_disable(struct ams369fg06 *lcd)
  236. {
  237. int ret, i;
  238. static const unsigned short *init_seq[] = {
  239. seq_display_off,
  240. seq_stand_by_on,
  241. };
  242. for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
  243. ret = ams369fg06_panel_send_sequence(lcd, init_seq[i]);
  244. if (ret)
  245. break;
  246. }
  247. return ret;
  248. }
  249. static int ams369fg06_power_is_on(int power)
  250. {
  251. return power <= FB_BLANK_NORMAL;
  252. }
  253. static int ams369fg06_power_on(struct ams369fg06 *lcd)
  254. {
  255. int ret = 0;
  256. struct lcd_platform_data *pd;
  257. struct backlight_device *bd;
  258. pd = lcd->lcd_pd;
  259. bd = lcd->bd;
  260. if (pd->power_on) {
  261. pd->power_on(lcd->ld, 1);
  262. msleep(pd->power_on_delay);
  263. }
  264. if (!pd->reset) {
  265. dev_err(lcd->dev, "reset is NULL.\n");
  266. return -EINVAL;
  267. }
  268. pd->reset(lcd->ld);
  269. msleep(pd->reset_delay);
  270. ret = ams369fg06_ldi_init(lcd);
  271. if (ret) {
  272. dev_err(lcd->dev, "failed to initialize ldi.\n");
  273. return ret;
  274. }
  275. ret = ams369fg06_ldi_enable(lcd);
  276. if (ret) {
  277. dev_err(lcd->dev, "failed to enable ldi.\n");
  278. return ret;
  279. }
  280. /* set brightness to current value after power on or resume. */
  281. ret = ams369fg06_gamma_ctl(lcd, bd->props.brightness);
  282. if (ret) {
  283. dev_err(lcd->dev, "lcd gamma setting failed.\n");
  284. return ret;
  285. }
  286. return 0;
  287. }
  288. static int ams369fg06_power_off(struct ams369fg06 *lcd)
  289. {
  290. int ret;
  291. struct lcd_platform_data *pd;
  292. pd = lcd->lcd_pd;
  293. ret = ams369fg06_ldi_disable(lcd);
  294. if (ret) {
  295. dev_err(lcd->dev, "lcd setting failed.\n");
  296. return -EIO;
  297. }
  298. msleep(pd->power_off_delay);
  299. if (pd->power_on)
  300. pd->power_on(lcd->ld, 0);
  301. return 0;
  302. }
  303. static int ams369fg06_power(struct ams369fg06 *lcd, int power)
  304. {
  305. int ret = 0;
  306. if (ams369fg06_power_is_on(power) &&
  307. !ams369fg06_power_is_on(lcd->power))
  308. ret = ams369fg06_power_on(lcd);
  309. else if (!ams369fg06_power_is_on(power) &&
  310. ams369fg06_power_is_on(lcd->power))
  311. ret = ams369fg06_power_off(lcd);
  312. if (!ret)
  313. lcd->power = power;
  314. return ret;
  315. }
  316. static int ams369fg06_get_power(struct lcd_device *ld)
  317. {
  318. struct ams369fg06 *lcd = lcd_get_data(ld);
  319. return lcd->power;
  320. }
  321. static int ams369fg06_set_power(struct lcd_device *ld, int power)
  322. {
  323. struct ams369fg06 *lcd = lcd_get_data(ld);
  324. if (power != FB_BLANK_UNBLANK && power != FB_BLANK_POWERDOWN &&
  325. power != FB_BLANK_NORMAL) {
  326. dev_err(lcd->dev, "power value should be 0, 1 or 4.\n");
  327. return -EINVAL;
  328. }
  329. return ams369fg06_power(lcd, power);
  330. }
  331. static int ams369fg06_set_brightness(struct backlight_device *bd)
  332. {
  333. int ret = 0;
  334. int brightness = bd->props.brightness;
  335. struct ams369fg06 *lcd = bl_get_data(bd);
  336. if (brightness < MIN_BRIGHTNESS ||
  337. brightness > bd->props.max_brightness) {
  338. dev_err(&bd->dev, "lcd brightness should be %d to %d.\n",
  339. MIN_BRIGHTNESS, MAX_BRIGHTNESS);
  340. return -EINVAL;
  341. }
  342. ret = ams369fg06_gamma_ctl(lcd, bd->props.brightness);
  343. if (ret) {
  344. dev_err(&bd->dev, "lcd brightness setting failed.\n");
  345. return -EIO;
  346. }
  347. return ret;
  348. }
  349. static struct lcd_ops ams369fg06_lcd_ops = {
  350. .get_power = ams369fg06_get_power,
  351. .set_power = ams369fg06_set_power,
  352. };
  353. static const struct backlight_ops ams369fg06_backlight_ops = {
  354. .update_status = ams369fg06_set_brightness,
  355. };
  356. static int ams369fg06_probe(struct spi_device *spi)
  357. {
  358. int ret = 0;
  359. struct ams369fg06 *lcd = NULL;
  360. struct lcd_device *ld = NULL;
  361. struct backlight_device *bd = NULL;
  362. struct backlight_properties props;
  363. lcd = devm_kzalloc(&spi->dev, sizeof(struct ams369fg06), GFP_KERNEL);
  364. if (!lcd)
  365. return -ENOMEM;
  366. /* ams369fg06 lcd panel uses 3-wire 16bits SPI Mode. */
  367. spi->bits_per_word = 16;
  368. ret = spi_setup(spi);
  369. if (ret < 0) {
  370. dev_err(&spi->dev, "spi setup failed.\n");
  371. return ret;
  372. }
  373. lcd->spi = spi;
  374. lcd->dev = &spi->dev;
  375. lcd->lcd_pd = dev_get_platdata(&spi->dev);
  376. if (!lcd->lcd_pd) {
  377. dev_err(&spi->dev, "platform data is NULL\n");
  378. return -EINVAL;
  379. }
  380. ld = devm_lcd_device_register(&spi->dev, "ams369fg06", &spi->dev, lcd,
  381. &ams369fg06_lcd_ops);
  382. if (IS_ERR(ld))
  383. return PTR_ERR(ld);
  384. lcd->ld = ld;
  385. memset(&props, 0, sizeof(struct backlight_properties));
  386. props.type = BACKLIGHT_RAW;
  387. props.max_brightness = MAX_BRIGHTNESS;
  388. bd = devm_backlight_device_register(&spi->dev, "ams369fg06-bl",
  389. &spi->dev, lcd,
  390. &ams369fg06_backlight_ops, &props);
  391. if (IS_ERR(bd))
  392. return PTR_ERR(bd);
  393. bd->props.brightness = DEFAULT_BRIGHTNESS;
  394. lcd->bd = bd;
  395. if (!lcd->lcd_pd->lcd_enabled) {
  396. /*
  397. * if lcd panel was off from bootloader then
  398. * current lcd status is powerdown and then
  399. * it enables lcd panel.
  400. */
  401. lcd->power = FB_BLANK_POWERDOWN;
  402. ams369fg06_power(lcd, FB_BLANK_UNBLANK);
  403. } else {
  404. lcd->power = FB_BLANK_UNBLANK;
  405. }
  406. spi_set_drvdata(spi, lcd);
  407. dev_info(&spi->dev, "ams369fg06 panel driver has been probed.\n");
  408. return 0;
  409. }
  410. static int ams369fg06_remove(struct spi_device *spi)
  411. {
  412. struct ams369fg06 *lcd = spi_get_drvdata(spi);
  413. ams369fg06_power(lcd, FB_BLANK_POWERDOWN);
  414. return 0;
  415. }
  416. #ifdef CONFIG_PM_SLEEP
  417. static int ams369fg06_suspend(struct device *dev)
  418. {
  419. struct ams369fg06 *lcd = dev_get_drvdata(dev);
  420. dev_dbg(dev, "lcd->power = %d\n", lcd->power);
  421. /*
  422. * when lcd panel is suspend, lcd panel becomes off
  423. * regardless of status.
  424. */
  425. return ams369fg06_power(lcd, FB_BLANK_POWERDOWN);
  426. }
  427. static int ams369fg06_resume(struct device *dev)
  428. {
  429. struct ams369fg06 *lcd = dev_get_drvdata(dev);
  430. lcd->power = FB_BLANK_POWERDOWN;
  431. return ams369fg06_power(lcd, FB_BLANK_UNBLANK);
  432. }
  433. #endif
  434. static SIMPLE_DEV_PM_OPS(ams369fg06_pm_ops, ams369fg06_suspend,
  435. ams369fg06_resume);
  436. static void ams369fg06_shutdown(struct spi_device *spi)
  437. {
  438. struct ams369fg06 *lcd = spi_get_drvdata(spi);
  439. ams369fg06_power(lcd, FB_BLANK_POWERDOWN);
  440. }
  441. static struct spi_driver ams369fg06_driver = {
  442. .driver = {
  443. .name = "ams369fg06",
  444. .pm = &ams369fg06_pm_ops,
  445. },
  446. .probe = ams369fg06_probe,
  447. .remove = ams369fg06_remove,
  448. .shutdown = ams369fg06_shutdown,
  449. };
  450. module_spi_driver(ams369fg06_driver);
  451. MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");
  452. MODULE_DESCRIPTION("ams369fg06 LCD Driver");
  453. MODULE_LICENSE("GPL");