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