drivers/gpu/drm/tegra/sor.c

   1 /*
   2  * Copyright (C) 2013 NVIDIA Corporation
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  */
   8
   9 #include <linux/clk.h>
  10 #include <linux/debugfs.h>
  11 #include <linux/gpio.h>
  12 #include <linux/io.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/reset.h>
  15
  16 #include <soc/tegra/pmc.h>
  17
  18 #include <drm/drm_atomic_helper.h>
  19 #include <drm/drm_dp_helper.h>
  20 #include <drm/drm_panel.h>
  21
  22 #include "dc.h"
  23 #include "drm.h"
  24 #include "sor.h"
  25
  26 struct tegra_sor {
  27         struct host1x_client client;
  28         struct tegra_output output;
  29         struct device *dev;
  30
  31         void __iomem *regs;
  32
  33         struct reset_control *rst;
  34         struct clk *clk_parent;
  35         struct clk *clk_safe;
  36         struct clk *clk_dp;
  37         struct clk *clk;
  38
  39         struct tegra_dpaux *dpaux;
  40
  41         struct mutex lock;
  42         bool enabled;
  43
  44         struct drm_info_list *debugfs_files;
  45         struct drm_minor *minor;
  46         struct dentry *debugfs;
  47 };
  48
  49 struct tegra_sor_config {
  50         u32 bits_per_pixel;
  51
  52         u32 active_polarity;
  53         u32 active_count;
  54         u32 tu_size;
  55         u32 active_frac;
  56         u32 watermark;
  57
  58         u32 hblank_symbols;
  59         u32 vblank_symbols;
  60 };
  61
  62 static inline struct tegra_sor *
  63 host1x_client_to_sor(struct host1x_client *client)
  64 {
  65         return container_of(client, struct tegra_sor, client);
  66 }
  67
  68 static inline struct tegra_sor *to_sor(struct tegra_output *output)
  69 {
  70         return container_of(output, struct tegra_sor, output);
  71 }
  72
  73 static inline u32 tegra_sor_readl(struct tegra_sor *sor, unsigned long offset)
  74 {
  75         return readl(sor->regs + (offset << 2));
  76 }
  77
  78 static inline void tegra_sor_writel(struct tegra_sor *sor, u32 value,
  79                                     unsigned long offset)
  80 {
  81         writel(value, sor->regs + (offset << 2));
  82 }
  83
  84 static int tegra_sor_dp_train_fast(struct tegra_sor *sor,
  85                                    struct drm_dp_link *link)
  86 {
  87         unsigned int i;
  88         u8 pattern;
  89         u32 value;
  90         int err;
  91
  92         /* setup lane parameters */
  93         value = SOR_LANE_DRIVE_CURRENT_LANE3(0x40) |
  94                 SOR_LANE_DRIVE_CURRENT_LANE2(0x40) |
  95                 SOR_LANE_DRIVE_CURRENT_LANE1(0x40) |
  96                 SOR_LANE_DRIVE_CURRENT_LANE0(0x40);
  97         tegra_sor_writel(sor, value, SOR_LANE_DRIVE_CURRENT_0);
  98
  99         value = SOR_LANE_PREEMPHASIS_LANE3(0x0f) |
 100                 SOR_LANE_PREEMPHASIS_LANE2(0x0f) |
 101                 SOR_LANE_PREEMPHASIS_LANE1(0x0f) |
 102                 SOR_LANE_PREEMPHASIS_LANE0(0x0f);
 103         tegra_sor_writel(sor, value, SOR_LANE_PREEMPHASIS_0);
 104
 105         value = SOR_LANE_POST_CURSOR_LANE3(0x00) |
 106                 SOR_LANE_POST_CURSOR_LANE2(0x00) |
 107                 SOR_LANE_POST_CURSOR_LANE1(0x00) |
 108                 SOR_LANE_POST_CURSOR_LANE0(0x00);
 109         tegra_sor_writel(sor, value, SOR_LANE_POST_CURSOR_0);
 110
 111         /* disable LVDS mode */
 112         tegra_sor_writel(sor, 0, SOR_LVDS);
 113
 114         value = tegra_sor_readl(sor, SOR_DP_PADCTL_0);
 115         value |= SOR_DP_PADCTL_TX_PU_ENABLE;
 116         value &= ~SOR_DP_PADCTL_TX_PU_MASK;
 117         value |= SOR_DP_PADCTL_TX_PU(2); /* XXX: don't hardcode? */
 118         tegra_sor_writel(sor, value, SOR_DP_PADCTL_0);
 119
 120         value = tegra_sor_readl(sor, SOR_DP_PADCTL_0);
 121         value |= SOR_DP_PADCTL_CM_TXD_3 | SOR_DP_PADCTL_CM_TXD_2 |
 122                  SOR_DP_PADCTL_CM_TXD_1 | SOR_DP_PADCTL_CM_TXD_0;
 123         tegra_sor_writel(sor, value, SOR_DP_PADCTL_0);
 124
 125         usleep_range(10, 100);
 126
 127         value = tegra_sor_readl(sor, SOR_DP_PADCTL_0);
 128         value &= ~(SOR_DP_PADCTL_CM_TXD_3 | SOR_DP_PADCTL_CM_TXD_2 |
 129                    SOR_DP_PADCTL_CM_TXD_1 | SOR_DP_PADCTL_CM_TXD_0);
 130         tegra_sor_writel(sor, value, SOR_DP_PADCTL_0);
 131
 132         err = tegra_dpaux_prepare(sor->dpaux, DP_SET_ANSI_8B10B);
 133         if (err < 0)
 134                 return err;
 135
 136         for (i = 0, value = 0; i < link->num_lanes; i++) {
 137                 unsigned long lane = SOR_DP_TPG_CHANNEL_CODING |
 138                                      SOR_DP_TPG_SCRAMBLER_NONE |
 139                                      SOR_DP_TPG_PATTERN_TRAIN1;
 140                 value = (value << 8) | lane;
 141         }
 142
 143         tegra_sor_writel(sor, value, SOR_DP_TPG);
 144
 145         pattern = DP_TRAINING_PATTERN_1;
 146
 147         err = tegra_dpaux_train(sor->dpaux, link, pattern);
 148         if (err < 0)
 149                 return err;
 150
 151         value = tegra_sor_readl(sor, SOR_DP_SPARE_0);
 152         value |= SOR_DP_SPARE_SEQ_ENABLE;
 153         value &= ~SOR_DP_SPARE_PANEL_INTERNAL;
 154         value |= SOR_DP_SPARE_MACRO_SOR_CLK;
 155         tegra_sor_writel(sor, value, SOR_DP_SPARE_0);
 156
 157         for (i = 0, value = 0; i < link->num_lanes; i++) {
 158                 unsigned long lane = SOR_DP_TPG_CHANNEL_CODING |
 159                                      SOR_DP_TPG_SCRAMBLER_NONE |
 160                                      SOR_DP_TPG_PATTERN_TRAIN2;
 161                 value = (value << 8) | lane;
 162         }
 163
 164         tegra_sor_writel(sor, value, SOR_DP_TPG);
 165
 166         pattern = DP_LINK_SCRAMBLING_DISABLE | DP_TRAINING_PATTERN_2;
 167
 168         err = tegra_dpaux_train(sor->dpaux, link, pattern);
 169         if (err < 0)
 170                 return err;
 171
 172         for (i = 0, value = 0; i < link->num_lanes; i++) {
 173                 unsigned long lane = SOR_DP_TPG_CHANNEL_CODING |
 174                                      SOR_DP_TPG_SCRAMBLER_GALIOS |
 175                                      SOR_DP_TPG_PATTERN_NONE;
 176                 value = (value << 8) | lane;
 177         }
 178
 179         tegra_sor_writel(sor, value, SOR_DP_TPG);
 180
 181         pattern = DP_TRAINING_PATTERN_DISABLE;
 182
 183         err = tegra_dpaux_train(sor->dpaux, link, pattern);
 184         if (err < 0)
 185                 return err;
 186
 187         return 0;
 188 }
 189
 190 static void tegra_sor_super_update(struct tegra_sor *sor)
 191 {
 192         tegra_sor_writel(sor, 0, SOR_SUPER_STATE_0);
 193         tegra_sor_writel(sor, 1, SOR_SUPER_STATE_0);
 194         tegra_sor_writel(sor, 0, SOR_SUPER_STATE_0);
 195 }
 196
 197 static void tegra_sor_update(struct tegra_sor *sor)
 198 {
 199         tegra_sor_writel(sor, 0, SOR_STATE_0);
 200         tegra_sor_writel(sor, 1, SOR_STATE_0);
 201         tegra_sor_writel(sor, 0, SOR_STATE_0);
 202 }
 203
 204 static int tegra_sor_setup_pwm(struct tegra_sor *sor, unsigned long timeout)
 205 {
 206         u32 value;
 207
 208         value = tegra_sor_readl(sor, SOR_PWM_DIV);
 209         value &= ~SOR_PWM_DIV_MASK;
 210         value |= 0x400; /* period */
 211         tegra_sor_writel(sor, value, SOR_PWM_DIV);
 212
 213         value = tegra_sor_readl(sor, SOR_PWM_CTL);
 214         value &= ~SOR_PWM_CTL_DUTY_CYCLE_MASK;
 215         value |= 0x400; /* duty cycle */
 216         value &= ~SOR_PWM_CTL_CLK_SEL; /* clock source: PCLK */
 217         value |= SOR_PWM_CTL_TRIGGER;
 218         tegra_sor_writel(sor, value, SOR_PWM_CTL);
 219
 220         timeout = jiffies + msecs_to_jiffies(timeout);
 221
 222         while (time_before(jiffies, timeout)) {
 223                 value = tegra_sor_readl(sor, SOR_PWM_CTL);
 224                 if ((value & SOR_PWM_CTL_TRIGGER) == 0)
 225                         return 0;
 226
 227                 usleep_range(25, 100);
 228         }
 229
 230         return -ETIMEDOUT;
 231 }
 232
 233 static int tegra_sor_attach(struct tegra_sor *sor)
 234 {
 235         unsigned long value, timeout;
 236
 237         /* wake up in normal mode */
 238         value = tegra_sor_readl(sor, SOR_SUPER_STATE_1);
 239         value |= SOR_SUPER_STATE_HEAD_MODE_AWAKE;
 240         value |= SOR_SUPER_STATE_MODE_NORMAL;
 241         tegra_sor_writel(sor, value, SOR_SUPER_STATE_1);
 242         tegra_sor_super_update(sor);
 243
 244         /* attach */
 245         value = tegra_sor_readl(sor, SOR_SUPER_STATE_1);
 246         value |= SOR_SUPER_STATE_ATTACHED;
 247         tegra_sor_writel(sor, value, SOR_SUPER_STATE_1);
 248         tegra_sor_super_update(sor);
 249
 250         timeout = jiffies + msecs_to_jiffies(250);
 251
 252         while (time_before(jiffies, timeout)) {
 253                 value = tegra_sor_readl(sor, SOR_TEST);
 254                 if ((value & SOR_TEST_ATTACHED) != 0)
 255                         return 0;
 256
 257                 usleep_range(25, 100);
 258         }
 259
 260         return -ETIMEDOUT;
 261 }
 262
 263 static int tegra_sor_wakeup(struct tegra_sor *sor)
 264 {
 265         unsigned long value, timeout;
 266
 267         timeout = jiffies + msecs_to_jiffies(250);
 268
 269         /* wait for head to wake up */
 270         while (time_before(jiffies, timeout)) {
 271                 value = tegra_sor_readl(sor, SOR_TEST);
 272                 value &= SOR_TEST_HEAD_MODE_MASK;
 273
 274                 if (value == SOR_TEST_HEAD_MODE_AWAKE)
 275                         return 0;
 276
 277                 usleep_range(25, 100);
 278         }
 279
 280         return -ETIMEDOUT;
 281 }
 282
 283 static int tegra_sor_power_up(struct tegra_sor *sor, unsigned long timeout)
 284 {
 285         u32 value;
 286
 287         value = tegra_sor_readl(sor, SOR_PWR);
 288         value |= SOR_PWR_TRIGGER | SOR_PWR_NORMAL_STATE_PU;
 289         tegra_sor_writel(sor, value, SOR_PWR);
 290
 291         timeout = jiffies + msecs_to_jiffies(timeout);
 292
 293         while (time_before(jiffies, timeout)) {
 294                 value = tegra_sor_readl(sor, SOR_PWR);
 295                 if ((value & SOR_PWR_TRIGGER) == 0)
 296                         return 0;
 297
 298                 usleep_range(25, 100);
 299         }
 300
 301         return -ETIMEDOUT;
 302 }
 303
 304 struct tegra_sor_params {
 305         /* number of link clocks per line */
 306         unsigned int num_clocks;
 307         /* ratio between input and output */
 308         u64 ratio;
 309         /* precision factor */
 310         u64 precision;
 311
 312         unsigned int active_polarity;
 313         unsigned int active_count;
 314         unsigned int active_frac;
 315         unsigned int tu_size;
 316         unsigned int error;
 317 };
 318
 319 static int tegra_sor_compute_params(struct tegra_sor *sor,
 320                                     struct tegra_sor_params *params,
 321                                     unsigned int tu_size)
 322 {
 323         u64 active_sym, active_count, frac, approx;
 324         u32 active_polarity, active_frac = 0;
 325         const u64 f = params->precision;
 326         s64 error;
 327
 328         active_sym = params->ratio * tu_size;
 329         active_count = div_u64(active_sym, f) * f;
 330         frac = active_sym - active_count;
 331
 332         /* fraction < 0.5 */
 333         if (frac >= (f / 2)) {
 334                 active_polarity = 1;
 335                 frac = f - frac;
 336         } else {
 337                 active_polarity = 0;
 338         }
 339
 340         if (frac != 0) {
 341                 frac = div_u64(f * f,  frac); /* 1/fraction */
 342                 if (frac <= (15 * f)) {
 343                         active_frac = div_u64(frac, f);
 344
 345                         /* round up */
 346                         if (active_polarity)
 347                                 active_frac++;
 348                 } else {
 349                         active_frac = active_polarity ? 1 : 15;
 350                 }
 351         }
 352
 353         if (active_frac == 1)
 354                 active_polarity = 0;
 355
 356         if (active_polarity == 1) {
 357                 if (active_frac) {
 358                         approx = active_count + (active_frac * (f - 1)) * f;
 359                         approx = div_u64(approx, active_frac * f);
 360                 } else {
 361                         approx = active_count + f;
 362                 }
 363         } else {
 364                 if (active_frac)
 365                         approx = active_count + div_u64(f, active_frac);
 366                 else
 367                         approx = active_count;
 368         }
 369
 370         error = div_s64(active_sym - approx, tu_size);
 371         error *= params->num_clocks;
 372
 373         if (error <= 0 && abs64(error) < params->error) {
 374                 params->active_count = div_u64(active_count, f);
 375                 params->active_polarity = active_polarity;
 376                 params->active_frac = active_frac;
 377                 params->error = abs64(error);
 378                 params->tu_size = tu_size;
 379
 380                 if (error == 0)
 381                         return true;
 382         }
 383
 384         return false;
 385 }
 386
 387 static int tegra_sor_calc_config(struct tegra_sor *sor,
 388                                  struct drm_display_mode *mode,
 389                                  struct tegra_sor_config *config,
 390                                  struct drm_dp_link *link)
 391 {
 392         const u64 f = 100000, link_rate = link->rate * 1000;
 393         const u64 pclk = mode->clock * 1000;
 394         u64 input, output, watermark, num;
 395         struct tegra_sor_params params;
 396         u32 num_syms_per_line;
 397         unsigned int i;
 398
 399         if (!link_rate || !link->num_lanes || !pclk || !config->bits_per_pixel)
 400                 return -EINVAL;
 401
 402         output = link_rate * 8 * link->num_lanes;
 403         input = pclk * config->bits_per_pixel;
 404
 405         if (input >= output)
 406                 return -ERANGE;
 407
 408         memset(&params, 0, sizeof(params));
 409         params.ratio = div64_u64(input * f, output);
 410         params.num_clocks = div_u64(link_rate * mode->hdisplay, pclk);
 411         params.precision = f;
 412         params.error = 64 * f;
 413         params.tu_size = 64;
 414
 415         for (i = params.tu_size; i >= 32; i--)
 416                 if (tegra_sor_compute_params(sor, &params, i))
 417                         break;
 418
 419         if (params.active_frac == 0) {
 420                 config->active_polarity = 0;
 421                 config->active_count = params.active_count;
 422
 423                 if (!params.active_polarity)
 424                         config->active_count--;
 425
 426                 config->tu_size = params.tu_size;
 427                 config->active_frac = 1;
 428         } else {
 429                 config->active_polarity = params.active_polarity;
 430                 config->active_count = params.active_count;
 431                 config->active_frac = params.active_frac;
 432                 config->tu_size = params.tu_size;
 433         }
 434
 435         dev_dbg(sor->dev,
 436                 "polarity: %d active count: %d tu size: %d active frac: %d\n",
 437                 config->active_polarity, config->active_count,
 438                 config->tu_size, config->active_frac);
 439
 440         watermark = params.ratio * config->tu_size * (f - params.ratio);
 441         watermark = div_u64(watermark, f);
 442
 443         watermark = div_u64(watermark + params.error, f);
 444         config->watermark = watermark + (config->bits_per_pixel / 8) + 2;
 445         num_syms_per_line = (mode->hdisplay * config->bits_per_pixel) *
 446                             (link->num_lanes * 8);
 447
 448         if (config->watermark > 30) {
 449                 config->watermark = 30;
 450                 dev_err(sor->dev,
 451                         "unable to compute TU size, forcing watermark to %u\n",
 452                         config->watermark);
 453         } else if (config->watermark > num_syms_per_line) {
 454                 config->watermark = num_syms_per_line;
 455                 dev_err(sor->dev, "watermark too high, forcing to %u\n",
 456                         config->watermark);
 457         }
 458
 459         /* compute the number of symbols per horizontal blanking interval */
 460         num = ((mode->htotal - mode->hdisplay) - 7) * link_rate;
 461         config->hblank_symbols = div_u64(num, pclk);
 462
 463         if (link->capabilities & DP_LINK_CAP_ENHANCED_FRAMING)
 464                 config->hblank_symbols -= 3;
 465
 466         config->hblank_symbols -= 12 / link->num_lanes;
 467
 468         /* compute the number of symbols per vertical blanking interval */
 469         num = (mode->hdisplay - 25) * link_rate;
 470         config->vblank_symbols = div_u64(num, pclk);
 471         config->vblank_symbols -= 36 / link->num_lanes + 4;
 472
 473         dev_dbg(sor->dev, "blank symbols: H:%u V:%u\n", config->hblank_symbols,
 474                 config->vblank_symbols);
 475
 476         return 0;
 477 }
 478
 479 static int tegra_sor_detach(struct tegra_sor *sor)
 480 {
 481         unsigned long value, timeout;
 482
 483         /* switch to safe mode */
 484         value = tegra_sor_readl(sor, SOR_SUPER_STATE_1);
 485         value &= ~SOR_SUPER_STATE_MODE_NORMAL;
 486         tegra_sor_writel(sor, value, SOR_SUPER_STATE_1);
 487         tegra_sor_super_update(sor);
 488
 489         timeout = jiffies + msecs_to_jiffies(250);
 490
 491         while (time_before(jiffies, timeout)) {
 492                 value = tegra_sor_readl(sor, SOR_PWR);
 493                 if (value & SOR_PWR_MODE_SAFE)
 494                         break;
 495         }
 496
 497         if ((value & SOR_PWR_MODE_SAFE) == 0)
 498                 return -ETIMEDOUT;
 499
 500         /* go to sleep */
 501         value = tegra_sor_readl(sor, SOR_SUPER_STATE_1);
 502         value &= ~SOR_SUPER_STATE_HEAD_MODE_MASK;
 503         tegra_sor_writel(sor, value, SOR_SUPER_STATE_1);
 504         tegra_sor_super_update(sor);
 505
 506         /* detach */
 507         value = tegra_sor_readl(sor, SOR_SUPER_STATE_1);
 508         value &= ~SOR_SUPER_STATE_ATTACHED;
 509         tegra_sor_writel(sor, value, SOR_SUPER_STATE_1);
 510         tegra_sor_super_update(sor);
 511
 512         timeout = jiffies + msecs_to_jiffies(250);
 513
 514         while (time_before(jiffies, timeout)) {
 515                 value = tegra_sor_readl(sor, SOR_TEST);
 516                 if ((value & SOR_TEST_ATTACHED) == 0)
 517                         break;
 518
 519                 usleep_range(25, 100);
 520         }
 521
 522         if ((value & SOR_TEST_ATTACHED) != 0)
 523                 return -ETIMEDOUT;
 524
 525         return 0;
 526 }
 527
 528 static int tegra_sor_power_down(struct tegra_sor *sor)
 529 {
 530         unsigned long value, timeout;
 531         int err;
 532
 533         value = tegra_sor_readl(sor, SOR_PWR);
 534         value &= ~SOR_PWR_NORMAL_STATE_PU;
 535         value |= SOR_PWR_TRIGGER;
 536         tegra_sor_writel(sor, value, SOR_PWR);
 537
 538         timeout = jiffies + msecs_to_jiffies(250);
 539
 540         while (time_before(jiffies, timeout)) {
 541                 value = tegra_sor_readl(sor, SOR_PWR);
 542                 if ((value & SOR_PWR_TRIGGER) == 0)
 543                         return 0;
 544
 545                 usleep_range(25, 100);
 546         }
 547
 548         if ((value & SOR_PWR_TRIGGER) != 0)
 549                 return -ETIMEDOUT;
 550
 551         err = clk_set_parent(sor->clk, sor->clk_safe);
 552         if (err < 0)
 553                 dev_err(sor->dev, "failed to set safe parent clock: %d\n", err);
 554
 555         value = tegra_sor_readl(sor, SOR_DP_PADCTL_0);
 556         value &= ~(SOR_DP_PADCTL_PD_TXD_3 | SOR_DP_PADCTL_PD_TXD_0 |
 557                    SOR_DP_PADCTL_PD_TXD_1 | SOR_DP_PADCTL_PD_TXD_2);
 558         tegra_sor_writel(sor, value, SOR_DP_PADCTL_0);
 559
 560         /* stop lane sequencer */
 561         value = SOR_LANE_SEQ_CTL_TRIGGER | SOR_LANE_SEQ_CTL_SEQUENCE_UP |
 562                 SOR_LANE_SEQ_CTL_POWER_STATE_DOWN;
 563         tegra_sor_writel(sor, value, SOR_LANE_SEQ_CTL);
 564
 565         timeout = jiffies + msecs_to_jiffies(250);
 566
 567         while (time_before(jiffies, timeout)) {
 568                 value = tegra_sor_readl(sor, SOR_LANE_SEQ_CTL);
 569                 if ((value & SOR_LANE_SEQ_CTL_TRIGGER) == 0)
 570                         break;
 571
 572                 usleep_range(25, 100);
 573         }
 574
 575         if ((value & SOR_LANE_SEQ_CTL_TRIGGER) != 0)
 576                 return -ETIMEDOUT;
 577
 578         value = tegra_sor_readl(sor, SOR_PLL_2);
 579         value |= SOR_PLL_2_PORT_POWERDOWN;
 580         tegra_sor_writel(sor, value, SOR_PLL_2);
 581
 582         usleep_range(20, 100);
 583
 584         value = tegra_sor_readl(sor, SOR_PLL_0);
 585         value |= SOR_PLL_0_POWER_OFF;
 586         value |= SOR_PLL_0_VCOPD;
 587         tegra_sor_writel(sor, value, SOR_PLL_0);
 588
 589         value = tegra_sor_readl(sor, SOR_PLL_2);
 590         value |= SOR_PLL_2_SEQ_PLLCAPPD;
 591         value |= SOR_PLL_2_SEQ_PLLCAPPD_ENFORCE;
 592         tegra_sor_writel(sor, value, SOR_PLL_2);
 593
 594         usleep_range(20, 100);
 595
 596         return 0;
 597 }
 598
 599 static int tegra_sor_crc_open(struct inode *inode, struct file *file)
 600 {
 601         file->private_data = inode->i_private;
 602
 603         return 0;
 604 }
 605
 606 static int tegra_sor_crc_release(struct inode *inode, struct file *file)
 607 {
 608         return 0;
 609 }
 610
 611 static int tegra_sor_crc_wait(struct tegra_sor *sor, unsigned long timeout)
 612 {
 613         u32 value;
 614
 615         timeout = jiffies + msecs_to_jiffies(timeout);
 616
 617         while (time_before(jiffies, timeout)) {
 618                 value = tegra_sor_readl(sor, SOR_CRC_A);
 619                 if (value & SOR_CRC_A_VALID)
 620                         return 0;
 621
 622                 usleep_range(100, 200);
 623         }
 624
 625         return -ETIMEDOUT;
 626 }
 627
 628 static ssize_t tegra_sor_crc_read(struct file *file, char __user *buffer,
 629                                   size_t size, loff_t *ppos)
 630 {
 631         struct tegra_sor *sor = file->private_data;
 632         ssize_t num, err;
 633         char buf[10];
 634         u32 value;
 635
 636         mutex_lock(&sor->lock);
 637
 638         if (!sor->enabled) {
 639                 err = -EAGAIN;
 640                 goto unlock;
 641         }
 642
 643         value = tegra_sor_readl(sor, SOR_STATE_1);
 644         value &= ~SOR_STATE_ASY_CRC_MODE_MASK;
 645         tegra_sor_writel(sor, value, SOR_STATE_1);
 646
 647         value = tegra_sor_readl(sor, SOR_CRC_CNTRL);
 648         value |= SOR_CRC_CNTRL_ENABLE;
 649         tegra_sor_writel(sor, value, SOR_CRC_CNTRL);
 650
 651         value = tegra_sor_readl(sor, SOR_TEST);
 652         value &= ~SOR_TEST_CRC_POST_SERIALIZE;
 653         tegra_sor_writel(sor, value, SOR_TEST);
 654
 655         err = tegra_sor_crc_wait(sor, 100);
 656         if (err < 0)
 657                 goto unlock;
 658
 659         tegra_sor_writel(sor, SOR_CRC_A_RESET, SOR_CRC_A);
 660         value = tegra_sor_readl(sor, SOR_CRC_B);
 661
 662         num = scnprintf(buf, sizeof(buf), "%08x\n", value);
 663
 664         err = simple_read_from_buffer(buffer, size, ppos, buf, num);
 665
 666 unlock:
 667         mutex_unlock(&sor->lock);
 668         return err;
 669 }
 670
 671 static const struct file_operations tegra_sor_crc_fops = {
 672         .owner = THIS_MODULE,
 673         .open = tegra_sor_crc_open,
 674         .read = tegra_sor_crc_read,
 675         .release = tegra_sor_crc_release,
 676 };
 677
 678 static int tegra_sor_show_regs(struct seq_file *s, void *data)
 679 {
 680         struct drm_info_node *node = s->private;
 681         struct tegra_sor *sor = node->info_ent->data;
 682
 683 #define DUMP_REG(name)                                          \
 684         seq_printf(s, "%-38s %#05x %08x\n", #name, name,        \
 685                    tegra_sor_readl(sor, name))
 686
 687         DUMP_REG(SOR_CTXSW);
 688         DUMP_REG(SOR_SUPER_STATE_0);
 689         DUMP_REG(SOR_SUPER_STATE_1);
 690         DUMP_REG(SOR_STATE_0);
 691         DUMP_REG(SOR_STATE_1);
 692         DUMP_REG(SOR_HEAD_STATE_0(0));
 693         DUMP_REG(SOR_HEAD_STATE_0(1));
 694         DUMP_REG(SOR_HEAD_STATE_1(0));
 695         DUMP_REG(SOR_HEAD_STATE_1(1));
 696         DUMP_REG(SOR_HEAD_STATE_2(0));
 697         DUMP_REG(SOR_HEAD_STATE_2(1));
 698         DUMP_REG(SOR_HEAD_STATE_3(0));
 699         DUMP_REG(SOR_HEAD_STATE_3(1));
 700         DUMP_REG(SOR_HEAD_STATE_4(0));
 701         DUMP_REG(SOR_HEAD_STATE_4(1));
 702         DUMP_REG(SOR_HEAD_STATE_5(0));
 703         DUMP_REG(SOR_HEAD_STATE_5(1));
 704         DUMP_REG(SOR_CRC_CNTRL);
 705         DUMP_REG(SOR_DP_DEBUG_MVID);
 706         DUMP_REG(SOR_CLK_CNTRL);
 707         DUMP_REG(SOR_CAP);
 708         DUMP_REG(SOR_PWR);
 709         DUMP_REG(SOR_TEST);
 710         DUMP_REG(SOR_PLL_0);
 711         DUMP_REG(SOR_PLL_1);
 712         DUMP_REG(SOR_PLL_2);
 713         DUMP_REG(SOR_PLL_3);
 714         DUMP_REG(SOR_CSTM);
 715         DUMP_REG(SOR_LVDS);
 716         DUMP_REG(SOR_CRC_A);
 717         DUMP_REG(SOR_CRC_B);
 718         DUMP_REG(SOR_BLANK);
 719         DUMP_REG(SOR_SEQ_CTL);
 720         DUMP_REG(SOR_LANE_SEQ_CTL);
 721         DUMP_REG(SOR_SEQ_INST(0));
 722         DUMP_REG(SOR_SEQ_INST(1));
 723         DUMP_REG(SOR_SEQ_INST(2));
 724         DUMP_REG(SOR_SEQ_INST(3));
 725         DUMP_REG(SOR_SEQ_INST(4));
 726         DUMP_REG(SOR_SEQ_INST(5));
 727         DUMP_REG(SOR_SEQ_INST(6));
 728         DUMP_REG(SOR_SEQ_INST(7));
 729         DUMP_REG(SOR_SEQ_INST(8));
 730         DUMP_REG(SOR_SEQ_INST(9));
 731         DUMP_REG(SOR_SEQ_INST(10));
 732         DUMP_REG(SOR_SEQ_INST(11));
 733         DUMP_REG(SOR_SEQ_INST(12));
 734         DUMP_REG(SOR_SEQ_INST(13));
 735         DUMP_REG(SOR_SEQ_INST(14));
 736         DUMP_REG(SOR_SEQ_INST(15));
 737         DUMP_REG(SOR_PWM_DIV);
 738         DUMP_REG(SOR_PWM_CTL);
 739         DUMP_REG(SOR_VCRC_A_0);
 740         DUMP_REG(SOR_VCRC_A_1);
 741         DUMP_REG(SOR_VCRC_B_0);
 742         DUMP_REG(SOR_VCRC_B_1);
 743         DUMP_REG(SOR_CCRC_A_0);
 744         DUMP_REG(SOR_CCRC_A_1);
 745         DUMP_REG(SOR_CCRC_B_0);
 746         DUMP_REG(SOR_CCRC_B_1);
 747         DUMP_REG(SOR_EDATA_A_0);
 748         DUMP_REG(SOR_EDATA_A_1);
 749         DUMP_REG(SOR_EDATA_B_0);
 750         DUMP_REG(SOR_EDATA_B_1);
 751         DUMP_REG(SOR_COUNT_A_0);
 752         DUMP_REG(SOR_COUNT_A_1);
 753         DUMP_REG(SOR_COUNT_B_0);
 754         DUMP_REG(SOR_COUNT_B_1);
 755         DUMP_REG(SOR_DEBUG_A_0);
 756         DUMP_REG(SOR_DEBUG_A_1);
 757         DUMP_REG(SOR_DEBUG_B_0);
 758         DUMP_REG(SOR_DEBUG_B_1);
 759         DUMP_REG(SOR_TRIG);
 760         DUMP_REG(SOR_MSCHECK);
 761         DUMP_REG(SOR_XBAR_CTRL);
 762         DUMP_REG(SOR_XBAR_POL);
 763         DUMP_REG(SOR_DP_LINKCTL_0);
 764         DUMP_REG(SOR_DP_LINKCTL_1);
 765         DUMP_REG(SOR_LANE_DRIVE_CURRENT_0);
 766         DUMP_REG(SOR_LANE_DRIVE_CURRENT_1);
 767         DUMP_REG(SOR_LANE4_DRIVE_CURRENT_0);
 768         DUMP_REG(SOR_LANE4_DRIVE_CURRENT_1);
 769         DUMP_REG(SOR_LANE_PREEMPHASIS_0);
 770         DUMP_REG(SOR_LANE_PREEMPHASIS_1);
 771         DUMP_REG(SOR_LANE4_PREEMPHASIS_0);
 772         DUMP_REG(SOR_LANE4_PREEMPHASIS_1);
 773         DUMP_REG(SOR_LANE_POST_CURSOR_0);
 774         DUMP_REG(SOR_LANE_POST_CURSOR_1);
 775         DUMP_REG(SOR_DP_CONFIG_0);
 776         DUMP_REG(SOR_DP_CONFIG_1);
 777         DUMP_REG(SOR_DP_MN_0);
 778         DUMP_REG(SOR_DP_MN_1);
 779         DUMP_REG(SOR_DP_PADCTL_0);
 780         DUMP_REG(SOR_DP_PADCTL_1);
 781         DUMP_REG(SOR_DP_DEBUG_0);
 782         DUMP_REG(SOR_DP_DEBUG_1);
 783         DUMP_REG(SOR_DP_SPARE_0);
 784         DUMP_REG(SOR_DP_SPARE_1);
 785         DUMP_REG(SOR_DP_AUDIO_CTRL);
 786         DUMP_REG(SOR_DP_AUDIO_HBLANK_SYMBOLS);
 787         DUMP_REG(SOR_DP_AUDIO_VBLANK_SYMBOLS);
 788         DUMP_REG(SOR_DP_GENERIC_INFOFRAME_HEADER);
 789         DUMP_REG(SOR_DP_GENERIC_INFOFRAME_SUBPACK_0);
 790         DUMP_REG(SOR_DP_GENERIC_INFOFRAME_SUBPACK_1);
 791         DUMP_REG(SOR_DP_GENERIC_INFOFRAME_SUBPACK_2);
 792         DUMP_REG(SOR_DP_GENERIC_INFOFRAME_SUBPACK_3);
 793         DUMP_REG(SOR_DP_GENERIC_INFOFRAME_SUBPACK_4);
 794         DUMP_REG(SOR_DP_GENERIC_INFOFRAME_SUBPACK_5);
 795         DUMP_REG(SOR_DP_GENERIC_INFOFRAME_SUBPACK_6);
 796         DUMP_REG(SOR_DP_TPG);
 797         DUMP_REG(SOR_DP_TPG_CONFIG);
 798         DUMP_REG(SOR_DP_LQ_CSTM_0);
 799         DUMP_REG(SOR_DP_LQ_CSTM_1);
 800         DUMP_REG(SOR_DP_LQ_CSTM_2);
 801
 802 #undef DUMP_REG
 803
 804         return 0;
 805 }
 806
 807 static const struct drm_info_list debugfs_files[] = {
 808         { "regs", tegra_sor_show_regs, 0, NULL },
 809 };
 810
 811 static int tegra_sor_debugfs_init(struct tegra_sor *sor,
 812                                   struct drm_minor *minor)
 813 {
 814         struct dentry *entry;
 815         unsigned int i;
 816         int err = 0;
 817
 818         sor->debugfs = debugfs_create_dir("sor", minor->debugfs_root);
 819         if (!sor->debugfs)
 820                 return -ENOMEM;
 821
 822         sor->debugfs_files = kmemdup(debugfs_files, sizeof(debugfs_files),
 823                                      GFP_KERNEL);
 824         if (!sor->debugfs_files) {
 825                 err = -ENOMEM;
 826                 goto remove;
 827         }
 828
 829         for (i = 0; i < ARRAY_SIZE(debugfs_files); i++)
 830                 sor->debugfs_files[i].data = sor;
 831
 832         err = drm_debugfs_create_files(sor->debugfs_files,
 833                                        ARRAY_SIZE(debugfs_files),
 834                                        sor->debugfs, minor);
 835         if (err < 0)
 836                 goto free;
 837
 838         entry = debugfs_create_file("crc", 0644, sor->debugfs, sor,
 839                                     &tegra_sor_crc_fops);
 840         if (!entry) {
 841                 err = -ENOMEM;
 842                 goto free;
 843         }
 844
 845         return err;
 846
 847 free:
 848         kfree(sor->debugfs_files);
 849         sor->debugfs_files = NULL;
 850 remove:
 851         debugfs_remove_recursive(sor->debugfs);
 852         sor->debugfs = NULL;
 853         return err;
 854 }
 855
 856 static void tegra_sor_debugfs_exit(struct tegra_sor *sor)
 857 {
 858         drm_debugfs_remove_files(sor->debugfs_files, ARRAY_SIZE(debugfs_files),
 859                                  sor->minor);
 860         sor->minor = NULL;
 861
 862         kfree(sor->debugfs_files);
 863         sor->debugfs = NULL;
 864
 865         debugfs_remove_recursive(sor->debugfs);
 866         sor->debugfs_files = NULL;
 867 }
 868
 869 static int tegra_sor_connector_dpms(struct drm_connector *connector, int mode)
 870 {
 871         return 0;
 872 }
 873
 874 static enum drm_connector_status
 875 tegra_sor_connector_detect(struct drm_connector *connector, bool force)
 876 {
 877         struct tegra_output *output = connector_to_output(connector);
 878         struct tegra_sor *sor = to_sor(output);
 879
 880         if (sor->dpaux)
 881                 return tegra_dpaux_detect(sor->dpaux);
 882
 883         return connector_status_unknown;
 884 }
 885
 886 static const struct drm_connector_funcs tegra_sor_connector_funcs = {
 887         .dpms = tegra_sor_connector_dpms,
 888         .reset = drm_atomic_helper_connector_reset,
 889         .detect = tegra_sor_connector_detect,
 890         .fill_modes = drm_helper_probe_single_connector_modes,
 891         .destroy = tegra_output_connector_destroy,
 892         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 893         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 894 };
 895
 896 static int tegra_sor_connector_get_modes(struct drm_connector *connector)
 897 {
 898         struct tegra_output *output = connector_to_output(connector);
 899         struct tegra_sor *sor = to_sor(output);
 900         int err;
 901
 902         if (sor->dpaux)
 903                 tegra_dpaux_enable(sor->dpaux);
 904
 905         err = tegra_output_connector_get_modes(connector);
 906
 907         if (sor->dpaux)
 908                 tegra_dpaux_disable(sor->dpaux);
 909
 910         return err;
 911 }
 912
 913 static enum drm_mode_status
 914 tegra_sor_connector_mode_valid(struct drm_connector *connector,
 915                                struct drm_display_mode *mode)
 916 {
 917         return MODE_OK;
 918 }
 919
 920 static const struct drm_connector_helper_funcs tegra_sor_connector_helper_funcs = {
 921         .get_modes = tegra_sor_connector_get_modes,
 922         .mode_valid = tegra_sor_connector_mode_valid,
 923         .best_encoder = tegra_output_connector_best_encoder,
 924 };
 925
 926 static const struct drm_encoder_funcs tegra_sor_encoder_funcs = {
 927         .destroy = tegra_output_encoder_destroy,
 928 };
 929
 930 static void tegra_sor_encoder_dpms(struct drm_encoder *encoder, int mode)
 931 {
 932 }
 933
 934 static void tegra_sor_encoder_prepare(struct drm_encoder *encoder)
 935 {
 936 }
 937
 938 static void tegra_sor_encoder_commit(struct drm_encoder *encoder)
 939 {
 940 }
 941
 942 static void tegra_sor_encoder_mode_set(struct drm_encoder *encoder,
 943                                        struct drm_display_mode *mode,
 944                                        struct drm_display_mode *adjusted)
 945 {
 946         struct tegra_output *output = encoder_to_output(encoder);
 947         struct tegra_dc *dc = to_tegra_dc(encoder->crtc);
 948         unsigned int vbe, vse, hbe, hse, vbs, hbs, i;
 949         struct tegra_sor *sor = to_sor(output);
 950         struct tegra_sor_config config;
 951         struct drm_dp_link link;
 952         struct drm_dp_aux *aux;
 953         int err = 0;
 954         u32 value;
 955
 956         mutex_lock(&sor->lock);
 957
 958         if (sor->enabled)
 959                 goto unlock;
 960
 961         err = clk_prepare_enable(sor->clk);
 962         if (err < 0)
 963                 goto unlock;
 964
 965         reset_control_deassert(sor->rst);
 966
 967         if (output->panel)
 968                 drm_panel_prepare(output->panel);
 969
 970         /* FIXME: properly convert to struct drm_dp_aux */
 971         aux = (struct drm_dp_aux *)sor->dpaux;
 972
 973         if (sor->dpaux) {
 974                 err = tegra_dpaux_enable(sor->dpaux);
 975                 if (err < 0)
 976                         dev_err(sor->dev, "failed to enable DP: %d\n", err);
 977
 978                 err = drm_dp_link_probe(aux, &link);
 979                 if (err < 0) {
 980                         dev_err(sor->dev, "failed to probe eDP link: %d\n",
 981                                 err);
 982                         goto unlock;
 983                 }
 984         }
 985
 986         err = clk_set_parent(sor->clk, sor->clk_safe);
 987         if (err < 0)
 988                 dev_err(sor->dev, "failed to set safe parent clock: %d\n", err);
 989
 990         memset(&config, 0, sizeof(config));
 991         config.bits_per_pixel = output->connector.display_info.bpc * 3;
 992
 993         err = tegra_sor_calc_config(sor, mode, &config, &link);
 994         if (err < 0)
 995                 dev_err(sor->dev, "failed to compute link configuration: %d\n",
 996                         err);
 997
 998         value = tegra_sor_readl(sor, SOR_CLK_CNTRL);
 999         value &= ~SOR_CLK_CNTRL_DP_CLK_SEL_MASK;
1000         value |= SOR_CLK_CNTRL_DP_CLK_SEL_SINGLE_DPCLK;
1001         tegra_sor_writel(sor, value, SOR_CLK_CNTRL);
1002
1003         value = tegra_sor_readl(sor, SOR_PLL_2);
1004         value &= ~SOR_PLL_2_BANDGAP_POWERDOWN;
1005         tegra_sor_writel(sor, value, SOR_PLL_2);
1006         usleep_range(20, 100);
1007
1008         value = tegra_sor_readl(sor, SOR_PLL_3);
1009         value |= SOR_PLL_3_PLL_VDD_MODE_V3_3;
1010         tegra_sor_writel(sor, value, SOR_PLL_3);
1011
1012         value = SOR_PLL_0_ICHPMP(0xf) | SOR_PLL_0_VCOCAP_RST |
1013                 SOR_PLL_0_PLLREG_LEVEL_V45 | SOR_PLL_0_RESISTOR_EXT;
1014         tegra_sor_writel(sor, value, SOR_PLL_0);
1015
1016         value = tegra_sor_readl(sor, SOR_PLL_2);
1017         value |= SOR_PLL_2_SEQ_PLLCAPPD;
1018         value &= ~SOR_PLL_2_SEQ_PLLCAPPD_ENFORCE;
1019         value |= SOR_PLL_2_LVDS_ENABLE;
1020         tegra_sor_writel(sor, value, SOR_PLL_2);
1021
1022         value = SOR_PLL_1_TERM_COMPOUT | SOR_PLL_1_TMDS_TERM;
1023         tegra_sor_writel(sor, value, SOR_PLL_1);
1024
1025         while (true) {
1026                 value = tegra_sor_readl(sor, SOR_PLL_2);
1027                 if ((value & SOR_PLL_2_SEQ_PLLCAPPD_ENFORCE) == 0)
1028                         break;
1029
1030                 usleep_range(250, 1000);
1031         }
1032
1033         value = tegra_sor_readl(sor, SOR_PLL_2);
1034         value &= ~SOR_PLL_2_POWERDOWN_OVERRIDE;
1035         value &= ~SOR_PLL_2_PORT_POWERDOWN;
1036         tegra_sor_writel(sor, value, SOR_PLL_2);
1037
1038         /*
1039          * power up
1040          */
1041
1042         /* set safe link bandwidth (1.62 Gbps) */
1043         value = tegra_sor_readl(sor, SOR_CLK_CNTRL);
1044         value &= ~SOR_CLK_CNTRL_DP_LINK_SPEED_MASK;
1045         value |= SOR_CLK_CNTRL_DP_LINK_SPEED_G1_62;
1046         tegra_sor_writel(sor, value, SOR_CLK_CNTRL);
1047
1048         /* step 1 */
1049         value = tegra_sor_readl(sor, SOR_PLL_2);
1050         value |= SOR_PLL_2_SEQ_PLLCAPPD_ENFORCE | SOR_PLL_2_PORT_POWERDOWN |
1051                  SOR_PLL_2_BANDGAP_POWERDOWN;
1052         tegra_sor_writel(sor, value, SOR_PLL_2);
1053
1054         value = tegra_sor_readl(sor, SOR_PLL_0);
1055         value |= SOR_PLL_0_VCOPD | SOR_PLL_0_POWER_OFF;
1056         tegra_sor_writel(sor, value, SOR_PLL_0);
1057
1058         value = tegra_sor_readl(sor, SOR_DP_PADCTL_0);
1059         value &= ~SOR_DP_PADCTL_PAD_CAL_PD;
1060         tegra_sor_writel(sor, value, SOR_DP_PADCTL_0);
1061
1062         /* step 2 */
1063         err = tegra_io_rail_power_on(TEGRA_IO_RAIL_LVDS);
1064         if (err < 0) {
1065                 dev_err(sor->dev, "failed to power on I/O rail: %d\n", err);
1066                 goto unlock;
1067         }
1068
1069         usleep_range(5, 100);
1070
1071         /* step 3 */
1072         value = tegra_sor_readl(sor, SOR_PLL_2);
1073         value &= ~SOR_PLL_2_BANDGAP_POWERDOWN;
1074         tegra_sor_writel(sor, value, SOR_PLL_2);
1075
1076         usleep_range(20, 100);
1077
1078         /* step 4 */
1079         value = tegra_sor_readl(sor, SOR_PLL_0);
1080         value &= ~SOR_PLL_0_POWER_OFF;
1081         value &= ~SOR_PLL_0_VCOPD;
1082         tegra_sor_writel(sor, value, SOR_PLL_0);
1083
1084         value = tegra_sor_readl(sor, SOR_PLL_2);
1085         value &= ~SOR_PLL_2_SEQ_PLLCAPPD_ENFORCE;
1086         tegra_sor_writel(sor, value, SOR_PLL_2);
1087
1088         usleep_range(200, 1000);
1089
1090         /* step 5 */
1091         value = tegra_sor_readl(sor, SOR_PLL_2);
1092         value &= ~SOR_PLL_2_PORT_POWERDOWN;
1093         tegra_sor_writel(sor, value, SOR_PLL_2);
1094
1095         /* switch to DP clock */
1096         err = clk_set_parent(sor->clk, sor->clk_dp);
1097         if (err < 0)
1098                 dev_err(sor->dev, "failed to set DP parent clock: %d\n", err);
1099
1100         /* power DP lanes */
1101         value = tegra_sor_readl(sor, SOR_DP_PADCTL_0);
1102
1103         if (link.num_lanes <= 2)
1104                 value &= ~(SOR_DP_PADCTL_PD_TXD_3 | SOR_DP_PADCTL_PD_TXD_2);
1105         else
1106                 value |= SOR_DP_PADCTL_PD_TXD_3 | SOR_DP_PADCTL_PD_TXD_2;
1107
1108         if (link.num_lanes <= 1)
1109                 value &= ~SOR_DP_PADCTL_PD_TXD_1;
1110         else
1111                 value |= SOR_DP_PADCTL_PD_TXD_1;
1112
1113         if (link.num_lanes == 0)
1114                 value &= ~SOR_DP_PADCTL_PD_TXD_0;
1115         else
1116                 value |= SOR_DP_PADCTL_PD_TXD_0;
1117
1118         tegra_sor_writel(sor, value, SOR_DP_PADCTL_0);
1119
1120         value = tegra_sor_readl(sor, SOR_DP_LINKCTL_0);
1121         value &= ~SOR_DP_LINKCTL_LANE_COUNT_MASK;
1122         value |= SOR_DP_LINKCTL_LANE_COUNT(link.num_lanes);
1123         tegra_sor_writel(sor, value, SOR_DP_LINKCTL_0);
1124
1125         /* start lane sequencer */
1126         value = SOR_LANE_SEQ_CTL_TRIGGER | SOR_LANE_SEQ_CTL_SEQUENCE_DOWN |
1127                 SOR_LANE_SEQ_CTL_POWER_STATE_UP;
1128         tegra_sor_writel(sor, value, SOR_LANE_SEQ_CTL);
1129
1130         while (true) {
1131                 value = tegra_sor_readl(sor, SOR_LANE_SEQ_CTL);
1132                 if ((value & SOR_LANE_SEQ_CTL_TRIGGER) == 0)
1133                         break;
1134
1135                 usleep_range(250, 1000);
1136         }
1137
1138         /* set link bandwidth */
1139         value = tegra_sor_readl(sor, SOR_CLK_CNTRL);
1140         value &= ~SOR_CLK_CNTRL_DP_LINK_SPEED_MASK;
1141         value |= drm_dp_link_rate_to_bw_code(link.rate) << 2;
1142         tegra_sor_writel(sor, value, SOR_CLK_CNTRL);
1143
1144         /* set linkctl */
1145         value = tegra_sor_readl(sor, SOR_DP_LINKCTL_0);
1146         value |= SOR_DP_LINKCTL_ENABLE;
1147
1148         value &= ~SOR_DP_LINKCTL_TU_SIZE_MASK;
1149         value |= SOR_DP_LINKCTL_TU_SIZE(config.tu_size);
1150
1151         value |= SOR_DP_LINKCTL_ENHANCED_FRAME;
1152         tegra_sor_writel(sor, value, SOR_DP_LINKCTL_0);
1153
1154         for (i = 0, value = 0; i < 4; i++) {
1155                 unsigned long lane = SOR_DP_TPG_CHANNEL_CODING |
1156                                      SOR_DP_TPG_SCRAMBLER_GALIOS |
1157                                      SOR_DP_TPG_PATTERN_NONE;
1158                 value = (value << 8) | lane;
1159         }
1160
1161         tegra_sor_writel(sor, value, SOR_DP_TPG);
1162
1163         value = tegra_sor_readl(sor, SOR_DP_CONFIG_0);
1164         value &= ~SOR_DP_CONFIG_WATERMARK_MASK;
1165         value |= SOR_DP_CONFIG_WATERMARK(config.watermark);
1166
1167         value &= ~SOR_DP_CONFIG_ACTIVE_SYM_COUNT_MASK;
1168         value |= SOR_DP_CONFIG_ACTIVE_SYM_COUNT(config.active_count);
1169
1170         value &= ~SOR_DP_CONFIG_ACTIVE_SYM_FRAC_MASK;
1171         value |= SOR_DP_CONFIG_ACTIVE_SYM_FRAC(config.active_frac);
1172
1173         if (config.active_polarity)
1174                 value |= SOR_DP_CONFIG_ACTIVE_SYM_POLARITY;
1175         else
1176                 value &= ~SOR_DP_CONFIG_ACTIVE_SYM_POLARITY;
1177
1178         value |= SOR_DP_CONFIG_ACTIVE_SYM_ENABLE;
1179         value |= SOR_DP_CONFIG_DISPARITY_NEGATIVE;
1180         tegra_sor_writel(sor, value, SOR_DP_CONFIG_0);
1181
1182         value = tegra_sor_readl(sor, SOR_DP_AUDIO_HBLANK_SYMBOLS);
1183         value &= ~SOR_DP_AUDIO_HBLANK_SYMBOLS_MASK;
1184         value |= config.hblank_symbols & 0xffff;
1185         tegra_sor_writel(sor, value, SOR_DP_AUDIO_HBLANK_SYMBOLS);
1186
1187         value = tegra_sor_readl(sor, SOR_DP_AUDIO_VBLANK_SYMBOLS);
1188         value &= ~SOR_DP_AUDIO_VBLANK_SYMBOLS_MASK;
1189         value |= config.vblank_symbols & 0xffff;
1190         tegra_sor_writel(sor, value, SOR_DP_AUDIO_VBLANK_SYMBOLS);
1191
1192         /* enable pad calibration logic */
1193         value = tegra_sor_readl(sor, SOR_DP_PADCTL_0);
1194         value |= SOR_DP_PADCTL_PAD_CAL_PD;
1195         tegra_sor_writel(sor, value, SOR_DP_PADCTL_0);
1196
1197         if (sor->dpaux) {
1198                 u8 rate, lanes;
1199
1200                 err = drm_dp_link_probe(aux, &link);
1201                 if (err < 0) {
1202                         dev_err(sor->dev, "failed to probe eDP link: %d\n",
1203                                 err);
1204                         goto unlock;
1205                 }
1206
1207                 err = drm_dp_link_power_up(aux, &link);
1208                 if (err < 0) {
1209                         dev_err(sor->dev, "failed to power up eDP link: %d\n",
1210                                 err);
1211                         goto unlock;
1212                 }
1213
1214                 err = drm_dp_link_configure(aux, &link);
1215                 if (err < 0) {
1216                         dev_err(sor->dev, "failed to configure eDP link: %d\n",
1217                                 err);
1218                         goto unlock;
1219                 }
1220
1221                 rate = drm_dp_link_rate_to_bw_code(link.rate);
1222                 lanes = link.num_lanes;
1223
1224                 value = tegra_sor_readl(sor, SOR_CLK_CNTRL);
1225                 value &= ~SOR_CLK_CNTRL_DP_LINK_SPEED_MASK;
1226                 value |= SOR_CLK_CNTRL_DP_LINK_SPEED(rate);
1227                 tegra_sor_writel(sor, value, SOR_CLK_CNTRL);
1228
1229                 value = tegra_sor_readl(sor, SOR_DP_LINKCTL_0);
1230                 value &= ~SOR_DP_LINKCTL_LANE_COUNT_MASK;
1231                 value |= SOR_DP_LINKCTL_LANE_COUNT(lanes);
1232
1233                 if (link.capabilities & DP_LINK_CAP_ENHANCED_FRAMING)
1234                         value |= SOR_DP_LINKCTL_ENHANCED_FRAME;
1235
1236                 tegra_sor_writel(sor, value, SOR_DP_LINKCTL_0);
1237
1238                 /* disable training pattern generator */
1239
1240                 for (i = 0; i < link.num_lanes; i++) {
1241                         unsigned long lane = SOR_DP_TPG_CHANNEL_CODING |
1242                                              SOR_DP_TPG_SCRAMBLER_GALIOS |
1243                                              SOR_DP_TPG_PATTERN_NONE;
1244                         value = (value << 8) | lane;
1245                 }
1246
1247                 tegra_sor_writel(sor, value, SOR_DP_TPG);
1248
1249                 err = tegra_sor_dp_train_fast(sor, &link);
1250                 if (err < 0) {
1251                         dev_err(sor->dev, "DP fast link training failed: %d\n",
1252                                 err);
1253                         goto unlock;
1254                 }
1255
1256                 dev_dbg(sor->dev, "fast link training succeeded\n");
1257         }
1258
1259         err = tegra_sor_power_up(sor, 250);
1260         if (err < 0) {
1261                 dev_err(sor->dev, "failed to power up SOR: %d\n", err);
1262                 goto unlock;
1263         }
1264
1265         /*
1266          * configure panel (24bpp, vsync-, hsync-, DP-A protocol, complete
1267          * raster, associate with display controller)
1268          */
1269         value = SOR_STATE_ASY_PROTOCOL_DP_A |
1270                 SOR_STATE_ASY_CRC_MODE_COMPLETE |
1271                 SOR_STATE_ASY_OWNER(dc->pipe + 1);
1272
1273         if (mode->flags & DRM_MODE_FLAG_PHSYNC)
1274                 value &= ~SOR_STATE_ASY_HSYNCPOL;
1275
1276         if (mode->flags & DRM_MODE_FLAG_NHSYNC)
1277                 value |= SOR_STATE_ASY_HSYNCPOL;
1278
1279         if (mode->flags & DRM_MODE_FLAG_PVSYNC)
1280                 value &= ~SOR_STATE_ASY_VSYNCPOL;
1281
1282         if (mode->flags & DRM_MODE_FLAG_NVSYNC)
1283                 value |= SOR_STATE_ASY_VSYNCPOL;
1284
1285         switch (config.bits_per_pixel) {
1286         case 24:
1287                 value |= SOR_STATE_ASY_PIXELDEPTH_BPP_24_444;
1288                 break;
1289
1290         case 18:
1291                 value |= SOR_STATE_ASY_PIXELDEPTH_BPP_18_444;
1292                 break;
1293
1294         default:
1295                 BUG();
1296                 break;
1297         }
1298
1299         tegra_sor_writel(sor, value, SOR_STATE_1);
1300
1301         /*
1302          * TODO: The video timing programming below doesn't seem to match the
1303          * register definitions.
1304          */
1305
1306         value = ((mode->vtotal & 0x7fff) << 16) | (mode->htotal & 0x7fff);
1307         tegra_sor_writel(sor, value, SOR_HEAD_STATE_1(0));
1308
1309         vse = mode->vsync_end - mode->vsync_start - 1;
1310         hse = mode->hsync_end - mode->hsync_start - 1;
1311
1312         value = ((vse & 0x7fff) << 16) | (hse & 0x7fff);
1313         tegra_sor_writel(sor, value, SOR_HEAD_STATE_2(0));
1314
1315         vbe = vse + (mode->vsync_start - mode->vdisplay);
1316         hbe = hse + (mode->hsync_start - mode->hdisplay);
1317
1318         value = ((vbe & 0x7fff) << 16) | (hbe & 0x7fff);
1319         tegra_sor_writel(sor, value, SOR_HEAD_STATE_3(0));
1320
1321         vbs = vbe + mode->vdisplay;
1322         hbs = hbe + mode->hdisplay;
1323
1324         value = ((vbs & 0x7fff) << 16) | (hbs & 0x7fff);
1325         tegra_sor_writel(sor, value, SOR_HEAD_STATE_4(0));
1326
1327         /* CSTM (LVDS, link A/B, upper) */
1328         value = SOR_CSTM_LVDS | SOR_CSTM_LINK_ACT_A | SOR_CSTM_LINK_ACT_B |
1329                 SOR_CSTM_UPPER;
1330         tegra_sor_writel(sor, value, SOR_CSTM);
1331
1332         /* PWM setup */
1333         err = tegra_sor_setup_pwm(sor, 250);
1334         if (err < 0) {
1335                 dev_err(sor->dev, "failed to setup PWM: %d\n", err);
1336                 goto unlock;
1337         }
1338
1339         tegra_sor_update(sor);
1340
1341         value = tegra_dc_readl(dc, DC_DISP_DISP_WIN_OPTIONS);
1342         value |= SOR_ENABLE;
1343         tegra_dc_writel(dc, value, DC_DISP_DISP_WIN_OPTIONS);
1344
1345         tegra_dc_commit(dc);
1346
1347         err = tegra_sor_attach(sor);
1348         if (err < 0) {
1349                 dev_err(sor->dev, "failed to attach SOR: %d\n", err);
1350                 goto unlock;
1351         }
1352
1353         err = tegra_sor_wakeup(sor);
1354         if (err < 0) {
1355                 dev_err(sor->dev, "failed to enable DC: %d\n", err);
1356                 goto unlock;
1357         }
1358
1359         if (output->panel)
1360                 drm_panel_enable(output->panel);
1361
1362         sor->enabled = true;
1363
1364 unlock:
1365         mutex_unlock(&sor->lock);
1366 }
1367
1368 static void tegra_sor_encoder_disable(struct drm_encoder *encoder)
1369 {
1370         struct tegra_output *output = encoder_to_output(encoder);
1371         struct tegra_dc *dc = to_tegra_dc(encoder->crtc);
1372         struct tegra_sor *sor = to_sor(output);
1373         u32 value;
1374         int err;
1375
1376         mutex_lock(&sor->lock);
1377
1378         if (!sor->enabled)
1379                 goto unlock;
1380
1381         if (output->panel)
1382                 drm_panel_disable(output->panel);
1383
1384         err = tegra_sor_detach(sor);
1385         if (err < 0) {
1386                 dev_err(sor->dev, "failed to detach SOR: %d\n", err);
1387                 goto unlock;
1388         }
1389
1390         tegra_sor_writel(sor, 0, SOR_STATE_1);
1391         tegra_sor_update(sor);
1392
1393         /*
1394          * The following accesses registers of the display controller, so make
1395          * sure it's only executed when the output is attached to one.
1396          */
1397         if (dc) {
1398                 value = tegra_dc_readl(dc, DC_DISP_DISP_WIN_OPTIONS);
1399                 value &= ~SOR_ENABLE;
1400                 tegra_dc_writel(dc, value, DC_DISP_DISP_WIN_OPTIONS);
1401
1402                 tegra_dc_commit(dc);
1403         }
1404
1405         err = tegra_sor_power_down(sor);
1406         if (err < 0) {
1407                 dev_err(sor->dev, "failed to power down SOR: %d\n", err);
1408                 goto unlock;
1409         }
1410
1411         if (sor->dpaux) {
1412                 err = tegra_dpaux_disable(sor->dpaux);
1413                 if (err < 0) {
1414                         dev_err(sor->dev, "failed to disable DP: %d\n", err);
1415                         goto unlock;
1416                 }
1417         }
1418
1419         err = tegra_io_rail_power_off(TEGRA_IO_RAIL_LVDS);
1420         if (err < 0) {
1421                 dev_err(sor->dev, "failed to power off I/O rail: %d\n", err);
1422                 goto unlock;
1423         }
1424
1425         if (output->panel)
1426                 drm_panel_unprepare(output->panel);
1427
1428         clk_disable_unprepare(sor->clk);
1429         reset_control_assert(sor->rst);
1430
1431         sor->enabled = false;
1432
1433 unlock:
1434         mutex_unlock(&sor->lock);
1435 }
1436
1437 static int
1438 tegra_sor_encoder_atomic_check(struct drm_encoder *encoder,
1439                                struct drm_crtc_state *crtc_state,
1440                                struct drm_connector_state *conn_state)
1441 {
1442         struct tegra_output *output = encoder_to_output(encoder);
1443         struct tegra_dc *dc = to_tegra_dc(conn_state->crtc);
1444         unsigned long pclk = crtc_state->mode.clock * 1000;
1445         struct tegra_sor *sor = to_sor(output);
1446         int err;
1447
1448         err = tegra_dc_state_setup_clock(dc, crtc_state, sor->clk_parent,
1449                                          pclk, 0);
1450         if (err < 0) {
1451                 dev_err(output->dev, "failed to setup CRTC state: %d\n", err);
1452                 return err;
1453         }
1454
1455         return 0;
1456 }
1457
1458 static const struct drm_encoder_helper_funcs tegra_sor_encoder_helper_funcs = {
1459         .dpms = tegra_sor_encoder_dpms,
1460         .prepare = tegra_sor_encoder_prepare,
1461         .commit = tegra_sor_encoder_commit,
1462         .mode_set = tegra_sor_encoder_mode_set,
1463         .disable = tegra_sor_encoder_disable,
1464         .atomic_check = tegra_sor_encoder_atomic_check,
1465 };
1466
1467 static int tegra_sor_init(struct host1x_client *client)
1468 {
1469         struct drm_device *drm = dev_get_drvdata(client->parent);
1470         struct tegra_sor *sor = host1x_client_to_sor(client);
1471         int err;
1472
1473         if (!sor->dpaux)
1474                 return -ENODEV;
1475
1476         sor->output.dev = sor->dev;
1477
1478         drm_connector_init(drm, &sor->output.connector,
1479                            &tegra_sor_connector_funcs,
1480                            DRM_MODE_CONNECTOR_eDP);
1481         drm_connector_helper_add(&sor->output.connector,
1482                                  &tegra_sor_connector_helper_funcs);
1483         sor->output.connector.dpms = DRM_MODE_DPMS_OFF;
1484
1485         drm_encoder_init(drm, &sor->output.encoder, &tegra_sor_encoder_funcs,
1486                          DRM_MODE_ENCODER_TMDS);
1487         drm_encoder_helper_add(&sor->output.encoder,
1488                                &tegra_sor_encoder_helper_funcs);
1489
1490         drm_mode_connector_attach_encoder(&sor->output.connector,
1491                                           &sor->output.encoder);
1492         drm_connector_register(&sor->output.connector);
1493
1494         err = tegra_output_init(drm, &sor->output);
1495         if (err < 0) {
1496                 dev_err(client->dev, "failed to initialize output: %d\n", err);
1497                 return err;
1498         }
1499
1500         sor->output.encoder.possible_crtcs = 0x3;
1501
1502         if (IS_ENABLED(CONFIG_DEBUG_FS)) {
1503                 err = tegra_sor_debugfs_init(sor, drm->primary);
1504                 if (err < 0)
1505                         dev_err(sor->dev, "debugfs setup failed: %d\n", err);
1506         }
1507
1508         if (sor->dpaux) {
1509                 err = tegra_dpaux_attach(sor->dpaux, &sor->output);
1510                 if (err < 0) {
1511                         dev_err(sor->dev, "failed to attach DP: %d\n", err);
1512                         return err;
1513                 }
1514         }
1515
1516         /*
1517          * XXX: Remove this reset once proper hand-over from firmware to
1518          * kernel is possible.
1519          */
1520         err = reset_control_assert(sor->rst);
1521         if (err < 0) {
1522                 dev_err(sor->dev, "failed to assert SOR reset: %d\n", err);
1523                 return err;
1524         }
1525
1526         err = clk_prepare_enable(sor->clk);
1527         if (err < 0) {
1528                 dev_err(sor->dev, "failed to enable clock: %d\n", err);
1529                 return err;
1530         }
1531
1532         usleep_range(1000, 3000);
1533
1534         err = reset_control_deassert(sor->rst);
1535         if (err < 0) {
1536                 dev_err(sor->dev, "failed to deassert SOR reset: %d\n", err);
1537                 return err;
1538         }
1539
1540         err = clk_prepare_enable(sor->clk_safe);
1541         if (err < 0)
1542                 return err;
1543
1544         err = clk_prepare_enable(sor->clk_dp);
1545         if (err < 0)
1546                 return err;
1547
1548         return 0;
1549 }
1550
1551 static int tegra_sor_exit(struct host1x_client *client)
1552 {
1553         struct tegra_sor *sor = host1x_client_to_sor(client);
1554         int err;
1555
1556         tegra_output_exit(&sor->output);
1557
1558         if (sor->dpaux) {
1559                 err = tegra_dpaux_detach(sor->dpaux);
1560                 if (err < 0) {
1561                         dev_err(sor->dev, "failed to detach DP: %d\n", err);
1562                         return err;
1563                 }
1564         }
1565
1566         clk_disable_unprepare(sor->clk_safe);
1567         clk_disable_unprepare(sor->clk_dp);
1568         clk_disable_unprepare(sor->clk);
1569
1570         if (IS_ENABLED(CONFIG_DEBUG_FS))
1571                 tegra_sor_debugfs_exit(sor);
1572
1573         return 0;
1574 }
1575
1576 static const struct host1x_client_ops sor_client_ops = {
1577         .init = tegra_sor_init,
1578         .exit = tegra_sor_exit,
1579 };
1580
1581 static int tegra_sor_probe(struct platform_device *pdev)
1582 {
1583         struct device_node *np;
1584         struct tegra_sor *sor;
1585         struct resource *regs;
1586         int err;
1587
1588         sor = devm_kzalloc(&pdev->dev, sizeof(*sor), GFP_KERNEL);
1589         if (!sor)
1590                 return -ENOMEM;
1591
1592         sor->output.dev = sor->dev = &pdev->dev;
1593
1594         np = of_parse_phandle(pdev->dev.of_node, "nvidia,dpaux", 0);
1595         if (np) {
1596                 sor->dpaux = tegra_dpaux_find_by_of_node(np);
1597                 of_node_put(np);
1598
1599                 if (!sor->dpaux)
1600                         return -EPROBE_DEFER;
1601         }
1602
1603         err = tegra_output_probe(&sor->output);
1604         if (err < 0)
1605                 return err;
1606
1607         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1608         sor->regs = devm_ioremap_resource(&pdev->dev, regs);
1609         if (IS_ERR(sor->regs))
1610                 return PTR_ERR(sor->regs);
1611
1612         sor->rst = devm_reset_control_get(&pdev->dev, "sor");
1613         if (IS_ERR(sor->rst))
1614                 return PTR_ERR(sor->rst);
1615
1616         sor->clk = devm_clk_get(&pdev->dev, NULL);
1617         if (IS_ERR(sor->clk))
1618                 return PTR_ERR(sor->clk);
1619
1620         sor->clk_parent = devm_clk_get(&pdev->dev, "parent");
1621         if (IS_ERR(sor->clk_parent))
1622                 return PTR_ERR(sor->clk_parent);
1623
1624         sor->clk_safe = devm_clk_get(&pdev->dev, "safe");
1625         if (IS_ERR(sor->clk_safe))
1626                 return PTR_ERR(sor->clk_safe);
1627
1628         sor->clk_dp = devm_clk_get(&pdev->dev, "dp");
1629         if (IS_ERR(sor->clk_dp))
1630                 return PTR_ERR(sor->clk_dp);
1631
1632         INIT_LIST_HEAD(&sor->client.list);
1633         sor->client.ops = &sor_client_ops;
1634         sor->client.dev = &pdev->dev;
1635
1636         mutex_init(&sor->lock);
1637
1638         err = host1x_client_register(&sor->client);
1639         if (err < 0) {
1640                 dev_err(&pdev->dev, "failed to register host1x client: %d\n",
1641                         err);
1642                 return err;
1643         }
1644
1645         platform_set_drvdata(pdev, sor);
1646
1647         return 0;
1648 }
1649
1650 static int tegra_sor_remove(struct platform_device *pdev)
1651 {
1652         struct tegra_sor *sor = platform_get_drvdata(pdev);
1653         int err;
1654
1655         err = host1x_client_unregister(&sor->client);
1656         if (err < 0) {
1657                 dev_err(&pdev->dev, "failed to unregister host1x client: %d\n",
1658                         err);
1659                 return err;
1660         }
1661
1662         tegra_output_remove(&sor->output);
1663
1664         return 0;
1665 }
1666
1667 static const struct of_device_id tegra_sor_of_match[] = {
1668         { .compatible = "nvidia,tegra124-sor", },
1669         { },
1670 };
1671 MODULE_DEVICE_TABLE(of, tegra_sor_of_match);
1672
1673 struct platform_driver tegra_sor_driver = {
1674         .driver = {
1675                 .name = "tegra-sor",
1676                 .of_match_table = tegra_sor_of_match,
1677         },
1678         .probe = tegra_sor_probe,
1679         .remove = tegra_sor_remove,
1680 };