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