?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] more fallout from get_property returning pointer to const
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / video / riva / fbdev.c
blob61a4665fb4863247a39024db50d6e29c3e4d49a6
1 /*
2 * linux/drivers/video/riva/fbdev.c - nVidia RIVA 128/TNT/TNT2 fb driver
3 *
4 * Maintained by Ani Joshi <ajoshi@shell.unixbox.com>
5 *
6 * Copyright 1999-2000 Jeff Garzik
7 *
8 * Contributors:
9 *
10 * Ani Joshi: Lots of debugging and cleanup work, really helped
11 * get the driver going
12 *
13 * Ferenc Bakonyi: Bug fixes, cleanup, modularization
14 *
15 * Jindrich Makovicka: Accel code help, hw cursor, mtrr
16 *
17 * Paul Richards: Bug fixes, updates
18 *
19 * Initial template from skeletonfb.c, created 28 Dec 1997 by Geert Uytterhoeven
20 * Includes riva_hw.c from nVidia, see copyright below.
21 * KGI code provided the basis for state storage, init, and mode switching.
22 *
23 * This file is subject to the terms and conditions of the GNU General Public
24 * License. See the file COPYING in the main directory of this archive
25 * for more details.
26 *
27 * Known bugs and issues:
28 * restoring text mode fails
29 * doublescan modes are broken
30 */
31
32 #include <linux/module.h>
33 #include <linux/kernel.h>
34 #include <linux/errno.h>
35 #include <linux/string.h>
36 #include <linux/mm.h>
37 #include <linux/slab.h>
38 #include <linux/delay.h>
39 #include <linux/fb.h>
40 #include <linux/init.h>
41 #include <linux/pci.h>
42 #include <linux/backlight.h>
43 #ifdef CONFIG_MTRR
44 #include <asm/mtrr.h>
45 #endif
46 #ifdef CONFIG_PPC_OF
47 #include <asm/prom.h>
48 #include <asm/pci-bridge.h>
49 #endif
50 #ifdef CONFIG_PMAC_BACKLIGHT
51 #include <asm/machdep.h>
52 #include <asm/backlight.h>
53 #endif
54
55 #include "rivafb.h"
56 #include "nvreg.h"
57
58 #ifndef CONFIG_PCI /* sanity check */
59 #error This driver requires PCI support.
60 #endif
61
62 /* version number of this driver */
63 #define RIVAFB_VERSION "0.9.5b"
64
65 /* ------------------------------------------------------------------------- *
66 *
67 * various helpful macros and constants
68 *
69 * ------------------------------------------------------------------------- */
70 #ifdef CONFIG_FB_RIVA_DEBUG
71 #define NVTRACE printk
72 #else
73 #define NVTRACE if(0) printk
74 #endif
75
76 #define NVTRACE_ENTER(...) NVTRACE("%s START\n", __FUNCTION__)
77 #define NVTRACE_LEAVE(...) NVTRACE("%s END\n", __FUNCTION__)
78
79 #ifdef CONFIG_FB_RIVA_DEBUG
80 #define assert(expr) \
81 if(!(expr)) { \
82 printk( "Assertion failed! %s,%s,%s,line=%d\n",\
83 #expr,__FILE__,__FUNCTION__,__LINE__); \
84 BUG(); \
85 }
86 #else
87 #define assert(expr)
88 #endif
89
90 #define PFX "rivafb: "
91
92 /* macro that allows you to set overflow bits */
93 #define SetBitField(value,from,to) SetBF(to,GetBF(value,from))
94 #define SetBit(n) (1<<(n))
95 #define Set8Bits(value) ((value)&0xff)
96
97 /* HW cursor parameters */
98 #define MAX_CURS 32
99
100 /* ------------------------------------------------------------------------- *
101 *
102 * prototypes
103 *
104 * ------------------------------------------------------------------------- */
105
106 static int rivafb_blank(int blank, struct fb_info *info);
107
108 /* ------------------------------------------------------------------------- *
109 *
110 * card identification
111 *
112 * ------------------------------------------------------------------------- */
113
114 static struct pci_device_id rivafb_pci_tbl[] = {
115 { PCI_VENDOR_ID_NVIDIA_SGS, PCI_DEVICE_ID_NVIDIA_SGS_RIVA128,
116 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
117 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_TNT,
118 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
119 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_TNT2,
120 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
121 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_UTNT2,
122 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
123 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_VTNT2,
124 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
125 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_UVTNT2,
126 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
127 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_ITNT2,
128 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
129 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE_SDR,
130 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
131 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE_DDR,
132 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
133 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO,
134 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
135 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE2_MX,
136 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
137 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE2_MX2,
138 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
139 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE2_GO,
140 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
141 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO2_MXR,
142 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
143 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE2_GTS,
144 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
145 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE2_GTS2,
146 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
147 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE2_ULTRA,
148 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
149 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO2_PRO,
150 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
151 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_460,
152 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
153 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_440,
154 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
155 // NF2/IGP version, GeForce 4 MX, NV18
156 { PCI_VENDOR_ID_NVIDIA, 0x01f0,
157 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
158 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_420,
159 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
160 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_440_GO,
161 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
162 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_420_GO,
163 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
164 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_420_GO_M32,
165 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
166 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_500XGL,
167 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
168 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_440_GO_M64,
169 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
170 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_200,
171 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
172 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_550XGL,
173 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
174 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_500_GOGL,
175 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
176 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_IGEFORCE2,
177 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
178 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE3,
179 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
180 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE3_1,
181 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
182 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE3_2,
183 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
184 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO_DDC,
185 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
186 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4600,
187 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
188 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4400,
189 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
190 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4200,
191 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
192 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_900XGL,
193 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
194 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_750XGL,
195 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
196 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_700XGL,
197 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
198 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_GO_5200,
199 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
200 { 0, } /* terminate list */
201 };
202 MODULE_DEVICE_TABLE(pci, rivafb_pci_tbl);
203
204 /* ------------------------------------------------------------------------- *
205 *
206 * global variables
207 *
208 * ------------------------------------------------------------------------- */
209
210 /* command line data, set in rivafb_setup() */
211 static int flatpanel __devinitdata = -1; /* Autodetect later */
212 static int forceCRTC __devinitdata = -1;
213 static int noaccel __devinitdata = 0;
214 #ifdef CONFIG_MTRR
215 static int nomtrr __devinitdata = 0;
216 #endif
217
218 static char *mode_option __devinitdata = NULL;
219 static int strictmode = 0;
220
221 static struct fb_fix_screeninfo __devinitdata rivafb_fix = {
222 .type = FB_TYPE_PACKED_PIXELS,
223 .xpanstep = 1,
224 .ypanstep = 1,
225 };
226
227 static struct fb_var_screeninfo __devinitdata rivafb_default_var = {
228 .xres = 640,
229 .yres = 480,
230 .xres_virtual = 640,
231 .yres_virtual = 480,
232 .bits_per_pixel = 8,
233 .red = {0, 8, 0},
234 .green = {0, 8, 0},
235 .blue = {0, 8, 0},
236 .transp = {0, 0, 0},
237 .activate = FB_ACTIVATE_NOW,
238 .height = -1,
239 .width = -1,
240 .pixclock = 39721,
241 .left_margin = 40,
242 .right_margin = 24,
243 .upper_margin = 32,
244 .lower_margin = 11,
245 .hsync_len = 96,
246 .vsync_len = 2,
247 .vmode = FB_VMODE_NONINTERLACED
248 };
249
250 /* from GGI */
251 static const struct riva_regs reg_template = {
252 {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /* ATTR */
253 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
254 0x41, 0x01, 0x0F, 0x00, 0x00},
255 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* CRT */
256 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
257 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE3, /* 0x10 */
258 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
259 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x20 */
260 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
261 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x30 */
262 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
263 0x00, /* 0x40 */
264 },
265 {0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, /* GRA */
266 0xFF},
267 {0x03, 0x01, 0x0F, 0x00, 0x0E}, /* SEQ */
268 0xEB /* MISC */
269 };
270
271 /*
272 * Backlight control
273 */
274 #ifdef CONFIG_FB_RIVA_BACKLIGHT
275 /* We do not have any information about which values are allowed, thus
276 * we used safe values.
277 */
278 #define MIN_LEVEL 0x158
279 #define MAX_LEVEL 0x534
280 #define LEVEL_STEP ((MAX_LEVEL - MIN_LEVEL) / FB_BACKLIGHT_MAX)
281
282 static struct backlight_properties riva_bl_data;
283
284 /* Call with fb_info->bl_mutex held */
285 static int riva_bl_get_level_brightness(struct riva_par *par,
286 int level)
287 {
288 struct fb_info *info = pci_get_drvdata(par->pdev);
289 int nlevel;
290
291 /* Get and convert the value */
292 nlevel = MIN_LEVEL + info->bl_curve[level] * LEVEL_STEP;
293
294 if (nlevel < 0)
295 nlevel = 0;
296 else if (nlevel < MIN_LEVEL)
297 nlevel = MIN_LEVEL;
298 else if (nlevel > MAX_LEVEL)
299 nlevel = MAX_LEVEL;
300
301 return nlevel;
302 }
303
304 /* Call with fb_info->bl_mutex held */
305 static int __riva_bl_update_status(struct backlight_device *bd)
306 {
307 struct riva_par *par = class_get_devdata(&bd->class_dev);
308 U032 tmp_pcrt, tmp_pmc;
309 int level;
310
311 if (bd->props->power != FB_BLANK_UNBLANK ||
312 bd->props->fb_blank != FB_BLANK_UNBLANK)
313 level = 0;
314 else
315 level = bd->props->brightness;
316
317 tmp_pmc = par->riva.PMC[0x10F0/4] & 0x0000FFFF;
318 tmp_pcrt = par->riva.PCRTC0[0x081C/4] & 0xFFFFFFFC;
319 if(level > 0) {
320 tmp_pcrt |= 0x1;
321 tmp_pmc |= (1 << 31); /* backlight bit */
322 tmp_pmc |= riva_bl_get_level_brightness(par, level) << 16; /* level */
323 }
324 par->riva.PCRTC0[0x081C/4] = tmp_pcrt;
325 par->riva.PMC[0x10F0/4] = tmp_pmc;
326
327 return 0;
328 }
329
330 static int riva_bl_update_status(struct backlight_device *bd)
331 {
332 struct riva_par *par = class_get_devdata(&bd->class_dev);
333 struct fb_info *info = pci_get_drvdata(par->pdev);
334 int ret;
335
336 mutex_lock(&info->bl_mutex);
337 ret = __riva_bl_update_status(bd);
338 mutex_unlock(&info->bl_mutex);
339
340 return ret;
341 }
342
343 static int riva_bl_get_brightness(struct backlight_device *bd)
344 {
345 return bd->props->brightness;
346 }
347
348 static struct backlight_properties riva_bl_data = {
349 .owner = THIS_MODULE,
350 .get_brightness = riva_bl_get_brightness,
351 .update_status = riva_bl_update_status,
352 .max_brightness = (FB_BACKLIGHT_LEVELS - 1),
353 };
354
355 static void riva_bl_set_power(struct fb_info *info, int power)
356 {
357 mutex_lock(&info->bl_mutex);
358
359 if (info->bl_dev) {
360 down(&info->bl_dev->sem);
361 info->bl_dev->props->power = power;
362 __riva_bl_update_status(info->bl_dev);
363 up(&info->bl_dev->sem);
364 }
365
366 mutex_unlock(&info->bl_mutex);
367 }
368
369 static void riva_bl_init(struct riva_par *par)
370 {
371 struct fb_info *info = pci_get_drvdata(par->pdev);
372 struct backlight_device *bd;
373 char name[12];
374
375 if (!par->FlatPanel)
376 return;
377
378 #ifdef CONFIG_PMAC_BACKLIGHT
379 if (!machine_is(powermac) ||
380 !pmac_has_backlight_type("mnca"))
381 return;
382 #endif
383
384 snprintf(name, sizeof(name), "rivabl%d", info->node);
385
386 bd = backlight_device_register(name, par, &riva_bl_data);
387 if (IS_ERR(bd)) {
388 info->bl_dev = NULL;
389 printk(KERN_WARNING "riva: Backlight registration failed\n");
390 goto error;
391 }
392
393 mutex_lock(&info->bl_mutex);
394 info->bl_dev = bd;
395 fb_bl_default_curve(info, 0,
396 0x158 * FB_BACKLIGHT_MAX / MAX_LEVEL,
397 0x534 * FB_BACKLIGHT_MAX / MAX_LEVEL);
398 mutex_unlock(&info->bl_mutex);
399
400 down(&bd->sem);
401 bd->props->brightness = riva_bl_data.max_brightness;
402 bd->props->power = FB_BLANK_UNBLANK;
403 bd->props->update_status(bd);
404 up(&bd->sem);
405
406 #ifdef CONFIG_PMAC_BACKLIGHT
407 mutex_lock(&pmac_backlight_mutex);
408 if (!pmac_backlight)
409 pmac_backlight = bd;
410 mutex_unlock(&pmac_backlight_mutex);
411 #endif
412
413 printk("riva: Backlight initialized (%s)\n", name);
414
415 return;
416
417 error:
418 return;
419 }
420
421 static void riva_bl_exit(struct riva_par *par)
422 {
423 struct fb_info *info = pci_get_drvdata(par->pdev);
424
425 #ifdef CONFIG_PMAC_BACKLIGHT
426 mutex_lock(&pmac_backlight_mutex);
427 #endif
428
429 mutex_lock(&info->bl_mutex);
430 if (info->bl_dev) {
431 #ifdef CONFIG_PMAC_BACKLIGHT
432 if (pmac_backlight == info->bl_dev)
433 pmac_backlight = NULL;
434 #endif
435
436 backlight_device_unregister(info->bl_dev);
437
438 printk("riva: Backlight unloaded\n");
439 }
440 mutex_unlock(&info->bl_mutex);
441
442 #ifdef CONFIG_PMAC_BACKLIGHT
443 mutex_unlock(&pmac_backlight_mutex);
444 #endif
445 }
446 #else
447 static inline void riva_bl_init(struct riva_par *par) {}
448 static inline void riva_bl_exit(struct riva_par *par) {}
449 static inline void riva_bl_set_power(struct fb_info *info, int power) {}
450 #endif /* CONFIG_FB_RIVA_BACKLIGHT */
451
452 /* ------------------------------------------------------------------------- *
453 *
454 * MMIO access macros
455 *
456 * ------------------------------------------------------------------------- */
457
458 static inline void CRTCout(struct riva_par *par, unsigned char index,
459 unsigned char val)
460 {
461 VGA_WR08(par->riva.PCIO, 0x3d4, index);
462 VGA_WR08(par->riva.PCIO, 0x3d5, val);
463 }
464
465 static inline unsigned char CRTCin(struct riva_par *par,
466 unsigned char index)
467 {
468 VGA_WR08(par->riva.PCIO, 0x3d4, index);
469 return (VGA_RD08(par->riva.PCIO, 0x3d5));
470 }
471
472 static inline void GRAout(struct riva_par *par, unsigned char index,
473 unsigned char val)
474 {
475 VGA_WR08(par->riva.PVIO, 0x3ce, index);
476 VGA_WR08(par->riva.PVIO, 0x3cf, val);
477 }
478
479 static inline unsigned char GRAin(struct riva_par *par,
480 unsigned char index)
481 {
482 VGA_WR08(par->riva.PVIO, 0x3ce, index);
483 return (VGA_RD08(par->riva.PVIO, 0x3cf));
484 }
485
486 static inline void SEQout(struct riva_par *par, unsigned char index,
487 unsigned char val)
488 {
489 VGA_WR08(par->riva.PVIO, 0x3c4, index);
490 VGA_WR08(par->riva.PVIO, 0x3c5, val);
491 }
492
493 static inline unsigned char SEQin(struct riva_par *par,
494 unsigned char index)
495 {
496 VGA_WR08(par->riva.PVIO, 0x3c4, index);
497 return (VGA_RD08(par->riva.PVIO, 0x3c5));
498 }
499
500 static inline void ATTRout(struct riva_par *par, unsigned char index,
501 unsigned char val)
502 {
503 VGA_WR08(par->riva.PCIO, 0x3c0, index);
504 VGA_WR08(par->riva.PCIO, 0x3c0, val);
505 }
506
507 static inline unsigned char ATTRin(struct riva_par *par,
508 unsigned char index)
509 {
510 VGA_WR08(par->riva.PCIO, 0x3c0, index);
511 return (VGA_RD08(par->riva.PCIO, 0x3c1));
512 }
513
514 static inline void MISCout(struct riva_par *par, unsigned char val)
515 {
516 VGA_WR08(par->riva.PVIO, 0x3c2, val);
517 }
518
519 static inline unsigned char MISCin(struct riva_par *par)
520 {
521 return (VGA_RD08(par->riva.PVIO, 0x3cc));
522 }
523
524 static u8 byte_rev[256] = {
525 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
526 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
527 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
528 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
529 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
530 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
531 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
532 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
533 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
534 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
535 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
536 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
537 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
538 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
539 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
540 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
541 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
542 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
543 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
544 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
545 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
546 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
547 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
548 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
549 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
550 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
551 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
552 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
553 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
554 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
555 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
556 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
557 };
558
559 static inline void reverse_order(u32 *l)
560 {
561 u8 *a = (u8 *)l;
562 *a = byte_rev[*a], a++;
563 *a = byte_rev[*a], a++;
564 *a = byte_rev[*a], a++;
565 *a = byte_rev[*a];
566 }
567
568 /* ------------------------------------------------------------------------- *
569 *
570 * cursor stuff
571 *
572 * ------------------------------------------------------------------------- */
573
574 /**
575 * rivafb_load_cursor_image - load cursor image to hardware
576 * @data: address to monochrome bitmap (1 = foreground color, 0 = background)
577 * @par: pointer to private data
578 * @w: width of cursor image in pixels
579 * @h: height of cursor image in scanlines
580 * @bg: background color (ARGB1555) - alpha bit determines opacity
581 * @fg: foreground color (ARGB1555)
582 *
583 * DESCRIPTiON:
584 * Loads cursor image based on a monochrome source and mask bitmap. The
585 * image bits determines the color of the pixel, 0 for background, 1 for
586 * foreground. Only the affected region (as determined by @w and @h
587 * parameters) will be updated.
588 *
589 * CALLED FROM:
590 * rivafb_cursor()
591 */
592 static void rivafb_load_cursor_image(struct riva_par *par, u8 *data8,
593 u16 bg, u16 fg, u32 w, u32 h)
594 {
595 int i, j, k = 0;
596 u32 b, tmp;
597 u32 *data = (u32 *)data8;
598 bg = le16_to_cpu(bg);
599 fg = le16_to_cpu(fg);
600
601 w = (w + 1) & ~1;
602
603 for (i = 0; i < h; i++) {
604 b = *data++;
605 reverse_order(&b);
606
607 for (j = 0; j < w/2; j++) {
608 tmp = 0;
609 #if defined (__BIG_ENDIAN)
610 tmp = (b & (1 << 31)) ? fg << 16 : bg << 16;
611 b <<= 1;
612 tmp |= (b & (1 << 31)) ? fg : bg;
613 b <<= 1;
614 #else
615 tmp = (b & 1) ? fg : bg;
616 b >>= 1;
617 tmp |= (b & 1) ? fg << 16 : bg << 16;
618 b >>= 1;
619 #endif
620 writel(tmp, &par->riva.CURSOR[k++]);
621 }
622 k += (MAX_CURS - w)/2;
623 }
624 }
625
626 /* ------------------------------------------------------------------------- *
627 *
628 * general utility functions
629 *
630 * ------------------------------------------------------------------------- */
631
632 /**
633 * riva_wclut - set CLUT entry
634 * @chip: pointer to RIVA_HW_INST object
635 * @regnum: register number
636 * @red: red component
637 * @green: green component
638 * @blue: blue component
639 *
640 * DESCRIPTION:
641 * Sets color register @regnum.
642 *
643 * CALLED FROM:
644 * rivafb_setcolreg()
645 */
646 static void riva_wclut(RIVA_HW_INST *chip,
647 unsigned char regnum, unsigned char red,
648 unsigned char green, unsigned char blue)
649 {
650 VGA_WR08(chip->PDIO, 0x3c8, regnum);
651 VGA_WR08(chip->PDIO, 0x3c9, red);
652 VGA_WR08(chip->PDIO, 0x3c9, green);
653 VGA_WR08(chip->PDIO, 0x3c9, blue);
654 }
655
656 /**
657 * riva_rclut - read fromCLUT register
658 * @chip: pointer to RIVA_HW_INST object
659 * @regnum: register number
660 * @red: red component
661 * @green: green component
662 * @blue: blue component
663 *
664 * DESCRIPTION:
665 * Reads red, green, and blue from color register @regnum.
666 *
667 * CALLED FROM:
668 * rivafb_setcolreg()
669 */
670 static void riva_rclut(RIVA_HW_INST *chip,
671 unsigned char regnum, unsigned char *red,
672 unsigned char *green, unsigned char *blue)
673 {
674
675 VGA_WR08(chip->PDIO, 0x3c7, regnum);
676 *red = VGA_RD08(chip->PDIO, 0x3c9);
677 *green = VGA_RD08(chip->PDIO, 0x3c9);
678 *blue = VGA_RD08(chip->PDIO, 0x3c9);
679 }
680
681 /**
682 * riva_save_state - saves current chip state
683 * @par: pointer to riva_par object containing info for current riva board
684 * @regs: pointer to riva_regs object
685 *
686 * DESCRIPTION:
687 * Saves current chip state to @regs.
688 *
689 * CALLED FROM:
690 * rivafb_probe()
691 */
692 /* from GGI */
693 static void riva_save_state(struct riva_par *par, struct riva_regs *regs)
694 {
695 int i;
696
697 NVTRACE_ENTER();
698 par->riva.LockUnlock(&par->riva, 0);
699
700 par->riva.UnloadStateExt(&par->riva, &regs->ext);
701
702 regs->misc_output = MISCin(par);
703
704 for (i = 0; i < NUM_CRT_REGS; i++)
705 regs->crtc[i] = CRTCin(par, i);
706
707 for (i = 0; i < NUM_ATC_REGS; i++)
708 regs->attr[i] = ATTRin(par, i);
709
710 for (i = 0; i < NUM_GRC_REGS; i++)
711 regs->gra[i] = GRAin(par, i);
712
713 for (i = 0; i < NUM_SEQ_REGS; i++)
714 regs->seq[i] = SEQin(par, i);
715 NVTRACE_LEAVE();
716 }
717
718 /**
719 * riva_load_state - loads current chip state
720 * @par: pointer to riva_par object containing info for current riva board
721 * @regs: pointer to riva_regs object
722 *
723 * DESCRIPTION:
724 * Loads chip state from @regs.
725 *
726 * CALLED FROM:
727 * riva_load_video_mode()
728 * rivafb_probe()
729 * rivafb_remove()
730 */
731 /* from GGI */
732 static void riva_load_state(struct riva_par *par, struct riva_regs *regs)
733 {
734 RIVA_HW_STATE *state = &regs->ext;
735 int i;
736
737 NVTRACE_ENTER();
738 CRTCout(par, 0x11, 0x00);
739
740 par->riva.LockUnlock(&par->riva, 0);
741
742 par->riva.LoadStateExt(&par->riva, state);
743
744 MISCout(par, regs->misc_output);
745
746 for (i = 0; i < NUM_CRT_REGS; i++) {
747 switch (i) {
748 case 0x19:
749 case 0x20 ... 0x40:
750 break;
751 default:
752 CRTCout(par, i, regs->crtc[i]);
753 }
754 }
755
756 for (i = 0; i < NUM_ATC_REGS; i++)
757 ATTRout(par, i, regs->attr[i]);
758
759 for (i = 0; i < NUM_GRC_REGS; i++)
760 GRAout(par, i, regs->gra[i]);
761
762 for (i = 0; i < NUM_SEQ_REGS; i++)
763 SEQout(par, i, regs->seq[i]);
764 NVTRACE_LEAVE();
765 }
766
767 /**
768 * riva_load_video_mode - calculate timings
769 * @info: pointer to fb_info object containing info for current riva board
770 *
771 * DESCRIPTION:
772 * Calculate some timings and then send em off to riva_load_state().
773 *
774 * CALLED FROM:
775 * rivafb_set_par()
776 */
777 static void riva_load_video_mode(struct fb_info *info)
778 {
779 int bpp, width, hDisplaySize, hDisplay, hStart,
780 hEnd, hTotal, height, vDisplay, vStart, vEnd, vTotal, dotClock;
781 int hBlankStart, hBlankEnd, vBlankStart, vBlankEnd;
782 struct riva_par *par = info->par;
783 struct riva_regs newmode;
784
785 NVTRACE_ENTER();
786 /* time to calculate */
787 rivafb_blank(1, info);
788
789 bpp = info->var.bits_per_pixel;
790 if (bpp == 16 && info->var.green.length == 5)
791 bpp = 15;
792 width = info->var.xres_virtual;
793 hDisplaySize = info->var.xres;
794 hDisplay = (hDisplaySize / 8) - 1;
795 hStart = (hDisplaySize + info->var.right_margin) / 8 - 1;
796 hEnd = (hDisplaySize + info->var.right_margin +
797 info->var.hsync_len) / 8 - 1;
798 hTotal = (hDisplaySize + info->var.right_margin +
799 info->var.hsync_len + info->var.left_margin) / 8 - 5;
800 hBlankStart = hDisplay;
801 hBlankEnd = hTotal + 4;
802
803 height = info->var.yres_virtual;
804 vDisplay = info->var.yres - 1;
805 vStart = info->var.yres + info->var.lower_margin - 1;
806 vEnd = info->var.yres + info->var.lower_margin +
807 info->var.vsync_len - 1;
808 vTotal = info->var.yres + info->var.lower_margin +
809 info->var.vsync_len + info->var.upper_margin + 2;
810 vBlankStart = vDisplay;
811 vBlankEnd = vTotal + 1;
812 dotClock = 1000000000 / info->var.pixclock;
813
814 memcpy(&newmode, &reg_template, sizeof(struct riva_regs));
815
816 if ((info->var.vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED)
817 vTotal |= 1;
818
819 if (par->FlatPanel) {
820 vStart = vTotal - 3;
821 vEnd = vTotal - 2;
822 vBlankStart = vStart;
823 hStart = hTotal - 3;
824 hEnd = hTotal - 2;
825 hBlankEnd = hTotal + 4;
826 }
827
828 newmode.crtc[0x0] = Set8Bits (hTotal);
829 newmode.crtc[0x1] = Set8Bits (hDisplay);
830 newmode.crtc[0x2] = Set8Bits (hBlankStart);
831 newmode.crtc[0x3] = SetBitField (hBlankEnd, 4: 0, 4:0) | SetBit (7);
832 newmode.crtc[0x4] = Set8Bits (hStart);
833 newmode.crtc[0x5] = SetBitField (hBlankEnd, 5: 5, 7:7)
834 | SetBitField (hEnd, 4: 0, 4:0);
835 newmode.crtc[0x6] = SetBitField (vTotal, 7: 0, 7:0);
836 newmode.crtc[0x7] = SetBitField (vTotal, 8: 8, 0:0)
837 | SetBitField (vDisplay, 8: 8, 1:1)
838 | SetBitField (vStart, 8: 8, 2:2)
839 | SetBitField (vBlankStart, 8: 8, 3:3)
840 | SetBit (4)
841 | SetBitField (vTotal, 9: 9, 5:5)
842 | SetBitField (vDisplay, 9: 9, 6:6)
843 | SetBitField (vStart, 9: 9, 7:7);
844 newmode.crtc[0x9] = SetBitField (vBlankStart, 9: 9, 5:5)
845 | SetBit (6);
846 newmode.crtc[0x10] = Set8Bits (vStart);
847 newmode.crtc[0x11] = SetBitField (vEnd, 3: 0, 3:0)
848 | SetBit (5);
849 newmode.crtc[0x12] = Set8Bits (vDisplay);
850 newmode.crtc[0x13] = (width / 8) * ((bpp + 1) / 8);
851 newmode.crtc[0x15] = Set8Bits (vBlankStart);
852 newmode.crtc[0x16] = Set8Bits (vBlankEnd);
853
854 newmode.ext.screen = SetBitField(hBlankEnd,6:6,4:4)
855 | SetBitField(vBlankStart,10:10,3:3)
856 | SetBitField(vStart,10:10,2:2)
857 | SetBitField(vDisplay,10:10,1:1)
858 | SetBitField(vTotal,10:10,0:0);
859 newmode.ext.horiz = SetBitField(hTotal,8:8,0:0)
860 | SetBitField(hDisplay,8:8,1:1)
861 | SetBitField(hBlankStart,8:8,2:2)
862 | SetBitField(hStart,8:8,3:3);
863 newmode.ext.extra = SetBitField(vTotal,11:11,0:0)
864 | SetBitField(vDisplay,11:11,2:2)
865 | SetBitField(vStart,11:11,4:4)
866 | SetBitField(vBlankStart,11:11,6:6);
867
868 if ((info->var.vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
869 int tmp = (hTotal >> 1) & ~1;
870 newmode.ext.interlace = Set8Bits(tmp);
871 newmode.ext.horiz |= SetBitField(tmp, 8:8,4:4);
872 } else
873 newmode.ext.interlace = 0xff; /* interlace off */
874
875 if (par->riva.Architecture >= NV_ARCH_10)
876 par->riva.CURSOR = (U032 __iomem *)(info->screen_base + par->riva.CursorStart);
877
878 if (info->var.sync & FB_SYNC_HOR_HIGH_ACT)
879 newmode.misc_output &= ~0x40;
880 else
881 newmode.misc_output |= 0x40;
882 if (info->var.sync & FB_SYNC_VERT_HIGH_ACT)
883 newmode.misc_output &= ~0x80;
884 else
885 newmode.misc_output |= 0x80;
886
887 par->riva.CalcStateExt(&par->riva, &newmode.ext, bpp, width,
888 hDisplaySize, height, dotClock);
889
890 newmode.ext.scale = NV_RD32(par->riva.PRAMDAC, 0x00000848) &
891 0xfff000ff;
892 if (par->FlatPanel == 1) {
893 newmode.ext.pixel |= (1 << 7);
894 newmode.ext.scale |= (1 << 8);
895 }
896 if (par->SecondCRTC) {
897 newmode.ext.head = NV_RD32(par->riva.PCRTC0, 0x00000860) &
898 ~0x00001000;
899 newmode.ext.head2 = NV_RD32(par->riva.PCRTC0, 0x00002860) |
900 0x00001000;
901 newmode.ext.crtcOwner = 3;
902 newmode.ext.pllsel |= 0x20000800;
903 newmode.ext.vpll2 = newmode.ext.vpll;
904 } else if (par->riva.twoHeads) {
905 newmode.ext.head = NV_RD32(par->riva.PCRTC0, 0x00000860) |
906 0x00001000;
907 newmode.ext.head2 = NV_RD32(par->riva.PCRTC0, 0x00002860) &
908 ~0x00001000;
909 newmode.ext.crtcOwner = 0;
910 newmode.ext.vpll2 = NV_RD32(par->riva.PRAMDAC0, 0x00000520);
911 }
912 if (par->FlatPanel == 1) {
913 newmode.ext.pixel |= (1 << 7);
914 newmode.ext.scale |= (1 << 8);
915 }
916 newmode.ext.cursorConfig = 0x02000100;
917 par->current_state = newmode;
918 riva_load_state(par, &par->current_state);
919 par->riva.LockUnlock(&par->riva, 0); /* important for HW cursor */
920 rivafb_blank(0, info);
921 NVTRACE_LEAVE();
922 }
923
924 static void riva_update_var(struct fb_var_screeninfo *var, struct fb_videomode *modedb)
925 {
926 NVTRACE_ENTER();
927 var->xres = var->xres_virtual = modedb->xres;
928 var->yres = modedb->yres;
929 if (var->yres_virtual < var->yres)
930 var->yres_virtual = var->yres;
931 var->xoffset = var->yoffset = 0;
932 var->pixclock = modedb->pixclock;
933 var->left_margin = modedb->left_margin;
934 var->right_margin = modedb->right_margin;
935 var->upper_margin = modedb->upper_margin;
936 var->lower_margin = modedb->lower_margin;
937 var->hsync_len = modedb->hsync_len;
938 var->vsync_len = modedb->vsync_len;
939 var->sync = modedb->sync;
940 var->vmode = modedb->vmode;
941 NVTRACE_LEAVE();
942 }
943
944 /**
945 * rivafb_do_maximize -
946 * @info: pointer to fb_info object containing info for current riva board
947 * @var:
948 * @nom:
949 * @den:
950 *
951 * DESCRIPTION:
952 * .
953 *
954 * RETURNS:
955 * -EINVAL on failure, 0 on success
956 *
957 *
958 * CALLED FROM:
959 * rivafb_check_var()
960 */
961 static int rivafb_do_maximize(struct fb_info *info,
962 struct fb_var_screeninfo *var,
963 int nom, int den)
964 {
965 static struct {
966 int xres, yres;
967 } modes[] = {
968 {1600, 1280},
969 {1280, 1024},
970 {1024, 768},
971 {800, 600},
972 {640, 480},
973 {-1, -1}
974 };
975 int i;
976
977 NVTRACE_ENTER();
978 /* use highest possible virtual resolution */
979 if (var->xres_virtual == -1 && var->yres_virtual == -1) {
980 printk(KERN_WARNING PFX
981 "using maximum available virtual resolution\n");
982 for (i = 0; modes[i].xres != -1; i++) {
983 if (modes[i].xres * nom / den * modes[i].yres <
984 info->fix.smem_len)
985 break;
986 }
987 if (modes[i].xres == -1) {
988 printk(KERN_ERR PFX
989 "could not find a virtual resolution that fits into video memory!!\n");
990 NVTRACE("EXIT - EINVAL error\n");
991 return -EINVAL;
992 }
993 var->xres_virtual = modes[i].xres;
994 var->yres_virtual = modes[i].yres;
995
996 printk(KERN_INFO PFX
997 "virtual resolution set to maximum of %dx%d\n",
998 var->xres_virtual, var->yres_virtual);
999 } else if (var->xres_virtual == -1) {
1000 var->xres_virtual = (info->fix.smem_len * den /
1001 (nom * var->yres_virtual)) & ~15;
1002 printk(KERN_WARNING PFX
1003 "setting virtual X resolution to %d\n", var->xres_virtual);
1004 } else if (var->yres_virtual == -1) {
1005 var->xres_virtual = (var->xres_virtual + 15) & ~15;
1006 var->yres_virtual = info->fix.smem_len * den /
1007 (nom * var->xres_virtual);
1008 printk(KERN_WARNING PFX
1009 "setting virtual Y resolution to %d\n", var->yres_virtual);
1010 } else {
1011 var->xres_virtual = (var->xres_virtual + 15) & ~15;
1012 if (var->xres_virtual * nom / den * var->yres_virtual > info->fix.smem_len) {
1013 printk(KERN_ERR PFX
1014 "mode %dx%dx%d rejected...resolution too high to fit into video memory!\n",
1015 var->xres, var->yres, var->bits_per_pixel);
1016 NVTRACE("EXIT - EINVAL error\n");
1017 return -EINVAL;
1018 }
1019 }
1020
1021 if (var->xres_virtual * nom / den >= 8192) {
1022 printk(KERN_WARNING PFX
1023 "virtual X resolution (%d) is too high, lowering to %d\n",
1024 var->xres_virtual, 8192 * den / nom - 16);
1025 var->xres_virtual = 8192 * den / nom - 16;
1026 }
1027
1028 if (var->xres_virtual < var->xres) {
1029 printk(KERN_ERR PFX
1030 "virtual X resolution (%d) is smaller than real\n", var->xres_virtual);
1031 return -EINVAL;
1032 }
1033
1034 if (var->yres_virtual < var->yres) {
1035 printk(KERN_ERR PFX
1036 "virtual Y resolution (%d) is smaller than real\n", var->yres_virtual);
1037 return -EINVAL;
1038 }
1039 if (var->yres_virtual > 0x7fff/nom)
1040 var->yres_virtual = 0x7fff/nom;
1041 if (var->xres_virtual > 0x7fff/nom)
1042 var->xres_virtual = 0x7fff/nom;
1043 NVTRACE_LEAVE();
1044 return 0;
1045 }
1046
1047 static void
1048 riva_set_pattern(struct riva_par *par, int clr0, int clr1, int pat0, int pat1)
1049 {
1050 RIVA_FIFO_FREE(par->riva, Patt, 4);
1051 NV_WR32(&par->riva.Patt->Color0, 0, clr0);
1052 NV_WR32(&par->riva.Patt->Color1, 0, clr1);
1053 NV_WR32(par->riva.Patt->Monochrome, 0, pat0);
1054 NV_WR32(par->riva.Patt->Monochrome, 4, pat1);
1055 }
1056
1057 /* acceleration routines */
1058 static inline void wait_for_idle(struct riva_par *par)
1059 {
1060 while (par->riva.Busy(&par->riva));
1061 }
1062
1063 /*
1064 * Set ROP. Translate X rop into ROP3. Internal routine.
1065 */
1066 static void
1067 riva_set_rop_solid(struct riva_par *par, int rop)
1068 {
1069 riva_set_pattern(par, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
1070 RIVA_FIFO_FREE(par->riva, Rop, 1);
1071 NV_WR32(&par->riva.Rop->Rop3, 0, rop);
1072
1073 }
1074
1075 static void riva_setup_accel(struct fb_info *info)
1076 {
1077 struct riva_par *par = info->par;
1078
1079 RIVA_FIFO_FREE(par->riva, Clip, 2);
1080 NV_WR32(&par->riva.Clip->TopLeft, 0, 0x0);
1081 NV_WR32(&par->riva.Clip->WidthHeight, 0,
1082 (info->var.xres_virtual & 0xffff) |
1083 (info->var.yres_virtual << 16));
1084 riva_set_rop_solid(par, 0xcc);
1085 wait_for_idle(par);
1086 }
1087
1088 /**
1089 * riva_get_cmap_len - query current color map length
1090 * @var: standard kernel fb changeable data
1091 *
1092 * DESCRIPTION:
1093 * Get current color map length.
1094 *
1095 * RETURNS:
1096 * Length of color map
1097 *
1098 * CALLED FROM:
1099 * rivafb_setcolreg()
1100 */
1101 static int riva_get_cmap_len(const struct fb_var_screeninfo *var)
1102 {
1103 int rc = 256; /* reasonable default */
1104
1105 switch (var->green.length) {
1106 case 8:
1107 rc = 256; /* 256 entries (2^8), 8 bpp and RGB8888 */
1108 break;
1109 case 5:
1110 rc = 32; /* 32 entries (2^5), 16 bpp, RGB555 */
1111 break;
1112 case 6:
1113 rc = 64; /* 64 entries (2^6), 16 bpp, RGB565 */
1114 break;
1115 default:
1116 /* should not occur */
1117 break;
1118 }
1119 return rc;
1120 }
1121
1122 /* ------------------------------------------------------------------------- *
1123 *
1124 * framebuffer operations
1125 *
1126 * ------------------------------------------------------------------------- */
1127
1128 static int rivafb_open(struct fb_info *info, int user)
1129 {
1130 struct riva_par *par = info->par;
1131 int cnt = atomic_read(&par->ref_count);
1132
1133 NVTRACE_ENTER();
1134 if (!cnt) {
1135 #ifdef CONFIG_X86
1136 memset(&par->state, 0, sizeof(struct vgastate));
1137 par->state.flags = VGA_SAVE_MODE | VGA_SAVE_FONTS;
1138 /* save the DAC for Riva128 */
1139 if (par->riva.Architecture == NV_ARCH_03)
1140 par->state.flags |= VGA_SAVE_CMAP;
1141 save_vga(&par->state);
1142 #endif
1143 /* vgaHWunlock() + riva unlock (0x7F) */
1144 CRTCout(par, 0x11, 0xFF);
1145 par->riva.LockUnlock(&par->riva, 0);
1146
1147 riva_save_state(par, &par->initial_state);
1148 }
1149 atomic_inc(&par->ref_count);
1150 NVTRACE_LEAVE();
1151 return 0;
1152 }
1153
1154 static int rivafb_release(struct fb_info *info, int user)
1155 {
1156 struct riva_par *par = info->par;
1157 int cnt = atomic_read(&par->ref_count);
1158
1159 NVTRACE_ENTER();
1160 if (!cnt)
1161 return -EINVAL;
1162 if (cnt == 1) {
1163 par->riva.LockUnlock(&par->riva, 0);
1164 par->riva.LoadStateExt(&par->riva, &par->initial_state.ext);
1165 riva_load_state(par, &par->initial_state);
1166 #ifdef CONFIG_X86
1167 restore_vga(&par->state);
1168 #endif
1169 par->riva.LockUnlock(&par->riva, 1);
1170 }
1171 atomic_dec(&par->ref_count);
1172 NVTRACE_LEAVE();
1173 return 0;
1174 }
1175
1176 static int rivafb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
1177 {
1178 struct fb_videomode *mode;
1179 struct riva_par *par = info->par;
1180 int nom, den; /* translating from pixels->bytes */
1181 int mode_valid = 0;
1182
1183 NVTRACE_ENTER();
1184 switch (var->bits_per_pixel) {
1185 case 1 ... 8:
1186 var->red.offset = var->green.offset = var->blue.offset = 0;
1187 var->red.length = var->green.length = var->blue.length = 8;
1188 var->bits_per_pixel = 8;
1189 nom = den = 1;
1190 break;
1191 case 9 ... 15:
1192 var->green.length = 5;
1193 /* fall through */
1194 case 16:
1195 var->bits_per_pixel = 16;
1196 /* The Riva128 supports RGB555 only */
1197 if (par->riva.Architecture == NV_ARCH_03)
1198 var->green.length = 5;
1199 if (var->green.length == 5) {
1200 /* 0rrrrrgg gggbbbbb */
1201 var->red.offset = 10;
1202 var->green.offset = 5;
1203 var->blue.offset = 0;
1204 var->red.length = 5;
1205 var->green.length = 5;
1206 var->blue.length = 5;
1207 } else {
1208 /* rrrrrggg gggbbbbb */
1209 var->red.offset = 11;
1210 var->green.offset = 5;
1211 var->blue.offset = 0;
1212 var->red.length = 5;
1213 var->green.length = 6;
1214 var->blue.length = 5;
1215 }
1216 nom = 2;
1217 den = 1;
1218 break;
1219 case 17 ... 32:
1220 var->red.length = var->green.length = var->blue.length = 8;
1221 var->bits_per_pixel = 32;
1222 var->red.offset = 16;
1223 var->green.offset = 8;
1224 var->blue.offset = 0;
1225 nom = 4;
1226 den = 1;
1227 break;
1228 default:
1229 printk(KERN_ERR PFX
1230 "mode %dx%dx%d rejected...color depth not supported.\n",
1231 var->xres, var->yres, var->bits_per_pixel);
1232 NVTRACE("EXIT, returning -EINVAL\n");
1233 return -EINVAL;
1234 }
1235
1236 if (!strictmode) {
1237 if (!info->monspecs.vfmax || !info->monspecs.hfmax ||
1238 !info->monspecs.dclkmax || !fb_validate_mode(var, info))
1239 mode_valid = 1;
1240 }
1241
1242 /* calculate modeline if supported by monitor */
1243 if (!mode_valid && info->monspecs.gtf) {
1244 if (!fb_get_mode(FB_MAXTIMINGS, 0, var, info))
1245 mode_valid = 1;
1246 }
1247
1248 if (!mode_valid) {
1249 mode = fb_find_best_mode(var, &info->modelist);
1250 if (mode) {
1251 riva_update_var(var, mode);
1252 mode_valid = 1;
1253 }
1254 }
1255
1256 if (!mode_valid && info->monspecs.modedb_len)
1257 return -EINVAL;
1258
1259 if (var->xres_virtual < var->xres)
1260 var->xres_virtual = var->xres;
1261 if (var->yres_virtual <= var->yres)
1262 var->yres_virtual = -1;
1263 if (rivafb_do_maximize(info, var, nom, den) < 0)
1264 return -EINVAL;
1265
1266 if (var->xoffset < 0)
1267 var->xoffset = 0;
1268 if (var->yoffset < 0)
1269 var->yoffset = 0;
1270
1271 /* truncate xoffset and yoffset to maximum if too high */
1272 if (var->xoffset > var->xres_virtual - var->xres)
1273 var->xoffset = var->xres_virtual - var->xres - 1;
1274
1275 if (var->yoffset > var->yres_virtual - var->yres)
1276 var->yoffset = var->yres_virtual - var->yres - 1;
1277
1278 var->red.msb_right =
1279 var->green.msb_right =
1280 var->blue.msb_right =
1281 var->transp.offset = var->transp.length = var->transp.msb_right = 0;
1282 NVTRACE_LEAVE();
1283 return 0;
1284 }
1285
1286 static int rivafb_set_par(struct fb_info *info)
1287 {
1288 struct riva_par *par = info->par;
1289
1290 NVTRACE_ENTER();
1291 /* vgaHWunlock() + riva unlock (0x7F) */
1292 CRTCout(par, 0x11, 0xFF);
1293 par->riva.LockUnlock(&par->riva, 0);
1294 riva_load_video_mode(info);
1295 if(!(info->flags & FBINFO_HWACCEL_DISABLED))
1296 riva_setup_accel(info);
1297
1298 par->cursor_reset = 1;
1299 info->fix.line_length = (info->var.xres_virtual * (info->var.bits_per_pixel >> 3));
1300 info->fix.visual = (info->var.bits_per_pixel == 8) ?
1301 FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_DIRECTCOLOR;
1302
1303 if (info->flags & FBINFO_HWACCEL_DISABLED)
1304 info->pixmap.scan_align = 1;
1305 else
1306 info->pixmap.scan_align = 4;
1307 NVTRACE_LEAVE();
1308 return 0;
1309 }
1310
1311 /**
1312 * rivafb_pan_display
1313 * @var: standard kernel fb changeable data
1314 * @con: TODO
1315 * @info: pointer to fb_info object containing info for current riva board
1316 *
1317 * DESCRIPTION:
1318 * Pan (or wrap, depending on the `vmode' field) the display using the
1319 * `xoffset' and `yoffset' fields of the `var' structure.
1320 * If the values don't fit, return -EINVAL.
1321 *
1322 * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
1323 */
1324 static int rivafb_pan_display(struct fb_var_screeninfo *var,
1325 struct fb_info *info)
1326 {
1327 struct riva_par *par = info->par;
1328 unsigned int base;
1329
1330 NVTRACE_ENTER();
1331 base = var->yoffset * info->fix.line_length + var->xoffset;
1332 par->riva.SetStartAddress(&par->riva, base);
1333 NVTRACE_LEAVE();
1334 return 0;
1335 }
1336
1337 static int rivafb_blank(int blank, struct fb_info *info)
1338 {
1339 struct riva_par *par= info->par;
1340 unsigned char tmp, vesa;
1341
1342 tmp = SEQin(par, 0x01) & ~0x20; /* screen on/off */
1343 vesa = CRTCin(par, 0x1a) & ~0xc0; /* sync on/off */
1344
1345 NVTRACE_ENTER();
1346
1347 if (blank)
1348 tmp |= 0x20;
1349
1350 switch (blank) {
1351 case FB_BLANK_UNBLANK:
1352 case FB_BLANK_NORMAL:
1353 break;
1354 case FB_BLANK_VSYNC_SUSPEND:
1355 vesa |= 0x80;
1356 break;
1357 case FB_BLANK_HSYNC_SUSPEND:
1358 vesa |= 0x40;
1359 break;
1360 case FB_BLANK_POWERDOWN:
1361 vesa |= 0xc0;
1362 break;
1363 }
1364
1365 SEQout(par, 0x01, tmp);
1366 CRTCout(par, 0x1a, vesa);
1367
1368 riva_bl_set_power(info, blank);
1369
1370 NVTRACE_LEAVE();
1371
1372 return 0;
1373 }
1374
1375 /**
1376 * rivafb_setcolreg
1377 * @regno: register index
1378 * @red: red component
1379 * @green: green component
1380 * @blue: blue component
1381 * @transp: transparency
1382 * @info: pointer to fb_info object containing info for current riva board
1383 *
1384 * DESCRIPTION:
1385 * Set a single color register. The values supplied have a 16 bit
1386 * magnitude.
1387 *
1388 * RETURNS:
1389 * Return != 0 for invalid regno.
1390 *
1391 * CALLED FROM:
1392 * fbcmap.c:fb_set_cmap()
1393 */
1394 static int rivafb_setcolreg(unsigned regno, unsigned red, unsigned green,
1395 unsigned blue, unsigned transp,
1396 struct fb_info *info)
1397 {
1398 struct riva_par *par = info->par;
1399 RIVA_HW_INST *chip = &par->riva;
1400 int i;
1401
1402 if (regno >= riva_get_cmap_len(&info->var))
1403 return -EINVAL;
1404
1405 if (info->var.grayscale) {
1406 /* gray = 0.30*R + 0.59*G + 0.11*B */
1407 red = green = blue =
1408 (red * 77 + green * 151 + blue * 28) >> 8;
1409 }
1410
1411 if (regno < 16 && info->fix.visual == FB_VISUAL_DIRECTCOLOR) {
1412 ((u32 *) info->pseudo_palette)[regno] =
1413 (regno << info->var.red.offset) |
1414 (regno << info->var.green.offset) |
1415 (regno << info->var.blue.offset);
1416 /*
1417 * The Riva128 2D engine requires color information in
1418 * TrueColor format even if framebuffer is in DirectColor
1419 */
1420 if (par->riva.Architecture == NV_ARCH_03) {
1421 switch (info->var.bits_per_pixel) {
1422 case 16:
1423 par->palette[regno] = ((red & 0xf800) >> 1) |
1424 ((green & 0xf800) >> 6) |
1425 ((blue & 0xf800) >> 11);
1426 break;
1427 case 32:
1428 par->palette[regno] = ((red & 0xff00) << 8) |
1429 ((green & 0xff00)) |
1430 ((blue & 0xff00) >> 8);
1431 break;
1432 }
1433 }
1434 }
1435
1436 switch (info->var.bits_per_pixel) {
1437 case 8:
1438 /* "transparent" stuff is completely ignored. */
1439 riva_wclut(chip, regno, red >> 8, green >> 8, blue >> 8);
1440 break;
1441 case 16:
1442 if (info->var.green.length == 5) {
1443 for (i = 0; i < 8; i++) {
1444 riva_wclut(chip, regno*8+i, red >> 8,
1445 green >> 8, blue >> 8);
1446 }
1447 } else {
1448 u8 r, g, b;
1449
1450 if (regno < 32) {
1451 for (i = 0; i < 8; i++) {
1452 riva_wclut(chip, regno*8+i,
1453 red >> 8, green >> 8,
1454 blue >> 8);
1455 }
1456 }
1457 riva_rclut(chip, regno*4, &r, &g, &b);
1458 for (i = 0; i < 4; i++)
1459 riva_wclut(chip, regno*4+i, r,
1460 green >> 8, b);
1461 }
1462 break;
1463 case 32:
1464 riva_wclut(chip, regno, red >> 8, green >> 8, blue >> 8);
1465 break;
1466 default:
1467 /* do nothing */
1468 break;
1469 }
1470 return 0;
1471 }
1472
1473 /**
1474 * rivafb_fillrect - hardware accelerated color fill function
1475 * @info: pointer to fb_info structure
1476 * @rect: pointer to fb_fillrect structure
1477 *
1478 * DESCRIPTION:
1479 * This function fills up a region of framebuffer memory with a solid
1480 * color with a choice of two different ROP's, copy or invert.
1481 *
1482 * CALLED FROM:
1483 * framebuffer hook
1484 */
1485 static void rivafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
1486 {
1487 struct riva_par *par = info->par;
1488 u_int color, rop = 0;
1489
1490 if ((info->flags & FBINFO_HWACCEL_DISABLED)) {
1491 cfb_fillrect(info, rect);
1492 return;
1493 }
1494
1495 if (info->var.bits_per_pixel == 8)
1496 color = rect->color;
1497 else {
1498 if (par->riva.Architecture != NV_ARCH_03)
1499 color = ((u32 *)info->pseudo_palette)[rect->color];
1500 else
1501 color = par->palette[rect->color];
1502 }
1503
1504 switch (rect->rop) {
1505 case ROP_XOR:
1506 rop = 0x66;
1507 break;
1508 case ROP_COPY:
1509 default:
1510 rop = 0xCC;
1511 break;
1512 }
1513
1514 riva_set_rop_solid(par, rop);
1515
1516 RIVA_FIFO_FREE(par->riva, Bitmap, 1);
1517 NV_WR32(&par->riva.Bitmap->Color1A, 0, color);
1518
1519 RIVA_FIFO_FREE(par->riva, Bitmap, 2);
1520 NV_WR32(&par->riva.Bitmap->UnclippedRectangle[0].TopLeft, 0,
1521 (rect->dx << 16) | rect->dy);
1522 mb();
1523 NV_WR32(&par->riva.Bitmap->UnclippedRectangle[0].WidthHeight, 0,
1524 (rect->width << 16) | rect->height);
1525 mb();
1526 riva_set_rop_solid(par, 0xcc);
1527
1528 }
1529
1530 /**
1531 * rivafb_copyarea - hardware accelerated blit function
1532 * @info: pointer to fb_info structure
1533 * @region: pointer to fb_copyarea structure
1534 *
1535 * DESCRIPTION:
1536 * This copies an area of pixels from one location to another
1537 *
1538 * CALLED FROM:
1539 * framebuffer hook
1540 */
1541 static void rivafb_copyarea(struct fb_info *info, const struct fb_copyarea *region)
1542 {
1543 struct riva_par *par = info->par;
1544
1545 if ((info->flags & FBINFO_HWACCEL_DISABLED)) {
1546 cfb_copyarea(info, region);
1547 return;
1548 }
1549
1550 RIVA_FIFO_FREE(par->riva, Blt, 3);
1551 NV_WR32(&par->riva.Blt->TopLeftSrc, 0,
1552 (region->sy << 16) | region->sx);
1553 NV_WR32(&par->riva.Blt->TopLeftDst, 0,
1554 (region->dy << 16) | region->dx);
1555 mb();
1556 NV_WR32(&par->riva.Blt->WidthHeight, 0,
1557 (region->height << 16) | region->width);
1558 mb();
1559 }
1560
1561 static inline void convert_bgcolor_16(u32 *col)
1562 {
1563 *col = ((*col & 0x0000F800) << 8)
1564 | ((*col & 0x00007E0) << 5)
1565 | ((*col & 0x0000001F) << 3)
1566 | 0xFF000000;
1567 mb();
1568 }
1569
1570 /**
1571 * rivafb_imageblit: hardware accelerated color expand function
1572 * @info: pointer to fb_info structure
1573 * @image: pointer to fb_image structure
1574 *
1575 * DESCRIPTION:
1576 * If the source is a monochrome bitmap, the function fills up a a region
1577 * of framebuffer memory with pixels whose color is determined by the bit
1578 * setting of the bitmap, 1 - foreground, 0 - background.
1579 *
1580 * If the source is not a monochrome bitmap, color expansion is not done.
1581 * In this case, it is channeled to a software function.
1582 *
1583 * CALLED FROM:
1584 * framebuffer hook
1585 */
1586 static void rivafb_imageblit(struct fb_info *info,
1587 const struct fb_image *image)
1588 {
1589 struct riva_par *par = info->par;
1590 u32 fgx = 0, bgx = 0, width, tmp;
1591 u8 *cdat = (u8 *) image->data;
1592 volatile u32 __iomem *d;
1593 int i, size;
1594
1595 if ((info->flags & FBINFO_HWACCEL_DISABLED) || image->depth != 1) {
1596 cfb_imageblit(info, image);
1597 return;
1598 }
1599
1600 switch (info->var.bits_per_pixel) {
1601 case 8:
1602 fgx = image->fg_color;
1603 bgx = image->bg_color;
1604 break;
1605 case 16:
1606 case 32:
1607 if (par->riva.Architecture != NV_ARCH_03) {
1608 fgx = ((u32 *)info->pseudo_palette)[image->fg_color];
1609 bgx = ((u32 *)info->pseudo_palette)[image->bg_color];
1610 } else {
1611 fgx = par->palette[image->fg_color];
1612 bgx = par->palette[image->bg_color];
1613 }
1614 if (info->var.green.length == 6)
1615 convert_bgcolor_16(&bgx);
1616 break;
1617 }
1618
1619 RIVA_FIFO_FREE(par->riva, Bitmap, 7);
1620 NV_WR32(&par->riva.Bitmap->ClipE.TopLeft, 0,
1621 (image->dy << 16) | (image->dx & 0xFFFF));
1622 NV_WR32(&par->riva.Bitmap->ClipE.BottomRight, 0,
1623 (((image->dy + image->height) << 16) |
1624 ((image->dx + image->width) & 0xffff)));
1625 NV_WR32(&par->riva.Bitmap->Color0E, 0, bgx);
1626 NV_WR32(&par->riva.Bitmap->Color1E, 0, fgx);
1627 NV_WR32(&par->riva.Bitmap->WidthHeightInE, 0,
1628 (image->height << 16) | ((image->width + 31) & ~31));
1629 NV_WR32(&par->riva.Bitmap->WidthHeightOutE, 0,
1630 (image->height << 16) | ((image->width + 31) & ~31));
1631 NV_WR32(&par->riva.Bitmap->PointE, 0,
1632 (image->dy << 16) | (image->dx & 0xFFFF));
1633
1634 d = &par->riva.Bitmap->MonochromeData01E;
1635
1636 width = (image->width + 31)/32;
1637 size = width * image->height;
1638 while (size >= 16) {
1639 RIVA_FIFO_FREE(par->riva, Bitmap, 16);
1640 for (i = 0; i < 16; i++) {
1641 tmp = *((u32 *)cdat);
1642 cdat = (u8 *)((u32 *)cdat + 1);
1643 reverse_order(&tmp);
1644 NV_WR32(d, i*4, tmp);
1645 }
1646 size -= 16;
1647 }
1648 if (size) {
1649 RIVA_FIFO_FREE(par->riva, Bitmap, size);
1650 for (i = 0; i < size; i++) {
1651 tmp = *((u32 *) cdat);
1652 cdat = (u8 *)((u32 *)cdat + 1);
1653 reverse_order(&tmp);
1654 NV_WR32(d, i*4, tmp);
1655 }
1656 }
1657 }
1658
1659 /**
1660 * rivafb_cursor - hardware cursor function
1661 * @info: pointer to info structure
1662 * @cursor: pointer to fbcursor structure
1663 *
1664 * DESCRIPTION:
1665 * A cursor function that supports displaying a cursor image via hardware.
1666 * Within the kernel, copy and invert rops are supported. If exported
1667 * to user space, only the copy rop will be supported.
1668 *
1669 * CALLED FROM
1670 * framebuffer hook
1671 */
1672 static int rivafb_cursor(struct fb_info *info, struct fb_cursor *cursor)
1673 {
1674 struct riva_par *par = info->par;
1675 u8 data[MAX_CURS * MAX_CURS/8];
1676 int i, set = cursor->set;
1677 u16 fg, bg;
1678
1679 if (cursor->image.width > MAX_CURS || cursor->image.height > MAX_CURS)
1680 return -ENXIO;
1681
1682 par->riva.ShowHideCursor(&par->riva, 0);
1683
1684 if (par->cursor_reset) {
1685 set = FB_CUR_SETALL;
1686 par->cursor_reset = 0;
1687 }
1688
1689 if (set & FB_CUR_SETSIZE)
1690 memset_io(par->riva.CURSOR, 0, MAX_CURS * MAX_CURS * 2);
1691
1692 if (set & FB_CUR_SETPOS) {
1693 u32 xx, yy, temp;
1694
1695 yy = cursor->image.dy - info->var.yoffset;
1696 xx = cursor->image.dx - info->var.xoffset;
1697 temp = xx & 0xFFFF;
1698 temp |= yy << 16;
1699
1700 NV_WR32(par->riva.PRAMDAC, 0x0000300, temp);
1701 }
1702
1703
1704 if (set & (FB_CUR_SETSHAPE | FB_CUR_SETCMAP | FB_CUR_SETIMAGE)) {
1705 u32 bg_idx = cursor->image.bg_color;
1706 u32 fg_idx = cursor->image.fg_color;
1707 u32 s_pitch = (cursor->image.width+7) >> 3;
1708 u32 d_pitch = MAX_CURS/8;
1709 u8 *dat = (u8 *) cursor->image.data;
1710 u8 *msk = (u8 *) cursor->mask;
1711 u8 *src;
1712
1713 src = kmalloc(s_pitch * cursor->image.height, GFP_ATOMIC);
1714
1715 if (src) {
1716 switch (cursor->rop) {
1717 case ROP_XOR:
1718 for (i = 0; i < s_pitch * cursor->image.height; i++)
1719 src[i] = dat[i] ^ msk[i];
1720 break;
1721 case ROP_COPY:
1722 default:
1723 for (i = 0; i < s_pitch * cursor->image.height; i++)
1724 src[i] = dat[i] & msk[i];
1725 break;
1726 }
1727
1728 fb_pad_aligned_buffer(data, d_pitch, src, s_pitch,
1729 cursor->image.height);
1730
1731 bg = ((info->cmap.red[bg_idx] & 0xf8) << 7) |
1732 ((info->cmap.green[bg_idx] & 0xf8) << 2) |
1733 ((info->cmap.blue[bg_idx] & 0xf8) >> 3) |
1734 1 << 15;
1735
1736 fg = ((info->cmap.red[fg_idx] & 0xf8) << 7) |
1737 ((info->cmap.green[fg_idx] & 0xf8) << 2) |
1738 ((info->cmap.blue[fg_idx] & 0xf8) >> 3) |
1739 1 << 15;
1740
1741 par->riva.LockUnlock(&par->riva, 0);
1742
1743 rivafb_load_cursor_image(par, data, bg, fg,
1744 cursor->image.width,
1745 cursor->image.height);
1746 kfree(src);
1747 }
1748 }
1749
1750 if (cursor->enable)
1751 par->riva.ShowHideCursor(&par->riva, 1);
1752
1753 return 0;
1754 }
1755
1756 static int rivafb_sync(struct fb_info *info)
1757 {
1758 struct riva_par *par = info->par;
1759
1760 wait_for_idle(par);
1761 return 0;
1762 }
1763
1764 /* ------------------------------------------------------------------------- *
1765 *
1766 * initialization helper functions
1767 *
1768 * ------------------------------------------------------------------------- */
1769
1770 /* kernel interface */
1771 static struct fb_ops riva_fb_ops = {
1772 .owner = THIS_MODULE,
1773 .fb_open = rivafb_open,
1774 .fb_release = rivafb_release,
1775 .fb_check_var = rivafb_check_var,
1776 .fb_set_par = rivafb_set_par,
1777 .fb_setcolreg = rivafb_setcolreg,
1778 .fb_pan_display = rivafb_pan_display,
1779 .fb_blank = rivafb_blank,
1780 .fb_fillrect = rivafb_fillrect,
1781 .fb_copyarea = rivafb_copyarea,
1782 .fb_imageblit = rivafb_imageblit,
1783 .fb_cursor = rivafb_cursor,
1784 .fb_sync = rivafb_sync,
1785 };
1786
1787 static int __devinit riva_set_fbinfo(struct fb_info *info)
1788 {
1789 unsigned int cmap_len;
1790 struct riva_par *par = info->par;
1791
1792 NVTRACE_ENTER();
1793 info->flags = FBINFO_DEFAULT
1794 | FBINFO_HWACCEL_XPAN
1795 | FBINFO_HWACCEL_YPAN
1796 | FBINFO_HWACCEL_COPYAREA
1797 | FBINFO_HWACCEL_FILLRECT
1798 | FBINFO_HWACCEL_IMAGEBLIT;
1799
1800 /* Accel seems to not work properly on NV30 yet...*/
1801 if ((par->riva.Architecture == NV_ARCH_30) || noaccel) {
1802 printk(KERN_DEBUG PFX "disabling acceleration\n");
1803 info->flags |= FBINFO_HWACCEL_DISABLED;
1804 }
1805
1806 info->var = rivafb_default_var;
1807 info->fix.visual = (info->var.bits_per_pixel == 8) ?
1808 FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_DIRECTCOLOR;
1809
1810 info->pseudo_palette = par->pseudo_palette;
1811
1812 cmap_len = riva_get_cmap_len(&info->var);
1813 fb_alloc_cmap(&info->cmap, cmap_len, 0);
1814
1815 info->pixmap.size = 8 * 1024;
1816 info->pixmap.buf_align = 4;
1817 info->pixmap.access_align = 32;
1818 info->pixmap.flags = FB_PIXMAP_SYSTEM;
1819 info->var.yres_virtual = -1;
1820 NVTRACE_LEAVE();
1821 return (rivafb_check_var(&info->var, info));
1822 }
1823
1824 #ifdef CONFIG_PPC_OF
1825 static int __devinit riva_get_EDID_OF(struct fb_info *info, struct pci_dev *pd)
1826 {
1827 struct riva_par *par = info->par;
1828 struct device_node *dp;
1829 unsigned char *pedid = NULL;
1830 const unsigned char *disptype = NULL;
1831 static char *propnames[] = {
1832 "DFP,EDID", "LCD,EDID", "EDID", "EDID1", "EDID,B", "EDID,A", NULL };
1833 int i;
1834
1835 NVTRACE_ENTER();
1836 dp = pci_device_to_OF_node(pd);
1837 for (; dp != NULL; dp = dp->child) {
1838 disptype = get_property(dp, "display-type", NULL);
1839 if (disptype == NULL)
1840 continue;
1841 if (strncmp(disptype, "LCD", 3) != 0)
1842 continue;
1843 for (i = 0; propnames[i] != NULL; ++i) {
1844 pedid = get_property(dp, propnames[i], NULL);
1845 if (pedid != NULL) {
1846 par->EDID = pedid;
1847 NVTRACE("LCD found.\n");
1848 return 1;
1849 }
1850 }
1851 }
1852 NVTRACE_LEAVE();
1853 return 0;
1854 }
1855 #endif /* CONFIG_PPC_OF */
1856
1857 #if defined(CONFIG_FB_RIVA_I2C) && !defined(CONFIG_PPC_OF)
1858 static int __devinit riva_get_EDID_i2c(struct fb_info *info)
1859 {
1860 struct riva_par *par = info->par;
1861 struct fb_var_screeninfo var;
1862 int i;
1863
1864 NVTRACE_ENTER();
1865 riva_create_i2c_busses(par);
1866 for (i = 0; i < par->bus; i++) {
1867 riva_probe_i2c_connector(par, i+1, &par->EDID);
1868 if (par->EDID && !fb_parse_edid(par->EDID, &var)) {
1869 printk(PFX "Found EDID Block from BUS %i\n", i);
1870 break;
1871 }
1872 }
1873
1874 NVTRACE_LEAVE();
1875 return (par->EDID) ? 1 : 0;
1876 }
1877 #endif /* CONFIG_FB_RIVA_I2C */
1878
1879 static void __devinit riva_update_default_var(struct fb_var_screeninfo *var,
1880 struct fb_info *info)
1881 {
1882 struct fb_monspecs *specs = &info->monspecs;
1883 struct fb_videomode modedb;
1884
1885 NVTRACE_ENTER();
1886 /* respect mode options */
1887 if (mode_option) {
1888 fb_find_mode(var, info, mode_option,
1889 specs->modedb, specs->modedb_len,
1890 NULL, 8);
1891 } else if (specs->modedb != NULL) {
1892 /* get preferred timing */
1893 if (info->monspecs.misc & FB_MISC_1ST_DETAIL) {
1894 int i;
1895
1896 for (i = 0; i < specs->modedb_len; i++) {
1897 if (specs->modedb[i].flag & FB_MODE_IS_FIRST) {
1898 modedb = specs->modedb[i];
1899 break;
1900 }
1901 }
1902 } else {
1903 /* otherwise, get first mode in database */
1904 modedb = specs->modedb[0];
1905 }
1906 var->bits_per_pixel = 8;
1907 riva_update_var(var, &modedb);
1908 }
1909 NVTRACE_LEAVE();
1910 }
1911
1912
1913 static void __devinit riva_get_EDID(struct fb_info *info, struct pci_dev *pdev)
1914 {
1915 NVTRACE_ENTER();
1916 #ifdef CONFIG_PPC_OF
1917 if (!riva_get_EDID_OF(info, pdev))
1918 printk(PFX "could not retrieve EDID from OF\n");
1919 #elif defined(CONFIG_FB_RIVA_I2C)
1920 if (!riva_get_EDID_i2c(info))
1921 printk(PFX "could not retrieve EDID from DDC/I2C\n");
1922 #endif
1923 NVTRACE_LEAVE();
1924 }
1925
1926
1927 static void __devinit riva_get_edidinfo(struct fb_info *info)
1928 {
1929 struct fb_var_screeninfo *var = &rivafb_default_var;
1930 struct riva_par *par = info->par;
1931
1932 fb_edid_to_monspecs(par->EDID, &info->monspecs);
1933 fb_videomode_to_modelist(info->monspecs.modedb, info->monspecs.modedb_len,
1934 &info->modelist);
1935 riva_update_default_var(var, info);
1936
1937 /* if user specified flatpanel, we respect that */
1938 if (info->monspecs.input & FB_DISP_DDI)
1939 par->FlatPanel = 1;
1940 }
1941
1942 /* ------------------------------------------------------------------------- *
1943 *
1944 * PCI bus
1945 *
1946 * ------------------------------------------------------------------------- */
1947
1948 static u32 __devinit riva_get_arch(struct pci_dev *pd)
1949 {
1950 u32 arch = 0;
1951
1952 switch (pd->device & 0x0ff0) {
1953 case 0x0100: /* GeForce 256 */
1954 case 0x0110: /* GeForce2 MX */
1955 case 0x0150: /* GeForce2 */
1956 case 0x0170: /* GeForce4 MX */
1957 case 0x0180: /* GeForce4 MX (8x AGP) */
1958 case 0x01A0: /* nForce */
1959 case 0x01F0: /* nForce2 */
1960 arch = NV_ARCH_10;
1961 break;
1962 case 0x0200: /* GeForce3 */
1963 case 0x0250: /* GeForce4 Ti */
1964 case 0x0280: /* GeForce4 Ti (8x AGP) */
1965 arch = NV_ARCH_20;
1966 break;
1967 case 0x0300: /* GeForceFX 5800 */
1968 case 0x0310: /* GeForceFX 5600 */
1969 case 0x0320: /* GeForceFX 5200 */
1970 case 0x0330: /* GeForceFX 5900 */
1971 case 0x0340: /* GeForceFX 5700 */
1972 arch = NV_ARCH_30;
1973 break;
1974 case 0x0020: /* TNT, TNT2 */
1975 arch = NV_ARCH_04;
1976 break;
1977 case 0x0010: /* Riva128 */
1978 arch = NV_ARCH_03;
1979 break;
1980 default: /* unknown architecture */
1981 break;
1982 }
1983 return arch;
1984 }
1985
1986 static int __devinit rivafb_probe(struct pci_dev *pd,
1987 const struct pci_device_id *ent)
1988 {
1989 struct riva_par *default_par;
1990 struct fb_info *info;
1991 int ret;
1992
1993 NVTRACE_ENTER();
1994 assert(pd != NULL);
1995
1996 info = framebuffer_alloc(sizeof(struct riva_par), &pd->dev);
1997 if (!info) {
1998 printk (KERN_ERR PFX "could not allocate memory\n");
1999 ret = -ENOMEM;
2000 goto err_ret;
2001 }
2002 default_par = info->par;
2003 default_par->pdev = pd;
2004
2005 info->pixmap.addr = kmalloc(8 * 1024, GFP_KERNEL);
2006 if (info->pixmap.addr == NULL) {
2007 ret = -ENOMEM;
2008 goto err_framebuffer_release;
2009 }
2010 memset(info->pixmap.addr, 0, 8 * 1024);
2011
2012 ret = pci_enable_device(pd);
2013 if (ret < 0) {
2014 printk(KERN_ERR PFX "cannot enable PCI device\n");
2015 goto err_free_pixmap;
2016 }
2017
2018 ret = pci_request_regions(pd, "rivafb");
2019 if (ret < 0) {
2020 printk(KERN_ERR PFX "cannot request PCI regions\n");
2021 goto err_disable_device;
2022 }
2023
2024 default_par->riva.Architecture = riva_get_arch(pd);
2025
2026 default_par->Chipset = (pd->vendor << 16) | pd->device;
2027 printk(KERN_INFO PFX "nVidia device/chipset %X\n",default_par->Chipset);
2028
2029 if(default_par->riva.Architecture == 0) {
2030 printk(KERN_ERR PFX "unknown NV_ARCH\n");
2031 ret=-ENODEV;
2032 goto err_release_region;
2033 }
2034 if(default_par->riva.Architecture == NV_ARCH_10 ||
2035 default_par->riva.Architecture == NV_ARCH_20 ||
2036 default_par->riva.Architecture == NV_ARCH_30) {
2037 sprintf(rivafb_fix.id, "NV%x", (pd->device & 0x0ff0) >> 4);
2038 } else {
2039 sprintf(rivafb_fix.id, "NV%x", default_par->riva.Architecture);
2040 }
2041
2042 default_par->FlatPanel = flatpanel;
2043 if (flatpanel == 1)
2044 printk(KERN_INFO PFX "flatpanel support enabled\n");
2045 default_par->forceCRTC = forceCRTC;
2046
2047 rivafb_fix.mmio_len = pci_resource_len(pd, 0);
2048 rivafb_fix.smem_len = pci_resource_len(pd, 1);
2049
2050 {
2051 /* enable IO and mem if not already done */
2052 unsigned short cmd;
2053
2054 pci_read_config_word(pd, PCI_COMMAND, &cmd);
2055 cmd |= (PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
2056 pci_write_config_word(pd, PCI_COMMAND, cmd);
2057 }
2058
2059 rivafb_fix.mmio_start = pci_resource_start(pd, 0);
2060 rivafb_fix.smem_start = pci_resource_start(pd, 1);
2061
2062 default_par->ctrl_base = ioremap(rivafb_fix.mmio_start,
2063 rivafb_fix.mmio_len);
2064 if (!default_par->ctrl_base) {
2065 printk(KERN_ERR PFX "cannot ioremap MMIO base\n");
2066 ret = -EIO;
2067 goto err_release_region;
2068 }
2069
2070 switch (default_par->riva.Architecture) {
2071 case NV_ARCH_03:
2072 /* Riva128's PRAMIN is in the "framebuffer" space
2073 * Since these cards were never made with more than 8 megabytes
2074 * we can safely allocate this separately.
2075 */
2076 default_par->riva.PRAMIN = ioremap(rivafb_fix.smem_start + 0x00C00000, 0x00008000);
2077 if (!default_par->riva.PRAMIN) {
2078 printk(KERN_ERR PFX "cannot ioremap PRAMIN region\n");
2079 ret = -EIO;
2080 goto err_iounmap_ctrl_base;
2081 }
2082 break;
2083 case NV_ARCH_04:
2084 case NV_ARCH_10:
2085 case NV_ARCH_20:
2086 case NV_ARCH_30:
2087 default_par->riva.PCRTC0 =
2088 (u32 __iomem *)(default_par->ctrl_base + 0x00600000);
2089 default_par->riva.PRAMIN =
2090 (u32 __iomem *)(default_par->ctrl_base + 0x00710000);
2091 break;
2092 }
2093 riva_common_setup(default_par);
2094
2095 if (default_par->riva.Architecture == NV_ARCH_03) {
2096 default_par->riva.PCRTC = default_par->riva.PCRTC0
2097 = default_par->riva.PGRAPH;
2098 }
2099
2100 rivafb_fix.smem_len = riva_get_memlen(default_par) * 1024;
2101 default_par->dclk_max = riva_get_maxdclk(default_par) * 1000;
2102 info->screen_base = ioremap(rivafb_fix.smem_start,
2103 rivafb_fix.smem_len);
2104 if (!info->screen_base) {
2105 printk(KERN_ERR PFX "cannot ioremap FB base\n");
2106 ret = -EIO;
2107 goto err_iounmap_pramin;
2108 }
2109
2110 #ifdef CONFIG_MTRR
2111 if (!nomtrr) {
2112 default_par->mtrr.vram = mtrr_add(rivafb_fix.smem_start,
2113 rivafb_fix.smem_len,
2114 MTRR_TYPE_WRCOMB, 1);
2115 if (default_par->mtrr.vram < 0) {
2116 printk(KERN_ERR PFX "unable to setup MTRR\n");
2117 } else {
2118 default_par->mtrr.vram_valid = 1;
2119 /* let there be speed */
2120 printk(KERN_INFO PFX "RIVA MTRR set to ON\n");
2121 }
2122 }
2123 #endif /* CONFIG_MTRR */
2124
2125 info->fbops = &riva_fb_ops;
2126 info->fix = rivafb_fix;
2127 riva_get_EDID(info, pd);
2128 riva_get_edidinfo(info);
2129
2130 ret=riva_set_fbinfo(info);
2131 if (ret < 0) {
2132 printk(KERN_ERR PFX "error setting initial video mode\n");
2133 goto err_iounmap_screen_base;
2134 }
2135
2136 fb_destroy_modedb(info->monspecs.modedb);
2137 info->monspecs.modedb = NULL;
2138
2139 pci_set_drvdata(pd, info);
2140 riva_bl_init(info->par);
2141 ret = register_framebuffer(info);
2142 if (ret < 0) {
2143 printk(KERN_ERR PFX
2144 "error registering riva framebuffer\n");
2145 goto err_iounmap_screen_base;
2146 }
2147
2148 printk(KERN_INFO PFX
2149 "PCI nVidia %s framebuffer ver %s (%dMB @ 0x%lX)\n",
2150 info->fix.id,
2151 RIVAFB_VERSION,
2152 info->fix.smem_len / (1024 * 1024),
2153 info->fix.smem_start);
2154
2155 NVTRACE_LEAVE();
2156 return 0;
2157
2158 err_iounmap_screen_base:
2159 #ifdef CONFIG_FB_RIVA_I2C
2160 riva_delete_i2c_busses(info->par);
2161 #endif
2162 iounmap(info->screen_base);
2163 err_iounmap_pramin:
2164 if (default_par->riva.Architecture == NV_ARCH_03)
2165 iounmap(default_par->riva.PRAMIN);
2166 err_iounmap_ctrl_base:
2167 iounmap(default_par->ctrl_base);
2168 err_release_region:
2169 pci_release_regions(pd);
2170 err_disable_device:
2171 err_free_pixmap:
2172 kfree(info->pixmap.addr);
2173 err_framebuffer_release:
2174 framebuffer_release(info);
2175 err_ret:
2176 return ret;
2177 }
2178
2179 static void __exit rivafb_remove(struct pci_dev *pd)
2180 {
2181 struct fb_info *info = pci_get_drvdata(pd);
2182 struct riva_par *par = info->par;
2183
2184 NVTRACE_ENTER();
2185
2186 riva_bl_exit(par);
2187
2188 #ifdef CONFIG_FB_RIVA_I2C
2189 riva_delete_i2c_busses(par);
2190 kfree(par->EDID);
2191 #endif
2192
2193 unregister_framebuffer(info);
2194 #ifdef CONFIG_MTRR
2195 if (par->mtrr.vram_valid)
2196 mtrr_del(par->mtrr.vram, info->fix.smem_start,
2197 info->fix.smem_len);
2198 #endif /* CONFIG_MTRR */
2199
2200 iounmap(par->ctrl_base);
2201 iounmap(info->screen_base);
2202 if (par->riva.Architecture == NV_ARCH_03)
2203 iounmap(par->riva.PRAMIN);
2204 pci_release_regions(pd);
2205 kfree(info->pixmap.addr);
2206 framebuffer_release(info);
2207 pci_set_drvdata(pd, NULL);
2208 NVTRACE_LEAVE();
2209 }
2210
2211 /* ------------------------------------------------------------------------- *
2212 *
2213 * initialization
2214 *
2215 * ------------------------------------------------------------------------- */
2216
2217 #ifndef MODULE
2218 static int __init rivafb_setup(char *options)
2219 {
2220 char *this_opt;
2221
2222 NVTRACE_ENTER();
2223 if (!options || !*options)
2224 return 0;
2225
2226 while ((this_opt = strsep(&options, ",")) != NULL) {
2227 if (!strncmp(this_opt, "forceCRTC", 9)) {
2228 char *p;
2229
2230 p = this_opt + 9;
2231 if (!*p || !*(++p)) continue;
2232 forceCRTC = *p - '0';
2233 if (forceCRTC < 0 || forceCRTC > 1)
2234 forceCRTC = -1;
2235 } else if (!strncmp(this_opt, "flatpanel", 9)) {
2236 flatpanel = 1;
2237 #ifdef CONFIG_MTRR
2238 } else if (!strncmp(this_opt, "nomtrr", 6)) {
2239 nomtrr = 1;
2240 #endif
2241 } else if (!strncmp(this_opt, "strictmode", 10)) {
2242 strictmode = 1;
2243 } else if (!strncmp(this_opt, "noaccel", 7)) {
2244 noaccel = 1;
2245 } else
2246 mode_option = this_opt;
2247 }
2248 NVTRACE_LEAVE();
2249 return 0;
2250 }
2251 #endif /* !MODULE */
2252
2253 static struct pci_driver rivafb_driver = {
2254 .name = "rivafb",
2255 .id_table = rivafb_pci_tbl,
2256 .probe = rivafb_probe,
2257 .remove = __exit_p(rivafb_remove),
2258 };
2259
2260
2261
2262 /* ------------------------------------------------------------------------- *
2263 *
2264 * modularization
2265 *
2266 * ------------------------------------------------------------------------- */
2267
2268 static int __devinit rivafb_init(void)
2269 {
2270 #ifndef MODULE
2271 char *option = NULL;
2272
2273 if (fb_get_options("rivafb", &option))
2274 return -ENODEV;
2275 rivafb_setup(option);
2276 #endif
2277 return pci_register_driver(&rivafb_driver);
2278 }
2279
2280
2281 module_init(rivafb_init);
2282
2283 #ifdef MODULE
2284 static void __exit rivafb_exit(void)
2285 {
2286 pci_unregister_driver(&rivafb_driver);
2287 }
2288
2289 module_exit(rivafb_exit);
2290 #endif /* MODULE */
2291
2292 module_param(noaccel, bool, 0);
2293 MODULE_PARM_DESC(noaccel, "bool: disable acceleration");
2294 module_param(flatpanel, int, 0);
2295 MODULE_PARM_DESC(flatpanel, "Enables experimental flat panel support for some chipsets. (0 or 1=enabled) (default=0)");
2296 module_param(forceCRTC, int, 0);
2297 MODULE_PARM_DESC(forceCRTC, "Forces usage of a particular CRTC in case autodetection fails. (0 or 1) (default=autodetect)");
2298 #ifdef CONFIG_MTRR
2299 module_param(nomtrr, bool, 0);
2300 MODULE_PARM_DESC(nomtrr, "Disables MTRR support (0 or 1=disabled) (default=0)");
2301 #endif
2302 module_param(strictmode, bool, 0);
2303 MODULE_PARM_DESC(strictmode, "Only use video modes from EDID");
2304
2305 MODULE_AUTHOR("Ani Joshi, maintainer");
2306 MODULE_DESCRIPTION("Framebuffer driver for nVidia Riva 128, TNT, TNT2, and the GeForce series");
2307 MODULE_LICENSE("GPL");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree