/drivers/video/omap2/dss/dsi.c

https://bitbucket.org/wisechild/galaxy-nexus · C · 4892 lines · 3688 code · 975 blank · 229 comment · 517 complexity · 651627daad8025e184a206d72d55e37f MD5 · raw file

Large files are truncated click here to view the full file

  1. /*
  2. * linux/drivers/video/omap2/dss/dsi.c
  3. *
  4. * Copyright (C) 2009 Nokia Corporation
  5. * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
  6. *
  7. * This program is free software; you can redistribute it and/or modify it
  8. * under the terms of the GNU General Public License version 2 as published by
  9. * the Free Software Foundation.
  10. *
  11. * This program is distributed in the hope that it will be useful, but WITHOUT
  12. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  14. * more details.
  15. *
  16. * You should have received a copy of the GNU General Public License along with
  17. * this program. If not, see <http://www.gnu.org/licenses/>.
  18. */
  19. #define DSS_SUBSYS_NAME "DSI"
  20. #include <linux/kernel.h>
  21. #include <linux/io.h>
  22. #include <linux/clk.h>
  23. #include <linux/device.h>
  24. #include <linux/err.h>
  25. #include <linux/interrupt.h>
  26. #include <linux/delay.h>
  27. #include <linux/mutex.h>
  28. #include <linux/semaphore.h>
  29. #include <linux/seq_file.h>
  30. #include <linux/platform_device.h>
  31. #include <linux/regulator/consumer.h>
  32. #include <linux/wait.h>
  33. #include <linux/workqueue.h>
  34. #include <linux/sched.h>
  35. #include <linux/slab.h>
  36. #include <linux/debugfs.h>
  37. #include <linux/pm_runtime.h>
  38. #include <video/omapdss.h>
  39. #include <plat/clock.h>
  40. #include "dss.h"
  41. #include "dss_features.h"
  42. /*#define VERBOSE_IRQ*/
  43. #define DSI_CATCH_MISSING_TE
  44. struct dsi_reg { u16 idx; };
  45. #define DSI_REG(idx) ((const struct dsi_reg) { idx })
  46. #define DSI_SZ_REGS SZ_1K
  47. /* DSI Protocol Engine */
  48. #define DSI_REVISION DSI_REG(0x0000)
  49. #define DSI_SYSCONFIG DSI_REG(0x0010)
  50. #define DSI_SYSSTATUS DSI_REG(0x0014)
  51. #define DSI_IRQSTATUS DSI_REG(0x0018)
  52. #define DSI_IRQENABLE DSI_REG(0x001C)
  53. #define DSI_CTRL DSI_REG(0x0040)
  54. #define DSI_GNQ DSI_REG(0x0044)
  55. #define DSI_COMPLEXIO_CFG1 DSI_REG(0x0048)
  56. #define DSI_COMPLEXIO_IRQ_STATUS DSI_REG(0x004C)
  57. #define DSI_COMPLEXIO_IRQ_ENABLE DSI_REG(0x0050)
  58. #define DSI_CLK_CTRL DSI_REG(0x0054)
  59. #define DSI_TIMING1 DSI_REG(0x0058)
  60. #define DSI_TIMING2 DSI_REG(0x005C)
  61. #define DSI_VM_TIMING1 DSI_REG(0x0060)
  62. #define DSI_VM_TIMING2 DSI_REG(0x0064)
  63. #define DSI_VM_TIMING3 DSI_REG(0x0068)
  64. #define DSI_CLK_TIMING DSI_REG(0x006C)
  65. #define DSI_TX_FIFO_VC_SIZE DSI_REG(0x0070)
  66. #define DSI_RX_FIFO_VC_SIZE DSI_REG(0x0074)
  67. #define DSI_COMPLEXIO_CFG2 DSI_REG(0x0078)
  68. #define DSI_RX_FIFO_VC_FULLNESS DSI_REG(0x007C)
  69. #define DSI_VM_TIMING4 DSI_REG(0x0080)
  70. #define DSI_TX_FIFO_VC_EMPTINESS DSI_REG(0x0084)
  71. #define DSI_VM_TIMING5 DSI_REG(0x0088)
  72. #define DSI_VM_TIMING6 DSI_REG(0x008C)
  73. #define DSI_VM_TIMING7 DSI_REG(0x0090)
  74. #define DSI_STOPCLK_TIMING DSI_REG(0x0094)
  75. #define DSI_VC_CTRL(n) DSI_REG(0x0100 + (n * 0x20))
  76. #define DSI_VC_TE(n) DSI_REG(0x0104 + (n * 0x20))
  77. #define DSI_VC_LONG_PACKET_HEADER(n) DSI_REG(0x0108 + (n * 0x20))
  78. #define DSI_VC_LONG_PACKET_PAYLOAD(n) DSI_REG(0x010C + (n * 0x20))
  79. #define DSI_VC_SHORT_PACKET_HEADER(n) DSI_REG(0x0110 + (n * 0x20))
  80. #define DSI_VC_IRQSTATUS(n) DSI_REG(0x0118 + (n * 0x20))
  81. #define DSI_VC_IRQENABLE(n) DSI_REG(0x011C + (n * 0x20))
  82. /* DSIPHY_SCP */
  83. #define DSI_DSIPHY_CFG0 DSI_REG(0x200 + 0x0000)
  84. #define DSI_DSIPHY_CFG1 DSI_REG(0x200 + 0x0004)
  85. #define DSI_DSIPHY_CFG2 DSI_REG(0x200 + 0x0008)
  86. #define DSI_DSIPHY_CFG5 DSI_REG(0x200 + 0x0014)
  87. #define DSI_DSIPHY_CFG10 DSI_REG(0x200 + 0x0028)
  88. /* DSI_PLL_CTRL_SCP */
  89. #define DSI_PLL_CONTROL DSI_REG(0x300 + 0x0000)
  90. #define DSI_PLL_STATUS DSI_REG(0x300 + 0x0004)
  91. #define DSI_PLL_GO DSI_REG(0x300 + 0x0008)
  92. #define DSI_PLL_CONFIGURATION1 DSI_REG(0x300 + 0x000C)
  93. #define DSI_PLL_CONFIGURATION2 DSI_REG(0x300 + 0x0010)
  94. #define REG_GET(dsidev, idx, start, end) \
  95. FLD_GET(dsi_read_reg(dsidev, idx), start, end)
  96. #define REG_FLD_MOD(dsidev, idx, val, start, end) \
  97. dsi_write_reg(dsidev, idx, FLD_MOD(dsi_read_reg(dsidev, idx), val, start, end))
  98. /* Global interrupts */
  99. #define DSI_IRQ_VC0 (1 << 0)
  100. #define DSI_IRQ_VC1 (1 << 1)
  101. #define DSI_IRQ_VC2 (1 << 2)
  102. #define DSI_IRQ_VC3 (1 << 3)
  103. #define DSI_IRQ_WAKEUP (1 << 4)
  104. #define DSI_IRQ_RESYNC (1 << 5)
  105. #define DSI_IRQ_PLL_LOCK (1 << 7)
  106. #define DSI_IRQ_PLL_UNLOCK (1 << 8)
  107. #define DSI_IRQ_PLL_RECALL (1 << 9)
  108. #define DSI_IRQ_COMPLEXIO_ERR (1 << 10)
  109. #define DSI_IRQ_HS_TX_TIMEOUT (1 << 14)
  110. #define DSI_IRQ_LP_RX_TIMEOUT (1 << 15)
  111. #define DSI_IRQ_TE_TRIGGER (1 << 16)
  112. #define DSI_IRQ_ACK_TRIGGER (1 << 17)
  113. #define DSI_IRQ_SYNC_LOST (1 << 18)
  114. #define DSI_IRQ_LDO_POWER_GOOD (1 << 19)
  115. #define DSI_IRQ_TA_TIMEOUT (1 << 20)
  116. #define DSI_IRQ_ERROR_MASK \
  117. (DSI_IRQ_HS_TX_TIMEOUT | DSI_IRQ_LP_RX_TIMEOUT | DSI_IRQ_SYNC_LOST | \
  118. DSI_IRQ_TA_TIMEOUT)
  119. #define DSI_IRQ_CHANNEL_MASK 0xf
  120. /* Virtual channel interrupts */
  121. #define DSI_VC_IRQ_CS (1 << 0)
  122. #define DSI_VC_IRQ_ECC_CORR (1 << 1)
  123. #define DSI_VC_IRQ_PACKET_SENT (1 << 2)
  124. #define DSI_VC_IRQ_FIFO_TX_OVF (1 << 3)
  125. #define DSI_VC_IRQ_FIFO_RX_OVF (1 << 4)
  126. #define DSI_VC_IRQ_BTA (1 << 5)
  127. #define DSI_VC_IRQ_ECC_NO_CORR (1 << 6)
  128. #define DSI_VC_IRQ_FIFO_TX_UDF (1 << 7)
  129. #define DSI_VC_IRQ_PP_BUSY_CHANGE (1 << 8)
  130. #define DSI_VC_IRQ_ERROR_MASK \
  131. (DSI_VC_IRQ_CS | DSI_VC_IRQ_ECC_CORR | DSI_VC_IRQ_FIFO_TX_OVF | \
  132. DSI_VC_IRQ_FIFO_RX_OVF | DSI_VC_IRQ_ECC_NO_CORR | \
  133. DSI_VC_IRQ_FIFO_TX_UDF)
  134. /* ComplexIO interrupts */
  135. #define DSI_CIO_IRQ_ERRSYNCESC1 (1 << 0)
  136. #define DSI_CIO_IRQ_ERRSYNCESC2 (1 << 1)
  137. #define DSI_CIO_IRQ_ERRSYNCESC3 (1 << 2)
  138. #define DSI_CIO_IRQ_ERRSYNCESC4 (1 << 3)
  139. #define DSI_CIO_IRQ_ERRSYNCESC5 (1 << 4)
  140. #define DSI_CIO_IRQ_ERRESC1 (1 << 5)
  141. #define DSI_CIO_IRQ_ERRESC2 (1 << 6)
  142. #define DSI_CIO_IRQ_ERRESC3 (1 << 7)
  143. #define DSI_CIO_IRQ_ERRESC4 (1 << 8)
  144. #define DSI_CIO_IRQ_ERRESC5 (1 << 9)
  145. #define DSI_CIO_IRQ_ERRCONTROL1 (1 << 10)
  146. #define DSI_CIO_IRQ_ERRCONTROL2 (1 << 11)
  147. #define DSI_CIO_IRQ_ERRCONTROL3 (1 << 12)
  148. #define DSI_CIO_IRQ_ERRCONTROL4 (1 << 13)
  149. #define DSI_CIO_IRQ_ERRCONTROL5 (1 << 14)
  150. #define DSI_CIO_IRQ_STATEULPS1 (1 << 15)
  151. #define DSI_CIO_IRQ_STATEULPS2 (1 << 16)
  152. #define DSI_CIO_IRQ_STATEULPS3 (1 << 17)
  153. #define DSI_CIO_IRQ_STATEULPS4 (1 << 18)
  154. #define DSI_CIO_IRQ_STATEULPS5 (1 << 19)
  155. #define DSI_CIO_IRQ_ERRCONTENTIONLP0_1 (1 << 20)
  156. #define DSI_CIO_IRQ_ERRCONTENTIONLP1_1 (1 << 21)
  157. #define DSI_CIO_IRQ_ERRCONTENTIONLP0_2 (1 << 22)
  158. #define DSI_CIO_IRQ_ERRCONTENTIONLP1_2 (1 << 23)
  159. #define DSI_CIO_IRQ_ERRCONTENTIONLP0_3 (1 << 24)
  160. #define DSI_CIO_IRQ_ERRCONTENTIONLP1_3 (1 << 25)
  161. #define DSI_CIO_IRQ_ERRCONTENTIONLP0_4 (1 << 26)
  162. #define DSI_CIO_IRQ_ERRCONTENTIONLP1_4 (1 << 27)
  163. #define DSI_CIO_IRQ_ERRCONTENTIONLP0_5 (1 << 28)
  164. #define DSI_CIO_IRQ_ERRCONTENTIONLP1_5 (1 << 29)
  165. #define DSI_CIO_IRQ_ULPSACTIVENOT_ALL0 (1 << 30)
  166. #define DSI_CIO_IRQ_ULPSACTIVENOT_ALL1 (1 << 31)
  167. #define DSI_CIO_IRQ_ERROR_MASK \
  168. (DSI_CIO_IRQ_ERRSYNCESC1 | DSI_CIO_IRQ_ERRSYNCESC2 | \
  169. DSI_CIO_IRQ_ERRSYNCESC3 | DSI_CIO_IRQ_ERRSYNCESC4 | \
  170. DSI_CIO_IRQ_ERRSYNCESC5 | \
  171. DSI_CIO_IRQ_ERRESC1 | DSI_CIO_IRQ_ERRESC2 | \
  172. DSI_CIO_IRQ_ERRESC3 | DSI_CIO_IRQ_ERRESC4 | \
  173. DSI_CIO_IRQ_ERRESC5 | \
  174. DSI_CIO_IRQ_ERRCONTROL1 | DSI_CIO_IRQ_ERRCONTROL2 | \
  175. DSI_CIO_IRQ_ERRCONTROL3 | DSI_CIO_IRQ_ERRCONTROL4 | \
  176. DSI_CIO_IRQ_ERRCONTROL5 | \
  177. DSI_CIO_IRQ_ERRCONTENTIONLP0_1 | DSI_CIO_IRQ_ERRCONTENTIONLP1_1 | \
  178. DSI_CIO_IRQ_ERRCONTENTIONLP0_2 | DSI_CIO_IRQ_ERRCONTENTIONLP1_2 | \
  179. DSI_CIO_IRQ_ERRCONTENTIONLP0_3 | DSI_CIO_IRQ_ERRCONTENTIONLP1_3 | \
  180. DSI_CIO_IRQ_ERRCONTENTIONLP0_4 | DSI_CIO_IRQ_ERRCONTENTIONLP1_4 | \
  181. DSI_CIO_IRQ_ERRCONTENTIONLP0_5 | DSI_CIO_IRQ_ERRCONTENTIONLP1_5)
  182. #define DSI_DT_DCS_SHORT_WRITE_0 0x05
  183. #define DSI_DT_DCS_SHORT_WRITE_1 0x15
  184. #define DSI_DT_DCS_READ 0x06
  185. #define DSI_DT_SET_MAX_RET_PKG_SIZE 0x37
  186. #define DSI_DT_NULL_PACKET 0x09
  187. #define DSI_DT_DCS_LONG_WRITE 0x39
  188. #define DSI_DT_RX_ACK_WITH_ERR 0x02
  189. #define DSI_DT_RX_LONG_READ 0x1a
  190. #define DSI_DT_RX_DCS_LONG_READ 0x1c
  191. #define DSI_DT_RX_SHORT_READ_1 0x21
  192. #define DSI_DT_RX_SHORT_READ_2 0x22
  193. typedef void (*omap_dsi_isr_t) (void *arg, u32 mask);
  194. #define DSI_MAX_NR_ISRS 2
  195. struct dsi_isr_data {
  196. omap_dsi_isr_t isr;
  197. void *arg;
  198. u32 mask;
  199. };
  200. enum fifo_size {
  201. DSI_FIFO_SIZE_0 = 0,
  202. DSI_FIFO_SIZE_32 = 1,
  203. DSI_FIFO_SIZE_64 = 2,
  204. DSI_FIFO_SIZE_96 = 3,
  205. DSI_FIFO_SIZE_128 = 4,
  206. };
  207. enum dsi_vc_mode {
  208. DSI_VC_MODE_L4 = 0,
  209. DSI_VC_MODE_VP,
  210. };
  211. enum dsi_lane {
  212. DSI_CLK_P = 1 << 0,
  213. DSI_CLK_N = 1 << 1,
  214. DSI_DATA1_P = 1 << 2,
  215. DSI_DATA1_N = 1 << 3,
  216. DSI_DATA2_P = 1 << 4,
  217. DSI_DATA2_N = 1 << 5,
  218. DSI_DATA3_P = 1 << 6,
  219. DSI_DATA3_N = 1 << 7,
  220. DSI_DATA4_P = 1 << 8,
  221. DSI_DATA4_N = 1 << 9,
  222. };
  223. struct dsi_update_region {
  224. u16 x, y, w, h;
  225. struct omap_dss_device *device;
  226. };
  227. struct dsi_irq_stats {
  228. unsigned long last_reset;
  229. unsigned irq_count;
  230. unsigned dsi_irqs[32];
  231. unsigned vc_irqs[4][32];
  232. unsigned cio_irqs[32];
  233. };
  234. struct dsi_isr_tables {
  235. struct dsi_isr_data isr_table[DSI_MAX_NR_ISRS];
  236. struct dsi_isr_data isr_table_vc[4][DSI_MAX_NR_ISRS];
  237. struct dsi_isr_data isr_table_cio[DSI_MAX_NR_ISRS];
  238. };
  239. struct dsi_data {
  240. struct platform_device *pdev;
  241. void __iomem *base;
  242. struct mutex runtime_lock;
  243. int runtime_count;
  244. int irq;
  245. struct clk *dss_clk;
  246. struct clk *sys_clk;
  247. void (*dsi_mux_pads)(bool enable);
  248. struct dsi_clock_info current_cinfo;
  249. bool vdds_dsi_enabled;
  250. struct regulator *vdds_dsi_reg;
  251. struct {
  252. enum dsi_vc_mode mode;
  253. struct omap_dss_device *dssdev;
  254. enum fifo_size fifo_size;
  255. int vc_id;
  256. } vc[4];
  257. struct mutex lock;
  258. struct semaphore bus_lock;
  259. unsigned pll_locked;
  260. spinlock_t irq_lock;
  261. struct dsi_isr_tables isr_tables;
  262. /* space for a copy used by the interrupt handler */
  263. struct dsi_isr_tables isr_tables_copy;
  264. int update_channel;
  265. struct dsi_update_region update_region;
  266. bool te_enabled;
  267. bool ulps_enabled;
  268. void (*framedone_callback)(int, void *);
  269. void *framedone_data;
  270. struct delayed_work framedone_timeout_work;
  271. #ifdef DSI_CATCH_MISSING_TE
  272. struct timer_list te_timer;
  273. #endif
  274. unsigned long cache_req_pck;
  275. unsigned long cache_clk_freq;
  276. struct dsi_clock_info cache_cinfo;
  277. u32 errors;
  278. spinlock_t errors_lock;
  279. #ifdef DEBUG
  280. ktime_t perf_setup_time;
  281. ktime_t perf_start_time;
  282. #endif
  283. int debug_read;
  284. int debug_write;
  285. #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
  286. spinlock_t irq_stats_lock;
  287. struct dsi_irq_stats irq_stats;
  288. #endif
  289. /* DSI PLL Parameter Ranges */
  290. unsigned long regm_max, regn_max;
  291. unsigned long regm_dispc_max, regm_dsi_max;
  292. unsigned long fint_min, fint_max;
  293. unsigned long lpdiv_max;
  294. int num_data_lanes;
  295. unsigned scp_clk_refcount;
  296. };
  297. struct dsi_packet_sent_handler_data {
  298. struct platform_device *dsidev;
  299. struct completion *completion;
  300. };
  301. static struct platform_device *dsi_pdev_map[MAX_NUM_DSI];
  302. #ifdef DEBUG
  303. static unsigned int dsi_perf;
  304. module_param_named(dsi_perf, dsi_perf, bool, 0644);
  305. #endif
  306. static inline struct dsi_data *dsi_get_dsidrv_data(struct platform_device *dsidev)
  307. {
  308. return dev_get_drvdata(&dsidev->dev);
  309. }
  310. static inline struct platform_device *dsi_get_dsidev_from_dssdev(struct omap_dss_device *dssdev)
  311. {
  312. return dsi_pdev_map[dssdev->phy.dsi.module];
  313. }
  314. struct platform_device *dsi_get_dsidev_from_id(int module)
  315. {
  316. return dsi_pdev_map[module];
  317. }
  318. static int dsi_get_dsidev_id(struct platform_device *dsidev)
  319. {
  320. /* TEMP: Pass 0 as the dsi module index till the time the dsi platform
  321. * device names aren't changed to the form "omapdss_dsi.0",
  322. * "omapdss_dsi.1" and so on */
  323. BUG_ON(dsidev->id != -1);
  324. return 0;
  325. }
  326. static inline void dsi_write_reg(struct platform_device *dsidev,
  327. const struct dsi_reg idx, u32 val)
  328. {
  329. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  330. __raw_writel(val, dsi->base + idx.idx);
  331. }
  332. static inline u32 dsi_read_reg(struct platform_device *dsidev,
  333. const struct dsi_reg idx)
  334. {
  335. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  336. return __raw_readl(dsi->base + idx.idx);
  337. }
  338. void dsi_bus_lock(struct omap_dss_device *dssdev)
  339. {
  340. struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
  341. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  342. down(&dsi->bus_lock);
  343. }
  344. EXPORT_SYMBOL(dsi_bus_lock);
  345. void dsi_bus_unlock(struct omap_dss_device *dssdev)
  346. {
  347. struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
  348. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  349. up(&dsi->bus_lock);
  350. }
  351. EXPORT_SYMBOL(dsi_bus_unlock);
  352. static bool dsi_bus_is_locked(struct platform_device *dsidev)
  353. {
  354. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  355. return dsi->bus_lock.count == 0;
  356. }
  357. static void dsi_completion_handler(void *data, u32 mask)
  358. {
  359. complete((struct completion *)data);
  360. }
  361. static inline int wait_for_bit_change(struct platform_device *dsidev,
  362. const struct dsi_reg idx, int bitnum, int value)
  363. {
  364. int t = 100000;
  365. while (REG_GET(dsidev, idx, bitnum, bitnum) != value) {
  366. if (--t == 0)
  367. return !value;
  368. }
  369. return value;
  370. }
  371. #ifdef DEBUG
  372. static void dsi_perf_mark_setup(struct platform_device *dsidev)
  373. {
  374. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  375. dsi->perf_setup_time = ktime_get();
  376. }
  377. static void dsi_perf_mark_start(struct platform_device *dsidev)
  378. {
  379. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  380. dsi->perf_start_time = ktime_get();
  381. }
  382. static void dsi_perf_show(struct platform_device *dsidev, const char *name)
  383. {
  384. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  385. ktime_t t, setup_time, trans_time;
  386. u32 total_bytes;
  387. u32 setup_us, trans_us, total_us;
  388. if (!dsi_perf)
  389. return;
  390. t = ktime_get();
  391. setup_time = ktime_sub(dsi->perf_start_time, dsi->perf_setup_time);
  392. setup_us = (u32)ktime_to_us(setup_time);
  393. if (setup_us == 0)
  394. setup_us = 1;
  395. trans_time = ktime_sub(t, dsi->perf_start_time);
  396. trans_us = (u32)ktime_to_us(trans_time);
  397. if (trans_us == 0)
  398. trans_us = 1;
  399. total_us = setup_us + trans_us;
  400. total_bytes = dsi->update_region.w *
  401. dsi->update_region.h *
  402. dsi->update_region.device->ctrl.pixel_size / 8;
  403. printk(KERN_INFO "DSI(%s): %u us + %u us = %u us (%uHz), "
  404. "%u bytes, %u kbytes/sec\n",
  405. name,
  406. setup_us,
  407. trans_us,
  408. total_us,
  409. 1000*1000 / total_us,
  410. total_bytes,
  411. total_bytes * 1000 / total_us);
  412. }
  413. #else
  414. static inline void dsi_perf_mark_setup(struct platform_device *dsidev)
  415. {
  416. }
  417. static inline void dsi_perf_mark_start(struct platform_device *dsidev)
  418. {
  419. }
  420. static inline void dsi_perf_show(struct platform_device *dsidev,
  421. const char *name)
  422. {
  423. }
  424. #endif
  425. static void print_irq_status(u32 status)
  426. {
  427. if (status == 0)
  428. return;
  429. #ifndef VERBOSE_IRQ
  430. if ((status & ~DSI_IRQ_CHANNEL_MASK) == 0)
  431. return;
  432. #endif
  433. printk(KERN_DEBUG "DSI IRQ: 0x%x: ", status);
  434. #define PIS(x) \
  435. if (status & DSI_IRQ_##x) \
  436. printk(#x " ");
  437. #ifdef VERBOSE_IRQ
  438. PIS(VC0);
  439. PIS(VC1);
  440. PIS(VC2);
  441. PIS(VC3);
  442. #endif
  443. PIS(WAKEUP);
  444. PIS(RESYNC);
  445. PIS(PLL_LOCK);
  446. PIS(PLL_UNLOCK);
  447. PIS(PLL_RECALL);
  448. PIS(COMPLEXIO_ERR);
  449. PIS(HS_TX_TIMEOUT);
  450. PIS(LP_RX_TIMEOUT);
  451. PIS(TE_TRIGGER);
  452. PIS(ACK_TRIGGER);
  453. PIS(SYNC_LOST);
  454. PIS(LDO_POWER_GOOD);
  455. PIS(TA_TIMEOUT);
  456. #undef PIS
  457. printk("\n");
  458. }
  459. static void print_irq_status_vc(int channel, u32 status)
  460. {
  461. if (status == 0)
  462. return;
  463. #ifndef VERBOSE_IRQ
  464. if ((status & ~DSI_VC_IRQ_PACKET_SENT) == 0)
  465. return;
  466. #endif
  467. printk(KERN_DEBUG "DSI VC(%d) IRQ 0x%x: ", channel, status);
  468. #define PIS(x) \
  469. if (status & DSI_VC_IRQ_##x) \
  470. printk(#x " ");
  471. PIS(CS);
  472. PIS(ECC_CORR);
  473. #ifdef VERBOSE_IRQ
  474. PIS(PACKET_SENT);
  475. #endif
  476. PIS(FIFO_TX_OVF);
  477. PIS(FIFO_RX_OVF);
  478. PIS(BTA);
  479. PIS(ECC_NO_CORR);
  480. PIS(FIFO_TX_UDF);
  481. PIS(PP_BUSY_CHANGE);
  482. #undef PIS
  483. printk("\n");
  484. }
  485. static void print_irq_status_cio(u32 status)
  486. {
  487. if (status == 0)
  488. return;
  489. printk(KERN_DEBUG "DSI CIO IRQ 0x%x: ", status);
  490. #define PIS(x) \
  491. if (status & DSI_CIO_IRQ_##x) \
  492. printk(#x " ");
  493. PIS(ERRSYNCESC1);
  494. PIS(ERRSYNCESC2);
  495. PIS(ERRSYNCESC3);
  496. PIS(ERRESC1);
  497. PIS(ERRESC2);
  498. PIS(ERRESC3);
  499. PIS(ERRCONTROL1);
  500. PIS(ERRCONTROL2);
  501. PIS(ERRCONTROL3);
  502. PIS(STATEULPS1);
  503. PIS(STATEULPS2);
  504. PIS(STATEULPS3);
  505. PIS(ERRCONTENTIONLP0_1);
  506. PIS(ERRCONTENTIONLP1_1);
  507. PIS(ERRCONTENTIONLP0_2);
  508. PIS(ERRCONTENTIONLP1_2);
  509. PIS(ERRCONTENTIONLP0_3);
  510. PIS(ERRCONTENTIONLP1_3);
  511. PIS(ULPSACTIVENOT_ALL0);
  512. PIS(ULPSACTIVENOT_ALL1);
  513. #undef PIS
  514. printk("\n");
  515. }
  516. #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
  517. static void dsi_collect_irq_stats(struct platform_device *dsidev, u32 irqstatus,
  518. u32 *vcstatus, u32 ciostatus)
  519. {
  520. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  521. int i;
  522. spin_lock(&dsi->irq_stats_lock);
  523. dsi->irq_stats.irq_count++;
  524. dss_collect_irq_stats(irqstatus, dsi->irq_stats.dsi_irqs);
  525. for (i = 0; i < 4; ++i)
  526. dss_collect_irq_stats(vcstatus[i], dsi->irq_stats.vc_irqs[i]);
  527. dss_collect_irq_stats(ciostatus, dsi->irq_stats.cio_irqs);
  528. spin_unlock(&dsi->irq_stats_lock);
  529. }
  530. #else
  531. #define dsi_collect_irq_stats(dsidev, irqstatus, vcstatus, ciostatus)
  532. #endif
  533. static int debug_irq;
  534. static void dsi_handle_irq_errors(struct platform_device *dsidev, u32 irqstatus,
  535. u32 *vcstatus, u32 ciostatus)
  536. {
  537. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  538. int i;
  539. if (irqstatus & DSI_IRQ_ERROR_MASK) {
  540. DSSERR("DSI error, irqstatus %x\n", irqstatus);
  541. print_irq_status(irqstatus);
  542. spin_lock(&dsi->errors_lock);
  543. dsi->errors |= irqstatus & DSI_IRQ_ERROR_MASK;
  544. spin_unlock(&dsi->errors_lock);
  545. } else if (debug_irq) {
  546. print_irq_status(irqstatus);
  547. }
  548. for (i = 0; i < 4; ++i) {
  549. if (vcstatus[i] & DSI_VC_IRQ_ERROR_MASK) {
  550. DSSERR("DSI VC(%d) error, vc irqstatus %x\n",
  551. i, vcstatus[i]);
  552. print_irq_status_vc(i, vcstatus[i]);
  553. } else if (debug_irq) {
  554. print_irq_status_vc(i, vcstatus[i]);
  555. }
  556. }
  557. if (ciostatus & DSI_CIO_IRQ_ERROR_MASK) {
  558. DSSERR("DSI CIO error, cio irqstatus %x\n", ciostatus);
  559. print_irq_status_cio(ciostatus);
  560. } else if (debug_irq) {
  561. print_irq_status_cio(ciostatus);
  562. }
  563. }
  564. static void dsi_call_isrs(struct dsi_isr_data *isr_array,
  565. unsigned isr_array_size, u32 irqstatus)
  566. {
  567. struct dsi_isr_data *isr_data;
  568. int i;
  569. for (i = 0; i < isr_array_size; i++) {
  570. isr_data = &isr_array[i];
  571. if (isr_data->isr && isr_data->mask & irqstatus)
  572. isr_data->isr(isr_data->arg, irqstatus);
  573. }
  574. }
  575. static void dsi_handle_isrs(struct dsi_isr_tables *isr_tables,
  576. u32 irqstatus, u32 *vcstatus, u32 ciostatus)
  577. {
  578. int i;
  579. dsi_call_isrs(isr_tables->isr_table,
  580. ARRAY_SIZE(isr_tables->isr_table),
  581. irqstatus);
  582. for (i = 0; i < 4; ++i) {
  583. if (vcstatus[i] == 0)
  584. continue;
  585. dsi_call_isrs(isr_tables->isr_table_vc[i],
  586. ARRAY_SIZE(isr_tables->isr_table_vc[i]),
  587. vcstatus[i]);
  588. }
  589. if (ciostatus != 0)
  590. dsi_call_isrs(isr_tables->isr_table_cio,
  591. ARRAY_SIZE(isr_tables->isr_table_cio),
  592. ciostatus);
  593. }
  594. static irqreturn_t omap_dsi_irq_handler(int irq, void *arg)
  595. {
  596. struct platform_device *dsidev;
  597. struct dsi_data *dsi;
  598. u32 irqstatus, vcstatus[4], ciostatus;
  599. int i;
  600. dsidev = (struct platform_device *) arg;
  601. dsi = dsi_get_dsidrv_data(dsidev);
  602. spin_lock(&dsi->irq_lock);
  603. irqstatus = dsi_read_reg(dsidev, DSI_IRQSTATUS);
  604. /* IRQ is not for us */
  605. if (!irqstatus) {
  606. spin_unlock(&dsi->irq_lock);
  607. return IRQ_NONE;
  608. }
  609. dsi_write_reg(dsidev, DSI_IRQSTATUS, irqstatus & ~DSI_IRQ_CHANNEL_MASK);
  610. /* flush posted write */
  611. dsi_read_reg(dsidev, DSI_IRQSTATUS);
  612. for (i = 0; i < 4; ++i) {
  613. if ((irqstatus & (1 << i)) == 0) {
  614. vcstatus[i] = 0;
  615. continue;
  616. }
  617. vcstatus[i] = dsi_read_reg(dsidev, DSI_VC_IRQSTATUS(i));
  618. dsi_write_reg(dsidev, DSI_VC_IRQSTATUS(i), vcstatus[i]);
  619. /* flush posted write */
  620. dsi_read_reg(dsidev, DSI_VC_IRQSTATUS(i));
  621. }
  622. if (irqstatus & DSI_IRQ_COMPLEXIO_ERR) {
  623. ciostatus = dsi_read_reg(dsidev, DSI_COMPLEXIO_IRQ_STATUS);
  624. dsi_write_reg(dsidev, DSI_COMPLEXIO_IRQ_STATUS, ciostatus);
  625. /* flush posted write */
  626. dsi_read_reg(dsidev, DSI_COMPLEXIO_IRQ_STATUS);
  627. } else {
  628. ciostatus = 0;
  629. }
  630. #ifdef DSI_CATCH_MISSING_TE
  631. if (irqstatus & DSI_IRQ_TE_TRIGGER)
  632. del_timer(&dsi->te_timer);
  633. #endif
  634. /* make a copy and unlock, so that isrs can unregister
  635. * themselves */
  636. memcpy(&dsi->isr_tables_copy, &dsi->isr_tables,
  637. sizeof(dsi->isr_tables));
  638. spin_unlock(&dsi->irq_lock);
  639. dsi_handle_isrs(&dsi->isr_tables_copy, irqstatus, vcstatus, ciostatus);
  640. dsi_handle_irq_errors(dsidev, irqstatus, vcstatus, ciostatus);
  641. dsi_collect_irq_stats(dsidev, irqstatus, vcstatus, ciostatus);
  642. return IRQ_HANDLED;
  643. }
  644. /* dsi->irq_lock has to be locked by the caller */
  645. static void _omap_dsi_configure_irqs(struct platform_device *dsidev,
  646. struct dsi_isr_data *isr_array,
  647. unsigned isr_array_size, u32 default_mask,
  648. const struct dsi_reg enable_reg,
  649. const struct dsi_reg status_reg)
  650. {
  651. struct dsi_isr_data *isr_data;
  652. u32 mask;
  653. u32 old_mask;
  654. int i;
  655. mask = default_mask;
  656. for (i = 0; i < isr_array_size; i++) {
  657. isr_data = &isr_array[i];
  658. if (isr_data->isr == NULL)
  659. continue;
  660. mask |= isr_data->mask;
  661. }
  662. old_mask = dsi_read_reg(dsidev, enable_reg);
  663. /* clear the irqstatus for newly enabled irqs */
  664. dsi_write_reg(dsidev, status_reg, (mask ^ old_mask) & mask);
  665. dsi_write_reg(dsidev, enable_reg, mask);
  666. /* flush posted writes */
  667. dsi_read_reg(dsidev, enable_reg);
  668. dsi_read_reg(dsidev, status_reg);
  669. }
  670. /* dsi->irq_lock has to be locked by the caller */
  671. static void _omap_dsi_set_irqs(struct platform_device *dsidev)
  672. {
  673. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  674. u32 mask = DSI_IRQ_ERROR_MASK;
  675. #ifdef DSI_CATCH_MISSING_TE
  676. mask |= DSI_IRQ_TE_TRIGGER;
  677. #endif
  678. _omap_dsi_configure_irqs(dsidev, dsi->isr_tables.isr_table,
  679. ARRAY_SIZE(dsi->isr_tables.isr_table), mask,
  680. DSI_IRQENABLE, DSI_IRQSTATUS);
  681. }
  682. /* dsi->irq_lock has to be locked by the caller */
  683. static void _omap_dsi_set_irqs_vc(struct platform_device *dsidev, int vc)
  684. {
  685. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  686. _omap_dsi_configure_irqs(dsidev, dsi->isr_tables.isr_table_vc[vc],
  687. ARRAY_SIZE(dsi->isr_tables.isr_table_vc[vc]),
  688. DSI_VC_IRQ_ERROR_MASK,
  689. DSI_VC_IRQENABLE(vc), DSI_VC_IRQSTATUS(vc));
  690. }
  691. /* dsi->irq_lock has to be locked by the caller */
  692. static void _omap_dsi_set_irqs_cio(struct platform_device *dsidev)
  693. {
  694. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  695. _omap_dsi_configure_irqs(dsidev, dsi->isr_tables.isr_table_cio,
  696. ARRAY_SIZE(dsi->isr_tables.isr_table_cio),
  697. DSI_CIO_IRQ_ERROR_MASK,
  698. DSI_COMPLEXIO_IRQ_ENABLE, DSI_COMPLEXIO_IRQ_STATUS);
  699. }
  700. static void _dsi_initialize_irq(struct platform_device *dsidev)
  701. {
  702. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  703. unsigned long flags;
  704. int vc;
  705. spin_lock_irqsave(&dsi->irq_lock, flags);
  706. memset(&dsi->isr_tables, 0, sizeof(dsi->isr_tables));
  707. _omap_dsi_set_irqs(dsidev);
  708. for (vc = 0; vc < 4; ++vc)
  709. _omap_dsi_set_irqs_vc(dsidev, vc);
  710. _omap_dsi_set_irqs_cio(dsidev);
  711. spin_unlock_irqrestore(&dsi->irq_lock, flags);
  712. }
  713. static int _dsi_register_isr(omap_dsi_isr_t isr, void *arg, u32 mask,
  714. struct dsi_isr_data *isr_array, unsigned isr_array_size)
  715. {
  716. struct dsi_isr_data *isr_data;
  717. int free_idx;
  718. int i;
  719. BUG_ON(isr == NULL);
  720. /* check for duplicate entry and find a free slot */
  721. free_idx = -1;
  722. for (i = 0; i < isr_array_size; i++) {
  723. isr_data = &isr_array[i];
  724. if (isr_data->isr == isr && isr_data->arg == arg &&
  725. isr_data->mask == mask) {
  726. return -EINVAL;
  727. }
  728. if (isr_data->isr == NULL && free_idx == -1)
  729. free_idx = i;
  730. }
  731. if (free_idx == -1)
  732. return -EBUSY;
  733. isr_data = &isr_array[free_idx];
  734. isr_data->isr = isr;
  735. isr_data->arg = arg;
  736. isr_data->mask = mask;
  737. return 0;
  738. }
  739. static int _dsi_unregister_isr(omap_dsi_isr_t isr, void *arg, u32 mask,
  740. struct dsi_isr_data *isr_array, unsigned isr_array_size)
  741. {
  742. struct dsi_isr_data *isr_data;
  743. int i;
  744. for (i = 0; i < isr_array_size; i++) {
  745. isr_data = &isr_array[i];
  746. if (isr_data->isr != isr || isr_data->arg != arg ||
  747. isr_data->mask != mask)
  748. continue;
  749. isr_data->isr = NULL;
  750. isr_data->arg = NULL;
  751. isr_data->mask = 0;
  752. return 0;
  753. }
  754. return -EINVAL;
  755. }
  756. static int dsi_register_isr(struct platform_device *dsidev, omap_dsi_isr_t isr,
  757. void *arg, u32 mask)
  758. {
  759. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  760. unsigned long flags;
  761. int r;
  762. spin_lock_irqsave(&dsi->irq_lock, flags);
  763. r = _dsi_register_isr(isr, arg, mask, dsi->isr_tables.isr_table,
  764. ARRAY_SIZE(dsi->isr_tables.isr_table));
  765. if (r == 0)
  766. _omap_dsi_set_irqs(dsidev);
  767. spin_unlock_irqrestore(&dsi->irq_lock, flags);
  768. return r;
  769. }
  770. static int dsi_unregister_isr(struct platform_device *dsidev,
  771. omap_dsi_isr_t isr, void *arg, u32 mask)
  772. {
  773. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  774. unsigned long flags;
  775. int r;
  776. spin_lock_irqsave(&dsi->irq_lock, flags);
  777. r = _dsi_unregister_isr(isr, arg, mask, dsi->isr_tables.isr_table,
  778. ARRAY_SIZE(dsi->isr_tables.isr_table));
  779. if (r == 0)
  780. _omap_dsi_set_irqs(dsidev);
  781. spin_unlock_irqrestore(&dsi->irq_lock, flags);
  782. return r;
  783. }
  784. static int dsi_register_isr_vc(struct platform_device *dsidev, int channel,
  785. omap_dsi_isr_t isr, void *arg, u32 mask)
  786. {
  787. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  788. unsigned long flags;
  789. int r;
  790. spin_lock_irqsave(&dsi->irq_lock, flags);
  791. r = _dsi_register_isr(isr, arg, mask,
  792. dsi->isr_tables.isr_table_vc[channel],
  793. ARRAY_SIZE(dsi->isr_tables.isr_table_vc[channel]));
  794. if (r == 0)
  795. _omap_dsi_set_irqs_vc(dsidev, channel);
  796. spin_unlock_irqrestore(&dsi->irq_lock, flags);
  797. return r;
  798. }
  799. static int dsi_unregister_isr_vc(struct platform_device *dsidev, int channel,
  800. omap_dsi_isr_t isr, void *arg, u32 mask)
  801. {
  802. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  803. unsigned long flags;
  804. int r;
  805. spin_lock_irqsave(&dsi->irq_lock, flags);
  806. r = _dsi_unregister_isr(isr, arg, mask,
  807. dsi->isr_tables.isr_table_vc[channel],
  808. ARRAY_SIZE(dsi->isr_tables.isr_table_vc[channel]));
  809. if (r == 0)
  810. _omap_dsi_set_irqs_vc(dsidev, channel);
  811. spin_unlock_irqrestore(&dsi->irq_lock, flags);
  812. return r;
  813. }
  814. static int dsi_register_isr_cio(struct platform_device *dsidev,
  815. omap_dsi_isr_t isr, void *arg, u32 mask)
  816. {
  817. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  818. unsigned long flags;
  819. int r;
  820. spin_lock_irqsave(&dsi->irq_lock, flags);
  821. r = _dsi_register_isr(isr, arg, mask, dsi->isr_tables.isr_table_cio,
  822. ARRAY_SIZE(dsi->isr_tables.isr_table_cio));
  823. if (r == 0)
  824. _omap_dsi_set_irqs_cio(dsidev);
  825. spin_unlock_irqrestore(&dsi->irq_lock, flags);
  826. return r;
  827. }
  828. static int dsi_unregister_isr_cio(struct platform_device *dsidev,
  829. omap_dsi_isr_t isr, void *arg, u32 mask)
  830. {
  831. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  832. unsigned long flags;
  833. int r;
  834. spin_lock_irqsave(&dsi->irq_lock, flags);
  835. r = _dsi_unregister_isr(isr, arg, mask, dsi->isr_tables.isr_table_cio,
  836. ARRAY_SIZE(dsi->isr_tables.isr_table_cio));
  837. if (r == 0)
  838. _omap_dsi_set_irqs_cio(dsidev);
  839. spin_unlock_irqrestore(&dsi->irq_lock, flags);
  840. return r;
  841. }
  842. static u32 dsi_get_errors(struct platform_device *dsidev)
  843. {
  844. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  845. unsigned long flags;
  846. u32 e;
  847. spin_lock_irqsave(&dsi->errors_lock, flags);
  848. e = dsi->errors;
  849. dsi->errors = 0;
  850. spin_unlock_irqrestore(&dsi->errors_lock, flags);
  851. return e;
  852. }
  853. int dsi_runtime_get(struct platform_device *dsidev)
  854. {
  855. int r;
  856. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  857. mutex_lock(&dsi->runtime_lock);
  858. if (dsi->runtime_count++ == 0) {
  859. DSSDBG("dsi_runtime_get\n");
  860. r = dss_runtime_get();
  861. if (r)
  862. goto err_get_dss;
  863. r = dispc_runtime_get();
  864. if (r)
  865. goto err_get_dispc;
  866. /* XXX dsi fclk can also come from DSI PLL */
  867. clk_enable(dsi->dss_clk);
  868. r = pm_runtime_get_sync(&dsi->pdev->dev);
  869. WARN_ON(r);
  870. if (r < 0)
  871. goto err_runtime_get;
  872. }
  873. mutex_unlock(&dsi->runtime_lock);
  874. return 0;
  875. err_runtime_get:
  876. clk_disable(dsi->dss_clk);
  877. dispc_runtime_put();
  878. err_get_dispc:
  879. dss_runtime_put();
  880. err_get_dss:
  881. mutex_unlock(&dsi->runtime_lock);
  882. return r;
  883. }
  884. void dsi_runtime_put(struct platform_device *dsidev)
  885. {
  886. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  887. mutex_lock(&dsi->runtime_lock);
  888. if (--dsi->runtime_count == 0) {
  889. int r;
  890. DSSDBG("dsi_runtime_put\n");
  891. r = pm_runtime_put_sync(&dsi->pdev->dev);
  892. WARN_ON(r);
  893. clk_disable(dsi->dss_clk);
  894. dispc_runtime_put();
  895. dss_runtime_put();
  896. }
  897. mutex_unlock(&dsi->runtime_lock);
  898. }
  899. /* source clock for DSI PLL. this could also be PCLKFREE */
  900. static inline void dsi_enable_pll_clock(struct platform_device *dsidev,
  901. bool enable)
  902. {
  903. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  904. if (enable)
  905. clk_enable(dsi->sys_clk);
  906. else
  907. clk_disable(dsi->sys_clk);
  908. if (enable && dsi->pll_locked) {
  909. if (wait_for_bit_change(dsidev, DSI_PLL_STATUS, 1, 1) != 1)
  910. DSSERR("cannot lock PLL when enabling clocks\n");
  911. }
  912. }
  913. #ifdef DEBUG
  914. static void _dsi_print_reset_status(struct platform_device *dsidev)
  915. {
  916. u32 l;
  917. int b0, b1, b2;
  918. if (!dss_debug)
  919. return;
  920. /* A dummy read using the SCP interface to any DSIPHY register is
  921. * required after DSIPHY reset to complete the reset of the DSI complex
  922. * I/O. */
  923. l = dsi_read_reg(dsidev, DSI_DSIPHY_CFG5);
  924. printk(KERN_DEBUG "DSI resets: ");
  925. l = dsi_read_reg(dsidev, DSI_PLL_STATUS);
  926. printk("PLL (%d) ", FLD_GET(l, 0, 0));
  927. l = dsi_read_reg(dsidev, DSI_COMPLEXIO_CFG1);
  928. printk("CIO (%d) ", FLD_GET(l, 29, 29));
  929. if (dss_has_feature(FEAT_DSI_REVERSE_TXCLKESC)) {
  930. b0 = 28;
  931. b1 = 27;
  932. b2 = 26;
  933. } else {
  934. b0 = 24;
  935. b1 = 25;
  936. b2 = 26;
  937. }
  938. l = dsi_read_reg(dsidev, DSI_DSIPHY_CFG5);
  939. printk("PHY (%x%x%x, %d, %d, %d)\n",
  940. FLD_GET(l, b0, b0),
  941. FLD_GET(l, b1, b1),
  942. FLD_GET(l, b2, b2),
  943. FLD_GET(l, 29, 29),
  944. FLD_GET(l, 30, 30),
  945. FLD_GET(l, 31, 31));
  946. }
  947. #else
  948. #define _dsi_print_reset_status(x)
  949. #endif
  950. static inline int dsi_if_enable(struct platform_device *dsidev, bool enable)
  951. {
  952. DSSDBG("dsi_if_enable(%d)\n", enable);
  953. enable = enable ? 1 : 0;
  954. REG_FLD_MOD(dsidev, DSI_CTRL, enable, 0, 0); /* IF_EN */
  955. if (wait_for_bit_change(dsidev, DSI_CTRL, 0, enable) != enable) {
  956. DSSERR("Failed to set dsi_if_enable to %d\n", enable);
  957. return -EIO;
  958. }
  959. return 0;
  960. }
  961. unsigned long dsi_get_pll_hsdiv_dispc_rate(struct platform_device *dsidev)
  962. {
  963. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  964. return dsi->current_cinfo.dsi_pll_hsdiv_dispc_clk;
  965. }
  966. static unsigned long dsi_get_pll_hsdiv_dsi_rate(struct platform_device *dsidev)
  967. {
  968. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  969. return dsi->current_cinfo.dsi_pll_hsdiv_dsi_clk;
  970. }
  971. static unsigned long dsi_get_txbyteclkhs(struct platform_device *dsidev)
  972. {
  973. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  974. return dsi->current_cinfo.clkin4ddr / 16;
  975. }
  976. static unsigned long dsi_fclk_rate(struct platform_device *dsidev)
  977. {
  978. unsigned long r;
  979. int dsi_module = dsi_get_dsidev_id(dsidev);
  980. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  981. if (dss_get_dsi_clk_source(dsi_module) == OMAP_DSS_CLK_SRC_FCK) {
  982. /* DSI FCLK source is DSS_CLK_FCK */
  983. r = clk_get_rate(dsi->dss_clk);
  984. } else {
  985. /* DSI FCLK source is dsi_pll_hsdiv_dsi_clk */
  986. r = dsi_get_pll_hsdiv_dsi_rate(dsidev);
  987. }
  988. return r;
  989. }
  990. static int dsi_set_lp_clk_divisor(struct omap_dss_device *dssdev)
  991. {
  992. struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
  993. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  994. unsigned long dsi_fclk;
  995. unsigned lp_clk_div;
  996. unsigned long lp_clk;
  997. lp_clk_div = dssdev->clocks.dsi.lp_clk_div;
  998. if (lp_clk_div == 0 || lp_clk_div > dsi->lpdiv_max)
  999. return -EINVAL;
  1000. dsi_fclk = dsi_fclk_rate(dsidev);
  1001. lp_clk = dsi_fclk / 2 / lp_clk_div;
  1002. DSSDBG("LP_CLK_DIV %u, LP_CLK %lu\n", lp_clk_div, lp_clk);
  1003. dsi->current_cinfo.lp_clk = lp_clk;
  1004. dsi->current_cinfo.lp_clk_div = lp_clk_div;
  1005. /* LP_CLK_DIVISOR */
  1006. REG_FLD_MOD(dsidev, DSI_CLK_CTRL, lp_clk_div, 12, 0);
  1007. /* LP_RX_SYNCHRO_ENABLE */
  1008. REG_FLD_MOD(dsidev, DSI_CLK_CTRL, dsi_fclk > 30000000 ? 1 : 0, 21, 21);
  1009. return 0;
  1010. }
  1011. static void dsi_enable_scp_clk(struct platform_device *dsidev)
  1012. {
  1013. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  1014. if (dsi->scp_clk_refcount++ == 0)
  1015. REG_FLD_MOD(dsidev, DSI_CLK_CTRL, 1, 14, 14); /* CIO_CLK_ICG */
  1016. }
  1017. static void dsi_disable_scp_clk(struct platform_device *dsidev)
  1018. {
  1019. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  1020. WARN_ON(dsi->scp_clk_refcount == 0);
  1021. if (--dsi->scp_clk_refcount == 0)
  1022. REG_FLD_MOD(dsidev, DSI_CLK_CTRL, 0, 14, 14); /* CIO_CLK_ICG */
  1023. }
  1024. enum dsi_pll_power_state {
  1025. DSI_PLL_POWER_OFF = 0x0,
  1026. DSI_PLL_POWER_ON_HSCLK = 0x1,
  1027. DSI_PLL_POWER_ON_ALL = 0x2,
  1028. DSI_PLL_POWER_ON_DIV = 0x3,
  1029. };
  1030. static int dsi_pll_power(struct platform_device *dsidev,
  1031. enum dsi_pll_power_state state)
  1032. {
  1033. int t = 0;
  1034. /* DSI-PLL power command 0x3 is not working */
  1035. if (dss_has_feature(FEAT_DSI_PLL_PWR_BUG) &&
  1036. state == DSI_PLL_POWER_ON_DIV)
  1037. state = DSI_PLL_POWER_ON_ALL;
  1038. /* PLL_PWR_CMD */
  1039. REG_FLD_MOD(dsidev, DSI_CLK_CTRL, state, 31, 30);
  1040. /* PLL_PWR_STATUS */
  1041. while (FLD_GET(dsi_read_reg(dsidev, DSI_CLK_CTRL), 29, 28) != state) {
  1042. if (++t > 1000) {
  1043. DSSERR("Failed to set DSI PLL power mode to %d\n",
  1044. state);
  1045. return -ENODEV;
  1046. }
  1047. udelay(1);
  1048. }
  1049. return 0;
  1050. }
  1051. /* calculate clock rates using dividers in cinfo */
  1052. static int dsi_calc_clock_rates(struct omap_dss_device *dssdev,
  1053. struct dsi_clock_info *cinfo)
  1054. {
  1055. struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
  1056. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  1057. if (cinfo->regn == 0 || cinfo->regn > dsi->regn_max)
  1058. return -EINVAL;
  1059. if (cinfo->regm == 0 || cinfo->regm > dsi->regm_max)
  1060. return -EINVAL;
  1061. if (cinfo->regm_dispc > dsi->regm_dispc_max)
  1062. return -EINVAL;
  1063. if (cinfo->regm_dsi > dsi->regm_dsi_max)
  1064. return -EINVAL;
  1065. if (cinfo->use_sys_clk) {
  1066. cinfo->clkin = clk_get_rate(dsi->sys_clk);
  1067. /* XXX it is unclear if highfreq should be used
  1068. * with DSS_SYS_CLK source also */
  1069. cinfo->highfreq = 0;
  1070. } else {
  1071. cinfo->clkin = dispc_pclk_rate(dssdev->manager->id);
  1072. if (cinfo->clkin < 32000000)
  1073. cinfo->highfreq = 0;
  1074. else
  1075. cinfo->highfreq = 1;
  1076. }
  1077. cinfo->fint = cinfo->clkin / (cinfo->regn * (cinfo->highfreq ? 2 : 1));
  1078. if (cinfo->fint > dsi->fint_max || cinfo->fint < dsi->fint_min)
  1079. return -EINVAL;
  1080. cinfo->clkin4ddr = 2 * cinfo->regm * cinfo->fint;
  1081. if (cinfo->clkin4ddr > 1800 * 1000 * 1000)
  1082. return -EINVAL;
  1083. if (cinfo->regm_dispc > 0)
  1084. cinfo->dsi_pll_hsdiv_dispc_clk =
  1085. cinfo->clkin4ddr / cinfo->regm_dispc;
  1086. else
  1087. cinfo->dsi_pll_hsdiv_dispc_clk = 0;
  1088. if (cinfo->regm_dsi > 0)
  1089. cinfo->dsi_pll_hsdiv_dsi_clk =
  1090. cinfo->clkin4ddr / cinfo->regm_dsi;
  1091. else
  1092. cinfo->dsi_pll_hsdiv_dsi_clk = 0;
  1093. return 0;
  1094. }
  1095. int dsi_pll_calc_clock_div_pck(struct platform_device *dsidev, bool is_tft,
  1096. unsigned long req_pck, struct dsi_clock_info *dsi_cinfo,
  1097. struct dispc_clock_info *dispc_cinfo)
  1098. {
  1099. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  1100. struct dsi_clock_info cur, best;
  1101. struct dispc_clock_info best_dispc;
  1102. int min_fck_per_pck;
  1103. int match = 0;
  1104. unsigned long dss_sys_clk, max_dss_fck;
  1105. dss_sys_clk = clk_get_rate(dsi->sys_clk);
  1106. max_dss_fck = dss_feat_get_param_max(FEAT_PARAM_DSS_FCK);
  1107. if (req_pck == dsi->cache_req_pck &&
  1108. dsi->cache_cinfo.clkin == dss_sys_clk) {
  1109. DSSDBG("DSI clock info found from cache\n");
  1110. *dsi_cinfo = dsi->cache_cinfo;
  1111. dispc_find_clk_divs(is_tft, req_pck,
  1112. dsi_cinfo->dsi_pll_hsdiv_dispc_clk, dispc_cinfo);
  1113. return 0;
  1114. }
  1115. min_fck_per_pck = CONFIG_OMAP2_DSS_MIN_FCK_PER_PCK;
  1116. if (min_fck_per_pck &&
  1117. req_pck * min_fck_per_pck > max_dss_fck) {
  1118. DSSERR("Requested pixel clock not possible with the current "
  1119. "OMAP2_DSS_MIN_FCK_PER_PCK setting. Turning "
  1120. "the constraint off.\n");
  1121. min_fck_per_pck = 0;
  1122. }
  1123. DSSDBG("dsi_pll_calc\n");
  1124. retry:
  1125. memset(&best, 0, sizeof(best));
  1126. memset(&best_dispc, 0, sizeof(best_dispc));
  1127. memset(&cur, 0, sizeof(cur));
  1128. cur.clkin = dss_sys_clk;
  1129. cur.use_sys_clk = 1;
  1130. cur.highfreq = 0;
  1131. /* no highfreq: 0.75MHz < Fint = clkin / regn < 2.1MHz */
  1132. /* highfreq: 0.75MHz < Fint = clkin / (2*regn) < 2.1MHz */
  1133. /* To reduce PLL lock time, keep Fint high (around 2 MHz) */
  1134. for (cur.regn = 1; cur.regn < dsi->regn_max; ++cur.regn) {
  1135. if (cur.highfreq == 0)
  1136. cur.fint = cur.clkin / cur.regn;
  1137. else
  1138. cur.fint = cur.clkin / (2 * cur.regn);
  1139. if (cur.fint > dsi->fint_max || cur.fint < dsi->fint_min)
  1140. continue;
  1141. /* DSIPHY(MHz) = (2 * regm / regn) * (clkin / (highfreq + 1)) */
  1142. for (cur.regm = 1; cur.regm < dsi->regm_max; ++cur.regm) {
  1143. unsigned long a, b;
  1144. a = 2 * cur.regm * (cur.clkin/1000);
  1145. b = cur.regn * (cur.highfreq + 1);
  1146. cur.clkin4ddr = a / b * 1000;
  1147. if (cur.clkin4ddr > 1800 * 1000 * 1000)
  1148. break;
  1149. /* dsi_pll_hsdiv_dispc_clk(MHz) =
  1150. * DSIPHY(MHz) / regm_dispc < 173MHz/186Mhz */
  1151. for (cur.regm_dispc = 1; cur.regm_dispc <
  1152. dsi->regm_dispc_max; ++cur.regm_dispc) {
  1153. struct dispc_clock_info cur_dispc;
  1154. cur.dsi_pll_hsdiv_dispc_clk =
  1155. cur.clkin4ddr / cur.regm_dispc;
  1156. /* this will narrow down the search a bit,
  1157. * but still give pixclocks below what was
  1158. * requested */
  1159. if (cur.dsi_pll_hsdiv_dispc_clk < req_pck)
  1160. break;
  1161. if (cur.dsi_pll_hsdiv_dispc_clk > max_dss_fck)
  1162. continue;
  1163. if (min_fck_per_pck &&
  1164. cur.dsi_pll_hsdiv_dispc_clk <
  1165. req_pck * min_fck_per_pck)
  1166. continue;
  1167. match = 1;
  1168. dispc_find_clk_divs(is_tft, req_pck,
  1169. cur.dsi_pll_hsdiv_dispc_clk,
  1170. &cur_dispc);
  1171. if (abs(cur_dispc.pck - req_pck) <
  1172. abs(best_dispc.pck - req_pck)) {
  1173. best = cur;
  1174. best_dispc = cur_dispc;
  1175. if (cur_dispc.pck == req_pck)
  1176. goto found;
  1177. }
  1178. }
  1179. }
  1180. }
  1181. found:
  1182. if (!match) {
  1183. if (min_fck_per_pck) {
  1184. DSSERR("Could not find suitable clock settings.\n"
  1185. "Turning FCK/PCK constraint off and"
  1186. "trying again.\n");
  1187. min_fck_per_pck = 0;
  1188. goto retry;
  1189. }
  1190. DSSERR("Could not find suitable clock settings.\n");
  1191. return -EINVAL;
  1192. }
  1193. /* dsi_pll_hsdiv_dsi_clk (regm_dsi) is not used */
  1194. best.regm_dsi = 0;
  1195. best.dsi_pll_hsdiv_dsi_clk = 0;
  1196. if (dsi_cinfo)
  1197. *dsi_cinfo = best;
  1198. if (dispc_cinfo)
  1199. *dispc_cinfo = best_dispc;
  1200. dsi->cache_req_pck = req_pck;
  1201. dsi->cache_clk_freq = 0;
  1202. dsi->cache_cinfo = best;
  1203. return 0;
  1204. }
  1205. int dsi_pll_set_clock_div(struct platform_device *dsidev,
  1206. struct dsi_clock_info *cinfo)
  1207. {
  1208. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  1209. int r = 0;
  1210. u32 l;
  1211. int f = 0;
  1212. u8 regn_start, regn_end, regm_start, regm_end;
  1213. u8 regm_dispc_start, regm_dispc_end, regm_dsi_start, regm_dsi_end;
  1214. DSSDBGF();
  1215. dsi->current_cinfo.use_sys_clk = cinfo->use_sys_clk;
  1216. dsi->current_cinfo.highfreq = cinfo->highfreq;
  1217. dsi->current_cinfo.fint = cinfo->fint;
  1218. dsi->current_cinfo.clkin4ddr = cinfo->clkin4ddr;
  1219. dsi->current_cinfo.dsi_pll_hsdiv_dispc_clk =
  1220. cinfo->dsi_pll_hsdiv_dispc_clk;
  1221. dsi->current_cinfo.dsi_pll_hsdiv_dsi_clk =
  1222. cinfo->dsi_pll_hsdiv_dsi_clk;
  1223. dsi->current_cinfo.regn = cinfo->regn;
  1224. dsi->current_cinfo.regm = cinfo->regm;
  1225. dsi->current_cinfo.regm_dispc = cinfo->regm_dispc;
  1226. dsi->current_cinfo.regm_dsi = cinfo->regm_dsi;
  1227. DSSDBG("DSI Fint %ld\n", cinfo->fint);
  1228. DSSDBG("clkin (%s) rate %ld, highfreq %d\n",
  1229. cinfo->use_sys_clk ? "dss_sys_clk" : "pclkfree",
  1230. cinfo->clkin,
  1231. cinfo->highfreq);
  1232. /* DSIPHY == CLKIN4DDR */
  1233. DSSDBG("CLKIN4DDR = 2 * %d / %d * %lu / %d = %lu\n",
  1234. cinfo->regm,
  1235. cinfo->regn,
  1236. cinfo->clkin,
  1237. cinfo->highfreq + 1,
  1238. cinfo->clkin4ddr);
  1239. DSSDBG("Data rate on 1 DSI lane %ld Mbps\n",
  1240. cinfo->clkin4ddr / 1000 / 1000 / 2);
  1241. DSSDBG("Clock lane freq %ld Hz\n", cinfo->clkin4ddr / 4);
  1242. DSSDBG("regm_dispc = %d, %s (%s) = %lu\n", cinfo->regm_dispc,
  1243. dss_get_generic_clk_source_name(OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC),
  1244. dss_feat_get_clk_source_name(OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC),
  1245. cinfo->dsi_pll_hsdiv_dispc_clk);
  1246. DSSDBG("regm_dsi = %d, %s (%s) = %lu\n", cinfo->regm_dsi,
  1247. dss_get_generic_clk_source_name(OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DSI),
  1248. dss_feat_get_clk_source_name(OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DSI),
  1249. cinfo->dsi_pll_hsdiv_dsi_clk);
  1250. dss_feat_get_reg_field(FEAT_REG_DSIPLL_REGN, &regn_start, &regn_end);
  1251. dss_feat_get_reg_field(FEAT_REG_DSIPLL_REGM, &regm_start, &regm_end);
  1252. dss_feat_get_reg_field(FEAT_REG_DSIPLL_REGM_DISPC, &regm_dispc_start,
  1253. &regm_dispc_end);
  1254. dss_feat_get_reg_field(FEAT_REG_DSIPLL_REGM_DSI, &regm_dsi_start,
  1255. &regm_dsi_end);
  1256. /* DSI_PLL_AUTOMODE = manual */
  1257. REG_FLD_MOD(dsidev, DSI_PLL_CONTROL, 0, 0, 0);
  1258. l = dsi_read_reg(dsidev, DSI_PLL_CONFIGURATION1);
  1259. l = FLD_MOD(l, 1, 0, 0); /* DSI_PLL_STOPMODE */
  1260. /* DSI_PLL_REGN */
  1261. l = FLD_MOD(l, cinfo->regn - 1, regn_start, regn_end);
  1262. /* DSI_PLL_REGM */
  1263. l = FLD_MOD(l, cinfo->regm, regm_start, regm_end);
  1264. /* DSI_CLOCK_DIV */
  1265. l = FLD_MOD(l, cinfo->regm_dispc > 0 ? cinfo->regm_dispc - 1 : 0,
  1266. regm_dispc_start, regm_dispc_end);
  1267. /* DSIPROTO_CLOCK_DIV */
  1268. l = FLD_MOD(l, cinfo->regm_dsi > 0 ? cinfo->regm_dsi - 1 : 0,
  1269. regm_dsi_start, regm_dsi_end);
  1270. dsi_write_reg(dsidev, DSI_PLL_CONFIGURATION1, l);
  1271. BUG_ON(cinfo->fint < dsi->fint_min || cinfo->fint > dsi->fint_max);
  1272. if (dss_has_feature(FEAT_DSI_PLL_FREQSEL)) {
  1273. f = cinfo->fint < 1000000 ? 0x3 :
  1274. cinfo->fint < 1250000 ? 0x4 :
  1275. cinfo->fint < 1500000 ? 0x5 :
  1276. cinfo->fint < 1750000 ? 0x6 :
  1277. 0x7;
  1278. }
  1279. l = dsi_read_reg(dsidev, DSI_PLL_CONFIGURATION2);
  1280. if (dss_has_feature(FEAT_DSI_PLL_FREQSEL))
  1281. l = FLD_MOD(l, f, 4, 1); /* DSI_PLL_FREQSEL */
  1282. l = FLD_MOD(l, cinfo->use_sys_clk ? 0 : 1,
  1283. 11, 11); /* DSI_PLL_CLKSEL */
  1284. l = FLD_MOD(l, cinfo->highfreq,
  1285. 12, 12); /* DSI_PLL_HIGHFREQ */
  1286. l = FLD_MOD(l, 1, 13, 13); /* DSI_PLL_REFEN */
  1287. l = FLD_MOD(l, 0, 14, 14); /* DSIPHY_CLKINEN */
  1288. l = FLD_MOD(l, 1, 20, 20); /* DSI_HSDIVBYPASS */
  1289. if (cpu_is_omap44xx())
  1290. l = FLD_MOD(l, 3, 22, 21); /* DSI_REF_SEL */
  1291. dsi_write_reg(dsidev, DSI_PLL_CONFIGURATION2, l);
  1292. REG_FLD_MOD(dsidev, DSI_PLL_GO, 1, 0, 0); /* DSI_PLL_GO */
  1293. if (wait_for_bit_change(dsidev, DSI_PLL_GO, 0, 0) != 0) {
  1294. DSSERR("dsi pll go bit not going down.\n");
  1295. r = -EIO;
  1296. goto err;
  1297. }
  1298. if (wait_for_bit_change(dsidev, DSI_PLL_STATUS, 1, 1) != 1) {
  1299. DSSERR("cannot lock PLL\n");
  1300. r = -EIO;
  1301. goto err;
  1302. }
  1303. dsi->pll_locked = 1;
  1304. l = dsi_read_reg(dsidev, DSI_PLL_CONFIGURATION2);
  1305. l = FLD_MOD(l, 0, 0, 0); /* DSI_PLL_IDLE */
  1306. l = FLD_MOD(l, 0, 5, 5); /* DSI_PLL_PLLLPMODE */
  1307. l = FLD_MOD(l, 0, 6, 6); /* DSI_PLL_LOWCURRSTBY */
  1308. l = FLD_MOD(l, 0, 7, 7); /* DSI_PLL_TIGHTPHASELOCK */
  1309. l = FLD_MOD(l, 0, 8, 8); /* DSI_PLL_DRIFTGUARDEN */
  1310. l = FLD_MOD(l, 0, 10, 9); /* DSI_PLL_LOCKSEL */
  1311. l = FLD_MOD(l, 1, 13, 13); /* DSI_PLL_REFEN */
  1312. l = FLD_MOD(l, 1, 14, 14); /* DSIPHY_CLKINEN */
  1313. l = FLD_MOD(l, 0, 15, 15); /* DSI_BYPASSEN */
  1314. l = FLD_MOD(l, 1, 16, 16); /* DSS_CLOCK_EN */
  1315. l = FLD_MOD(l, 0, 17, 17); /* DSS_CLOCK_PWDN */
  1316. l = FLD_MOD(l, 1, 18, 18); /* DSI_PROTO_CLOCK_EN */
  1317. l = FLD_MOD(l, 0, 19, 19); /* DSI_PROTO_CLOCK_PWDN */
  1318. l = FLD_MOD(l, 0, 20, 20); /* DSI_HSDIVBYPASS */
  1319. dsi_write_reg(dsidev, DSI_PLL_CONFIGURATION2, l);
  1320. DSSDBG("PLL config done\n");
  1321. err:
  1322. return r;
  1323. }
  1324. int dsi_pll_init(struct platform_device *dsidev, bool enable_hsclk,
  1325. bool enable_hsdiv)
  1326. {
  1327. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  1328. int r = 0;
  1329. enum dsi_pll_power_state pwstate;
  1330. DSSDBG("PLL init\n");
  1331. if (dsi->vdds_dsi_reg == NULL) {
  1332. struct regulator *vdds_dsi;
  1333. vdds_dsi = regulator_get(&dsi->pdev->dev, "vdds_dsi");
  1334. if (IS_ERR(vdds_dsi)) {
  1335. DSSERR("can't get VDDS_DSI regulator\n");
  1336. return PTR_ERR(vdds_dsi);
  1337. }
  1338. dsi->vdds_dsi_reg = vdds_dsi;
  1339. }
  1340. dsi_enable_pll_clock(dsidev, 1);
  1341. /*
  1342. * Note: SCP CLK is not required on OMAP3, but it is required on OMAP4.
  1343. */
  1344. dsi_enable_scp_clk(dsidev);
  1345. if (!dsi->vdds_dsi_enabled) {
  1346. r = regulator_enable(dsi->vdds_dsi_reg);
  1347. if (r)
  1348. goto err0;
  1349. dsi->vdds_dsi_enabled = true;
  1350. }
  1351. /* XXX PLL does not come out of reset without this... */
  1352. dispc_pck_free_enable(1);
  1353. if (wait_for_bit_change(dsidev, DSI_PLL_STATUS, 0, 1) != 1) {
  1354. DSSERR("PLL not coming out of reset.\n");
  1355. r = -ENODEV;
  1356. dispc_pck_free_enable(0);
  1357. goto err1;
  1358. }
  1359. /* XXX ... but if left on, we get problems when planes do not
  1360. * fill the whole display. No idea about this */
  1361. dispc_pck_free_enable(0);
  1362. if (enable_hsclk && enable_hsdiv)
  1363. pwstate = DSI_PLL_POWER_ON_ALL;
  1364. else if (enable_hsclk)
  1365. pwstate = DSI_PLL_POWER_ON_HSCLK;
  1366. else if (enable_hsdiv)
  1367. pwstate = DSI_PLL_POWER_ON_DIV;
  1368. else
  1369. pwstate = DSI_PLL_POWER_OFF;
  1370. r = dsi_pll_power(dsidev, pwstate);
  1371. if (r)
  1372. goto err1;
  1373. DSSDBG("PLL init done\n");
  1374. return 0;
  1375. err1:
  1376. if (dsi->vdds_dsi_enabled) {
  1377. regulator_disable(dsi->vdds_dsi_reg);
  1378. dsi->vdds_dsi_enabled = false;
  1379. }
  1380. err0:
  1381. dsi_disable_scp_clk(dsidev);
  1382. dsi_enable_pll_clock(dsidev, 0);
  1383. return r;
  1384. }
  1385. void dsi_pll_uninit(struct platform_device *dsidev, bool disconnect_lanes)
  1386. {
  1387. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  1388. dsi->pll_locked = 0;
  1389. dsi_pll_power(dsidev, DSI_PLL_POWER_OFF);
  1390. if (disconnect_lanes) {
  1391. WARN_ON(!dsi->vdds_dsi_enabled);
  1392. regulator_disable(dsi->vdds_dsi_reg);
  1393. dsi->vdds_dsi_enabled = false;
  1394. }
  1395. dsi_disable_scp_clk(dsidev);
  1396. dsi_enable_pll_clock(dsidev, 0);
  1397. DSSDBG("PLL uninit done\n");
  1398. }
  1399. static void dsi_dump_dsidev_clocks(struct platform_device *dsidev,
  1400. struct seq_file *s)
  1401. {
  1402. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  1403. struct dsi_clock_info *cinfo = &dsi->current_cinfo;
  1404. enum omap_dss_clk_source dispc_clk_src, dsi_clk_src;
  1405. int dsi_module = dsi_get_dsidev_id(dsidev);
  1406. dispc_clk_src = dss_get_dispc_clk_source();
  1407. dsi_clk_src = dss_get_dsi_clk_source(dsi_module);
  1408. if (dsi_runtime_get(dsidev))
  1409. return;
  1410. seq_printf(s, "- DSI%d PLL -\n", dsi_module + 1);
  1411. seq_printf(s, "dsi pll source = %s\n",
  1412. cinfo->use_sys_clk ? "dss_sys_clk" : "pclkfree");
  1413. seq_printf(s, "Fint\t\t%-16luregn %u\n", cinfo->fint, cinfo->regn);
  1414. seq_printf(s, "CLKIN4DDR\t%-16luregm %u\n",
  1415. cinfo->clkin4ddr, cinfo->regm);
  1416. seq_printf(s, "%s (%s)\t%-16luregm_dispc %u\t(%s)\n",
  1417. dss_get_generic_clk_source_name(dispc_clk_src),
  1418. dss_feat_get_clk_source_name(dispc_clk_src),
  1419. cinfo->dsi_pll_hsdiv_dispc_clk,
  1420. cinfo->regm_dispc,
  1421. dispc_clk_src == OMAP_DSS_CLK_SRC_FCK ?
  1422. "off" : "on");
  1423. seq_printf(s, "%s (%s)\t%-16luregm_dsi %u\t(%s)\n",
  1424. dss_get_generic_clk_source_name(dsi_clk_src),
  1425. dss_feat_get_clk_source_name(dsi_clk_src),
  1426. cinfo->dsi_pll_hsdiv_dsi_clk,
  1427. cinfo->regm_dsi,
  1428. dsi_clk_src == OMAP_DSS_CLK_SRC_FCK ?
  1429. "off" : "on");
  1430. seq_printf(s, "- DSI%d -\n", dsi_module + 1);
  1431. seq_printf(s, "dsi fclk source = %s (%s)\n",
  1432. dss_get_generic_clk_source_name(dsi_clk_src),
  1433. dss_feat_get_clk_source_name(dsi_clk_src));
  1434. seq_printf(s, "DSI_FCLK\t%lu\n", dsi_fclk_rate(dsidev));
  1435. seq_printf(s, "DDR_CLK\t\t%lu\n",
  1436. cinfo->clkin4ddr / 4);
  1437. seq_printf(s, "TxByteClkHS\t%lu\n", dsi_get_txbyteclkhs(dsidev));
  1438. seq_printf(s, "LP_CLK\t\t%lu\n", cinfo->lp_clk);
  1439. dsi_runtime_put(dsidev);
  1440. }
  1441. void dsi_dump_clocks(struct seq_file *s)
  1442. {
  1443. struct platform_device *dsidev;
  1444. int i;
  1445. for (i = 0; i < MAX_NUM_DSI; i++) {
  1446. dsidev = dsi_get_dsidev_from_id(i);
  1447. if (dsidev)
  1448. dsi_dump_dsidev_clocks(dsidev, s);
  1449. }
  1450. }
  1451. #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
  1452. static void dsi_dump_dsidev_irqs(struct platform_device *dsidev,
  1453. struct seq_file *s)
  1454. {
  1455. struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
  1456. unsigned long flags;
  1457. struct dsi_irq_stats stats;
  1458. int dsi_module = dsi_get_dsidev_id(dsidev);
  1459. spin_lock_irqsave(&dsi->irq_stats_lock, flags);
  1460. stats = dsi->irq_stats;
  1461. memset(&dsi->irq_stats, 0, sizeof(dsi->irq_stats));
  1462. dsi->irq_stats.last_reset = jiffies;
  1463. spin_unlock_irqrestore(&dsi->irq_stats_lock, flags);
  1464. seq_printf(s, "period %u ms\n",
  1465. jiffies_to_msecs(jiffies - stats.last_reset));
  1466. seq_printf(s, "irqs %d\n", stats.irq_count);
  1467. #define PIS(x) \
  1468. seq_printf(s, "%-20s %10d\n", #x, stats.dsi_irqs[ffs(DSI_IRQ_##x)-1]);
  1469. seq_printf(s, "-- DSI%d interrupts --\n", dsi_module + 1);
  1470. PIS(VC0);
  1471. PIS(VC1);
  1472. PIS(VC2);
  1473. PIS(VC3);
  1474. PIS(WAKEUP);
  1475. PIS(RESYNC);
  1476. PIS(PLL_LOCK);
  1477. PIS(PLL_UNLOCK);
  1478. PIS(PLL_RECALL);
  1479. PIS(COMPLEXIO_ERR);
  1480. PIS(HS_TX_TIMEOUT);
  1481. PIS(LP_RX_TIMEOUT);
  1482. PIS(TE_TRIGGER);
  1483. PIS(ACK_TRIGGER);
  1484. PIS(SYNC_LOST);
  1485. PIS(LDO_POWER_GOOD);
  1486. PIS(TA_TIMEOUT);
  1487. #undef PIS
  1488. #define PIS(x) \
  1489. seq_printf(s, "%-20s %10d %10d %10d %10d\n", #x, \
  1490. stats.vc_irqs[0][ffs(DSI_VC_IRQ_##x)-1], \
  1491. stats.vc_irqs[1][ffs(DSI_VC_IRQ_##x)-1], \
  1492. stats.vc_irqs[2][ffs(DSI_VC_IRQ_##x)-1], \
  1493. stats.vc_irqs[3][ffs(DSI_VC_IRQ_##x)-1]);
  1494. seq_printf(s, "-- VC interrupts --\n");
  1495. PIS(CS);
  1496. PIS(ECC_CORR);
  1497. PIS(PACKET_SENT);
  1498. PIS(FIFO_TX_OVF);
  1499. PIS(FIFO_RX_OVF);
  1500. PIS(BTA);
  1501. PIS(ECC_NO_CORR);
  1502. PIS(FIFO_TX_UDF);
  1503. PIS(PP_BUSY_CHANGE);
  1504. #undef PIS
  1505. #define PIS(x) \
  1506. seq_printf(s, "%-20s %10d\n", #x, \
  1507. stats.cio_irqs[ffs(DSI_CIO_IRQ_##x)-1]);
  1508. seq_printf(s, "-- CIO interrupts --\n");
  1509. PIS(ERRSYNCESC1);
  1510. PIS(ERRSYNCESC2);
  1511. PIS(ERRSYNCESC3);
  1512. PIS(ERRESC1);
  1513. PIS(ERRESC2);
  1514. PIS(ERRESC3);
  1515. PIS(ERRCONTROL1);
  1516. PIS(ERRCONTROL2);
  1517. PIS(ERRCONTROL3);
  1518. PIS(STATEULPS1);
  1519. PIS(STATEULPS2);
  1520. PIS(STATEULPS3);
  1521. PIS(ERRCONTENTIONLP0_1);
  1522. PIS(ERRCONTENTIONLP1_1);
  1523. PIS(ERRCONTENTIONLP0_2);
  1524. PIS(ERRCONTENTIONLP1_2);
  1525. PIS(ERRCONTENTIONLP0_3);
  1526. PIS(ERRCONTENTIONLP1_3);
  1527. PIS(ULPSACTIVENOT_ALL0);
  1528. PIS(ULPSACTIVENOT_ALL1);
  1529. #undef PIS
  1530. }
  1531. static void dsi1_dump_irqs(struct seq_file *s)
  1532. {
  1533. struct platform_device *dsidev = dsi_get_dsidev_from_id(0);
  1534. dsi_dump_dsidev_irqs(dsidev, s);
  1535. }
  1536. static void dsi2_dump_irqs(struct seq_file *s)
  1537. {
  1538. struct platform_device *dsidev = dsi_get_dsidev_from_id(1);
  1539. dsi_dump_dsidev_irqs(dsidev, s);
  1540. }
  1541. void dsi_create_debugfs_files_irq(struct dentry *debugfs_dir,
  1542. const struct file_operations *debug_fops)
  1543. {
  1544. struct platform_device *dsidev;
  1545. dsidev = dsi_get_dsidev_from_id(0);
  1546. if (dsidev)
  1547. debugfs_create_file("dsi1_irqs", S_IRUGO, debugfs_dir,
  1548. &dsi1_dump_irqs, debug_fops);
  1549. dsidev = dsi_get_dsidev_from_id(1);
  1550. if (dsidev)
  1551. debugfs_create_file("dsi2_irqs", S_IRUGO, debugfs_dir,
  1552. &dsi2_dump_irqs, debug_fops);
  1553. }
  1554. #endif
  1555. static void dsi_dump_dsidev_regs(struct platform_device *dsidev,
  1556. struct seq_file *s)
  1557. {
  1558. #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, dsi_read_reg(dsidev, r))
  1559. if (dsi_runtime_get(dsidev))
  1560. return;
  1561. dsi_enable_scp_clk(dsidev);
  1562. DUMPREG(DSI_REVISION);
  1563. DUMPREG(DSI_SYSCONFIG);
  1564. DUMPREG(DSI_SYSSTATUS);
  1565. DUMPREG(DSI_IRQSTATUS);
  1566. DUMPREG(DSI_IRQENABLE);
  1567. DUMPREG(DSI_CTRL);
  1568. DUMPREG(DSI_COMPLEXIO_CFG1);
  1569. DUMPREG(DSI_COMPLEXIO_IRQ_STATUS);
  1570. DUMPREG(DSI_COMPLEXIO_IRQ_ENABLE);
  1571. DUMPREG(DSI_CLK_CTRL);
  1572. DUMPREG(DSI_TIMING1);
  1573. DUMPREG(DSI_TIMING2);
  1574. DUMPREG(DSI_VM_TIMING1);
  1575. DUMPREG(DSI_VM_TIMING2);
  1576. DUMPREG(DSI_VM_TIMING3);
  1577. DUMPREG(DSI_CLK_TIMING);
  1578. DUMPREG(DSI_TX_FIFO_VC_SIZE);
  1579. DUMPREG(DSI_RX_FIFO_VC_SIZE);
  1580. DUMPREG(DSI_COMPLEXIO_CFG2);
  1581. DUMPREG(DSI_RX_FIFO_VC_FULLNESS);
  1582. DUMPREG(DSI_VM_TIMING4);
  1583. DUMPREG(DSI_TX_FIFO_VC_EMPTINESS