drivers/gpu/drm/ast/ast_mode.c

   1 /*
   2  * Copyright 2012 Red Hat Inc.
   3  * Parts based on xf86-video-ast
   4  * Copyright (c) 2005 ASPEED Technology Inc.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  18  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  19  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  20  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * The above copyright notice and this permission notice (including the
  23  * next paragraph) shall be included in all copies or substantial portions
  24  * of the Software.
  25  *
  26  */
  27 /*
  28  * Authors: Dave Airlie <[email protected]>
  29  */
  30
  31 #include <linux/export.h>
  32 #include <linux/pci.h>
  33
  34 #include <drm/drm_atomic.h>
  35 #include <drm/drm_atomic_helper.h>
  36 #include <drm/drm_atomic_state_helper.h>
  37 #include <drm/drm_crtc.h>
  38 #include <drm/drm_damage_helper.h>
  39 #include <drm/drm_edid.h>
  40 #include <drm/drm_format_helper.h>
  41 #include <drm/drm_fourcc.h>
  42 #include <drm/drm_gem_atomic_helper.h>
  43 #include <drm/drm_gem_framebuffer_helper.h>
  44 #include <drm/drm_gem_shmem_helper.h>
  45 #include <drm/drm_managed.h>
  46 #include <drm/drm_panic.h>
  47 #include <drm/drm_probe_helper.h>
  48
  49 #include "ast_ddc.h"
  50 #include "ast_drv.h"
  51 #include "ast_tables.h"
  52
  53 #define AST_LUT_SIZE 256
  54
  55 static inline void ast_load_palette_index(struct ast_device *ast,
  56                                      u8 index, u8 red, u8 green,
  57                                      u8 blue)
  58 {
  59         ast_io_write8(ast, AST_IO_VGADWR, index);
  60         ast_io_read8(ast, AST_IO_VGASRI);
  61         ast_io_write8(ast, AST_IO_VGAPDR, red);
  62         ast_io_read8(ast, AST_IO_VGASRI);
  63         ast_io_write8(ast, AST_IO_VGAPDR, green);
  64         ast_io_read8(ast, AST_IO_VGASRI);
  65         ast_io_write8(ast, AST_IO_VGAPDR, blue);
  66         ast_io_read8(ast, AST_IO_VGASRI);
  67 }
  68
  69 static void ast_crtc_set_gamma_linear(struct ast_device *ast,
  70                                       const struct drm_format_info *format)
  71 {
  72         int i;
  73
  74         switch (format->format) {
  75         case DRM_FORMAT_C8: /* In this case, gamma table is used as color palette */
  76         case DRM_FORMAT_RGB565:
  77         case DRM_FORMAT_XRGB8888:
  78                 for (i = 0; i < AST_LUT_SIZE; i++)
  79                         ast_load_palette_index(ast, i, i, i, i);
  80                 break;
  81         default:
  82                 drm_warn_once(&ast->base, "Unsupported format %p4cc for gamma correction\n",
  83                               &format->format);
  84                 break;
  85         }
  86 }
  87
  88 static void ast_crtc_set_gamma(struct ast_device *ast,
  89                                const struct drm_format_info *format,
  90                                struct drm_color_lut *lut)
  91 {
  92         int i;
  93
  94         switch (format->format) {
  95         case DRM_FORMAT_C8: /* In this case, gamma table is used as color palette */
  96         case DRM_FORMAT_RGB565:
  97         case DRM_FORMAT_XRGB8888:
  98                 for (i = 0; i < AST_LUT_SIZE; i++)
  99                         ast_load_palette_index(ast, i,
 100                                                lut[i].red >> 8,
 101                                                lut[i].green >> 8,
 102                                                lut[i].blue >> 8);
 103                 break;
 104         default:
 105                 drm_warn_once(&ast->base, "Unsupported format %p4cc for gamma correction\n",
 106                               &format->format);
 107                 break;
 108         }
 109 }
 110
 111 static bool ast_get_vbios_mode_info(const struct drm_format_info *format,
 112                                     const struct drm_display_mode *mode,
 113                                     struct drm_display_mode *adjusted_mode,
 114                                     struct ast_vbios_mode_info *vbios_mode)
 115 {
 116         u32 refresh_rate_index = 0, refresh_rate;
 117         const struct ast_vbios_enhtable *best = NULL;
 118         u32 hborder, vborder;
 119         bool check_sync;
 120
 121         switch (format->cpp[0] * 8) {
 122         case 8:
 123                 vbios_mode->std_table = &vbios_stdtable[VGAModeIndex];
 124                 break;
 125         case 16:
 126                 vbios_mode->std_table = &vbios_stdtable[HiCModeIndex];
 127                 break;
 128         case 24:
 129         case 32:
 130                 vbios_mode->std_table = &vbios_stdtable[TrueCModeIndex];
 131                 break;
 132         default:
 133                 return false;
 134         }
 135
 136         switch (mode->crtc_hdisplay) {
 137         case 640:
 138                 vbios_mode->enh_table = &res_640x480[refresh_rate_index];
 139                 break;
 140         case 800:
 141                 vbios_mode->enh_table = &res_800x600[refresh_rate_index];
 142                 break;
 143         case 1024:
 144                 vbios_mode->enh_table = &res_1024x768[refresh_rate_index];
 145                 break;
 146         case 1152:
 147                 vbios_mode->enh_table = &res_1152x864[refresh_rate_index];
 148                 break;
 149         case 1280:
 150                 if (mode->crtc_vdisplay == 800)
 151                         vbios_mode->enh_table = &res_1280x800[refresh_rate_index];
 152                 else
 153                         vbios_mode->enh_table = &res_1280x1024[refresh_rate_index];
 154                 break;
 155         case 1360:
 156                 vbios_mode->enh_table = &res_1360x768[refresh_rate_index];
 157                 break;
 158         case 1440:
 159                 vbios_mode->enh_table = &res_1440x900[refresh_rate_index];
 160                 break;
 161         case 1600:
 162                 if (mode->crtc_vdisplay == 900)
 163                         vbios_mode->enh_table = &res_1600x900[refresh_rate_index];
 164                 else
 165                         vbios_mode->enh_table = &res_1600x1200[refresh_rate_index];
 166                 break;
 167         case 1680:
 168                 vbios_mode->enh_table = &res_1680x1050[refresh_rate_index];
 169                 break;
 170         case 1920:
 171                 if (mode->crtc_vdisplay == 1080)
 172                         vbios_mode->enh_table = &res_1920x1080[refresh_rate_index];
 173                 else
 174                         vbios_mode->enh_table = &res_1920x1200[refresh_rate_index];
 175                 break;
 176         default:
 177                 return false;
 178         }
 179
 180         refresh_rate = drm_mode_vrefresh(mode);
 181         check_sync = vbios_mode->enh_table->flags & WideScreenMode;
 182
 183         while (1) {
 184                 const struct ast_vbios_enhtable *loop = vbios_mode->enh_table;
 185
 186                 while (loop->refresh_rate != 0xff) {
 187                         if ((check_sync) &&
 188                             (((mode->flags & DRM_MODE_FLAG_NVSYNC)  &&
 189                               (loop->flags & PVSync))  ||
 190                              ((mode->flags & DRM_MODE_FLAG_PVSYNC)  &&
 191                               (loop->flags & NVSync))  ||
 192                              ((mode->flags & DRM_MODE_FLAG_NHSYNC)  &&
 193                               (loop->flags & PHSync))  ||
 194                              ((mode->flags & DRM_MODE_FLAG_PHSYNC)  &&
 195                               (loop->flags & NHSync)))) {
 196                                 loop++;
 197                                 continue;
 198                         }
 199                         if (loop->refresh_rate <= refresh_rate
 200                             && (!best || loop->refresh_rate > best->refresh_rate))
 201                                 best = loop;
 202                         loop++;
 203                 }
 204                 if (best || !check_sync)
 205                         break;
 206                 check_sync = 0;
 207         }
 208
 209         if (best)
 210                 vbios_mode->enh_table = best;
 211
 212         hborder = (vbios_mode->enh_table->flags & HBorder) ? 8 : 0;
 213         vborder = (vbios_mode->enh_table->flags & VBorder) ? 8 : 0;
 214
 215         adjusted_mode->crtc_htotal = vbios_mode->enh_table->ht;
 216         adjusted_mode->crtc_hblank_start = vbios_mode->enh_table->hde + hborder;
 217         adjusted_mode->crtc_hblank_end = vbios_mode->enh_table->ht - hborder;
 218         adjusted_mode->crtc_hsync_start = vbios_mode->enh_table->hde + hborder +
 219                 vbios_mode->enh_table->hfp;
 220         adjusted_mode->crtc_hsync_end = (vbios_mode->enh_table->hde + hborder +
 221                                          vbios_mode->enh_table->hfp +
 222                                          vbios_mode->enh_table->hsync);
 223
 224         adjusted_mode->crtc_vtotal = vbios_mode->enh_table->vt;
 225         adjusted_mode->crtc_vblank_start = vbios_mode->enh_table->vde + vborder;
 226         adjusted_mode->crtc_vblank_end = vbios_mode->enh_table->vt - vborder;
 227         adjusted_mode->crtc_vsync_start = vbios_mode->enh_table->vde + vborder +
 228                 vbios_mode->enh_table->vfp;
 229         adjusted_mode->crtc_vsync_end = (vbios_mode->enh_table->vde + vborder +
 230                                          vbios_mode->enh_table->vfp +
 231                                          vbios_mode->enh_table->vsync);
 232
 233         return true;
 234 }
 235
 236 static void ast_set_vbios_color_reg(struct ast_device *ast,
 237                                     const struct drm_format_info *format,
 238                                     const struct ast_vbios_mode_info *vbios_mode)
 239 {
 240         u32 color_index;
 241
 242         switch (format->cpp[0]) {
 243         case 1:
 244                 color_index = VGAModeIndex - 1;
 245                 break;
 246         case 2:
 247                 color_index = HiCModeIndex;
 248                 break;
 249         case 3:
 250         case 4:
 251                 color_index = TrueCModeIndex;
 252                 break;
 253         default:
 254                 return;
 255         }
 256
 257         ast_set_index_reg(ast, AST_IO_VGACRI, 0x8c, (u8)((color_index & 0x0f) << 4));
 258
 259         ast_set_index_reg(ast, AST_IO_VGACRI, 0x91, 0x00);
 260
 261         if (vbios_mode->enh_table->flags & NewModeInfo) {
 262                 ast_set_index_reg(ast, AST_IO_VGACRI, 0x91, 0xa8);
 263                 ast_set_index_reg(ast, AST_IO_VGACRI, 0x92, format->cpp[0] * 8);
 264         }
 265 }
 266
 267 static void ast_set_vbios_mode_reg(struct ast_device *ast,
 268                                    const struct drm_display_mode *adjusted_mode,
 269                                    const struct ast_vbios_mode_info *vbios_mode)
 270 {
 271         u32 refresh_rate_index, mode_id;
 272
 273         refresh_rate_index = vbios_mode->enh_table->refresh_rate_index;
 274         mode_id = vbios_mode->enh_table->mode_id;
 275
 276         ast_set_index_reg(ast, AST_IO_VGACRI, 0x8d, refresh_rate_index & 0xff);
 277         ast_set_index_reg(ast, AST_IO_VGACRI, 0x8e, mode_id & 0xff);
 278
 279         ast_set_index_reg(ast, AST_IO_VGACRI, 0x91, 0x00);
 280
 281         if (vbios_mode->enh_table->flags & NewModeInfo) {
 282                 ast_set_index_reg(ast, AST_IO_VGACRI, 0x91, 0xa8);
 283                 ast_set_index_reg(ast, AST_IO_VGACRI, 0x93, adjusted_mode->clock / 1000);
 284                 ast_set_index_reg(ast, AST_IO_VGACRI, 0x94, adjusted_mode->crtc_hdisplay);
 285                 ast_set_index_reg(ast, AST_IO_VGACRI, 0x95, adjusted_mode->crtc_hdisplay >> 8);
 286                 ast_set_index_reg(ast, AST_IO_VGACRI, 0x96, adjusted_mode->crtc_vdisplay);
 287                 ast_set_index_reg(ast, AST_IO_VGACRI, 0x97, adjusted_mode->crtc_vdisplay >> 8);
 288         }
 289 }
 290
 291 static void ast_set_std_reg(struct ast_device *ast,
 292                             struct drm_display_mode *mode,
 293                             struct ast_vbios_mode_info *vbios_mode)
 294 {
 295         const struct ast_vbios_stdtable *stdtable;
 296         u32 i;
 297         u8 jreg;
 298
 299         stdtable = vbios_mode->std_table;
 300
 301         jreg = stdtable->misc;
 302         ast_io_write8(ast, AST_IO_VGAMR_W, jreg);
 303
 304         /* Set SEQ; except Screen Disable field */
 305         ast_set_index_reg(ast, AST_IO_VGASRI, 0x00, 0x03);
 306         ast_set_index_reg_mask(ast, AST_IO_VGASRI, 0x01, 0x20, stdtable->seq[0]);
 307         for (i = 1; i < 4; i++) {
 308                 jreg = stdtable->seq[i];
 309                 ast_set_index_reg(ast, AST_IO_VGASRI, (i + 1), jreg);
 310         }
 311
 312         /* Set CRTC; except base address and offset */
 313         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x11, 0x7f, 0x00);
 314         for (i = 0; i < 12; i++)
 315                 ast_set_index_reg(ast, AST_IO_VGACRI, i, stdtable->crtc[i]);
 316         for (i = 14; i < 19; i++)
 317                 ast_set_index_reg(ast, AST_IO_VGACRI, i, stdtable->crtc[i]);
 318         for (i = 20; i < 25; i++)
 319                 ast_set_index_reg(ast, AST_IO_VGACRI, i, stdtable->crtc[i]);
 320
 321         /* set AR */
 322         jreg = ast_io_read8(ast, AST_IO_VGAIR1_R);
 323         for (i = 0; i < 20; i++) {
 324                 jreg = stdtable->ar[i];
 325                 ast_io_write8(ast, AST_IO_VGAARI_W, (u8)i);
 326                 ast_io_write8(ast, AST_IO_VGAARI_W, jreg);
 327         }
 328         ast_io_write8(ast, AST_IO_VGAARI_W, 0x14);
 329         ast_io_write8(ast, AST_IO_VGAARI_W, 0x00);
 330
 331         jreg = ast_io_read8(ast, AST_IO_VGAIR1_R);
 332         ast_io_write8(ast, AST_IO_VGAARI_W, 0x20);
 333
 334         /* Set GR */
 335         for (i = 0; i < 9; i++)
 336                 ast_set_index_reg(ast, AST_IO_VGAGRI, i, stdtable->gr[i]);
 337 }
 338
 339 static void ast_set_crtc_reg(struct ast_device *ast,
 340                              struct drm_display_mode *mode,
 341                              struct ast_vbios_mode_info *vbios_mode)
 342 {
 343         u8 jreg05 = 0, jreg07 = 0, jreg09 = 0, jregAC = 0, jregAD = 0, jregAE = 0;
 344         u16 temp, precache = 0;
 345
 346         if ((IS_AST_GEN6(ast) || IS_AST_GEN7(ast)) &&
 347             (vbios_mode->enh_table->flags & AST2500PreCatchCRT))
 348                 precache = 40;
 349
 350         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x11, 0x7f, 0x00);
 351
 352         temp = (mode->crtc_htotal >> 3) - 5;
 353         if (temp & 0x100)
 354                 jregAC |= 0x01; /* HT D[8] */
 355         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x00, 0x00, temp);
 356
 357         temp = (mode->crtc_hdisplay >> 3) - 1;
 358         if (temp & 0x100)
 359                 jregAC |= 0x04; /* HDE D[8] */
 360         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x01, 0x00, temp);
 361
 362         temp = (mode->crtc_hblank_start >> 3) - 1;
 363         if (temp & 0x100)
 364                 jregAC |= 0x10; /* HBS D[8] */
 365         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x02, 0x00, temp);
 366
 367         temp = ((mode->crtc_hblank_end >> 3) - 1) & 0x7f;
 368         if (temp & 0x20)
 369                 jreg05 |= 0x80;  /* HBE D[5] */
 370         if (temp & 0x40)
 371                 jregAD |= 0x01;  /* HBE D[5] */
 372         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x03, 0xE0, (temp & 0x1f));
 373
 374         temp = ((mode->crtc_hsync_start-precache) >> 3) - 1;
 375         if (temp & 0x100)
 376                 jregAC |= 0x40; /* HRS D[5] */
 377         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x04, 0x00, temp);
 378
 379         temp = (((mode->crtc_hsync_end-precache) >> 3) - 1) & 0x3f;
 380         if (temp & 0x20)
 381                 jregAD |= 0x04; /* HRE D[5] */
 382         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x05, 0x60, (u8)((temp & 0x1f) | jreg05));
 383
 384         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xAC, 0x00, jregAC);
 385         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xAD, 0x00, jregAD);
 386
 387         // Workaround for HSync Time non octave pixels (1920x1080@60Hz HSync 44 pixels);
 388         if (IS_AST_GEN7(ast) && (mode->crtc_vdisplay == 1080))
 389                 ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xFC, 0xFD, 0x02);
 390         else
 391                 ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xFC, 0xFD, 0x00);
 392
 393         /* vert timings */
 394         temp = (mode->crtc_vtotal) - 2;
 395         if (temp & 0x100)
 396                 jreg07 |= 0x01;
 397         if (temp & 0x200)
 398                 jreg07 |= 0x20;
 399         if (temp & 0x400)
 400                 jregAE |= 0x01;
 401         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x06, 0x00, temp);
 402
 403         temp = (mode->crtc_vsync_start) - 1;
 404         if (temp & 0x100)
 405                 jreg07 |= 0x04;
 406         if (temp & 0x200)
 407                 jreg07 |= 0x80;
 408         if (temp & 0x400)
 409                 jregAE |= 0x08;
 410         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x10, 0x00, temp);
 411
 412         temp = (mode->crtc_vsync_end - 1) & 0x3f;
 413         if (temp & 0x10)
 414                 jregAE |= 0x20;
 415         if (temp & 0x20)
 416                 jregAE |= 0x40;
 417         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x11, 0x70, temp & 0xf);
 418
 419         temp = mode->crtc_vdisplay - 1;
 420         if (temp & 0x100)
 421                 jreg07 |= 0x02;
 422         if (temp & 0x200)
 423                 jreg07 |= 0x40;
 424         if (temp & 0x400)
 425                 jregAE |= 0x02;
 426         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x12, 0x00, temp);
 427
 428         temp = mode->crtc_vblank_start - 1;
 429         if (temp & 0x100)
 430                 jreg07 |= 0x08;
 431         if (temp & 0x200)
 432                 jreg09 |= 0x20;
 433         if (temp & 0x400)
 434                 jregAE |= 0x04;
 435         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x15, 0x00, temp);
 436
 437         temp = mode->crtc_vblank_end - 1;
 438         if (temp & 0x100)
 439                 jregAE |= 0x10;
 440         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x16, 0x00, temp);
 441
 442         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x07, 0x00, jreg07);
 443         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x09, 0xdf, jreg09);
 444         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xAE, 0x00, (jregAE | 0x80));
 445
 446         if (precache)
 447                 ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xb6, 0x3f, 0x80);
 448         else
 449                 ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xb6, 0x3f, 0x00);
 450
 451         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0x11, 0x7f, 0x80);
 452 }
 453
 454 static void ast_set_offset_reg(struct ast_device *ast,
 455                                struct drm_framebuffer *fb)
 456 {
 457         u16 offset;
 458
 459         offset = fb->pitches[0] >> 3;
 460         ast_set_index_reg(ast, AST_IO_VGACRI, 0x13, (offset & 0xff));
 461         ast_set_index_reg(ast, AST_IO_VGACRI, 0xb0, (offset >> 8) & 0x3f);
 462 }
 463
 464 static void ast_set_dclk_reg(struct ast_device *ast,
 465                              struct drm_display_mode *mode,
 466                              struct ast_vbios_mode_info *vbios_mode)
 467 {
 468         const struct ast_vbios_dclk_info *clk_info;
 469
 470         if (IS_AST_GEN6(ast) || IS_AST_GEN7(ast))
 471                 clk_info = &dclk_table_ast2500[vbios_mode->enh_table->dclk_index];
 472         else
 473                 clk_info = &dclk_table[vbios_mode->enh_table->dclk_index];
 474
 475         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xc0, 0x00, clk_info->param1);
 476         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xc1, 0x00, clk_info->param2);
 477         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xbb, 0x0f,
 478                                (clk_info->param3 & 0xc0) |
 479                                ((clk_info->param3 & 0x3) << 4));
 480 }
 481
 482 static void ast_set_color_reg(struct ast_device *ast,
 483                               const struct drm_format_info *format)
 484 {
 485         u8 jregA0 = 0, jregA3 = 0, jregA8 = 0;
 486
 487         switch (format->cpp[0] * 8) {
 488         case 8:
 489                 jregA0 = 0x70;
 490                 jregA3 = 0x01;
 491                 jregA8 = 0x00;
 492                 break;
 493         case 15:
 494         case 16:
 495                 jregA0 = 0x70;
 496                 jregA3 = 0x04;
 497                 jregA8 = 0x02;
 498                 break;
 499         case 32:
 500                 jregA0 = 0x70;
 501                 jregA3 = 0x08;
 502                 jregA8 = 0x02;
 503                 break;
 504         }
 505
 506         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xa0, 0x8f, jregA0);
 507         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xa3, 0xf0, jregA3);
 508         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xa8, 0xfd, jregA8);
 509 }
 510
 511 static void ast_set_crtthd_reg(struct ast_device *ast)
 512 {
 513         /* Set Threshold */
 514         if (IS_AST_GEN7(ast)) {
 515                 ast_set_index_reg(ast, AST_IO_VGACRI, 0xa7, 0xe0);
 516                 ast_set_index_reg(ast, AST_IO_VGACRI, 0xa6, 0xa0);
 517         } else if (IS_AST_GEN6(ast) || IS_AST_GEN5(ast) || IS_AST_GEN4(ast)) {
 518                 ast_set_index_reg(ast, AST_IO_VGACRI, 0xa7, 0x78);
 519                 ast_set_index_reg(ast, AST_IO_VGACRI, 0xa6, 0x60);
 520         } else if (IS_AST_GEN3(ast) || IS_AST_GEN2(ast)) {
 521                 ast_set_index_reg(ast, AST_IO_VGACRI, 0xa7, 0x3f);
 522                 ast_set_index_reg(ast, AST_IO_VGACRI, 0xa6, 0x2f);
 523         } else {
 524                 ast_set_index_reg(ast, AST_IO_VGACRI, 0xa7, 0x2f);
 525                 ast_set_index_reg(ast, AST_IO_VGACRI, 0xa6, 0x1f);
 526         }
 527 }
 528
 529 static void ast_set_sync_reg(struct ast_device *ast,
 530                              struct drm_display_mode *mode,
 531                              struct ast_vbios_mode_info *vbios_mode)
 532 {
 533         u8 jreg;
 534
 535         jreg  = ast_io_read8(ast, AST_IO_VGAMR_R);
 536         jreg &= ~0xC0;
 537         if (vbios_mode->enh_table->flags & NVSync)
 538                 jreg |= 0x80;
 539         if (vbios_mode->enh_table->flags & NHSync)
 540                 jreg |= 0x40;
 541         ast_io_write8(ast, AST_IO_VGAMR_W, jreg);
 542 }
 543
 544 static void ast_set_start_address_crt1(struct ast_device *ast,
 545                                        unsigned int offset)
 546 {
 547         u32 addr;
 548
 549         addr = offset >> 2;
 550         ast_set_index_reg(ast, AST_IO_VGACRI, 0x0d, (u8)(addr & 0xff));
 551         ast_set_index_reg(ast, AST_IO_VGACRI, 0x0c, (u8)((addr >> 8) & 0xff));
 552         ast_set_index_reg(ast, AST_IO_VGACRI, 0xaf, (u8)((addr >> 16) & 0xff));
 553
 554 }
 555
 556 static void ast_wait_for_vretrace(struct ast_device *ast)
 557 {
 558         unsigned long timeout = jiffies + HZ;
 559         u8 vgair1;
 560
 561         do {
 562                 vgair1 = ast_io_read8(ast, AST_IO_VGAIR1_R);
 563         } while (!(vgair1 & AST_IO_VGAIR1_VREFRESH) && time_before(jiffies, timeout));
 564 }
 565
 566 /*
 567  * Planes
 568  */
 569
 570 static int ast_plane_init(struct drm_device *dev, struct ast_plane *ast_plane,
 571                           void __iomem *vaddr, u64 offset, unsigned long size,
 572                           uint32_t possible_crtcs,
 573                           const struct drm_plane_funcs *funcs,
 574                           const uint32_t *formats, unsigned int format_count,
 575                           const uint64_t *format_modifiers,
 576                           enum drm_plane_type type)
 577 {
 578         struct drm_plane *plane = &ast_plane->base;
 579
 580         ast_plane->vaddr = vaddr;
 581         ast_plane->offset = offset;
 582         ast_plane->size = size;
 583
 584         return drm_universal_plane_init(dev, plane, possible_crtcs, funcs,
 585                                         formats, format_count, format_modifiers,
 586                                         type, NULL);
 587 }
 588
 589 /*
 590  * Primary plane
 591  */
 592
 593 static const uint32_t ast_primary_plane_formats[] = {
 594         DRM_FORMAT_XRGB8888,
 595         DRM_FORMAT_RGB565,
 596         DRM_FORMAT_C8,
 597 };
 598
 599 static int ast_primary_plane_helper_atomic_check(struct drm_plane *plane,
 600                                                  struct drm_atomic_state *state)
 601 {
 602         struct drm_device *dev = plane->dev;
 603         struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
 604         struct drm_crtc_state *new_crtc_state = NULL;
 605         struct ast_crtc_state *new_ast_crtc_state;
 606         int ret;
 607
 608         if (new_plane_state->crtc)
 609                 new_crtc_state = drm_atomic_get_new_crtc_state(state, new_plane_state->crtc);
 610
 611         ret = drm_atomic_helper_check_plane_state(new_plane_state, new_crtc_state,
 612                                                   DRM_PLANE_NO_SCALING,
 613                                                   DRM_PLANE_NO_SCALING,
 614                                                   false, true);
 615         if (ret) {
 616                 return ret;
 617         } else if (!new_plane_state->visible) {
 618                 if (drm_WARN_ON(dev, new_plane_state->crtc)) /* cannot legally happen */
 619                         return -EINVAL;
 620                 else
 621                         return 0;
 622         }
 623
 624         new_ast_crtc_state = to_ast_crtc_state(new_crtc_state);
 625
 626         new_ast_crtc_state->format = new_plane_state->fb->format;
 627
 628         return 0;
 629 }
 630
 631 static void ast_handle_damage(struct ast_plane *ast_plane, struct iosys_map *src,
 632                               struct drm_framebuffer *fb,
 633                               const struct drm_rect *clip)
 634 {
 635         struct iosys_map dst = IOSYS_MAP_INIT_VADDR_IOMEM(ast_plane->vaddr);
 636
 637         iosys_map_incr(&dst, drm_fb_clip_offset(fb->pitches[0], fb->format, clip));
 638         drm_fb_memcpy(&dst, fb->pitches, src, fb, clip);
 639 }
 640
 641 static void ast_primary_plane_helper_atomic_update(struct drm_plane *plane,
 642                                                    struct drm_atomic_state *state)
 643 {
 644         struct drm_device *dev = plane->dev;
 645         struct ast_device *ast = to_ast_device(dev);
 646         struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
 647         struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state);
 648         struct drm_framebuffer *fb = plane_state->fb;
 649         struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
 650         struct drm_framebuffer *old_fb = old_plane_state->fb;
 651         struct ast_plane *ast_plane = to_ast_plane(plane);
 652         struct drm_crtc *crtc = plane_state->crtc;
 653         struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
 654         struct drm_rect damage;
 655         struct drm_atomic_helper_damage_iter iter;
 656
 657         if (!old_fb || (fb->format != old_fb->format) || crtc_state->mode_changed) {
 658                 struct ast_crtc_state *ast_crtc_state = to_ast_crtc_state(crtc_state);
 659                 struct ast_vbios_mode_info *vbios_mode_info = &ast_crtc_state->vbios_mode_info;
 660
 661                 ast_set_color_reg(ast, fb->format);
 662                 ast_set_vbios_color_reg(ast, fb->format, vbios_mode_info);
 663         }
 664
 665         drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);
 666         drm_atomic_for_each_plane_damage(&iter, &damage) {
 667                 ast_handle_damage(ast_plane, shadow_plane_state->data, fb, &damage);
 668         }
 669
 670         /*
 671          * Some BMCs stop scanning out the video signal after the driver
 672          * reprogrammed the offset. This stalls display output for several
 673          * seconds and makes the display unusable. Therefore only update
 674          * the offset if it changes.
 675          */
 676         if (!old_fb || old_fb->pitches[0] != fb->pitches[0])
 677                 ast_set_offset_reg(ast, fb);
 678 }
 679
 680 static void ast_primary_plane_helper_atomic_enable(struct drm_plane *plane,
 681                                                    struct drm_atomic_state *state)
 682 {
 683         struct ast_device *ast = to_ast_device(plane->dev);
 684         struct ast_plane *ast_plane = to_ast_plane(plane);
 685
 686         /*
 687          * Some BMCs stop scanning out the video signal after the driver
 688          * reprogrammed the scanout address. This stalls display
 689          * output for several seconds and makes the display unusable.
 690          * Therefore only reprogram the address after enabling the plane.
 691          */
 692         ast_set_start_address_crt1(ast, (u32)ast_plane->offset);
 693 }
 694
 695 static void ast_primary_plane_helper_atomic_disable(struct drm_plane *plane,
 696                                                     struct drm_atomic_state *state)
 697 {
 698         /*
 699          * Keep this empty function to avoid calling
 700          * atomic_update when disabling the plane.
 701          */
 702 }
 703
 704 static int ast_primary_plane_helper_get_scanout_buffer(struct drm_plane *plane,
 705                                                        struct drm_scanout_buffer *sb)
 706 {
 707         struct ast_plane *ast_plane = to_ast_plane(plane);
 708
 709         if (plane->state && plane->state->fb && ast_plane->vaddr) {
 710                 sb->format = plane->state->fb->format;
 711                 sb->width = plane->state->fb->width;
 712                 sb->height = plane->state->fb->height;
 713                 sb->pitch[0] = plane->state->fb->pitches[0];
 714                 iosys_map_set_vaddr_iomem(&sb->map[0], ast_plane->vaddr);
 715                 return 0;
 716         }
 717         return -ENODEV;
 718 }
 719
 720 static const struct drm_plane_helper_funcs ast_primary_plane_helper_funcs = {
 721         DRM_GEM_SHADOW_PLANE_HELPER_FUNCS,
 722         .atomic_check = ast_primary_plane_helper_atomic_check,
 723         .atomic_update = ast_primary_plane_helper_atomic_update,
 724         .atomic_enable = ast_primary_plane_helper_atomic_enable,
 725         .atomic_disable = ast_primary_plane_helper_atomic_disable,
 726         .get_scanout_buffer = ast_primary_plane_helper_get_scanout_buffer,
 727 };
 728
 729 static const struct drm_plane_funcs ast_primary_plane_funcs = {
 730         .update_plane = drm_atomic_helper_update_plane,
 731         .disable_plane = drm_atomic_helper_disable_plane,
 732         .destroy = drm_plane_cleanup,
 733         DRM_GEM_SHADOW_PLANE_FUNCS,
 734 };
 735
 736 static int ast_primary_plane_init(struct ast_device *ast)
 737 {
 738         struct drm_device *dev = &ast->base;
 739         struct ast_plane *ast_primary_plane = &ast->primary_plane;
 740         struct drm_plane *primary_plane = &ast_primary_plane->base;
 741         void __iomem *vaddr = ast->vram;
 742         u64 offset = 0; /* with shmem, the primary plane is always at offset 0 */
 743         unsigned long cursor_size = roundup(AST_HWC_SIZE + AST_HWC_SIGNATURE_SIZE, PAGE_SIZE);
 744         unsigned long size = ast->vram_fb_available - cursor_size;
 745         int ret;
 746
 747         ret = ast_plane_init(dev, ast_primary_plane, vaddr, offset, size,
 748                              0x01, &ast_primary_plane_funcs,
 749                              ast_primary_plane_formats, ARRAY_SIZE(ast_primary_plane_formats),
 750                              NULL, DRM_PLANE_TYPE_PRIMARY);
 751         if (ret) {
 752                 drm_err(dev, "ast_plane_init() failed: %d\n", ret);
 753                 return ret;
 754         }
 755         drm_plane_helper_add(primary_plane, &ast_primary_plane_helper_funcs);
 756         drm_plane_enable_fb_damage_clips(primary_plane);
 757
 758         return 0;
 759 }
 760
 761 /*
 762  * Cursor plane
 763  */
 764
 765 static void ast_update_cursor_image(u8 __iomem *dst, const u8 *src, int width, int height)
 766 {
 767         union {
 768                 u32 ul;
 769                 u8 b[4];
 770         } srcdata32[2], data32;
 771         union {
 772                 u16 us;
 773                 u8 b[2];
 774         } data16;
 775         u32 csum = 0;
 776         s32 alpha_dst_delta, last_alpha_dst_delta;
 777         u8 __iomem *dstxor;
 778         const u8 *srcxor;
 779         int i, j;
 780         u32 per_pixel_copy, two_pixel_copy;
 781
 782         alpha_dst_delta = AST_MAX_HWC_WIDTH << 1;
 783         last_alpha_dst_delta = alpha_dst_delta - (width << 1);
 784
 785         srcxor = src;
 786         dstxor = (u8 *)dst + last_alpha_dst_delta + (AST_MAX_HWC_HEIGHT - height) * alpha_dst_delta;
 787         per_pixel_copy = width & 1;
 788         two_pixel_copy = width >> 1;
 789
 790         for (j = 0; j < height; j++) {
 791                 for (i = 0; i < two_pixel_copy; i++) {
 792                         srcdata32[0].ul = *((u32 *)srcxor) & 0xf0f0f0f0;
 793                         srcdata32[1].ul = *((u32 *)(srcxor + 4)) & 0xf0f0f0f0;
 794                         data32.b[0] = srcdata32[0].b[1] | (srcdata32[0].b[0] >> 4);
 795                         data32.b[1] = srcdata32[0].b[3] | (srcdata32[0].b[2] >> 4);
 796                         data32.b[2] = srcdata32[1].b[1] | (srcdata32[1].b[0] >> 4);
 797                         data32.b[3] = srcdata32[1].b[3] | (srcdata32[1].b[2] >> 4);
 798
 799                         writel(data32.ul, dstxor);
 800                         csum += data32.ul;
 801
 802                         dstxor += 4;
 803                         srcxor += 8;
 804
 805                 }
 806
 807                 for (i = 0; i < per_pixel_copy; i++) {
 808                         srcdata32[0].ul = *((u32 *)srcxor) & 0xf0f0f0f0;
 809                         data16.b[0] = srcdata32[0].b[1] | (srcdata32[0].b[0] >> 4);
 810                         data16.b[1] = srcdata32[0].b[3] | (srcdata32[0].b[2] >> 4);
 811                         writew(data16.us, dstxor);
 812                         csum += (u32)data16.us;
 813
 814                         dstxor += 2;
 815                         srcxor += 4;
 816                 }
 817                 dstxor += last_alpha_dst_delta;
 818         }
 819
 820         /* write checksum + signature */
 821         dst += AST_HWC_SIZE;
 822         writel(csum, dst);
 823         writel(width, dst + AST_HWC_SIGNATURE_SizeX);
 824         writel(height, dst + AST_HWC_SIGNATURE_SizeY);
 825         writel(0, dst + AST_HWC_SIGNATURE_HOTSPOTX);
 826         writel(0, dst + AST_HWC_SIGNATURE_HOTSPOTY);
 827 }
 828
 829 static void ast_set_cursor_base(struct ast_device *ast, u64 address)
 830 {
 831         u8 addr0 = (address >> 3) & 0xff;
 832         u8 addr1 = (address >> 11) & 0xff;
 833         u8 addr2 = (address >> 19) & 0xff;
 834
 835         ast_set_index_reg(ast, AST_IO_VGACRI, 0xc8, addr0);
 836         ast_set_index_reg(ast, AST_IO_VGACRI, 0xc9, addr1);
 837         ast_set_index_reg(ast, AST_IO_VGACRI, 0xca, addr2);
 838 }
 839
 840 static void ast_set_cursor_location(struct ast_device *ast, u16 x, u16 y,
 841                                     u8 x_offset, u8 y_offset)
 842 {
 843         u8 x0 = (x & 0x00ff);
 844         u8 x1 = (x & 0x0f00) >> 8;
 845         u8 y0 = (y & 0x00ff);
 846         u8 y1 = (y & 0x0700) >> 8;
 847
 848         ast_set_index_reg(ast, AST_IO_VGACRI, 0xc2, x_offset);
 849         ast_set_index_reg(ast, AST_IO_VGACRI, 0xc3, y_offset);
 850         ast_set_index_reg(ast, AST_IO_VGACRI, 0xc4, x0);
 851         ast_set_index_reg(ast, AST_IO_VGACRI, 0xc5, x1);
 852         ast_set_index_reg(ast, AST_IO_VGACRI, 0xc6, y0);
 853         ast_set_index_reg(ast, AST_IO_VGACRI, 0xc7, y1);
 854 }
 855
 856 static void ast_set_cursor_enabled(struct ast_device *ast, bool enabled)
 857 {
 858         static const u8 mask = (u8)~(AST_IO_VGACRCB_HWC_16BPP |
 859                                      AST_IO_VGACRCB_HWC_ENABLED);
 860
 861         u8 vgacrcb = AST_IO_VGACRCB_HWC_16BPP;
 862
 863         if (enabled)
 864                 vgacrcb |= AST_IO_VGACRCB_HWC_ENABLED;
 865
 866         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xcb, mask, vgacrcb);
 867 }
 868
 869 static const uint32_t ast_cursor_plane_formats[] = {
 870         DRM_FORMAT_ARGB8888,
 871 };
 872
 873 static int ast_cursor_plane_helper_atomic_check(struct drm_plane *plane,
 874                                                 struct drm_atomic_state *state)
 875 {
 876         struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
 877         struct drm_framebuffer *new_fb = new_plane_state->fb;
 878         struct drm_crtc_state *new_crtc_state = NULL;
 879         int ret;
 880
 881         if (new_plane_state->crtc)
 882                 new_crtc_state = drm_atomic_get_new_crtc_state(state, new_plane_state->crtc);
 883
 884         ret = drm_atomic_helper_check_plane_state(new_plane_state, new_crtc_state,
 885                                                   DRM_PLANE_NO_SCALING,
 886                                                   DRM_PLANE_NO_SCALING,
 887                                                   true, true);
 888         if (ret || !new_plane_state->visible)
 889                 return ret;
 890
 891         if (new_fb->width > AST_MAX_HWC_WIDTH || new_fb->height > AST_MAX_HWC_HEIGHT)
 892                 return -EINVAL;
 893
 894         return 0;
 895 }
 896
 897 static void ast_cursor_plane_helper_atomic_update(struct drm_plane *plane,
 898                                                   struct drm_atomic_state *state)
 899 {
 900         struct ast_plane *ast_plane = to_ast_plane(plane);
 901         struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
 902         struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state);
 903         struct drm_framebuffer *fb = plane_state->fb;
 904         struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
 905         struct ast_device *ast = to_ast_device(plane->dev);
 906         struct iosys_map src_map = shadow_plane_state->data[0];
 907         struct drm_rect damage;
 908         const u8 *src = src_map.vaddr; /* TODO: Use mapping abstraction properly */
 909         u64 dst_off = ast_plane->offset;
 910         u8 __iomem *dst = ast_plane->vaddr; /* TODO: Use mapping abstraction properly */
 911         u8 __iomem *sig = dst + AST_HWC_SIZE; /* TODO: Use mapping abstraction properly */
 912         unsigned int offset_x, offset_y;
 913         u16 x, y;
 914         u8 x_offset, y_offset;
 915
 916         /*
 917          * Do data transfer to hardware buffer and point the scanout
 918          * engine to the offset.
 919          */
 920
 921         if (drm_atomic_helper_damage_merged(old_plane_state, plane_state, &damage)) {
 922                 ast_update_cursor_image(dst, src, fb->width, fb->height);
 923                 ast_set_cursor_base(ast, dst_off);
 924         }
 925
 926         /*
 927          * Update location in HWC signature and registers.
 928          */
 929
 930         writel(plane_state->crtc_x, sig + AST_HWC_SIGNATURE_X);
 931         writel(plane_state->crtc_y, sig + AST_HWC_SIGNATURE_Y);
 932
 933         offset_x = AST_MAX_HWC_WIDTH - fb->width;
 934         offset_y = AST_MAX_HWC_HEIGHT - fb->height;
 935
 936         if (plane_state->crtc_x < 0) {
 937                 x_offset = (-plane_state->crtc_x) + offset_x;
 938                 x = 0;
 939         } else {
 940                 x_offset = offset_x;
 941                 x = plane_state->crtc_x;
 942         }
 943         if (plane_state->crtc_y < 0) {
 944                 y_offset = (-plane_state->crtc_y) + offset_y;
 945                 y = 0;
 946         } else {
 947                 y_offset = offset_y;
 948                 y = plane_state->crtc_y;
 949         }
 950
 951         ast_set_cursor_location(ast, x, y, x_offset, y_offset);
 952
 953         /* Dummy write to enable HWC and make the HW pick-up the changes. */
 954         ast_set_cursor_enabled(ast, true);
 955 }
 956
 957 static void ast_cursor_plane_helper_atomic_disable(struct drm_plane *plane,
 958                                                    struct drm_atomic_state *state)
 959 {
 960         struct ast_device *ast = to_ast_device(plane->dev);
 961
 962         ast_set_cursor_enabled(ast, false);
 963 }
 964
 965 static const struct drm_plane_helper_funcs ast_cursor_plane_helper_funcs = {
 966         DRM_GEM_SHADOW_PLANE_HELPER_FUNCS,
 967         .atomic_check = ast_cursor_plane_helper_atomic_check,
 968         .atomic_update = ast_cursor_plane_helper_atomic_update,
 969         .atomic_disable = ast_cursor_plane_helper_atomic_disable,
 970 };
 971
 972 static const struct drm_plane_funcs ast_cursor_plane_funcs = {
 973         .update_plane = drm_atomic_helper_update_plane,
 974         .disable_plane = drm_atomic_helper_disable_plane,
 975         .destroy = drm_plane_cleanup,
 976         DRM_GEM_SHADOW_PLANE_FUNCS,
 977 };
 978
 979 static int ast_cursor_plane_init(struct ast_device *ast)
 980 {
 981         struct drm_device *dev = &ast->base;
 982         struct ast_plane *ast_cursor_plane = &ast->cursor_plane;
 983         struct drm_plane *cursor_plane = &ast_cursor_plane->base;
 984         size_t size;
 985         void __iomem *vaddr;
 986         u64 offset;
 987         int ret;
 988
 989         /*
 990          * Allocate backing storage for cursors. The BOs are permanently
 991          * pinned to the top end of the VRAM.
 992          */
 993
 994         size = roundup(AST_HWC_SIZE + AST_HWC_SIGNATURE_SIZE, PAGE_SIZE);
 995
 996         if (ast->vram_fb_available < size)
 997                 return -ENOMEM;
 998
 999         vaddr = ast->vram + ast->vram_fb_available - size;
1000         offset = ast->vram_fb_available - size;
1001
1002         ret = ast_plane_init(dev, ast_cursor_plane, vaddr, offset, size,
1003                              0x01, &ast_cursor_plane_funcs,
1004                              ast_cursor_plane_formats, ARRAY_SIZE(ast_cursor_plane_formats),
1005                              NULL, DRM_PLANE_TYPE_CURSOR);
1006         if (ret) {
1007                 drm_err(dev, "ast_plane_init() failed: %d\n", ret);
1008                 return ret;
1009         }
1010         drm_plane_helper_add(cursor_plane, &ast_cursor_plane_helper_funcs);
1011         drm_plane_enable_fb_damage_clips(cursor_plane);
1012
1013         ast->vram_fb_available -= size;
1014
1015         return 0;
1016 }
1017
1018 /*
1019  * CRTC
1020  */
1021
1022 static enum drm_mode_status
1023 ast_crtc_helper_mode_valid(struct drm_crtc *crtc, const struct drm_display_mode *mode)
1024 {
1025         struct ast_device *ast = to_ast_device(crtc->dev);
1026         enum drm_mode_status status;
1027         uint32_t jtemp;
1028
1029         if (ast->support_wide_screen) {
1030                 if ((mode->hdisplay == 1680) && (mode->vdisplay == 1050))
1031                         return MODE_OK;
1032                 if ((mode->hdisplay == 1280) && (mode->vdisplay == 800))
1033                         return MODE_OK;
1034                 if ((mode->hdisplay == 1440) && (mode->vdisplay == 900))
1035                         return MODE_OK;
1036                 if ((mode->hdisplay == 1360) && (mode->vdisplay == 768))
1037                         return MODE_OK;
1038                 if ((mode->hdisplay == 1600) && (mode->vdisplay == 900))
1039                         return MODE_OK;
1040                 if ((mode->hdisplay == 1152) && (mode->vdisplay == 864))
1041                         return MODE_OK;
1042
1043                 if ((ast->chip == AST2100) || // GEN2, but not AST1100 (?)
1044                     (ast->chip == AST2200) || // GEN3, but not AST2150 (?)
1045                     IS_AST_GEN4(ast) || IS_AST_GEN5(ast) ||
1046                     IS_AST_GEN6(ast) || IS_AST_GEN7(ast)) {
1047                         if ((mode->hdisplay == 1920) && (mode->vdisplay == 1080))
1048                                 return MODE_OK;
1049
1050                         if ((mode->hdisplay == 1920) && (mode->vdisplay == 1200)) {
1051                                 jtemp = ast_get_index_reg_mask(ast, AST_IO_VGACRI, 0xd1, 0xff);
1052                                 if (jtemp & 0x01)
1053                                         return MODE_NOMODE;
1054                                 else
1055                                         return MODE_OK;
1056                         }
1057                 }
1058         }
1059
1060         status = MODE_NOMODE;
1061
1062         switch (mode->hdisplay) {
1063         case 640:
1064                 if (mode->vdisplay == 480)
1065                         status = MODE_OK;
1066                 break;
1067         case 800:
1068                 if (mode->vdisplay == 600)
1069                         status = MODE_OK;
1070                 break;
1071         case 1024:
1072                 if (mode->vdisplay == 768)
1073                         status = MODE_OK;
1074                 break;
1075         case 1152:
1076                 if (mode->vdisplay == 864)
1077                         status = MODE_OK;
1078                 break;
1079         case 1280:
1080                 if (mode->vdisplay == 1024)
1081                         status = MODE_OK;
1082                 break;
1083         case 1600:
1084                 if (mode->vdisplay == 1200)
1085                         status = MODE_OK;
1086                 break;
1087         default:
1088                 break;
1089         }
1090
1091         return status;
1092 }
1093
1094 static void ast_crtc_helper_mode_set_nofb(struct drm_crtc *crtc)
1095 {
1096         struct drm_device *dev = crtc->dev;
1097         struct ast_device *ast = to_ast_device(dev);
1098         struct drm_crtc_state *crtc_state = crtc->state;
1099         struct ast_crtc_state *ast_crtc_state = to_ast_crtc_state(crtc_state);
1100         struct ast_vbios_mode_info *vbios_mode_info =
1101                 &ast_crtc_state->vbios_mode_info;
1102         struct drm_display_mode *adjusted_mode = &crtc_state->adjusted_mode;
1103
1104         /*
1105          * Ensure that no scanout takes place before reprogramming mode
1106          * and format registers.
1107          *
1108          * TODO: Get vblank interrupts working and remove this line.
1109          */
1110         ast_wait_for_vretrace(ast);
1111
1112         ast_set_vbios_mode_reg(ast, adjusted_mode, vbios_mode_info);
1113         ast_set_index_reg(ast, AST_IO_VGACRI, 0xa1, 0x06);
1114         ast_set_std_reg(ast, adjusted_mode, vbios_mode_info);
1115         ast_set_crtc_reg(ast, adjusted_mode, vbios_mode_info);
1116         ast_set_dclk_reg(ast, adjusted_mode, vbios_mode_info);
1117         ast_set_crtthd_reg(ast);
1118         ast_set_sync_reg(ast, adjusted_mode, vbios_mode_info);
1119 }
1120
1121 static int ast_crtc_helper_atomic_check(struct drm_crtc *crtc,
1122                                         struct drm_atomic_state *state)
1123 {
1124         struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
1125         struct drm_crtc_state *old_crtc_state = drm_atomic_get_old_crtc_state(state, crtc);
1126         struct ast_crtc_state *old_ast_crtc_state = to_ast_crtc_state(old_crtc_state);
1127         struct drm_device *dev = crtc->dev;
1128         struct ast_crtc_state *ast_state;
1129         const struct drm_format_info *format;
1130         bool succ;
1131         int ret;
1132
1133         if (!crtc_state->enable)
1134                 return 0;
1135
1136         ret = drm_atomic_helper_check_crtc_primary_plane(crtc_state);
1137         if (ret)
1138                 return ret;
1139
1140         ast_state = to_ast_crtc_state(crtc_state);
1141
1142         format = ast_state->format;
1143         if (drm_WARN_ON_ONCE(dev, !format))
1144                 return -EINVAL; /* BUG: We didn't set format in primary check(). */
1145
1146         /*
1147          * The gamma LUT has to be reloaded after changing the primary
1148          * plane's color format.
1149          */
1150         if (old_ast_crtc_state->format != format)
1151                 crtc_state->color_mgmt_changed = true;
1152
1153         if (crtc_state->color_mgmt_changed && crtc_state->gamma_lut) {
1154                 if (crtc_state->gamma_lut->length !=
1155                     AST_LUT_SIZE * sizeof(struct drm_color_lut)) {
1156                         drm_err(dev, "Wrong size for gamma_lut %zu\n",
1157                                 crtc_state->gamma_lut->length);
1158                         return -EINVAL;
1159                 }
1160         }
1161
1162         succ = ast_get_vbios_mode_info(format, &crtc_state->mode,
1163                                        &crtc_state->adjusted_mode,
1164                                        &ast_state->vbios_mode_info);
1165         if (!succ)
1166                 return -EINVAL;
1167
1168         return 0;
1169 }
1170
1171 static void
1172 ast_crtc_helper_atomic_flush(struct drm_crtc *crtc,
1173                              struct drm_atomic_state *state)
1174 {
1175         struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
1176                                                                           crtc);
1177         struct drm_device *dev = crtc->dev;
1178         struct ast_device *ast = to_ast_device(dev);
1179         struct ast_crtc_state *ast_crtc_state = to_ast_crtc_state(crtc_state);
1180
1181         /*
1182          * The gamma LUT has to be reloaded after changing the primary
1183          * plane's color format.
1184          */
1185         if (crtc_state->enable && crtc_state->color_mgmt_changed) {
1186                 if (crtc_state->gamma_lut)
1187                         ast_crtc_set_gamma(ast,
1188                                            ast_crtc_state->format,
1189                                            crtc_state->gamma_lut->data);
1190                 else
1191                         ast_crtc_set_gamma_linear(ast, ast_crtc_state->format);
1192         }
1193 }
1194
1195 static void ast_crtc_helper_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_state *state)
1196 {
1197         struct ast_device *ast = to_ast_device(crtc->dev);
1198
1199         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xb6, 0xfc, 0x00);
1200         ast_set_index_reg_mask(ast, AST_IO_VGASRI, 0x01, 0xdf, 0x00);
1201 }
1202
1203 static void ast_crtc_helper_atomic_disable(struct drm_crtc *crtc, struct drm_atomic_state *state)
1204 {
1205         struct drm_crtc_state *old_crtc_state = drm_atomic_get_old_crtc_state(state, crtc);
1206         struct ast_device *ast = to_ast_device(crtc->dev);
1207         u8 vgacrb6;
1208
1209         ast_set_index_reg_mask(ast, AST_IO_VGASRI, 0x01, 0xdf, AST_IO_VGASR1_SD);
1210
1211         vgacrb6 = AST_IO_VGACRB6_VSYNC_OFF |
1212                   AST_IO_VGACRB6_HSYNC_OFF;
1213         ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xb6, 0xfc, vgacrb6);
1214
1215         /*
1216          * HW cursors require the underlying primary plane and CRTC to
1217          * display a valid mode and image. This is not the case during
1218          * full modeset operations. So we temporarily disable any active
1219          * plane, including the HW cursor. Each plane's atomic_update()
1220          * helper will re-enable it if necessary.
1221          *
1222          * We only do this during *full* modesets. It does not affect
1223          * simple pageflips on the planes.
1224          */
1225         drm_atomic_helper_disable_planes_on_crtc(old_crtc_state, false);
1226 }
1227
1228 static const struct drm_crtc_helper_funcs ast_crtc_helper_funcs = {
1229         .mode_valid = ast_crtc_helper_mode_valid,
1230         .mode_set_nofb = ast_crtc_helper_mode_set_nofb,
1231         .atomic_check = ast_crtc_helper_atomic_check,
1232         .atomic_flush = ast_crtc_helper_atomic_flush,
1233         .atomic_enable = ast_crtc_helper_atomic_enable,
1234         .atomic_disable = ast_crtc_helper_atomic_disable,
1235 };
1236
1237 static void ast_crtc_reset(struct drm_crtc *crtc)
1238 {
1239         struct ast_crtc_state *ast_state =
1240                 kzalloc(sizeof(*ast_state), GFP_KERNEL);
1241
1242         if (crtc->state)
1243                 crtc->funcs->atomic_destroy_state(crtc, crtc->state);
1244
1245         if (ast_state)
1246                 __drm_atomic_helper_crtc_reset(crtc, &ast_state->base);
1247         else
1248                 __drm_atomic_helper_crtc_reset(crtc, NULL);
1249 }
1250
1251 static struct drm_crtc_state *
1252 ast_crtc_atomic_duplicate_state(struct drm_crtc *crtc)
1253 {
1254         struct ast_crtc_state *new_ast_state, *ast_state;
1255         struct drm_device *dev = crtc->dev;
1256
1257         if (drm_WARN_ON(dev, !crtc->state))
1258                 return NULL;
1259
1260         new_ast_state = kmalloc(sizeof(*new_ast_state), GFP_KERNEL);
1261         if (!new_ast_state)
1262                 return NULL;
1263         __drm_atomic_helper_crtc_duplicate_state(crtc, &new_ast_state->base);
1264
1265         ast_state = to_ast_crtc_state(crtc->state);
1266
1267         new_ast_state->format = ast_state->format;
1268         memcpy(&new_ast_state->vbios_mode_info, &ast_state->vbios_mode_info,
1269                sizeof(new_ast_state->vbios_mode_info));
1270
1271         return &new_ast_state->base;
1272 }
1273
1274 static void ast_crtc_atomic_destroy_state(struct drm_crtc *crtc,
1275                                           struct drm_crtc_state *state)
1276 {
1277         struct ast_crtc_state *ast_state = to_ast_crtc_state(state);
1278
1279         __drm_atomic_helper_crtc_destroy_state(&ast_state->base);
1280         kfree(ast_state);
1281 }
1282
1283 static const struct drm_crtc_funcs ast_crtc_funcs = {
1284         .reset = ast_crtc_reset,
1285         .destroy = drm_crtc_cleanup,
1286         .set_config = drm_atomic_helper_set_config,
1287         .page_flip = drm_atomic_helper_page_flip,
1288         .atomic_duplicate_state = ast_crtc_atomic_duplicate_state,
1289         .atomic_destroy_state = ast_crtc_atomic_destroy_state,
1290 };
1291
1292 static int ast_crtc_init(struct drm_device *dev)
1293 {
1294         struct ast_device *ast = to_ast_device(dev);
1295         struct drm_crtc *crtc = &ast->crtc;
1296         int ret;
1297
1298         ret = drm_crtc_init_with_planes(dev, crtc, &ast->primary_plane.base,
1299                                         &ast->cursor_plane.base, &ast_crtc_funcs,
1300                                         NULL);
1301         if (ret)
1302                 return ret;
1303
1304         drm_mode_crtc_set_gamma_size(crtc, AST_LUT_SIZE);
1305         drm_crtc_enable_color_mgmt(crtc, 0, false, AST_LUT_SIZE);
1306
1307         drm_crtc_helper_add(crtc, &ast_crtc_helper_funcs);
1308
1309         return 0;
1310 }
1311
1312 /*
1313  * VGA Encoder
1314  */
1315
1316 static const struct drm_encoder_funcs ast_vga_encoder_funcs = {
1317         .destroy = drm_encoder_cleanup,
1318 };
1319
1320 /*
1321  * VGA Connector
1322  */
1323
1324 static const struct drm_connector_helper_funcs ast_vga_connector_helper_funcs = {
1325         .get_modes = drm_connector_helper_get_modes,
1326         .detect_ctx = drm_connector_helper_detect_from_ddc,
1327 };
1328
1329 static const struct drm_connector_funcs ast_vga_connector_funcs = {
1330         .reset = drm_atomic_helper_connector_reset,
1331         .fill_modes = drm_helper_probe_single_connector_modes,
1332         .destroy = drm_connector_cleanup,
1333         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
1334         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
1335 };
1336
1337 static int ast_vga_connector_init(struct drm_device *dev, struct drm_connector *connector)
1338 {
1339         struct ast_device *ast = to_ast_device(dev);
1340         struct i2c_adapter *ddc;
1341         int ret;
1342
1343         ddc = ast_ddc_create(ast);
1344         if (IS_ERR(ddc)) {
1345                 ret = PTR_ERR(ddc);
1346                 drm_err(dev, "failed to add DDC bus for connector; ret=%d\n", ret);
1347                 return ret;
1348         }
1349
1350         ret = drm_connector_init_with_ddc(dev, connector, &ast_vga_connector_funcs,
1351                                           DRM_MODE_CONNECTOR_VGA, ddc);
1352         if (ret)
1353                 return ret;
1354
1355         drm_connector_helper_add(connector, &ast_vga_connector_helper_funcs);
1356
1357         connector->interlace_allowed = 0;
1358         connector->doublescan_allowed = 0;
1359
1360         connector->polled = DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT;
1361
1362         return 0;
1363 }
1364
1365 static int ast_vga_output_init(struct ast_device *ast)
1366 {
1367         struct drm_device *dev = &ast->base;
1368         struct drm_crtc *crtc = &ast->crtc;
1369         struct drm_encoder *encoder = &ast->output.vga.encoder;
1370         struct drm_connector *connector = &ast->output.vga.connector;
1371         int ret;
1372
1373         ret = drm_encoder_init(dev, encoder, &ast_vga_encoder_funcs,
1374                                DRM_MODE_ENCODER_DAC, NULL);
1375         if (ret)
1376                 return ret;
1377         encoder->possible_crtcs = drm_crtc_mask(crtc);
1378
1379         ret = ast_vga_connector_init(dev, connector);
1380         if (ret)
1381                 return ret;
1382
1383         ret = drm_connector_attach_encoder(connector, encoder);
1384         if (ret)
1385                 return ret;
1386
1387         return 0;
1388 }
1389
1390 /*
1391  * SIL164 Encoder
1392  */
1393
1394 static const struct drm_encoder_funcs ast_sil164_encoder_funcs = {
1395         .destroy = drm_encoder_cleanup,
1396 };
1397
1398 /*
1399  * SIL164 Connector
1400  */
1401
1402 static const struct drm_connector_helper_funcs ast_sil164_connector_helper_funcs = {
1403         .get_modes = drm_connector_helper_get_modes,
1404         .detect_ctx = drm_connector_helper_detect_from_ddc,
1405 };
1406
1407 static const struct drm_connector_funcs ast_sil164_connector_funcs = {
1408         .reset = drm_atomic_helper_connector_reset,
1409         .fill_modes = drm_helper_probe_single_connector_modes,
1410         .destroy = drm_connector_cleanup,
1411         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
1412         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
1413 };
1414
1415 static int ast_sil164_connector_init(struct drm_device *dev, struct drm_connector *connector)
1416 {
1417         struct ast_device *ast = to_ast_device(dev);
1418         struct i2c_adapter *ddc;
1419         int ret;
1420
1421         ddc = ast_ddc_create(ast);
1422         if (IS_ERR(ddc)) {
1423                 ret = PTR_ERR(ddc);
1424                 drm_err(dev, "failed to add DDC bus for connector; ret=%d\n", ret);
1425                 return ret;
1426         }
1427
1428         ret = drm_connector_init_with_ddc(dev, connector, &ast_sil164_connector_funcs,
1429                                           DRM_MODE_CONNECTOR_DVII, ddc);
1430         if (ret)
1431                 return ret;
1432
1433         drm_connector_helper_add(connector, &ast_sil164_connector_helper_funcs);
1434
1435         connector->interlace_allowed = 0;
1436         connector->doublescan_allowed = 0;
1437
1438         connector->polled = DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT;
1439
1440         return 0;
1441 }
1442
1443 static int ast_sil164_output_init(struct ast_device *ast)
1444 {
1445         struct drm_device *dev = &ast->base;
1446         struct drm_crtc *crtc = &ast->crtc;
1447         struct drm_encoder *encoder = &ast->output.sil164.encoder;
1448         struct drm_connector *connector = &ast->output.sil164.connector;
1449         int ret;
1450
1451         ret = drm_encoder_init(dev, encoder, &ast_sil164_encoder_funcs,
1452                                DRM_MODE_ENCODER_TMDS, NULL);
1453         if (ret)
1454                 return ret;
1455         encoder->possible_crtcs = drm_crtc_mask(crtc);
1456
1457         ret = ast_sil164_connector_init(dev, connector);
1458         if (ret)
1459                 return ret;
1460
1461         ret = drm_connector_attach_encoder(connector, encoder);
1462         if (ret)
1463                 return ret;
1464
1465         return 0;
1466 }
1467
1468 /*
1469  * DP501 Encoder
1470  */
1471
1472 static const struct drm_encoder_funcs ast_dp501_encoder_funcs = {
1473         .destroy = drm_encoder_cleanup,
1474 };
1475
1476 static void ast_dp501_encoder_helper_atomic_enable(struct drm_encoder *encoder,
1477                                                    struct drm_atomic_state *state)
1478 {
1479         struct drm_device *dev = encoder->dev;
1480
1481         ast_set_dp501_video_output(dev, 1);
1482 }
1483
1484 static void ast_dp501_encoder_helper_atomic_disable(struct drm_encoder *encoder,
1485                                                     struct drm_atomic_state *state)
1486 {
1487         struct drm_device *dev = encoder->dev;
1488
1489         ast_set_dp501_video_output(dev, 0);
1490 }
1491
1492 static const struct drm_encoder_helper_funcs ast_dp501_encoder_helper_funcs = {
1493         .atomic_enable = ast_dp501_encoder_helper_atomic_enable,
1494         .atomic_disable = ast_dp501_encoder_helper_atomic_disable,
1495 };
1496
1497 /*
1498  * DP501 Connector
1499  */
1500
1501 static int ast_dp501_connector_helper_get_modes(struct drm_connector *connector)
1502 {
1503         void *edid;
1504         bool succ;
1505         int count;
1506
1507         edid = kmalloc(EDID_LENGTH, GFP_KERNEL);
1508         if (!edid)
1509                 goto err_drm_connector_update_edid_property;
1510
1511         succ = ast_dp501_read_edid(connector->dev, edid);
1512         if (!succ)
1513                 goto err_kfree;
1514
1515         drm_connector_update_edid_property(connector, edid);
1516         count = drm_add_edid_modes(connector, edid);
1517         kfree(edid);
1518
1519         return count;
1520
1521 err_kfree:
1522         kfree(edid);
1523 err_drm_connector_update_edid_property:
1524         drm_connector_update_edid_property(connector, NULL);
1525         return 0;
1526 }
1527
1528 static int ast_dp501_connector_helper_detect_ctx(struct drm_connector *connector,
1529                                                  struct drm_modeset_acquire_ctx *ctx,
1530                                                  bool force)
1531 {
1532         struct ast_device *ast = to_ast_device(connector->dev);
1533
1534         if (ast_dp501_is_connected(ast))
1535                 return connector_status_connected;
1536         return connector_status_disconnected;
1537 }
1538
1539 static const struct drm_connector_helper_funcs ast_dp501_connector_helper_funcs = {
1540         .get_modes = ast_dp501_connector_helper_get_modes,
1541         .detect_ctx = ast_dp501_connector_helper_detect_ctx,
1542 };
1543
1544 static const struct drm_connector_funcs ast_dp501_connector_funcs = {
1545         .reset = drm_atomic_helper_connector_reset,
1546         .fill_modes = drm_helper_probe_single_connector_modes,
1547         .destroy = drm_connector_cleanup,
1548         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
1549         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
1550 };
1551
1552 static int ast_dp501_connector_init(struct drm_device *dev, struct drm_connector *connector)
1553 {
1554         int ret;
1555
1556         ret = drm_connector_init(dev, connector, &ast_dp501_connector_funcs,
1557                                  DRM_MODE_CONNECTOR_DisplayPort);
1558         if (ret)
1559                 return ret;
1560
1561         drm_connector_helper_add(connector, &ast_dp501_connector_helper_funcs);
1562
1563         connector->interlace_allowed = 0;
1564         connector->doublescan_allowed = 0;
1565
1566         connector->polled = DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT;
1567
1568         return 0;
1569 }
1570
1571 static int ast_dp501_output_init(struct ast_device *ast)
1572 {
1573         struct drm_device *dev = &ast->base;
1574         struct drm_crtc *crtc = &ast->crtc;
1575         struct drm_encoder *encoder = &ast->output.dp501.encoder;
1576         struct drm_connector *connector = &ast->output.dp501.connector;
1577         int ret;
1578
1579         ret = drm_encoder_init(dev, encoder, &ast_dp501_encoder_funcs,
1580                                DRM_MODE_ENCODER_TMDS, NULL);
1581         if (ret)
1582                 return ret;
1583         drm_encoder_helper_add(encoder, &ast_dp501_encoder_helper_funcs);
1584
1585         encoder->possible_crtcs = drm_crtc_mask(crtc);
1586
1587         ret = ast_dp501_connector_init(dev, connector);
1588         if (ret)
1589                 return ret;
1590
1591         ret = drm_connector_attach_encoder(connector, encoder);
1592         if (ret)
1593                 return ret;
1594
1595         return 0;
1596 }
1597
1598 /*
1599  * ASPEED Display-Port Encoder
1600  */
1601
1602 static const struct drm_encoder_funcs ast_astdp_encoder_funcs = {
1603         .destroy = drm_encoder_cleanup,
1604 };
1605
1606 static void ast_astdp_encoder_helper_atomic_mode_set(struct drm_encoder *encoder,
1607                                                      struct drm_crtc_state *crtc_state,
1608                                                      struct drm_connector_state *conn_state)
1609 {
1610         struct drm_crtc *crtc = crtc_state->crtc;
1611         struct ast_crtc_state *ast_crtc_state = to_ast_crtc_state(crtc_state);
1612         struct ast_vbios_mode_info *vbios_mode_info = &ast_crtc_state->vbios_mode_info;
1613
1614         ast_dp_set_mode(crtc, vbios_mode_info);
1615 }
1616
1617 static void ast_astdp_encoder_helper_atomic_enable(struct drm_encoder *encoder,
1618                                                    struct drm_atomic_state *state)
1619 {
1620         struct drm_device *dev = encoder->dev;
1621         struct ast_device *ast = to_ast_device(dev);
1622
1623         ast_dp_power_on_off(dev, AST_DP_POWER_ON);
1624         ast_wait_for_vretrace(ast);
1625         ast_dp_set_on_off(dev, 1);
1626 }
1627
1628 static void ast_astdp_encoder_helper_atomic_disable(struct drm_encoder *encoder,
1629                                                     struct drm_atomic_state *state)
1630 {
1631         struct drm_device *dev = encoder->dev;
1632
1633         ast_dp_set_on_off(dev, 0);
1634         ast_dp_power_on_off(dev, AST_DP_POWER_OFF);
1635 }
1636
1637 static const struct drm_encoder_helper_funcs ast_astdp_encoder_helper_funcs = {
1638         .atomic_mode_set = ast_astdp_encoder_helper_atomic_mode_set,
1639         .atomic_enable = ast_astdp_encoder_helper_atomic_enable,
1640         .atomic_disable = ast_astdp_encoder_helper_atomic_disable,
1641 };
1642
1643 /*
1644  * ASPEED Display-Port Connector
1645  */
1646
1647 static int ast_astdp_connector_helper_get_modes(struct drm_connector *connector)
1648 {
1649         void *edid;
1650         struct drm_device *dev = connector->dev;
1651         struct ast_device *ast = to_ast_device(dev);
1652
1653         int succ;
1654         int count;
1655
1656         edid = kmalloc(EDID_LENGTH, GFP_KERNEL);
1657         if (!edid)
1658                 goto err_drm_connector_update_edid_property;
1659
1660         /*
1661          * Protect access to I/O registers from concurrent modesetting
1662          * by acquiring the I/O-register lock.
1663          */
1664         mutex_lock(&ast->modeset_lock);
1665
1666         succ = ast_astdp_read_edid(connector->dev, edid);
1667         if (succ < 0)
1668                 goto err_mutex_unlock;
1669
1670         mutex_unlock(&ast->modeset_lock);
1671
1672         drm_connector_update_edid_property(connector, edid);
1673         count = drm_add_edid_modes(connector, edid);
1674         kfree(edid);
1675
1676         return count;
1677
1678 err_mutex_unlock:
1679         mutex_unlock(&ast->modeset_lock);
1680         kfree(edid);
1681 err_drm_connector_update_edid_property:
1682         drm_connector_update_edid_property(connector, NULL);
1683         return 0;
1684 }
1685
1686 static int ast_astdp_connector_helper_detect_ctx(struct drm_connector *connector,
1687                                                  struct drm_modeset_acquire_ctx *ctx,
1688                                                  bool force)
1689 {
1690         struct ast_device *ast = to_ast_device(connector->dev);
1691
1692         if (ast_astdp_is_connected(ast))
1693                 return connector_status_connected;
1694         return connector_status_disconnected;
1695 }
1696
1697 static const struct drm_connector_helper_funcs ast_astdp_connector_helper_funcs = {
1698         .get_modes = ast_astdp_connector_helper_get_modes,
1699         .detect_ctx = ast_astdp_connector_helper_detect_ctx,
1700 };
1701
1702 static const struct drm_connector_funcs ast_astdp_connector_funcs = {
1703         .reset = drm_atomic_helper_connector_reset,
1704         .fill_modes = drm_helper_probe_single_connector_modes,
1705         .destroy = drm_connector_cleanup,
1706         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
1707         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
1708 };
1709
1710 static int ast_astdp_connector_init(struct drm_device *dev, struct drm_connector *connector)
1711 {
1712         int ret;
1713
1714         ret = drm_connector_init(dev, connector, &ast_astdp_connector_funcs,
1715                                  DRM_MODE_CONNECTOR_DisplayPort);
1716         if (ret)
1717                 return ret;
1718
1719         drm_connector_helper_add(connector, &ast_astdp_connector_helper_funcs);
1720
1721         connector->interlace_allowed = 0;
1722         connector->doublescan_allowed = 0;
1723
1724         connector->polled = DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT;
1725
1726         return 0;
1727 }
1728
1729 static int ast_astdp_output_init(struct ast_device *ast)
1730 {
1731         struct drm_device *dev = &ast->base;
1732         struct drm_crtc *crtc = &ast->crtc;
1733         struct drm_encoder *encoder = &ast->output.astdp.encoder;
1734         struct drm_connector *connector = &ast->output.astdp.connector;
1735         int ret;
1736
1737         ret = drm_encoder_init(dev, encoder, &ast_astdp_encoder_funcs,
1738                                DRM_MODE_ENCODER_TMDS, NULL);
1739         if (ret)
1740                 return ret;
1741         drm_encoder_helper_add(encoder, &ast_astdp_encoder_helper_funcs);
1742
1743         encoder->possible_crtcs = drm_crtc_mask(crtc);
1744
1745         ret = ast_astdp_connector_init(dev, connector);
1746         if (ret)
1747                 return ret;
1748
1749         ret = drm_connector_attach_encoder(connector, encoder);
1750         if (ret)
1751                 return ret;
1752
1753         return 0;
1754 }
1755
1756 /*
1757  * BMC virtual Connector
1758  */
1759
1760 static const struct drm_encoder_funcs ast_bmc_encoder_funcs = {
1761         .destroy = drm_encoder_cleanup,
1762 };
1763
1764 static int ast_bmc_connector_helper_detect_ctx(struct drm_connector *connector,
1765                                                struct drm_modeset_acquire_ctx *ctx,
1766                                                bool force)
1767 {
1768         struct ast_bmc_connector *bmc_connector = to_ast_bmc_connector(connector);
1769         struct drm_connector *physical_connector = bmc_connector->physical_connector;
1770
1771         /*
1772          * Most user-space compositors cannot handle more than one connected
1773          * connector per CRTC. Hence, we only mark the BMC as connected if the
1774          * physical connector is disconnected. If the physical connector's status
1775          * is connected or unknown, the BMC remains disconnected. This has no
1776          * effect on the output of the BMC.
1777          *
1778          * FIXME: Remove this logic once user-space compositors can handle more
1779          *        than one connector per CRTC. The BMC should always be connected.
1780          */
1781
1782         if (physical_connector && physical_connector->status == connector_status_disconnected)
1783                 return connector_status_connected;
1784
1785         return connector_status_disconnected;
1786 }
1787
1788 static int ast_bmc_connector_helper_get_modes(struct drm_connector *connector)
1789 {
1790         return drm_add_modes_noedid(connector, 4096, 4096);
1791 }
1792
1793 static const struct drm_connector_helper_funcs ast_bmc_connector_helper_funcs = {
1794         .get_modes = ast_bmc_connector_helper_get_modes,
1795         .detect_ctx = ast_bmc_connector_helper_detect_ctx,
1796 };
1797
1798 static const struct drm_connector_funcs ast_bmc_connector_funcs = {
1799         .reset = drm_atomic_helper_connector_reset,
1800         .fill_modes = drm_helper_probe_single_connector_modes,
1801         .destroy = drm_connector_cleanup,
1802         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
1803         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
1804 };
1805
1806 static int ast_bmc_connector_init(struct drm_device *dev,
1807                                   struct ast_bmc_connector *bmc_connector,
1808                                   struct drm_connector *physical_connector)
1809 {
1810         struct drm_connector *connector = &bmc_connector->base;
1811         int ret;
1812
1813         ret = drm_connector_init(dev, connector, &ast_bmc_connector_funcs,
1814                                  DRM_MODE_CONNECTOR_VIRTUAL);
1815         if (ret)
1816                 return ret;
1817
1818         drm_connector_helper_add(connector, &ast_bmc_connector_helper_funcs);
1819
1820         bmc_connector->physical_connector = physical_connector;
1821
1822         return 0;
1823 }
1824
1825 static int ast_bmc_output_init(struct ast_device *ast,
1826                                struct drm_connector *physical_connector)
1827 {
1828         struct drm_device *dev = &ast->base;
1829         struct drm_crtc *crtc = &ast->crtc;
1830         struct drm_encoder *encoder = &ast->output.bmc.encoder;
1831         struct ast_bmc_connector *bmc_connector = &ast->output.bmc.bmc_connector;
1832         struct drm_connector *connector = &bmc_connector->base;
1833         int ret;
1834
1835         ret = drm_encoder_init(dev, encoder,
1836                                &ast_bmc_encoder_funcs,
1837                                DRM_MODE_ENCODER_VIRTUAL, "ast_bmc");
1838         if (ret)
1839                 return ret;
1840         encoder->possible_crtcs = drm_crtc_mask(crtc);
1841
1842         ret = ast_bmc_connector_init(dev, bmc_connector, physical_connector);
1843         if (ret)
1844                 return ret;
1845
1846         ret = drm_connector_attach_encoder(connector, encoder);
1847         if (ret)
1848                 return ret;
1849
1850         return 0;
1851 }
1852
1853 /*
1854  * Mode config
1855  */
1856
1857 static void ast_mode_config_helper_atomic_commit_tail(struct drm_atomic_state *state)
1858 {
1859         struct ast_device *ast = to_ast_device(state->dev);
1860
1861         /*
1862          * Concurrent operations could possibly trigger a call to
1863          * drm_connector_helper_funcs.get_modes by trying to read the
1864          * display modes. Protect access to I/O registers by acquiring
1865          * the I/O-register lock. Released in atomic_flush().
1866          */
1867         mutex_lock(&ast->modeset_lock);
1868         drm_atomic_helper_commit_tail(state);
1869         mutex_unlock(&ast->modeset_lock);
1870 }
1871
1872 static const struct drm_mode_config_helper_funcs ast_mode_config_helper_funcs = {
1873         .atomic_commit_tail = ast_mode_config_helper_atomic_commit_tail,
1874 };
1875
1876 static enum drm_mode_status ast_mode_config_mode_valid(struct drm_device *dev,
1877                                                        const struct drm_display_mode *mode)
1878 {
1879         static const unsigned long max_bpp = 4; /* DRM_FORMAT_XRGB8888 */
1880         struct ast_device *ast = to_ast_device(dev);
1881         unsigned long fbsize, fbpages, max_fbpages;
1882
1883         max_fbpages = (ast->vram_fb_available) >> PAGE_SHIFT;
1884
1885         fbsize = mode->hdisplay * mode->vdisplay * max_bpp;
1886         fbpages = DIV_ROUND_UP(fbsize, PAGE_SIZE);
1887
1888         if (fbpages > max_fbpages)
1889                 return MODE_MEM;
1890
1891         return MODE_OK;
1892 }
1893
1894 static const struct drm_mode_config_funcs ast_mode_config_funcs = {
1895         .fb_create = drm_gem_fb_create_with_dirty,
1896         .mode_valid = ast_mode_config_mode_valid,
1897         .atomic_check = drm_atomic_helper_check,
1898         .atomic_commit = drm_atomic_helper_commit,
1899 };
1900
1901 int ast_mode_config_init(struct ast_device *ast)
1902 {
1903         struct drm_device *dev = &ast->base;
1904         struct drm_connector *physical_connector = NULL;
1905         int ret;
1906
1907         ret = drmm_mutex_init(dev, &ast->modeset_lock);
1908         if (ret)
1909                 return ret;
1910
1911         ret = drmm_mode_config_init(dev);
1912         if (ret)
1913                 return ret;
1914
1915         dev->mode_config.funcs = &ast_mode_config_funcs;
1916         dev->mode_config.min_width = 0;
1917         dev->mode_config.min_height = 0;
1918         dev->mode_config.preferred_depth = 24;
1919
1920         if (ast->chip == AST2100 || // GEN2, but not AST1100 (?)
1921             ast->chip == AST2200 || // GEN3, but not AST2150 (?)
1922             IS_AST_GEN7(ast) ||
1923             IS_AST_GEN6(ast) ||
1924             IS_AST_GEN5(ast) ||
1925             IS_AST_GEN4(ast)) {
1926                 dev->mode_config.max_width = 1920;
1927                 dev->mode_config.max_height = 2048;
1928         } else {
1929                 dev->mode_config.max_width = 1600;
1930                 dev->mode_config.max_height = 1200;
1931         }
1932
1933         dev->mode_config.helper_private = &ast_mode_config_helper_funcs;
1934
1935         ret = ast_primary_plane_init(ast);
1936         if (ret)
1937                 return ret;
1938
1939         ret = ast_cursor_plane_init(ast);
1940         if (ret)
1941                 return ret;
1942
1943         ast_crtc_init(dev);
1944
1945         if (ast->tx_chip_types & AST_TX_NONE_BIT) {
1946                 ret = ast_vga_output_init(ast);
1947                 if (ret)
1948                         return ret;
1949                 physical_connector = &ast->output.vga.connector;
1950         }
1951         if (ast->tx_chip_types & AST_TX_SIL164_BIT) {
1952                 ret = ast_sil164_output_init(ast);
1953                 if (ret)
1954                         return ret;
1955                 physical_connector = &ast->output.sil164.connector;
1956         }
1957         if (ast->tx_chip_types & AST_TX_DP501_BIT) {
1958                 ret = ast_dp501_output_init(ast);
1959                 if (ret)
1960                         return ret;
1961                 physical_connector = &ast->output.dp501.connector;
1962         }
1963         if (ast->tx_chip_types & AST_TX_ASTDP_BIT) {
1964                 ret = ast_astdp_output_init(ast);
1965                 if (ret)
1966                         return ret;
1967                 physical_connector = &ast->output.astdp.connector;
1968         }
1969         ret = ast_bmc_output_init(ast, physical_connector);
1970         if (ret)
1971                 return ret;
1972
1973         drm_mode_config_reset(dev);
1974
1975         ret = drmm_kms_helper_poll_init(dev);
1976         if (ret)
1977                 return ret;
1978
1979         return 0;
1980 }