API tools faq
paste
Advertisement
reisei

Untitled

reisei
Jan 25th, 2012
78
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 12.12 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. * Generic DPI Panels support
  3. *
  4. * Copyright (C) 2010 Canonical Ltd.
  5. * Author: Bryan Wu <bryan.wu@canonical.com>
  6. *
  7. * LCD panel driver for Sharp LQ043T1DG01
  8. *
  9. * Copyright (C) 2009 Texas Instruments Inc
  10. * Author: Vaibhav Hiremath <hvaibhav@ti.com>
  11. *
  12. * LCD panel driver for Toppoly TDO35S
  13. *
  14. * Copyright (C) 2009 CompuLab, Ltd.
  15. * Author: Mike Rapoport <mike@compulab.co.il>
  16. *
  17. * Copyright (C) 2008 Nokia Corporation
  18. * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
  19. *
  20. * This program is free software; you can redistribute it and/or modify it
  21. * under the terms of the GNU General Public License version 2 as published by
  22. * the Free Software Foundation.
  23. *
  24. * This program is distributed in the hope that it will be useful, but WITHOUT
  25. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  26. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  27. * more details.
  28. *
  29. * You should have received a copy of the GNU General Public License along with
  30. * this program. If not, see <http://www.gnu.org/licenses/>.
  31. */
  32.  
  33. #include <linux/module.h>
  34. #include <linux/delay.h>
  35. #include <linux/slab.h>
  36. #include <video/omapdss.h>
  37. #include <linux/i2c.h>
  38. #include "../../edid.h"
  39.  
  40. #include <video/omap-panel-generic-dpi.h>
  41.  
  42. struct panel_config {
  43. struct omap_video_timings timings;
  44.  
  45. int acbi; /* ac-bias pin transitions per interrupt */
  46. /* Unit: line clocks */
  47. int acb; /* ac-bias pin frequency */
  48.  
  49. enum omap_panel_config config;
  50.  
  51. int power_on_delay;
  52. int power_off_delay;
  53.  
  54. /*
  55. * Used to match device to panel configuration
  56. * when use generic panel driver
  57. */
  58. const char *name;
  59. };
  60.  
  61. /* Panel configurations */
  62. static struct panel_config generic_dpi_panels[] = {
  63. /* Generic Panel */
  64. {
  65. {
  66. .x_res = 640,
  67. .y_res = 480,
  68.  
  69. .pixel_clock = 23500,
  70.  
  71. .hfp = 48,
  72. .hsw = 32,
  73. .hbp = 80,
  74.  
  75. .vfp = 3,
  76. .vsw = 4,
  77. .vbp = 7,
  78. },
  79. .acbi = 0x0,
  80. .acb = 0x0,
  81. .config = OMAP_DSS_LCD_TFT,
  82. .power_on_delay = 0,
  83. .power_off_delay = 0,
  84. .name = "generic",
  85. },
  86.  
  87. /* Sharp LQ043T1DG01 */
  88. {
  89. {
  90. .x_res = 480,
  91. .y_res = 272,
  92.  
  93. .pixel_clock = 9000,
  94.  
  95. .hsw = 42,
  96. .hfp = 3,
  97. .hbp = 2,
  98.  
  99. .vsw = 11,
  100. .vfp = 3,
  101. .vbp = 2,
  102. },
  103. .acbi = 0x0,
  104. .acb = 0x0,
  105. .config = OMAP_DSS_LCD_TFT | OMAP_DSS_LCD_IVS |
  106. OMAP_DSS_LCD_IHS | OMAP_DSS_LCD_IEO,
  107. .power_on_delay = 50,
  108. .power_off_delay = 100,
  109. .name = "sharp_lq",
  110. },
  111.  
  112. /* Sharp LS037V7DW01 */
  113. {
  114. {
  115. .x_res = 480,
  116. .y_res = 640,
  117.  
  118. .pixel_clock = 19200,
  119.  
  120. .hsw = 2,
  121. .hfp = 1,
  122. .hbp = 28,
  123.  
  124. .vsw = 1,
  125. .vfp = 1,
  126. .vbp = 1,
  127. },
  128. .acbi = 0x0,
  129. .acb = 0x28,
  130. .config = OMAP_DSS_LCD_TFT | OMAP_DSS_LCD_IVS |
  131. OMAP_DSS_LCD_IHS,
  132. .power_on_delay = 50,
  133. .power_off_delay = 100,
  134. .name = "sharp_ls",
  135. },
  136.  
  137. /* Toppoly TDO35S */
  138. {
  139. {
  140. .x_res = 480,
  141. .y_res = 640,
  142.  
  143. .pixel_clock = 26000,
  144.  
  145. .hfp = 104,
  146. .hsw = 8,
  147. .hbp = 8,
  148.  
  149. .vfp = 4,
  150. .vsw = 2,
  151. .vbp = 2,
  152. },
  153. .acbi = 0x0,
  154. .acb = 0x0,
  155. .config = OMAP_DSS_LCD_TFT | OMAP_DSS_LCD_IVS |
  156. OMAP_DSS_LCD_IHS | OMAP_DSS_LCD_IPC |
  157. OMAP_DSS_LCD_ONOFF,
  158. .power_on_delay = 0,
  159. .power_off_delay = 0,
  160. .name = "toppoly_tdo35s",
  161. },
  162.  
  163. /* Samsung LTE430WQ-F0C */
  164. {
  165. {
  166. .x_res = 480,
  167. .y_res = 272,
  168.  
  169. .pixel_clock = 9200,
  170.  
  171. .hfp = 8,
  172. .hsw = 41,
  173. .hbp = 45 - 41,
  174.  
  175. .vfp = 4,
  176. .vsw = 10,
  177. .vbp = 12 - 10,
  178. },
  179. .acbi = 0x0,
  180. .acb = 0x0,
  181. .config = OMAP_DSS_LCD_TFT | OMAP_DSS_LCD_IVS |
  182. OMAP_DSS_LCD_IHS,
  183. .power_on_delay = 0,
  184. .power_off_delay = 0,
  185. .name = "samsung_lte430wq_f0c",
  186. },
  187.  
  188. /* Seiko 70WVW1TZ3Z3 */
  189. {
  190. {
  191. .x_res = 800,
  192. .y_res = 480,
  193.  
  194. .pixel_clock = 33000,
  195.  
  196. .hsw = 128,
  197. .hfp = 10,
  198. .hbp = 10,
  199.  
  200. .vsw = 2,
  201. .vfp = 4,
  202. .vbp = 11,
  203. },
  204. .acbi = 0x0,
  205. .acb = 0x0,
  206. .config = OMAP_DSS_LCD_TFT | OMAP_DSS_LCD_IVS |
  207. OMAP_DSS_LCD_IHS,
  208. .power_on_delay = 0,
  209. .power_off_delay = 0,
  210. .name = "seiko_70wvw1tz3",
  211. },
  212.  
  213. /* Powertip PH480272T */
  214. {
  215. {
  216. .x_res = 480,
  217. .y_res = 272,
  218.  
  219. .pixel_clock = 9000,
  220.  
  221. .hsw = 40,
  222. .hfp = 2,
  223. .hbp = 2,
  224.  
  225. .vsw = 10,
  226. .vfp = 2,
  227. .vbp = 2,
  228. },
  229. .acbi = 0x0,
  230. .acb = 0x0,
  231. .config = OMAP_DSS_LCD_TFT | OMAP_DSS_LCD_IVS |
  232. OMAP_DSS_LCD_IHS | OMAP_DSS_LCD_IEO,
  233. .power_on_delay = 0,
  234. .power_off_delay = 0,
  235. .name = "powertip_ph480272t",
  236. },
  237. };
  238.  
  239. struct panel_drv_data {
  240.  
  241. struct omap_dss_device *dssdev;
  242.  
  243. struct panel_config *panel_config;
  244. };
  245.  
  246. static bool generic_dpi_panel_is_detected(struct omap_dss_device *dssdev,
  247. bool force);
  248.  
  249. static inline struct panel_generic_dpi_data
  250. *get_panel_data(const struct omap_dss_device *dssdev)
  251. {
  252. return (struct panel_generic_dpi_data *) dssdev->data;
  253. }
  254.  
  255. static int generic_dpi_panel_power_on(struct omap_dss_device *dssdev)
  256. {
  257. int r;
  258. struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
  259. struct panel_drv_data *drv_data = dev_get_drvdata(&dssdev->dev);
  260. struct panel_config *panel_config = drv_data->panel_config;
  261.  
  262. if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
  263. return 0;
  264.  
  265. r = omapdss_dpi_display_enable(dssdev);
  266. if (r)
  267. goto err0;
  268.  
  269. /* wait couple of vsyncs until enabling the LCD */
  270. if (panel_config->power_on_delay)
  271. msleep(panel_config->power_on_delay);
  272.  
  273. if (panel_data->platform_enable) {
  274. r = panel_data->platform_enable(dssdev);
  275. if (r)
  276. goto err1;
  277. }
  278.  
  279. return 0;
  280. err1:
  281. omapdss_dpi_display_disable(dssdev);
  282. err0:
  283. return r;
  284. }
  285.  
  286. static void generic_dpi_panel_power_off(struct omap_dss_device *dssdev)
  287. {
  288. struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
  289. struct panel_drv_data *drv_data = dev_get_drvdata(&dssdev->dev);
  290. struct panel_config *panel_config = drv_data->panel_config;
  291.  
  292. if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
  293. return;
  294.  
  295. if (panel_data->platform_disable)
  296. panel_data->platform_disable(dssdev);
  297.  
  298. /* wait couple of vsyncs after disabling the LCD */
  299. if (panel_config->power_off_delay)
  300. msleep(panel_config->power_off_delay);
  301.  
  302. omapdss_dpi_display_disable(dssdev);
  303. }
  304.  
  305. static int generic_dpi_panel_probe(struct omap_dss_device *dssdev)
  306. {
  307. struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
  308. struct panel_config *panel_config = NULL;
  309. struct panel_drv_data *drv_data = NULL;
  310. int i;
  311. const char *default_disp_name;
  312.  
  313. dev_dbg(&dssdev->dev, "probe\n");
  314.  
  315. if (!panel_data || !panel_data->name)
  316. return -EINVAL;
  317.  
  318. for (i = 0; i < ARRAY_SIZE(generic_dpi_panels); i++) {
  319. if (strcmp(panel_data->name, generic_dpi_panels[i].name) == 0) {
  320. panel_config = &generic_dpi_panels[i];
  321. break;
  322. }
  323. }
  324.  
  325. if (!panel_config)
  326. return -EINVAL;
  327.  
  328. dssdev->panel.config = panel_config->config;
  329. dssdev->panel.timings = panel_config->timings;
  330. dssdev->panel.acb = panel_config->acb;
  331. dssdev->panel.acbi = panel_config->acbi;
  332.  
  333. drv_data = kzalloc(sizeof(*drv_data), GFP_KERNEL);
  334. if (!drv_data)
  335. return -ENOMEM;
  336.  
  337. drv_data->dssdev = dssdev;
  338. drv_data->panel_config = panel_config;
  339.  
  340. dev_set_drvdata(&dssdev->dev, drv_data);
  341.  
  342. default_disp_name = omap_dss_get_def_disp();
  343.  
  344. if (!panel_data->i2c_bus_num && dssdev->name && default_disp_name &&
  345. strcmp(dssdev->name, default_disp_name) == 0) {
  346. dev_dbg(&dssdev->dev, "manually enabling %s",
  347. dssdev->name);
  348. dssdev->state = OMAP_DSS_DISPLAY_SUSPENDED;
  349. dssdev->activate_after_resume = true;
  350. }
  351.  
  352. return 0;
  353. }
  354.  
  355. static void __exit generic_dpi_panel_remove(struct omap_dss_device *dssdev)
  356. {
  357. struct panel_drv_data *drv_data = dev_get_drvdata(&dssdev->dev);
  358.  
  359. dev_dbg(&dssdev->dev, "remove\n");
  360.  
  361. kfree(drv_data);
  362.  
  363. dev_set_drvdata(&dssdev->dev, NULL);
  364. }
  365.  
  366. static int generic_dpi_panel_enable(struct omap_dss_device *dssdev)
  367. {
  368. int r = 0;
  369.  
  370. /* Avoid enabling the panel if there is none around */
  371. if (!generic_dpi_panel_is_detected(dssdev, false)) {
  372. printk(KERN_ERR "Not enabling generic panel as no "
  373. "connector is detected\n");
  374. return 1;
  375. }
  376.  
  377. r = generic_dpi_panel_power_on(dssdev);
  378. if (r)
  379. return r;
  380.  
  381. dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
  382.  
  383. return 0;
  384. }
  385.  
  386. static void generic_dpi_panel_disable(struct omap_dss_device *dssdev)
  387. {
  388. generic_dpi_panel_power_off(dssdev);
  389.  
  390. dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
  391. }
  392.  
  393. static int generic_dpi_panel_suspend(struct omap_dss_device *dssdev)
  394. {
  395. generic_dpi_panel_power_off(dssdev);
  396.  
  397. dssdev->state = OMAP_DSS_DISPLAY_SUSPENDED;
  398.  
  399. return 0;
  400. }
  401.  
  402. static int generic_dpi_panel_resume(struct omap_dss_device *dssdev)
  403. {
  404. int r = 0;
  405.  
  406. r = generic_dpi_panel_power_on(dssdev);
  407. if (r)
  408. return r;
  409.  
  410. dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
  411.  
  412. return 0;
  413. }
  414.  
  415. static void generic_dpi_panel_set_timings(struct omap_dss_device *dssdev,
  416. struct omap_video_timings *timings)
  417. {
  418. dpi_set_timings(dssdev, timings);
  419. }
  420.  
  421. static void generic_dpi_panel_get_timings(struct omap_dss_device *dssdev,
  422. struct omap_video_timings *timings)
  423. {
  424. *timings = dssdev->panel.timings;
  425. }
  426.  
  427. static int generic_dpi_panel_check_timings(struct omap_dss_device *dssdev,
  428. struct omap_video_timings *timings)
  429. {
  430. return dpi_check_timings(dssdev, timings);
  431. }
  432.  
  433. /* i2c / edid support */
  434.  
  435. #define DDC_ADDR 0x50
  436.  
  437. static int do_probe_ddc_edid(struct i2c_adapter *adapter,
  438. unsigned char *buf, int block, int len)
  439. {
  440. unsigned char start = block * EDID_LENGTH;
  441. int i;
  442. struct i2c_msg msgs[] = {
  443. {
  444. .addr = DDC_ADDR,
  445. .flags = 0,
  446. .len = 1,
  447. .buf = &start,
  448. }, {
  449. .addr = DDC_ADDR,
  450. .flags = I2C_M_RD,
  451. .len = len,
  452. .buf = buf,
  453. }
  454. };
  455.  
  456. /* try at least 3 times, avoid miss for time-out */
  457. for (i = 0; i < 3; i++) {
  458. if (i2c_transfer(adapter, msgs, 2) == 2)
  459. return 0;
  460. }
  461.  
  462. return -1;
  463. }
  464.  
  465. static int generic_dpi_panel_get_edid(struct omap_dss_device *dssdev,
  466. u8 *buf, int len)
  467. {
  468. struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
  469. struct i2c_adapter *adapter;
  470. int i;
  471. u8 *edid, *new;
  472.  
  473. adapter = i2c_get_adapter(panel_data->i2c_bus_num);
  474. if (!adapter) {
  475. printk(KERN_ERR "Invalid I2C adapter, bus number: %d\n",
  476. panel_data->i2c_bus_num);
  477. return -EINVAL;
  478. }
  479.  
  480. if ((edid = kmalloc(EDID_LENGTH, GFP_KERNEL)) == NULL)
  481. return -EINVAL;
  482.  
  483. if (do_probe_ddc_edid(adapter, edid, 0, EDID_LENGTH))
  484. goto out;
  485.  
  486. /* if there are extensions, probe more */
  487. if (edid[0x7e] != 0) {
  488. new = krealloc(edid, (edid[0x7e] + 1) * EDID_LENGTH,
  489. GFP_KERNEL);
  490. if (!new)
  491. goto out;
  492. edid = new;
  493.  
  494. for (i = 1; i <= edid[0x7e]; i++) {
  495. if (do_probe_ddc_edid(adapter,
  496. edid + i * EDID_LENGTH,
  497. i, EDID_LENGTH))
  498. goto out;
  499. }
  500. }
  501.  
  502. if (edid) {
  503. memcpy(buf, edid, len);
  504. kfree(edid);
  505. return 0;
  506. }
  507.  
  508. out:
  509. kfree(edid);
  510. return -EINVAL;
  511. }
  512.  
  513. static bool generic_dpi_panel_is_detected(struct omap_dss_device *dssdev,
  514. bool force)
  515. {
  516. struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
  517. struct i2c_adapter *adapter;
  518. unsigned char out;
  519.  
  520. adapter = i2c_get_adapter(panel_data->i2c_bus_num);
  521. if (!adapter) {
  522. return omapdss_default_is_detected(dssdev, force);
  523. }
  524.  
  525. return (do_probe_ddc_edid(adapter, &out, 0, 1) == 0);
  526. }
  527.  
  528. static struct omap_dss_driver dpi_driver = {
  529. .probe = generic_dpi_panel_probe,
  530. .remove = __exit_p(generic_dpi_panel_remove),
  531.  
  532. .enable = generic_dpi_panel_enable,
  533. .disable = generic_dpi_panel_disable,
  534. .suspend = generic_dpi_panel_suspend,
  535. .resume = generic_dpi_panel_resume,
  536.  
  537. .set_timings = generic_dpi_panel_set_timings,
  538. .get_timings = generic_dpi_panel_get_timings,
  539. .check_timings = generic_dpi_panel_check_timings,
  540.  
  541. .get_edid = generic_dpi_panel_get_edid,
  542. .is_detected = generic_dpi_panel_is_detected,
  543.  
  544. .driver = {
  545. .name = "generic_dpi_panel",
  546. .owner = THIS_MODULE,
  547. },
  548. };
  549.  
  550. static int __init generic_dpi_panel_drv_init(void)
  551. {
  552. return omap_dss_register_driver(&dpi_driver);
  553. }
  554.  
  555. static void __exit generic_dpi_panel_drv_exit(void)
  556. {
  557. omap_dss_unregister_driver(&dpi_driver);
  558. }
  559.  
  560. module_init(generic_dpi_panel_drv_init);
  561. module_exit(generic_dpi_panel_drv_exit);
  562. MODULE_LICENSE("GPL");
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!