Mercurial > mplayer.hg
annotate vidix/sis_vid.c @ 22987:4f439985c7ce
synced with r23003
author | Gabrov |
---|---|
date | Mon, 16 Apr 2007 11:13:12 +0000 |
parents | f34e5d778267 |
children | 82216ef041e0 |
rev | line source |
---|---|
22850 | 1 /** |
2 VIDIX driver for SiS 300 and 310/325 series chips. | |
3 | |
4 Copyright 2003 Jake Page, Sugar Media. | |
5 | |
6 Based on SiS Xv driver: | |
7 Copyright 2002-2003 by Thomas Winischhofer, Vienna, Austria. | |
8 | |
9 This program is free software; you can redistribute it and/or modify | |
10 it under the terms of the GNU General Public License as published by | |
11 the Free Software Foundation; either version 2 of the License, or | |
12 (at your option) any later version. | |
13 | |
14 This program is distributed in the hope that it will be useful, | |
15 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 GNU General Public License for more details. | |
18 | |
19 You should have received a copy of the GNU General Public License | |
20 along with this program; if not, write to the Free Software | |
21 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
22 | |
23 2003/10/08 integrated into mplayer/vidix architecture -- Alex Beregszaszi | |
24 **/ | |
25 | |
26 #include <errno.h> | |
27 #include <stdio.h> | |
28 #include <stdlib.h> | |
29 #include <string.h> | |
30 #include <inttypes.h> | |
31 #include <unistd.h> | |
32 | |
33 #include "vidix.h" | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
34 #include "vidixlib.h" |
22850 | 35 #include "fourcc.h" |
22901 | 36 #include "dha.h" |
22900
a9e111b88c4a
merged libdha and libvidix, moved all files from libdha to vidix directory
ben
parents:
22867
diff
changeset
|
37 #include "pci_ids.h" |
a9e111b88c4a
merged libdha and libvidix, moved all files from libdha to vidix directory
ben
parents:
22867
diff
changeset
|
38 #include "pci_names.h" |
22905 | 39 #include "config.h" |
22850 | 40 |
41 #include "sis_regs.h" | |
42 #include "sis_defs.h" | |
43 | |
44 | |
45 /** Random defines **/ | |
46 | |
47 #define WATCHDOG_DELAY 500000 /* Watchdog counter for retrace waiting */ | |
48 #define IMAGE_MIN_WIDTH 32 /* Min and max source image sizes */ | |
49 #define IMAGE_MIN_HEIGHT 24 | |
50 #define IMAGE_MAX_WIDTH 720 | |
51 #define IMAGE_MAX_HEIGHT 576 | |
52 #define IMAGE_MAX_WIDTH_M650 1920 | |
53 #define IMAGE_MAX_HEIGHT_M650 1080 | |
54 | |
55 #define OVERLAY_MIN_WIDTH 32 /* Minimum overlay sizes */ | |
56 #define OVERLAY_MIN_HEIGHT 24 | |
57 | |
58 #define DISPMODE_SINGLE1 0x1 /* TW: CRT1 only */ | |
59 #define DISPMODE_SINGLE2 0x2 /* TW: CRT2 only */ | |
60 #define DISPMODE_MIRROR 0x4 /* TW: CRT1 + CRT2 MIRROR */ | |
61 | |
62 #define VMODE_INTERLACED 0x1 | |
63 #define VMODE_DOUBLESCAN 0x2 | |
64 | |
65 typedef struct { | |
66 short x1, y1, x2, y2; | |
67 } BoxRec; | |
68 | |
69 typedef struct { | |
70 int pixelFormat; | |
71 | |
72 uint16_t pitch; | |
73 uint16_t origPitch; | |
74 | |
75 uint8_t keyOP; | |
76 uint16_t HUSF; | |
77 uint16_t VUSF; | |
78 uint8_t IntBit; | |
79 uint8_t wHPre; | |
80 | |
81 uint16_t srcW; | |
82 uint16_t srcH; | |
83 | |
84 BoxRec dstBox; | |
85 | |
86 uint32_t PSY; | |
87 uint32_t PSV; | |
88 uint32_t PSU; | |
89 uint8_t bobEnable; | |
90 | |
91 uint8_t contrastCtrl; | |
92 uint8_t contrastFactor; | |
93 | |
94 uint8_t lineBufSize; | |
95 | |
96 uint8_t(*VBlankActiveFunc) (); | |
97 | |
98 uint16_t SCREENheight; | |
99 | |
100 } SISOverlayRec, *SISOverlayPtr; | |
101 | |
102 | |
103 /** static variable definitions **/ | |
104 static int sis_probed = 0; | |
105 static pciinfo_t pci_info; | |
106 unsigned int sis_verbose = 0; | |
107 | |
108 static void *sis_mem_base; | |
109 /* static void *sis_reg_base; */ | |
110 unsigned short sis_iobase; | |
111 | |
112 unsigned int sis_vga_engine = UNKNOWN_VGA; | |
113 static unsigned int sis_displaymode = DISPMODE_SINGLE1; | |
114 static unsigned int sis_has_two_overlays = 0; | |
115 static unsigned int sis_bridge_is_slave = 0; | |
116 static unsigned int sis_shift_value = 1; | |
117 static unsigned int sis_vmode = 0; | |
118 unsigned int sis_vbflags = DISPTYPE_DISP1; | |
119 unsigned int sis_overlay_on_crt1 = 1; | |
22867 | 120 int sis_crt1_off = -1; |
22850 | 121 unsigned int sis_detected_crt2_devices; |
122 unsigned int sis_force_crt2_type = CRT2_DEFAULT; | |
22867 | 123 int sis_device_id = -1; |
22850 | 124 |
125 static int sis_format; | |
126 static int sis_Yoff = 0; | |
127 static int sis_Voff = 0; | |
128 static int sis_Uoff = 0; | |
129 static int sis_screen_width = 640; | |
130 static int sis_screen_height = 480; | |
131 | |
132 static int sis_frames[VID_PLAY_MAXFRAMES]; | |
133 | |
134 static vidix_grkey_t sis_grkey; | |
135 | |
136 static vidix_capability_t sis_cap = { | |
137 "SiS 300/310/325 Video Driver", | |
138 "Jake Page", | |
139 TYPE_OUTPUT, | |
140 {0, 0, 0, 0}, | |
141 2048, | |
142 2048, | |
143 4, | |
144 4, | |
145 -1, | |
146 FLAG_UPSCALER | FLAG_DOWNSCALER | FLAG_EQUALIZER, | |
147 VENDOR_SIS, | |
148 -1, | |
149 {0, 0, 0, 0} | |
150 }; | |
151 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
152 static vidix_video_eq_t sis_equal = { |
22850 | 153 VEQ_CAP_BRIGHTNESS | VEQ_CAP_CONTRAST, |
154 200, 0, 0, 0, 0, 0, 0, 0 | |
155 }; | |
156 | |
157 static unsigned short sis_card_ids[] = { | |
158 DEVICE_SIS_300, | |
159 DEVICE_SIS_315H, | |
160 DEVICE_SIS_315, | |
161 DEVICE_SIS_315PRO, | |
162 DEVICE_SIS_330, | |
163 DEVICE_SIS_540_VGA, | |
164 DEVICE_SIS_550_VGA, | |
165 DEVICE_SIS_630_VGA, | |
166 DEVICE_SIS_650_VGA | |
167 }; | |
168 | |
169 /** function declarations **/ | |
170 | |
171 extern void sis_init_video_bridge(void); | |
172 | |
173 | |
174 static void set_overlay(SISOverlayPtr pOverlay, int index); | |
175 static void close_overlay(void); | |
176 static void calc_scale_factor(SISOverlayPtr pOverlay, | |
177 int index, int iscrt2); | |
178 static void set_line_buf_size(SISOverlayPtr pOverlay); | |
179 static void merge_line_buf(int enable); | |
180 static void set_format(SISOverlayPtr pOverlay); | |
181 static void set_colorkey(void); | |
182 | |
183 static void set_brightness(uint8_t brightness); | |
184 static void set_contrast(uint8_t contrast); | |
185 static void set_saturation(char saturation); | |
186 static void set_hue(uint8_t hue); | |
187 #if 0 | |
188 static void set_alpha(uint8_t alpha); | |
189 #endif | |
190 | |
191 /* IO Port access functions */ | |
192 static uint8_t getvideoreg(uint8_t reg) | |
193 { | |
194 uint8_t ret; | |
195 inSISIDXREG(SISVID, reg, ret); | |
196 return (ret); | |
197 } | |
198 | |
199 static void setvideoreg(uint8_t reg, uint8_t data) | |
200 { | |
201 outSISIDXREG(SISVID, reg, data); | |
202 } | |
203 | |
204 static void setvideoregmask(uint8_t reg, uint8_t data, uint8_t mask) | |
205 { | |
206 uint8_t old; | |
207 | |
208 inSISIDXREG(SISVID, reg, old); | |
209 data = (data & mask) | (old & (~mask)); | |
210 outSISIDXREG(SISVID, reg, data); | |
211 } | |
212 | |
213 static void setsrregmask(uint8_t reg, uint8_t data, uint8_t mask) | |
214 { | |
215 uint8_t old; | |
216 | |
217 inSISIDXREG(SISSR, reg, old); | |
218 data = (data & mask) | (old & (~mask)); | |
219 outSISIDXREG(SISSR, reg, data); | |
220 } | |
221 | |
222 /* vblank checking*/ | |
223 static uint8_t vblank_active_CRT1(void) | |
224 { | |
225 /* this may be too simplistic? */ | |
226 return (inSISREG(SISINPSTAT) & 0x08); | |
227 } | |
228 | |
229 static uint8_t vblank_active_CRT2(void) | |
230 { | |
231 uint8_t ret; | |
232 if (sis_vga_engine == SIS_315_VGA) { | |
233 inSISIDXREG(SISPART1, Index_310_CRT2_FC_VR, ret); | |
234 } else { | |
235 inSISIDXREG(SISPART1, Index_CRT2_FC_VR, ret); | |
236 } | |
237 return ((ret & 0x02) ^ 0x02); | |
238 } | |
239 | |
240 static int find_chip(unsigned chip_id) | |
241 { | |
242 unsigned i; | |
243 for (i = 0; i < sizeof(sis_card_ids) / sizeof(unsigned short); i++) { | |
244 if (chip_id == sis_card_ids[i]) | |
245 return i; | |
246 } | |
247 return -1; | |
248 } | |
249 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
250 static int sis_probe(int verbose, int force) |
22850 | 251 { |
252 pciinfo_t lst[MAX_PCI_DEVICES]; | |
253 unsigned i, num_pci; | |
254 int err; | |
255 | |
256 sis_verbose = verbose; | |
257 force = force; | |
258 err = pci_scan(lst, &num_pci); | |
259 if (err) { | |
260 printf("[SiS] Error occurred during pci scan: %s\n", strerror(err)); | |
261 return err; | |
262 } else { | |
263 err = ENXIO; | |
264 for (i = 0; i < num_pci; i++) { | |
265 if (lst[i].vendor == VENDOR_SIS) { | |
266 int idx; | |
267 const char *dname; | |
268 idx = find_chip(lst[i].device); | |
269 if (idx == -1) | |
270 continue; | |
271 dname = pci_device_name(VENDOR_SIS, lst[i].device); | |
272 dname = dname ? dname : "Unknown chip"; | |
273 if (sis_verbose > 0) | |
274 printf("[SiS] Found chip: %s (0x%X)\n", | |
275 dname, lst[i].device); | |
276 sis_device_id = sis_cap.device_id = lst[i].device; | |
277 err = 0; | |
278 memcpy(&pci_info, &lst[i], sizeof(pciinfo_t)); | |
279 | |
280 sis_has_two_overlays = 0; | |
281 switch (sis_cap.device_id) { | |
282 case DEVICE_SIS_300: | |
283 case DEVICE_SIS_630_VGA: | |
284 sis_has_two_overlays = 1; | |
285 case DEVICE_SIS_540_VGA: | |
286 sis_vga_engine = SIS_300_VGA; | |
287 break; | |
288 case DEVICE_SIS_330: | |
289 case DEVICE_SIS_550_VGA: | |
290 sis_has_two_overlays = 1; | |
291 case DEVICE_SIS_315H: | |
292 case DEVICE_SIS_315: | |
293 case DEVICE_SIS_315PRO: | |
294 case DEVICE_SIS_650_VGA: | |
295 /* M650 & 651 have 2 overlays */ | |
296 /* JCP: I think this works, but not really tested yet */ | |
297 { | |
298 unsigned char CR5F; | |
299 unsigned char tempreg1, tempreg2; | |
300 | |
301 inSISIDXREG(SISCR, 0x5F, CR5F); | |
302 CR5F &= 0xf0; | |
303 andSISIDXREG(SISCR, 0x5c, 0x07); | |
304 inSISIDXREG(SISCR, 0x5c, tempreg1); | |
305 tempreg1 &= 0xf8; | |
306 setSISIDXREG(SISCR, 0x5c, 0x07, 0xf8); | |
307 inSISIDXREG(SISCR, 0x5c, tempreg2); | |
308 tempreg2 &= 0xf8; | |
309 if ((!tempreg1) || (tempreg2)) { | |
310 if (CR5F & 0x80) { | |
311 sis_has_two_overlays = 1; | |
312 } | |
313 } else { | |
314 sis_has_two_overlays = 1; /* ? */ | |
315 } | |
316 if (sis_has_two_overlays) { | |
317 if (sis_verbose > 0) | |
318 printf | |
319 ("[SiS] detected M650/651 with 2 overlays\n"); | |
320 } | |
321 } | |
322 sis_vga_engine = SIS_315_VGA; | |
323 break; | |
324 default: | |
325 /* should never get here */ | |
326 sis_vga_engine = UNKNOWN_VGA; | |
327 break; | |
328 } | |
329 } | |
330 } | |
331 } | |
332 if (err && sis_verbose) { | |
333 printf("[SiS] Can't find chip\n"); | |
334 } else { | |
335 sis_probed = 1; | |
336 } | |
337 | |
338 return err; | |
339 } | |
340 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
341 static int sis_init(void) |
22850 | 342 { |
343 uint8_t sr_data, cr_data, cr_data2; | |
344 char *env_overlay_crt; | |
345 | |
346 if (!sis_probed) { | |
347 printf("[SiS] driver was not probed but is being initialized\n"); | |
348 return (EINTR); | |
349 } | |
350 | |
351 /* JCP: this is WRONG. Need to coordinate w/ sisfb to use correct mem */ | |
352 /* map 16MB scary hack for now. */ | |
353 sis_mem_base = map_phys_mem(pci_info.base0, 0x1000000); | |
354 /* sis_reg_base = map_phys_mem(pci_info.base1, 0x20000); */ | |
355 sis_iobase = pci_info.base2 & 0xFFFC; | |
356 | |
357 /* would like to use fb ioctl - or some other method - here to get | |
358 current resolution. */ | |
359 inSISIDXREG(SISCR, 0x12, cr_data); | |
360 inSISIDXREG(SISCR, 0x07, cr_data2); | |
361 sis_screen_height = | |
362 ((cr_data & 0xff) | ((uint16_t) (cr_data2 & 0x02) << 7) | | |
363 ((uint16_t) (cr_data2 & 0x40) << 3) | ((uint16_t) (cr_data & 0x02) | |
364 << 9)) + 1; | |
365 | |
366 inSISIDXREG(SISSR, 0x0b, sr_data); | |
367 inSISIDXREG(SISCR, 0x01, cr_data); | |
368 sis_screen_width = (((cr_data & 0xff) | | |
369 ((uint16_t) (sr_data & 0x0C) << 6)) + 1) * 8; | |
370 | |
371 inSISIDXREG(SISSR, Index_SR_Graphic_Mode, sr_data); | |
372 if (sr_data & 0x20) /* interlaced mode */ | |
373 sis_vmode |= VMODE_INTERLACED; | |
374 | |
375 #if 0 /* getting back false data here... */ | |
376 /* CR9 bit 7 set = double scan active */ | |
377 inSISIDXREG(SISCR, 0x09, cr_data); | |
378 if (cr_data & 0x40) { | |
379 sis_vmode |= VMODE_DOUBLESCAN; | |
380 } | |
381 #endif | |
382 | |
383 /* JCP: eventually I'd like to replace this with a call to sisfb | |
384 SISFB_GET_INFO ioctl to get video bridge info. Not for now, | |
385 since it requires a very new and not widely distributed version. */ | |
386 sis_init_video_bridge(); | |
387 | |
388 env_overlay_crt = getenv("VIDIX_CRT"); | |
389 if (env_overlay_crt) { | |
390 int crt = atoi(env_overlay_crt); | |
391 if (crt == 1 || crt == 2) { | |
392 sis_overlay_on_crt1 = (crt == 1); | |
393 if (sis_verbose > 0) { | |
394 printf | |
395 ("[SiS] override: using overlay on CRT%d from VIDIX_CRT\n", | |
396 crt); | |
397 } | |
398 } | |
399 } | |
400 | |
401 return 0; | |
402 } | |
403 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
404 static void sis_destroy(void) |
22850 | 405 { |
406 /* unmap_phys_mem(sis_reg_base, 0x20000); */ | |
407 /* JCP: see above, hence also a hack. */ | |
408 unmap_phys_mem(sis_mem_base, 0x1000000); | |
409 } | |
410 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
411 static int sis_get_caps(vidix_capability_t * to) |
22850 | 412 { |
413 memcpy(to, &sis_cap, sizeof(vidix_capability_t)); | |
414 return 0; | |
415 } | |
416 | |
417 static int is_supported_fourcc(uint32_t fourcc) | |
418 { | |
419 switch (fourcc) { | |
420 case IMGFMT_YV12: | |
421 case IMGFMT_I420: | |
422 case IMGFMT_UYVY: | |
423 case IMGFMT_YUY2: | |
424 case IMGFMT_RGB15: | |
425 case IMGFMT_RGB16: | |
426 return 1; | |
427 default: | |
428 return 0; | |
429 } | |
430 } | |
431 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
432 static int sis_query_fourcc(vidix_fourcc_t * to) |
22850 | 433 { |
434 if (is_supported_fourcc(to->fourcc)) { | |
435 to->depth = VID_DEPTH_8BPP | VID_DEPTH_16BPP | VID_DEPTH_32BPP; | |
436 to->flags = VID_CAP_EXPAND | VID_CAP_SHRINK | VID_CAP_COLORKEY; | |
437 return 0; | |
438 } else | |
439 to->depth = to->flags = 0; | |
440 return ENOSYS; | |
441 } | |
442 | |
443 static int bridge_in_slave_mode(void) | |
444 { | |
445 unsigned char usScratchP1_00; | |
446 | |
447 if (!(sis_vbflags & VB_VIDEOBRIDGE)) | |
448 return 0; | |
449 | |
450 inSISIDXREG(SISPART1, 0x00, usScratchP1_00); | |
451 if (((sis_vga_engine == SIS_300_VGA) | |
452 && (usScratchP1_00 & 0xa0) == 0x20) | |
453 || ((sis_vga_engine == SIS_315_VGA) | |
454 && (usScratchP1_00 & 0x50) == 0x10)) { | |
455 return 1; | |
456 } else { | |
457 return 0; | |
458 } | |
459 } | |
460 | |
461 /* This does not handle X dual head mode, since 1) vidix doesn't support it | |
462 and 2) it doesn't make sense for other gfx drivers */ | |
463 static void set_dispmode(void) | |
464 { | |
465 sis_bridge_is_slave = 0; | |
466 | |
467 if (bridge_in_slave_mode()) | |
468 sis_bridge_is_slave = 1; | |
469 | |
470 if ((sis_vbflags & VB_DISPMODE_MIRROR) || | |
471 (sis_bridge_is_slave && (sis_vbflags & DISPTYPE_DISP2))) { | |
472 if (sis_has_two_overlays) | |
473 sis_displaymode = DISPMODE_MIRROR; /* TW: CRT1+CRT2 (2 overlays) */ | |
474 else if (!sis_overlay_on_crt1) | |
475 sis_displaymode = DISPMODE_SINGLE2; | |
476 else | |
477 sis_displaymode = DISPMODE_SINGLE1; | |
478 } else { | |
479 if (sis_vbflags & DISPTYPE_DISP1) { | |
480 sis_displaymode = DISPMODE_SINGLE1; /* TW: CRT1 only */ | |
481 } else { | |
482 sis_displaymode = DISPMODE_SINGLE2; /* TW: CRT2 only */ | |
483 } | |
484 } | |
485 } | |
486 | |
487 static void set_disptype_regs(void) | |
488 { | |
489 switch (sis_displaymode) { | |
490 case DISPMODE_SINGLE1: /* TW: CRT1 only */ | |
491 if (sis_verbose > 2) { | |
492 printf("[SiS] Setting up overlay on CRT1\n"); | |
493 } | |
494 if (sis_has_two_overlays) { | |
495 setsrregmask(0x06, 0x00, 0xc0); | |
496 setsrregmask(0x32, 0x00, 0xc0); | |
497 } else { | |
498 setsrregmask(0x06, 0x00, 0xc0); | |
499 setsrregmask(0x32, 0x00, 0xc0); | |
500 } | |
501 break; | |
502 case DISPMODE_SINGLE2: /* TW: CRT2 only */ | |
503 if (sis_verbose > 2) { | |
504 printf("[SiS] Setting up overlay on CRT2\n"); | |
505 } | |
506 if (sis_has_two_overlays) { | |
507 setsrregmask(0x06, 0x80, 0xc0); | |
508 setsrregmask(0x32, 0x80, 0xc0); | |
509 } else { | |
510 setsrregmask(0x06, 0x40, 0xc0); | |
511 setsrregmask(0x32, 0x40, 0xc0); | |
512 } | |
513 break; | |
514 case DISPMODE_MIRROR: /* TW: CRT1 + CRT2 */ | |
515 default: | |
516 if (sis_verbose > 2) { | |
517 printf("[SiS] Setting up overlay on CRT1 AND CRT2!\n"); | |
518 } | |
519 setsrregmask(0x06, 0x80, 0xc0); | |
520 setsrregmask(0x32, 0x80, 0xc0); | |
521 break; | |
522 } | |
523 } | |
524 | |
525 static void init_overlay(void) | |
526 { | |
527 /* Initialize first overlay (CRT1) */ | |
528 | |
529 /* Write-enable video registers */ | |
530 setvideoregmask(Index_VI_Control_Misc2, 0x80, 0x81); | |
531 | |
532 /* Disable overlay */ | |
533 setvideoregmask(Index_VI_Control_Misc0, 0x00, 0x02); | |
534 | |
535 /* Disable bobEnable */ | |
536 setvideoregmask(Index_VI_Control_Misc1, 0x02, 0x02); | |
537 | |
538 /* Reset scale control and contrast */ | |
539 setvideoregmask(Index_VI_Scale_Control, 0x60, 0x60); | |
540 setvideoregmask(Index_VI_Contrast_Enh_Ctrl, 0x04, 0x1F); | |
541 | |
542 setvideoreg(Index_VI_Disp_Y_Buf_Preset_Low, 0x00); | |
543 setvideoreg(Index_VI_Disp_Y_Buf_Preset_Middle, 0x00); | |
544 setvideoreg(Index_VI_UV_Buf_Preset_Low, 0x00); | |
545 setvideoreg(Index_VI_UV_Buf_Preset_Middle, 0x00); | |
546 setvideoreg(Index_VI_Disp_Y_UV_Buf_Preset_High, 0x00); | |
547 setvideoreg(Index_VI_Play_Threshold_Low, 0x00); | |
548 setvideoreg(Index_VI_Play_Threshold_High, 0x00); | |
549 | |
550 /* may not want to init these here, could already be set to other | |
551 values by app? */ | |
552 setvideoregmask(Index_VI_Control_Misc2, 0x00, 0x01); | |
553 setvideoregmask(Index_VI_Contrast_Enh_Ctrl, 0x04, 0x07); | |
554 setvideoreg(Index_VI_Brightness, 0x20); | |
555 if (sis_vga_engine == SIS_315_VGA) { | |
556 setvideoreg(Index_VI_Hue, 0x00); | |
557 setvideoreg(Index_VI_Saturation, 0x00); | |
558 } | |
559 | |
560 /* Initialize second overlay (CRT2) */ | |
561 if (sis_has_two_overlays) { | |
562 /* Write-enable video registers */ | |
563 setvideoregmask(Index_VI_Control_Misc2, 0x81, 0x81); | |
564 | |
565 /* Disable overlay */ | |
566 setvideoregmask(Index_VI_Control_Misc0, 0x00, 0x02); | |
567 | |
568 /* Disable bobEnable */ | |
569 setvideoregmask(Index_VI_Control_Misc1, 0x02, 0x02); | |
570 | |
571 /* Reset scale control and contrast */ | |
572 setvideoregmask(Index_VI_Scale_Control, 0x60, 0x60); | |
573 setvideoregmask(Index_VI_Contrast_Enh_Ctrl, 0x04, 0x1F); | |
574 | |
575 setvideoreg(Index_VI_Disp_Y_Buf_Preset_Low, 0x00); | |
576 setvideoreg(Index_VI_Disp_Y_Buf_Preset_Middle, 0x00); | |
577 setvideoreg(Index_VI_UV_Buf_Preset_Low, 0x00); | |
578 setvideoreg(Index_VI_UV_Buf_Preset_Middle, 0x00); | |
579 setvideoreg(Index_VI_Disp_Y_UV_Buf_Preset_High, 0x00); | |
580 setvideoreg(Index_VI_Play_Threshold_Low, 0x00); | |
581 setvideoreg(Index_VI_Play_Threshold_High, 0x00); | |
582 | |
583 setvideoregmask(Index_VI_Control_Misc2, 0x01, 0x01); | |
584 setvideoregmask(Index_VI_Contrast_Enh_Ctrl, 0x04, 0x07); | |
585 setvideoreg(Index_VI_Brightness, 0x20); | |
586 if (sis_vga_engine == SIS_315_VGA) { | |
587 setvideoreg(Index_VI_Hue, 0x00); | |
588 setvideoreg(Index_VI_Saturation, 0x00); | |
589 } | |
590 } | |
591 } | |
592 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
593 static int sis_set_eq(const vidix_video_eq_t * eq); |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
594 |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
595 static int sis_config_playback(vidix_playback_t * info) |
22850 | 596 { |
597 SISOverlayRec overlay; | |
598 int srcOffsetX = 0, srcOffsetY = 0; | |
599 int sx, sy; | |
600 int index = 0, iscrt2 = 0; | |
601 int total_size; | |
602 | |
603 short src_w, drw_w; | |
604 short src_h, drw_h; | |
605 short src_x, drw_x; | |
606 short src_y, drw_y; | |
607 long dga_offset; | |
608 int pitch; | |
609 unsigned int i; | |
610 | |
611 if (!is_supported_fourcc(info->fourcc)) | |
612 return -1; | |
613 | |
614 /* set chipset/engine.dependent config info */ | |
615 /* which CRT to use, etc.? */ | |
616 switch (sis_vga_engine) { | |
617 case SIS_315_VGA: | |
618 sis_shift_value = 1; | |
619 sis_equal.cap |= VEQ_CAP_SATURATION | VEQ_CAP_HUE; | |
620 break; | |
621 case SIS_300_VGA: | |
622 default: | |
623 sis_shift_value = 2; | |
624 break; | |
625 } | |
626 | |
627 sis_displaymode = DISPMODE_SINGLE1; /* xV driver code in set_dispmode() */ | |
628 set_dispmode(); | |
629 | |
630 set_disptype_regs(); | |
631 | |
632 init_overlay(); | |
633 | |
634 /* get basic dimension info */ | |
635 src_x = info->src.x; | |
636 src_y = info->src.y; | |
637 src_w = info->src.w; | |
638 src_h = info->src.h; | |
639 | |
640 drw_x = info->dest.x; | |
641 drw_y = info->dest.y; | |
642 drw_w = info->dest.w; | |
643 drw_h = info->dest.h; | |
644 | |
645 switch (info->fourcc) { | |
646 case IMGFMT_YV12: | |
647 case IMGFMT_I420: | |
648 pitch = (src_w + 7) & ~7; | |
649 total_size = (pitch * src_h * 3) >> 1; | |
650 break; | |
651 case IMGFMT_YUY2: | |
652 case IMGFMT_UYVY: | |
653 case IMGFMT_RGB15: | |
654 case IMGFMT_RGB16: | |
655 pitch = ((src_w << 1) + 3) & ~3; | |
656 total_size = pitch * src_h; | |
657 break; | |
658 default: | |
659 return -1; | |
660 } | |
661 | |
662 /* "allocate" memory for overlay! */ | |
663 /* start at 8MB = sisfb's "dri reserved space" - | |
664 really shouldn't hardcode though */ | |
665 /* XXX: JCP - this can use the sisfb FBIO_ALLOC ioctl to safely | |
666 allocate "video heap" memory... */ | |
667 dga_offset = 0x800000; | |
668 | |
669 /* use 7MB for now. need to calc/get real info from sisfb? */ | |
670 /* this can result in a LOT of frames - probably not necessary */ | |
671 info->num_frames = 0x700000 / (total_size * 2); | |
672 if (info->num_frames > VID_PLAY_MAXFRAMES) | |
673 info->num_frames = VID_PLAY_MAXFRAMES; | |
674 | |
675 info->dga_addr = sis_mem_base + dga_offset; | |
676 info->dest.pitch.y = 16; | |
677 info->dest.pitch.u = 16; | |
678 info->dest.pitch.v = 16; | |
679 info->offset.y = 0; | |
680 info->offset.u = 0; | |
681 info->offset.v = 0; | |
682 info->frame_size = (total_size * 2); /* why times 2 ? */ | |
683 for (i = 0; i < info->num_frames; i++) { | |
684 info->offsets[i] = info->frame_size * i; | |
685 /* save ptrs to mem buffers */ | |
686 sis_frames[i] = (dga_offset + info->offsets[i]); | |
687 } | |
688 | |
689 memset(&overlay, 0, sizeof(overlay)); | |
690 overlay.pixelFormat = sis_format = info->fourcc; | |
691 overlay.pitch = overlay.origPitch = pitch; | |
692 | |
693 | |
694 overlay.keyOP = (sis_grkey.ckey.op == CKEY_TRUE ? | |
695 VI_ROP_DestKey : VI_ROP_Always); | |
696 | |
697 overlay.bobEnable = 0x00; | |
698 | |
699 overlay.SCREENheight = sis_screen_height; | |
700 | |
701 /* probably will not support X virtual screen > phys very well? */ | |
702 overlay.dstBox.x1 = drw_x; /* - pScrn->frameX0; */ | |
703 overlay.dstBox.x2 = drw_x + drw_w; /* - pScrn->frameX0; ??? */ | |
704 overlay.dstBox.y1 = drw_y; /* - pScrn->frameY0; */ | |
705 overlay.dstBox.y2 = drw_y + drw_h; /* - pScrn->frameY0; ??? */ | |
706 | |
707 if ((overlay.dstBox.x1 > overlay.dstBox.x2) || | |
708 (overlay.dstBox.y1 > overlay.dstBox.y2)) | |
709 return -1; | |
710 | |
711 if ((overlay.dstBox.x2 < 0) || (overlay.dstBox.y2 < 0)) | |
712 return -1; | |
713 | |
714 if (overlay.dstBox.x1 < 0) { | |
715 srcOffsetX = src_w * (-overlay.dstBox.x1) / drw_w; | |
716 overlay.dstBox.x1 = 0; | |
717 } | |
718 if (overlay.dstBox.y1 < 0) { | |
719 srcOffsetY = src_h * (-overlay.dstBox.y1) / drw_h; | |
720 overlay.dstBox.y1 = 0; | |
721 } | |
722 | |
723 switch (info->fourcc) { | |
724 case IMGFMT_YV12: | |
725 info->dest.pitch.y = 16; | |
726 sx = (src_x + srcOffsetX) & ~7; | |
727 sy = (src_y + srcOffsetY) & ~1; | |
728 info->offset.y = sis_Yoff = sx + sy * pitch; | |
729 /* JCP: NOTE reversed u & v here! Not sure why this is needed. | |
730 maybe mplayer & sis define U & V differently?? */ | |
731 info->offset.u = sis_Voff = | |
732 src_h * pitch + ((sx + sy * pitch / 2) >> 1); | |
733 info->offset.v = sis_Uoff = | |
734 src_h * pitch * 5 / 4 + ((sx + sy * pitch / 2) >> 1); | |
735 | |
736 overlay.PSY = (sis_frames[0] + sis_Yoff) >> sis_shift_value; | |
737 overlay.PSV = (sis_frames[0] + sis_Voff) >> sis_shift_value; | |
738 overlay.PSU = (sis_frames[0] + sis_Uoff) >> sis_shift_value; | |
739 break; | |
740 case IMGFMT_I420: | |
741 sx = (src_x + srcOffsetX) & ~7; | |
742 sy = (src_y + srcOffsetY) & ~1; | |
743 info->offset.y = sis_Yoff = sx + sy * pitch; | |
744 /* JCP: see above... */ | |
745 info->offset.u = sis_Voff = | |
746 src_h * pitch * 5 / 4 + ((sx + sy * pitch / 2) >> 1); | |
747 info->offset.v = sis_Uoff = | |
748 src_h * pitch + ((sx + sy * pitch / 2) >> 1); | |
749 | |
750 overlay.PSY = (sis_frames[0] + sis_Yoff) >> sis_shift_value; | |
751 overlay.PSV = (sis_frames[0] + sis_Voff) >> sis_shift_value; | |
752 overlay.PSU = (sis_frames[0] + sis_Uoff) >> sis_shift_value; | |
753 break; | |
754 case IMGFMT_YUY2: | |
755 case IMGFMT_UYVY: | |
756 case IMGFMT_RGB16: | |
757 case IMGFMT_RGB15: | |
758 default: | |
759 sx = (src_x + srcOffsetX) & ~1; | |
760 sy = (src_y + srcOffsetY); | |
761 info->offset.y = sis_Yoff = sx * 2 + sy * pitch; | |
762 | |
763 overlay.PSY = (sis_frames[0] + sis_Yoff) >> sis_shift_value; | |
764 break; | |
765 } | |
766 | |
767 /* FIXME: is it possible that srcW < 0? */ | |
768 overlay.srcW = src_w - (sx - src_x); | |
769 overlay.srcH = src_h - (sy - src_y); | |
770 | |
771 /* JCP: what to do about this? */ | |
772 #if 0 | |
773 if ((pPriv->oldx1 != overlay.dstBox.x1) || | |
774 (pPriv->oldx2 != overlay.dstBox.x2) || | |
775 (pPriv->oldy1 != overlay.dstBox.y1) || | |
776 (pPriv->oldy2 != overlay.dstBox.y2)) { | |
777 pPriv->mustwait = 1; | |
778 pPriv->oldx1 = overlay.dstBox.x1; | |
779 pPriv->oldx2 = overlay.dstBox.x2; | |
780 pPriv->oldy1 = overlay.dstBox.y1; | |
781 pPriv->oldy2 = overlay.dstBox.y2; | |
782 } | |
783 #endif | |
784 | |
785 /* set merge line buffer */ | |
786 merge_line_buf(overlay.srcW > 384); | |
787 | |
788 /* calculate line buffer length */ | |
789 set_line_buf_size(&overlay); | |
790 | |
791 if (sis_displaymode == DISPMODE_SINGLE2) { | |
792 if (sis_has_two_overlays) { | |
793 /* TW: On chips with two overlays we use | |
794 * overlay 2 for CRT2 */ | |
795 index = 1; | |
796 iscrt2 = 1; | |
797 } else { | |
798 /* TW: On chips with only one overlay we | |
799 * use that only overlay for CRT2 */ | |
800 index = 0; | |
801 iscrt2 = 1; | |
802 } | |
803 overlay.VBlankActiveFunc = vblank_active_CRT2; | |
804 /* overlay.GetScanLineFunc = get_scanline_CRT2; */ | |
805 } else { | |
806 index = 0; | |
807 iscrt2 = 0; | |
808 overlay.VBlankActiveFunc = vblank_active_CRT1; | |
809 /* overlay.GetScanLineFunc = get_scanline_CRT1; */ | |
810 } | |
811 | |
812 /* calc scale factor (to use below) */ | |
813 calc_scale_factor(&overlay, index, iscrt2); | |
814 | |
815 /* Select video1 (used for CRT1) or video2 (used for CRT2) */ | |
816 setvideoregmask(Index_VI_Control_Misc2, index, 0x01); | |
817 | |
818 set_format(&overlay); | |
819 | |
820 set_colorkey(); | |
821 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
822 sis_set_eq(&sis_equal); |
22850 | 823 |
824 /* set up video overlay registers */ | |
825 set_overlay(&overlay, index); | |
826 | |
827 /* prevent badness if bits are not at default setting */ | |
828 setvideoregmask(Index_VI_Control_Misc1, 0x00, 0x01); | |
829 setvideoregmask(Index_VI_Control_Misc2, 0x00, 0x04); | |
830 | |
831 /* JCP: Xv driver implementation loops back over above code to | |
832 setup mirror CRT2 */ | |
833 | |
834 return 0; | |
835 } | |
836 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
837 static int sis_playback_on(void) |
22850 | 838 { |
839 setvideoregmask(Index_VI_Control_Misc0, 0x02, 0x02); | |
840 return 0; | |
841 } | |
842 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
843 static int sis_playback_off(void) |
22850 | 844 { |
845 unsigned char sridx, cridx; | |
846 sridx = inSISREG(SISSR); | |
847 cridx = inSISREG(SISCR); | |
848 close_overlay(); | |
849 outSISREG(SISSR, sridx); | |
850 outSISREG(SISCR, cridx); | |
851 | |
852 return 0; | |
853 } | |
854 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
855 static int sis_frame_select(unsigned int frame) |
22850 | 856 { |
857 uint8_t data; | |
858 int index = 0; | |
859 uint32_t PSY; | |
860 | |
861 if (sis_displaymode == DISPMODE_SINGLE2 && sis_has_two_overlays) { | |
862 index = 1; | |
863 } | |
864 | |
865 PSY = (sis_frames[frame] + sis_Yoff) >> sis_shift_value; | |
866 | |
867 /* Unlock address registers */ | |
868 data = getvideoreg(Index_VI_Control_Misc1); | |
869 setvideoreg(Index_VI_Control_Misc1, data | 0x20); | |
870 /* TEST: Is this required? */ | |
871 setvideoreg(Index_VI_Control_Misc1, data | 0x20); | |
872 /* TEST end */ | |
873 /* TEST: Is this required? */ | |
874 if (sis_vga_engine == SIS_315_VGA) | |
875 setvideoreg(Index_VI_Control_Misc3, 0x00); | |
876 /* TEST end */ | |
877 | |
878 /* set Y start address */ | |
879 setvideoreg(Index_VI_Disp_Y_Buf_Start_Low, (uint8_t) (PSY)); | |
880 setvideoreg(Index_VI_Disp_Y_Buf_Start_Middle, (uint8_t) ((PSY) >> 8)); | |
881 setvideoreg(Index_VI_Disp_Y_Buf_Start_High, (uint8_t) ((PSY) >> 16)); | |
882 /* set 310/325 series overflow bits for Y plane */ | |
883 if (sis_vga_engine == SIS_315_VGA) { | |
884 setvideoreg(Index_VI_Y_Buf_Start_Over, | |
885 ((uint8_t) ((PSY) >> 24) & 0x01)); | |
886 } | |
887 | |
888 /* Set U/V data if using plane formats */ | |
889 if ((sis_format == IMGFMT_YV12) || (sis_format == IMGFMT_I420)) { | |
890 | |
891 uint32_t PSU, PSV; | |
892 | |
893 PSU = (sis_frames[frame] + sis_Uoff) >> sis_shift_value; | |
894 PSV = (sis_frames[frame] + sis_Voff) >> sis_shift_value; | |
895 | |
896 /* set U/V start address */ | |
897 setvideoreg(Index_VI_U_Buf_Start_Low, (uint8_t) PSU); | |
898 setvideoreg(Index_VI_U_Buf_Start_Middle, (uint8_t) (PSU >> 8)); | |
899 setvideoreg(Index_VI_U_Buf_Start_High, (uint8_t) (PSU >> 16)); | |
900 | |
901 setvideoreg(Index_VI_V_Buf_Start_Low, (uint8_t) PSV); | |
902 setvideoreg(Index_VI_V_Buf_Start_Middle, (uint8_t) (PSV >> 8)); | |
903 setvideoreg(Index_VI_V_Buf_Start_High, (uint8_t) (PSV >> 16)); | |
904 | |
905 /* 310/325 series overflow bits */ | |
906 if (sis_vga_engine == SIS_315_VGA) { | |
907 setvideoreg(Index_VI_U_Buf_Start_Over, | |
908 ((uint8_t) (PSU >> 24) & 0x01)); | |
909 setvideoreg(Index_VI_V_Buf_Start_Over, | |
910 ((uint8_t) (PSV >> 24) & 0x01)); | |
911 } | |
912 } | |
913 | |
914 if (sis_vga_engine == SIS_315_VGA) { | |
915 /* Trigger register copy for 310 series */ | |
916 setvideoreg(Index_VI_Control_Misc3, 1 << index); | |
917 } | |
918 | |
919 /* Lock the address registers */ | |
920 setvideoregmask(Index_VI_Control_Misc1, 0x00, 0x20); | |
921 | |
922 return 0; | |
923 } | |
924 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
925 static int sis_get_gkeys(vidix_grkey_t * grkey) |
22850 | 926 { |
927 memcpy(grkey, &sis_grkey, sizeof(vidix_grkey_t)); | |
928 return 0; | |
929 } | |
930 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
931 static int sis_set_gkeys(const vidix_grkey_t * grkey) |
22850 | 932 { |
933 memcpy(&sis_grkey, grkey, sizeof(vidix_grkey_t)); | |
934 set_colorkey(); | |
935 return 0; | |
936 } | |
937 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
938 static int sis_get_eq(vidix_video_eq_t * eq) |
22850 | 939 { |
940 memcpy(eq, &sis_equal, sizeof(vidix_video_eq_t)); | |
941 return 0; | |
942 } | |
943 | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
944 static int sis_set_eq(const vidix_video_eq_t * eq) |
22850 | 945 { |
946 int br, sat, cr, hue; | |
947 if (eq->cap & VEQ_CAP_BRIGHTNESS) | |
948 sis_equal.brightness = eq->brightness; | |
949 if (eq->cap & VEQ_CAP_CONTRAST) | |
950 sis_equal.contrast = eq->contrast; | |
951 if (eq->cap & VEQ_CAP_SATURATION) | |
952 sis_equal.saturation = eq->saturation; | |
953 if (eq->cap & VEQ_CAP_HUE) | |
954 sis_equal.hue = eq->hue; | |
955 if (eq->cap & VEQ_CAP_RGB_INTENSITY) { | |
956 sis_equal.red_intensity = eq->red_intensity; | |
957 sis_equal.green_intensity = eq->green_intensity; | |
958 sis_equal.blue_intensity = eq->blue_intensity; | |
959 } | |
960 sis_equal.flags = eq->flags; | |
961 | |
962 cr = (sis_equal.contrast + 1000) * 7 / 2000; | |
963 if (cr < 0) | |
964 cr = 0; | |
965 if (cr > 7) | |
966 cr = 7; | |
967 | |
968 br = sis_equal.brightness * 127 / 1000; | |
969 if (br < -128) | |
970 br = -128; | |
971 if (br > 127) | |
972 br = 127; | |
973 | |
974 sat = (sis_equal.saturation * 7) / 1000; | |
975 if (sat < -7) | |
976 sat = -7; | |
977 if (sat > 7) | |
978 sat = 7; | |
979 | |
980 hue = sis_equal.hue * 7 / 1000; | |
981 if (hue < -8) | |
982 hue = -8; | |
983 if (hue > 7) | |
984 hue = 7; | |
985 | |
986 set_brightness(br); | |
987 set_contrast(cr); | |
988 if (sis_vga_engine == SIS_315_VGA) { | |
989 set_saturation(sat); | |
990 set_hue(hue); | |
991 } | |
992 | |
993 return 0; | |
994 } | |
995 | |
996 static void set_overlay(SISOverlayPtr pOverlay, int index) | |
997 { | |
998 uint16_t pitch = 0; | |
999 uint8_t h_over = 0, v_over = 0; | |
1000 uint16_t top, bottom, left, right; | |
1001 uint16_t screenX = sis_screen_width; | |
1002 uint16_t screenY = sis_screen_height; | |
1003 uint8_t data; | |
1004 uint32_t watchdog; | |
1005 | |
1006 top = pOverlay->dstBox.y1; | |
1007 bottom = pOverlay->dstBox.y2; | |
1008 if (bottom > screenY) { | |
1009 bottom = screenY; | |
1010 } | |
1011 | |
1012 left = pOverlay->dstBox.x1; | |
1013 right = pOverlay->dstBox.x2; | |
1014 if (right > screenX) { | |
1015 right = screenX; | |
1016 } | |
1017 | |
1018 /* JCP: these aren't really tested... */ | |
1019 /* TW: DoubleScan modes require Y coordinates * 2 */ | |
1020 if (sis_vmode & VMODE_DOUBLESCAN) { | |
1021 top <<= 1; | |
1022 bottom <<= 1; | |
1023 } | |
1024 /* TW: Interlace modes require Y coordinates / 2 */ | |
1025 if (sis_vmode & VMODE_INTERLACED) { | |
1026 top >>= 1; | |
1027 bottom >>= 1; | |
1028 } | |
1029 | |
1030 h_over = (((left >> 8) & 0x0f) | ((right >> 4) & 0xf0)); | |
1031 v_over = (((top >> 8) & 0x0f) | ((bottom >> 4) & 0xf0)); | |
1032 | |
1033 pitch = pOverlay->pitch >> sis_shift_value; | |
1034 | |
1035 /* set line buffer size */ | |
1036 setvideoreg(Index_VI_Line_Buffer_Size, pOverlay->lineBufSize); | |
1037 | |
1038 /* set color key mode */ | |
1039 setvideoregmask(Index_VI_Key_Overlay_OP, pOverlay->keyOP, 0x0F); | |
1040 | |
1041 /* TW: We don't have to wait for vertical retrace in all cases */ | |
1042 /* JCP: be safe for now. */ | |
1043 if (1 /*pPriv->mustwait */ ) { | |
1044 watchdog = WATCHDOG_DELAY; | |
1045 while (pOverlay->VBlankActiveFunc() && --watchdog); | |
1046 watchdog = WATCHDOG_DELAY; | |
1047 while ((!pOverlay->VBlankActiveFunc()) && --watchdog); | |
1048 if (!watchdog && sis_verbose > 0) { | |
1049 printf("[SiS]: timed out waiting for vertical retrace\n"); | |
1050 } | |
1051 } | |
1052 | |
1053 /* Unlock address registers */ | |
1054 data = getvideoreg(Index_VI_Control_Misc1); | |
1055 setvideoreg(Index_VI_Control_Misc1, data | 0x20); | |
1056 /* TEST: Is this required? */ | |
1057 setvideoreg(Index_VI_Control_Misc1, data | 0x20); | |
1058 /* TEST end */ | |
1059 | |
1060 /* TEST: Is this required? */ | |
1061 if (sis_vga_engine == SIS_315_VGA) | |
1062 setvideoreg(Index_VI_Control_Misc3, 0x00); | |
1063 /* TEST end */ | |
1064 | |
1065 /* Set Y buf pitch */ | |
1066 setvideoreg(Index_VI_Disp_Y_Buf_Pitch_Low, (uint8_t) (pitch)); | |
1067 setvideoregmask(Index_VI_Disp_Y_UV_Buf_Pitch_Middle, | |
1068 (uint8_t) (pitch >> 8), 0x0f); | |
1069 | |
1070 /* Set Y start address */ | |
1071 setvideoreg(Index_VI_Disp_Y_Buf_Start_Low, (uint8_t) (pOverlay->PSY)); | |
1072 setvideoreg(Index_VI_Disp_Y_Buf_Start_Middle, | |
1073 (uint8_t) ((pOverlay->PSY) >> 8)); | |
1074 setvideoreg(Index_VI_Disp_Y_Buf_Start_High, | |
1075 (uint8_t) ((pOverlay->PSY) >> 16)); | |
1076 | |
1077 /* set 310/325 series overflow bits for Y plane */ | |
1078 if (sis_vga_engine == SIS_315_VGA) { | |
1079 setvideoreg(Index_VI_Disp_Y_Buf_Pitch_High, | |
1080 (uint8_t) (pitch >> 12)); | |
1081 setvideoreg(Index_VI_Y_Buf_Start_Over, | |
1082 ((uint8_t) ((pOverlay->PSY) >> 24) & 0x01)); | |
1083 } | |
1084 | |
1085 /* Set U/V data if using plane formats */ | |
1086 if ((pOverlay->pixelFormat == IMGFMT_YV12) || | |
1087 (pOverlay->pixelFormat == IMGFMT_I420)) { | |
1088 | |
1089 uint32_t PSU, PSV; | |
1090 | |
1091 PSU = pOverlay->PSU; | |
1092 PSV = pOverlay->PSV; | |
1093 | |
1094 /* Set U/V pitch */ | |
1095 setvideoreg(Index_VI_Disp_UV_Buf_Pitch_Low, | |
1096 (uint8_t) (pitch >> 1)); | |
1097 setvideoregmask(Index_VI_Disp_Y_UV_Buf_Pitch_Middle, | |
1098 (uint8_t) (pitch >> 5), 0xf0); | |
1099 | |
1100 /* set U/V start address */ | |
1101 setvideoreg(Index_VI_U_Buf_Start_Low, (uint8_t) PSU); | |
1102 setvideoreg(Index_VI_U_Buf_Start_Middle, (uint8_t) (PSU >> 8)); | |
1103 setvideoreg(Index_VI_U_Buf_Start_High, (uint8_t) (PSU >> 16)); | |
1104 | |
1105 setvideoreg(Index_VI_V_Buf_Start_Low, (uint8_t) PSV); | |
1106 setvideoreg(Index_VI_V_Buf_Start_Middle, (uint8_t) (PSV >> 8)); | |
1107 setvideoreg(Index_VI_V_Buf_Start_High, (uint8_t) (PSV >> 16)); | |
1108 | |
1109 /* 310/325 series overflow bits */ | |
1110 if (sis_vga_engine == SIS_315_VGA) { | |
1111 setvideoreg(Index_VI_Disp_UV_Buf_Pitch_High, | |
1112 (uint8_t) (pitch >> 13)); | |
1113 setvideoreg(Index_VI_U_Buf_Start_Over, | |
1114 ((uint8_t) (PSU >> 24) & 0x01)); | |
1115 setvideoreg(Index_VI_V_Buf_Start_Over, | |
1116 ((uint8_t) (PSV >> 24) & 0x01)); | |
1117 } | |
1118 } | |
1119 | |
1120 if (sis_vga_engine == SIS_315_VGA) { | |
1121 /* Trigger register copy for 310 series */ | |
1122 setvideoreg(Index_VI_Control_Misc3, 1 << index); | |
1123 } | |
1124 | |
1125 /* set scale factor */ | |
1126 setvideoreg(Index_VI_Hor_Post_Up_Scale_Low, | |
1127 (uint8_t) (pOverlay->HUSF)); | |
1128 setvideoreg(Index_VI_Hor_Post_Up_Scale_High, | |
1129 (uint8_t) ((pOverlay->HUSF) >> 8)); | |
1130 setvideoreg(Index_VI_Ver_Up_Scale_Low, (uint8_t) (pOverlay->VUSF)); | |
1131 setvideoreg(Index_VI_Ver_Up_Scale_High, | |
1132 (uint8_t) ((pOverlay->VUSF) >> 8)); | |
1133 | |
1134 setvideoregmask(Index_VI_Scale_Control, (pOverlay->IntBit << 3) | |
1135 | (pOverlay->wHPre), 0x7f); | |
1136 | |
1137 /* set destination window position */ | |
1138 setvideoreg(Index_VI_Win_Hor_Disp_Start_Low, (uint8_t) left); | |
1139 setvideoreg(Index_VI_Win_Hor_Disp_End_Low, (uint8_t) right); | |
1140 setvideoreg(Index_VI_Win_Hor_Over, (uint8_t) h_over); | |
1141 | |
1142 setvideoreg(Index_VI_Win_Ver_Disp_Start_Low, (uint8_t) top); | |
1143 setvideoreg(Index_VI_Win_Ver_Disp_End_Low, (uint8_t) bottom); | |
1144 setvideoreg(Index_VI_Win_Ver_Over, (uint8_t) v_over); | |
1145 | |
1146 setvideoregmask(Index_VI_Control_Misc1, pOverlay->bobEnable, 0x1a); | |
1147 | |
1148 /* Lock the address registers */ | |
1149 setvideoregmask(Index_VI_Control_Misc1, 0x00, 0x20); | |
1150 } | |
1151 | |
1152 | |
1153 /* TW: Overlay MUST NOT be switched off while beam is over it */ | |
1154 static void close_overlay(void) | |
1155 { | |
1156 uint32_t watchdog; | |
1157 | |
1158 if ((sis_displaymode == DISPMODE_SINGLE2) || | |
1159 (sis_displaymode == DISPMODE_MIRROR)) { | |
1160 if (sis_has_two_overlays) { | |
1161 setvideoregmask(Index_VI_Control_Misc2, 0x01, 0x01); | |
1162 watchdog = WATCHDOG_DELAY; | |
1163 while (vblank_active_CRT2() && --watchdog); | |
1164 watchdog = WATCHDOG_DELAY; | |
1165 while ((!vblank_active_CRT2()) && --watchdog); | |
1166 setvideoregmask(Index_VI_Control_Misc0, 0x00, 0x02); | |
1167 watchdog = WATCHDOG_DELAY; | |
1168 while (vblank_active_CRT2() && --watchdog); | |
1169 watchdog = WATCHDOG_DELAY; | |
1170 while ((!vblank_active_CRT2()) && --watchdog); | |
1171 } else if (sis_displaymode == DISPMODE_SINGLE2) { | |
1172 setvideoregmask(Index_VI_Control_Misc2, 0x00, 0x01); | |
1173 watchdog = WATCHDOG_DELAY; | |
1174 while (vblank_active_CRT1() && --watchdog); | |
1175 watchdog = WATCHDOG_DELAY; | |
1176 while ((!vblank_active_CRT1()) && --watchdog); | |
1177 setvideoregmask(Index_VI_Control_Misc0, 0x00, 0x02); | |
1178 watchdog = WATCHDOG_DELAY; | |
1179 while (vblank_active_CRT1() && --watchdog); | |
1180 watchdog = WATCHDOG_DELAY; | |
1181 while ((!vblank_active_CRT1()) && --watchdog); | |
1182 } | |
1183 } | |
1184 if ((sis_displaymode == DISPMODE_SINGLE1) || | |
1185 (sis_displaymode == DISPMODE_MIRROR)) { | |
1186 setvideoregmask(Index_VI_Control_Misc2, 0x00, 0x01); | |
1187 watchdog = WATCHDOG_DELAY; | |
1188 while (vblank_active_CRT1() && --watchdog); | |
1189 watchdog = WATCHDOG_DELAY; | |
1190 while ((!vblank_active_CRT1()) && --watchdog); | |
1191 setvideoregmask(Index_VI_Control_Misc0, 0x00, 0x02); | |
1192 watchdog = WATCHDOG_DELAY; | |
1193 while (vblank_active_CRT1() && --watchdog); | |
1194 watchdog = WATCHDOG_DELAY; | |
1195 while ((!vblank_active_CRT1()) && --watchdog); | |
1196 } | |
1197 } | |
1198 | |
1199 | |
1200 static void | |
1201 calc_scale_factor(SISOverlayPtr pOverlay, int index, int iscrt2) | |
1202 { | |
1203 uint32_t i = 0, mult = 0; | |
1204 int flag = 0; | |
1205 | |
1206 int dstW = pOverlay->dstBox.x2 - pOverlay->dstBox.x1; | |
1207 int dstH = pOverlay->dstBox.y2 - pOverlay->dstBox.y1; | |
1208 int srcW = pOverlay->srcW; | |
1209 int srcH = pOverlay->srcH; | |
1210 /* uint16_t LCDheight = pSiS->LCDheight; */ | |
1211 int srcPitch = pOverlay->origPitch; | |
1212 int origdstH = dstH; | |
1213 | |
1214 /* get rid of warnings for now */ | |
1215 index = index; | |
1216 iscrt2 = iscrt2; | |
1217 | |
1218 #if 0 /* JCP: don't bother with this for now. */ | |
1219 /* TW: Stretch image due to idiotic LCD "auto"-scaling on LVDS (and 630+301B) */ | |
1220 if (pSiS->VBFlags & CRT2_LCD) { | |
1221 if (sis_bridge_is_slave) { | |
1222 if (pSiS->VBFlags & VB_LVDS) { | |
1223 dstH = (dstH * LCDheight) / pOverlay->SCREENheight; | |
1224 } else if ((sis_vga_engine == SIS_300_VGA) && | |
1225 (pSiS-> | |
1226 VBFlags & (VB_301B | VB_302B | VB_301LV | | |
1227 VB_302LV))) { | |
1228 dstH = (dstH * LCDheight) / pOverlay->SCREENheight; | |
1229 } | |
1230 } else if (iscrt2) { | |
1231 if (pSiS->VBFlags & VB_LVDS) { | |
1232 dstH = (dstH * LCDheight) / pOverlay->SCREENheight; | |
1233 if (sis_displaymode == DISPMODE_MIRROR) | |
1234 flag = 1; | |
1235 } else if ((sis_vga_engine == SIS_300_VGA) && | |
1236 (pSiS-> | |
1237 VBFlags & (VB_301B | VB_302B | VB_301LV | | |
1238 VB_302LV))) { | |
1239 dstH = (dstH * LCDheight) / pOverlay->SCREENheight; | |
1240 if (sis_displaymode == DISPMODE_MIRROR) | |
1241 flag = 1; | |
1242 } | |
1243 } | |
1244 } | |
1245 #endif | |
1246 | |
1247 /* TW: For double scan modes, we need to double the height | |
1248 * (Perhaps we also need to scale LVDS, but I'm not sure.) | |
1249 * On 310/325 series, we need to double the width as well. | |
1250 * Interlace mode vice versa. | |
1251 */ | |
1252 if (sis_vmode & VMODE_DOUBLESCAN) { | |
1253 dstH = origdstH << 1; | |
1254 flag = 0; | |
1255 if (sis_vga_engine == SIS_315_VGA) { | |
1256 dstW <<= 1; | |
1257 } | |
1258 } | |
1259 if (sis_vmode & VMODE_INTERLACED) { | |
1260 dstH = origdstH >> 1; | |
1261 flag = 0; | |
1262 } | |
1263 | |
1264 if (dstW < OVERLAY_MIN_WIDTH) | |
1265 dstW = OVERLAY_MIN_WIDTH; | |
1266 if (dstW == srcW) { | |
1267 pOverlay->HUSF = 0x00; | |
1268 pOverlay->IntBit = 0x05; | |
1269 pOverlay->wHPre = 0; | |
1270 } else if (dstW > srcW) { | |
1271 dstW += 2; | |
1272 pOverlay->HUSF = (srcW << 16) / dstW; | |
1273 pOverlay->IntBit = 0x04; | |
1274 pOverlay->wHPre = 0; | |
1275 } else { | |
1276 int tmpW = dstW; | |
1277 | |
1278 /* TW: It seems, the hardware can't scale below factor .125 (=1/8) if the | |
1279 pitch isn't a multiple of 256. | |
1280 TODO: Test this on the 310/325 series! | |
1281 */ | |
1282 if ((srcPitch % 256) || (srcPitch < 256)) { | |
1283 if (((dstW * 1000) / srcW) < 125) | |
1284 dstW = tmpW = ((srcW * 125) / 1000) + 1; | |
1285 } | |
1286 | |
1287 i = 0; | |
1288 pOverlay->IntBit = 0x01; | |
1289 while (srcW >= tmpW) { | |
1290 tmpW <<= 1; | |
1291 i++; | |
1292 } | |
1293 pOverlay->wHPre = (uint8_t) (i - 1); | |
1294 dstW <<= (i - 1); | |
1295 if ((srcW % dstW)) | |
1296 pOverlay->HUSF = ((srcW - dstW) << 16) / dstW; | |
1297 else | |
1298 pOverlay->HUSF = 0x00; | |
1299 } | |
1300 | |
1301 if (dstH < OVERLAY_MIN_HEIGHT) | |
1302 dstH = OVERLAY_MIN_HEIGHT; | |
1303 if (dstH == srcH) { | |
1304 pOverlay->VUSF = 0x00; | |
1305 pOverlay->IntBit |= 0x0A; | |
1306 } else if (dstH > srcH) { | |
1307 dstH += 0x02; | |
1308 pOverlay->VUSF = (srcH << 16) / dstH; | |
1309 pOverlay->IntBit |= 0x08; | |
1310 } else { | |
1311 uint32_t realI; | |
1312 | |
1313 i = realI = srcH / dstH; | |
1314 pOverlay->IntBit |= 0x02; | |
1315 | |
1316 if (i < 2) { | |
1317 pOverlay->VUSF = ((srcH - dstH) << 16) / dstH; | |
1318 /* TW: Needed for LCD-scaling modes */ | |
1319 if ((flag) && (mult = (srcH / origdstH)) >= 2) | |
1320 pOverlay->pitch /= mult; | |
1321 } else { | |
1322 #if 0 | |
1323 if (((pOverlay->bobEnable & 0x08) == 0x00) && | |
1324 (((srcPitch * i) >> 2) > 0xFFF)) { | |
1325 pOverlay->bobEnable |= 0x08; | |
1326 srcPitch >>= 1; | |
1327 } | |
1328 #endif | |
1329 if (((srcPitch * i) >> 2) > 0xFFF) { | |
1330 i = (0xFFF * 2 / srcPitch); | |
1331 pOverlay->VUSF = 0xFFFF; | |
1332 } else { | |
1333 dstH = i * dstH; | |
1334 if (srcH % dstH) | |
1335 pOverlay->VUSF = ((srcH - dstH) << 16) / dstH; | |
1336 else | |
1337 pOverlay->VUSF = 0x00; | |
1338 } | |
1339 /* set video frame buffer offset */ | |
1340 pOverlay->pitch = (uint16_t) (srcPitch * i); | |
1341 } | |
1342 } | |
1343 } | |
1344 | |
1345 static void set_line_buf_size(SISOverlayPtr pOverlay) | |
1346 { | |
1347 uint8_t preHIDF; | |
1348 uint32_t i; | |
1349 uint32_t line = pOverlay->srcW; | |
1350 | |
1351 if ((pOverlay->pixelFormat == IMGFMT_YV12) || | |
1352 (pOverlay->pixelFormat == IMGFMT_I420)) { | |
1353 preHIDF = pOverlay->wHPre & 0x07; | |
1354 switch (preHIDF) { | |
1355 case 3: | |
1356 if ((line & 0xffffff00) == line) | |
1357 i = (line >> 8); | |
1358 else | |
1359 i = (line >> 8) + 1; | |
1360 pOverlay->lineBufSize = (uint8_t) (i * 32 - 1); | |
1361 break; | |
1362 case 4: | |
1363 if ((line & 0xfffffe00) == line) | |
1364 i = (line >> 9); | |
1365 else | |
1366 i = (line >> 9) + 1; | |
1367 pOverlay->lineBufSize = (uint8_t) (i * 64 - 1); | |
1368 break; | |
1369 case 5: | |
1370 if ((line & 0xfffffc00) == line) | |
1371 i = (line >> 10); | |
1372 else | |
1373 i = (line >> 10) + 1; | |
1374 pOverlay->lineBufSize = (uint8_t) (i * 128 - 1); | |
1375 break; | |
1376 case 6: | |
1377 if ((line & 0xfffff800) == line) | |
1378 i = (line >> 11); | |
1379 else | |
1380 i = (line >> 11) + 1; | |
1381 pOverlay->lineBufSize = (uint8_t) (i * 256 - 1); | |
1382 break; | |
1383 default: | |
1384 if ((line & 0xffffff80) == line) | |
1385 i = (line >> 7); | |
1386 else | |
1387 i = (line >> 7) + 1; | |
1388 pOverlay->lineBufSize = (uint8_t) (i * 16 - 1); | |
1389 break; | |
1390 } | |
1391 } else { /* YUV2, UYVY */ | |
1392 if ((line & 0xffffff8) == line) | |
1393 i = (line >> 3); | |
1394 else | |
1395 i = (line >> 3) + 1; | |
1396 pOverlay->lineBufSize = (uint8_t) (i - 1); | |
1397 } | |
1398 } | |
1399 | |
1400 static void merge_line_buf(int enable) | |
1401 { | |
1402 if (enable) { | |
1403 switch (sis_displaymode) { | |
1404 case DISPMODE_SINGLE1: | |
1405 if (sis_has_two_overlays) { | |
1406 /* dual line merge */ | |
1407 setvideoregmask(Index_VI_Control_Misc2, 0x10, 0x11); | |
1408 setvideoregmask(Index_VI_Control_Misc1, 0x00, 0x04); | |
1409 } else { | |
1410 setvideoregmask(Index_VI_Control_Misc2, 0x10, 0x11); | |
1411 setvideoregmask(Index_VI_Control_Misc1, 0x00, 0x04); | |
1412 } | |
1413 break; | |
1414 case DISPMODE_SINGLE2: | |
1415 if (sis_has_two_overlays) { | |
1416 /* line merge */ | |
1417 setvideoregmask(Index_VI_Control_Misc2, 0x01, 0x11); | |
1418 setvideoregmask(Index_VI_Control_Misc1, 0x04, 0x04); | |
1419 } else { | |
1420 setvideoregmask(Index_VI_Control_Misc2, 0x10, 0x11); | |
1421 setvideoregmask(Index_VI_Control_Misc1, 0x00, 0x04); | |
1422 } | |
1423 break; | |
1424 case DISPMODE_MIRROR: | |
1425 default: | |
1426 /* line merge */ | |
1427 setvideoregmask(Index_VI_Control_Misc2, 0x00, 0x11); | |
1428 setvideoregmask(Index_VI_Control_Misc1, 0x04, 0x04); | |
1429 if (sis_has_two_overlays) { | |
1430 /* line merge */ | |
1431 setvideoregmask(Index_VI_Control_Misc2, 0x01, 0x11); | |
1432 setvideoregmask(Index_VI_Control_Misc1, 0x04, 0x04); | |
1433 } | |
1434 break; | |
1435 } | |
1436 } else { | |
1437 switch (sis_displaymode) { | |
1438 case DISPMODE_SINGLE1: | |
1439 setvideoregmask(Index_VI_Control_Misc2, 0x00, 0x11); | |
1440 setvideoregmask(Index_VI_Control_Misc1, 0x00, 0x04); | |
1441 break; | |
1442 case DISPMODE_SINGLE2: | |
1443 if (sis_has_two_overlays) { | |
1444 setvideoregmask(Index_VI_Control_Misc2, 0x01, 0x11); | |
1445 setvideoregmask(Index_VI_Control_Misc1, 0x00, 0x04); | |
1446 } else { | |
1447 setvideoregmask(Index_VI_Control_Misc2, 0x00, 0x11); | |
1448 setvideoregmask(Index_VI_Control_Misc1, 0x00, 0x04); | |
1449 } | |
1450 break; | |
1451 case DISPMODE_MIRROR: | |
1452 default: | |
1453 setvideoregmask(Index_VI_Control_Misc2, 0x00, 0x11); | |
1454 setvideoregmask(Index_VI_Control_Misc1, 0x00, 0x04); | |
1455 if (sis_has_two_overlays) { | |
1456 setvideoregmask(Index_VI_Control_Misc2, 0x01, 0x11); | |
1457 setvideoregmask(Index_VI_Control_Misc1, 0x00, 0x04); | |
1458 } | |
1459 break; | |
1460 } | |
1461 } | |
1462 } | |
1463 | |
1464 | |
1465 static void set_format(SISOverlayPtr pOverlay) | |
1466 { | |
1467 uint8_t fmt; | |
1468 | |
1469 switch (pOverlay->pixelFormat) { | |
1470 case IMGFMT_YV12: | |
1471 case IMGFMT_I420: | |
1472 fmt = 0x0c; | |
1473 break; | |
1474 case IMGFMT_YUY2: | |
1475 fmt = 0x28; | |
1476 break; | |
1477 case IMGFMT_UYVY: | |
1478 fmt = 0x08; | |
1479 break; | |
1480 case IMGFMT_RGB15: /* D[5:4] : 00 RGB555, 01 RGB 565 */ | |
1481 fmt = 0x00; | |
1482 break; | |
1483 case IMGFMT_RGB16: | |
1484 fmt = 0x10; | |
1485 break; | |
1486 default: | |
1487 fmt = 0x00; | |
1488 break; | |
1489 } | |
1490 setvideoregmask(Index_VI_Control_Misc0, fmt, 0x7c); | |
1491 } | |
1492 | |
1493 static void set_colorkey(void) | |
1494 { | |
1495 uint8_t r, g, b; | |
1496 | |
1497 b = (uint8_t) sis_grkey.ckey.blue; | |
1498 g = (uint8_t) sis_grkey.ckey.green; | |
1499 r = (uint8_t) sis_grkey.ckey.red; | |
1500 | |
1501 /* set color key mode */ | |
1502 setvideoregmask(Index_VI_Key_Overlay_OP, | |
1503 sis_grkey.ckey.op == CKEY_TRUE ? | |
1504 VI_ROP_DestKey : VI_ROP_Always, 0x0F); | |
1505 | |
1506 /* set colorkey values */ | |
1507 setvideoreg(Index_VI_Overlay_ColorKey_Blue_Min, (uint8_t) b); | |
1508 setvideoreg(Index_VI_Overlay_ColorKey_Green_Min, (uint8_t) g); | |
1509 setvideoreg(Index_VI_Overlay_ColorKey_Red_Min, (uint8_t) r); | |
1510 | |
1511 setvideoreg(Index_VI_Overlay_ColorKey_Blue_Max, (uint8_t) b); | |
1512 setvideoreg(Index_VI_Overlay_ColorKey_Green_Max, (uint8_t) g); | |
1513 setvideoreg(Index_VI_Overlay_ColorKey_Red_Max, (uint8_t) r); | |
1514 } | |
1515 | |
1516 static void set_brightness(uint8_t brightness) | |
1517 { | |
1518 setvideoreg(Index_VI_Brightness, brightness); | |
1519 } | |
1520 | |
1521 static void set_contrast(uint8_t contrast) | |
1522 { | |
1523 setvideoregmask(Index_VI_Contrast_Enh_Ctrl, contrast, 0x07); | |
1524 } | |
1525 | |
1526 /* Next 3 functions are 310/325 series only */ | |
1527 | |
1528 static void set_saturation(char saturation) | |
1529 { | |
1530 uint8_t temp = 0; | |
1531 | |
1532 if (saturation < 0) { | |
1533 temp |= 0x88; | |
1534 saturation = -saturation; | |
1535 } | |
1536 temp |= (saturation & 0x07); | |
1537 temp |= ((saturation & 0x07) << 4); | |
1538 | |
1539 setvideoreg(Index_VI_Saturation, temp); | |
1540 } | |
1541 | |
1542 static void set_hue(uint8_t hue) | |
1543 { | |
1544 setvideoreg(Index_VI_Hue, (hue & 0x08) ? (hue ^ 0x07) : hue); | |
1545 } | |
1546 | |
1547 #if 0 | |
1548 /* JCP: not used (I don't think it's correct anyway) */ | |
1549 static void set_alpha(uint8_t alpha) | |
1550 { | |
1551 uint8_t data; | |
1552 | |
1553 data = getvideoreg(Index_VI_Key_Overlay_OP); | |
1554 data &= 0x0F; | |
1555 setvideoreg(Index_VI_Key_Overlay_OP, data | (alpha << 4)); | |
1556 } | |
1557 #endif | |
22857
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1558 |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1559 VDXDriver sis_drv = { |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1560 "sis", |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1561 NULL, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1562 |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1563 .probe = sis_probe, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1564 .get_caps = sis_get_caps, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1565 .query_fourcc = sis_query_fourcc, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1566 .init = sis_init, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1567 .destroy = sis_destroy, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1568 .config_playback = sis_config_playback, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1569 .playback_on = sis_playback_on, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1570 .playback_off = sis_playback_off, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1571 .frame_sel = sis_frame_select, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1572 .get_eq = sis_get_eq, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1573 .set_eq = sis_set_eq, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1574 .get_gkey = sis_get_gkeys, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1575 .set_gkey = sis_set_gkeys, |
77def5093daf
switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in
ben
parents:
22850
diff
changeset
|
1576 }; |