1 /*
2 * linux/drivers/video/kyro/STG4000OverlayDevice.c
3 *
4 * Copyright (C) 2000 Imagination Technologies Ltd
5 * Copyright (C) 2002 STMicroelectronics
6 *
7 * This file is subject to the terms and conditions of the GNU General Public
8 * License. See the file COPYING in the main directory of this archive
9 * for more details.
10 */
11
12 #include <linux/kernel.h>
13 #include <linux/errno.h>
14 #include <linux/types.h>
15
16 #include "STG4000Reg.h"
17 #include "STG4000Interface.h"
18
19 /* HW Defines */
20
21 #define STG4000_NO_SCALING 0x800
22 #define STG4000_NO_DECIMATION 0xFFFFFFFF
23
24 /* Primary surface */
25 #define STG4000_PRIM_NUM_PIX 5
26 #define STG4000_PRIM_ALIGN 4
27 #define STG4000_PRIM_ADDR_BITS 20
28
29 #define STG4000_PRIM_MIN_WIDTH 640
30 #define STG4000_PRIM_MAX_WIDTH 1600
31 #define STG4000_PRIM_MIN_HEIGHT 480
32 #define STG4000_PRIM_MAX_HEIGHT 1200
33
34 /* Overlay surface */
35 #define STG4000_OVRL_NUM_PIX 4
36 #define STG4000_OVRL_ALIGN 2
37 #define STG4000_OVRL_ADDR_BITS 20
38 #define STG4000_OVRL_NUM_MODES 5
39
40 #define STG4000_OVRL_MIN_WIDTH 0
41 #define STG4000_OVRL_MAX_WIDTH 720
42 #define STG4000_OVRL_MIN_HEIGHT 0
43 #define STG4000_OVRL_MAX_HEIGHT 576
44
45 /* Decimation and Scaling */
46 static u32 adwDecim8[33] = {
47 0xffffffff, 0xfffeffff, 0xffdffbff, 0xfefefeff, 0xfdf7efbf,
48 0xfbdf7bdf, 0xf7bbddef, 0xeeeeeeef, 0xeeddbb77, 0xedb76db7,
49 0xdb6db6db, 0xdb5b5b5b, 0xdab5ad6b, 0xd5ab55ab, 0xd555aaab,
50 0xaaaaaaab, 0xaaaa5555, 0xaa952a55, 0xa94a5295, 0xa5252525,
51 0xa4924925, 0x92491249, 0x91224489, 0x91111111, 0x90884211,
52 0x88410821, 0x88102041, 0x81010101, 0x80800801, 0x80010001,
53 0x80000001, 0x00000001, 0x00000000
54 };
55
56 typedef struct _OVRL_SRC_DEST {
57 /*clipped on-screen pixel position of overlay */
58 u32 ulDstX1;
59 u32 ulDstY1;
60 u32 ulDstX2;
61 u32 ulDstY2;
62
63 /*clipped pixel pos of source data within buffer thses need to be 128 bit word aligned */
64 u32 ulSrcX1;
65 u32 ulSrcY1;
66 u32 ulSrcX2;
67 u32 ulSrcY2;
68
69 /* on-screen pixel position of overlay */
70 s32 lDstX1;
71 s32 lDstY1;
72 s32 lDstX2;
73 s32 lDstY2;
74 } OVRL_SRC_DEST;
75
76 static u32 ovlWidth, ovlHeight, ovlStride;
77 static int ovlLinear;
78
ResetOverlayRegisters(volatile STG4000REG __iomem * pSTGReg)79 void ResetOverlayRegisters(volatile STG4000REG __iomem *pSTGReg)
80 {
81 u32 tmp;
82
83 /* Set Overlay address to default */
84 tmp = STG_READ_REG(DACOverlayAddr);
85 CLEAR_BITS_FRM_TO(0, 20);
86 CLEAR_BIT(31);
87 STG_WRITE_REG(DACOverlayAddr, tmp);
88
89 /* Set Overlay U address */
90 tmp = STG_READ_REG(DACOverlayUAddr);
91 CLEAR_BITS_FRM_TO(0, 20);
92 STG_WRITE_REG(DACOverlayUAddr, tmp);
93
94 /* Set Overlay V address */
95 tmp = STG_READ_REG(DACOverlayVAddr);
96 CLEAR_BITS_FRM_TO(0, 20);
97 STG_WRITE_REG(DACOverlayVAddr, tmp);
98
99 /* Set Overlay Size */
100 tmp = STG_READ_REG(DACOverlaySize);
101 CLEAR_BITS_FRM_TO(0, 10);
102 CLEAR_BITS_FRM_TO(12, 31);
103 STG_WRITE_REG(DACOverlaySize, tmp);
104
105 /* Set Overlay Vt Decimation */
106 tmp = STG4000_NO_DECIMATION;
107 STG_WRITE_REG(DACOverlayVtDec, tmp);
108
109 /* Set Overlay format to default value */
110 tmp = STG_READ_REG(DACPixelFormat);
111 CLEAR_BITS_FRM_TO(4, 7);
112 CLEAR_BITS_FRM_TO(16, 22);
113 STG_WRITE_REG(DACPixelFormat, tmp);
114
115 /* Set Vertical scaling to default */
116 tmp = STG_READ_REG(DACVerticalScal);
117 CLEAR_BITS_FRM_TO(0, 11);
118 CLEAR_BITS_FRM_TO(16, 22);
119 tmp |= STG4000_NO_SCALING; /* Set to no scaling */
120 STG_WRITE_REG(DACVerticalScal, tmp);
121
122 /* Set Horizontal Scaling to default */
123 tmp = STG_READ_REG(DACHorizontalScal);
124 CLEAR_BITS_FRM_TO(0, 11);
125 CLEAR_BITS_FRM_TO(16, 17);
126 tmp |= STG4000_NO_SCALING; /* Set to no scaling */
127 STG_WRITE_REG(DACHorizontalScal, tmp);
128
129 /* Set Blend mode to Alpha Blend */
130 /* ????? SG 08/11/2001 Surely this isn't the alpha blend mode,
131 hopefully its overwrite
132 */
133 tmp = STG_READ_REG(DACBlendCtrl);
134 CLEAR_BITS_FRM_TO(0, 30);
135 tmp = (GRAPHICS_MODE << 28);
136 STG_WRITE_REG(DACBlendCtrl, tmp);
137
138 }
139
CreateOverlaySurface(volatile STG4000REG __iomem * pSTGReg,u32 inWidth,u32 inHeight,int bLinear,u32 ulOverlayOffset,u32 * retStride,u32 * retUVStride)140 int CreateOverlaySurface(volatile STG4000REG __iomem *pSTGReg,
141 u32 inWidth,
142 u32 inHeight,
143 int bLinear,
144 u32 ulOverlayOffset,
145 u32 * retStride, u32 * retUVStride)
146 {
147 u32 tmp;
148 u32 ulStride;
149
150 if (inWidth > STG4000_OVRL_MAX_WIDTH ||
151 inHeight > STG4000_OVRL_MAX_HEIGHT) {
152 return -EINVAL;
153 }
154
155 /* Stride in 16 byte words - 16Bpp */
156 if (bLinear) {
157 /* Format is 16bits so num 16 byte words is width/8 */
158 if ((inWidth & 0x7) == 0) { /* inWidth % 8 */
159 ulStride = (inWidth / 8);
160 } else {
161 /* Round up to next 16byte boundary */
162 ulStride = ((inWidth + 8) / 8);
163 }
164 } else {
165 /* Y component is 8bits so num 16 byte words is width/16 */
166 if ((inWidth & 0xf) == 0) { /* inWidth % 16 */
167 ulStride = (inWidth / 16);
168 } else {
169 /* Round up to next 16byte boundary */
170 ulStride = ((inWidth + 16) / 16);
171 }
172 }
173
174
175 /* Set Overlay address and Format mode */
176 tmp = STG_READ_REG(DACOverlayAddr);
177 CLEAR_BITS_FRM_TO(0, 20);
178 if (bLinear) {
179 CLEAR_BIT(31); /* Overlay format to Linear */
180 } else {
181 tmp |= SET_BIT(31); /* Overlay format to Planer */
182 }
183
184 /* Only bits 24:4 of the Overlay address */
185 tmp |= (ulOverlayOffset >> 4);
186 STG_WRITE_REG(DACOverlayAddr, tmp);
187
188 if (!bLinear) {
189 u32 uvSize =
190 (inWidth & 0x1) ? (inWidth + 1 / 2) : (inWidth / 2);
191 u32 uvStride;
192 u32 ulOffset;
193 /* Y component is 8bits so num 32 byte words is width/32 */
194 if ((uvSize & 0xf) == 0) { /* inWidth % 16 */
195 uvStride = (uvSize / 16);
196 } else {
197 /* Round up to next 32byte boundary */
198 uvStride = ((uvSize + 16) / 16);
199 }
200
201 ulOffset = ulOverlayOffset + (inHeight * (ulStride * 16));
202 /* Align U,V data to 32byte boundary */
203 if ((ulOffset & 0x1f) != 0)
204 ulOffset = (ulOffset + 32L) & 0xffffffE0L;
205
206 tmp = STG_READ_REG(DACOverlayUAddr);
207 CLEAR_BITS_FRM_TO(0, 20);
208 tmp |= (ulOffset >> 4);
209 STG_WRITE_REG(DACOverlayUAddr, tmp);
210
211 ulOffset += (inHeight / 2) * (uvStride * 16);
212 /* Align U,V data to 32byte boundary */
213 if ((ulOffset & 0x1f) != 0)
214 ulOffset = (ulOffset + 32L) & 0xffffffE0L;
215
216 tmp = STG_READ_REG(DACOverlayVAddr);
217 CLEAR_BITS_FRM_TO(0, 20);
218 tmp |= (ulOffset >> 4);
219 STG_WRITE_REG(DACOverlayVAddr, tmp);
220
221 *retUVStride = uvStride * 16;
222 }
223
224
225 /* Set Overlay YUV pixel format
226 * Make sure that LUT not used - ??????
227 */
228 tmp = STG_READ_REG(DACPixelFormat);
229 /* Only support Planer or UYVY linear formats */
230 CLEAR_BITS_FRM_TO(4, 9);
231 STG_WRITE_REG(DACPixelFormat, tmp);
232
233 ovlWidth = inWidth;
234 ovlHeight = inHeight;
235 ovlStride = ulStride;
236 ovlLinear = bLinear;
237 *retStride = ulStride << 4; /* In bytes */
238
239 return 0;
240 }
241
SetOverlayBlendMode(volatile STG4000REG __iomem * pSTGReg,OVRL_BLEND_MODE mode,u32 ulAlpha,u32 ulColorKey)242 int SetOverlayBlendMode(volatile STG4000REG __iomem *pSTGReg,
243 OVRL_BLEND_MODE mode,
244 u32 ulAlpha, u32 ulColorKey)
245 {
246 u32 tmp;
247
248 tmp = STG_READ_REG(DACBlendCtrl);
249 CLEAR_BITS_FRM_TO(28, 30);
250 tmp |= (mode << 28);
251
252 switch (mode) {
253 case COLOR_KEY:
254 CLEAR_BITS_FRM_TO(0, 23);
255 tmp |= (ulColorKey & 0x00FFFFFF);
256 break;
257
258 case GLOBAL_ALPHA:
259 CLEAR_BITS_FRM_TO(24, 27);
260 tmp |= ((ulAlpha & 0xF) << 24);
261 break;
262
263 case CK_PIXEL_ALPHA:
264 CLEAR_BITS_FRM_TO(0, 23);
265 tmp |= (ulColorKey & 0x00FFFFFF);
266 break;
267
268 case CK_GLOBAL_ALPHA:
269 CLEAR_BITS_FRM_TO(0, 23);
270 tmp |= (ulColorKey & 0x00FFFFFF);
271 CLEAR_BITS_FRM_TO(24, 27);
272 tmp |= ((ulAlpha & 0xF) << 24);
273 break;
274
275 case GRAPHICS_MODE:
276 case PER_PIXEL_ALPHA:
277 break;
278
279 default:
280 return -EINVAL;
281 }
282
283 STG_WRITE_REG(DACBlendCtrl, tmp);
284
285 return 0;
286 }
287
EnableOverlayPlane(volatile STG4000REG __iomem * pSTGReg)288 void EnableOverlayPlane(volatile STG4000REG __iomem *pSTGReg)
289 {
290 u32 tmp;
291 /* Enable Overlay */
292 tmp = STG_READ_REG(DACPixelFormat);
293 tmp |= SET_BIT(7);
294 STG_WRITE_REG(DACPixelFormat, tmp);
295
296 /* Set video stream control */
297 tmp = STG_READ_REG(DACStreamCtrl);
298 tmp |= SET_BIT(1); /* video stream */
299 STG_WRITE_REG(DACStreamCtrl, tmp);
300 }
301
Overlap(u32 ulBits,u32 ulPattern)302 static u32 Overlap(u32 ulBits, u32 ulPattern)
303 {
304 u32 ulCount = 0;
305
306 while (ulBits) {
307 if (!(ulPattern & 1))
308 ulCount++;
309 ulBits--;
310 ulPattern = ulPattern >> 1;
311 }
312
313 return ulCount;
314
315 }
316
SetOverlayViewPort(volatile STG4000REG __iomem * pSTGReg,u32 left,u32 top,u32 right,u32 bottom)317 int SetOverlayViewPort(volatile STG4000REG __iomem *pSTGReg,
318 u32 left, u32 top,
319 u32 right, u32 bottom)
320 {
321 OVRL_SRC_DEST srcDest;
322
323 u32 ulSrcTop, ulSrcBottom;
324 u32 ulSrc, ulDest;
325 u32 ulFxScale, ulFxOffset;
326 u32 ulHeight, ulWidth;
327 u32 ulPattern;
328 u32 ulDecimate, ulDecimated;
329 u32 ulApplied;
330 u32 ulDacXScale, ulDacYScale;
331 u32 ulScale;
332 u32 ulLeft, ulRight;
333 u32 ulSrcLeft, ulSrcRight;
334 u32 ulScaleLeft, ulScaleRight;
335 u32 ulhDecim;
336 u32 ulsVal;
337 u32 ulVertDecFactor;
338 int bResult;
339 u32 ulClipOff = 0;
340 u32 ulBits = 0;
341 u32 ulsAdd = 0;
342 u32 tmp, ulStride;
343 u32 ulExcessPixels, ulClip, ulExtraLines;
344
345
346 srcDest.ulSrcX1 = 0;
347 srcDest.ulSrcY1 = 0;
348 srcDest.ulSrcX2 = ovlWidth - 1;
349 srcDest.ulSrcY2 = ovlHeight - 1;
350
351 srcDest.ulDstX1 = left;
352 srcDest.ulDstY1 = top;
353 srcDest.ulDstX2 = right;
354 srcDest.ulDstY2 = bottom;
355
356 srcDest.lDstX1 = srcDest.ulDstX1;
357 srcDest.lDstY1 = srcDest.ulDstY1;
358 srcDest.lDstX2 = srcDest.ulDstX2;
359 srcDest.lDstY2 = srcDest.ulDstY2;
360
361 /************* Vertical decimation/scaling ******************/
362
363 /* Get Src Top and Bottom */
364 ulSrcTop = srcDest.ulSrcY1;
365 ulSrcBottom = srcDest.ulSrcY2;
366
367 ulSrc = ulSrcBottom - ulSrcTop;
368 ulDest = srcDest.lDstY2 - srcDest.lDstY1; /* on-screen overlay */
369
370 if (ulSrc <= 1)
371 return -EINVAL;
372
373 /* First work out the position we are to display as offset from the
374 * source of the buffer
375 */
376 ulFxScale = (ulDest << 11) / ulSrc; /* fixed point scale factor */
377 ulFxOffset = (srcDest.lDstY2 - srcDest.ulDstY2) << 11;
378
379 ulSrcBottom = ulSrcBottom - (ulFxOffset / ulFxScale);
380 ulSrc = ulSrcBottom - ulSrcTop;
381 ulHeight = ulSrc;
382
383 ulDest = srcDest.ulDstY2 - (srcDest.ulDstY1 - 1);
384 ulPattern = adwDecim8[ulBits];
385
386 /* At this point ulSrc represents the input decimator */
387 if (ulSrc > ulDest) {
388 ulDecimate = ulSrc - ulDest;
389 ulBits = 0;
390 ulApplied = ulSrc / 32;
391
392 while (((ulBits * ulApplied) +
393 Overlap((ulSrc % 32),
394 adwDecim8[ulBits])) < ulDecimate)
395 ulBits++;
396
397 ulPattern = adwDecim8[ulBits];
398 ulDecimated =
399 (ulBits * ulApplied) + Overlap((ulSrc % 32),
400 ulPattern);
401 ulSrc = ulSrc - ulDecimated; /* the number number of lines that will go into the scaler */
402 }
403
404 if (ulBits && (ulBits != 32)) {
405 ulVertDecFactor = (63 - ulBits) / (32 - ulBits); /* vertical decimation factor scaled up to nearest integer */
406 } else {
407 ulVertDecFactor = 1;
408 }
409
410 ulDacYScale = ((ulSrc - 1) * 2048) / (ulDest + 1);
411
412 tmp = STG_READ_REG(DACOverlayVtDec); /* Decimation */
413 CLEAR_BITS_FRM_TO(0, 31);
414 tmp = ulPattern;
415 STG_WRITE_REG(DACOverlayVtDec, tmp);
416
417 /***************** Horizontal decimation/scaling ***************************/
418
419 /*
420 * Now we handle the horizontal case, this is a simplified version of
421 * the vertical case in that we decimate by factors of 2. as we are
422 * working in words we should always be able to decimate by these
423 * factors. as we always have to have a buffer which is aligned to a
424 * whole number of 128 bit words, we must align the left side to the
425 * lowest to the next lowest 128 bit boundary, and the right hand edge
426 * to the next largets boundary, (in a similar way to how we didi it in
427 * PMX1) as the left and right hand edges are aligned to these
428 * boundaries normally this only becomes an issue when we are chopping
429 * of one of the sides We shall work out vertical stuff first
430 */
431 ulSrc = srcDest.ulSrcX2 - srcDest.ulSrcX1;
432 ulDest = srcDest.lDstX2 - srcDest.lDstX1;
433 #ifdef _OLDCODE
434 ulLeft = srcDest.ulDstX1;
435 ulRight = srcDest.ulDstX2;
436 #else
437 if (srcDest.ulDstX1 > 2) {
438 ulLeft = srcDest.ulDstX1 + 2;
439 ulRight = srcDest.ulDstX2 + 1;
440 } else {
441 ulLeft = srcDest.ulDstX1;
442 ulRight = srcDest.ulDstX2 + 1;
443 }
444 #endif
445 /* first work out the position we are to display as offset from the source of the buffer */
446 bResult = 1;
447
448 do {
449 if (ulDest == 0)
450 return -EINVAL;
451
452 /* source pixels per dest pixel <<11 */
453 ulFxScale = ((ulSrc - 1) << 11) / (ulDest);
454
455 /* then number of destination pixels out we are */
456 ulFxOffset = ulFxScale * ((srcDest.ulDstX1 - srcDest.lDstX1) + ulClipOff);
457 ulFxOffset >>= 11;
458
459 /* this replaces the code which was making a decision as to use either ulFxOffset or ulSrcX1 */
460 ulSrcLeft = srcDest.ulSrcX1 + ulFxOffset;
461
462 /* then number of destination pixels out we are */
463 ulFxOffset = ulFxScale * (srcDest.lDstX2 - srcDest.ulDstX2);
464 ulFxOffset >>= 11;
465
466 ulSrcRight = srcDest.ulSrcX2 - ulFxOffset;
467
468 /*
469 * we must align these to our 128 bit boundaries. we shall
470 * round down the pixel pos to the nearest 8 pixels.
471 */
472 ulScaleLeft = ulSrcLeft;
473 ulScaleRight = ulSrcRight;
474
475 /* shift fxscale until it is in the range of the scaler */
476 ulhDecim = 0;
477 ulScale = (((ulSrcRight - ulSrcLeft) - 1) << (11 - ulhDecim)) / (ulRight - ulLeft + 2);
478
479 while (ulScale > 0x800) {
480 ulhDecim++;
481 ulScale = (((ulSrcRight - ulSrcLeft) - 1) << (11 - ulhDecim)) / (ulRight - ulLeft + 2);
482 }
483
484 /*
485 * to try and get the best values We first try and use
486 * src/dwdest for the scale factor, then we move onto src-1
487 *
488 * we want to check to see if we will need to clip data, if so
489 * then we should clip our source so that we don't need to
490 */
491 if (!ovlLinear) {
492 ulSrcLeft &= ~0x1f;
493
494 /*
495 * we must align the right hand edge to the next 32
496 * pixel` boundary, must be on a 256 boundary so u, and
497 * v are 128 bit aligned
498 */
499 ulSrcRight = (ulSrcRight + 0x1f) & ~0x1f;
500 } else {
501 ulSrcLeft &= ~0x7;
502
503 /*
504 * we must align the right hand edge to the next
505 * 8pixel` boundary
506 */
507 ulSrcRight = (ulSrcRight + 0x7) & ~0x7;
508 }
509
510 /* this is the input size line store needs to cope with */
511 ulWidth = ulSrcRight - ulSrcLeft;
512
513 /*
514 * use unclipped value to work out scale factror this is the
515 * scale factor we want we shall now work out the horizonal
516 * decimation and scaling
517 */
518 ulsVal = ((ulWidth / 8) >> ulhDecim);
519
520 if ((ulWidth != (ulsVal << ulhDecim) * 8))
521 ulsAdd = 1;
522
523 /* input pixels to scaler; */
524 ulSrc = ulWidth >> ulhDecim;
525
526 if (ulSrc <= 2)
527 return -EINVAL;
528
529 ulExcessPixels = ((((ulScaleLeft - ulSrcLeft)) << (11 - ulhDecim)) / ulScale);
530
531 ulClip = (ulSrc << 11) / ulScale;
532 ulClip -= (ulRight - ulLeft);
533 ulClip += ulExcessPixels;
534
535 if (ulClip)
536 ulClip--;
537
538 /* We may need to do more here if we really have a HW rev < 5 */
539 } while (!bResult);
540
541 ulExtraLines = (1 << ulhDecim) * ulVertDecFactor;
542 ulExtraLines += 64;
543 ulHeight += ulExtraLines;
544
545 ulDacXScale = ulScale;
546
547
548 tmp = STG_READ_REG(DACVerticalScal);
549 CLEAR_BITS_FRM_TO(0, 11);
550 CLEAR_BITS_FRM_TO(16, 22); /* Vertical Scaling */
551
552 /* Calculate new output line stride, this is always the number of 422
553 words in the line buffer, so it doesn't matter if the
554 mode is 420. Then set the vertical scale register.
555 */
556 ulStride = (ulWidth >> (ulhDecim + 3)) + ulsAdd;
557 tmp |= ((ulStride << 16) | (ulDacYScale)); /* DAC_LS_CTRL = stride */
558 STG_WRITE_REG(DACVerticalScal, tmp);
559
560 /* Now set up the overlay size using the modified width and height
561 from decimate and scaling calculations
562 */
563 tmp = STG_READ_REG(DACOverlaySize);
564 CLEAR_BITS_FRM_TO(0, 10);
565 CLEAR_BITS_FRM_TO(12, 31);
566
567 if (ovlLinear) {
568 tmp |=
569 (ovlStride | ((ulHeight + 1) << 12) |
570 (((ulWidth / 8) - 1) << 23));
571 } else {
572 tmp |=
573 (ovlStride | ((ulHeight + 1) << 12) |
574 (((ulWidth / 32) - 1) << 23));
575 }
576
577 STG_WRITE_REG(DACOverlaySize, tmp);
578
579 /* Set Video Window Start */
580 tmp = ((ulLeft << 16)) | (srcDest.ulDstY1);
581 STG_WRITE_REG(DACVidWinStart, tmp);
582
583 /* Set Video Window End */
584 tmp = ((ulRight) << 16) | (srcDest.ulDstY2);
585 STG_WRITE_REG(DACVidWinEnd, tmp);
586
587 /* Finally set up the rest of the overlay regs in the order
588 done in the IMG driver
589 */
590 tmp = STG_READ_REG(DACPixelFormat);
591 tmp = ((ulExcessPixels << 16) | tmp) & 0x7fffffff;
592 STG_WRITE_REG(DACPixelFormat, tmp);
593
594 tmp = STG_READ_REG(DACHorizontalScal);
595 CLEAR_BITS_FRM_TO(0, 11);
596 CLEAR_BITS_FRM_TO(16, 17);
597 tmp |= ((ulhDecim << 16) | (ulDacXScale));
598 STG_WRITE_REG(DACHorizontalScal, tmp);
599
600 return 0;
601 }
602