drivers/video/omap2/dss/dsi.c

   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
  20 #define DSS_SUBSYS_NAME "DSI"
  21
  22 #include <linux/kernel.h>
  23 #include <linux/io.h>
  24 #include <linux/clk.h>
  25 #include <linux/device.h>
  26 #include <linux/err.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/delay.h>
  29 #include <linux/mutex.h>
  30 #include <linux/semaphore.h>
  31 #include <linux/seq_file.h>
  32 #include <linux/platform_device.h>
  33 #include <linux/regulator/consumer.h>
  34 #include <linux/wait.h>
  35 #include <linux/workqueue.h>
  36
  37 #include <plat/display.h>
  38 #include <plat/clock.h>
  39
  40 #include "dss.h"
  41
  42 /*#define VERBOSE_IRQ*/
  43 #define DSI_CATCH_MISSING_TE
  44
  45 #define DSI_BASE                0x4804FC00
  46
  47 struct dsi_reg { u16 idx; };
  48
  49 #define DSI_REG(idx)            ((const struct dsi_reg) { idx })
  50
  51 #define DSI_SZ_REGS             SZ_1K
  52 /* DSI Protocol Engine */
  53
  54 #define DSI_REVISION                    DSI_REG(0x0000)
  55 #define DSI_SYSCONFIG                   DSI_REG(0x0010)
  56 #define DSI_SYSSTATUS                   DSI_REG(0x0014)
  57 #define DSI_IRQSTATUS                   DSI_REG(0x0018)
  58 #define DSI_IRQENABLE                   DSI_REG(0x001C)
  59 #define DSI_CTRL                        DSI_REG(0x0040)
  60 #define DSI_COMPLEXIO_CFG1              DSI_REG(0x0048)
  61 #define DSI_COMPLEXIO_IRQ_STATUS        DSI_REG(0x004C)
  62 #define DSI_COMPLEXIO_IRQ_ENABLE        DSI_REG(0x0050)
  63 #define DSI_CLK_CTRL                    DSI_REG(0x0054)
  64 #define DSI_TIMING1                     DSI_REG(0x0058)
  65 #define DSI_TIMING2                     DSI_REG(0x005C)
  66 #define DSI_VM_TIMING1                  DSI_REG(0x0060)
  67 #define DSI_VM_TIMING2                  DSI_REG(0x0064)
  68 #define DSI_VM_TIMING3                  DSI_REG(0x0068)
  69 #define DSI_CLK_TIMING                  DSI_REG(0x006C)
  70 #define DSI_TX_FIFO_VC_SIZE             DSI_REG(0x0070)
  71 #define DSI_RX_FIFO_VC_SIZE             DSI_REG(0x0074)
  72 #define DSI_COMPLEXIO_CFG2              DSI_REG(0x0078)
  73 #define DSI_RX_FIFO_VC_FULLNESS         DSI_REG(0x007C)
  74 #define DSI_VM_TIMING4                  DSI_REG(0x0080)
  75 #define DSI_TX_FIFO_VC_EMPTINESS        DSI_REG(0x0084)
  76 #define DSI_VM_TIMING5                  DSI_REG(0x0088)
  77 #define DSI_VM_TIMING6                  DSI_REG(0x008C)
  78 #define DSI_VM_TIMING7                  DSI_REG(0x0090)
  79 #define DSI_STOPCLK_TIMING              DSI_REG(0x0094)
  80 #define DSI_VC_CTRL(n)                  DSI_REG(0x0100 + (n * 0x20))
  81 #define DSI_VC_TE(n)                    DSI_REG(0x0104 + (n * 0x20))
  82 #define DSI_VC_LONG_PACKET_HEADER(n)    DSI_REG(0x0108 + (n * 0x20))
  83 #define DSI_VC_LONG_PACKET_PAYLOAD(n)   DSI_REG(0x010C + (n * 0x20))
  84 #define DSI_VC_SHORT_PACKET_HEADER(n)   DSI_REG(0x0110 + (n * 0x20))
  85 #define DSI_VC_IRQSTATUS(n)             DSI_REG(0x0118 + (n * 0x20))
  86 #define DSI_VC_IRQENABLE(n)             DSI_REG(0x011C + (n * 0x20))
  87
  88 /* DSIPHY_SCP */
  89
  90 #define DSI_DSIPHY_CFG0                 DSI_REG(0x200 + 0x0000)
  91 #define DSI_DSIPHY_CFG1                 DSI_REG(0x200 + 0x0004)
  92 #define DSI_DSIPHY_CFG2                 DSI_REG(0x200 + 0x0008)
  93 #define DSI_DSIPHY_CFG5                 DSI_REG(0x200 + 0x0014)
  94
  95 /* DSI_PLL_CTRL_SCP */
  96
  97 #define DSI_PLL_CONTROL                 DSI_REG(0x300 + 0x0000)
  98 #define DSI_PLL_STATUS                  DSI_REG(0x300 + 0x0004)
  99 #define DSI_PLL_GO                      DSI_REG(0x300 + 0x0008)
 100 #define DSI_PLL_CONFIGURATION1          DSI_REG(0x300 + 0x000C)
 101 #define DSI_PLL_CONFIGURATION2          DSI_REG(0x300 + 0x0010)
 102
 103 #define REG_GET(idx, start, end) \
 104         FLD_GET(dsi_read_reg(idx), start, end)
 105
 106 #define REG_FLD_MOD(idx, val, start, end) \
 107         dsi_write_reg(idx, FLD_MOD(dsi_read_reg(idx), val, start, end))
 108
 109 /* Global interrupts */
 110 #define DSI_IRQ_VC0             (1 << 0)
 111 #define DSI_IRQ_VC1             (1 << 1)
 112 #define DSI_IRQ_VC2             (1 << 2)
 113 #define DSI_IRQ_VC3             (1 << 3)
 114 #define DSI_IRQ_WAKEUP          (1 << 4)
 115 #define DSI_IRQ_RESYNC          (1 << 5)
 116 #define DSI_IRQ_PLL_LOCK        (1 << 7)
 117 #define DSI_IRQ_PLL_UNLOCK      (1 << 8)
 118 #define DSI_IRQ_PLL_RECALL      (1 << 9)
 119 #define DSI_IRQ_COMPLEXIO_ERR   (1 << 10)
 120 #define DSI_IRQ_HS_TX_TIMEOUT   (1 << 14)
 121 #define DSI_IRQ_LP_RX_TIMEOUT   (1 << 15)
 122 #define DSI_IRQ_TE_TRIGGER      (1 << 16)
 123 #define DSI_IRQ_ACK_TRIGGER     (1 << 17)
 124 #define DSI_IRQ_SYNC_LOST       (1 << 18)
 125 #define DSI_IRQ_LDO_POWER_GOOD  (1 << 19)
 126 #define DSI_IRQ_TA_TIMEOUT      (1 << 20)
 127 #define DSI_IRQ_ERROR_MASK \
 128         (DSI_IRQ_HS_TX_TIMEOUT | DSI_IRQ_LP_RX_TIMEOUT | DSI_IRQ_SYNC_LOST | \
 129         DSI_IRQ_TA_TIMEOUT)
 130 #define DSI_IRQ_CHANNEL_MASK    0xf
 131
 132 /* Virtual channel interrupts */
 133 #define DSI_VC_IRQ_CS           (1 << 0)
 134 #define DSI_VC_IRQ_ECC_CORR     (1 << 1)
 135 #define DSI_VC_IRQ_PACKET_SENT  (1 << 2)
 136 #define DSI_VC_IRQ_FIFO_TX_OVF  (1 << 3)
 137 #define DSI_VC_IRQ_FIFO_RX_OVF  (1 << 4)
 138 #define DSI_VC_IRQ_BTA          (1 << 5)
 139 #define DSI_VC_IRQ_ECC_NO_CORR  (1 << 6)
 140 #define DSI_VC_IRQ_FIFO_TX_UDF  (1 << 7)
 141 #define DSI_VC_IRQ_PP_BUSY_CHANGE (1 << 8)
 142 #define DSI_VC_IRQ_ERROR_MASK \
 143         (DSI_VC_IRQ_CS | DSI_VC_IRQ_ECC_CORR | DSI_VC_IRQ_FIFO_TX_OVF | \
 144         DSI_VC_IRQ_FIFO_RX_OVF | DSI_VC_IRQ_ECC_NO_CORR | \
 145         DSI_VC_IRQ_FIFO_TX_UDF)
 146
 147 /* ComplexIO interrupts */
 148 #define DSI_CIO_IRQ_ERRSYNCESC1         (1 << 0)
 149 #define DSI_CIO_IRQ_ERRSYNCESC2         (1 << 1)
 150 #define DSI_CIO_IRQ_ERRSYNCESC3         (1 << 2)
 151 #define DSI_CIO_IRQ_ERRESC1             (1 << 5)
 152 #define DSI_CIO_IRQ_ERRESC2             (1 << 6)
 153 #define DSI_CIO_IRQ_ERRESC3             (1 << 7)
 154 #define DSI_CIO_IRQ_ERRCONTROL1         (1 << 10)
 155 #define DSI_CIO_IRQ_ERRCONTROL2         (1 << 11)
 156 #define DSI_CIO_IRQ_ERRCONTROL3         (1 << 12)
 157 #define DSI_CIO_IRQ_STATEULPS1          (1 << 15)
 158 #define DSI_CIO_IRQ_STATEULPS2          (1 << 16)
 159 #define DSI_CIO_IRQ_STATEULPS3          (1 << 17)
 160 #define DSI_CIO_IRQ_ERRCONTENTIONLP0_1  (1 << 20)
 161 #define DSI_CIO_IRQ_ERRCONTENTIONLP1_1  (1 << 21)
 162 #define DSI_CIO_IRQ_ERRCONTENTIONLP0_2  (1 << 22)
 163 #define DSI_CIO_IRQ_ERRCONTENTIONLP1_2  (1 << 23)
 164 #define DSI_CIO_IRQ_ERRCONTENTIONLP0_3  (1 << 24)
 165 #define DSI_CIO_IRQ_ERRCONTENTIONLP1_3  (1 << 25)
 166 #define DSI_CIO_IRQ_ULPSACTIVENOT_ALL0  (1 << 30)
 167 #define DSI_CIO_IRQ_ULPSACTIVENOT_ALL1  (1 << 31)
 168 #define DSI_CIO_IRQ_ERROR_MASK \
 169         (DSI_CIO_IRQ_ERRSYNCESC1 | DSI_CIO_IRQ_ERRSYNCESC2 | \
 170          DSI_CIO_IRQ_ERRSYNCESC3 | DSI_CIO_IRQ_ERRESC1 | DSI_CIO_IRQ_ERRESC2 | \
 171          DSI_CIO_IRQ_ERRESC3 | DSI_CIO_IRQ_ERRCONTROL1 | \
 172          DSI_CIO_IRQ_ERRCONTROL2 | DSI_CIO_IRQ_ERRCONTROL3 | \
 173          DSI_CIO_IRQ_ERRCONTENTIONLP0_1 | DSI_CIO_IRQ_ERRCONTENTIONLP1_1 | \
 174          DSI_CIO_IRQ_ERRCONTENTIONLP0_2 | DSI_CIO_IRQ_ERRCONTENTIONLP1_2 | \
 175          DSI_CIO_IRQ_ERRCONTENTIONLP0_3 | DSI_CIO_IRQ_ERRCONTENTIONLP1_3)
 176
 177 #define DSI_DT_DCS_SHORT_WRITE_0        0x05
 178 #define DSI_DT_DCS_SHORT_WRITE_1        0x15
 179 #define DSI_DT_DCS_READ                 0x06
 180 #define DSI_DT_SET_MAX_RET_PKG_SIZE     0x37
 181 #define DSI_DT_NULL_PACKET              0x09
 182 #define DSI_DT_DCS_LONG_WRITE           0x39
 183
 184 #define DSI_DT_RX_ACK_WITH_ERR          0x02
 185 #define DSI_DT_RX_DCS_LONG_READ         0x1c
 186 #define DSI_DT_RX_SHORT_READ_1          0x21
 187 #define DSI_DT_RX_SHORT_READ_2          0x22
 188
 189 #define FINT_MAX 2100000
 190 #define FINT_MIN 750000
 191 #define REGN_MAX (1 << 7)
 192 #define REGM_MAX ((1 << 11) - 1)
 193 #define REGM3_MAX (1 << 4)
 194 #define REGM4_MAX (1 << 4)
 195 #define LP_DIV_MAX ((1 << 13) - 1)
 196
 197 enum fifo_size {
 198         DSI_FIFO_SIZE_0         = 0,
 199         DSI_FIFO_SIZE_32        = 1,
 200         DSI_FIFO_SIZE_64        = 2,
 201         DSI_FIFO_SIZE_96        = 3,
 202         DSI_FIFO_SIZE_128       = 4,
 203 };
 204
 205 enum dsi_vc_mode {
 206         DSI_VC_MODE_L4 = 0,
 207         DSI_VC_MODE_VP,
 208 };
 209
 210 struct dsi_update_region {
 211         u16 x, y, w, h;
 212         struct omap_dss_device *device;
 213 };
 214
 215 struct dsi_irq_stats {
 216         unsigned long last_reset;
 217         unsigned irq_count;
 218         unsigned dsi_irqs[32];
 219         unsigned vc_irqs[4][32];
 220         unsigned cio_irqs[32];
 221 };
 222
 223 static struct
 224 {
 225         struct platform_device *pdev;
 226         void __iomem    *base;
 227
 228         struct dsi_clock_info current_cinfo;
 229
 230         struct regulator *vdds_dsi_reg;
 231
 232         struct {
 233                 enum dsi_vc_mode mode;
 234                 struct omap_dss_device *dssdev;
 235                 enum fifo_size fifo_size;
 236         } vc[4];
 237
 238         struct mutex lock;
 239         struct semaphore bus_lock;
 240
 241         unsigned pll_locked;
 242
 243         struct completion bta_completion;
 244         void (*bta_callback)(void);
 245
 246         int update_channel;
 247         struct dsi_update_region update_region;
 248
 249         bool te_enabled;
 250
 251         struct workqueue_struct *workqueue;
 252
 253         void (*framedone_callback)(int, void *);
 254         void *framedone_data;
 255
 256         struct delayed_work framedone_timeout_work;
 257
 258 #ifdef DSI_CATCH_MISSING_TE
 259         struct timer_list te_timer;
 260 #endif
 261
 262         unsigned long cache_req_pck;
 263         unsigned long cache_clk_freq;
 264         struct dsi_clock_info cache_cinfo;
 265
 266         u32             errors;
 267         spinlock_t      errors_lock;
 268 #ifdef DEBUG
 269         ktime_t perf_setup_time;
 270         ktime_t perf_start_time;
 271 #endif
 272         int debug_read;
 273         int debug_write;
 274
 275 #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
 276         spinlock_t irq_stats_lock;
 277         struct dsi_irq_stats irq_stats;
 278 #endif
 279 } dsi;
 280
 281 #ifdef DEBUG
 282 static unsigned int dsi_perf;
 283 module_param_named(dsi_perf, dsi_perf, bool, 0644);
 284 #endif
 285
 286 static inline void dsi_write_reg(const struct dsi_reg idx, u32 val)
 287 {
 288         __raw_writel(val, dsi.base + idx.idx);
 289 }
 290
 291 static inline u32 dsi_read_reg(const struct dsi_reg idx)
 292 {
 293         return __raw_readl(dsi.base + idx.idx);
 294 }
 295
 296 static struct regulator *dsi_get_vdds_dsi(void)
 297 {
 298         struct regulator *reg;
 299
 300         if (dsi.vdds_dsi_reg != NULL)
 301                 return dsi.vdds_dsi_reg;
 302
 303         reg = regulator_get(&dsi.pdev->dev, "vdds_dsi");
 304         if (!IS_ERR(reg))
 305                 dsi.vdds_dsi_reg = reg;
 306
 307         return reg;
 308 }
 309
 310
 311 void dsi_save_context(void)
 312 {
 313 }
 314
 315 void dsi_restore_context(void)
 316 {
 317 }
 318
 319 void dsi_bus_lock(void)
 320 {
 321         down(&dsi.bus_lock);
 322 }
 323 EXPORT_SYMBOL(dsi_bus_lock);
 324
 325 void dsi_bus_unlock(void)
 326 {
 327         up(&dsi.bus_lock);
 328 }
 329 EXPORT_SYMBOL(dsi_bus_unlock);
 330
 331 static bool dsi_bus_is_locked(void)
 332 {
 333         return dsi.bus_lock.count == 0;
 334 }
 335
 336 static inline int wait_for_bit_change(const struct dsi_reg idx, int bitnum,
 337                 int value)
 338 {
 339         int t = 100000;
 340
 341         while (REG_GET(idx, bitnum, bitnum) != value) {
 342                 if (--t == 0)
 343                         return !value;
 344         }
 345
 346         return value;
 347 }
 348
 349 #ifdef DEBUG
 350 static void dsi_perf_mark_setup(void)
 351 {
 352         dsi.perf_setup_time = ktime_get();
 353 }
 354
 355 static void dsi_perf_mark_start(void)
 356 {
 357         dsi.perf_start_time = ktime_get();
 358 }
 359
 360 static void dsi_perf_show(const char *name)
 361 {
 362         ktime_t t, setup_time, trans_time;
 363         u32 total_bytes;
 364         u32 setup_us, trans_us, total_us;
 365
 366         if (!dsi_perf)
 367                 return;
 368
 369         t = ktime_get();
 370
 371         setup_time = ktime_sub(dsi.perf_start_time, dsi.perf_setup_time);
 372         setup_us = (u32)ktime_to_us(setup_time);
 373         if (setup_us == 0)
 374                 setup_us = 1;
 375
 376         trans_time = ktime_sub(t, dsi.perf_start_time);
 377         trans_us = (u32)ktime_to_us(trans_time);
 378         if (trans_us == 0)
 379                 trans_us = 1;
 380
 381         total_us = setup_us + trans_us;
 382
 383         total_bytes = dsi.update_region.w *
 384                 dsi.update_region.h *
 385                 dsi.update_region.device->ctrl.pixel_size / 8;
 386
 387         printk(KERN_INFO "DSI(%s): %u us + %u us = %u us (%uHz), "
 388                         "%u bytes, %u kbytes/sec\n",
 389                         name,
 390                         setup_us,
 391                         trans_us,
 392                         total_us,
 393                         1000*1000 / total_us,
 394                         total_bytes,
 395                         total_bytes * 1000 / total_us);
 396 }
 397 #else
 398 #define dsi_perf_mark_setup()
 399 #define dsi_perf_mark_start()
 400 #define dsi_perf_show(x)
 401 #endif
 402
 403 static void print_irq_status(u32 status)
 404 {
 405 #ifndef VERBOSE_IRQ
 406         if ((status & ~DSI_IRQ_CHANNEL_MASK) == 0)
 407                 return;
 408 #endif
 409         printk(KERN_DEBUG "DSI IRQ: 0x%x: ", status);
 410
 411 #define PIS(x) \
 412         if (status & DSI_IRQ_##x) \
 413                 printk(#x " ");
 414 #ifdef VERBOSE_IRQ
 415         PIS(VC0);
 416         PIS(VC1);
 417         PIS(VC2);
 418         PIS(VC3);
 419 #endif
 420         PIS(WAKEUP);
 421         PIS(RESYNC);
 422         PIS(PLL_LOCK);
 423         PIS(PLL_UNLOCK);
 424         PIS(PLL_RECALL);
 425         PIS(COMPLEXIO_ERR);
 426         PIS(HS_TX_TIMEOUT);
 427         PIS(LP_RX_TIMEOUT);
 428         PIS(TE_TRIGGER);
 429         PIS(ACK_TRIGGER);
 430         PIS(SYNC_LOST);
 431         PIS(LDO_POWER_GOOD);
 432         PIS(TA_TIMEOUT);
 433 #undef PIS
 434
 435         printk("\n");
 436 }
 437
 438 static void print_irq_status_vc(int channel, u32 status)
 439 {
 440 #ifndef VERBOSE_IRQ
 441         if ((status & ~DSI_VC_IRQ_PACKET_SENT) == 0)
 442                 return;
 443 #endif
 444         printk(KERN_DEBUG "DSI VC(%d) IRQ 0x%x: ", channel, status);
 445
 446 #define PIS(x) \
 447         if (status & DSI_VC_IRQ_##x) \
 448                 printk(#x " ");
 449         PIS(CS);
 450         PIS(ECC_CORR);
 451 #ifdef VERBOSE_IRQ
 452         PIS(PACKET_SENT);
 453 #endif
 454         PIS(FIFO_TX_OVF);
 455         PIS(FIFO_RX_OVF);
 456         PIS(BTA);
 457         PIS(ECC_NO_CORR);
 458         PIS(FIFO_TX_UDF);
 459         PIS(PP_BUSY_CHANGE);
 460 #undef PIS
 461         printk("\n");
 462 }
 463
 464 static void print_irq_status_cio(u32 status)
 465 {
 466         printk(KERN_DEBUG "DSI CIO IRQ 0x%x: ", status);
 467
 468 #define PIS(x) \
 469         if (status & DSI_CIO_IRQ_##x) \
 470                 printk(#x " ");
 471         PIS(ERRSYNCESC1);
 472         PIS(ERRSYNCESC2);
 473         PIS(ERRSYNCESC3);
 474         PIS(ERRESC1);
 475         PIS(ERRESC2);
 476         PIS(ERRESC3);
 477         PIS(ERRCONTROL1);
 478         PIS(ERRCONTROL2);
 479         PIS(ERRCONTROL3);
 480         PIS(STATEULPS1);
 481         PIS(STATEULPS2);
 482         PIS(STATEULPS3);
 483         PIS(ERRCONTENTIONLP0_1);
 484         PIS(ERRCONTENTIONLP1_1);
 485         PIS(ERRCONTENTIONLP0_2);
 486         PIS(ERRCONTENTIONLP1_2);
 487         PIS(ERRCONTENTIONLP0_3);
 488         PIS(ERRCONTENTIONLP1_3);
 489         PIS(ULPSACTIVENOT_ALL0);
 490         PIS(ULPSACTIVENOT_ALL1);
 491 #undef PIS
 492
 493         printk("\n");
 494 }
 495
 496 static int debug_irq;
 497
 498 /* called from dss */
 499 void dsi_irq_handler(void)
 500 {
 501         u32 irqstatus, vcstatus, ciostatus;
 502         int i;
 503
 504         irqstatus = dsi_read_reg(DSI_IRQSTATUS);
 505
 506 #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
 507         spin_lock(&dsi.irq_stats_lock);
 508         dsi.irq_stats.irq_count++;
 509         dss_collect_irq_stats(irqstatus, dsi.irq_stats.dsi_irqs);
 510 #endif
 511
 512         if (irqstatus & DSI_IRQ_ERROR_MASK) {
 513                 DSSERR("DSI error, irqstatus %x\n", irqstatus);
 514                 print_irq_status(irqstatus);
 515                 spin_lock(&dsi.errors_lock);
 516                 dsi.errors |= irqstatus & DSI_IRQ_ERROR_MASK;
 517                 spin_unlock(&dsi.errors_lock);
 518         } else if (debug_irq) {
 519                 print_irq_status(irqstatus);
 520         }
 521
 522 #ifdef DSI_CATCH_MISSING_TE
 523         if (irqstatus & DSI_IRQ_TE_TRIGGER)
 524                 del_timer(&dsi.te_timer);
 525 #endif
 526
 527         for (i = 0; i < 4; ++i) {
 528                 if ((irqstatus & (1<<i)) == 0)
 529                         continue;
 530
 531                 vcstatus = dsi_read_reg(DSI_VC_IRQSTATUS(i));
 532
 533 #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
 534                 dss_collect_irq_stats(vcstatus, dsi.irq_stats.vc_irqs[i]);
 535 #endif
 536
 537                 if (vcstatus & DSI_VC_IRQ_BTA) {
 538                         complete(&dsi.bta_completion);
 539
 540                         if (dsi.bta_callback)
 541                                 dsi.bta_callback();
 542                 }
 543
 544                 if (vcstatus & DSI_VC_IRQ_ERROR_MASK) {
 545                         DSSERR("DSI VC(%d) error, vc irqstatus %x\n",
 546                                        i, vcstatus);
 547                         print_irq_status_vc(i, vcstatus);
 548                 } else if (debug_irq) {
 549                         print_irq_status_vc(i, vcstatus);
 550                 }
 551
 552                 dsi_write_reg(DSI_VC_IRQSTATUS(i), vcstatus);
 553                 /* flush posted write */
 554                 dsi_read_reg(DSI_VC_IRQSTATUS(i));
 555         }
 556
 557         if (irqstatus & DSI_IRQ_COMPLEXIO_ERR) {
 558                 ciostatus = dsi_read_reg(DSI_COMPLEXIO_IRQ_STATUS);
 559
 560 #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
 561                 dss_collect_irq_stats(ciostatus, dsi.irq_stats.cio_irqs);
 562 #endif
 563
 564                 dsi_write_reg(DSI_COMPLEXIO_IRQ_STATUS, ciostatus);
 565                 /* flush posted write */
 566                 dsi_read_reg(DSI_COMPLEXIO_IRQ_STATUS);
 567
 568                 if (ciostatus & DSI_CIO_IRQ_ERROR_MASK) {
 569                         DSSERR("DSI CIO error, cio irqstatus %x\n", ciostatus);
 570                         print_irq_status_cio(ciostatus);
 571                 } else if (debug_irq) {
 572                         print_irq_status_cio(ciostatus);
 573                 }
 574         }
 575
 576         dsi_write_reg(DSI_IRQSTATUS, irqstatus & ~DSI_IRQ_CHANNEL_MASK);
 577         /* flush posted write */
 578         dsi_read_reg(DSI_IRQSTATUS);
 579
 580 #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
 581         spin_unlock(&dsi.irq_stats_lock);
 582 #endif
 583 }
 584
 585
 586 static void _dsi_initialize_irq(void)
 587 {
 588         u32 l;
 589         int i;
 590
 591         /* disable all interrupts */
 592         dsi_write_reg(DSI_IRQENABLE, 0);
 593         for (i = 0; i < 4; ++i)
 594                 dsi_write_reg(DSI_VC_IRQENABLE(i), 0);
 595         dsi_write_reg(DSI_COMPLEXIO_IRQ_ENABLE, 0);
 596
 597         /* clear interrupt status */
 598         l = dsi_read_reg(DSI_IRQSTATUS);
 599         dsi_write_reg(DSI_IRQSTATUS, l & ~DSI_IRQ_CHANNEL_MASK);
 600
 601         for (i = 0; i < 4; ++i) {
 602                 l = dsi_read_reg(DSI_VC_IRQSTATUS(i));
 603                 dsi_write_reg(DSI_VC_IRQSTATUS(i), l);
 604         }
 605
 606         l = dsi_read_reg(DSI_COMPLEXIO_IRQ_STATUS);
 607         dsi_write_reg(DSI_COMPLEXIO_IRQ_STATUS, l);
 608
 609         /* enable error irqs */
 610         l = DSI_IRQ_ERROR_MASK;
 611 #ifdef DSI_CATCH_MISSING_TE
 612         l |= DSI_IRQ_TE_TRIGGER;
 613 #endif
 614         dsi_write_reg(DSI_IRQENABLE, l);
 615
 616         l = DSI_VC_IRQ_ERROR_MASK;
 617         for (i = 0; i < 4; ++i)
 618                 dsi_write_reg(DSI_VC_IRQENABLE(i), l);
 619
 620         l = DSI_CIO_IRQ_ERROR_MASK;
 621         dsi_write_reg(DSI_COMPLEXIO_IRQ_ENABLE, l);
 622 }
 623
 624 static u32 dsi_get_errors(void)
 625 {
 626         unsigned long flags;
 627         u32 e;
 628         spin_lock_irqsave(&dsi.errors_lock, flags);
 629         e = dsi.errors;
 630         dsi.errors = 0;
 631         spin_unlock_irqrestore(&dsi.errors_lock, flags);
 632         return e;
 633 }
 634
 635 static void dsi_vc_enable_bta_irq(int channel)
 636 {
 637         u32 l;
 638
 639         dsi_write_reg(DSI_VC_IRQSTATUS(channel), DSI_VC_IRQ_BTA);
 640
 641         l = dsi_read_reg(DSI_VC_IRQENABLE(channel));
 642         l |= DSI_VC_IRQ_BTA;
 643         dsi_write_reg(DSI_VC_IRQENABLE(channel), l);
 644 }
 645
 646 static void dsi_vc_disable_bta_irq(int channel)
 647 {
 648         u32 l;
 649
 650         l = dsi_read_reg(DSI_VC_IRQENABLE(channel));
 651         l &= ~DSI_VC_IRQ_BTA;
 652         dsi_write_reg(DSI_VC_IRQENABLE(channel), l);
 653 }
 654
 655 /* DSI func clock. this could also be DSI2_PLL_FCLK */
 656 static inline void enable_clocks(bool enable)
 657 {
 658         if (enable)
 659                 dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
 660         else
 661                 dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
 662 }
 663
 664 /* source clock for DSI PLL. this could also be PCLKFREE */
 665 static inline void dsi_enable_pll_clock(bool enable)
 666 {
 667         if (enable)
 668                 dss_clk_enable(DSS_CLK_FCK2);
 669         else
 670                 dss_clk_disable(DSS_CLK_FCK2);
 671
 672         if (enable && dsi.pll_locked) {
 673                 if (wait_for_bit_change(DSI_PLL_STATUS, 1, 1) != 1)
 674                         DSSERR("cannot lock PLL when enabling clocks\n");
 675         }
 676 }
 677
 678 #ifdef DEBUG
 679 static void _dsi_print_reset_status(void)
 680 {
 681         u32 l;
 682
 683         if (!dss_debug)
 684                 return;
 685
 686         /* A dummy read using the SCP interface to any DSIPHY register is
 687          * required after DSIPHY reset to complete the reset of the DSI complex
 688          * I/O. */
 689         l = dsi_read_reg(DSI_DSIPHY_CFG5);
 690
 691         printk(KERN_DEBUG "DSI resets: ");
 692
 693         l = dsi_read_reg(DSI_PLL_STATUS);
 694         printk("PLL (%d) ", FLD_GET(l, 0, 0));
 695
 696         l = dsi_read_reg(DSI_COMPLEXIO_CFG1);
 697         printk("CIO (%d) ", FLD_GET(l, 29, 29));
 698
 699         l = dsi_read_reg(DSI_DSIPHY_CFG5);
 700         printk("PHY (%x, %d, %d, %d)\n",
 701                         FLD_GET(l, 28, 26),
 702                         FLD_GET(l, 29, 29),
 703                         FLD_GET(l, 30, 30),
 704                         FLD_GET(l, 31, 31));
 705 }
 706 #else
 707 #define _dsi_print_reset_status()
 708 #endif
 709
 710 static inline int dsi_if_enable(bool enable)
 711 {
 712         DSSDBG("dsi_if_enable(%d)\n", enable);
 713
 714         enable = enable ? 1 : 0;
 715         REG_FLD_MOD(DSI_CTRL, enable, 0, 0); /* IF_EN */
 716
 717         if (wait_for_bit_change(DSI_CTRL, 0, enable) != enable) {
 718                         DSSERR("Failed to set dsi_if_enable to %d\n", enable);
 719                         return -EIO;
 720         }
 721
 722         return 0;
 723 }
 724
 725 unsigned long dsi_get_dsi1_pll_rate(void)
 726 {
 727         return dsi.current_cinfo.dsi1_pll_fclk;
 728 }
 729
 730 static unsigned long dsi_get_dsi2_pll_rate(void)
 731 {
 732         return dsi.current_cinfo.dsi2_pll_fclk;
 733 }
 734
 735 static unsigned long dsi_get_txbyteclkhs(void)
 736 {
 737         return dsi.current_cinfo.clkin4ddr / 16;
 738 }
 739
 740 static unsigned long dsi_fclk_rate(void)
 741 {
 742         unsigned long r;
 743
 744         if (dss_get_dsi_clk_source() == DSS_SRC_DSS1_ALWON_FCLK) {
 745                 /* DSI FCLK source is DSS1_ALWON_FCK, which is dss1_fck */
 746                 r = dss_clk_get_rate(DSS_CLK_FCK1);
 747         } else {
 748                 /* DSI FCLK source is DSI2_PLL_FCLK */
 749                 r = dsi_get_dsi2_pll_rate();
 750         }
 751
 752         return r;
 753 }
 754
 755 static int dsi_set_lp_clk_divisor(struct omap_dss_device *dssdev)
 756 {
 757         unsigned long dsi_fclk;
 758         unsigned lp_clk_div;
 759         unsigned long lp_clk;
 760
 761         lp_clk_div = dssdev->phy.dsi.div.lp_clk_div;
 762
 763         if (lp_clk_div == 0 || lp_clk_div > LP_DIV_MAX)
 764                 return -EINVAL;
 765
 766         dsi_fclk = dsi_fclk_rate();
 767
 768         lp_clk = dsi_fclk / 2 / lp_clk_div;
 769
 770         DSSDBG("LP_CLK_DIV %u, LP_CLK %lu\n", lp_clk_div, lp_clk);
 771         dsi.current_cinfo.lp_clk = lp_clk;
 772         dsi.current_cinfo.lp_clk_div = lp_clk_div;
 773
 774         REG_FLD_MOD(DSI_CLK_CTRL, lp_clk_div, 12, 0);   /* LP_CLK_DIVISOR */
 775
 776         REG_FLD_MOD(DSI_CLK_CTRL, dsi_fclk > 30000000 ? 1 : 0,
 777                         21, 21);                /* LP_RX_SYNCHRO_ENABLE */
 778
 779         return 0;
 780 }
 781
 782
 783 enum dsi_pll_power_state {
 784         DSI_PLL_POWER_OFF       = 0x0,
 785         DSI_PLL_POWER_ON_HSCLK  = 0x1,
 786         DSI_PLL_POWER_ON_ALL    = 0x2,
 787         DSI_PLL_POWER_ON_DIV    = 0x3,
 788 };
 789
 790 static int dsi_pll_power(enum dsi_pll_power_state state)
 791 {
 792         int t = 0;
 793
 794         REG_FLD_MOD(DSI_CLK_CTRL, state, 31, 30);       /* PLL_PWR_CMD */
 795
 796         /* PLL_PWR_STATUS */
 797         while (FLD_GET(dsi_read_reg(DSI_CLK_CTRL), 29, 28) != state) {
 798                 if (++t > 1000) {
 799                         DSSERR("Failed to set DSI PLL power mode to %d\n",
 800                                         state);
 801                         return -ENODEV;
 802                 }
 803                 udelay(1);
 804         }
 805
 806         return 0;
 807 }
 808
 809 /* calculate clock rates using dividers in cinfo */
 810 static int dsi_calc_clock_rates(struct omap_dss_device *dssdev,
 811                 struct dsi_clock_info *cinfo)
 812 {
 813         if (cinfo->regn == 0 || cinfo->regn > REGN_MAX)
 814                 return -EINVAL;
 815
 816         if (cinfo->regm == 0 || cinfo->regm > REGM_MAX)
 817                 return -EINVAL;
 818
 819         if (cinfo->regm3 > REGM3_MAX)
 820                 return -EINVAL;
 821
 822         if (cinfo->regm4 > REGM4_MAX)
 823                 return -EINVAL;
 824
 825         if (cinfo->use_dss2_fck) {
 826                 cinfo->clkin = dss_clk_get_rate(DSS_CLK_FCK2);
 827                 /* XXX it is unclear if highfreq should be used
 828                  * with DSS2_FCK source also */
 829                 cinfo->highfreq = 0;
 830         } else {
 831                 cinfo->clkin = dispc_pclk_rate(dssdev->manager->id);
 832
 833                 if (cinfo->clkin < 32000000)
 834                         cinfo->highfreq = 0;
 835                 else
 836                         cinfo->highfreq = 1;
 837         }
 838
 839         cinfo->fint = cinfo->clkin / (cinfo->regn * (cinfo->highfreq ? 2 : 1));
 840
 841         if (cinfo->fint > FINT_MAX || cinfo->fint < FINT_MIN)
 842                 return -EINVAL;
 843
 844         cinfo->clkin4ddr = 2 * cinfo->regm * cinfo->fint;
 845
 846         if (cinfo->clkin4ddr > 1800 * 1000 * 1000)
 847                 return -EINVAL;
 848
 849         if (cinfo->regm3 > 0)
 850                 cinfo->dsi1_pll_fclk = cinfo->clkin4ddr / cinfo->regm3;
 851         else
 852                 cinfo->dsi1_pll_fclk = 0;
 853
 854         if (cinfo->regm4 > 0)
 855                 cinfo->dsi2_pll_fclk = cinfo->clkin4ddr / cinfo->regm4;
 856         else
 857                 cinfo->dsi2_pll_fclk = 0;
 858
 859         return 0;
 860 }
 861
 862 int dsi_pll_calc_clock_div_pck(bool is_tft, unsigned long req_pck,
 863                 struct dsi_clock_info *dsi_cinfo,
 864                 struct dispc_clock_info *dispc_cinfo)
 865 {
 866         struct dsi_clock_info cur, best;
 867         struct dispc_clock_info best_dispc;
 868         int min_fck_per_pck;
 869         int match = 0;
 870         unsigned long dss_clk_fck2;
 871
 872         dss_clk_fck2 = dss_clk_get_rate(DSS_CLK_FCK2);
 873
 874         if (req_pck == dsi.cache_req_pck &&
 875                         dsi.cache_cinfo.clkin == dss_clk_fck2) {
 876                 DSSDBG("DSI clock info found from cache\n");
 877                 *dsi_cinfo = dsi.cache_cinfo;
 878                 dispc_find_clk_divs(is_tft, req_pck, dsi_cinfo->dsi1_pll_fclk,
 879                                 dispc_cinfo);
 880                 return 0;
 881         }
 882
 883         min_fck_per_pck = CONFIG_OMAP2_DSS_MIN_FCK_PER_PCK;
 884
 885         if (min_fck_per_pck &&
 886                 req_pck * min_fck_per_pck > DISPC_MAX_FCK) {
 887                 DSSERR("Requested pixel clock not possible with the current "
 888                                 "OMAP2_DSS_MIN_FCK_PER_PCK setting. Turning "
 889                                 "the constraint off.\n");
 890                 min_fck_per_pck = 0;
 891         }
 892
 893         DSSDBG("dsi_pll_calc\n");
 894
 895 retry:
 896         memset(&best, 0, sizeof(best));
 897         memset(&best_dispc, 0, sizeof(best_dispc));
 898
 899         memset(&cur, 0, sizeof(cur));
 900         cur.clkin = dss_clk_fck2;
 901         cur.use_dss2_fck = 1;
 902         cur.highfreq = 0;
 903
 904         /* no highfreq: 0.75MHz < Fint = clkin / regn < 2.1MHz */
 905         /* highfreq: 0.75MHz < Fint = clkin / (2*regn) < 2.1MHz */
 906         /* To reduce PLL lock time, keep Fint high (around 2 MHz) */
 907         for (cur.regn = 1; cur.regn < REGN_MAX; ++cur.regn) {
 908                 if (cur.highfreq == 0)
 909                         cur.fint = cur.clkin / cur.regn;
 910                 else
 911                         cur.fint = cur.clkin / (2 * cur.regn);
 912
 913                 if (cur.fint > FINT_MAX || cur.fint < FINT_MIN)
 914                         continue;
 915
 916                 /* DSIPHY(MHz) = (2 * regm / regn) * (clkin / (highfreq + 1)) */
 917                 for (cur.regm = 1; cur.regm < REGM_MAX; ++cur.regm) {
 918                         unsigned long a, b;
 919
 920                         a = 2 * cur.regm * (cur.clkin/1000);
 921                         b = cur.regn * (cur.highfreq + 1);
 922                         cur.clkin4ddr = a / b * 1000;
 923
 924                         if (cur.clkin4ddr > 1800 * 1000 * 1000)
 925                                 break;
 926
 927                         /* DSI1_PLL_FCLK(MHz) = DSIPHY(MHz) / regm3  < 173MHz */
 928                         for (cur.regm3 = 1; cur.regm3 < REGM3_MAX;
 929                                         ++cur.regm3) {
 930                                 struct dispc_clock_info cur_dispc;
 931                                 cur.dsi1_pll_fclk = cur.clkin4ddr / cur.regm3;
 932
 933                                 /* this will narrow down the search a bit,
 934                                  * but still give pixclocks below what was
 935                                  * requested */
 936                                 if (cur.dsi1_pll_fclk  < req_pck)
 937                                         break;
 938
 939                                 if (cur.dsi1_pll_fclk > DISPC_MAX_FCK)
 940                                         continue;
 941
 942                                 if (min_fck_per_pck &&
 943                                         cur.dsi1_pll_fclk <
 944                                                 req_pck * min_fck_per_pck)
 945                                         continue;
 946
 947                                 match = 1;
 948
 949                                 dispc_find_clk_divs(is_tft, req_pck,
 950                                                 cur.dsi1_pll_fclk,
 951                                                 &cur_dispc);
 952
 953                                 if (abs(cur_dispc.pck - req_pck) <
 954                                                 abs(best_dispc.pck - req_pck)) {
 955                                         best = cur;
 956                                         best_dispc = cur_dispc;
 957
 958                                         if (cur_dispc.pck == req_pck)
 959                                                 goto found;
 960                                 }
 961                         }
 962                 }
 963         }
 964 found:
 965         if (!match) {
 966                 if (min_fck_per_pck) {
 967                         DSSERR("Could not find suitable clock settings.\n"
 968                                         "Turning FCK/PCK constraint off and"
 969                                         "trying again.\n");
 970                         min_fck_per_pck = 0;
 971                         goto retry;
 972                 }
 973
 974                 DSSERR("Could not find suitable clock settings.\n");
 975
 976                 return -EINVAL;
 977         }
 978
 979         /* DSI2_PLL_FCLK (regm4) is not used */
 980         best.regm4 = 0;
 981         best.dsi2_pll_fclk = 0;
 982
 983         if (dsi_cinfo)
 984                 *dsi_cinfo = best;
 985         if (dispc_cinfo)
 986                 *dispc_cinfo = best_dispc;
 987
 988         dsi.cache_req_pck = req_pck;
 989         dsi.cache_clk_freq = 0;
 990         dsi.cache_cinfo = best;
 991
 992         return 0;
 993 }
 994
 995 int dsi_pll_set_clock_div(struct dsi_clock_info *cinfo)
 996 {
 997         int r = 0;
 998         u32 l;
 999         int f;
1000
1001         DSSDBGF();
1002
1003         dsi.current_cinfo.fint = cinfo->fint;
1004         dsi.current_cinfo.clkin4ddr = cinfo->clkin4ddr;
1005         dsi.current_cinfo.dsi1_pll_fclk = cinfo->dsi1_pll_fclk;
1006         dsi.current_cinfo.dsi2_pll_fclk = cinfo->dsi2_pll_fclk;
1007
1008         dsi.current_cinfo.regn = cinfo->regn;
1009         dsi.current_cinfo.regm = cinfo->regm;
1010         dsi.current_cinfo.regm3 = cinfo->regm3;
1011         dsi.current_cinfo.regm4 = cinfo->regm4;
1012
1013         DSSDBG("DSI Fint %ld\n", cinfo->fint);
1014
1015         DSSDBG("clkin (%s) rate %ld, highfreq %d\n",
1016                         cinfo->use_dss2_fck ? "dss2_fck" : "pclkfree",
1017                         cinfo->clkin,
1018                         cinfo->highfreq);
1019
1020         /* DSIPHY == CLKIN4DDR */
1021         DSSDBG("CLKIN4DDR = 2 * %d / %d * %lu / %d = %lu\n",
1022                         cinfo->regm,
1023                         cinfo->regn,
1024                         cinfo->clkin,
1025                         cinfo->highfreq + 1,
1026                         cinfo->clkin4ddr);
1027
1028         DSSDBG("Data rate on 1 DSI lane %ld Mbps\n",
1029                         cinfo->clkin4ddr / 1000 / 1000 / 2);
1030
1031         DSSDBG("Clock lane freq %ld Hz\n", cinfo->clkin4ddr / 4);
1032
1033         DSSDBG("regm3 = %d, dsi1_pll_fclk = %lu\n",
1034                         cinfo->regm3, cinfo->dsi1_pll_fclk);
1035         DSSDBG("regm4 = %d, dsi2_pll_fclk = %lu\n",
1036                         cinfo->regm4, cinfo->dsi2_pll_fclk);
1037
1038         REG_FLD_MOD(DSI_PLL_CONTROL, 0, 0, 0); /* DSI_PLL_AUTOMODE = manual */
1039
1040         l = dsi_read_reg(DSI_PLL_CONFIGURATION1);
1041         l = FLD_MOD(l, 1, 0, 0);                /* DSI_PLL_STOPMODE */
1042         l = FLD_MOD(l, cinfo->regn - 1, 7, 1);  /* DSI_PLL_REGN */
1043         l = FLD_MOD(l, cinfo->regm, 18, 8);     /* DSI_PLL_REGM */
1044         l = FLD_MOD(l, cinfo->regm3 > 0 ? cinfo->regm3 - 1 : 0,
1045                         22, 19);                /* DSI_CLOCK_DIV */
1046         l = FLD_MOD(l, cinfo->regm4 > 0 ? cinfo->regm4 - 1 : 0,
1047                         26, 23);                /* DSIPROTO_CLOCK_DIV */
1048         dsi_write_reg(DSI_PLL_CONFIGURATION1, l);
1049
1050         BUG_ON(cinfo->fint < 750000 || cinfo->fint > 2100000);
1051         if (cinfo->fint < 1000000)
1052                 f = 0x3;
1053         else if (cinfo->fint < 1250000)
1054                 f = 0x4;
1055         else if (cinfo->fint < 1500000)
1056                 f = 0x5;
1057         else if (cinfo->fint < 1750000)
1058                 f = 0x6;
1059         else
1060                 f = 0x7;
1061
1062         l = dsi_read_reg(DSI_PLL_CONFIGURATION2);
1063         l = FLD_MOD(l, f, 4, 1);                /* DSI_PLL_FREQSEL */
1064         l = FLD_MOD(l, cinfo->use_dss2_fck ? 0 : 1,
1065                         11, 11);                /* DSI_PLL_CLKSEL */
1066         l = FLD_MOD(l, cinfo->highfreq,
1067                         12, 12);                /* DSI_PLL_HIGHFREQ */
1068         l = FLD_MOD(l, 1, 13, 13);              /* DSI_PLL_REFEN */
1069         l = FLD_MOD(l, 0, 14, 14);              /* DSIPHY_CLKINEN */
1070         l = FLD_MOD(l, 1, 20, 20);              /* DSI_HSDIVBYPASS */
1071         dsi_write_reg(DSI_PLL_CONFIGURATION2, l);
1072
1073         REG_FLD_MOD(DSI_PLL_GO, 1, 0, 0);       /* DSI_PLL_GO */
1074
1075         if (wait_for_bit_change(DSI_PLL_GO, 0, 0) != 0) {
1076                 DSSERR("dsi pll go bit not going down.\n");
1077                 r = -EIO;
1078                 goto err;
1079         }
1080
1081         if (wait_for_bit_change(DSI_PLL_STATUS, 1, 1) != 1) {
1082                 DSSERR("cannot lock PLL\n");
1083                 r = -EIO;
1084                 goto err;
1085         }
1086
1087         dsi.pll_locked = 1;
1088
1089         l = dsi_read_reg(DSI_PLL_CONFIGURATION2);
1090         l = FLD_MOD(l, 0, 0, 0);        /* DSI_PLL_IDLE */
1091         l = FLD_MOD(l, 0, 5, 5);        /* DSI_PLL_PLLLPMODE */
1092         l = FLD_MOD(l, 0, 6, 6);        /* DSI_PLL_LOWCURRSTBY */
1093         l = FLD_MOD(l, 0, 7, 7);        /* DSI_PLL_TIGHTPHASELOCK */
1094         l = FLD_MOD(l, 0, 8, 8);        /* DSI_PLL_DRIFTGUARDEN */
1095         l = FLD_MOD(l, 0, 10, 9);       /* DSI_PLL_LOCKSEL */
1096         l = FLD_MOD(l, 1, 13, 13);      /* DSI_PLL_REFEN */
1097         l = FLD_MOD(l, 1, 14, 14);      /* DSIPHY_CLKINEN */
1098         l = FLD_MOD(l, 0, 15, 15);      /* DSI_BYPASSEN */
1099         l = FLD_MOD(l, 1, 16, 16);      /* DSS_CLOCK_EN */
1100         l = FLD_MOD(l, 0, 17, 17);      /* DSS_CLOCK_PWDN */
1101         l = FLD_MOD(l, 1, 18, 18);      /* DSI_PROTO_CLOCK_EN */
1102         l = FLD_MOD(l, 0, 19, 19);      /* DSI_PROTO_CLOCK_PWDN */
1103         l = FLD_MOD(l, 0, 20, 20);      /* DSI_HSDIVBYPASS */
1104         dsi_write_reg(DSI_PLL_CONFIGURATION2, l);
1105
1106         DSSDBG("PLL config done\n");
1107 err:
1108         return r;
1109 }
1110
1111 int dsi_pll_init(struct omap_dss_device *dssdev, bool enable_hsclk,
1112                 bool enable_hsdiv)
1113 {
1114         int r = 0;
1115         enum dsi_pll_power_state pwstate;
1116
1117         DSSDBG("PLL init\n");
1118
1119         enable_clocks(1);
1120         dsi_enable_pll_clock(1);
1121
1122         r = regulator_enable(dsi.vdds_dsi_reg);
1123         if (r)
1124                 goto err0;
1125
1126         /* XXX PLL does not come out of reset without this... */
1127         dispc_pck_free_enable(1);
1128
1129         if (wait_for_bit_change(DSI_PLL_STATUS, 0, 1) != 1) {
1130                 DSSERR("PLL not coming out of reset.\n");
1131                 r = -ENODEV;
1132                 dispc_pck_free_enable(0);
1133                 goto err1;
1134         }
1135
1136         /* XXX ... but if left on, we get problems when planes do not
1137          * fill the whole display. No idea about this */
1138         dispc_pck_free_enable(0);
1139
1140         if (enable_hsclk && enable_hsdiv)
1141                 pwstate = DSI_PLL_POWER_ON_ALL;
1142         else if (enable_hsclk)
1143                 pwstate = DSI_PLL_POWER_ON_HSCLK;
1144         else if (enable_hsdiv)
1145                 pwstate = DSI_PLL_POWER_ON_DIV;
1146         else
1147                 pwstate = DSI_PLL_POWER_OFF;
1148
1149         r = dsi_pll_power(pwstate);
1150
1151         if (r)
1152                 goto err1;
1153
1154         DSSDBG("PLL init done\n");
1155
1156         return 0;
1157 err1:
1158         regulator_disable(dsi.vdds_dsi_reg);
1159 err0:
1160         enable_clocks(0);
1161         dsi_enable_pll_clock(0);
1162         return r;
1163 }
1164
1165 void dsi_pll_uninit(void)
1166 {
1167         enable_clocks(0);
1168         dsi_enable_pll_clock(0);
1169
1170         dsi.pll_locked = 0;
1171         dsi_pll_power(DSI_PLL_POWER_OFF);
1172         regulator_disable(dsi.vdds_dsi_reg);
1173         DSSDBG("PLL uninit done\n");
1174 }
1175
1176 void dsi_dump_clocks(struct seq_file *s)
1177 {
1178         int clksel;
1179         struct dsi_clock_info *cinfo = &dsi.current_cinfo;
1180
1181         enable_clocks(1);
1182
1183         clksel = REG_GET(DSI_PLL_CONFIGURATION2, 11, 11);
1184
1185         seq_printf(s,   "- DSI PLL -\n");
1186
1187         seq_printf(s,   "dsi pll source = %s\n",
1188                         clksel == 0 ?
1189                         "dss2_alwon_fclk" : "pclkfree");
1190
1191         seq_printf(s,   "Fint\t\t%-16luregn %u\n", cinfo->fint, cinfo->regn);
1192
1193         seq_printf(s,   "CLKIN4DDR\t%-16luregm %u\n",
1194                         cinfo->clkin4ddr, cinfo->regm);
1195
1196         seq_printf(s,   "dsi1_pll_fck\t%-16luregm3 %u\t(%s)\n",
1197                         cinfo->dsi1_pll_fclk,
1198                         cinfo->regm3,
1199                         dss_get_dispc_clk_source() == DSS_SRC_DSS1_ALWON_FCLK ?
1200                         "off" : "on");
1201
1202         seq_printf(s,   "dsi2_pll_fck\t%-16luregm4 %u\t(%s)\n",
1203                         cinfo->dsi2_pll_fclk,
1204                         cinfo->regm4,
1205                         dss_get_dsi_clk_source() == DSS_SRC_DSS1_ALWON_FCLK ?
1206                         "off" : "on");
1207
1208         seq_printf(s,   "- DSI -\n");
1209
1210         seq_printf(s,   "dsi fclk source = %s\n",
1211                         dss_get_dsi_clk_source() == DSS_SRC_DSS1_ALWON_FCLK ?
1212                         "dss1_alwon_fclk" : "dsi2_pll_fclk");
1213
1214         seq_printf(s,   "DSI_FCLK\t%lu\n", dsi_fclk_rate());
1215
1216         seq_printf(s,   "DDR_CLK\t\t%lu\n",
1217                         cinfo->clkin4ddr / 4);
1218
1219         seq_printf(s,   "TxByteClkHS\t%lu\n", dsi_get_txbyteclkhs());
1220
1221         seq_printf(s,   "LP_CLK\t\t%lu\n", cinfo->lp_clk);
1222
1223         seq_printf(s,   "VP_CLK\t\t%lu\n"
1224                         "VP_PCLK\t\t%lu\n",
1225                         dispc_lclk_rate(OMAP_DSS_CHANNEL_LCD),
1226                         dispc_pclk_rate(OMAP_DSS_CHANNEL_LCD));
1227
1228         enable_clocks(0);
1229 }
1230
1231 #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
1232 void dsi_dump_irqs(struct seq_file *s)
1233 {
1234         unsigned long flags;
1235         struct dsi_irq_stats stats;
1236
1237         spin_lock_irqsave(&dsi.irq_stats_lock, flags);
1238
1239         stats = dsi.irq_stats;
1240         memset(&dsi.irq_stats, 0, sizeof(dsi.irq_stats));
1241         dsi.irq_stats.last_reset = jiffies;
1242
1243         spin_unlock_irqrestore(&dsi.irq_stats_lock, flags);
1244
1245         seq_printf(s, "period %u ms\n",
1246                         jiffies_to_msecs(jiffies - stats.last_reset));
1247
1248         seq_printf(s, "irqs %d\n", stats.irq_count);
1249 #define PIS(x) \
1250         seq_printf(s, "%-20s %10d\n", #x, stats.dsi_irqs[ffs(DSI_IRQ_##x)-1]);
1251
1252         seq_printf(s, "-- DSI interrupts --\n");
1253         PIS(VC0);
1254         PIS(VC1);
1255         PIS(VC2);
1256         PIS(VC3);
1257         PIS(WAKEUP);
1258         PIS(RESYNC);
1259         PIS(PLL_LOCK);
1260         PIS(PLL_UNLOCK);
1261         PIS(PLL_RECALL);
1262         PIS(COMPLEXIO_ERR);
1263         PIS(HS_TX_TIMEOUT);
1264         PIS(LP_RX_TIMEOUT);
1265         PIS(TE_TRIGGER);
1266         PIS(ACK_TRIGGER);
1267         PIS(SYNC_LOST);
1268         PIS(LDO_POWER_GOOD);
1269         PIS(TA_TIMEOUT);
1270 #undef PIS
1271
1272 #define PIS(x) \
1273         seq_printf(s, "%-20s %10d %10d %10d %10d\n", #x, \
1274                         stats.vc_irqs[0][ffs(DSI_VC_IRQ_##x)-1], \
1275                         stats.vc_irqs[1][ffs(DSI_VC_IRQ_##x)-1], \
1276                         stats.vc_irqs[2][ffs(DSI_VC_IRQ_##x)-1], \
1277                         stats.vc_irqs[3][ffs(DSI_VC_IRQ_##x)-1]);
1278
1279         seq_printf(s, "-- VC interrupts --\n");
1280         PIS(CS);
1281         PIS(ECC_CORR);
1282         PIS(PACKET_SENT);
1283         PIS(FIFO_TX_OVF);
1284         PIS(FIFO_RX_OVF);
1285         PIS(BTA);
1286         PIS(ECC_NO_CORR);
1287         PIS(FIFO_TX_UDF);
1288         PIS(PP_BUSY_CHANGE);
1289 #undef PIS
1290
1291 #define PIS(x) \
1292         seq_printf(s, "%-20s %10d\n", #x, \
1293                         stats.cio_irqs[ffs(DSI_CIO_IRQ_##x)-1]);
1294
1295         seq_printf(s, "-- CIO interrupts --\n");
1296         PIS(ERRSYNCESC1);
1297         PIS(ERRSYNCESC2);
1298         PIS(ERRSYNCESC3);
1299         PIS(ERRESC1);
1300         PIS(ERRESC2);
1301         PIS(ERRESC3);
1302         PIS(ERRCONTROL1);
1303         PIS(ERRCONTROL2);
1304         PIS(ERRCONTROL3);
1305         PIS(STATEULPS1);
1306         PIS(STATEULPS2);
1307         PIS(STATEULPS3);
1308         PIS(ERRCONTENTIONLP0_1);
1309         PIS(ERRCONTENTIONLP1_1);
1310         PIS(ERRCONTENTIONLP0_2);
1311         PIS(ERRCONTENTIONLP1_2);
1312         PIS(ERRCONTENTIONLP0_3);
1313         PIS(ERRCONTENTIONLP1_3);
1314         PIS(ULPSACTIVENOT_ALL0);
1315         PIS(ULPSACTIVENOT_ALL1);
1316 #undef PIS
1317 }
1318 #endif
1319
1320 void dsi_dump_regs(struct seq_file *s)
1321 {
1322 #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, dsi_read_reg(r))
1323
1324         dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK1);
1325
1326         DUMPREG(DSI_REVISION);
1327         DUMPREG(DSI_SYSCONFIG);
1328         DUMPREG(DSI_SYSSTATUS);
1329         DUMPREG(DSI_IRQSTATUS);
1330         DUMPREG(DSI_IRQENABLE);
1331         DUMPREG(DSI_CTRL);
1332         DUMPREG(DSI_COMPLEXIO_CFG1);
1333         DUMPREG(DSI_COMPLEXIO_IRQ_STATUS);
1334         DUMPREG(DSI_COMPLEXIO_IRQ_ENABLE);
1335         DUMPREG(DSI_CLK_CTRL);
1336         DUMPREG(DSI_TIMING1);
1337         DUMPREG(DSI_TIMING2);
1338         DUMPREG(DSI_VM_TIMING1);
1339         DUMPREG(DSI_VM_TIMING2);
1340         DUMPREG(DSI_VM_TIMING3);
1341         DUMPREG(DSI_CLK_TIMING);
1342         DUMPREG(DSI_TX_FIFO_VC_SIZE);
1343         DUMPREG(DSI_RX_FIFO_VC_SIZE);
1344         DUMPREG(DSI_COMPLEXIO_CFG2);
1345         DUMPREG(DSI_RX_FIFO_VC_FULLNESS);
1346         DUMPREG(DSI_VM_TIMING4);
1347         DUMPREG(DSI_TX_FIFO_VC_EMPTINESS);
1348         DUMPREG(DSI_VM_TIMING5);
1349         DUMPREG(DSI_VM_TIMING6);
1350         DUMPREG(DSI_VM_TIMING7);
1351         DUMPREG(DSI_STOPCLK_TIMING);
1352
1353         DUMPREG(DSI_VC_CTRL(0));
1354         DUMPREG(DSI_VC_TE(0));
1355         DUMPREG(DSI_VC_LONG_PACKET_HEADER(0));
1356         DUMPREG(DSI_VC_LONG_PACKET_PAYLOAD(0));
1357         DUMPREG(DSI_VC_SHORT_PACKET_HEADER(0));
1358         DUMPREG(DSI_VC_IRQSTATUS(0));
1359         DUMPREG(DSI_VC_IRQENABLE(0));
1360
1361         DUMPREG(DSI_VC_CTRL(1));
1362         DUMPREG(DSI_VC_TE(1));
1363         DUMPREG(DSI_VC_LONG_PACKET_HEADER(1));
1364         DUMPREG(DSI_VC_LONG_PACKET_PAYLOAD(1));
1365         DUMPREG(DSI_VC_SHORT_PACKET_HEADER(1));
1366         DUMPREG(DSI_VC_IRQSTATUS(1));
1367         DUMPREG(DSI_VC_IRQENABLE(1));
1368
1369         DUMPREG(DSI_VC_CTRL(2));
1370         DUMPREG(DSI_VC_TE(2));
1371         DUMPREG(DSI_VC_LONG_PACKET_HEADER(2));
1372         DUMPREG(DSI_VC_LONG_PACKET_PAYLOAD(2));
1373         DUMPREG(DSI_VC_SHORT_PACKET_HEADER(2));
1374         DUMPREG(DSI_VC_IRQSTATUS(2));
1375         DUMPREG(DSI_VC_IRQENABLE(2));
1376
1377         DUMPREG(DSI_VC_CTRL(3));
1378         DUMPREG(DSI_VC_TE(3));
1379         DUMPREG(DSI_VC_LONG_PACKET_HEADER(3));
1380         DUMPREG(DSI_VC_LONG_PACKET_PAYLOAD(3));
1381         DUMPREG(DSI_VC_SHORT_PACKET_HEADER(3));
1382         DUMPREG(DSI_VC_IRQSTATUS(3));
1383         DUMPREG(DSI_VC_IRQENABLE(3));
1384
1385         DUMPREG(DSI_DSIPHY_CFG0);
1386         DUMPREG(DSI_DSIPHY_CFG1);
1387         DUMPREG(DSI_DSIPHY_CFG2);
1388         DUMPREG(DSI_DSIPHY_CFG5);
1389
1390         DUMPREG(DSI_PLL_CONTROL);
1391         DUMPREG(DSI_PLL_STATUS);
1392         DUMPREG(DSI_PLL_GO);
1393         DUMPREG(DSI_PLL_CONFIGURATION1);
1394         DUMPREG(DSI_PLL_CONFIGURATION2);
1395
1396         dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK1);
1397 #undef DUMPREG
1398 }
1399
1400 enum dsi_complexio_power_state {
1401         DSI_COMPLEXIO_POWER_OFF         = 0x0,
1402         DSI_COMPLEXIO_POWER_ON          = 0x1,
1403         DSI_COMPLEXIO_POWER_ULPS        = 0x2,
1404 };
1405
1406 static int dsi_complexio_power(enum dsi_complexio_power_state state)
1407 {
1408         int t = 0;
1409
1410         /* PWR_CMD */
1411         REG_FLD_MOD(DSI_COMPLEXIO_CFG1, state, 28, 27);
1412
1413         /* PWR_STATUS */
1414         while (FLD_GET(dsi_read_reg(DSI_COMPLEXIO_CFG1), 26, 25) != state) {
1415                 if (++t > 1000) {
1416                         DSSERR("failed to set complexio power state to "
1417                                         "%d\n", state);
1418                         return -ENODEV;
1419                 }
1420                 udelay(1);
1421         }
1422
1423         return 0;
1424 }
1425
1426 static void dsi_complexio_config(struct omap_dss_device *dssdev)
1427 {
1428         u32 r;
1429
1430         int clk_lane   = dssdev->phy.dsi.clk_lane;
1431         int data1_lane = dssdev->phy.dsi.data1_lane;
1432         int data2_lane = dssdev->phy.dsi.data2_lane;
1433         int clk_pol    = dssdev->phy.dsi.clk_pol;
1434         int data1_pol  = dssdev->phy.dsi.data1_pol;
1435         int data2_pol  = dssdev->phy.dsi.data2_pol;
1436
1437         r = dsi_read_reg(DSI_COMPLEXIO_CFG1);
1438         r = FLD_MOD(r, clk_lane, 2, 0);
1439         r = FLD_MOD(r, clk_pol, 3, 3);
1440         r = FLD_MOD(r, data1_lane, 6, 4);
1441         r = FLD_MOD(r, data1_pol, 7, 7);
1442         r = FLD_MOD(r, data2_lane, 10, 8);
1443         r = FLD_MOD(r, data2_pol, 11, 11);
1444         dsi_write_reg(DSI_COMPLEXIO_CFG1, r);
1445
1446         /* The configuration of the DSI complex I/O (number of data lanes,
1447            position, differential order) should not be changed while
1448            DSS.DSI_CLK_CRTRL[20] LP_CLK_ENABLE bit is set to 1. In order for
1449            the hardware to take into account a new configuration of the complex
1450            I/O (done in DSS.DSI_COMPLEXIO_CFG1 register), it is recommended to
1451            follow this sequence: First set the DSS.DSI_CTRL[0] IF_EN bit to 1,
1452            then reset the DSS.DSI_CTRL[0] IF_EN to 0, then set
1453            DSS.DSI_CLK_CTRL[20] LP_CLK_ENABLE to 1 and finally set again the
1454            DSS.DSI_CTRL[0] IF_EN bit to 1. If the sequence is not followed, the
1455            DSI complex I/O configuration is unknown. */
1456
1457         /*
1458         REG_FLD_MOD(DSI_CTRL, 1, 0, 0);
1459         REG_FLD_MOD(DSI_CTRL, 0, 0, 0);
1460         REG_FLD_MOD(DSI_CLK_CTRL, 1, 20, 20);
1461         REG_FLD_MOD(DSI_CTRL, 1, 0, 0);
1462         */
1463 }
1464
1465 static inline unsigned ns2ddr(unsigned ns)
1466 {
1467         /* convert time in ns to ddr ticks, rounding up */
1468         unsigned long ddr_clk = dsi.current_cinfo.clkin4ddr / 4;
1469         return (ns * (ddr_clk / 1000 / 1000) + 999) / 1000;
1470 }
1471
1472 static inline unsigned ddr2ns(unsigned ddr)
1473 {
1474         unsigned long ddr_clk = dsi.current_cinfo.clkin4ddr / 4;
1475         return ddr * 1000 * 1000 / (ddr_clk / 1000);
1476 }
1477
1478 static void dsi_complexio_timings(void)
1479 {
1480         u32 r;
1481         u32 ths_prepare, ths_prepare_ths_zero, ths_trail, ths_exit;
1482         u32 tlpx_half, tclk_trail, tclk_zero;
1483         u32 tclk_prepare;
1484
1485         /* calculate timings */
1486
1487         /* 1 * DDR_CLK = 2 * UI */
1488
1489         /* min 40ns + 4*UI      max 85ns + 6*UI */
1490         ths_prepare = ns2ddr(70) + 2;
1491
1492         /* min 145ns + 10*UI */
1493         ths_prepare_ths_zero = ns2ddr(175) + 2;
1494
1495         /* min max(8*UI, 60ns+4*UI) */
1496         ths_trail = ns2ddr(60) + 5;
1497
1498         /* min 100ns */
1499         ths_exit = ns2ddr(145);
1500
1501         /* tlpx min 50n */
1502         tlpx_half = ns2ddr(25);
1503
1504         /* min 60ns */
1505         tclk_trail = ns2ddr(60) + 2;
1506
1507         /* min 38ns, max 95ns */
1508         tclk_prepare = ns2ddr(65);
1509
1510         /* min tclk-prepare + tclk-zero = 300ns */
1511         tclk_zero = ns2ddr(260);
1512
1513         DSSDBG("ths_prepare %u (%uns), ths_prepare_ths_zero %u (%uns)\n",
1514                 ths_prepare, ddr2ns(ths_prepare),
1515                 ths_prepare_ths_zero, ddr2ns(ths_prepare_ths_zero));
1516         DSSDBG("ths_trail %u (%uns), ths_exit %u (%uns)\n",
1517                         ths_trail, ddr2ns(ths_trail),
1518                         ths_exit, ddr2ns(ths_exit));
1519
1520         DSSDBG("tlpx_half %u (%uns), tclk_trail %u (%uns), "
1521                         "tclk_zero %u (%uns)\n",
1522                         tlpx_half, ddr2ns(tlpx_half),
1523                         tclk_trail, ddr2ns(tclk_trail),
1524                         tclk_zero, ddr2ns(tclk_zero));
1525         DSSDBG("tclk_prepare %u (%uns)\n",
1526                         tclk_prepare, ddr2ns(tclk_prepare));
1527
1528         /* program timings */
1529
1530         r = dsi_read_reg(DSI_DSIPHY_CFG0);
1531         r = FLD_MOD(r, ths_prepare, 31, 24);
1532         r = FLD_MOD(r, ths_prepare_ths_zero, 23, 16);
1533         r = FLD_MOD(r, ths_trail, 15, 8);
1534         r = FLD_MOD(r, ths_exit, 7, 0);
1535         dsi_write_reg(DSI_DSIPHY_CFG0, r);
1536
1537         r = dsi_read_reg(DSI_DSIPHY_CFG1);
1538         r = FLD_MOD(r, tlpx_half, 22, 16);
1539         r = FLD_MOD(r, tclk_trail, 15, 8);
1540         r = FLD_MOD(r, tclk_zero, 7, 0);
1541         dsi_write_reg(DSI_DSIPHY_CFG1, r);
1542
1543         r = dsi_read_reg(DSI_DSIPHY_CFG2);
1544         r = FLD_MOD(r, tclk_prepare, 7, 0);
1545         dsi_write_reg(DSI_DSIPHY_CFG2, r);
1546 }
1547
1548
1549 static int dsi_complexio_init(struct omap_dss_device *dssdev)
1550 {
1551         int r = 0;
1552
1553         DSSDBG("dsi_complexio_init\n");
1554
1555         /* CIO_CLK_ICG, enable L3 clk to CIO */
1556         REG_FLD_MOD(DSI_CLK_CTRL, 1, 14, 14);
1557
1558         /* A dummy read using the SCP interface to any DSIPHY register is
1559          * required after DSIPHY reset to complete the reset of the DSI complex
1560          * I/O. */
1561         dsi_read_reg(DSI_DSIPHY_CFG5);
1562
1563         if (wait_for_bit_change(DSI_DSIPHY_CFG5, 30, 1) != 1) {
1564                 DSSERR("ComplexIO PHY not coming out of reset.\n");
1565                 r = -ENODEV;
1566                 goto err;
1567         }
1568
1569         dsi_complexio_config(dssdev);
1570
1571         r = dsi_complexio_power(DSI_COMPLEXIO_POWER_ON);
1572
1573         if (r)
1574                 goto err;
1575
1576         if (wait_for_bit_change(DSI_COMPLEXIO_CFG1, 29, 1) != 1) {
1577                 DSSERR("ComplexIO not coming out of reset.\n");
1578                 r = -ENODEV;
1579                 goto err;
1580         }
1581
1582         if (wait_for_bit_change(DSI_COMPLEXIO_CFG1, 21, 1) != 1) {
1583                 DSSERR("ComplexIO LDO power down.\n");
1584                 r = -ENODEV;
1585                 goto err;
1586         }
1587
1588         dsi_complexio_timings();
1589
1590         /*
1591            The configuration of the DSI complex I/O (number of data lanes,
1592            position, differential order) should not be changed while
1593            DSS.DSI_CLK_CRTRL[20] LP_CLK_ENABLE bit is set to 1. For the
1594            hardware to recognize a new configuration of the complex I/O (done
1595            in DSS.DSI_COMPLEXIO_CFG1 register), it is recommended to follow
1596            this sequence: First set the DSS.DSI_CTRL[0] IF_EN bit to 1, next
1597            reset the DSS.DSI_CTRL[0] IF_EN to 0, then set DSS.DSI_CLK_CTRL[20]
1598            LP_CLK_ENABLE to 1, and finally, set again the DSS.DSI_CTRL[0] IF_EN
1599            bit to 1. If the sequence is not followed, the DSi complex I/O
1600            configuration is undetermined.
1601            */
1602         dsi_if_enable(1);
1603         dsi_if_enable(0);
1604         REG_FLD_MOD(DSI_CLK_CTRL, 1, 20, 20); /* LP_CLK_ENABLE */
1605         dsi_if_enable(1);
1606         dsi_if_enable(0);
1607
1608         DSSDBG("CIO init done\n");
1609 err:
1610         return r;
1611 }
1612
1613 static void dsi_complexio_uninit(void)
1614 {
1615         dsi_complexio_power(DSI_COMPLEXIO_POWER_OFF);
1616 }
1617
1618 static int _dsi_wait_reset(void)
1619 {
1620         int t = 0;
1621
1622         while (REG_GET(DSI_SYSSTATUS, 0, 0) == 0) {
1623                 if (++t > 5) {
1624                         DSSERR("soft reset failed\n");
1625                         return -ENODEV;
1626                 }
1627                 udelay(1);
1628         }
1629
1630         return 0;
1631 }
1632
1633 static int _dsi_reset(void)
1634 {
1635         /* Soft reset */
1636         REG_FLD_MOD(DSI_SYSCONFIG, 1, 1, 1);
1637         return _dsi_wait_reset();
1638 }
1639
1640 static void dsi_reset_tx_fifo(int channel)
1641 {
1642         u32 mask;
1643         u32 l;
1644
1645         /* set fifosize of the channel to 0, then return the old size */
1646         l = dsi_read_reg(DSI_TX_FIFO_VC_SIZE);
1647
1648         mask = FLD_MASK((8 * channel) + 7, (8 * channel) + 4);
1649         dsi_write_reg(DSI_TX_FIFO_VC_SIZE, l & ~mask);
1650
1651         dsi_write_reg(DSI_TX_FIFO_VC_SIZE, l);
1652 }
1653
1654 static void dsi_config_tx_fifo(enum fifo_size size1, enum fifo_size size2,
1655                 enum fifo_size size3, enum fifo_size size4)
1656 {
1657         u32 r = 0;
1658         int add = 0;
1659         int i;
1660
1661         dsi.vc[0].fifo_size = size1;
1662         dsi.vc[1].fifo_size = size2;
1663         dsi.vc[2].fifo_size = size3;
1664         dsi.vc[3].fifo_size = size4;
1665
1666         for (i = 0; i < 4; i++) {
1667                 u8 v;
1668                 int size = dsi.vc[i].fifo_size;
1669
1670                 if (add + size > 4) {
1671                         DSSERR("Illegal FIFO configuration\n");
1672                         BUG();
1673                 }
1674
1675                 v = FLD_VAL(add, 2, 0) | FLD_VAL(size, 7, 4);
1676                 r |= v << (8 * i);
1677                 /*DSSDBG("TX FIFO vc %d: size %d, add %d\n", i, size, add); */
1678                 add += size;
1679         }
1680
1681         dsi_write_reg(DSI_TX_FIFO_VC_SIZE, r);
1682 }
1683
1684 static void dsi_config_rx_fifo(enum fifo_size size1, enum fifo_size size2,
1685                 enum fifo_size size3, enum fifo_size size4)
1686 {
1687         u32 r = 0;
1688         int add = 0;
1689         int i;
1690
1691         dsi.vc[0].fifo_size = size1;
1692         dsi.vc[1].fifo_size = size2;
1693         dsi.vc[2].fifo_size = size3;
1694         dsi.vc[3].fifo_size = size4;
1695
1696         for (i = 0; i < 4; i++) {
1697                 u8 v;
1698                 int size = dsi.vc[i].fifo_size;
1699
1700                 if (add + size > 4) {
1701                         DSSERR("Illegal FIFO configuration\n");
1702                         BUG();
1703                 }
1704
1705                 v = FLD_VAL(add, 2, 0) | FLD_VAL(size, 7, 4);
1706                 r |= v << (8 * i);
1707                 /*DSSDBG("RX FIFO vc %d: size %d, add %d\n", i, size, add); */
1708                 add += size;
1709         }
1710
1711         dsi_write_reg(DSI_RX_FIFO_VC_SIZE, r);
1712 }
1713
1714 static int dsi_force_tx_stop_mode_io(void)
1715 {
1716         u32 r;
1717
1718         r = dsi_read_reg(DSI_TIMING1);
1719         r = FLD_MOD(r, 1, 15, 15);      /* FORCE_TX_STOP_MODE_IO */
1720         dsi_write_reg(DSI_TIMING1, r);
1721
1722         if (wait_for_bit_change(DSI_TIMING1, 15, 0) != 0) {
1723                 DSSERR("TX_STOP bit not going down\n");
1724                 return -EIO;
1725         }
1726
1727         return 0;
1728 }
1729
1730 static int dsi_vc_enable(int channel, bool enable)
1731 {
1732         DSSDBG("dsi_vc_enable channel %d, enable %d\n",
1733                         channel, enable);
1734
1735         enable = enable ? 1 : 0;
1736
1737         REG_FLD_MOD(DSI_VC_CTRL(channel), enable, 0, 0);
1738
1739         if (wait_for_bit_change(DSI_VC_CTRL(channel), 0, enable) != enable) {
1740                         DSSERR("Failed to set dsi_vc_enable to %d\n", enable);
1741                         return -EIO;
1742         }
1743
1744         return 0;
1745 }
1746
1747 static void dsi_vc_initial_config(int channel)
1748 {
1749         u32 r;
1750
1751         DSSDBGF("%d", channel);
1752
1753         r = dsi_read_reg(DSI_VC_CTRL(channel));
1754
1755         if (FLD_GET(r, 15, 15)) /* VC_BUSY */
1756                 DSSERR("VC(%d) busy when trying to configure it!\n",
1757                                 channel);
1758
1759         r = FLD_MOD(r, 0, 1, 1); /* SOURCE, 0 = L4 */
1760         r = FLD_MOD(r, 0, 2, 2); /* BTA_SHORT_EN  */
1761         r = FLD_MOD(r, 0, 3, 3); /* BTA_LONG_EN */
1762         r = FLD_MOD(r, 0, 4, 4); /* MODE, 0 = command */
1763         r = FLD_MOD(r, 1, 7, 7); /* CS_TX_EN */
1764         r = FLD_MOD(r, 1, 8, 8); /* ECC_TX_EN */
1765         r = FLD_MOD(r, 0, 9, 9); /* MODE_SPEED, high speed on/off */
1766
1767         r = FLD_MOD(r, 4, 29, 27); /* DMA_RX_REQ_NB = no dma */
1768         r = FLD_MOD(r, 4, 23, 21); /* DMA_TX_REQ_NB = no dma */
1769
1770         dsi_write_reg(DSI_VC_CTRL(channel), r);
1771
1772         dsi.vc[channel].mode = DSI_VC_MODE_L4;
1773 }
1774
1775 static int dsi_vc_config_l4(int channel)
1776 {
1777         if (dsi.vc[channel].mode == DSI_VC_MODE_L4)
1778                 return 0;
1779
1780         DSSDBGF("%d", channel);
1781
1782         dsi_vc_enable(channel, 0);
1783
1784         /* VC_BUSY */
1785         if (wait_for_bit_change(DSI_VC_CTRL(channel), 15, 0) != 0) {
1786                 DSSERR("vc(%d) busy when trying to config for L4\n", channel);
1787                 return -EIO;
1788         }
1789
1790         REG_FLD_MOD(DSI_VC_CTRL(channel), 0, 1, 1); /* SOURCE, 0 = L4 */
1791
1792         dsi_vc_enable(channel, 1);
1793
1794         dsi.vc[channel].mode = DSI_VC_MODE_L4;
1795
1796         return 0;
1797 }
1798
1799 static int dsi_vc_config_vp(int channel)
1800 {
1801         if (dsi.vc[channel].mode == DSI_VC_MODE_VP)
1802                 return 0;
1803
1804         DSSDBGF("%d", channel);
1805
1806         dsi_vc_enable(channel, 0);
1807
1808         /* VC_BUSY */
1809         if (wait_for_bit_change(DSI_VC_CTRL(channel), 15, 0) != 0) {
1810                 DSSERR("vc(%d) busy when trying to config for VP\n", channel);
1811                 return -EIO;
1812         }
1813
1814         REG_FLD_MOD(DSI_VC_CTRL(channel), 1, 1, 1); /* SOURCE, 1 = video port */
1815
1816         dsi_vc_enable(channel, 1);
1817
1818         dsi.vc[channel].mode = DSI_VC_MODE_VP;
1819
1820         return 0;
1821 }
1822
1823
1824 void omapdss_dsi_vc_enable_hs(int channel, bool enable)
1825 {
1826         DSSDBG("dsi_vc_enable_hs(%d, %d)\n", channel, enable);
1827
1828         WARN_ON(!dsi_bus_is_locked());
1829
1830         dsi_vc_enable(channel, 0);
1831         dsi_if_enable(0);
1832
1833         REG_FLD_MOD(DSI_VC_CTRL(channel), enable, 9, 9);
1834
1835         dsi_vc_enable(channel, 1);
1836         dsi_if_enable(1);
1837
1838         dsi_force_tx_stop_mode_io();
1839 }
1840 EXPORT_SYMBOL(omapdss_dsi_vc_enable_hs);
1841
1842 static void dsi_vc_flush_long_data(int channel)
1843 {
1844         while (REG_GET(DSI_VC_CTRL(channel), 20, 20)) {
1845                 u32 val;
1846                 val = dsi_read_reg(DSI_VC_SHORT_PACKET_HEADER(channel));
1847                 DSSDBG("\t\tb1 %#02x b2 %#02x b3 %#02x b4 %#02x\n",
1848                                 (val >> 0) & 0xff,
1849                                 (val >> 8) & 0xff,
1850                                 (val >> 16) & 0xff,
1851                                 (val >> 24) & 0xff);
1852         }
1853 }
1854
1855 static void dsi_show_rx_ack_with_err(u16 err)
1856 {
1857         DSSERR("\tACK with ERROR (%#x):\n", err);
1858         if (err & (1 << 0))
1859                 DSSERR("\t\tSoT Error\n");
1860         if (err & (1 << 1))
1861                 DSSERR("\t\tSoT Sync Error\n");
1862         if (err & (1 << 2))
1863                 DSSERR("\t\tEoT Sync Error\n");
1864         if (err & (1 << 3))
1865                 DSSERR("\t\tEscape Mode Entry Command Error\n");
1866         if (err & (1 << 4))
1867                 DSSERR("\t\tLP Transmit Sync Error\n");
1868         if (err & (1 << 5))
1869                 DSSERR("\t\tHS Receive Timeout Error\n");
1870         if (err & (1 << 6))
1871                 DSSERR("\t\tFalse Control Error\n");
1872         if (err & (1 << 7))
1873                 DSSERR("\t\t(reserved7)\n");
1874         if (err & (1 << 8))
1875                 DSSERR("\t\tECC Error, single-bit (corrected)\n");
1876         if (err & (1 << 9))
1877                 DSSERR("\t\tECC Error, multi-bit (not corrected)\n");
1878         if (err & (1 << 10))
1879                 DSSERR("\t\tChecksum Error\n");
1880         if (err & (1 << 11))
1881                 DSSERR("\t\tData type not recognized\n");
1882         if (err & (1 << 12))
1883                 DSSERR("\t\tInvalid VC ID\n");
1884         if (err & (1 << 13))
1885                 DSSERR("\t\tInvalid Transmission Length\n");
1886         if (err & (1 << 14))
1887                 DSSERR("\t\t(reserved14)\n");
1888         if (err & (1 << 15))
1889                 DSSERR("\t\tDSI Protocol Violation\n");
1890 }
1891
1892 static u16 dsi_vc_flush_receive_data(int channel)
1893 {
1894         /* RX_FIFO_NOT_EMPTY */
1895         while (REG_GET(DSI_VC_CTRL(channel), 20, 20)) {
1896                 u32 val;
1897                 u8 dt;
1898                 val = dsi_read_reg(DSI_VC_SHORT_PACKET_HEADER(channel));
1899                 DSSERR("\trawval %#08x\n", val);
1900                 dt = FLD_GET(val, 5, 0);
1901                 if (dt == DSI_DT_RX_ACK_WITH_ERR) {
1902                         u16 err = FLD_GET(val, 23, 8);
1903                         dsi_show_rx_ack_with_err(err);
1904                 } else if (dt == DSI_DT_RX_SHORT_READ_1) {
1905                         DSSERR("\tDCS short response, 1 byte: %#x\n",
1906                                         FLD_GET(val, 23, 8));
1907                 } else if (dt == DSI_DT_RX_SHORT_READ_2) {
1908                         DSSERR("\tDCS short response, 2 byte: %#x\n",
1909                                         FLD_GET(val, 23, 8));
1910                 } else if (dt == DSI_DT_RX_DCS_LONG_READ) {
1911                         DSSERR("\tDCS long response, len %d\n",
1912                                         FLD_GET(val, 23, 8));
1913                         dsi_vc_flush_long_data(channel);
1914                 } else {
1915                         DSSERR("\tunknown datatype 0x%02x\n", dt);
1916                 }
1917         }
1918         return 0;
1919 }
1920
1921 static int dsi_vc_send_bta(int channel)
1922 {
1923         if (dsi.debug_write || dsi.debug_read)
1924                 DSSDBG("dsi_vc_send_bta %d\n", channel);
1925
1926         WARN_ON(!dsi_bus_is_locked());
1927
1928         if (REG_GET(DSI_VC_CTRL(channel), 20, 20)) {    /* RX_FIFO_NOT_EMPTY */
1929                 DSSERR("rx fifo not empty when sending BTA, dumping data:\n");
1930                 dsi_vc_flush_receive_data(channel);
1931         }
1932
1933         REG_FLD_MOD(DSI_VC_CTRL(channel), 1, 6, 6); /* BTA_EN */
1934
1935         return 0;
1936 }
1937
1938 int dsi_vc_send_bta_sync(int channel)
1939 {
1940         int r = 0;
1941         u32 err;
1942
1943         INIT_COMPLETION(dsi.bta_completion);
1944
1945         dsi_vc_enable_bta_irq(channel);
1946
1947         r = dsi_vc_send_bta(channel);
1948         if (r)
1949                 goto err;
1950
1951         if (wait_for_completion_timeout(&dsi.bta_completion,
1952                                 msecs_to_jiffies(500)) == 0) {
1953                 DSSERR("Failed to receive BTA\n");
1954                 r = -EIO;
1955                 goto err;
1956         }
1957
1958         err = dsi_get_errors();
1959         if (err) {
1960                 DSSERR("Error while sending BTA: %x\n", err);
1961                 r = -EIO;
1962                 goto err;
1963         }
1964 err:
1965         dsi_vc_disable_bta_irq(channel);
1966
1967         return r;
1968 }
1969 EXPORT_SYMBOL(dsi_vc_send_bta_sync);
1970
1971 static inline void dsi_vc_write_long_header(int channel, u8 data_type,
1972                 u16 len, u8 ecc)
1973 {
1974         u32 val;
1975         u8 data_id;
1976
1977         WARN_ON(!dsi_bus_is_locked());
1978
1979         data_id = data_type | channel << 6;
1980
1981         val = FLD_VAL(data_id, 7, 0) | FLD_VAL(len, 23, 8) |
1982                 FLD_VAL(ecc, 31, 24);
1983
1984         dsi_write_reg(DSI_VC_LONG_PACKET_HEADER(channel), val);
1985 }
1986
1987 static inline void dsi_vc_write_long_payload(int channel,
1988                 u8 b1, u8 b2, u8 b3, u8 b4)
1989 {
1990         u32 val;
1991
1992         val = b4 << 24 | b3 << 16 | b2 << 8  | b1 << 0;
1993
1994 /*      DSSDBG("\twriting %02x, %02x, %02x, %02x (%#010x)\n",
1995                         b1, b2, b3, b4, val); */
1996
1997         dsi_write_reg(DSI_VC_LONG_PACKET_PAYLOAD(channel), val);
1998 }
1999
2000 static int dsi_vc_send_long(int channel, u8 data_type, u8 *data, u16 len,
2001                 u8 ecc)
2002 {
2003         /*u32 val; */
2004         int i;
2005         u8 *p;
2006         int r = 0;
2007         u8 b1, b2, b3, b4;
2008
2009         if (dsi.debug_write)
2010                 DSSDBG("dsi_vc_send_long, %d bytes\n", len);
2011
2012         /* len + header */
2013         if (dsi.vc[channel].fifo_size * 32 * 4 < len + 4) {
2014                 DSSERR("unable to send long packet: packet too long.\n");
2015                 return -EINVAL;
2016         }
2017
2018         dsi_vc_config_l4(channel);
2019
2020         dsi_vc_write_long_header(channel, data_type, len, ecc);
2021
2022         p = data;
2023         for (i = 0; i < len >> 2; i++) {
2024                 if (dsi.debug_write)
2025                         DSSDBG("\tsending full packet %d\n", i);
2026
2027                 b1 = *p++;
2028                 b2 = *p++;
2029                 b3 = *p++;
2030                 b4 = *p++;
2031
2032                 dsi_vc_write_long_payload(channel, b1, b2, b3, b4);
2033         }
2034
2035         i = len % 4;
2036         if (i) {
2037                 b1 = 0; b2 = 0; b3 = 0;
2038
2039                 if (dsi.debug_write)
2040                         DSSDBG("\tsending remainder bytes %d\n", i);
2041
2042                 switch (i) {
2043                 case 3:
2044                         b1 = *p++;
2045                         b2 = *p++;
2046                         b3 = *p++;
2047                         break;
2048                 case 2:
2049                         b1 = *p++;
2050                         b2 = *p++;
2051                         break;
2052                 case 1:
2053                         b1 = *p++;
2054                         break;
2055                 }
2056
2057                 dsi_vc_write_long_payload(channel, b1, b2, b3, 0);
2058         }
2059
2060         return r;
2061 }
2062
2063 static int dsi_vc_send_short(int channel, u8 data_type, u16 data, u8 ecc)
2064 {
2065         u32 r;
2066         u8 data_id;
2067
2068         WARN_ON(!dsi_bus_is_locked());
2069
2070         if (dsi.debug_write)
2071                 DSSDBG("dsi_vc_send_short(ch%d, dt %#x, b1 %#x, b2 %#x)\n",
2072                                 channel,
2073                                 data_type, data & 0xff, (data >> 8) & 0xff);
2074
2075         dsi_vc_config_l4(channel);
2076
2077         if (FLD_GET(dsi_read_reg(DSI_VC_CTRL(channel)), 16, 16)) {
2078                 DSSERR("ERROR FIFO FULL, aborting transfer\n");
2079                 return -EINVAL;
2080         }
2081
2082         data_id = data_type | channel << 6;
2083
2084         r = (data_id << 0) | (data << 8) | (ecc << 24);
2085
2086         dsi_write_reg(DSI_VC_SHORT_PACKET_HEADER(channel), r);
2087
2088         return 0;
2089 }
2090
2091 int dsi_vc_send_null(int channel)
2092 {
2093         u8 nullpkg[] = {0, 0, 0, 0};
2094         return dsi_vc_send_long(channel, DSI_DT_NULL_PACKET, nullpkg, 4, 0);
2095 }
2096 EXPORT_SYMBOL(dsi_vc_send_null);
2097
2098 int dsi_vc_dcs_write_nosync(int channel, u8 *data, int len)
2099 {
2100         int r;
2101
2102         BUG_ON(len == 0);
2103
2104         if (len == 1) {
2105                 r = dsi_vc_send_short(channel, DSI_DT_DCS_SHORT_WRITE_0,
2106                                 data[0], 0);
2107         } else if (len == 2) {
2108                 r = dsi_vc_send_short(channel, DSI_DT_DCS_SHORT_WRITE_1,
2109                                 data[0] | (data[1] << 8), 0);
2110         } else {
2111                 /* 0x39 = DCS Long Write */
2112                 r = dsi_vc_send_long(channel, DSI_DT_DCS_LONG_WRITE,
2113                                 data, len, 0);
2114         }
2115
2116         return r;
2117 }
2118 EXPORT_SYMBOL(dsi_vc_dcs_write_nosync);
2119
2120 int dsi_vc_dcs_write(int channel, u8 *data, int len)
2121 {
2122         int r;
2123
2124         r = dsi_vc_dcs_write_nosync(channel, data, len);
2125         if (r)
2126                 goto err;
2127
2128         r = dsi_vc_send_bta_sync(channel);
2129         if (r)
2130                 goto err;
2131
2132         if (REG_GET(DSI_VC_CTRL(channel), 20, 20)) {    /* RX_FIFO_NOT_EMPTY */
2133                 DSSERR("rx fifo not empty after write, dumping data:\n");
2134                 dsi_vc_flush_receive_data(channel);
2135                 r = -EIO;
2136                 goto err;
2137         }
2138
2139         return 0;
2140 err:
2141         DSSERR("dsi_vc_dcs_write(ch %d, cmd 0x%02x, len %d) failed\n",
2142                         channel, data[0], len);
2143         return r;
2144 }
2145 EXPORT_SYMBOL(dsi_vc_dcs_write);
2146
2147 int dsi_vc_dcs_write_0(int channel, u8 dcs_cmd)
2148 {
2149         return dsi_vc_dcs_write(channel, &dcs_cmd, 1);
2150 }
2151 EXPORT_SYMBOL(dsi_vc_dcs_write_0);
2152
2153 int dsi_vc_dcs_write_1(int channel, u8 dcs_cmd, u8 param)
2154 {
2155         u8 buf[2];
2156         buf[0] = dcs_cmd;
2157         buf[1] = param;
2158         return dsi_vc_dcs_write(channel, buf, 2);
2159 }
2160 EXPORT_SYMBOL(dsi_vc_dcs_write_1);
2161
2162 int dsi_vc_dcs_read(int channel, u8 dcs_cmd, u8 *buf, int buflen)
2163 {
2164         u32 val;
2165         u8 dt;
2166         int r;
2167
2168         if (dsi.debug_read)
2169                 DSSDBG("dsi_vc_dcs_read(ch%d, dcs_cmd %x)\n", channel, dcs_cmd);
2170
2171         r = dsi_vc_send_short(channel, DSI_DT_DCS_READ, dcs_cmd, 0);
2172         if (r)
2173                 goto err;
2174
2175         r = dsi_vc_send_bta_sync(channel);
2176         if (r)
2177                 goto err;
2178
2179         /* RX_FIFO_NOT_EMPTY */
2180         if (REG_GET(DSI_VC_CTRL(channel), 20, 20) == 0) {
2181                 DSSERR("RX fifo empty when trying to read.\n");
2182                 r = -EIO;
2183                 goto err;
2184         }
2185
2186         val = dsi_read_reg(DSI_VC_SHORT_PACKET_HEADER(channel));
2187         if (dsi.debug_read)
2188                 DSSDBG("\theader: %08x\n", val);
2189         dt = FLD_GET(val, 5, 0);
2190         if (dt == DSI_DT_RX_ACK_WITH_ERR) {
2191                 u16 err = FLD_GET(val, 23, 8);
2192                 dsi_show_rx_ack_with_err(err);
2193                 r = -EIO;
2194                 goto err;
2195
2196         } else if (dt == DSI_DT_RX_SHORT_READ_1) {
2197                 u8 data = FLD_GET(val, 15, 8);
2198                 if (dsi.debug_read)
2199                         DSSDBG("\tDCS short response, 1 byte: %02x\n", data);
2200
2201                 if (buflen < 1) {
2202                         r = -EIO;
2203                         goto err;
2204                 }
2205
2206                 buf[0] = data;
2207
2208                 return 1;
2209         } else if (dt == DSI_DT_RX_SHORT_READ_2) {
2210                 u16 data = FLD_GET(val, 23, 8);
2211                 if (dsi.debug_read)
2212                         DSSDBG("\tDCS short response, 2 byte: %04x\n", data);
2213
2214                 if (buflen < 2) {
2215                         r = -EIO;
2216                         goto err;
2217                 }
2218
2219                 buf[0] = data & 0xff;
2220                 buf[1] = (data >> 8) & 0xff;
2221
2222                 return 2;
2223         } else if (dt == DSI_DT_RX_DCS_LONG_READ) {
2224                 int w;
2225                 int len = FLD_GET(val, 23, 8);
2226                 if (dsi.debug_read)
2227                         DSSDBG("\tDCS long response, len %d\n", len);
2228
2229                 if (len > buflen) {
2230                         r = -EIO;
2231                         goto err;
2232                 }
2233
2234                 /* two byte checksum ends the packet, not included in len */
2235                 for (w = 0; w < len + 2;) {
2236                         int b;
2237                         val = dsi_read_reg(DSI_VC_SHORT_PACKET_HEADER(channel));
2238                         if (dsi.debug_read)
2239                                 DSSDBG("\t\t%02x %02x %02x %02x\n",
2240                                                 (val >> 0) & 0xff,
2241                                                 (val >> 8) & 0xff,
2242                                                 (val >> 16) & 0xff,
2243                                                 (val >> 24) & 0xff);
2244
2245                         for (b = 0; b < 4; ++b) {
2246                                 if (w < len)
2247                                         buf[w] = (val >> (b * 8)) & 0xff;
2248                                 /* we discard the 2 byte checksum */
2249                                 ++w;
2250                         }
2251                 }
2252
2253                 return len;
2254         } else {
2255                 DSSERR("\tunknown datatype 0x%02x\n", dt);
2256                 r = -EIO;
2257                 goto err;
2258         }
2259
2260         BUG();
2261 err:
2262         DSSERR("dsi_vc_dcs_read(ch %d, cmd 0x%02x) failed\n",
2263                         channel, dcs_cmd);
2264         return r;
2265
2266 }
2267 EXPORT_SYMBOL(dsi_vc_dcs_read);
2268
2269 int dsi_vc_dcs_read_1(int channel, u8 dcs_cmd, u8 *data)
2270 {
2271         int r;
2272
2273         r = dsi_vc_dcs_read(channel, dcs_cmd, data, 1);
2274
2275         if (r < 0)
2276                 return r;
2277
2278         if (r != 1)
2279                 return -EIO;
2280
2281         return 0;
2282 }
2283 EXPORT_SYMBOL(dsi_vc_dcs_read_1);
2284
2285 int dsi_vc_dcs_read_2(int channel, u8 dcs_cmd, u8 *data1, u8 *data2)
2286 {
2287         u8 buf[2];
2288         int r;
2289
2290         r = dsi_vc_dcs_read(channel, dcs_cmd, buf, 2);
2291
2292         if (r < 0)
2293                 return r;
2294
2295         if (r != 2)
2296                 return -EIO;
2297
2298         *data1 = buf[0];
2299         *data2 = buf[1];
2300
2301         return 0;
2302 }
2303 EXPORT_SYMBOL(dsi_vc_dcs_read_2);
2304
2305 int dsi_vc_set_max_rx_packet_size(int channel, u16 len)
2306 {
2307         return dsi_vc_send_short(channel, DSI_DT_SET_MAX_RET_PKG_SIZE,
2308                         len, 0);
2309 }
2310 EXPORT_SYMBOL(dsi_vc_set_max_rx_packet_size);
2311
2312 static void dsi_set_lp_rx_timeout(unsigned ticks, bool x4, bool x16)
2313 {
2314         unsigned long fck;
2315         unsigned long total_ticks;
2316         u32 r;
2317
2318         BUG_ON(ticks > 0x1fff);
2319
2320         /* ticks in DSI_FCK */
2321         fck = dsi_fclk_rate();
2322
2323         r = dsi_read_reg(DSI_TIMING2);
2324         r = FLD_MOD(r, 1, 15, 15);      /* LP_RX_TO */
2325         r = FLD_MOD(r, x16 ? 1 : 0, 14, 14);    /* LP_RX_TO_X16 */
2326         r = FLD_MOD(r, x4 ? 1 : 0, 13, 13);     /* LP_RX_TO_X4 */
2327         r = FLD_MOD(r, ticks, 12, 0);   /* LP_RX_COUNTER */
2328         dsi_write_reg(DSI_TIMING2, r);
2329
2330         total_ticks = ticks * (x16 ? 16 : 1) * (x4 ? 4 : 1);
2331
2332         DSSDBG("LP_RX_TO %lu ticks (%#x%s%s) = %lu ns\n",
2333                         total_ticks,
2334                         ticks, x4 ? " x4" : "", x16 ? " x16" : "",
2335                         (total_ticks * 1000) / (fck / 1000 / 1000));
2336 }
2337
2338 static void dsi_set_ta_timeout(unsigned ticks, bool x8, bool x16)
2339 {
2340         unsigned long fck;
2341         unsigned long total_ticks;
2342         u32 r;
2343
2344         BUG_ON(ticks > 0x1fff);
2345
2346         /* ticks in DSI_FCK */
2347         fck = dsi_fclk_rate();
2348
2349         r = dsi_read_reg(DSI_TIMING1);
2350         r = FLD_MOD(r, 1, 31, 31);      /* TA_TO */
2351         r = FLD_MOD(r, x16 ? 1 : 0, 30, 30);    /* TA_TO_X16 */
2352         r = FLD_MOD(r, x8 ? 1 : 0, 29, 29);     /* TA_TO_X8 */
2353         r = FLD_MOD(r, ticks, 28, 16);  /* TA_TO_COUNTER */
2354         dsi_write_reg(DSI_TIMING1, r);
2355
2356         total_ticks = ticks * (x16 ? 16 : 1) * (x8 ? 8 : 1);
2357
2358         DSSDBG("TA_TO %lu ticks (%#x%s%s) = %lu ns\n",
2359                         total_ticks,
2360                         ticks, x8 ? " x8" : "", x16 ? " x16" : "",
2361                         (total_ticks * 1000) / (fck / 1000 / 1000));
2362 }
2363
2364 static void dsi_set_stop_state_counter(unsigned ticks, bool x4, bool x16)
2365 {
2366         unsigned long fck;
2367         unsigned long total_ticks;
2368         u32 r;
2369
2370         BUG_ON(ticks > 0x1fff);
2371
2372         /* ticks in DSI_FCK */
2373         fck = dsi_fclk_rate();
2374
2375         r = dsi_read_reg(DSI_TIMING1);
2376         r = FLD_MOD(r, 1, 15, 15);      /* FORCE_TX_STOP_MODE_IO */
2377         r = FLD_MOD(r, x16 ? 1 : 0, 14, 14);    /* STOP_STATE_X16_IO */
2378         r = FLD_MOD(r, x4 ? 1 : 0, 13, 13);     /* STOP_STATE_X4_IO */
2379         r = FLD_MOD(r, ticks, 12, 0);   /* STOP_STATE_COUNTER_IO */
2380         dsi_write_reg(DSI_TIMING1, r);
2381
2382         total_ticks = ticks * (x16 ? 16 : 1) * (x4 ? 4 : 1);
2383
2384         DSSDBG("STOP_STATE_COUNTER %lu ticks (%#x%s%s) = %lu ns\n",
2385                         total_ticks,
2386                         ticks, x4 ? " x4" : "", x16 ? " x16" : "",
2387                         (total_ticks * 1000) / (fck / 1000 / 1000));
2388 }
2389
2390 static void dsi_set_hs_tx_timeout(unsigned ticks, bool x4, bool x16)
2391 {
2392         unsigned long fck;
2393         unsigned long total_ticks;
2394         u32 r;
2395
2396         BUG_ON(ticks > 0x1fff);
2397
2398         /* ticks in TxByteClkHS */
2399         fck = dsi_get_txbyteclkhs();
2400
2401         r = dsi_read_reg(DSI_TIMING2);
2402         r = FLD_MOD(r, 1, 31, 31);      /* HS_TX_TO */
2403         r = FLD_MOD(r, x16 ? 1 : 0, 30, 30);    /* HS_TX_TO_X16 */
2404         r = FLD_MOD(r, x4 ? 1 : 0, 29, 29);     /* HS_TX_TO_X8 (4 really) */
2405         r = FLD_MOD(r, ticks, 28, 16);  /* HS_TX_TO_COUNTER */
2406         dsi_write_reg(DSI_TIMING2, r);
2407
2408         total_ticks = ticks * (x16 ? 16 : 1) * (x4 ? 4 : 1);
2409
2410         DSSDBG("HS_TX_TO %lu ticks (%#x%s%s) = %lu ns\n",
2411                         total_ticks,
2412                         ticks, x4 ? " x4" : "", x16 ? " x16" : "",
2413                         (total_ticks * 1000) / (fck / 1000 / 1000));
2414 }
2415 static int dsi_proto_config(struct omap_dss_device *dssdev)
2416 {
2417         u32 r;
2418         int buswidth = 0;
2419
2420         dsi_config_tx_fifo(DSI_FIFO_SIZE_32,
2421                         DSI_FIFO_SIZE_32,
2422                         DSI_FIFO_SIZE_32,
2423                         DSI_FIFO_SIZE_32);
2424
2425         dsi_config_rx_fifo(DSI_FIFO_SIZE_32,
2426                         DSI_FIFO_SIZE_32,
2427                         DSI_FIFO_SIZE_32,
2428                         DSI_FIFO_SIZE_32);
2429
2430         /* XXX what values for the timeouts? */
2431         dsi_set_stop_state_counter(0x1000, false, false);
2432         dsi_set_ta_timeout(0x1fff, true, true);
2433         dsi_set_lp_rx_timeout(0x1fff, true, true);
2434         dsi_set_hs_tx_timeout(0x1fff, true, true);
2435
2436         switch (dssdev->ctrl.pixel_size) {
2437         case 16:
2438                 buswidth = 0;
2439                 break;
2440         case 18:
2441                 buswidth = 1;
2442                 break;
2443         case 24:
2444                 buswidth = 2;
2445                 break;
2446         default:
2447                 BUG();
2448         }
2449
2450         r = dsi_read_reg(DSI_CTRL);
2451         r = FLD_MOD(r, 1, 1, 1);        /* CS_RX_EN */
2452         r = FLD_MOD(r, 1, 2, 2);        /* ECC_RX_EN */
2453         r = FLD_MOD(r, 1, 3, 3);        /* TX_FIFO_ARBITRATION */
2454         r = FLD_MOD(r, 1, 4, 4);        /* VP_CLK_RATIO, always 1, see errata*/
2455         r = FLD_MOD(r, buswidth, 7, 6); /* VP_DATA_BUS_WIDTH */
2456         r = FLD_MOD(r, 0, 8, 8);        /* VP_CLK_POL */
2457         r = FLD_MOD(r, 2, 13, 12);      /* LINE_BUFFER, 2 lines */
2458         r = FLD_MOD(r, 1, 14, 14);      /* TRIGGER_RESET_MODE */
2459         r = FLD_MOD(r, 1, 19, 19);      /* EOT_ENABLE */
2460         r = FLD_MOD(r, 1, 24, 24);      /* DCS_CMD_ENABLE */
2461         r = FLD_MOD(r, 0, 25, 25);      /* DCS_CMD_CODE, 1=start, 0=continue */
2462
2463         dsi_write_reg(DSI_CTRL, r);
2464
2465         dsi_vc_initial_config(0);
2466         dsi_vc_initial_config(1);
2467         dsi_vc_initial_config(2);
2468         dsi_vc_initial_config(3);
2469
2470         return 0;
2471 }
2472
2473 static void dsi_proto_timings(struct omap_dss_device *dssdev)
2474 {
2475         unsigned tlpx, tclk_zero, tclk_prepare, tclk_trail;
2476         unsigned tclk_pre, tclk_post;
2477         unsigned ths_prepare, ths_prepare_ths_zero, ths_zero;
2478         unsigned ths_trail, ths_exit;
2479         unsigned ddr_clk_pre, ddr_clk_post;
2480         unsigned enter_hs_mode_lat, exit_hs_mode_lat;
2481         unsigned ths_eot;
2482         u32 r;
2483
2484         r = dsi_read_reg(DSI_DSIPHY_CFG0);
2485         ths_prepare = FLD_GET(r, 31, 24);
2486         ths_prepare_ths_zero = FLD_GET(r, 23, 16);
2487         ths_zero = ths_prepare_ths_zero - ths_prepare;
2488         ths_trail = FLD_GET(r, 15, 8);
2489         ths_exit = FLD_GET(r, 7, 0);
2490
2491         r = dsi_read_reg(DSI_DSIPHY_CFG1);
2492         tlpx = FLD_GET(r, 22, 16) * 2;
2493         tclk_trail = FLD_GET(r, 15, 8);
2494         tclk_zero = FLD_GET(r, 7, 0);
2495
2496         r = dsi_read_reg(DSI_DSIPHY_CFG2);
2497         tclk_prepare = FLD_GET(r, 7, 0);
2498
2499         /* min 8*UI */
2500         tclk_pre = 20;
2501         /* min 60ns + 52*UI */
2502         tclk_post = ns2ddr(60) + 26;
2503
2504         /* ths_eot is 2 for 2 datalanes and 4 for 1 datalane */
2505         if (dssdev->phy.dsi.data1_lane != 0 &&
2506                         dssdev->phy.dsi.data2_lane != 0)
2507                 ths_eot = 2;
2508         else
2509                 ths_eot = 4;
2510
2511         ddr_clk_pre = DIV_ROUND_UP(tclk_pre + tlpx + tclk_zero + tclk_prepare,
2512                         4);
2513         ddr_clk_post = DIV_ROUND_UP(tclk_post + ths_trail, 4) + ths_eot;
2514
2515         BUG_ON(ddr_clk_pre == 0 || ddr_clk_pre > 255);
2516         BUG_ON(ddr_clk_post == 0 || ddr_clk_post > 255);
2517
2518         r = dsi_read_reg(DSI_CLK_TIMING);
2519         r = FLD_MOD(r, ddr_clk_pre, 15, 8);
2520         r = FLD_MOD(r, ddr_clk_post, 7, 0);
2521         dsi_write_reg(DSI_CLK_TIMING, r);
2522
2523         DSSDBG("ddr_clk_pre %u, ddr_clk_post %u\n",
2524                         ddr_clk_pre,
2525                         ddr_clk_post);
2526
2527         enter_hs_mode_lat = 1 + DIV_ROUND_UP(tlpx, 4) +
2528                 DIV_ROUND_UP(ths_prepare, 4) +
2529                 DIV_ROUND_UP(ths_zero + 3, 4);
2530
2531         exit_hs_mode_lat = DIV_ROUND_UP(ths_trail + ths_exit, 4) + 1 + ths_eot;
2532
2533         r = FLD_VAL(enter_hs_mode_lat, 31, 16) |
2534                 FLD_VAL(exit_hs_mode_lat, 15, 0);
2535         dsi_write_reg(DSI_VM_TIMING7, r);
2536
2537         DSSDBG("enter_hs_mode_lat %u, exit_hs_mode_lat %u\n",
2538                         enter_hs_mode_lat, exit_hs_mode_lat);
2539 }
2540
2541
2542 #define DSI_DECL_VARS \
2543         int __dsi_cb = 0; u32 __dsi_cv = 0;
2544
2545 #define DSI_FLUSH(ch) \
2546         if (__dsi_cb > 0) { \
2547                 /*DSSDBG("sending long packet %#010x\n", __dsi_cv);*/ \
2548                 dsi_write_reg(DSI_VC_LONG_PACKET_PAYLOAD(ch), __dsi_cv); \
2549                 __dsi_cb = __dsi_cv = 0; \
2550         }
2551
2552 #define DSI_PUSH(ch, data) \
2553         do { \
2554                 __dsi_cv |= (data) << (__dsi_cb * 8); \
2555                 /*DSSDBG("cv = %#010x, cb = %d\n", __dsi_cv, __dsi_cb);*/ \
2556                 if (++__dsi_cb > 3) \
2557                         DSI_FLUSH(ch); \
2558         } while (0)
2559
2560 static int dsi_update_screen_l4(struct omap_dss_device *dssdev,
2561                         int x, int y, int w, int h)
2562 {
2563         /* Note: supports only 24bit colors in 32bit container */
2564         int first = 1;
2565         int fifo_stalls = 0;
2566         int max_dsi_packet_size;
2567         int max_data_per_packet;
2568         int max_pixels_per_packet;
2569         int pixels_left;
2570         int bytespp = dssdev->ctrl.pixel_size / 8;
2571         int scr_width;
2572         u32 __iomem *data;
2573         int start_offset;
2574         int horiz_inc;
2575         int current_x;
2576         struct omap_overlay *ovl;
2577
2578         debug_irq = 0;
2579
2580         DSSDBG("dsi_update_screen_l4 (%d,%d %dx%d)\n",
2581                         x, y, w, h);
2582
2583         ovl = dssdev->manager->overlays[0];
2584
2585         if (ovl->info.color_mode != OMAP_DSS_COLOR_RGB24U)
2586                 return -EINVAL;
2587
2588         if (dssdev->ctrl.pixel_size != 24)
2589                 return -EINVAL;
2590
2591         scr_width = ovl->info.screen_width;
2592         data = ovl->info.vaddr;
2593
2594         start_offset = scr_width * y + x;
2595         horiz_inc = scr_width - w;
2596         current_x = x;
2597
2598         /* We need header(4) + DCSCMD(1) + pixels(numpix*bytespp) bytes
2599          * in fifo */
2600
2601         /* When using CPU, max long packet size is TX buffer size */
2602         max_dsi_packet_size = dsi.vc[0].fifo_size * 32 * 4;
2603
2604         /* we seem to get better perf if we divide the tx fifo to half,
2605            and while the other half is being sent, we fill the other half
2606            max_dsi_packet_size /= 2; */
2607
2608         max_data_per_packet = max_dsi_packet_size - 4 - 1;
2609
2610         max_pixels_per_packet = max_data_per_packet / bytespp;
2611
2612         DSSDBG("max_pixels_per_packet %d\n", max_pixels_per_packet);
2613
2614         pixels_left = w * h;
2615
2616         DSSDBG("total pixels %d\n", pixels_left);
2617
2618         data += start_offset;
2619
2620         while (pixels_left > 0) {
2621                 /* 0x2c = write_memory_start */
2622                 /* 0x3c = write_memory_continue */
2623                 u8 dcs_cmd = first ? 0x2c : 0x3c;
2624                 int pixels;
2625                 DSI_DECL_VARS;
2626                 first = 0;
2627
2628 #if 1
2629                 /* using fifo not empty */
2630                 /* TX_FIFO_NOT_EMPTY */
2631                 while (FLD_GET(dsi_read_reg(DSI_VC_CTRL(0)), 5, 5)) {
2632                         fifo_stalls++;
2633                         if (fifo_stalls > 0xfffff) {
2634                                 DSSERR("fifo stalls overflow, pixels left %d\n",
2635                                                 pixels_left);
2636                                 dsi_if_enable(0);
2637                                 return -EIO;
2638                         }
2639                         udelay(1);
2640                 }
2641 #elif 1
2642                 /* using fifo emptiness */
2643                 while ((REG_GET(DSI_TX_FIFO_VC_EMPTINESS, 7, 0)+1)*4 <
2644                                 max_dsi_packet_size) {
2645                         fifo_stalls++;
2646                         if (fifo_stalls > 0xfffff) {
2647                                 DSSERR("fifo stalls overflow, pixels left %d\n",
2648                                                pixels_left);
2649                                 dsi_if_enable(0);
2650                                 return -EIO;
2651                         }
2652                 }
2653 #else
2654                 while ((REG_GET(DSI_TX_FIFO_VC_EMPTINESS, 7, 0)+1)*4 == 0) {
2655                         fifo_stalls++;
2656                         if (fifo_stalls > 0xfffff) {
2657                                 DSSERR("fifo stalls overflow, pixels left %d\n",
2658                                                pixels_left);
2659                                 dsi_if_enable(0);
2660                                 return -EIO;
2661                         }
2662                 }
2663 #endif
2664                 pixels = min(max_pixels_per_packet, pixels_left);
2665
2666                 pixels_left -= pixels;
2667
2668                 dsi_vc_write_long_header(0, DSI_DT_DCS_LONG_WRITE,
2669                                 1 + pixels * bytespp, 0);
2670
2671                 DSI_PUSH(0, dcs_cmd);
2672
2673                 while (pixels-- > 0) {
2674                         u32 pix = __raw_readl(data++);
2675
2676                         DSI_PUSH(0, (pix >> 16) & 0xff);
2677                         DSI_PUSH(0, (pix >> 8) & 0xff);
2678                         DSI_PUSH(0, (pix >> 0) & 0xff);
2679
2680                         current_x++;
2681                         if (current_x == x+w) {
2682                                 current_x = x;
2683                                 data += horiz_inc;
2684                         }
2685                 }
2686
2687                 DSI_FLUSH(0);
2688         }
2689
2690         return 0;
2691 }
2692
2693 static void dsi_update_screen_dispc(struct omap_dss_device *dssdev,
2694                 u16 x, u16 y, u16 w, u16 h)
2695 {
2696         unsigned bytespp;
2697         unsigned bytespl;
2698         unsigned bytespf;
2699         unsigned total_len;
2700         unsigned packet_payload;
2701         unsigned packet_len;
2702         u32 l;
2703         int r;
2704         const unsigned channel = dsi.update_channel;
2705         /* line buffer is 1024 x 24bits */
2706         /* XXX: for some reason using full buffer size causes considerable TX
2707          * slowdown with update sizes that fill the whole buffer */
2708         const unsigned line_buf_size = 1023 * 3;
2709
2710         DSSDBG("dsi_update_screen_dispc(%d,%d %dx%d)\n",
2711                         x, y, w, h);
2712
2713         dsi_vc_config_vp(channel);
2714
2715         bytespp = dssdev->ctrl.pixel_size / 8;
2716         bytespl = w * bytespp;
2717         bytespf = bytespl * h;
2718
2719         /* NOTE: packet_payload has to be equal to N * bytespl, where N is
2720          * number of lines in a packet.  See errata about VP_CLK_RATIO */
2721
2722         if (bytespf < line_buf_size)
2723                 packet_payload = bytespf;
2724         else
2725                 packet_payload = (line_buf_size) / bytespl * bytespl;
2726
2727         packet_len = packet_payload + 1;        /* 1 byte for DCS cmd */
2728         total_len = (bytespf / packet_payload) * packet_len;
2729
2730         if (bytespf % packet_payload)
2731                 total_len += (bytespf % packet_payload) + 1;
2732
2733         l = FLD_VAL(total_len, 23, 0); /* TE_SIZE */
2734         dsi_write_reg(DSI_VC_TE(channel), l);
2735
2736         dsi_vc_write_long_header(channel, DSI_DT_DCS_LONG_WRITE, packet_len, 0);
2737
2738         if (dsi.te_enabled)
2739                 l = FLD_MOD(l, 1, 30, 30); /* TE_EN */
2740         else
2741                 l = FLD_MOD(l, 1, 31, 31); /* TE_START */
2742         dsi_write_reg(DSI_VC_TE(channel), l);
2743
2744         /* We put SIDLEMODE to no-idle for the duration of the transfer,
2745          * because DSS interrupts are not capable of waking up the CPU and the
2746          * framedone interrupt could be delayed for quite a long time. I think
2747          * the same goes for any DSS interrupts, but for some reason I have not
2748          * seen the problem anywhere else than here.
2749          */
2750         dispc_disable_sidle();
2751
2752         dsi_perf_mark_start();
2753
2754         r = queue_delayed_work(dsi.workqueue, &dsi.framedone_timeout_work,
2755                         msecs_to_jiffies(250));
2756         BUG_ON(r == 0);
2757
2758         dss_start_update(dssdev);
2759
2760         if (dsi.te_enabled) {
2761                 /* disable LP_RX_TO, so that we can receive TE.  Time to wait
2762                  * for TE is longer than the timer allows */
2763                 REG_FLD_MOD(DSI_TIMING2, 0, 15, 15); /* LP_RX_TO */
2764
2765                 dsi_vc_send_bta(channel);
2766
2767 #ifdef DSI_CATCH_MISSING_TE
2768                 mod_timer(&dsi.te_timer, jiffies + msecs_to_jiffies(250));
2769 #endif
2770         }
2771 }
2772
2773 #ifdef DSI_CATCH_MISSING_TE
2774 static void dsi_te_timeout(unsigned long arg)
2775 {
2776         DSSERR("TE not received for 250ms!\n");
2777 }
2778 #endif
2779
2780 static void dsi_handle_framedone(int error)
2781 {
2782         const int channel = dsi.update_channel;
2783
2784         cancel_delayed_work(&dsi.framedone_timeout_work);
2785
2786         dsi_vc_disable_bta_irq(channel);
2787
2788         /* SIDLEMODE back to smart-idle */
2789         dispc_enable_sidle();
2790
2791         dsi.bta_callback = NULL;
2792
2793         if (dsi.te_enabled) {
2794                 /* enable LP_RX_TO again after the TE */
2795                 REG_FLD_MOD(DSI_TIMING2, 1, 15, 15); /* LP_RX_TO */
2796         }
2797
2798         /* RX_FIFO_NOT_EMPTY */
2799         if (REG_GET(DSI_VC_CTRL(channel), 20, 20)) {
2800                 DSSERR("Received error during frame transfer:\n");
2801                 dsi_vc_flush_receive_data(channel);
2802                 if (!error)
2803                         error = -EIO;
2804         }
2805
2806         dsi.framedone_callback(error, dsi.framedone_data);
2807
2808         if (!error)
2809                 dsi_perf_show("DISPC");
2810 }
2811
2812 static void dsi_framedone_timeout_work_callback(struct work_struct *work)
2813 {
2814         /* XXX While extremely unlikely, we could get FRAMEDONE interrupt after
2815          * 250ms which would conflict with this timeout work. What should be
2816          * done is first cancel the transfer on the HW, and then cancel the
2817          * possibly scheduled framedone work. However, cancelling the transfer
2818          * on the HW is buggy, and would probably require resetting the whole
2819          * DSI */
2820
2821         DSSERR("Framedone not received for 250ms!\n");
2822
2823         dsi_handle_framedone(-ETIMEDOUT);
2824 }
2825
2826 static void dsi_framedone_bta_callback(void)
2827 {
2828         dsi_handle_framedone(0);
2829
2830 #ifdef CONFIG_OMAP2_DSS_FAKE_VSYNC
2831         dispc_fake_vsync_irq();
2832 #endif
2833 }
2834
2835 static void dsi_framedone_irq_callback(void *data, u32 mask)
2836 {
2837         const int channel = dsi.update_channel;
2838         int r;
2839
2840         /* Note: We get FRAMEDONE when DISPC has finished sending pixels and
2841          * turns itself off. However, DSI still has the pixels in its buffers,
2842          * and is sending the data.
2843          */
2844
2845         if (dsi.te_enabled) {
2846                 /* enable LP_RX_TO again after the TE */
2847                 REG_FLD_MOD(DSI_TIMING2, 1, 15, 15); /* LP_RX_TO */
2848         }
2849
2850         /* Send BTA after the frame. We need this for the TE to work, as TE
2851          * trigger is only sent for BTAs without preceding packet. Thus we need
2852          * to BTA after the pixel packets so that next BTA will cause TE
2853          * trigger.
2854          *
2855          * This is not needed when TE is not in use, but we do it anyway to
2856          * make sure that the transfer has been completed. It would be more
2857          * optimal, but more complex, to wait only just before starting next
2858          * transfer.
2859          *
2860          * Also, as there's no interrupt telling when the transfer has been
2861          * done and the channel could be reconfigured, the only way is to
2862          * busyloop until TE_SIZE is zero. With BTA we can do this
2863          * asynchronously.
2864          * */
2865
2866         dsi.bta_callback = dsi_framedone_bta_callback;
2867
2868         barrier();
2869
2870         dsi_vc_enable_bta_irq(channel);
2871
2872         r = dsi_vc_send_bta(channel);
2873         if (r) {
2874                 DSSERR("BTA after framedone failed\n");
2875                 dsi_handle_framedone(-EIO);
2876         }
2877 }
2878
2879 int omap_dsi_prepare_update(struct omap_dss_device *dssdev,
2880                                     u16 *x, u16 *y, u16 *w, u16 *h,
2881                                     bool enlarge_update_area)
2882 {
2883         u16 dw, dh;
2884
2885         dssdev->driver->get_resolution(dssdev, &dw, &dh);
2886
2887         if  (*x > dw || *y > dh)
2888                 return -EINVAL;
2889
2890         if (*x + *w > dw)
2891                 return -EINVAL;
2892
2893         if (*y + *h > dh)
2894                 return -EINVAL;
2895
2896         if (*w == 1)
2897                 return -EINVAL;
2898
2899         if (*w == 0 || *h == 0)
2900                 return -EINVAL;
2901
2902         dsi_perf_mark_setup();
2903
2904         if (dssdev->manager->caps & OMAP_DSS_OVL_MGR_CAP_DISPC) {
2905                 dss_setup_partial_planes(dssdev, x, y, w, h,
2906                                 enlarge_update_area);
2907                 dispc_set_lcd_size(dssdev->manager->id, *w, *h);
2908         }
2909
2910         return 0;
2911 }
2912 EXPORT_SYMBOL(omap_dsi_prepare_update);
2913
2914 int omap_dsi_update(struct omap_dss_device *dssdev,
2915                 int channel,
2916                 u16 x, u16 y, u16 w, u16 h,
2917                 void (*callback)(int, void *), void *data)
2918 {
2919         dsi.update_channel = channel;
2920
2921         /* OMAP DSS cannot send updates of odd widths.
2922          * omap_dsi_prepare_update() makes the widths even, but add a BUG_ON
2923          * here to make sure we catch erroneous updates. Otherwise we'll only
2924          * see rather obscure HW error happening, as DSS halts. */
2925         BUG_ON(x % 2 == 1);
2926
2927         if (dssdev->manager->caps & OMAP_DSS_OVL_MGR_CAP_DISPC) {
2928                 dsi.framedone_callback = callback;
2929                 dsi.framedone_data = data;
2930
2931                 dsi.update_region.x = x;
2932                 dsi.update_region.y = y;
2933                 dsi.update_region.w = w;
2934                 dsi.update_region.h = h;
2935                 dsi.update_region.device = dssdev;
2936
2937                 dsi_update_screen_dispc(dssdev, x, y, w, h);
2938         } else {
2939                 int r;
2940
2941                 r = dsi_update_screen_l4(dssdev, x, y, w, h);
2942                 if (r)
2943                         return r;
2944
2945                 dsi_perf_show("L4");
2946                 callback(0, data);
2947         }
2948
2949         return 0;
2950 }
2951 EXPORT_SYMBOL(omap_dsi_update);
2952
2953 /* Display funcs */
2954
2955 static int dsi_display_init_dispc(struct omap_dss_device *dssdev)
2956 {
2957         int r;
2958
2959         r = omap_dispc_register_isr(dsi_framedone_irq_callback, NULL,
2960                         DISPC_IRQ_FRAMEDONE);
2961         if (r) {
2962                 DSSERR("can't get FRAMEDONE irq\n");
2963                 return r;
2964         }
2965
2966         dispc_set_lcd_display_type(dssdev->manager->id,
2967                         OMAP_DSS_LCD_DISPLAY_TFT);
2968
2969         dispc_set_parallel_interface_mode(dssdev->manager->id,
2970                         OMAP_DSS_PARALLELMODE_DSI);
2971         dispc_enable_fifohandcheck(dssdev->manager->id, 1);
2972
2973         dispc_set_tft_data_lines(dssdev->manager->id, dssdev->ctrl.pixel_size);
2974
2975         {
2976                 struct omap_video_timings timings = {
2977                         .hsw            = 1,
2978                         .hfp            = 1,
2979                         .hbp            = 1,
2980                         .vsw            = 1,
2981                         .vfp            = 0,
2982                         .vbp            = 0,
2983                 };
2984
2985                 dispc_set_lcd_timings(dssdev->manager->id, &timings);
2986         }
2987
2988         return 0;
2989 }
2990
2991 static void dsi_display_uninit_dispc(struct omap_dss_device *dssdev)
2992 {
2993         omap_dispc_unregister_isr(dsi_framedone_irq_callback, NULL,
2994                         DISPC_IRQ_FRAMEDONE);
2995 }
2996
2997 static int dsi_configure_dsi_clocks(struct omap_dss_device *dssdev)
2998 {
2999         struct dsi_clock_info cinfo;
3000         int r;
3001
3002         /* we always use DSS2_FCK as input clock */
3003         cinfo.use_dss2_fck = true;
3004         cinfo.regn  = dssdev->phy.dsi.div.regn;
3005         cinfo.regm  = dssdev->phy.dsi.div.regm;
3006         cinfo.regm3 = dssdev->phy.dsi.div.regm3;
3007         cinfo.regm4 = dssdev->phy.dsi.div.regm4;
3008         r = dsi_calc_clock_rates(dssdev, &cinfo);
3009         if (r) {
3010                 DSSERR("Failed to calc dsi clocks\n");
3011                 return r;
3012         }
3013
3014         r = dsi_pll_set_clock_div(&cinfo);
3015         if (r) {
3016                 DSSERR("Failed to set dsi clocks\n");
3017                 return r;
3018         }
3019
3020         return 0;
3021 }
3022
3023 static int dsi_configure_dispc_clocks(struct omap_dss_device *dssdev)
3024 {
3025         struct dispc_clock_info dispc_cinfo;
3026         int r;
3027         unsigned long long fck;
3028
3029         fck = dsi_get_dsi1_pll_rate();
3030
3031         dispc_cinfo.lck_div = dssdev->phy.dsi.div.lck_div;
3032         dispc_cinfo.pck_div = dssdev->phy.dsi.div.pck_div;
3033
3034         r = dispc_calc_clock_rates(fck, &dispc_cinfo);
3035         if (r) {
3036                 DSSERR("Failed to calc dispc clocks\n");
3037                 return r;
3038         }
3039
3040         r = dispc_set_clock_div(dssdev->manager->id, &dispc_cinfo);
3041         if (r) {
3042                 DSSERR("Failed to set dispc clocks\n");
3043                 return r;
3044         }
3045
3046         return 0;
3047 }
3048
3049 static int dsi_display_init_dsi(struct omap_dss_device *dssdev)
3050 {
3051         int r;
3052
3053         _dsi_print_reset_status();
3054
3055         r = dsi_pll_init(dssdev, true, true);
3056         if (r)
3057                 goto err0;
3058
3059         r = dsi_configure_dsi_clocks(dssdev);
3060         if (r)
3061                 goto err1;
3062
3063         dss_select_dispc_clk_source(DSS_SRC_DSI1_PLL_FCLK);
3064         dss_select_dsi_clk_source(DSS_SRC_DSI2_PLL_FCLK);
3065
3066         DSSDBG("PLL OK\n");
3067
3068         r = dsi_configure_dispc_clocks(dssdev);
3069         if (r)
3070                 goto err2;
3071
3072         r = dsi_complexio_init(dssdev);
3073         if (r)
3074                 goto err2;
3075
3076         _dsi_print_reset_status();
3077
3078         dsi_proto_timings(dssdev);
3079         dsi_set_lp_clk_divisor(dssdev);
3080
3081         if (1)
3082                 _dsi_print_reset_status();
3083
3084         r = dsi_proto_config(dssdev);
3085         if (r)
3086                 goto err3;
3087
3088         /* enable interface */
3089         dsi_vc_enable(0, 1);
3090         dsi_vc_enable(1, 1);
3091         dsi_vc_enable(2, 1);
3092         dsi_vc_enable(3, 1);
3093         dsi_if_enable(1);
3094         dsi_force_tx_stop_mode_io();
3095
3096         return 0;
3097 err3:
3098         dsi_complexio_uninit();
3099 err2:
3100         dss_select_dispc_clk_source(DSS_SRC_DSS1_ALWON_FCLK);
3101         dss_select_dsi_clk_source(DSS_SRC_DSS1_ALWON_FCLK);
3102 err1:
3103         dsi_pll_uninit();
3104 err0:
3105         return r;
3106 }
3107
3108 static void dsi_display_uninit_dsi(struct omap_dss_device *dssdev)
3109 {
3110         /* disable interface */
3111         dsi_if_enable(0);
3112         dsi_vc_enable(0, 0);
3113         dsi_vc_enable(1, 0);
3114         dsi_vc_enable(2, 0);
3115         dsi_vc_enable(3, 0);
3116
3117         dss_select_dispc_clk_source(DSS_SRC_DSS1_ALWON_FCLK);
3118         dss_select_dsi_clk_source(DSS_SRC_DSS1_ALWON_FCLK);
3119         dsi_complexio_uninit();
3120         dsi_pll_uninit();
3121 }
3122
3123 static int dsi_core_init(void)
3124 {
3125         /* Autoidle */
3126         REG_FLD_MOD(DSI_SYSCONFIG, 1, 0, 0);
3127
3128         /* ENWAKEUP */
3129         REG_FLD_MOD(DSI_SYSCONFIG, 1, 2, 2);
3130
3131         /* SIDLEMODE smart-idle */
3132         REG_FLD_MOD(DSI_SYSCONFIG, 2, 4, 3);
3133
3134         _dsi_initialize_irq();
3135
3136         return 0;
3137 }
3138
3139 int omapdss_dsi_display_enable(struct omap_dss_device *dssdev)
3140 {
3141         int r = 0;
3142
3143         DSSDBG("dsi_display_enable\n");
3144
3145         WARN_ON(!dsi_bus_is_locked());
3146
3147         mutex_lock(&dsi.lock);
3148
3149         r = omap_dss_start_device(dssdev);
3150         if (r) {
3151                 DSSERR("failed to start device\n");
3152                 goto err0;
3153         }
3154
3155         enable_clocks(1);
3156         dsi_enable_pll_clock(1);
3157
3158         r = _dsi_reset();
3159         if (r)
3160                 goto err1;
3161
3162         dsi_core_init();
3163
3164         r = dsi_display_init_dispc(dssdev);
3165         if (r)
3166                 goto err1;
3167
3168         r = dsi_display_init_dsi(dssdev);
3169         if (r)
3170                 goto err2;
3171
3172         mutex_unlock(&dsi.lock);
3173
3174         return 0;
3175
3176 err2:
3177         dsi_display_uninit_dispc(dssdev);
3178 err1:
3179         enable_clocks(0);
3180         dsi_enable_pll_clock(0);
3181         omap_dss_stop_device(dssdev);
3182 err0:
3183         mutex_unlock(&dsi.lock);
3184         DSSDBG("dsi_display_enable FAILED\n");
3185         return r;
3186 }
3187 EXPORT_SYMBOL(omapdss_dsi_display_enable);
3188
3189 void omapdss_dsi_display_disable(struct omap_dss_device *dssdev)
3190 {
3191         DSSDBG("dsi_display_disable\n");
3192
3193         WARN_ON(!dsi_bus_is_locked());
3194
3195         mutex_lock(&dsi.lock);
3196
3197         dsi_display_uninit_dispc(dssdev);
3198
3199         dsi_display_uninit_dsi(dssdev);
3200
3201         enable_clocks(0);
3202         dsi_enable_pll_clock(0);
3203
3204         omap_dss_stop_device(dssdev);
3205
3206         mutex_unlock(&dsi.lock);
3207 }
3208 EXPORT_SYMBOL(omapdss_dsi_display_disable);
3209
3210 int omapdss_dsi_enable_te(struct omap_dss_device *dssdev, bool enable)
3211 {
3212         dsi.te_enabled = enable;
3213         return 0;
3214 }
3215 EXPORT_SYMBOL(omapdss_dsi_enable_te);
3216
3217 void dsi_get_overlay_fifo_thresholds(enum omap_plane plane,
3218                 u32 fifo_size, enum omap_burst_size *burst_size,
3219                 u32 *fifo_low, u32 *fifo_high)
3220 {
3221         unsigned burst_size_bytes;
3222
3223         *burst_size = OMAP_DSS_BURST_16x32;
3224         burst_size_bytes = 16 * 32 / 8;
3225
3226         *fifo_high = fifo_size - burst_size_bytes;
3227         *fifo_low = fifo_size - burst_size_bytes * 2;
3228 }
3229
3230 int dsi_init_display(struct omap_dss_device *dssdev)
3231 {
3232         DSSDBG("DSI init\n");
3233
3234         /* XXX these should be figured out dynamically */
3235         dssdev->caps = OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE |
3236                 OMAP_DSS_DISPLAY_CAP_TEAR_ELIM;
3237
3238         dsi.vc[0].dssdev = dssdev;
3239         dsi.vc[1].dssdev = dssdev;
3240
3241         return 0;
3242 }
3243
3244 void dsi_wait_dsi1_pll_active(void)
3245 {
3246         if (wait_for_bit_change(DSI_PLL_STATUS, 7, 1) != 1)
3247                 DSSERR("DSI1 PLL clock not active\n");
3248 }
3249
3250 void dsi_wait_dsi2_pll_active(void)
3251 {
3252         if (wait_for_bit_change(DSI_PLL_STATUS, 8, 1) != 1)
3253                 DSSERR("DSI2 PLL clock not active\n");
3254 }
3255
3256 static int dsi_init(struct platform_device *pdev)
3257 {
3258         u32 rev;
3259         int r;
3260
3261         spin_lock_init(&dsi.errors_lock);
3262         dsi.errors = 0;
3263
3264 #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
3265         spin_lock_init(&dsi.irq_stats_lock);
3266         dsi.irq_stats.last_reset = jiffies;
3267 #endif
3268
3269         init_completion(&dsi.bta_completion);
3270
3271         mutex_init(&dsi.lock);
3272         sema_init(&dsi.bus_lock, 1);
3273
3274         dsi.workqueue = create_singlethread_workqueue("dsi");
3275         if (dsi.workqueue == NULL)
3276                 return -ENOMEM;
3277
3278         INIT_DELAYED_WORK_DEFERRABLE(&dsi.framedone_timeout_work,
3279                         dsi_framedone_timeout_work_callback);
3280
3281 #ifdef DSI_CATCH_MISSING_TE
3282         init_timer(&dsi.te_timer);
3283         dsi.te_timer.function = dsi_te_timeout;
3284         dsi.te_timer.data = 0;
3285 #endif
3286         dsi.base = ioremap(DSI_BASE, DSI_SZ_REGS);
3287         if (!dsi.base) {
3288                 DSSERR("can't ioremap DSI\n");
3289                 r = -ENOMEM;
3290                 goto err1;
3291         }
3292
3293         dsi.vdds_dsi_reg = dsi_get_vdds_dsi();
3294         if (IS_ERR(dsi.vdds_dsi_reg)) {
3295                 DSSERR("can't get VDDS_DSI regulator\n");
3296                 r = PTR_ERR(dsi.vdds_dsi_reg);
3297                 goto err2;
3298         }
3299
3300         enable_clocks(1);
3301
3302         rev = dsi_read_reg(DSI_REVISION);
3303         printk(KERN_INFO "OMAP DSI rev %d.%d\n",
3304                FLD_GET(rev, 7, 4), FLD_GET(rev, 3, 0));
3305
3306         enable_clocks(0);
3307
3308         return 0;
3309 err2:
3310         iounmap(dsi.base);
3311 err1:
3312         destroy_workqueue(dsi.workqueue);
3313         return r;
3314 }
3315
3316 static void dsi_exit(void)
3317 {
3318         if (dsi.vdds_dsi_reg != NULL) {
3319                 regulator_put(dsi.vdds_dsi_reg);
3320                 dsi.vdds_dsi_reg = NULL;
3321         }
3322
3323         iounmap(dsi.base);
3324
3325         destroy_workqueue(dsi.workqueue);
3326
3327         DSSDBG("omap_dsi_exit\n");
3328 }
3329
3330 /* DSI1 HW IP initialisation */
3331 static int omap_dsi1hw_probe(struct platform_device *pdev)
3332 {
3333         int r;
3334         dsi.pdev = pdev;
3335         r = dsi_init(pdev);
3336         if (r) {
3337                 DSSERR("Failed to initialize DSI\n");
3338                 goto err_dsi;
3339         }
3340 err_dsi:
3341         return r;
3342 }
3343
3344 static int omap_dsi1hw_remove(struct platform_device *pdev)
3345 {
3346         dsi_exit();
3347         return 0;
3348 }
3349
3350 static struct platform_driver omap_dsi1hw_driver = {
3351         .probe          = omap_dsi1hw_probe,
3352         .remove         = omap_dsi1hw_remove,
3353         .driver         = {
3354                 .name   = "omapdss_dsi1",
3355                 .owner  = THIS_MODULE,
3356         },
3357 };
3358
3359 int dsi_init_platform_driver(void)
3360 {
3361         return platform_driver_register(&omap_dsi1hw_driver);
3362 }
3363
3364 void dsi_uninit_platform_driver(void)
3365 {
3366         return platform_driver_unregister(&omap_dsi1hw_driver);
3367 }