drivers/video/omap/rfbi.c

   1 /*
   2  * OMAP2 Remote Frame Buffer Interface support
   3  *
   4  * Copyright (C) 2005 Nokia Corporation
   5  * Author: Juha Yrjölä <juha.yrjola@nokia.com>
   6  *         Imre Deak <imre.deak@nokia.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2 of the License, or (at your
  11  * option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, write to the Free Software Foundation, Inc.,
  20  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21  */
  22 #include <linux/module.h>
  23 #include <linux/delay.h>
  24 #include <linux/i2c.h>
  25 #include <linux/err.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/clk.h>
  28 #include <linux/io.h>
  29
  30 #include <mach/omapfb.h>
  31
  32 #include "dispc.h"
  33
  34 /* To work around an RFBI transfer rate limitation */
  35 #define OMAP_RFBI_RATE_LIMIT    1
  36
  37 #define RFBI_BASE               0x48050800
  38 #define RFBI_REVISION           0x0000
  39 #define RFBI_SYSCONFIG          0x0010
  40 #define RFBI_SYSSTATUS          0x0014
  41 #define RFBI_CONTROL            0x0040
  42 #define RFBI_PIXEL_CNT          0x0044
  43 #define RFBI_LINE_NUMBER        0x0048
  44 #define RFBI_CMD                0x004c
  45 #define RFBI_PARAM              0x0050
  46 #define RFBI_DATA               0x0054
  47 #define RFBI_READ               0x0058
  48 #define RFBI_STATUS             0x005c
  49 #define RFBI_CONFIG0            0x0060
  50 #define RFBI_ONOFF_TIME0        0x0064
  51 #define RFBI_CYCLE_TIME0        0x0068
  52 #define RFBI_DATA_CYCLE1_0      0x006c
  53 #define RFBI_DATA_CYCLE2_0      0x0070
  54 #define RFBI_DATA_CYCLE3_0      0x0074
  55 #define RFBI_VSYNC_WIDTH        0x0090
  56 #define RFBI_HSYNC_WIDTH        0x0094
  57
  58 #define DISPC_BASE              0x48050400
  59 #define DISPC_CONTROL           0x0040
  60
  61 static struct {
  62         void __iomem    *base;
  63         void            (*lcdc_callback)(void *data);
  64         void            *lcdc_callback_data;
  65         unsigned long   l4_khz;
  66         int             bits_per_cycle;
  67         struct omapfb_device *fbdev;
  68         struct clk      *dss_ick;
  69         struct clk      *dss1_fck;
  70         unsigned        tearsync_pin_cnt;
  71         unsigned        tearsync_mode;
  72 } rfbi;
  73
  74 static inline void rfbi_write_reg(int idx, u32 val)
  75 {
  76         __raw_writel(val, rfbi.base + idx);
  77 }
  78
  79 static inline u32 rfbi_read_reg(int idx)
  80 {
  81         return __raw_readl(rfbi.base + idx);
  82 }
  83
  84 static int rfbi_get_clocks(void)
  85 {
  86         rfbi.dss_ick = clk_get(rfbi.fbdev->dev, "ick");
  87         if (IS_ERR(rfbi.dss_ick)) {
  88                 dev_err(rfbi.fbdev->dev, "can't get ick\n");
  89                 return PTR_ERR(rfbi.dss_ick);
  90         }
  91
  92         rfbi.dss1_fck = clk_get(rfbi.fbdev->dev, "dss1_fck");
  93         if (IS_ERR(rfbi.dss1_fck)) {
  94                 dev_err(rfbi.fbdev->dev, "can't get dss1_fck\n");
  95                 clk_put(rfbi.dss_ick);
  96                 return PTR_ERR(rfbi.dss1_fck);
  97         }
  98
  99         return 0;
 100 }
 101
 102 static void rfbi_put_clocks(void)
 103 {
 104         clk_put(rfbi.dss1_fck);
 105         clk_put(rfbi.dss_ick);
 106 }
 107
 108 static void rfbi_enable_clocks(int enable)
 109 {
 110         if (enable) {
 111                 clk_enable(rfbi.dss_ick);
 112                 clk_enable(rfbi.dss1_fck);
 113         } else {
 114                 clk_disable(rfbi.dss1_fck);
 115                 clk_disable(rfbi.dss_ick);
 116         }
 117 }
 118
 119
 120 #ifdef VERBOSE
 121 static void rfbi_print_timings(void)
 122 {
 123         u32 l;
 124         u32 time;
 125
 126         l = rfbi_read_reg(RFBI_CONFIG0);
 127         time = 1000000000 / rfbi.l4_khz;
 128         if (l & (1 << 4))
 129                 time *= 2;
 130
 131         dev_dbg(rfbi.fbdev->dev, "Tick time %u ps\n", time);
 132         l = rfbi_read_reg(RFBI_ONOFF_TIME0);
 133         dev_dbg(rfbi.fbdev->dev,
 134                 "CSONTIME %d, CSOFFTIME %d, WEONTIME %d, WEOFFTIME %d, "
 135                 "REONTIME %d, REOFFTIME %d\n",
 136                 l & 0x0f, (l >> 4) & 0x3f, (l >> 10) & 0x0f, (l >> 14) & 0x3f,
 137                 (l >> 20) & 0x0f, (l >> 24) & 0x3f);
 138
 139         l = rfbi_read_reg(RFBI_CYCLE_TIME0);
 140         dev_dbg(rfbi.fbdev->dev,
 141                 "WECYCLETIME %d, RECYCLETIME %d, CSPULSEWIDTH %d, "
 142                 "ACCESSTIME %d\n",
 143                 (l & 0x3f), (l >> 6) & 0x3f, (l >> 12) & 0x3f,
 144                 (l >> 22) & 0x3f);
 145 }
 146 #else
 147 static void rfbi_print_timings(void) {}
 148 #endif
 149
 150 static void rfbi_set_timings(const struct extif_timings *t)
 151 {
 152         u32 l;
 153
 154         BUG_ON(!t->converted);
 155
 156         rfbi_enable_clocks(1);
 157         rfbi_write_reg(RFBI_ONOFF_TIME0, t->tim[0]);
 158         rfbi_write_reg(RFBI_CYCLE_TIME0, t->tim[1]);
 159
 160         l = rfbi_read_reg(RFBI_CONFIG0);
 161         l &= ~(1 << 4);
 162         l |= (t->tim[2] ? 1 : 0) << 4;
 163         rfbi_write_reg(RFBI_CONFIG0, l);
 164
 165         rfbi_print_timings();
 166         rfbi_enable_clocks(0);
 167 }
 168
 169 static void rfbi_get_clk_info(u32 *clk_period, u32 *max_clk_div)
 170 {
 171         *clk_period = 1000000000 / rfbi.l4_khz;
 172         *max_clk_div = 2;
 173 }
 174
 175 static int ps_to_rfbi_ticks(int time, int div)
 176 {
 177         unsigned long tick_ps;
 178         int ret;
 179
 180         /* Calculate in picosecs to yield more exact results */
 181         tick_ps = 1000000000 / (rfbi.l4_khz) * div;
 182
 183         ret = (time + tick_ps - 1) / tick_ps;
 184
 185         return ret;
 186 }
 187
 188 #ifdef OMAP_RFBI_RATE_LIMIT
 189 static unsigned long rfbi_get_max_tx_rate(void)
 190 {
 191         unsigned long   l4_rate, dss1_rate;
 192         int             min_l4_ticks = 0;
 193         int             i;
 194
 195         /* According to TI this can't be calculated so make the
 196          * adjustments for a couple of known frequencies and warn for
 197          * others.
 198          */
 199         static const struct {
 200                 unsigned long l4_clk;           /* HZ */
 201                 unsigned long dss1_clk;         /* HZ */
 202                 unsigned long min_l4_ticks;
 203         } ftab[] = {
 204                 { 55,   132,    7, },           /* 7.86 MPix/s */
 205                 { 110,  110,    12, },          /* 9.16 MPix/s */
 206                 { 110,  132,    10, },          /* 11   Mpix/s */
 207                 { 120,  120,    10, },          /* 12   Mpix/s */
 208                 { 133,  133,    10, },          /* 13.3 Mpix/s */
 209         };
 210
 211         l4_rate = rfbi.l4_khz / 1000;
 212         dss1_rate = clk_get_rate(rfbi.dss1_fck) / 1000000;
 213
 214         for (i = 0; i < ARRAY_SIZE(ftab); i++) {
 215                 /* Use a window instead of an exact match, to account
 216                  * for different DPLL multiplier / divider pairs.
 217                  */
 218                 if (abs(ftab[i].l4_clk - l4_rate) < 3 &&
 219                     abs(ftab[i].dss1_clk - dss1_rate) < 3) {
 220                         min_l4_ticks = ftab[i].min_l4_ticks;
 221                         break;
 222                 }
 223         }
 224         if (i == ARRAY_SIZE(ftab)) {
 225                 /* Can't be sure, return anyway the maximum not
 226                  * rate-limited. This might cause a problem only for the
 227                  * tearing synchronisation.
 228                  */
 229                 dev_err(rfbi.fbdev->dev,
 230                         "can't determine maximum RFBI transfer rate\n");
 231                 return rfbi.l4_khz * 1000;
 232         }
 233         return rfbi.l4_khz * 1000 / min_l4_ticks;
 234 }
 235 #else
 236 static int rfbi_get_max_tx_rate(void)
 237 {
 238         return rfbi.l4_khz * 1000;
 239 }
 240 #endif
 241
 242
 243 static int rfbi_convert_timings(struct extif_timings *t)
 244 {
 245         u32 l;
 246         int reon, reoff, weon, weoff, cson, csoff, cs_pulse;
 247         int actim, recyc, wecyc;
 248         int div = t->clk_div;
 249
 250         if (div <= 0 || div > 2)
 251                 return -1;
 252
 253         /* Make sure that after conversion it still holds that:
 254          * weoff > weon, reoff > reon, recyc >= reoff, wecyc >= weoff,
 255          * csoff > cson, csoff >= max(weoff, reoff), actim > reon
 256          */
 257         weon = ps_to_rfbi_ticks(t->we_on_time, div);
 258         weoff = ps_to_rfbi_ticks(t->we_off_time, div);
 259         if (weoff <= weon)
 260                 weoff = weon + 1;
 261         if (weon > 0x0f)
 262                 return -1;
 263         if (weoff > 0x3f)
 264                 return -1;
 265
 266         reon = ps_to_rfbi_ticks(t->re_on_time, div);
 267         reoff = ps_to_rfbi_ticks(t->re_off_time, div);
 268         if (reoff <= reon)
 269                 reoff = reon + 1;
 270         if (reon > 0x0f)
 271                 return -1;
 272         if (reoff > 0x3f)
 273                 return -1;
 274
 275         cson = ps_to_rfbi_ticks(t->cs_on_time, div);
 276         csoff = ps_to_rfbi_ticks(t->cs_off_time, div);
 277         if (csoff <= cson)
 278                 csoff = cson + 1;
 279         if (csoff < max(weoff, reoff))
 280                 csoff = max(weoff, reoff);
 281         if (cson > 0x0f)
 282                 return -1;
 283         if (csoff > 0x3f)
 284                 return -1;
 285
 286         l =  cson;
 287         l |= csoff << 4;
 288         l |= weon  << 10;
 289         l |= weoff << 14;
 290         l |= reon  << 20;
 291         l |= reoff << 24;
 292
 293         t->tim[0] = l;
 294
 295         actim = ps_to_rfbi_ticks(t->access_time, div);
 296         if (actim <= reon)
 297                 actim = reon + 1;
 298         if (actim > 0x3f)
 299                 return -1;
 300
 301         wecyc = ps_to_rfbi_ticks(t->we_cycle_time, div);
 302         if (wecyc < weoff)
 303                 wecyc = weoff;
 304         if (wecyc > 0x3f)
 305                 return -1;
 306
 307         recyc = ps_to_rfbi_ticks(t->re_cycle_time, div);
 308         if (recyc < reoff)
 309                 recyc = reoff;
 310         if (recyc > 0x3f)
 311                 return -1;
 312
 313         cs_pulse = ps_to_rfbi_ticks(t->cs_pulse_width, div);
 314         if (cs_pulse > 0x3f)
 315                 return -1;
 316
 317         l =  wecyc;
 318         l |= recyc    << 6;
 319         l |= cs_pulse << 12;
 320         l |= actim    << 22;
 321
 322         t->tim[1] = l;
 323
 324         t->tim[2] = div - 1;
 325
 326         t->converted = 1;
 327
 328         return 0;
 329 }
 330
 331 static int rfbi_setup_tearsync(unsigned pin_cnt,
 332                                unsigned hs_pulse_time, unsigned vs_pulse_time,
 333                                int hs_pol_inv, int vs_pol_inv, int extif_div)
 334 {
 335         int hs, vs;
 336         int min;
 337         u32 l;
 338
 339         if (pin_cnt != 1 && pin_cnt != 2)
 340                 return -EINVAL;
 341
 342         hs = ps_to_rfbi_ticks(hs_pulse_time, 1);
 343         vs = ps_to_rfbi_ticks(vs_pulse_time, 1);
 344         if (hs < 2)
 345                 return -EDOM;
 346         if (pin_cnt == 2)
 347                 min = 2;
 348         else
 349                 min = 4;
 350         if (vs < min)
 351                 return -EDOM;
 352         if (vs == hs)
 353                 return -EINVAL;
 354         rfbi.tearsync_pin_cnt = pin_cnt;
 355         dev_dbg(rfbi.fbdev->dev,
 356                 "setup_tearsync: pins %d hs %d vs %d hs_inv %d vs_inv %d\n",
 357                 pin_cnt, hs, vs, hs_pol_inv, vs_pol_inv);
 358
 359         rfbi_enable_clocks(1);
 360         rfbi_write_reg(RFBI_HSYNC_WIDTH, hs);
 361         rfbi_write_reg(RFBI_VSYNC_WIDTH, vs);
 362
 363         l = rfbi_read_reg(RFBI_CONFIG0);
 364         if (hs_pol_inv)
 365                 l &= ~(1 << 21);
 366         else
 367                 l |= 1 << 21;
 368         if (vs_pol_inv)
 369                 l &= ~(1 << 20);
 370         else
 371                 l |= 1 << 20;
 372         rfbi_enable_clocks(0);
 373
 374         return 0;
 375 }
 376
 377 static int rfbi_enable_tearsync(int enable, unsigned line)
 378 {
 379         u32 l;
 380
 381         dev_dbg(rfbi.fbdev->dev, "tearsync %d line %d mode %d\n",
 382                 enable, line, rfbi.tearsync_mode);
 383         if (line > (1 << 11) - 1)
 384                 return -EINVAL;
 385
 386         rfbi_enable_clocks(1);
 387         l = rfbi_read_reg(RFBI_CONFIG0);
 388         l &= ~(0x3 << 2);
 389         if (enable) {
 390                 rfbi.tearsync_mode = rfbi.tearsync_pin_cnt;
 391                 l |= rfbi.tearsync_mode << 2;
 392         } else
 393                 rfbi.tearsync_mode = 0;
 394         rfbi_write_reg(RFBI_CONFIG0, l);
 395         rfbi_write_reg(RFBI_LINE_NUMBER, line);
 396         rfbi_enable_clocks(0);
 397
 398         return 0;
 399 }
 400
 401 static void rfbi_write_command(const void *buf, unsigned int len)
 402 {
 403         rfbi_enable_clocks(1);
 404         if (rfbi.bits_per_cycle == 16) {
 405                 const u16 *w = buf;
 406                 BUG_ON(len & 1);
 407                 for (; len; len -= 2)
 408                         rfbi_write_reg(RFBI_CMD, *w++);
 409         } else {
 410                 const u8 *b = buf;
 411                 BUG_ON(rfbi.bits_per_cycle != 8);
 412                 for (; len; len--)
 413                         rfbi_write_reg(RFBI_CMD, *b++);
 414         }
 415         rfbi_enable_clocks(0);
 416 }
 417
 418 static void rfbi_read_data(void *buf, unsigned int len)
 419 {
 420         rfbi_enable_clocks(1);
 421         if (rfbi.bits_per_cycle == 16) {
 422                 u16 *w = buf;
 423                 BUG_ON(len & ~1);
 424                 for (; len; len -= 2) {
 425                         rfbi_write_reg(RFBI_READ, 0);
 426                         *w++ = rfbi_read_reg(RFBI_READ);
 427                 }
 428         } else {
 429                 u8 *b = buf;
 430                 BUG_ON(rfbi.bits_per_cycle != 8);
 431                 for (; len; len--) {
 432                         rfbi_write_reg(RFBI_READ, 0);
 433                         *b++ = rfbi_read_reg(RFBI_READ);
 434                 }
 435         }
 436         rfbi_enable_clocks(0);
 437 }
 438
 439 static void rfbi_write_data(const void *buf, unsigned int len)
 440 {
 441         rfbi_enable_clocks(1);
 442         if (rfbi.bits_per_cycle == 16) {
 443                 const u16 *w = buf;
 444                 BUG_ON(len & 1);
 445                 for (; len; len -= 2)
 446                         rfbi_write_reg(RFBI_PARAM, *w++);
 447         } else {
 448                 const u8 *b = buf;
 449                 BUG_ON(rfbi.bits_per_cycle != 8);
 450                 for (; len; len--)
 451                         rfbi_write_reg(RFBI_PARAM, *b++);
 452         }
 453         rfbi_enable_clocks(0);
 454 }
 455
 456 static void rfbi_transfer_area(int width, int height,
 457                                 void (callback)(void * data), void *data)
 458 {
 459         u32 w;
 460
 461         BUG_ON(callback == NULL);
 462
 463         rfbi_enable_clocks(1);
 464         omap_dispc_set_lcd_size(width, height);
 465
 466         rfbi.lcdc_callback = callback;
 467         rfbi.lcdc_callback_data = data;
 468
 469         rfbi_write_reg(RFBI_PIXEL_CNT, width * height);
 470
 471         w = rfbi_read_reg(RFBI_CONTROL);
 472         w |= 1;                         /* enable */
 473         if (!rfbi.tearsync_mode)
 474                 w |= 1 << 4;            /* internal trigger, reset by HW */
 475         rfbi_write_reg(RFBI_CONTROL, w);
 476
 477         omap_dispc_enable_lcd_out(1);
 478 }
 479
 480 static inline void _stop_transfer(void)
 481 {
 482         u32 w;
 483
 484         w = rfbi_read_reg(RFBI_CONTROL);
 485         rfbi_write_reg(RFBI_CONTROL, w & ~(1 << 0));
 486         rfbi_enable_clocks(0);
 487 }
 488
 489 static void rfbi_dma_callback(void *data)
 490 {
 491         _stop_transfer();
 492         rfbi.lcdc_callback(rfbi.lcdc_callback_data);
 493 }
 494
 495 static void rfbi_set_bits_per_cycle(int bpc)
 496 {
 497         u32 l;
 498
 499         rfbi_enable_clocks(1);
 500         l = rfbi_read_reg(RFBI_CONFIG0);
 501         l &= ~(0x03 << 0);
 502
 503         switch (bpc) {
 504         case 8:
 505                 break;
 506         case 16:
 507                 l |= 3;
 508                 break;
 509         default:
 510                 BUG();
 511         }
 512         rfbi_write_reg(RFBI_CONFIG0, l);
 513         rfbi.bits_per_cycle = bpc;
 514         rfbi_enable_clocks(0);
 515 }
 516
 517 static int rfbi_init(struct omapfb_device *fbdev)
 518 {
 519         u32 l;
 520         int r;
 521
 522         rfbi.fbdev = fbdev;
 523         rfbi.base = ioremap(RFBI_BASE, SZ_1K);
 524         if (!rfbi.base) {
 525                 dev_err(fbdev->dev, "can't ioremap RFBI\n");
 526                 return -ENOMEM;
 527         }
 528
 529         if ((r = rfbi_get_clocks()) < 0)
 530                 return r;
 531         rfbi_enable_clocks(1);
 532
 533         rfbi.l4_khz = clk_get_rate(rfbi.dss_ick) / 1000;
 534
 535         /* Reset */
 536         rfbi_write_reg(RFBI_SYSCONFIG, 1 << 1);
 537         while (!(rfbi_read_reg(RFBI_SYSSTATUS) & (1 << 0)));
 538
 539         l = rfbi_read_reg(RFBI_SYSCONFIG);
 540         /* Enable autoidle and smart-idle */
 541         l |= (1 << 0) | (2 << 3);
 542         rfbi_write_reg(RFBI_SYSCONFIG, l);
 543
 544         /* 16-bit interface, ITE trigger mode, 16-bit data */
 545         l = (0x03 << 0) | (0x00 << 2) | (0x01 << 5) | (0x02 << 7);
 546         l |= (0 << 9) | (1 << 20) | (1 << 21);
 547         rfbi_write_reg(RFBI_CONFIG0, l);
 548
 549         rfbi_write_reg(RFBI_DATA_CYCLE1_0, 0x00000010);
 550
 551         l = rfbi_read_reg(RFBI_CONTROL);
 552         /* Select CS0, clear bypass mode */
 553         l = (0x01 << 2);
 554         rfbi_write_reg(RFBI_CONTROL, l);
 555
 556         if ((r = omap_dispc_request_irq(rfbi_dma_callback, NULL)) < 0) {
 557                 dev_err(fbdev->dev, "can't get DISPC irq\n");
 558                 rfbi_enable_clocks(0);
 559                 return r;
 560         }
 561
 562         l = rfbi_read_reg(RFBI_REVISION);
 563         pr_info("omapfb: RFBI version %d.%d initialized\n",
 564                 (l >> 4) & 0x0f, l & 0x0f);
 565
 566         rfbi_enable_clocks(0);
 567
 568         return 0;
 569 }
 570
 571 static void rfbi_cleanup(void)
 572 {
 573         omap_dispc_free_irq();
 574         rfbi_put_clocks();
 575         iounmap(rfbi.base);
 576 }
 577
 578 const struct lcd_ctrl_extif omap2_ext_if = {
 579         .init                   = rfbi_init,
 580         .cleanup                = rfbi_cleanup,
 581         .get_clk_info           = rfbi_get_clk_info,
 582         .get_max_tx_rate        = rfbi_get_max_tx_rate,
 583         .set_bits_per_cycle     = rfbi_set_bits_per_cycle,
 584         .convert_timings        = rfbi_convert_timings,
 585         .set_timings            = rfbi_set_timings,
 586         .write_command          = rfbi_write_command,
 587         .read_data              = rfbi_read_data,
 588         .write_data             = rfbi_write_data,
 589         .transfer_area          = rfbi_transfer_area,
 590         .setup_tearsync         = rfbi_setup_tearsync,
 591         .enable_tearsync        = rfbi_enable_tearsync,
 592
 593         .max_transmit_size      = (u32) ~0,
 594 };
 595