Loading...
Note: File does not exist in v3.1.
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}