|
1
|
1 /*
|
|
26003
|
2 * Matrox MGA G200/G400 YUV Video Interface module Version 0.1.0
|
|
|
3 * BES == Back End Scaler
|
|
1
|
4 *
|
|
|
5 * Copyright (C) 1999 Aaron Holtzman
|
|
26003
|
6 *
|
|
|
7 * Module skeleton based on gutted agpgart module by
|
|
|
8 * Jeff Hartmann <slicer@ionet.net>
|
|
|
9 * YUY2 support (see config.format) added by A'rpi/ESP-team
|
|
|
10 * double buffering added by A'rpi/ESP-team
|
|
|
11 * brightness/contrast introduced by eyck
|
|
|
12 * multiple card support by Attila Kinali <attila@kinali.ch>
|
|
|
13 *
|
|
27027
|
14 * This file is part of mga_vid.
|
|
1
|
15 *
|
|
27027
|
16 * mga_vid is free software; you can redistribute it and/or modify
|
|
26003
|
17 * it under the terms of the GNU General Public License as published by
|
|
|
18 * the Free Software Foundation; either version 2 of the License, or
|
|
|
19 * (at your option) any later version.
|
|
|
20 *
|
|
27027
|
21 * mga_vid is distributed in the hope that it will be useful,
|
|
26003
|
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
24 * GNU General Public License for more details.
|
|
|
25 *
|
|
|
26 * You should have received a copy of the GNU General Public License along
|
|
27027
|
27 * with mga_vid; if not, write to the Free Software Foundation, Inc.,
|
|
26003
|
28 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
1
|
29 */
|
|
|
30
|
|
|
31 //It's entirely possible this major conflicts with something else
|
|
9639
|
32 //use the 'major' parameter to override the default major number (178)
|
|
1
|
33 /* mknod /dev/mga_vid c 178 0 */
|
|
|
34
|
|
26004
|
35 //#define CRTC2
|
|
|
36
|
|
|
37 // Set this value, if autodetection fails! (video ram size in megabytes)
|
|
|
38 // #define MGA_MEMORY_SIZE 16
|
|
|
39
|
|
|
40 //#define MGA_ALLOW_IRQ
|
|
|
41
|
|
|
42 #define MGA_VSYNC_POS 2
|
|
|
43
|
|
1
|
44 #include <linux/config.h>
|
|
|
45 #include <linux/version.h>
|
|
|
46 #include <linux/module.h>
|
|
|
47 #include <linux/types.h>
|
|
|
48 #include <linux/kernel.h>
|
|
|
49 #include <linux/sched.h>
|
|
|
50 #include <linux/mm.h>
|
|
|
51 #include <linux/string.h>
|
|
|
52 #include <linux/errno.h>
|
|
3125
|
53
|
|
|
54 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,10)
|
|
1
|
55 #include <linux/malloc.h>
|
|
3125
|
56 #else
|
|
|
57 #include <linux/slab.h>
|
|
|
58 #endif
|
|
|
59
|
|
1
|
60 #include <linux/pci.h>
|
|
63
|
61 #include <linux/ioport.h>
|
|
1
|
62 #include <linux/init.h>
|
|
|
63
|
|
|
64 #include "mga_vid.h"
|
|
|
65
|
|
29263
|
66 #ifdef CONFIG_MTRR
|
|
1
|
67 #include <asm/mtrr.h>
|
|
|
68 #endif
|
|
|
69
|
|
5653
|
70 #ifdef CONFIG_DEVFS_FS
|
|
|
71 #include <linux/devfs_fs_kernel.h>
|
|
|
72 #endif
|
|
|
73
|
|
1
|
74 #include <asm/uaccess.h>
|
|
|
75 #include <asm/system.h>
|
|
|
76 #include <asm/io.h>
|
|
|
77
|
|
|
78 #define TRUE 1
|
|
|
79 #define FALSE 0
|
|
|
80
|
|
9639
|
81 #define DEFAULT_MGA_VID_MAJOR 178
|
|
1
|
82
|
|
29263
|
83 #ifndef PCI_DEVICE_ID_MATROX_G200_PCI
|
|
1
|
84 #define PCI_DEVICE_ID_MATROX_G200_PCI 0x0520
|
|
|
85 #endif
|
|
|
86
|
|
29263
|
87 #ifndef PCI_DEVICE_ID_MATROX_G200_AGP
|
|
1
|
88 #define PCI_DEVICE_ID_MATROX_G200_AGP 0x0521
|
|
|
89 #endif
|
|
|
90
|
|
29263
|
91 #ifndef PCI_DEVICE_ID_MATROX_G400
|
|
1
|
92 #define PCI_DEVICE_ID_MATROX_G400 0x0525
|
|
|
93 #endif
|
|
|
94
|
|
29263
|
95 #ifndef PCI_DEVICE_ID_MATROX_G550
|
|
1989
|
96 #define PCI_DEVICE_ID_MATROX_G550 0x2527
|
|
|
97 #endif
|
|
|
98
|
|
9518
|
99 #ifndef PCI_SUBSYSTEM_ID_MATROX_G400_DH_16MB
|
|
|
100 #define PCI_SUBSYSTEM_ID_MATROX_G400_DH_16MB 0x2159
|
|
|
101 #endif
|
|
|
102
|
|
|
103 #ifndef PCI_SUBSYSTEM_ID_MATROX_G400_16MB_SGRAM
|
|
|
104 #define PCI_SUBSYSTEM_ID_MATROX_G400_16MB_SGRAM 0x19d8
|
|
|
105 #endif
|
|
|
106
|
|
|
107 #ifndef PCI_SUBSYSTEM_ID_MATROX_G400_16MB_SDRAM
|
|
|
108 #define PCI_SUBSYSTEM_ID_MATROX_G400_16MB_SDRAM 0x0328
|
|
|
109 #endif
|
|
|
110
|
|
1
|
111 MODULE_AUTHOR("Aaron Holtzman <aholtzma@engr.uvic.ca>");
|
|
2262
|
112 #ifdef MODULE_LICENSE
|
|
|
113 MODULE_LICENSE("GPL");
|
|
|
114 #endif
|
|
1
|
115
|
|
4483
|
116 #define PARAM_BRIGHTNESS "brightness="
|
|
4487
|
117 #define PARAM_CONTRAST "contrast="
|
|
4483
|
118 #define PARAM_BLACKIE "blackie="
|
|
4484
|
119
|
|
10743
|
120 // set PARAM_BUFF_SIZE to just below 4k because some kernel versions
|
|
|
121 // store additional information in the memory page which leads to
|
|
|
122 // the allocation of an additional page if exactly 4k is used
|
|
|
123 #define PARAM_BUFF_SIZE 4000
|
|
4484
|
124
|
|
5764
|
125 #ifndef min
|
|
5013
|
126 #define min(x,y) (((x)<(y))?(x):(y))
|
|
5764
|
127 #endif
|
|
5013
|
128
|
|
4487
|
129 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
|
|
|
130 #include <linux/ctype.h>
|
|
|
131
|
|
5884
|
132 static unsigned long simple_strtoul(const char *cp,char **endp,unsigned int base)
|
|
4487
|
133 {
|
|
30990
|
134 unsigned long result = 0,value;
|
|
4487
|
135
|
|
30990
|
136 if (!base) {
|
|
|
137 base = 10;
|
|
|
138 if (*cp == '0') {
|
|
|
139 base = 8;
|
|
|
140 cp++;
|
|
|
141 if ((*cp == 'x') && isxdigit(cp[1])) {
|
|
|
142 cp++;
|
|
|
143 base = 16;
|
|
|
144 }
|
|
4487
|
145 }
|
|
30990
|
146 }
|
|
|
147 while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp)
|
|
|
148 ? toupper(*cp) : *cp)-'A'+10) < base) {
|
|
|
149 result = result*base + value;
|
|
|
150 cp++;
|
|
|
151 }
|
|
|
152 if (endp)
|
|
|
153 *endp = (char *)cp;
|
|
|
154 return result;
|
|
4487
|
155 }
|
|
|
156
|
|
5884
|
157 static long simple_strtol(const char *cp,char **endp,unsigned int base)
|
|
4487
|
158 {
|
|
30990
|
159 if(*cp=='-')
|
|
|
160 return -simple_strtoul(cp+1,endp,base);
|
|
|
161 return simple_strtoul(cp,endp,base);
|
|
4487
|
162 }
|
|
|
163 #endif
|
|
|
164
|
|
4483
|
165
|
|
1
|
166 typedef struct bes_registers_s
|
|
|
167 {
|
|
30990
|
168 //BES Control
|
|
|
169 uint32_t besctl;
|
|
|
170 //BES Global control
|
|
|
171 uint32_t besglobctl;
|
|
|
172 //Luma control (brightness and contrast)
|
|
|
173 uint32_t beslumactl;
|
|
|
174 //Line pitch
|
|
|
175 uint32_t bespitch;
|
|
1
|
176
|
|
30990
|
177 //Buffer A-1 Chroma 3 plane org
|
|
|
178 uint32_t besa1c3org;
|
|
|
179 //Buffer A-1 Chroma org
|
|
|
180 uint32_t besa1corg;
|
|
|
181 //Buffer A-1 Luma org
|
|
|
182 uint32_t besa1org;
|
|
1
|
183
|
|
30990
|
184 //Buffer A-2 Chroma 3 plane org
|
|
|
185 uint32_t besa2c3org;
|
|
|
186 //Buffer A-2 Chroma org
|
|
|
187 uint32_t besa2corg;
|
|
|
188 //Buffer A-2 Luma org
|
|
|
189 uint32_t besa2org;
|
|
1
|
190
|
|
30990
|
191 //Buffer B-1 Chroma 3 plane org
|
|
|
192 uint32_t besb1c3org;
|
|
|
193 //Buffer B-1 Chroma org
|
|
|
194 uint32_t besb1corg;
|
|
|
195 //Buffer B-1 Luma org
|
|
|
196 uint32_t besb1org;
|
|
1
|
197
|
|
30990
|
198 //Buffer B-2 Chroma 3 plane org
|
|
|
199 uint32_t besb2c3org;
|
|
|
200 //Buffer B-2 Chroma org
|
|
|
201 uint32_t besb2corg;
|
|
|
202 //Buffer B-2 Luma org
|
|
|
203 uint32_t besb2org;
|
|
1
|
204
|
|
30990
|
205 //BES Horizontal coord
|
|
|
206 uint32_t beshcoord;
|
|
|
207 //BES Horizontal inverse scaling [5.14]
|
|
|
208 uint32_t beshiscal;
|
|
|
209 //BES Horizontal source start [10.14] (for scaling)
|
|
|
210 uint32_t beshsrcst;
|
|
|
211 //BES Horizontal source ending [10.14] (for scaling)
|
|
|
212 uint32_t beshsrcend;
|
|
|
213 //BES Horizontal source last
|
|
|
214 uint32_t beshsrclst;
|
|
1
|
215
|
|
29263
|
216
|
|
30990
|
217 //BES Vertical coord
|
|
|
218 uint32_t besvcoord;
|
|
|
219 //BES Vertical inverse scaling [5.14]
|
|
|
220 uint32_t besviscal;
|
|
|
221 //BES Field 1 vertical source last position
|
|
|
222 uint32_t besv1srclst;
|
|
|
223 //BES Field 1 weight start
|
|
|
224 uint32_t besv1wght;
|
|
|
225 //BES Field 2 vertical source last position
|
|
|
226 uint32_t besv2srclst;
|
|
|
227 //BES Field 2 weight start
|
|
|
228 uint32_t besv2wght;
|
|
1
|
229
|
|
4483
|
230
|
|
30990
|
231 //configurable stuff
|
|
|
232 int blackie;
|
|
4483
|
233
|
|
1
|
234 } bes_registers_t;
|
|
|
235
|
|
2344
|
236 #ifdef CRTC2
|
|
|
237 typedef struct crtc2_registers_s
|
|
|
238 {
|
|
30990
|
239 uint32_t c2ctl;
|
|
|
240 uint32_t c2datactl;
|
|
|
241 uint32_t c2misc;
|
|
|
242 uint32_t c2hparam;
|
|
|
243 uint32_t c2hsync;
|
|
|
244 uint32_t c2offset;
|
|
|
245 uint32_t c2pl2startadd0;
|
|
|
246 uint32_t c2pl2startadd1;
|
|
|
247 uint32_t c2pl3startadd0;
|
|
|
248 uint32_t c2pl3startadd1;
|
|
|
249 uint32_t c2preload;
|
|
|
250 uint32_t c2spicstartadd0;
|
|
|
251 uint32_t c2spicstartadd1;
|
|
|
252 uint32_t c2startadd0;
|
|
|
253 uint32_t c2startadd1;
|
|
|
254 uint32_t c2subpiclut;
|
|
|
255 uint32_t c2vcount;
|
|
|
256 uint32_t c2vparam;
|
|
|
257 uint32_t c2vsync;
|
|
2344
|
258 } crtc2_registers_t;
|
|
5653
|
259 #endif
|
|
|
260
|
|
10743
|
261
|
|
2086
|
262
|
|
10743
|
263
|
|
1
|
264
|
|
|
265 //All register offsets are converted to word aligned offsets (32 bit)
|
|
|
266 //because we want all our register accesses to be 32 bits
|
|
|
267 #define VCOUNT 0x1e20
|
|
|
268
|
|
|
269 #define PALWTADD 0x3c00 // Index register for X_DATAREG port
|
|
|
270 #define X_DATAREG 0x3c0a
|
|
|
271
|
|
|
272 #define XMULCTRL 0x19
|
|
|
273 #define BPP_8 0x00
|
|
|
274 #define BPP_15 0x01
|
|
|
275 #define BPP_16 0x02
|
|
|
276 #define BPP_24 0x03
|
|
|
277 #define BPP_32_DIR 0x04
|
|
|
278 #define BPP_32_PAL 0x07
|
|
|
279
|
|
|
280 #define XCOLMSK 0x40
|
|
|
281 #define X_COLKEY 0x42
|
|
|
282 #define XKEYOPMODE 0x51
|
|
|
283 #define XCOLMSK0RED 0x52
|
|
|
284 #define XCOLMSK0GREEN 0x53
|
|
|
285 #define XCOLMSK0BLUE 0x54
|
|
|
286 #define XCOLKEY0RED 0x55
|
|
|
287 #define XCOLKEY0GREEN 0x56
|
|
|
288 #define XCOLKEY0BLUE 0x57
|
|
|
289
|
|
2344
|
290 #ifdef CRTC2
|
|
|
291
|
|
|
292 /*CRTC2 registers*/
|
|
|
293 #define XMISCCTRL 0x1e
|
|
29263
|
294 #define C2CTL 0x3c10
|
|
2344
|
295 #define C2DATACTL 0x3c4c
|
|
|
296 #define C2MISC 0x3c44
|
|
|
297 #define C2HPARAM 0x3c14
|
|
|
298 #define C2HSYNC 0x3c18
|
|
|
299 #define C2OFFSET 0x3c40
|
|
|
300 #define C2PL2STARTADD0 0x3c30 // like BESA1CORG
|
|
|
301 #define C2PL2STARTADD1 0x3c34 // like BESA2CORG
|
|
|
302 #define C2PL3STARTADD0 0x3c38 // like BESA1C3ORG
|
|
|
303 #define C2PL3STARTADD1 0x3c3c // like BESA2C3ORG
|
|
|
304 #define C2PRELOAD 0x3c24
|
|
|
305 #define C2SPICSTARTADD0 0x3c54
|
|
|
306 #define C2SPICSTARTADD1 0x3c58
|
|
|
307 #define C2STARTADD0 0x3c28 // like BESA1ORG
|
|
|
308 #define C2STARTADD1 0x3c2c // like BESA2ORG
|
|
|
309 #define C2SUBPICLUT 0x3c50
|
|
|
310 #define C2VCOUNT 0x3c48
|
|
|
311 #define C2VPARAM 0x3c1c
|
|
|
312 #define C2VSYNC 0x3c20
|
|
|
313
|
|
|
314 #endif
|
|
|
315
|
|
1
|
316 // Backend Scaler registers
|
|
|
317 #define BESCTL 0x3d20
|
|
|
318 #define BESGLOBCTL 0x3dc0
|
|
|
319 #define BESLUMACTL 0x3d40
|
|
|
320 #define BESPITCH 0x3d24
|
|
48
|
321
|
|
1
|
322 #define BESA1C3ORG 0x3d60
|
|
|
323 #define BESA1CORG 0x3d10
|
|
|
324 #define BESA1ORG 0x3d00
|
|
48
|
325
|
|
29263
|
326 #define BESA2C3ORG 0x3d64
|
|
1
|
327 #define BESA2CORG 0x3d14
|
|
|
328 #define BESA2ORG 0x3d04
|
|
48
|
329
|
|
1
|
330 #define BESB1C3ORG 0x3d68
|
|
|
331 #define BESB1CORG 0x3d18
|
|
|
332 #define BESB1ORG 0x3d08
|
|
48
|
333
|
|
1
|
334 #define BESB2C3ORG 0x3d6C
|
|
|
335 #define BESB2CORG 0x3d1C
|
|
|
336 #define BESB2ORG 0x3d0C
|
|
48
|
337
|
|
1
|
338 #define BESHCOORD 0x3d28
|
|
|
339 #define BESHISCAL 0x3d30
|
|
|
340 #define BESHSRCEND 0x3d3C
|
|
|
341 #define BESHSRCLST 0x3d50
|
|
|
342 #define BESHSRCST 0x3d38
|
|
|
343 #define BESV1WGHT 0x3d48
|
|
|
344 #define BESV2WGHT 0x3d4c
|
|
|
345 #define BESV1SRCLST 0x3d54
|
|
|
346 #define BESV2SRCLST 0x3d58
|
|
|
347 #define BESVISCAL 0x3d34
|
|
|
348 #define BESVCOORD 0x3d2c
|
|
|
349 #define BESSTATUS 0x3dc4
|
|
|
350
|
|
30990
|
351 #define CRTCX 0x1fd4
|
|
|
352 #define CRTCD 0x1fd5
|
|
|
353 #define IEN 0x1e1c
|
|
|
354 #define ICLEAR 0x1e18
|
|
48
|
355 #define STATUS 0x1e14
|
|
|
356
|
|
10743
|
357
|
|
|
358 // global devfs handle for /dev/mga_vid
|
|
|
359 #ifdef CONFIG_DEVFS_FS
|
|
|
360 static devfs_handle_t dev_handle = NULL;
|
|
|
361 #endif
|
|
|
362
|
|
|
363 // card local config
|
|
|
364 typedef struct mga_card_s {
|
|
|
365
|
|
|
366 // local devfs handle for /dev/mga_vidX
|
|
|
367 #ifdef CONFIG_DEVFS_FS
|
|
30990
|
368 devfs_handle_t dev_handle;
|
|
10743
|
369 #endif
|
|
|
370
|
|
30990
|
371 uint8_t *param_buff; // buffer for read()
|
|
|
372 uint32_t param_buff_size;
|
|
|
373 uint32_t param_buff_len;
|
|
|
374 bes_registers_t regs;
|
|
10743
|
375 #ifdef CRTC2
|
|
30990
|
376 crtc2_registers_t cregs;
|
|
10743
|
377 #endif
|
|
30990
|
378 uint32_t vid_in_use;
|
|
|
379 uint32_t is_g400;
|
|
|
380 uint32_t vid_src_ready;
|
|
|
381 uint32_t vid_overlay_on;
|
|
10743
|
382
|
|
30990
|
383 uint8_t *mmio_base;
|
|
|
384 uint32_t mem_base;
|
|
|
385 int src_base; // YUV buffer position in video memory
|
|
|
386 uint32_t ram_size; // how much megabytes videoram we have
|
|
|
387 uint32_t top_reserved; // reserved space for console font (matroxfb + fastfont)
|
|
10743
|
388
|
|
30990
|
389 int brightness; // initial brightness
|
|
|
390 int contrast; // initial contrast
|
|
10743
|
391
|
|
30990
|
392 struct pci_dev *pci_dev;
|
|
10743
|
393
|
|
30990
|
394 mga_vid_config_t config;
|
|
|
395 int configured; // set to 1 when the card is configured over ioctl
|
|
10743
|
396
|
|
30990
|
397 int colkey_saved;
|
|
|
398 int colkey_on;
|
|
|
399 unsigned char colkey_color[4];
|
|
|
400 unsigned char colkey_mask[4];
|
|
10743
|
401
|
|
30990
|
402 int irq; // = -1
|
|
|
403 int next_frame;
|
|
10743
|
404 } mga_card_t;
|
|
|
405
|
|
|
406 #define MGA_MAX_CARDS 16
|
|
|
407 // this is used as init value for the parameter arrays
|
|
|
408 // it should have exactly MGA_MAX_CARDS elements
|
|
|
409 #define MGA_MAX_CARDS_INIT_ARRAY {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
|
|
|
410 static unsigned int mga_cards_num=0;
|
|
|
411 static mga_card_t * mga_cards[MGA_MAX_CARDS] = MGA_MAX_CARDS_INIT_ARRAY;
|
|
|
412
|
|
|
413 // module parameters
|
|
|
414 static int major = DEFAULT_MGA_VID_MAJOR;
|
|
|
415 static int mga_ram_size[MGA_MAX_CARDS] = MGA_MAX_CARDS_INIT_ARRAY;
|
|
|
416 static int mga_brightness[MGA_MAX_CARDS] = MGA_MAX_CARDS_INIT_ARRAY;
|
|
|
417 static int mga_contrast[MGA_MAX_CARDS] = MGA_MAX_CARDS_INIT_ARRAY;
|
|
|
418 static int mga_top_reserved[MGA_MAX_CARDS] = MGA_MAX_CARDS_INIT_ARRAY;
|
|
|
419
|
|
|
420 MODULE_PARM(mga_ram_size, "1-" __MODULE_STRING(MGA_MAX_CARDS) "i");
|
|
|
421 MODULE_PARM(mga_top_reserved, "1-" __MODULE_STRING(MGA_MAX_CARDS) "i");
|
|
|
422 MODULE_PARM(mga_brightness, "1-" __MODULE_STRING(MGA_MAX_CARDS) "i");
|
|
|
423 MODULE_PARM(mga_contrast, "1-" __MODULE_STRING(MGA_MAX_CARDS) "i");
|
|
|
424 MODULE_PARM(major, "i");
|
|
1
|
425
|
|
2344
|
426 #ifdef CRTC2
|
|
10743
|
427 static void crtc2_frame_sel(mga_card_t * card, int frame)
|
|
2344
|
428 {
|
|
|
429 switch(frame) {
|
|
29263
|
430 case 0:
|
|
30990
|
431 card->cregs.c2pl2startadd0=card->regs.besa1corg;
|
|
|
432 card->cregs.c2pl3startadd0=card->regs.besa1c3org;
|
|
|
433 card->cregs.c2startadd0=card->regs.besa1org;
|
|
|
434 break;
|
|
2344
|
435 case 1:
|
|
30990
|
436 card->cregs.c2pl2startadd0=card->regs.besa2corg;
|
|
|
437 card->cregs.c2pl3startadd0=card->regs.besa2c3org;
|
|
|
438 card->cregs.c2startadd0=card->regs.besa2org;
|
|
|
439 break;
|
|
2344
|
440 case 2:
|
|
30990
|
441 card->cregs.c2pl2startadd0=card->regs.besb1corg;
|
|
|
442 card->cregs.c2pl3startadd0=card->regs.besb1c3org;
|
|
|
443 card->cregs.c2startadd0=card->regs.besb1org;
|
|
|
444 break;
|
|
2344
|
445 case 3:
|
|
30990
|
446 card->cregs.c2pl2startadd0=card->regs.besb2corg;
|
|
|
447 card->cregs.c2pl3startadd0=card->regs.besb2c3org;
|
|
|
448 card->cregs.c2startadd0=card->regs.besb2org;
|
|
|
449 break;
|
|
2344
|
450 }
|
|
30990
|
451 writel(card->cregs.c2startadd0, card->mmio_base + C2STARTADD0);
|
|
|
452 writel(card->cregs.c2pl2startadd0, card->mmio_base + C2PL2STARTADD0);
|
|
|
453 writel(card->cregs.c2pl3startadd0, card->mmio_base + C2PL3STARTADD0);
|
|
2344
|
454 }
|
|
|
455 #endif
|
|
|
456
|
|
10743
|
457 static void mga_vid_frame_sel(mga_card_t * card, int frame)
|
|
1
|
458 {
|
|
10743
|
459 if ( card->irq != -1 ) {
|
|
30990
|
460 card->next_frame=frame;
|
|
48
|
461 } else {
|
|
|
462
|
|
30990
|
463 //we don't need the vcount protection as we're only hitting
|
|
|
464 //one register (and it doesn't seem to be double buffered)
|
|
|
465 card->regs.besctl = (card->regs.besctl & ~0x07000000) + (frame << 25);
|
|
|
466 writel( card->regs.besctl, card->mmio_base + BESCTL );
|
|
68
|
467
|
|
30990
|
468 // writel( card->regs.besglobctl + ((readl(card->mmio_base + VCOUNT)+2)<<16),
|
|
|
469 writel( card->regs.besglobctl + (MGA_VSYNC_POS<<16),
|
|
|
470 card->mmio_base + BESGLOBCTL);
|
|
2344
|
471 #ifdef CRTC2
|
|
30990
|
472 crtc2_frame_sel(card, frame);
|
|
2344
|
473 #endif
|
|
68
|
474
|
|
48
|
475 }
|
|
1
|
476 }
|
|
|
477
|
|
|
478
|
|
10743
|
479 static void mga_vid_write_regs(mga_card_t * card, int restore)
|
|
1
|
480 {
|
|
30990
|
481 //Make sure internal registers don't get updated until we're done
|
|
|
482 writel( (readl(card->mmio_base + VCOUNT)-1)<<16,
|
|
|
483 card->mmio_base + BESGLOBCTL);
|
|
1
|
484
|
|
30990
|
485 // color or coordinate keying
|
|
29263
|
486
|
|
30990
|
487 if(restore && card->colkey_saved){
|
|
|
488 // restore it
|
|
|
489 card->colkey_saved=0;
|
|
2086
|
490
|
|
5623
|
491 #ifdef MP_DEBUG
|
|
30990
|
492 printk("mga_vid: Restoring colorkey (ON: %d %02X:%02X:%02X)\n",
|
|
|
493 card->colkey_on,card->colkey_color[0],card->colkey_color[1],card->colkey_color[2]);
|
|
29263
|
494 #endif
|
|
2086
|
495
|
|
30990
|
496 // Set color key registers:
|
|
|
497 writeb( XKEYOPMODE, card->mmio_base + PALWTADD);
|
|
|
498 writeb( card->colkey_on, card->mmio_base + X_DATAREG);
|
|
29263
|
499
|
|
30990
|
500 writeb( XCOLKEY0RED, card->mmio_base + PALWTADD);
|
|
|
501 writeb( card->colkey_color[0], card->mmio_base + X_DATAREG);
|
|
|
502 writeb( XCOLKEY0GREEN, card->mmio_base + PALWTADD);
|
|
|
503 writeb( card->colkey_color[1], card->mmio_base + X_DATAREG);
|
|
|
504 writeb( XCOLKEY0BLUE, card->mmio_base + PALWTADD);
|
|
|
505 writeb( card->colkey_color[2], card->mmio_base + X_DATAREG);
|
|
|
506 writeb( X_COLKEY, card->mmio_base + PALWTADD);
|
|
|
507 writeb( card->colkey_color[3], card->mmio_base + X_DATAREG);
|
|
2086
|
508
|
|
30990
|
509 writeb( XCOLMSK0RED, card->mmio_base + PALWTADD);
|
|
|
510 writeb( card->colkey_mask[0], card->mmio_base + X_DATAREG);
|
|
|
511 writeb( XCOLMSK0GREEN, card->mmio_base + PALWTADD);
|
|
|
512 writeb( card->colkey_mask[1], card->mmio_base + X_DATAREG);
|
|
|
513 writeb( XCOLMSK0BLUE, card->mmio_base + PALWTADD);
|
|
|
514 writeb( card->colkey_mask[2], card->mmio_base + X_DATAREG);
|
|
|
515 writeb( XCOLMSK, card->mmio_base + PALWTADD);
|
|
|
516 writeb( card->colkey_mask[3], card->mmio_base + X_DATAREG);
|
|
2086
|
517
|
|
30990
|
518 } else if(!card->colkey_saved){
|
|
|
519 // save it
|
|
|
520 card->colkey_saved=1;
|
|
|
521 // Get color key registers:
|
|
|
522 writeb( XKEYOPMODE, card->mmio_base + PALWTADD);
|
|
|
523 card->colkey_on=(unsigned char)readb(card->mmio_base + X_DATAREG) & 1;
|
|
29263
|
524
|
|
30990
|
525 writeb( XCOLKEY0RED, card->mmio_base + PALWTADD);
|
|
|
526 card->colkey_color[0]=(unsigned char)readb(card->mmio_base + X_DATAREG);
|
|
|
527 writeb( XCOLKEY0GREEN, card->mmio_base + PALWTADD);
|
|
|
528 card->colkey_color[1]=(unsigned char)readb(card->mmio_base + X_DATAREG);
|
|
|
529 writeb( XCOLKEY0BLUE, card->mmio_base + PALWTADD);
|
|
|
530 card->colkey_color[2]=(unsigned char)readb(card->mmio_base + X_DATAREG);
|
|
|
531 writeb( X_COLKEY, card->mmio_base + PALWTADD);
|
|
|
532 card->colkey_color[3]=(unsigned char)readb(card->mmio_base + X_DATAREG);
|
|
2086
|
533
|
|
30990
|
534 writeb( XCOLMSK0RED, card->mmio_base + PALWTADD);
|
|
|
535 card->colkey_mask[0]=(unsigned char)readb(card->mmio_base + X_DATAREG);
|
|
|
536 writeb( XCOLMSK0GREEN, card->mmio_base + PALWTADD);
|
|
|
537 card->colkey_mask[1]=(unsigned char)readb(card->mmio_base + X_DATAREG);
|
|
|
538 writeb( XCOLMSK0BLUE, card->mmio_base + PALWTADD);
|
|
|
539 card->colkey_mask[2]=(unsigned char)readb(card->mmio_base + X_DATAREG);
|
|
|
540 writeb( XCOLMSK, card->mmio_base + PALWTADD);
|
|
|
541 card->colkey_mask[3]=(unsigned char)readb(card->mmio_base + X_DATAREG);
|
|
2086
|
542
|
|
5623
|
543 #ifdef MP_DEBUG
|
|
30990
|
544 printk("mga_vid: Saved colorkey (ON: %d %02X:%02X:%02X)\n",
|
|
|
545 card->colkey_on, card->colkey_color[0], card->colkey_color[1], card->colkey_color[2]);
|
|
29263
|
546 #endif
|
|
2086
|
547
|
|
30990
|
548 }
|
|
29263
|
549
|
|
30990
|
550 if(!restore){
|
|
|
551 writeb( XKEYOPMODE, card->mmio_base + PALWTADD);
|
|
|
552 writeb( card->config.colkey_on, card->mmio_base + X_DATAREG);
|
|
|
553 if ( card->config.colkey_on )
|
|
|
554 {
|
|
|
555 uint32_t r=0, g=0, b=0;
|
|
1
|
556
|
|
30990
|
557 writeb( XMULCTRL, card->mmio_base + PALWTADD);
|
|
|
558 switch (readb (card->mmio_base + X_DATAREG))
|
|
|
559 {
|
|
|
560 case BPP_8:
|
|
|
561 /* Need to look up the color index, just using color 0 for now. */
|
|
|
562 break;
|
|
1
|
563
|
|
30990
|
564 case BPP_15:
|
|
|
565 r = card->config.colkey_red >> 3;
|
|
|
566 g = card->config.colkey_green >> 3;
|
|
|
567 b = card->config.colkey_blue >> 3;
|
|
|
568 break;
|
|
1
|
569
|
|
30990
|
570 case BPP_16:
|
|
|
571 r = card->config.colkey_red >> 3;
|
|
|
572 g = card->config.colkey_green >> 2;
|
|
|
573 b = card->config.colkey_blue >> 3;
|
|
|
574 break;
|
|
1
|
575
|
|
30990
|
576 case BPP_24:
|
|
|
577 case BPP_32_DIR:
|
|
|
578 case BPP_32_PAL:
|
|
|
579 r = card->config.colkey_red;
|
|
|
580 g = card->config.colkey_green;
|
|
|
581 b = card->config.colkey_blue;
|
|
|
582 break;
|
|
|
583 }
|
|
1
|
584
|
|
30990
|
585 // Disable color keying on alpha channel
|
|
|
586 writeb( XCOLMSK, card->mmio_base + PALWTADD);
|
|
|
587 writeb( 0x00, card->mmio_base + X_DATAREG);
|
|
|
588 writeb( X_COLKEY, card->mmio_base + PALWTADD);
|
|
|
589 writeb( 0x00, card->mmio_base + X_DATAREG);
|
|
1
|
590
|
|
2086
|
591
|
|
30990
|
592 // Set up color key registers
|
|
|
593 writeb( XCOLKEY0RED, card->mmio_base + PALWTADD);
|
|
|
594 writeb( r, card->mmio_base + X_DATAREG);
|
|
|
595 writeb( XCOLKEY0GREEN, card->mmio_base + PALWTADD);
|
|
|
596 writeb( g, card->mmio_base + X_DATAREG);
|
|
|
597 writeb( XCOLKEY0BLUE, card->mmio_base + PALWTADD);
|
|
|
598 writeb( b, card->mmio_base + X_DATAREG);
|
|
1
|
599
|
|
30990
|
600 // Set up color key mask registers
|
|
|
601 writeb( XCOLMSK0RED, card->mmio_base + PALWTADD);
|
|
|
602 writeb( 0xff, card->mmio_base + X_DATAREG);
|
|
|
603 writeb( XCOLMSK0GREEN, card->mmio_base + PALWTADD);
|
|
|
604 writeb( 0xff, card->mmio_base + X_DATAREG);
|
|
|
605 writeb( XCOLMSK0BLUE, card->mmio_base + PALWTADD);
|
|
|
606 writeb( 0xff, card->mmio_base + X_DATAREG);
|
|
|
607 }
|
|
|
608 }
|
|
1
|
609
|
|
30990
|
610 // Backend Scaler
|
|
|
611 writel( card->regs.besctl, card->mmio_base + BESCTL);
|
|
|
612 if(card->is_g400)
|
|
|
613 writel( card->regs.beslumactl, card->mmio_base + BESLUMACTL);
|
|
|
614 writel( card->regs.bespitch, card->mmio_base + BESPITCH);
|
|
1
|
615
|
|
30990
|
616 writel( card->regs.besa1org, card->mmio_base + BESA1ORG);
|
|
|
617 writel( card->regs.besa1corg, card->mmio_base + BESA1CORG);
|
|
|
618 writel( card->regs.besa2org, card->mmio_base + BESA2ORG);
|
|
|
619 writel( card->regs.besa2corg, card->mmio_base + BESA2CORG);
|
|
|
620 writel( card->regs.besb1org, card->mmio_base + BESB1ORG);
|
|
|
621 writel( card->regs.besb1corg, card->mmio_base + BESB1CORG);
|
|
|
622 writel( card->regs.besb2org, card->mmio_base + BESB2ORG);
|
|
|
623 writel( card->regs.besb2corg, card->mmio_base + BESB2CORG);
|
|
|
624 if(card->is_g400)
|
|
|
625 {
|
|
|
626 writel( card->regs.besa1c3org, card->mmio_base + BESA1C3ORG);
|
|
|
627 writel( card->regs.besa2c3org, card->mmio_base + BESA2C3ORG);
|
|
|
628 writel( card->regs.besb1c3org, card->mmio_base + BESB1C3ORG);
|
|
|
629 writel( card->regs.besb2c3org, card->mmio_base + BESB2C3ORG);
|
|
|
630 }
|
|
1
|
631
|
|
30990
|
632 writel( card->regs.beshcoord, card->mmio_base + BESHCOORD);
|
|
|
633 writel( card->regs.beshiscal, card->mmio_base + BESHISCAL);
|
|
|
634 writel( card->regs.beshsrcst, card->mmio_base + BESHSRCST);
|
|
|
635 writel( card->regs.beshsrcend, card->mmio_base + BESHSRCEND);
|
|
|
636 writel( card->regs.beshsrclst, card->mmio_base + BESHSRCLST);
|
|
29263
|
637
|
|
30990
|
638 writel( card->regs.besvcoord, card->mmio_base + BESVCOORD);
|
|
|
639 writel( card->regs.besviscal, card->mmio_base + BESVISCAL);
|
|
48
|
640
|
|
30990
|
641 writel( card->regs.besv1srclst, card->mmio_base + BESV1SRCLST);
|
|
|
642 writel( card->regs.besv1wght, card->mmio_base + BESV1WGHT);
|
|
|
643 writel( card->regs.besv2srclst, card->mmio_base + BESV2SRCLST);
|
|
|
644 writel( card->regs.besv2wght, card->mmio_base + BESV2WGHT);
|
|
29263
|
645
|
|
30990
|
646 //update the registers somewhere between 1 and 2 frames from now.
|
|
|
647 writel( card->regs.besglobctl + ((readl(card->mmio_base + VCOUNT)+2)<<16),
|
|
|
648 card->mmio_base + BESGLOBCTL);
|
|
1
|
649
|
|
77
|
650 #if 0
|
|
30990
|
651 printk(KERN_DEBUG "mga_vid: wrote BES registers\n");
|
|
|
652 printk(KERN_DEBUG "mga_vid: BESCTL = 0x%08x\n",
|
|
|
653 readl(card->mmio_base + BESCTL));
|
|
|
654 printk(KERN_DEBUG "mga_vid: BESGLOBCTL = 0x%08x\n",
|
|
|
655 readl(card->mmio_base + BESGLOBCTL));
|
|
|
656 printk(KERN_DEBUG "mga_vid: BESSTATUS= 0x%08x\n",
|
|
|
657 readl(card->mmio_base + BESSTATUS));
|
|
77
|
658 #endif
|
|
2344
|
659 #ifdef CRTC2
|
|
30990
|
660 // printk("c2ctl:0x%08x c2datactl:0x%08x\n", readl(card->mmio_base + C2CTL), readl(card->mmio_base + C2DATACTL));
|
|
|
661 // printk("c2misc:0x%08x\n", readl(card->mmio_base + C2MISC));
|
|
|
662 // printk("c2ctl:0x%08x c2datactl:0x%08x\n", card->cregs.c2ctl, card->cregs.c2datactl);
|
|
2344
|
663
|
|
30990
|
664 // writel(card->cregs.c2ctl, card->mmio_base + C2CTL);
|
|
2344
|
665
|
|
30990
|
666 writel(((readl(card->mmio_base + C2CTL) & ~0x03e00000) + (card->cregs.c2ctl & 0x03e00000)), card->mmio_base + C2CTL);
|
|
|
667 writel(((readl(card->mmio_base + C2DATACTL) & ~0x000000ff) + (card->cregs.c2datactl & 0x000000ff)), card->mmio_base + C2DATACTL);
|
|
|
668 // ctrc2
|
|
|
669 // disable CRTC2 acording to specs
|
|
|
670 // writel(card->cregs.c2ctl & 0xfffffff0, card->mmio_base + C2CTL);
|
|
2344
|
671 // je to treba ???
|
|
30990
|
672 // writeb((readb(card->mmio_base + XMISCCTRL) & 0x19) | 0xa2, card->mmio_base + XMISCCTRL); // MAFC - mfcsel & vdoutsel
|
|
|
673 // writeb((readb(card->mmio_base + XMISCCTRL) & 0x19) | 0x92, card->mmio_base + XMISCCTRL);
|
|
|
674 // writeb((readb(card->mmio_base + XMISCCTRL) & ~0xe9) + 0xa2, card->mmio_base + XMISCCTRL);
|
|
|
675 // writel(card->cregs.c2datactl, card->mmio_base + C2DATACTL);
|
|
|
676 // writel(card->cregs.c2hparam, card->mmio_base + C2HPARAM);
|
|
|
677 // writel(card->cregs.c2hsync, card->mmio_base + C2HSYNC);
|
|
|
678 // writel(card->cregs.c2vparam, card->mmio_base + C2VPARAM);
|
|
|
679 // writel(card->cregs.c2vsync, card->mmio_base + C2VSYNC);
|
|
|
680 writel(card->cregs.c2misc, card->mmio_base + C2MISC);
|
|
2344
|
681
|
|
5623
|
682 #ifdef MP_DEBUG
|
|
30990
|
683 printk("c2offset = %d\n",card->cregs.c2offset);
|
|
29263
|
684 #endif
|
|
2344
|
685
|
|
30990
|
686 writel(card->cregs.c2offset, card->mmio_base + C2OFFSET);
|
|
|
687 writel(card->cregs.c2startadd0, card->mmio_base + C2STARTADD0);
|
|
|
688 // writel(card->cregs.c2startadd1, card->mmio_base + C2STARTADD1);
|
|
|
689 writel(card->cregs.c2pl2startadd0, card->mmio_base + C2PL2STARTADD0);
|
|
|
690 // writel(card->cregs.c2pl2startadd1, card->mmio_base + C2PL2STARTADD1);
|
|
|
691 writel(card->cregs.c2pl3startadd0, card->mmio_base + C2PL3STARTADD0);
|
|
|
692 // writel(card->cregs.c2pl3startadd1, card->mmio_base + C2PL3STARTADD1);
|
|
|
693 writel(card->cregs.c2spicstartadd0, card->mmio_base + C2SPICSTARTADD0);
|
|
|
694 // writel(card->cregs.c2spicstartadd1, card->mmio_base + C2SPICSTARTADD1);
|
|
|
695 // writel(card->cregs.c2subpiclut, card->mmio_base + C2SUBPICLUT);
|
|
|
696 // writel(card->cregs.c2preload, card->mmio_base + C2PRELOAD);
|
|
|
697 // finaly enable everything
|
|
|
698 // writel(card->cregs.c2ctl, card->mmio_base + C2CTL);
|
|
|
699 // printk("c2ctl:0x%08x c2datactl:0x%08x\n",readl(card->mmio_base + C2CTL),readl(card->mmio_base + C2DATACTL));
|
|
|
700 // printk("c2misc:0x%08x\n", readl(card->mmio_base + C2MISC));
|
|
29263
|
701 #endif
|
|
1
|
702 }
|
|
|
703
|
|
10743
|
704 static int mga_vid_set_config(mga_card_t * card)
|
|
1
|
705 {
|
|
30990
|
706 int x, y, sw, sh, dw, dh;
|
|
|
707 int besleft, bestop, ifactor, ofsleft, ofstop, baseadrofs, weight, weights;
|
|
|
708 mga_vid_config_t *config = &card->config;
|
|
|
709 int frame_size = card->config.frame_size;
|
|
10743
|
710
|
|
2344
|
711 #ifdef CRTC2
|
|
|
712 #define right_margin 0
|
|
|
713 #define left_margin 18
|
|
|
714 #define hsync_len 46
|
|
|
715 #define lower_margin 10
|
|
|
716 #define vsync_len 4
|
|
|
717 #define upper_margin 39
|
|
|
718
|
|
30990
|
719 unsigned int hdispend = (config->src_width + 31) & ~31;
|
|
|
720 unsigned int hsyncstart = hdispend + (right_margin & ~7);
|
|
|
721 unsigned int hsyncend = hsyncstart + (hsync_len & ~7);
|
|
|
722 unsigned int htotal = hsyncend + (left_margin & ~7);
|
|
|
723 unsigned int vdispend = config->src_height;
|
|
|
724 unsigned int vsyncstart = vdispend + lower_margin;
|
|
|
725 unsigned int vsyncend = vsyncstart + vsync_len;
|
|
|
726 unsigned int vtotal = vsyncend + upper_margin;
|
|
29263
|
727 #endif
|
|
30990
|
728 x = config->x_org;
|
|
|
729 y = config->y_org;
|
|
|
730 sw = config->src_width;
|
|
|
731 sh = config->src_height;
|
|
|
732 dw = config->dest_width;
|
|
|
733 dh = config->dest_height;
|
|
1
|
734
|
|
5623
|
735 #ifdef MP_DEBUG
|
|
30990
|
736 printk(KERN_DEBUG "mga_vid: Setting up a %dx%d+%d+%d video window (src %dx%d) format %X\n",
|
|
|
737 dw, dh, x, y, sw, sh, config->format);
|
|
29263
|
738 #endif
|
|
1
|
739
|
|
30990
|
740 if(sw<4 || sh<4 || dw<4 || dh<4){
|
|
|
741 printk(KERN_ERR "mga_vid: Invalid src/dest dimenstions\n");
|
|
|
742 return -1;
|
|
|
743 }
|
|
3959
|
744
|
|
30990
|
745 //FIXME check that window is valid and inside desktop
|
|
29263
|
746
|
|
30990
|
747 //Setup the BES registers for a three plane 4:2:0 video source
|
|
1
|
748
|
|
30990
|
749 card->regs.besglobctl = 0;
|
|
466
|
750
|
|
30990
|
751 switch(config->format){
|
|
29263
|
752 case MGA_VID_FORMAT_YV12:
|
|
|
753 case MGA_VID_FORMAT_I420:
|
|
|
754 case MGA_VID_FORMAT_IYUV:
|
|
30990
|
755 card->regs.besctl = 1 // BES enabled
|
|
|
756 + (0<<6) // even start polarity
|
|
|
757 + (1<<10) // x filtering enabled
|
|
|
758 + (1<<11) // y filtering enabled
|
|
|
759 + (1<<16) // chroma upsampling
|
|
|
760 + (1<<17) // 4:2:0 mode
|
|
|
761 + (1<<18); // dither enabled
|
|
466
|
762 #if 0
|
|
30990
|
763 if(card->is_g400)
|
|
|
764 {
|
|
|
765 //zoom disabled, zoom filter disabled, 420 3 plane format, proc amp
|
|
|
766 //disabled, rgb mode disabled
|
|
|
767 card->regs.besglobctl = (1<<5);
|
|
|
768 }
|
|
|
769 else
|
|
|
770 {
|
|
|
771 //zoom disabled, zoom filter disabled, Cb samples in 0246, Cr
|
|
|
772 //in 1357, BES register update on besvcnt
|
|
|
773 card->regs.besglobctl = 0;
|
|
|
774 }
|
|
466
|
775 #endif
|
|
1
|
776 break;
|
|
|
777
|
|
29263
|
778 case MGA_VID_FORMAT_YUY2:
|
|
30990
|
779 card->regs.besctl = 1 // BES enabled
|
|
|
780 + (0<<6) // even start polarity
|
|
|
781 + (1<<10) // x filtering enabled
|
|
|
782 + (1<<11) // y filtering enabled
|
|
|
783 + (1<<16) // chroma upsampling
|
|
|
784 + (0<<17) // 4:2:2 mode
|
|
|
785 + (1<<18); // dither enabled
|
|
1
|
786
|
|
30990
|
787 card->regs.besglobctl = 0; // YUY2 format selected
|
|
1
|
788 break;
|
|
466
|
789
|
|
29263
|
790 case MGA_VID_FORMAT_UYVY:
|
|
30990
|
791 card->regs.besctl = 1 // BES enabled
|
|
|
792 + (0<<6) // even start polarity
|
|
|
793 + (1<<10) // x filtering enabled
|
|
|
794 + (1<<11) // y filtering enabled
|
|
|
795 + (1<<16) // chroma upsampling
|
|
|
796 + (0<<17) // 4:2:2 mode
|
|
|
797 + (1<<18); // dither enabled
|
|
466
|
798
|
|
30990
|
799 card->regs.besglobctl = 1<<6; // UYVY format selected
|
|
466
|
800 break;
|
|
|
801
|
|
1
|
802 default:
|
|
30990
|
803 printk(KERN_ERR "mga_vid: Unsupported pixel format: 0x%X\n",config->format);
|
|
|
804 return -1;
|
|
1
|
805 }
|
|
|
806
|
|
30990
|
807 // setting black&white mode
|
|
|
808 card->regs.besctl|=(card->regs.blackie<<20);
|
|
1
|
809
|
|
30990
|
810 //Enable contrast and brightness control
|
|
|
811 card->regs.besglobctl |= (1<<5) + (1<<7);
|
|
29263
|
812
|
|
30990
|
813 // brightness (-128..127) && contrast (0..255)
|
|
|
814 card->regs.beslumactl = (card->brightness << 16) | ((card->contrast+0x80)&0xFFFF);
|
|
1
|
815
|
|
30990
|
816 //Setup destination window boundaries
|
|
|
817 besleft = x > 0 ? x : 0;
|
|
|
818 bestop = y > 0 ? y : 0;
|
|
|
819 card->regs.beshcoord = (besleft<<16) + (x + dw-1);
|
|
|
820 card->regs.besvcoord = (bestop<<16) + (y + dh-1);
|
|
29263
|
821
|
|
30990
|
822 //Setup source dimensions
|
|
|
823 card->regs.beshsrclst = (sw - 1) << 16;
|
|
|
824 card->regs.bespitch = (sw + 31) & ~31 ;
|
|
29263
|
825
|
|
30990
|
826 //Setup horizontal scaling
|
|
|
827 ifactor = ((sw-1)<<14)/(dw-1);
|
|
|
828 ofsleft = besleft - x;
|
|
29263
|
829
|
|
30990
|
830 card->regs.beshiscal = ifactor<<2;
|
|
|
831 card->regs.beshsrcst = (ofsleft*ifactor)<<2;
|
|
|
832 card->regs.beshsrcend = card->regs.beshsrcst + (((dw - ofsleft - 1) * ifactor) << 2);
|
|
29263
|
833
|
|
30990
|
834 //Setup vertical scaling
|
|
|
835 ifactor = ((sh-1)<<14)/(dh-1);
|
|
|
836 ofstop = bestop - y;
|
|
1
|
837
|
|
30990
|
838 card->regs.besviscal = ifactor<<2;
|
|
1
|
839
|
|
30990
|
840 baseadrofs = ( (ofstop * card->regs.besviscal) >>16) * card->regs.bespitch;
|
|
|
841 //frame_size = ((sw + 31) & ~31) * sh + (((sw + 31) & ~31) * sh) / 2;
|
|
|
842 card->regs.besa1org = (uint32_t) card->src_base + baseadrofs;
|
|
|
843 card->regs.besa2org = (uint32_t) card->src_base + baseadrofs + 1*frame_size;
|
|
|
844 card->regs.besb1org = (uint32_t) card->src_base + baseadrofs + 2*frame_size;
|
|
|
845 card->regs.besb2org = (uint32_t) card->src_base + baseadrofs + 3*frame_size;
|
|
1
|
846
|
|
30990
|
847 if(config->format==MGA_VID_FORMAT_YV12
|
|
|
848 ||config->format==MGA_VID_FORMAT_IYUV
|
|
|
849 ||config->format==MGA_VID_FORMAT_I420
|
|
|
850 ){
|
|
57
|
851 // planar YUV frames:
|
|
30990
|
852 if (card->is_g400)
|
|
|
853 baseadrofs = ( ( (ofstop * card->regs.besviscal ) / 4 ) >> 16 ) * card->regs.bespitch;
|
|
|
854 else
|
|
|
855 baseadrofs = ( ( ( ofstop * card->regs.besviscal ) / 2 ) >> 16 ) * card->regs.bespitch;
|
|
1
|
856
|
|
30990
|
857 if(config->format==MGA_VID_FORMAT_YV12 || !card->is_g400){
|
|
|
858 card->regs.besa1corg = (uint32_t) card->src_base + baseadrofs + card->regs.bespitch * sh ;
|
|
|
859 card->regs.besa2corg = (uint32_t) card->src_base + baseadrofs + 1*frame_size + card->regs.bespitch * sh;
|
|
|
860 card->regs.besb1corg = (uint32_t) card->src_base + baseadrofs + 2*frame_size + card->regs.bespitch * sh;
|
|
|
861 card->regs.besb2corg = (uint32_t) card->src_base + baseadrofs + 3*frame_size + card->regs.bespitch * sh;
|
|
|
862 card->regs.besa1c3org = card->regs.besa1corg + ( (card->regs.bespitch * sh) / 4);
|
|
|
863 card->regs.besa2c3org = card->regs.besa2corg + ( (card->regs.bespitch * sh) / 4);
|
|
|
864 card->regs.besb1c3org = card->regs.besb1corg + ( (card->regs.bespitch * sh) / 4);
|
|
|
865 card->regs.besb2c3org = card->regs.besb2corg + ( (card->regs.bespitch * sh) / 4);
|
|
|
866 } else {
|
|
|
867 card->regs.besa1c3org = (uint32_t) card->src_base + baseadrofs + card->regs.bespitch * sh ;
|
|
|
868 card->regs.besa2c3org = (uint32_t) card->src_base + baseadrofs + 1*frame_size + card->regs.bespitch * sh;
|
|
|
869 card->regs.besb1c3org = (uint32_t) card->src_base + baseadrofs + 2*frame_size + card->regs.bespitch * sh;
|
|
|
870 card->regs.besb2c3org = (uint32_t) card->src_base + baseadrofs + 3*frame_size + card->regs.bespitch * sh;
|
|
|
871 card->regs.besa1corg = card->regs.besa1c3org + ((card->regs.bespitch * sh) / 4);
|
|
|
872 card->regs.besa2corg = card->regs.besa2c3org + ((card->regs.bespitch * sh) / 4);
|
|
|
873 card->regs.besb1corg = card->regs.besb1c3org + ((card->regs.bespitch * sh) / 4);
|
|
|
874 card->regs.besb2corg = card->regs.besb2c3org + ((card->regs.bespitch * sh) / 4);
|
|
|
875 }
|
|
470
|
876 }
|
|
|
877
|
|
30990
|
878 weight = ofstop * (card->regs.besviscal >> 2);
|
|
|
879 weights = weight < 0 ? 1 : 0;
|
|
|
880 card->regs.besv2wght = card->regs.besv1wght = (weights << 16) + ((weight & 0x3FFF) << 2);
|
|
|
881 card->regs.besv2srclst = card->regs.besv1srclst = sh - 1 - (((ofstop * card->regs.besviscal) >> 16) & 0x03FF);
|
|
1
|
882
|
|
2344
|
883 #ifdef CRTC2
|
|
30990
|
884 // pridat hlavni registry - tj. casovani ...
|
|
2344
|
885
|
|
|
886
|
|
30990
|
887 switch(config->format){
|
|
29263
|
888 case MGA_VID_FORMAT_YV12:
|
|
|
889 case MGA_VID_FORMAT_I420:
|
|
|
890 case MGA_VID_FORMAT_IYUV:
|
|
30990
|
891 card->cregs.c2ctl = 1 // CRTC2 enabled
|
|
|
892 + (1<<1) // external clock
|
|
|
893 + (0<<2) // external clock
|
|
|
894 + (1<<3) // pixel clock enable - not needed ???
|
|
|
895 + (0<<4) // high prioryty req
|
|
|
896 + (1<<5) // high prioryty req
|
|
|
897 + (0<<6) // high prioryty req
|
|
|
898 + (1<<8) // high prioryty req max
|
|
|
899 + (0<<9) // high prioryty req max
|
|
|
900 + (0<<10) // high prioryty req max
|
|
|
901 + (0<<20) // CRTC1 to DAC
|
|
|
902 + (1<<21) // 420 mode
|
|
|
903 + (1<<22) // 420 mode
|
|
|
904 + (1<<23) // 420 mode
|
|
|
905 + (0<<24) // single chroma line for 420 mode - need to be corrected
|
|
|
906 + (0<<25) /*/ interlace mode - need to be corrected*/
|
|
|
907 + (0<<26) // field legth polariry
|
|
|
908 + (0<<27) // field identification polariry
|
|
|
909 + (1<<28) // VIDRST detection mode
|
|
|
910 + (0<<29) // VIDRST detection mode
|
|
|
911 + (1<<30) // Horizontal counter preload
|
|
|
912 + (1<<31) // Vertical counter preload
|
|
|
913 ;
|
|
|
914 card->cregs.c2datactl = 1 // disable dither - propably not needed, we are already in YUV mode
|
|
|
915 + (1<<1) // Y filter enable
|
|
|
916 + (1<<2) // CbCr filter enable
|
|
|
917 + (0<<3) // subpicture enable (disabled)
|
|
|
918 + (0<<4) // NTSC enable (disabled - PAL)
|
|
|
919 + (0<<5) // C2 static subpicture enable (disabled)
|
|
|
920 + (0<<6) // C2 subpicture offset division (disabled)
|
|
|
921 + (0<<7) // 422 subformat selection !
|
|
|
922 /* + (0<<8) // 15 bpp high alpha
|
|
|
923 + (0<<9) // 15 bpp high alpha
|
|
|
924 + (0<<10) // 15 bpp high alpha
|
|
|
925 + (0<<11) // 15 bpp high alpha
|
|
|
926 + (0<<12) // 15 bpp high alpha
|
|
|
927 + (0<<13) // 15 bpp high alpha
|
|
|
928 + (0<<14) // 15 bpp high alpha
|
|
|
929 + (0<<15) // 15 bpp high alpha
|
|
|
930 + (0<<16) // 15 bpp low alpha
|
|
|
931 + (0<<17) // 15 bpp low alpha
|
|
|
932 + (0<<18) // 15 bpp low alpha
|
|
|
933 + (0<<19) // 15 bpp low alpha
|
|
|
934 + (0<<20) // 15 bpp low alpha
|
|
|
935 + (0<<21) // 15 bpp low alpha
|
|
|
936 + (0<<22) // 15 bpp low alpha
|
|
|
937 + (0<<23) // 15 bpp low alpha
|
|
|
938 + (0<<24) // static subpicture key
|
|
|
939 + (0<<25) // static subpicture key
|
|
|
940 + (0<<26) // static subpicture key
|
|
|
941 + (0<<27) // static subpicture key
|
|
|
942 + (0<<28) // static subpicture key
|
|
|
943 */ ;
|
|
2344
|
944 break;
|
|
|
945
|
|
29263
|
946 case MGA_VID_FORMAT_YUY2:
|
|
30990
|
947 card->cregs.c2ctl = 1 // CRTC2 enabled
|
|
|
948 + (1<<1) // external clock
|
|
|
949 + (0<<2) // external clock
|
|
|
950 + (1<<3) // pixel clock enable - not needed ???
|
|
|
951 + (0<<4) // high prioryty req - acc to spec
|
|
|
952 + (1<<5) // high prioryty req
|
|
|
953 + (0<<6) // high prioryty req
|
|
|
954 // 7 reserved
|
|
|
955 + (1<<8) // high prioryty req max
|
|
|
956 + (0<<9) // high prioryty req max
|
|
|
957 + (0<<10) // high prioryty req max
|
|
|
958 // 11-19 reserved
|
|
|
959 + (0<<20) // CRTC1 to DAC
|
|
|
960 + (1<<21) // 422 mode
|
|
|
961 + (0<<22) // 422 mode
|
|
|
962 + (1<<23) // 422 mode
|
|
|
963 + (0<<24) // single chroma line for 420 mode - need to be corrected
|
|
|
964 + (0<<25) /*/ interlace mode - need to be corrected*/
|
|
|
965 + (0<<26) // field legth polariry
|
|
|
966 + (0<<27) // field identification polariry
|
|
|
967 + (1<<28) // VIDRST detection mode
|
|
|
968 + (0<<29) // VIDRST detection mode
|
|
|
969 + (1<<30) // Horizontal counter preload
|
|
|
970 + (1<<31) // Vertical counter preload
|
|
|
971 ;
|
|
|
972 card->cregs.c2datactl = 1 // disable dither - propably not needed, we are already in YUV mode
|
|
|
973 + (1<<1) // Y filter enable
|
|
|
974 + (1<<2) // CbCr filter enable
|
|
|
975 + (0<<3) // subpicture enable (disabled)
|
|
|
976 + (0<<4) // NTSC enable (disabled - PAL)
|
|
|
977 + (0<<5) // C2 static subpicture enable (disabled)
|
|
|
978 + (0<<6) // C2 subpicture offset division (disabled)
|
|
|
979 + (0<<7) // 422 subformat selection !
|
|
|
980 /* + (0<<8) // 15 bpp high alpha
|
|
|
981 + (0<<9) // 15 bpp high alpha
|
|
|
982 + (0<<10) // 15 bpp high alpha
|
|
|
983 + (0<<11) // 15 bpp high alpha
|
|
|
984 + (0<<12) // 15 bpp high alpha
|
|
|
985 + (0<<13) // 15 bpp high alpha
|
|
|
986 + (0<<14) // 15 bpp high alpha
|
|
|
987 + (0<<15) // 15 bpp high alpha
|
|
|
988 + (0<<16) // 15 bpp low alpha
|
|
|
989 + (0<<17) // 15 bpp low alpha
|
|
|
990 + (0<<18) // 15 bpp low alpha
|
|
|
991 + (0<<19) // 15 bpp low alpha
|
|
|
992 + (0<<20) // 15 bpp low alpha
|
|
|
993 + (0<<21) // 15 bpp low alpha
|
|
|
994 + (0<<22) // 15 bpp low alpha
|
|
|
995 + (0<<23) // 15 bpp low alpha
|
|
|
996 + (0<<24) // static subpicture key
|
|
|
997 + (0<<25) // static subpicture key
|
|
|
998 + (0<<26) // static subpicture key
|
|
|
999 + (0<<27) // static subpicture key
|
|
|
1000 + (0<<28) // static subpicture key
|
|
|
1001 */ ;
|
|
2344
|
1002 break;
|
|
|
1003
|
|
29263
|
1004 case MGA_VID_FORMAT_UYVY:
|
|
30990
|
1005 card->cregs.c2ctl = 1 // CRTC2 enabled
|
|
|
1006 + (1<<1) // external clock
|
|
|
1007 + (0<<2) // external clock
|
|
|
1008 + (1<<3) // pixel clock enable - not needed ???
|
|
|
1009 + (0<<4) // high prioryty req
|
|
|
1010 + (1<<5) // high prioryty req
|
|
|
1011 + (0<<6) // high prioryty req
|
|
|
1012 + (1<<8) // high prioryty req max
|
|
|
1013 + (0<<9) // high prioryty req max
|
|
|
1014 + (0<<10) // high prioryty req max
|
|
|
1015 + (0<<20) // CRTC1 to DAC
|
|
|
1016 + (1<<21) // 422 mode
|
|
|
1017 + (0<<22) // 422 mode
|
|
|
1018 + (1<<23) // 422 mode
|
|
|
1019 + (1<<24) // single chroma line for 420 mode - need to be corrected
|
|
|
1020 + (1<<25) /*/ interlace mode - need to be corrected*/
|
|
|
1021 + (0<<26) // field legth polariry
|
|
|
1022 + (0<<27) // field identification polariry
|
|
|
1023 + (1<<28) // VIDRST detection mode
|
|
|
1024 + (0<<29) // VIDRST detection mode
|
|
|
1025 + (1<<30) // Horizontal counter preload
|
|
|
1026 + (1<<31) // Vertical counter preload
|
|
|
1027 ;
|
|
|
1028 card->cregs.c2datactl = 0 // enable dither - propably not needed, we are already in YUV mode
|
|
|
1029 + (1<<1) // Y filter enable
|
|
|
1030 + (1<<2) // CbCr filter enable
|
|
|
1031 + (0<<3) // subpicture enable (disabled)
|
|
|
1032 + (0<<4) // NTSC enable (disabled - PAL)
|
|
|
1033 + (0<<5) // C2 static subpicture enable (disabled)
|
|
|
1034 + (0<<6) // C2 subpicture offset division (disabled)
|
|
|
1035 + (1<<7) // 422 subformat selection !
|
|
|
1036 /* + (0<<8) // 15 bpp high alpha
|
|
|
1037 + (0<<9) // 15 bpp high alpha
|
|
|
1038 + (0<<10) // 15 bpp high alpha
|
|
|
1039 + (0<<11) // 15 bpp high alpha
|
|
|
1040 + (0<<12) // 15 bpp high alpha
|
|
|
1041 + (0<<13) // 15 bpp high alpha
|
|
|
1042 + (0<<14) // 15 bpp high alpha
|
|
|
1043 + (0<<15) // 15 bpp high alpha
|
|
|
1044 + (0<<16) // 15 bpp low alpha
|
|
|
1045 + (0<<17) // 15 bpp low alpha
|
|
|
1046 + (0<<18) // 15 bpp low alpha
|
|
|
1047 + (0<<19) // 15 bpp low alpha
|
|
|
1048 + (0<<20) // 15 bpp low alpha
|
|
|
1049 + (0<<21) // 15 bpp low alpha
|
|
|
1050 + (0<<22) // 15 bpp low alpha
|
|
|
1051 + (0<<23) // 15 bpp low alpha
|
|
|
1052 + (0<<24) // static subpicture key
|
|
|
1053 + (0<<25) // static subpicture key
|
|
|
1054 + (0<<26) // static subpicture key
|
|
|
1055 + (0<<27) // static subpicture key
|
|
|
1056 + (0<<28) // static subpicture key
|
|
|
1057 */ ;
|
|
2344
|
1058 break;
|
|
|
1059
|
|
|
1060 default:
|
|
30990
|
1061 printk(KERN_ERR "mga_vid: Unsupported pixel format: 0x%X\n",config->format);
|
|
|
1062 return -1;
|
|
2344
|
1063 }
|
|
|
1064
|
|
30990
|
1065 card->cregs.c2hparam = ( (hdispend - 8) << 16) | (htotal - 8);
|
|
|
1066 card->cregs.c2hsync = ( (hsyncend - 8) << 16) | (hsyncstart - 8);
|
|
29263
|
1067
|
|
30990
|
1068 card->cregs.c2misc = 0 // CRTCV2 656 togg f0
|
|
|
1069 + (0<<1) // CRTCV2 656 togg f0
|
|
|
1070 + (0<<2) // CRTCV2 656 togg f0
|
|
|
1071 + (0<<4) // CRTCV2 656 togg f1
|
|
|
1072 + (0<<5) // CRTCV2 656 togg f1
|
|
|
1073 + (0<<6) // CRTCV2 656 togg f1
|
|
|
1074 + (0<<8) // Hsync active high
|
|
|
1075 + (0<<9) // Vsync active high
|
|
|
1076 // 16-27 c2vlinecomp - nevim co tam dat
|
|
|
1077 ;
|
|
|
1078 card->cregs.c2offset=(card->regs.bespitch << 1);
|
|
2344
|
1079
|
|
30990
|
1080 card->cregs.c2pl2startadd0=card->regs.besa1corg;
|
|
|
1081 // card->cregs.c2pl2startadd1=card->regs.besa2corg;
|
|
|
1082 card->cregs.c2pl3startadd0=card->regs.besa1c3org;
|
|
|
1083 // card->cregs.c2pl3startadd1=card->regs.besa2c3org;
|
|
29263
|
1084
|
|
30990
|
1085 card->cregs.c2preload=(vsyncstart << 16) | (hsyncstart); // from
|
|
29263
|
1086
|
|
30990
|
1087 card->cregs.c2spicstartadd0=0; // not used
|
|
|
1088 // card->cregs.c2spicstartadd1=0; // not used
|
|
29263
|
1089
|
|
30990
|
1090 card->cregs.c2startadd0=card->regs.besa1org;
|
|
|
1091 // card->cregs.c2startadd1=card->regs.besa2org;
|
|
29263
|
1092
|
|
30990
|
1093 card->cregs.c2subpiclut=0; //not used
|
|
29263
|
1094
|
|
30990
|
1095 card->cregs.c2vparam = ( (vdispend - 1) << 16) | (vtotal - 1);
|
|
|
1096 card->cregs.c2vsync = ( (vsyncend - 1) << 16) | (vsyncstart - 1);
|
|
2344
|
1097
|
|
29263
|
1098
|
|
2344
|
1099 #endif
|
|
|
1100
|
|
30990
|
1101 mga_vid_write_regs(card, 0);
|
|
|
1102 return 0;
|
|
1
|
1103 }
|
|
|
1104
|
|
68
|
1105 #ifdef MGA_ALLOW_IRQ
|
|
|
1106
|
|
10743
|
1107 static void enable_irq(mga_card_t * card){
|
|
30990
|
1108 long int cc;
|
|
48
|
1109
|
|
30990
|
1110 cc = readl(card->mmio_base + IEN);
|
|
|
1111 // printk(KERN_ALERT "*** !!! IRQREG = %d\n", (int)(cc&0xff));
|
|
29263
|
1112
|
|
30990
|
1113 writeb(0x11, card->mmio_base + CRTCX);
|
|
29263
|
1114
|
|
30990
|
1115 writeb(0x20, card->mmio_base + CRTCD); /* clear 0, enable off */
|
|
|
1116 writeb(0x00, card->mmio_base + CRTCD); /* enable on */
|
|
|
1117 writeb(0x10, card->mmio_base + CRTCD); /* clear = 1 */
|
|
48
|
1118
|
|
30990
|
1119 writel(card->regs.besglobctl , card->mmio_base + BESGLOBCTL);
|
|
48
|
1120 }
|
|
|
1121
|
|
10743
|
1122 static void disable_irq(mga_card_t * card){
|
|
30990
|
1123 writeb(0x11, card->mmio_base + CRTCX);
|
|
|
1124 writeb(0x20, card->mmio_base + CRTCD); /* clear 0, enable off */
|
|
48
|
1125 }
|
|
|
1126
|
|
5884
|
1127 static void mga_handle_irq(int irq, void *dev_id, struct pt_regs *pregs) {
|
|
30990
|
1128 // static int frame=0;
|
|
|
1129 // static int counter=0;
|
|
|
1130 long int cc;
|
|
|
1131 mga_card_t * card = dev_id;
|
|
48
|
1132
|
|
30990
|
1133 // printk(KERN_DEBUG "vcount = %d\n",readl(mga_mmio_base + VCOUNT));
|
|
68
|
1134
|
|
30990
|
1135 //printk("mga_interrupt #%d\n", irq);
|
|
48
|
1136
|
|
30990
|
1137 // check whether the interrupt is really for us (irq sharing)
|
|
|
1138 if ( irq != -1 ) {
|
|
|
1139 cc = readl(card->mmio_base + STATUS);
|
|
|
1140 if ( ! (cc & 0x10) ) return; /* vsyncpen */
|
|
|
1141 // debug_irqcnt++;
|
|
|
1142 }
|
|
48
|
1143
|
|
30990
|
1144 // if ( debug_irqignore ) {
|
|
|
1145 // debug_irqignore = 0;
|
|
48
|
1146
|
|
30990
|
1147 // frame=(frame+1)&1;
|
|
|
1148 card->regs.besctl = (card->regs.besctl & ~0x07000000) + (card->next_frame << 25);
|
|
|
1149 writel( card->regs.besctl, card->mmio_base + BESCTL );
|
|
2344
|
1150
|
|
|
1151 #ifdef CRTC2
|
|
29263
|
1152 // sem pridat vyber obrazku !!!!
|
|
23734
|
1153 // i han echt kei ahnig was das obe heisse s旦ll
|
|
30990
|
1154 crtc2_frame_sel(card->next_frame);
|
|
2344
|
1155 #endif
|
|
29263
|
1156
|
|
48
|
1157 #if 0
|
|
30990
|
1158 ++counter;
|
|
|
1159 if(!(counter&63)){
|
|
|
1160 printk("mga irq counter = %d\n",counter);
|
|
|
1161 }
|
|
48
|
1162 #endif
|
|
|
1163
|
|
30990
|
1164 // } else {
|
|
|
1165 // debug_irqignore = 1;
|
|
|
1166 // }
|
|
48
|
1167
|
|
30990
|
1168 if ( irq != -1 ) {
|
|
|
1169 writeb( 0x11, card->mmio_base + CRTCX);
|
|
|
1170 writeb( 0, card->mmio_base + CRTCD );
|
|
|
1171 writeb( 0x10, card->mmio_base + CRTCD );
|
|
|
1172 }
|
|
48
|
1173
|
|
30990
|
1174 // writel( card->regs.besglobctl, card->mmio_base + BESGLOBCTL);
|
|
48
|
1175
|
|
30990
|
1176 return;
|
|
48
|
1177 }
|
|
|
1178
|
|
68
|
1179 #endif
|
|
1
|
1180
|
|
|
1181 static int mga_vid_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
|
|
|
1182 {
|
|
30990
|
1183 int frame, result;
|
|
|
1184 uint32_t tmp;
|
|
|
1185 mga_card_t * card = (mga_card_t *) file->private_data;
|
|
1
|
1186
|
|
30990
|
1187 switch(cmd)
|
|
|
1188 {
|
|
|
1189 case MGA_VID_GET_VERSION:
|
|
|
1190 tmp = MGA_VID_VERSION;
|
|
|
1191 if (copy_to_user((uint32_t *) arg, &tmp, sizeof(uint32_t))) {
|
|
|
1192 printk(KERN_ERR "mga_vid: failed copy %p to userspace %p\n", &tmp, (uint32_t *) arg);
|
|
|
1193 return -EFAULT;
|
|
|
1194 }
|
|
|
1195 break;
|
|
27026
|
1196
|
|
30990
|
1197 case MGA_VID_CONFIG:
|
|
|
1198 //FIXME remove
|
|
|
1199 // printk(KERN_DEBUG "mga_vid: vcount = %d\n",readl(card->mmio_base + VCOUNT));
|
|
5623
|
1200 #ifdef MP_DEBUG
|
|
30990
|
1201 printk(KERN_DEBUG "mga_vid: mmio_base = %p\n",card->mmio_base);
|
|
|
1202 printk(KERN_DEBUG "mga_vid: mem_base = %08x\n",card->mem_base);
|
|
|
1203 //FIXME remove
|
|
1
|
1204
|
|
30990
|
1205 printk(KERN_DEBUG "mga_vid: Received configuration\n");
|
|
29263
|
1206 #endif
|
|
1
|
1207
|
|
30990
|
1208 if(copy_from_user(&card->config,(mga_vid_config_t*) arg,sizeof(mga_vid_config_t)))
|
|
|
1209 {
|
|
|
1210 printk(KERN_ERR "mga_vid: failed copy from userspace\n");
|
|
|
1211 return -EFAULT;
|
|
|
1212 }
|
|
|
1213 if(card->config.version != MGA_VID_VERSION){
|
|
|
1214 printk(KERN_ERR "mga_vid: incompatible version! driver: %X requested: %X\n",MGA_VID_VERSION,card->config.version);
|
|
|
1215 return -EFAULT;
|
|
|
1216 }
|
|
57
|
1217
|
|
30990
|
1218 if(card->config.frame_size==0 || card->config.frame_size>1024*768*2){
|
|
|
1219 printk(KERN_ERR "mga_vid: illegal frame_size: %d\n",card->config.frame_size);
|
|
|
1220 return -EFAULT;
|
|
|
1221 }
|
|
57
|
1222
|
|
30990
|
1223 if(card->config.num_frames<1 || card->config.num_frames>4){
|
|
|
1224 printk(KERN_ERR "mga_vid: illegal num_frames: %d\n",card->config.num_frames);
|
|
|
1225 return -EFAULT;
|
|
|
1226 }
|
|
29263
|
1227
|
|
30990
|
1228 card->src_base = (card->ram_size * 0x100000 - card->config.num_frames * card->config.frame_size - card->top_reserved);
|
|
|
1229 if(card->src_base<0){
|
|
|
1230 printk(KERN_ERR "mga_vid: not enough memory for frames!\n");
|
|
|
1231 return -EFAULT;
|
|
|
1232 }
|
|
|
1233 card->src_base &= (~0xFFFF); // 64k boundary
|
|
5623
|
1234 #ifdef MP_DEBUG
|
|
30990
|
1235 printk(KERN_DEBUG "mga YUV buffer base: 0x%X\n", card->src_base);
|
|
29263
|
1236 #endif
|
|
|
1237
|
|
30990
|
1238 if (card->is_g400)
|
|
|
1239 card->config.card_type = MGA_G400;
|
|
|
1240 else
|
|
|
1241 card->config.card_type = MGA_G200;
|
|
29263
|
1242
|
|
30990
|
1243 card->config.ram_size = card->ram_size;
|
|
1
|
1244
|
|
30990
|
1245 if (copy_to_user((mga_vid_config_t *) arg, &card->config, sizeof(mga_vid_config_t)))
|
|
|
1246 {
|
|
|
1247 printk(KERN_ERR "mga_vid: failed copy to userspace\n");
|
|
|
1248 return -EFAULT;
|
|
|
1249 }
|
|
10743
|
1250
|
|
30990
|
1251 result = mga_vid_set_config(card);
|
|
|
1252 if(!result) card->configured=1;
|
|
|
1253 return result;
|
|
|
1254 break;
|
|
1
|
1255
|
|
30990
|
1256 case MGA_VID_ON:
|
|
5623
|
1257 #ifdef MP_DEBUG
|
|
30990
|
1258 printk(KERN_DEBUG "mga_vid: Video ON\n");
|
|
29263
|
1259 #endif
|
|
30990
|
1260 card->vid_src_ready = 1;
|
|
|
1261 if(card->vid_overlay_on)
|
|
|
1262 {
|
|
|
1263 card->regs.besctl |= 1;
|
|
|
1264 mga_vid_write_regs(card, 0);
|
|
|
1265 }
|
|
68
|
1266 #ifdef MGA_ALLOW_IRQ
|
|
30990
|
1267 if ( card->irq != -1 ) enable_irq(card);
|
|
68
|
1268 #endif
|
|
30990
|
1269 card->next_frame=0;
|
|
|
1270 break;
|
|
1
|
1271
|
|
30990
|
1272 case MGA_VID_OFF:
|
|
5623
|
1273 #ifdef MP_DEBUG
|
|
30990
|
1274 printk(KERN_DEBUG "mga_vid: Video OFF (ioctl)\n");
|
|
29263
|
1275 #endif
|
|
30990
|
1276 card->vid_src_ready = 0;
|
|
68
|
1277 #ifdef MGA_ALLOW_IRQ
|
|
30990
|
1278 if ( card->irq != -1 ) disable_irq(card);
|
|
68
|
1279 #endif
|
|
30990
|
1280 card->regs.besctl &= ~1;
|
|
|
1281 card->regs.besglobctl &= ~(1<<6); // UYVY format selected
|
|
|
1282 mga_vid_write_regs(card, 0);
|
|
|
1283 break;
|
|
29263
|
1284
|
|
30990
|
1285 case MGA_VID_FSEL:
|
|
|
1286 if(copy_from_user(&frame,(int *) arg,sizeof(int)))
|
|
|
1287 {
|
|
|
1288 printk(KERN_ERR "mga_vid: FSEL failed copy from userspace\n");
|
|
|
1289 return -EFAULT;
|
|
|
1290 }
|
|
1
|
1291
|
|
30990
|
1292 mga_vid_frame_sel(card, frame);
|
|
|
1293 break;
|
|
1
|
1294
|
|
30990
|
1295 case MGA_VID_GET_LUMA:
|
|
|
1296 //tmp = card->regs.beslumactl;
|
|
|
1297 //tmp = (tmp&0xFFFF0000) | (((tmp&0xFFFF) - 0x80)&0xFFFF);
|
|
|
1298 tmp = (card->brightness << 16) | (card->contrast&0xFFFF);
|
|
6798
|
1299
|
|
30990
|
1300 if (copy_to_user((uint32_t *) arg, &tmp, sizeof(uint32_t)))
|
|
|
1301 {
|
|
|
1302 printk(KERN_ERR "mga_vid: failed copy %p to userspace %p\n",
|
|
|
1303 &tmp, (uint32_t *) arg);
|
|
|
1304 return -EFAULT;
|
|
|
1305 }
|
|
|
1306 break;
|
|
29263
|
1307
|
|
30990
|
1308 case MGA_VID_SET_LUMA:
|
|
|
1309 tmp = arg;
|
|
|
1310 card->brightness=tmp>>16; card->contrast=tmp&0xFFFF;
|
|
|
1311 //card->regs.beslumactl = (tmp&0xFFFF0000) | ((tmp + 0x80)&0xFFFF);
|
|
|
1312 card->regs.beslumactl = (card->brightness << 16) | ((card->contrast+0x80)&0xFFFF);
|
|
|
1313 mga_vid_write_regs(card, 0);
|
|
|
1314 break;
|
|
29263
|
1315
|
|
30990
|
1316 default:
|
|
|
1317 printk(KERN_ERR "mga_vid: Invalid ioctl\n");
|
|
|
1318 return -EINVAL;
|
|
|
1319 }
|
|
29263
|
1320
|
|
30990
|
1321 return 0;
|
|
1
|
1322 }
|
|
|
1323
|
|
10743
|
1324 static void cards_init(mga_card_t * card, struct pci_dev * dev, int card_number, int is_g400);
|
|
1
|
1325
|
|
10743
|
1326 // returns the number of found cards
|
|
1
|
1327 static int mga_vid_find_card(void)
|
|
|
1328 {
|
|
30990
|
1329 struct pci_dev *dev = NULL;
|
|
|
1330 char *mga_dev_name;
|
|
|
1331 mga_card_t * card;
|
|
1
|
1332
|
|
30990
|
1333 while((dev = pci_find_device(PCI_VENDOR_ID_MATROX, PCI_ANY_ID, dev)))
|
|
|
1334 {
|
|
|
1335 mga_dev_name = "";
|
|
|
1336 mga_cards_num++;
|
|
|
1337 if(mga_cards_num == MGA_MAX_CARDS)
|
|
|
1338 {
|
|
|
1339 printk(KERN_WARNING "mga_vid: Trying to initialize more than %d cards\n",MGA_MAX_CARDS);
|
|
|
1340 mga_cards_num--;
|
|
|
1341 break;
|
|
|
1342 }
|
|
10743
|
1343
|
|
30990
|
1344 card = kmalloc(sizeof(mga_card_t), GFP_KERNEL);
|
|
|
1345 if(!card)
|
|
|
1346 {
|
|
|
1347 printk(KERN_ERR "mga_vid: memory allocation failed\n");
|
|
|
1348 mga_cards_num--;
|
|
|
1349 break;
|
|
|
1350 }
|
|
29263
|
1351
|
|
30990
|
1352 mga_cards[mga_cards_num - 1] = card;
|
|
29263
|
1353
|
|
30990
|
1354 switch(dev->device) {
|
|
|
1355 case PCI_DEVICE_ID_MATROX_G550:
|
|
|
1356 mga_dev_name = "MGA G550";
|
|
|
1357 printk(KERN_INFO "mga_vid: Found %s at %s [%s]\n", mga_dev_name, dev->slot_name, dev->name);
|
|
|
1358 cards_init(card, dev, mga_cards_num - 1, 1);
|
|
|
1359 break;
|
|
|
1360 case PCI_DEVICE_ID_MATROX_G400:
|
|
|
1361 mga_dev_name = "MGA G400/G450";
|
|
|
1362 printk(KERN_INFO "mga_vid: Found %s at %s [%s]\n", mga_dev_name, dev->slot_name, dev->name);
|
|
|
1363 cards_init(card, dev, mga_cards_num - 1, 1);
|
|
|
1364 break;
|
|
|
1365 case PCI_DEVICE_ID_MATROX_G200_AGP:
|
|
|
1366 mga_dev_name = "MGA G200 AGP";
|
|
|
1367 printk(KERN_INFO "mga_vid: Found %s at %s [%s]\n", mga_dev_name, dev->slot_name, dev->name);
|
|
|
1368 cards_init(card, dev, mga_cards_num - 1, 0);
|
|
|
1369 break;
|
|
|
1370 case PCI_DEVICE_ID_MATROX_G200_PCI:
|
|
|
1371 mga_dev_name = "MGA G200";
|
|
|
1372 printk(KERN_INFO "mga_vid: Found %s at %s [%s]\n", mga_dev_name, dev->slot_name, dev->name);
|
|
|
1373 cards_init(card, dev, mga_cards_num - 1, 0);
|
|
|
1374 break;
|
|
|
1375 default:
|
|
|
1376 mga_cards_num--;
|
|
|
1377 printk(KERN_INFO "mga_vid: ignoring matrox device (%d) at %s [%s]\n", dev->device, dev->slot_name, dev->name);
|
|
|
1378 break;
|
|
|
1379 }
|
|
|
1380 }
|
|
29263
|
1381
|
|
30990
|
1382 if(!mga_cards_num)
|
|
|
1383 {
|
|
|
1384 printk(KERN_ERR "mga_vid: No supported cards found\n");
|
|
|
1385 } else {
|
|
|
1386 printk(KERN_INFO "mga_vid: %d supported cards found\n", mga_cards_num);
|
|
|
1387 }
|
|
29263
|
1388
|
|
30990
|
1389 return mga_cards_num;
|
|
1
|
1390 }
|
|
|
1391
|
|
10743
|
1392 static void mga_param_buff_fill( mga_card_t * card )
|
|
4484
|
1393 {
|
|
|
1394 unsigned len;
|
|
10743
|
1395 unsigned size = card->param_buff_size;
|
|
|
1396 char * buf = card->param_buff;
|
|
4484
|
1397 len = 0;
|
|
10743
|
1398 len += snprintf(&buf[len],size-len,"Interface version: %04X\n",MGA_VID_VERSION);
|
|
|
1399 len += snprintf(&buf[len],size-len,"Memory: %x:%dM\n",card->mem_base,(unsigned int) card->ram_size);
|
|
|
1400 len += snprintf(&buf[len],size-len,"MMIO: %p\n",card->mmio_base);
|
|
|
1401 len += snprintf(&buf[len],size-len,"Configurable stuff:\n");
|
|
|
1402 len += snprintf(&buf[len],size-len,"~~~~~~~~~~~~~~~~~~~\n");
|
|
|
1403 len += snprintf(&buf[len],size-len,PARAM_BRIGHTNESS"%d\n",card->brightness);
|
|
|
1404 len += snprintf(&buf[len],size-len,PARAM_CONTRAST"%d\n",card->contrast);
|
|
|
1405 len += snprintf(&buf[len],size-len,PARAM_BLACKIE"%s\n",card->regs.blackie?"on":"off");
|
|
|
1406 card->param_buff_len = len;
|
|
4527
|
1407 // check boundaries of mga_param_buff before writing to it!!!
|
|
4484
|
1408 }
|
|
|
1409
|
|
1
|
1410
|
|
|
1411 static ssize_t mga_vid_read(struct file *file, char *buf, size_t count, loff_t *ppos)
|
|
|
1412 {
|
|
30990
|
1413 uint32_t size;
|
|
|
1414 mga_card_t * card = (mga_card_t *) file->private_data;
|
|
29263
|
1415
|
|
30990
|
1416 if(!card->param_buff) return -ESPIPE;
|
|
|
1417 if(!(*ppos)) mga_param_buff_fill(card);
|
|
|
1418 if(*ppos >= card->param_buff_len) return 0;
|
|
|
1419 size = min(count,card->param_buff_len-(uint32_t)(*ppos));
|
|
|
1420 memcpy(buf,card->param_buff,size);
|
|
|
1421 *ppos += size;
|
|
|
1422 return size;
|
|
1
|
1423 }
|
|
|
1424
|
|
|
1425 static ssize_t mga_vid_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
|
|
|
1426 {
|
|
30990
|
1427 mga_card_t * card = (mga_card_t *) file->private_data;
|
|
10743
|
1428
|
|
30990
|
1429 if(memcmp(buf,PARAM_BRIGHTNESS,min(count,strlen(PARAM_BRIGHTNESS))) == 0)
|
|
|
1430 {
|
|
|
1431 short brightness;
|
|
|
1432 brightness=simple_strtol(&buf[strlen(PARAM_BRIGHTNESS)],NULL,10);
|
|
|
1433 if (brightness>127 || brightness<-128) { brightness=0;}
|
|
|
1434 // printk(KERN_DEBUG "mga_vid: brightness modified ( %d ) \n",brightness);
|
|
|
1435 card->brightness=brightness;
|
|
|
1436 } else
|
|
|
1437 if(memcmp(buf,PARAM_CONTRAST,min(count,strlen(PARAM_CONTRAST))) == 0)
|
|
|
1438 {
|
|
|
1439 short contrast;
|
|
|
1440 contrast=simple_strtol(&buf[strlen(PARAM_CONTRAST)],NULL,10);
|
|
|
1441 if (contrast>127 || contrast<-128) { contrast=0;}
|
|
|
1442 // printk(KERN_DEBUG "mga_vid: contrast modified ( %d ) \n",contrast);
|
|
|
1443 card->contrast=contrast;
|
|
|
1444 } else
|
|
4487
|
1445
|
|
30990
|
1446 if(memcmp(buf,PARAM_BLACKIE,min(count,strlen(PARAM_BLACKIE))) == 0)
|
|
|
1447 {
|
|
|
1448 short blackie;
|
|
|
1449 blackie=simple_strtol(&buf[strlen(PARAM_BLACKIE)],NULL,10);
|
|
|
1450 // printk(KERN_DEBUG "mga_vid: shadow mode: ( %d ) \n",blackie);
|
|
|
1451 card->regs.blackie=(blackie>0)?1:0;
|
|
|
1452 } else count = -EIO;
|
|
|
1453 // TODO: reset settings
|
|
|
1454 return count;
|
|
1
|
1455 }
|
|
|
1456
|
|
|
1457 static int mga_vid_mmap(struct file *file, struct vm_area_struct *vma)
|
|
|
1458 {
|
|
30990
|
1459 mga_card_t * card = (mga_card_t *) file->private_data;
|
|
1
|
1460
|
|
5623
|
1461 #ifdef MP_DEBUG
|
|
30990
|
1462 printk(KERN_DEBUG "mga_vid: mapping video memory into userspace\n");
|
|
29263
|
1463 #endif
|
|
10743
|
1464
|
|
30990
|
1465 if(!card->configured)
|
|
|
1466 {
|
|
|
1467 printk(KERN_ERR "mga_vid: card is not configured, cannot mmap\n");
|
|
|
1468 return -EAGAIN;
|
|
|
1469 }
|
|
10743
|
1470
|
|
30990
|
1471 if(remap_page_range(vma->vm_start, card->mem_base + card->src_base,
|
|
|
1472 vma->vm_end - vma->vm_start, vma->vm_page_prot))
|
|
|
1473 {
|
|
|
1474 printk(KERN_ERR "mga_vid: error mapping video memory\n");
|
|
|
1475 return -EAGAIN;
|
|
|
1476 }
|
|
1
|
1477
|
|
30990
|
1478 return 0;
|
|
1
|
1479 }
|
|
|
1480
|
|
|
1481 static int mga_vid_release(struct inode *inode, struct file *file)
|
|
|
1482 {
|
|
30990
|
1483 mga_card_t * card;
|
|
10743
|
1484
|
|
30990
|
1485 //Close the window just in case
|
|
5623
|
1486 #ifdef MP_DEBUG
|
|
30990
|
1487 printk(KERN_DEBUG "mga_vid: Video OFF (release)\n");
|
|
29263
|
1488 #endif
|
|
94
|
1489
|
|
30990
|
1490 card = (mga_card_t *) file->private_data;
|
|
10743
|
1491
|
|
30990
|
1492 card->vid_src_ready = 0;
|
|
|
1493 card->regs.besctl &= ~1;
|
|
|
1494 card->regs.besglobctl &= ~(1<<6); // UYVY format selected
|
|
|
1495 // card->config.colkey_on=0; //!!!
|
|
|
1496 mga_vid_write_regs(card, 1);
|
|
|
1497 card->vid_in_use = 0;
|
|
1
|
1498
|
|
30990
|
1499 MOD_DEC_USE_COUNT;
|
|
|
1500 return 0;
|
|
1
|
1501 }
|
|
|
1502
|
|
|
1503 static long long mga_vid_lseek(struct file *file, long long offset, int origin)
|
|
|
1504 {
|
|
30990
|
1505 return -ESPIPE;
|
|
29263
|
1506 }
|
|
1
|
1507
|
|
|
1508 static int mga_vid_open(struct inode *inode, struct file *file)
|
|
|
1509 {
|
|
30990
|
1510 mga_card_t * card;
|
|
29263
|
1511
|
|
30990
|
1512 int minor = MINOR(inode->i_rdev);
|
|
1
|
1513
|
|
30990
|
1514 if(!file->private_data)
|
|
|
1515 {
|
|
|
1516 // we are not using devfs, use the minor
|
|
|
1517 // number to specify the card we are using
|
|
10743
|
1518
|
|
30990
|
1519 // we don't have that many cards
|
|
|
1520 if(minor >= mga_cards_num)
|
|
|
1521 return -ENXIO;
|
|
1
|
1522
|
|
30990
|
1523 file->private_data = mga_cards[minor];
|
|
10743
|
1524 #ifdef MP_DEBUG
|
|
30990
|
1525 printk(KERN_DEBUG "mga_vid: Not using devfs\n");
|
|
29263
|
1526 #endif
|
|
30990
|
1527 }
|
|
10743
|
1528 #ifdef MP_DEBUG
|
|
30990
|
1529 else {
|
|
|
1530 printk(KERN_DEBUG "mga_vid: Using devfs\n");
|
|
|
1531 }
|
|
29263
|
1532 #endif
|
|
10743
|
1533
|
|
30990
|
1534 card = (mga_card_t *) file->private_data;
|
|
10743
|
1535
|
|
30990
|
1536 if(card->vid_in_use == 1)
|
|
|
1537 return -EBUSY;
|
|
1
|
1538
|
|
30990
|
1539 card->vid_in_use = 1;
|
|
|
1540 MOD_INC_USE_COUNT;
|
|
|
1541 return 0;
|
|
1
|
1542 }
|
|
|
1543
|
|
|
1544 #if LINUX_VERSION_CODE >= 0x020400
|
|
|
1545 static struct file_operations mga_vid_fops =
|
|
|
1546 {
|
|
30990
|
1547 llseek: mga_vid_lseek,
|
|
|
1548 read: mga_vid_read,
|
|
|
1549 write: mga_vid_write,
|
|
|
1550 ioctl: mga_vid_ioctl,
|
|
|
1551 mmap: mga_vid_mmap,
|
|
|
1552 open: mga_vid_open,
|
|
|
1553 release: mga_vid_release
|
|
1
|
1554 };
|
|
|
1555 #else
|
|
|
1556 static struct file_operations mga_vid_fops =
|
|
|
1557 {
|
|
30990
|
1558 mga_vid_lseek,
|
|
|
1559 mga_vid_read,
|
|
|
1560 mga_vid_write,
|
|
|
1561 NULL,
|
|
|
1562 NULL,
|
|
|
1563 mga_vid_ioctl,
|
|
|
1564 mga_vid_mmap,
|
|
|
1565 mga_vid_open,
|
|
|
1566 NULL,
|
|
|
1567 mga_vid_release
|
|
1
|
1568 };
|
|
|
1569 #endif
|
|
|
1570
|
|
10743
|
1571 static void cards_init(mga_card_t * card, struct pci_dev * dev, int card_number, int is_g400)
|
|
|
1572 {
|
|
30990
|
1573 unsigned int card_option;
|
|
10743
|
1574 // temp buffer for device filename creation used only by devfs
|
|
|
1575 #ifdef CONFIG_DEVFS_FS
|
|
30990
|
1576 char buffer[16];
|
|
10743
|
1577 #endif
|
|
|
1578
|
|
30990
|
1579 memset(card,0,sizeof(mga_card_t));
|
|
|
1580 card->irq = -1;
|
|
10743
|
1581
|
|
30990
|
1582 card->pci_dev = dev;
|
|
|
1583 card->irq = dev->irq;
|
|
|
1584 card->is_g400 = is_g400;
|
|
10743
|
1585
|
|
30990
|
1586 card->param_buff = kmalloc(PARAM_BUFF_SIZE,GFP_KERNEL);
|
|
|
1587 if(card->param_buff) card->param_buff_size = PARAM_BUFF_SIZE;
|
|
10743
|
1588
|
|
30990
|
1589 card->brightness = mga_brightness[card_number];
|
|
|
1590 card->contrast = mga_contrast[card_number];
|
|
|
1591 card->top_reserved = mga_top_reserved[card_number];
|
|
29263
|
1592
|
|
10743
|
1593 #if LINUX_VERSION_CODE >= 0x020300
|
|
30990
|
1594 card->mmio_base = ioremap_nocache(dev->resource[1].start,0x4000);
|
|
|
1595 card->mem_base = dev->resource[0].start;
|
|
10743
|
1596 #else
|
|
30990
|
1597 card->mmio_base = ioremap_nocache(dev->base_address[1] & PCI_BASE_ADDRESS_MEM_MASK,0x4000);
|
|
|
1598 card->mem_base = dev->base_address[0] & PCI_BASE_ADDRESS_MEM_MASK;
|
|
10743
|
1599 #endif
|
|
30990
|
1600 printk(KERN_INFO "mga_vid: MMIO at 0x%p IRQ: %d framebuffer: 0x%08X\n", card->mmio_base, card->irq, card->mem_base);
|
|
10743
|
1601
|
|
30990
|
1602 pci_read_config_dword(dev, 0x40, &card_option);
|
|
|
1603 printk(KERN_INFO "mga_vid: OPTION word: 0x%08X mem: 0x%02X %s\n", card_option,
|
|
|
1604 (card_option>>10)&0x17, ((card_option>>14)&1)?"SGRAM":"SDRAM");
|
|
10743
|
1605
|
|
30990
|
1606 if (mga_ram_size[card_number]) {
|
|
|
1607 printk(KERN_INFO "mga_vid: RAMSIZE forced to %d MB\n", mga_ram_size[card_number]);
|
|
|
1608 card->ram_size=mga_ram_size[card_number];
|
|
|
1609 } else {
|
|
10743
|
1610
|
|
|
1611 #ifdef MGA_MEMORY_SIZE
|
|
30990
|
1612 card->ram_size = MGA_MEMORY_SIZE;
|
|
|
1613 printk(KERN_INFO "mga_vid: hard-coded RAMSIZE is %d MB\n", (unsigned int) card->ram_size);
|
|
10743
|
1614 #else
|
|
30990
|
1615 if (card->is_g400){
|
|
|
1616 switch((card_option>>10)&0x17){
|
|
|
1617 // SDRAM:
|
|
|
1618 case 0x00:
|
|
|
1619 case 0x04: card->ram_size = 16; break;
|
|
|
1620 case 0x03:
|
|
|
1621 case 0x05: card->ram_size = 32; break;
|
|
|
1622 // SGRAM:
|
|
|
1623 case 0x10:
|
|
|
1624 case 0x14: card->ram_size = 32; break;
|
|
|
1625 case 0x11:
|
|
|
1626 case 0x12: card->ram_size = 16; break;
|
|
|
1627 default:
|
|
|
1628 card->ram_size = 16;
|
|
|
1629 printk(KERN_INFO "mga_vid: Couldn't detect RAMSIZE, assuming 16MB!");
|
|
|
1630 }
|
|
|
1631 /* Check for buggy 16MB cards reporting 32 MB */
|
|
|
1632 if(card->ram_size != 16 &&
|
|
|
1633 (dev->subsystem_device == PCI_SUBSYSTEM_ID_MATROX_G400_16MB_SDRAM ||
|
|
|
1634 dev->subsystem_device == PCI_SUBSYSTEM_ID_MATROX_G400_16MB_SGRAM ||
|
|
|
1635 dev->subsystem_device == PCI_SUBSYSTEM_ID_MATROX_G400_DH_16MB))
|
|
|
1636 {
|
|
|
1637 printk(KERN_INFO "mga_vid: Detected 16MB card reporting %d MB RAMSIZE, overriding\n", card->ram_size);
|
|
|
1638 card->ram_size = 16;
|
|
|
1639 }
|
|
|
1640 }else{
|
|
|
1641 switch((card_option>>10)&0x17){
|
|
|
1642 // case 0x10:
|
|
|
1643 // case 0x13: card->ram_size = 8; break;
|
|
|
1644 default: card->ram_size = 8;
|
|
|
1645 }
|
|
|
1646 }
|
|
10743
|
1647 #if 0
|
|
30990
|
1648 // printk("List resources -----------\n");
|
|
|
1649 for(temp=0;temp<DEVICE_COUNT_RESOURCE;temp++){
|
|
|
1650 struct resource *res=&dev->resource[temp];
|
|
|
1651 if(res->flags){
|
|
|
1652 int size=(1+res->end-res->start)>>20;
|
|
|
1653 printk(KERN_DEBUG "res %d: start: 0x%X end: 0x%X (%d MB) flags=0x%X\n",temp,res->start,res->end,size,res->flags);
|
|
|
1654 if(res->flags&(IORESOURCE_MEM|IORESOURCE_PREFETCH)){
|
|
|
1655 if(size>card->ram_size && size<=64) card->ram_size=size;
|
|
|
1656 }
|
|
|
1657 }
|
|
|
1658 }
|
|
10743
|
1659 #endif
|
|
30990
|
1660 printk(KERN_INFO "mga_vid: detected RAMSIZE is %d MB\n", (unsigned int) card->ram_size);
|
|
10743
|
1661 #endif
|
|
30990
|
1662 }
|
|
10743
|
1663
|
|
|
1664
|
|
|
1665 #ifdef MGA_ALLOW_IRQ
|
|
30990
|
1666 if ( card->irq != -1 ) {
|
|
|
1667 int tmp = request_irq(card->irq, mga_handle_irq, SA_INTERRUPT | SA_SHIRQ, "Syncfb Time Base", card);
|
|
|
1668 if ( tmp ) {
|
|
|
1669 printk(KERN_INFO "syncfb (mga): cannot register irq %d (Err: %d)\n", card->irq, tmp);
|
|
|
1670 card->irq=-1;
|
|
|
1671 } else {
|
|
|
1672 printk(KERN_DEBUG "syncfb (mga): registered irq %d\n", card->irq);
|
|
|
1673 }
|
|
|
1674 } else {
|
|
|
1675 printk(KERN_INFO "syncfb (mga): No valid irq was found\n");
|
|
|
1676 card->irq=-1;
|
|
|
1677 }
|
|
10743
|
1678 #else
|
|
30990
|
1679 printk(KERN_INFO "syncfb (mga): IRQ disabled in mga_vid.c\n");
|
|
|
1680 card->irq=-1;
|
|
10743
|
1681 #endif
|
|
|
1682
|
|
30990
|
1683 // register devfs, let the kernel give us major and minor numbers
|
|
10743
|
1684 #ifdef CONFIG_DEVFS_FS
|
|
30990
|
1685 snprintf(buffer, 16, "mga_vid%d", card_number);
|
|
|
1686 card->dev_handle = devfs_register(NULL, buffer, DEVFS_FL_AUTO_DEVNUM,
|
|
|
1687 0, 0,
|
|
|
1688 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IFCHR,
|
|
|
1689 &mga_vid_fops, card);
|
|
10743
|
1690 #endif
|
|
|
1691 }
|
|
1
|
1692
|
|
29263
|
1693 /*
|
|
|
1694 * Main Initialization Function
|
|
1
|
1695 */
|
|
|
1696
|
|
|
1697 static int mga_vid_initialize(void)
|
|
|
1698 {
|
|
30990
|
1699 int i;
|
|
1
|
1700
|
|
30990
|
1701 // printk(KERN_INFO "Matrox MGA G200/G400 YUV Video interface v0.01 (c) Aaron Holtzman \n");
|
|
|
1702 printk(KERN_INFO "Matrox MGA G200/G400/G450/G550 YUV Video interface v2.01 (c) Aaron Holtzman & A'rpi\n");
|
|
90
|
1703
|
|
30990
|
1704 for(i = 0; i < MGA_MAX_CARDS; i++)
|
|
|
1705 {
|
|
|
1706 if (mga_ram_size[i]) {
|
|
|
1707 if (mga_ram_size[i]<4 || mga_ram_size[i]>64) {
|
|
|
1708 printk(KERN_ERR "mga_vid: invalid RAMSIZE: %d MB\n", mga_ram_size[i]);
|
|
|
1709 return -EINVAL;
|
|
|
1710 }
|
|
|
1711 }
|
|
|
1712 }
|
|
29263
|
1713
|
|
30990
|
1714 if(register_chrdev(major, "mga_vid", &mga_vid_fops))
|
|
|
1715 {
|
|
|
1716 printk(KERN_ERR "mga_vid: unable to get major: %d\n", major);
|
|
|
1717 return -EIO;
|
|
|
1718 }
|
|
1
|
1719
|
|
30990
|
1720 if (!mga_vid_find_card())
|
|
|
1721 {
|
|
|
1722 printk(KERN_ERR "mga_vid: no supported devices found\n");
|
|
|
1723 unregister_chrdev(major, "mga_vid");
|
|
|
1724 return -EINVAL;
|
|
|
1725 }
|
|
10743
|
1726 #ifdef CONFIG_DEVFS_FS
|
|
30990
|
1727 else {
|
|
|
1728 // we assume that this always succeedes
|
|
|
1729 dev_handle = devfs_register(NULL, "mga_vid", DEVFS_FL_AUTO_DEVNUM,
|
|
|
1730 0,0,
|
|
|
1731 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IFCHR,
|
|
|
1732 &mga_vid_fops, mga_cards[0]);
|
|
|
1733 }
|
|
10743
|
1734 #endif
|
|
|
1735
|
|
30990
|
1736 return 0;
|
|
1
|
1737 }
|
|
|
1738
|
|
|
1739 int init_module(void)
|
|
|
1740 {
|
|
30990
|
1741 return mga_vid_initialize();
|
|
1
|
1742 }
|
|
|
1743
|
|
|
1744 void cleanup_module(void)
|
|
|
1745 {
|
|
30990
|
1746 int i;
|
|
|
1747 mga_card_t * card;
|
|
48
|
1748
|
|
30990
|
1749 for (i = 0; i < MGA_MAX_CARDS; i++)
|
|
|
1750 {
|
|
|
1751 card = mga_cards[i];
|
|
|
1752 if(card)
|
|
|
1753 {
|
|
68
|
1754 #ifdef MGA_ALLOW_IRQ
|
|
30990
|
1755 if (card->irq != -1)
|
|
|
1756 free_irq(card->irq, &(card->irq));
|
|
68
|
1757 #endif
|
|
48
|
1758
|
|
30990
|
1759 if(card->mmio_base)
|
|
|
1760 iounmap(card->mmio_base);
|
|
|
1761 if(card->param_buff)
|
|
|
1762 kfree(card->param_buff);
|
|
10743
|
1763 #ifdef CONFIG_DEVFS_FS
|
|
30990
|
1764 if(card->dev_handle) devfs_unregister(card->dev_handle);
|
|
10743
|
1765 #endif
|
|
|
1766
|
|
30990
|
1767 kfree(card);
|
|
|
1768 mga_cards[i]=NULL;
|
|
|
1769 }
|
|
|
1770 }
|
|
1
|
1771
|
|
30990
|
1772 //FIXME turn off BES
|
|
|
1773 printk(KERN_INFO "mga_vid: Cleaning up module\n");
|
|
5653
|
1774 #ifdef CONFIG_DEVFS_FS
|
|
30990
|
1775 if(dev_handle) devfs_unregister(dev_handle);
|
|
5764
|
1776 #endif
|
|
30990
|
1777 unregister_chrdev(major, "mga_vid");
|
|
1
|
1778 }
|
