?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[NETFILTER]: nf_conntrack: export hash allocation/destruction functions
[linux-2.6/verdex.git] / drivers / video / aty / radeon_base.c
blob2ce05019301892d9a0420f97ef2b803f8742100a
1 /*
2 * drivers/video/aty/radeon_base.c
3 *
4 * framebuffer driver for ATI Radeon chipset video boards
5 *
6 * Copyright 2003 Ben. Herrenschmidt <benh@kernel.crashing.org>
7 * Copyright 2000 Ani Joshi <ajoshi@kernel.crashing.org>
8 *
9 * i2c bits from Luca Tettamanti <kronos@kronoz.cjb.net>
10 *
11 * Special thanks to ATI DevRel team for their hardware donations.
12 *
13 * ...Insert GPL boilerplate here...
14 *
15 * Significant portions of this driver apdated from XFree86 Radeon
16 * driver which has the following copyright notice:
17 *
18 * Copyright 2000 ATI Technologies Inc., Markham, Ontario, and
19 * VA Linux Systems Inc., Fremont, California.
20 *
21 * All Rights Reserved.
22 *
23 * Permission is hereby granted, free of charge, to any person obtaining
24 * a copy of this software and associated documentation files (the
25 * "Software"), to deal in the Software without restriction, including
26 * without limitation on the rights to use, copy, modify, merge,
27 * publish, distribute, sublicense, and/or sell copies of the Software,
28 * and to permit persons to whom the Software is furnished to do so,
29 * subject to the following conditions:
30 *
31 * The above copyright notice and this permission notice (including the
32 * next paragraph) shall be included in all copies or substantial
33 * portions of the Software.
34 *
35 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
36 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
37 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
38 * NON-INFRINGEMENT. IN NO EVENT SHALL ATI, VA LINUX SYSTEMS AND/OR
39 * THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
40 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
41 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
42 * DEALINGS IN THE SOFTWARE.
43 *
44 * XFree86 driver authors:
45 *
46 * Kevin E. Martin <martin@xfree86.org>
47 * Rickard E. Faith <faith@valinux.com>
48 * Alan Hourihane <alanh@fairlite.demon.co.uk>
49 *
50 */
51
52
53 #define RADEON_VERSION "0.2.0"
54
55 #include <linux/module.h>
56 #include <linux/moduleparam.h>
57 #include <linux/kernel.h>
58 #include <linux/errno.h>
59 #include <linux/string.h>
60 #include <linux/mm.h>
61 #include <linux/slab.h>
62 #include <linux/delay.h>
63 #include <linux/time.h>
64 #include <linux/fb.h>
65 #include <linux/ioport.h>
66 #include <linux/init.h>
67 #include <linux/pci.h>
68 #include <linux/vmalloc.h>
69 #include <linux/device.h>
70
71 #include <asm/io.h>
72 #include <asm/uaccess.h>
73
74 #ifdef CONFIG_PPC_OF
75
76 #include <asm/pci-bridge.h>
77 #include "../macmodes.h"
78
79 #ifdef CONFIG_BOOTX_TEXT
80 #include <asm/btext.h>
81 #endif
82
83 #endif /* CONFIG_PPC_OF */
84
85 #ifdef CONFIG_MTRR
86 #include <asm/mtrr.h>
87 #endif
88
89 #include <video/radeon.h>
90 #include <linux/radeonfb.h>
91
92 #include "../edid.h" // MOVE THAT TO include/video
93 #include "ati_ids.h"
94 #include "radeonfb.h"
95
96 #define MAX_MAPPED_VRAM (2048*2048*4)
97 #define MIN_MAPPED_VRAM (1024*768*1)
98
99 #define CHIP_DEF(id, family, flags) \
100 { PCI_VENDOR_ID_ATI, id, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (flags) | (CHIP_FAMILY_##family) }
101
102 static struct pci_device_id radeonfb_pci_table[] = {
103 /* Radeon Xpress 200m */
104 CHIP_DEF(PCI_CHIP_RS480_5955, RS480, CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
105 /* Mobility M6 */
106 CHIP_DEF(PCI_CHIP_RADEON_LY, RV100, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
107 CHIP_DEF(PCI_CHIP_RADEON_LZ, RV100, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
108 /* Radeon VE/7000 */
109 CHIP_DEF(PCI_CHIP_RV100_QY, RV100, CHIP_HAS_CRTC2),
110 CHIP_DEF(PCI_CHIP_RV100_QZ, RV100, CHIP_HAS_CRTC2),
111 CHIP_DEF(PCI_CHIP_RN50, RV100, CHIP_HAS_CRTC2),
112 /* Radeon IGP320M (U1) */
113 CHIP_DEF(PCI_CHIP_RS100_4336, RS100, CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
114 /* Radeon IGP320 (A3) */
115 CHIP_DEF(PCI_CHIP_RS100_4136, RS100, CHIP_HAS_CRTC2 | CHIP_IS_IGP),
116 /* IGP330M/340M/350M (U2) */
117 CHIP_DEF(PCI_CHIP_RS200_4337, RS200, CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
118 /* IGP330/340/350 (A4) */
119 CHIP_DEF(PCI_CHIP_RS200_4137, RS200, CHIP_HAS_CRTC2 | CHIP_IS_IGP),
120 /* Mobility 7000 IGP */
121 CHIP_DEF(PCI_CHIP_RS250_4437, RS200, CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
122 /* 7000 IGP (A4+) */
123 CHIP_DEF(PCI_CHIP_RS250_4237, RS200, CHIP_HAS_CRTC2 | CHIP_IS_IGP),
124 /* 8500 AIW */
125 CHIP_DEF(PCI_CHIP_R200_BB, R200, CHIP_HAS_CRTC2),
126 CHIP_DEF(PCI_CHIP_R200_BC, R200, CHIP_HAS_CRTC2),
127 /* 8700/8800 */
128 CHIP_DEF(PCI_CHIP_R200_QH, R200, CHIP_HAS_CRTC2),
129 /* 8500 */
130 CHIP_DEF(PCI_CHIP_R200_QL, R200, CHIP_HAS_CRTC2),
131 /* 9100 */
132 CHIP_DEF(PCI_CHIP_R200_QM, R200, CHIP_HAS_CRTC2),
133 /* Mobility M7 */
134 CHIP_DEF(PCI_CHIP_RADEON_LW, RV200, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
135 CHIP_DEF(PCI_CHIP_RADEON_LX, RV200, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
136 /* 7500 */
137 CHIP_DEF(PCI_CHIP_RV200_QW, RV200, CHIP_HAS_CRTC2),
138 CHIP_DEF(PCI_CHIP_RV200_QX, RV200, CHIP_HAS_CRTC2),
139 /* Mobility M9 */
140 CHIP_DEF(PCI_CHIP_RV250_Ld, RV250, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
141 CHIP_DEF(PCI_CHIP_RV250_Le, RV250, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
142 CHIP_DEF(PCI_CHIP_RV250_Lf, RV250, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
143 CHIP_DEF(PCI_CHIP_RV250_Lg, RV250, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
144 /* 9000/Pro */
145 CHIP_DEF(PCI_CHIP_RV250_If, RV250, CHIP_HAS_CRTC2),
146 CHIP_DEF(PCI_CHIP_RV250_Ig, RV250, CHIP_HAS_CRTC2),
147 /* Mobility 9100 IGP (U3) */
148 CHIP_DEF(PCI_CHIP_RS300_5835, RS300, CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
149 CHIP_DEF(PCI_CHIP_RS350_7835, RS300, CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
150 /* 9100 IGP (A5) */
151 CHIP_DEF(PCI_CHIP_RS300_5834, RS300, CHIP_HAS_CRTC2 | CHIP_IS_IGP),
152 CHIP_DEF(PCI_CHIP_RS350_7834, RS300, CHIP_HAS_CRTC2 | CHIP_IS_IGP),
153 /* Mobility 9200 (M9+) */
154 CHIP_DEF(PCI_CHIP_RV280_5C61, RV280, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
155 CHIP_DEF(PCI_CHIP_RV280_5C63, RV280, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
156 /* 9200 */
157 CHIP_DEF(PCI_CHIP_RV280_5960, RV280, CHIP_HAS_CRTC2),
158 CHIP_DEF(PCI_CHIP_RV280_5961, RV280, CHIP_HAS_CRTC2),
159 CHIP_DEF(PCI_CHIP_RV280_5962, RV280, CHIP_HAS_CRTC2),
160 CHIP_DEF(PCI_CHIP_RV280_5964, RV280, CHIP_HAS_CRTC2),
161 /* 9500 */
162 CHIP_DEF(PCI_CHIP_R300_AD, R300, CHIP_HAS_CRTC2),
163 CHIP_DEF(PCI_CHIP_R300_AE, R300, CHIP_HAS_CRTC2),
164 /* 9600TX / FireGL Z1 */
165 CHIP_DEF(PCI_CHIP_R300_AF, R300, CHIP_HAS_CRTC2),
166 CHIP_DEF(PCI_CHIP_R300_AG, R300, CHIP_HAS_CRTC2),
167 /* 9700/9500/Pro/FireGL X1 */
168 CHIP_DEF(PCI_CHIP_R300_ND, R300, CHIP_HAS_CRTC2),
169 CHIP_DEF(PCI_CHIP_R300_NE, R300, CHIP_HAS_CRTC2),
170 CHIP_DEF(PCI_CHIP_R300_NF, R300, CHIP_HAS_CRTC2),
171 CHIP_DEF(PCI_CHIP_R300_NG, R300, CHIP_HAS_CRTC2),
172 /* Mobility M10/M11 */
173 CHIP_DEF(PCI_CHIP_RV350_NP, RV350, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
174 CHIP_DEF(PCI_CHIP_RV350_NQ, RV350, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
175 CHIP_DEF(PCI_CHIP_RV350_NR, RV350, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
176 CHIP_DEF(PCI_CHIP_RV350_NS, RV350, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
177 CHIP_DEF(PCI_CHIP_RV350_NT, RV350, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
178 CHIP_DEF(PCI_CHIP_RV350_NV, RV350, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
179 /* 9600/FireGL T2 */
180 CHIP_DEF(PCI_CHIP_RV350_AP, RV350, CHIP_HAS_CRTC2),
181 CHIP_DEF(PCI_CHIP_RV350_AQ, RV350, CHIP_HAS_CRTC2),
182 CHIP_DEF(PCI_CHIP_RV360_AR, RV350, CHIP_HAS_CRTC2),
183 CHIP_DEF(PCI_CHIP_RV350_AS, RV350, CHIP_HAS_CRTC2),
184 CHIP_DEF(PCI_CHIP_RV350_AT, RV350, CHIP_HAS_CRTC2),
185 CHIP_DEF(PCI_CHIP_RV350_AV, RV350, CHIP_HAS_CRTC2),
186 /* 9800/Pro/FileGL X2 */
187 CHIP_DEF(PCI_CHIP_R350_AH, R350, CHIP_HAS_CRTC2),
188 CHIP_DEF(PCI_CHIP_R350_AI, R350, CHIP_HAS_CRTC2),
189 CHIP_DEF(PCI_CHIP_R350_AJ, R350, CHIP_HAS_CRTC2),
190 CHIP_DEF(PCI_CHIP_R350_AK, R350, CHIP_HAS_CRTC2),
191 CHIP_DEF(PCI_CHIP_R350_NH, R350, CHIP_HAS_CRTC2),
192 CHIP_DEF(PCI_CHIP_R350_NI, R350, CHIP_HAS_CRTC2),
193 CHIP_DEF(PCI_CHIP_R360_NJ, R350, CHIP_HAS_CRTC2),
194 CHIP_DEF(PCI_CHIP_R350_NK, R350, CHIP_HAS_CRTC2),
195 /* Newer stuff */
196 CHIP_DEF(PCI_CHIP_RV380_3E50, RV380, CHIP_HAS_CRTC2),
197 CHIP_DEF(PCI_CHIP_RV380_3E54, RV380, CHIP_HAS_CRTC2),
198 CHIP_DEF(PCI_CHIP_RV380_3150, RV380, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
199 CHIP_DEF(PCI_CHIP_RV380_3154, RV380, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
200 CHIP_DEF(PCI_CHIP_RV370_5B60, RV380, CHIP_HAS_CRTC2),
201 CHIP_DEF(PCI_CHIP_RV370_5B62, RV380, CHIP_HAS_CRTC2),
202 CHIP_DEF(PCI_CHIP_RV370_5B64, RV380, CHIP_HAS_CRTC2),
203 CHIP_DEF(PCI_CHIP_RV370_5B65, RV380, CHIP_HAS_CRTC2),
204 CHIP_DEF(PCI_CHIP_RV370_5460, RV380, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
205 CHIP_DEF(PCI_CHIP_RV370_5464, RV380, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
206 CHIP_DEF(PCI_CHIP_R420_JH, R420, CHIP_HAS_CRTC2),
207 CHIP_DEF(PCI_CHIP_R420_JI, R420, CHIP_HAS_CRTC2),
208 CHIP_DEF(PCI_CHIP_R420_JJ, R420, CHIP_HAS_CRTC2),
209 CHIP_DEF(PCI_CHIP_R420_JK, R420, CHIP_HAS_CRTC2),
210 CHIP_DEF(PCI_CHIP_R420_JL, R420, CHIP_HAS_CRTC2),
211 CHIP_DEF(PCI_CHIP_R420_JM, R420, CHIP_HAS_CRTC2),
212 CHIP_DEF(PCI_CHIP_R420_JN, R420, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
213 CHIP_DEF(PCI_CHIP_R420_JP, R420, CHIP_HAS_CRTC2),
214 CHIP_DEF(PCI_CHIP_R423_UH, R420, CHIP_HAS_CRTC2),
215 CHIP_DEF(PCI_CHIP_R423_UI, R420, CHIP_HAS_CRTC2),
216 CHIP_DEF(PCI_CHIP_R423_UJ, R420, CHIP_HAS_CRTC2),
217 CHIP_DEF(PCI_CHIP_R423_UK, R420, CHIP_HAS_CRTC2),
218 CHIP_DEF(PCI_CHIP_R423_UQ, R420, CHIP_HAS_CRTC2),
219 CHIP_DEF(PCI_CHIP_R423_UR, R420, CHIP_HAS_CRTC2),
220 CHIP_DEF(PCI_CHIP_R423_UT, R420, CHIP_HAS_CRTC2),
221 CHIP_DEF(PCI_CHIP_R423_5D57, R420, CHIP_HAS_CRTC2),
222 /* Original Radeon/7200 */
223 CHIP_DEF(PCI_CHIP_RADEON_QD, RADEON, 0),
224 CHIP_DEF(PCI_CHIP_RADEON_QE, RADEON, 0),
225 CHIP_DEF(PCI_CHIP_RADEON_QF, RADEON, 0),
226 CHIP_DEF(PCI_CHIP_RADEON_QG, RADEON, 0),
227 { 0, }
228 };
229 MODULE_DEVICE_TABLE(pci, radeonfb_pci_table);
230
231
232 typedef struct {
233 u16 reg;
234 u32 val;
235 } reg_val;
236
237
238 /* these common regs are cleared before mode setting so they do not
239 * interfere with anything
240 */
241 static reg_val common_regs[] = {
242 { OVR_CLR, 0 },
243 { OVR_WID_LEFT_RIGHT, 0 },
244 { OVR_WID_TOP_BOTTOM, 0 },
245 { OV0_SCALE_CNTL, 0 },
246 { SUBPIC_CNTL, 0 },
247 { VIPH_CONTROL, 0 },
248 { I2C_CNTL_1, 0 },
249 { GEN_INT_CNTL, 0 },
250 { CAP0_TRIG_CNTL, 0 },
251 { CAP1_TRIG_CNTL, 0 },
252 };
253
254 /*
255 * globals
256 */
257
258 static char *mode_option;
259 static char *monitor_layout;
260 static int noaccel = 0;
261 static int default_dynclk = -2;
262 static int nomodeset = 0;
263 static int ignore_edid = 0;
264 static int mirror = 0;
265 static int panel_yres = 0;
266 static int force_dfp = 0;
267 static int force_measure_pll = 0;
268 #ifdef CONFIG_MTRR
269 static int nomtrr = 0;
270 #endif
271 static int force_sleep;
272 static int ignore_devlist;
273 #ifdef CONFIG_PMAC_BACKLIGHT
274 static int backlight = 1;
275 #else
276 static int backlight = 0;
277 #endif
278
279 /*
280 * prototypes
281 */
282
283 static void radeon_unmap_ROM(struct radeonfb_info *rinfo, struct pci_dev *dev)
284 {
285 if (!rinfo->bios_seg)
286 return;
287 pci_unmap_rom(dev, rinfo->bios_seg);
288 }
289
290 static int __devinit radeon_map_ROM(struct radeonfb_info *rinfo, struct pci_dev *dev)
291 {
292 void __iomem *rom;
293 u16 dptr;
294 u8 rom_type;
295 size_t rom_size;
296
297 /* If this is a primary card, there is a shadow copy of the
298 * ROM somewhere in the first meg. We will just ignore the copy
299 * and use the ROM directly.
300 */
301
302 /* Fix from ATI for problem with Radeon hardware not leaving ROM enabled */
303 unsigned int temp;
304 temp = INREG(MPP_TB_CONFIG);
305 temp &= 0x00ffffffu;
306 temp |= 0x04 << 24;
307 OUTREG(MPP_TB_CONFIG, temp);
308 temp = INREG(MPP_TB_CONFIG);
309
310 rom = pci_map_rom(dev, &rom_size);
311 if (!rom) {
312 printk(KERN_ERR "radeonfb (%s): ROM failed to map\n",
313 pci_name(rinfo->pdev));
314 return -ENOMEM;
315 }
316
317 rinfo->bios_seg = rom;
318
319 /* Very simple test to make sure it appeared */
320 if (BIOS_IN16(0) != 0xaa55) {
321 printk(KERN_DEBUG "radeonfb (%s): Invalid ROM signature %x "
322 "should be 0xaa55\n",
323 pci_name(rinfo->pdev), BIOS_IN16(0));
324 goto failed;
325 }
326 /* Look for the PCI data to check the ROM type */
327 dptr = BIOS_IN16(0x18);
328
329 /* Check the PCI data signature. If it's wrong, we still assume a normal x86 ROM
330 * for now, until I've verified this works everywhere. The goal here is more
331 * to phase out Open Firmware images.
332 *
333 * Currently, we only look at the first PCI data, we could iteratre and deal with
334 * them all, and we should use fb_bios_start relative to start of image and not
335 * relative start of ROM, but so far, I never found a dual-image ATI card
336 *
337 * typedef struct {
338 * u32 signature; + 0x00
339 * u16 vendor; + 0x04
340 * u16 device; + 0x06
341 * u16 reserved_1; + 0x08
342 * u16 dlen; + 0x0a
343 * u8 drevision; + 0x0c
344 * u8 class_hi; + 0x0d
345 * u16 class_lo; + 0x0e
346 * u16 ilen; + 0x10
347 * u16 irevision; + 0x12
348 * u8 type; + 0x14
349 * u8 indicator; + 0x15
350 * u16 reserved_2; + 0x16
351 * } pci_data_t;
352 */
353 if (BIOS_IN32(dptr) != (('R' << 24) | ('I' << 16) | ('C' << 8) | 'P')) {
354 printk(KERN_WARNING "radeonfb (%s): PCI DATA signature in ROM"
355 "incorrect: %08x\n", pci_name(rinfo->pdev), BIOS_IN32(dptr));
356 goto anyway;
357 }
358 rom_type = BIOS_IN8(dptr + 0x14);
359 switch(rom_type) {
360 case 0:
361 printk(KERN_INFO "radeonfb: Found Intel x86 BIOS ROM Image\n");
362 break;
363 case 1:
364 printk(KERN_INFO "radeonfb: Found Open Firmware ROM Image\n");
365 goto failed;
366 case 2:
367 printk(KERN_INFO "radeonfb: Found HP PA-RISC ROM Image\n");
368 goto failed;
369 default:
370 printk(KERN_INFO "radeonfb: Found unknown type %d ROM Image\n", rom_type);
371 goto failed;
372 }
373 anyway:
374 /* Locate the flat panel infos, do some sanity checking !!! */
375 rinfo->fp_bios_start = BIOS_IN16(0x48);
376 return 0;
377
378 failed:
379 rinfo->bios_seg = NULL;
380 radeon_unmap_ROM(rinfo, dev);
381 return -ENXIO;
382 }
383
384 #ifdef CONFIG_X86
385 static int __devinit radeon_find_mem_vbios(struct radeonfb_info *rinfo)
386 {
387 /* I simplified this code as we used to miss the signatures in
388 * a lot of case. It's now closer to XFree, we just don't check
389 * for signatures at all... Something better will have to be done
390 * if we end up having conflicts
391 */
392 u32 segstart;
393 void __iomem *rom_base = NULL;
394
395 for(segstart=0x000c0000; segstart<0x000f0000; segstart+=0x00001000) {
396 rom_base = ioremap(segstart, 0x10000);
397 if (rom_base == NULL)
398 return -ENOMEM;
399 if (readb(rom_base) == 0x55 && readb(rom_base + 1) == 0xaa)
400 break;
401 iounmap(rom_base);
402 rom_base = NULL;
403 }
404 if (rom_base == NULL)
405 return -ENXIO;
406
407 /* Locate the flat panel infos, do some sanity checking !!! */
408 rinfo->bios_seg = rom_base;
409 rinfo->fp_bios_start = BIOS_IN16(0x48);
410
411 return 0;
412 }
413 #endif
414
415 #if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
416 /*
417 * Read XTAL (ref clock), SCLK and MCLK from Open Firmware device
418 * tree. Hopefully, ATI OF driver is kind enough to fill these
419 */
420 static int __devinit radeon_read_xtal_OF (struct radeonfb_info *rinfo)
421 {
422 struct device_node *dp = rinfo->of_node;
423 const u32 *val;
424
425 if (dp == NULL)
426 return -ENODEV;
427 val = of_get_property(dp, "ATY,RefCLK", NULL);
428 if (!val || !*val) {
429 printk(KERN_WARNING "radeonfb: No ATY,RefCLK property !\n");
430 return -EINVAL;
431 }
432
433 rinfo->pll.ref_clk = (*val) / 10;
434
435 val = of_get_property(dp, "ATY,SCLK", NULL);
436 if (val && *val)
437 rinfo->pll.sclk = (*val) / 10;
438
439 val = of_get_property(dp, "ATY,MCLK", NULL);
440 if (val && *val)
441 rinfo->pll.mclk = (*val) / 10;
442
443 return 0;
444 }
445 #endif /* CONFIG_PPC_OF || CONFIG_SPARC */
446
447 /*
448 * Read PLL infos from chip registers
449 */
450 static int __devinit radeon_probe_pll_params(struct radeonfb_info *rinfo)
451 {
452 unsigned char ppll_div_sel;
453 unsigned Ns, Nm, M;
454 unsigned sclk, mclk, tmp, ref_div;
455 int hTotal, vTotal, num, denom, m, n;
456 unsigned long long hz, vclk;
457 long xtal;
458 struct timeval start_tv, stop_tv;
459 long total_secs, total_usecs;
460 int i;
461
462 /* Ugh, we cut interrupts, bad bad bad, but we want some precision
463 * here, so... --BenH
464 */
465
466 /* Flush PCI buffers ? */
467 tmp = INREG16(DEVICE_ID);
468
469 local_irq_disable();
470
471 for(i=0; i<1000000; i++)
472 if (((INREG(CRTC_VLINE_CRNT_VLINE) >> 16) & 0x3ff) == 0)
473 break;
474
475 do_gettimeofday(&start_tv);
476
477 for(i=0; i<1000000; i++)
478 if (((INREG(CRTC_VLINE_CRNT_VLINE) >> 16) & 0x3ff) != 0)
479 break;
480
481 for(i=0; i<1000000; i++)
482 if (((INREG(CRTC_VLINE_CRNT_VLINE) >> 16) & 0x3ff) == 0)
483 break;
484
485 do_gettimeofday(&stop_tv);
486
487 local_irq_enable();
488
489 total_secs = stop_tv.tv_sec - start_tv.tv_sec;
490 if (total_secs > 10)
491 return -1;
492 total_usecs = stop_tv.tv_usec - start_tv.tv_usec;
493 total_usecs += total_secs * 1000000;
494 if (total_usecs < 0)
495 total_usecs = -total_usecs;
496 hz = 1000000/total_usecs;
497
498 hTotal = ((INREG(CRTC_H_TOTAL_DISP) & 0x1ff) + 1) * 8;
499 vTotal = ((INREG(CRTC_V_TOTAL_DISP) & 0x3ff) + 1);
500 vclk = (long long)hTotal * (long long)vTotal * hz;
501
502 switch((INPLL(PPLL_REF_DIV) & 0x30000) >> 16) {
503 case 0:
504 default:
505 num = 1;
506 denom = 1;
507 break;
508 case 1:
509 n = ((INPLL(M_SPLL_REF_FB_DIV) >> 16) & 0xff);
510 m = (INPLL(M_SPLL_REF_FB_DIV) & 0xff);
511 num = 2*n;
512 denom = 2*m;
513 break;
514 case 2:
515 n = ((INPLL(M_SPLL_REF_FB_DIV) >> 8) & 0xff);
516 m = (INPLL(M_SPLL_REF_FB_DIV) & 0xff);
517 num = 2*n;
518 denom = 2*m;
519 break;
520 }
521
522 ppll_div_sel = INREG8(CLOCK_CNTL_INDEX + 1) & 0x3;
523 radeon_pll_errata_after_index(rinfo);
524
525 n = (INPLL(PPLL_DIV_0 + ppll_div_sel) & 0x7ff);
526 m = (INPLL(PPLL_REF_DIV) & 0x3ff);
527
528 num *= n;
529 denom *= m;
530
531 switch ((INPLL(PPLL_DIV_0 + ppll_div_sel) >> 16) & 0x7) {
532 case 1:
533 denom *= 2;
534 break;
535 case 2:
536 denom *= 4;
537 break;
538 case 3:
539 denom *= 8;
540 break;
541 case 4:
542 denom *= 3;
543 break;
544 case 6:
545 denom *= 6;
546 break;
547 case 7:
548 denom *= 12;
549 break;
550 }
551
552 vclk *= denom;
553 do_div(vclk, 1000 * num);
554 xtal = vclk;
555
556 if ((xtal > 26900) && (xtal < 27100))
557 xtal = 2700;
558 else if ((xtal > 14200) && (xtal < 14400))
559 xtal = 1432;
560 else if ((xtal > 29400) && (xtal < 29600))
561 xtal = 2950;
562 else {
563 printk(KERN_WARNING "xtal calculation failed: %ld\n", xtal);
564 return -1;
565 }
566
567 tmp = INPLL(M_SPLL_REF_FB_DIV);
568 ref_div = INPLL(PPLL_REF_DIV) & 0x3ff;
569
570 Ns = (tmp & 0xff0000) >> 16;
571 Nm = (tmp & 0xff00) >> 8;
572 M = (tmp & 0xff);
573 sclk = round_div((2 * Ns * xtal), (2 * M));
574 mclk = round_div((2 * Nm * xtal), (2 * M));
575
576 /* we're done, hopefully these are sane values */
577 rinfo->pll.ref_clk = xtal;
578 rinfo->pll.ref_div = ref_div;
579 rinfo->pll.sclk = sclk;
580 rinfo->pll.mclk = mclk;
581
582 return 0;
583 }
584
585 /*
586 * Retrieve PLL infos by different means (BIOS, Open Firmware, register probing...)
587 */
588 static void __devinit radeon_get_pllinfo(struct radeonfb_info *rinfo)
589 {
590 /*
591 * In the case nothing works, these are defaults; they are mostly
592 * incomplete, however. It does provide ppll_max and _min values
593 * even for most other methods, however.
594 */
595 switch (rinfo->chipset) {
596 case PCI_DEVICE_ID_ATI_RADEON_QW:
597 case PCI_DEVICE_ID_ATI_RADEON_QX:
598 rinfo->pll.ppll_max = 35000;
599 rinfo->pll.ppll_min = 12000;
600 rinfo->pll.mclk = 23000;
601 rinfo->pll.sclk = 23000;
602 rinfo->pll.ref_clk = 2700;
603 break;
604 case PCI_DEVICE_ID_ATI_RADEON_QL:
605 case PCI_DEVICE_ID_ATI_RADEON_QN:
606 case PCI_DEVICE_ID_ATI_RADEON_QO:
607 case PCI_DEVICE_ID_ATI_RADEON_Ql:
608 case PCI_DEVICE_ID_ATI_RADEON_BB:
609 rinfo->pll.ppll_max = 35000;
610 rinfo->pll.ppll_min = 12000;
611 rinfo->pll.mclk = 27500;
612 rinfo->pll.sclk = 27500;
613 rinfo->pll.ref_clk = 2700;
614 break;
615 case PCI_DEVICE_ID_ATI_RADEON_Id:
616 case PCI_DEVICE_ID_ATI_RADEON_Ie:
617 case PCI_DEVICE_ID_ATI_RADEON_If:
618 case PCI_DEVICE_ID_ATI_RADEON_Ig:
619 rinfo->pll.ppll_max = 35000;
620 rinfo->pll.ppll_min = 12000;
621 rinfo->pll.mclk = 25000;
622 rinfo->pll.sclk = 25000;
623 rinfo->pll.ref_clk = 2700;
624 break;
625 case PCI_DEVICE_ID_ATI_RADEON_ND:
626 case PCI_DEVICE_ID_ATI_RADEON_NE:
627 case PCI_DEVICE_ID_ATI_RADEON_NF:
628 case PCI_DEVICE_ID_ATI_RADEON_NG:
629 rinfo->pll.ppll_max = 40000;
630 rinfo->pll.ppll_min = 20000;
631 rinfo->pll.mclk = 27000;
632 rinfo->pll.sclk = 27000;
633 rinfo->pll.ref_clk = 2700;
634 break;
635 case PCI_DEVICE_ID_ATI_RADEON_QD:
636 case PCI_DEVICE_ID_ATI_RADEON_QE:
637 case PCI_DEVICE_ID_ATI_RADEON_QF:
638 case PCI_DEVICE_ID_ATI_RADEON_QG:
639 default:
640 rinfo->pll.ppll_max = 35000;
641 rinfo->pll.ppll_min = 12000;
642 rinfo->pll.mclk = 16600;
643 rinfo->pll.sclk = 16600;
644 rinfo->pll.ref_clk = 2700;
645 break;
646 }
647 rinfo->pll.ref_div = INPLL(PPLL_REF_DIV) & PPLL_REF_DIV_MASK;
648
649
650 #if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
651 /*
652 * Retrieve PLL infos from Open Firmware first
653 */
654 if (!force_measure_pll && radeon_read_xtal_OF(rinfo) == 0) {
655 printk(KERN_INFO "radeonfb: Retrieved PLL infos from Open Firmware\n");
656 goto found;
657 }
658 #endif /* CONFIG_PPC_OF || CONFIG_SPARC */
659
660 /*
661 * Check out if we have an X86 which gave us some PLL informations
662 * and if yes, retrieve them
663 */
664 if (!force_measure_pll && rinfo->bios_seg) {
665 u16 pll_info_block = BIOS_IN16(rinfo->fp_bios_start + 0x30);
666
667 rinfo->pll.sclk = BIOS_IN16(pll_info_block + 0x08);
668 rinfo->pll.mclk = BIOS_IN16(pll_info_block + 0x0a);
669 rinfo->pll.ref_clk = BIOS_IN16(pll_info_block + 0x0e);
670 rinfo->pll.ref_div = BIOS_IN16(pll_info_block + 0x10);
671 rinfo->pll.ppll_min = BIOS_IN32(pll_info_block + 0x12);
672 rinfo->pll.ppll_max = BIOS_IN32(pll_info_block + 0x16);
673
674 printk(KERN_INFO "radeonfb: Retrieved PLL infos from BIOS\n");
675 goto found;
676 }
677
678 /*
679 * We didn't get PLL parameters from either OF or BIOS, we try to
680 * probe them
681 */
682 if (radeon_probe_pll_params(rinfo) == 0) {
683 printk(KERN_INFO "radeonfb: Retrieved PLL infos from registers\n");
684 goto found;
685 }
686
687 /*
688 * Fall back to already-set defaults...
689 */
690 printk(KERN_INFO "radeonfb: Used default PLL infos\n");
691
692 found:
693 /*
694 * Some methods fail to retrieve SCLK and MCLK values, we apply default
695 * settings in this case (200Mhz). If that really happne often, we could
696 * fetch from registers instead...
697 */
698 if (rinfo->pll.mclk == 0)
699 rinfo->pll.mclk = 20000;
700 if (rinfo->pll.sclk == 0)
701 rinfo->pll.sclk = 20000;
702
703 printk("radeonfb: Reference=%d.%02d MHz (RefDiv=%d) Memory=%d.%02d Mhz, System=%d.%02d MHz\n",
704 rinfo->pll.ref_clk / 100, rinfo->pll.ref_clk % 100,
705 rinfo->pll.ref_div,
706 rinfo->pll.mclk / 100, rinfo->pll.mclk % 100,
707 rinfo->pll.sclk / 100, rinfo->pll.sclk % 100);
708 printk("radeonfb: PLL min %d max %d\n", rinfo->pll.ppll_min, rinfo->pll.ppll_max);
709 }
710
711 static int radeonfb_check_var (struct fb_var_screeninfo *var, struct fb_info *info)
712 {
713 struct radeonfb_info *rinfo = info->par;
714 struct fb_var_screeninfo v;
715 int nom, den;
716 unsigned int pitch;
717
718 if (radeon_match_mode(rinfo, &v, var))
719 return -EINVAL;
720
721 switch (v.bits_per_pixel) {
722 case 0 ... 8:
723 v.bits_per_pixel = 8;
724 break;
725 case 9 ... 16:
726 v.bits_per_pixel = 16;
727 break;
728 case 17 ... 24:
729 #if 0 /* Doesn't seem to work */
730 v.bits_per_pixel = 24;
731 break;
732 #endif
733 return -EINVAL;
734 case 25 ... 32:
735 v.bits_per_pixel = 32;
736 break;
737 default:
738 return -EINVAL;
739 }
740
741 switch (var_to_depth(&v)) {
742 case 8:
743 nom = den = 1;
744 v.red.offset = v.green.offset = v.blue.offset = 0;
745 v.red.length = v.green.length = v.blue.length = 8;
746 v.transp.offset = v.transp.length = 0;
747 break;
748 case 15:
749 nom = 2;
750 den = 1;
751 v.red.offset = 10;
752 v.green.offset = 5;
753 v.blue.offset = 0;
754 v.red.length = v.green.length = v.blue.length = 5;
755 v.transp.offset = v.transp.length = 0;
756 break;
757 case 16:
758 nom = 2;
759 den = 1;
760 v.red.offset = 11;
761 v.green.offset = 5;
762 v.blue.offset = 0;
763 v.red.length = 5;
764 v.green.length = 6;
765 v.blue.length = 5;
766 v.transp.offset = v.transp.length = 0;
767 break;
768 case 24:
769 nom = 4;
770 den = 1;
771 v.red.offset = 16;
772 v.green.offset = 8;
773 v.blue.offset = 0;
774 v.red.length = v.blue.length = v.green.length = 8;
775 v.transp.offset = v.transp.length = 0;
776 break;
777 case 32:
778 nom = 4;
779 den = 1;
780 v.red.offset = 16;
781 v.green.offset = 8;
782 v.blue.offset = 0;
783 v.red.length = v.blue.length = v.green.length = 8;
784 v.transp.offset = 24;
785 v.transp.length = 8;
786 break;
787 default:
788 printk ("radeonfb: mode %dx%dx%d rejected, color depth invalid\n",
789 var->xres, var->yres, var->bits_per_pixel);
790 return -EINVAL;
791 }
792
793 if (v.yres_virtual < v.yres)
794 v.yres_virtual = v.yres;
795 if (v.xres_virtual < v.xres)
796 v.xres_virtual = v.xres;
797
798
799 /* XXX I'm adjusting xres_virtual to the pitch, that may help XFree
800 * with some panels, though I don't quite like this solution
801 */
802 if (rinfo->info->flags & FBINFO_HWACCEL_DISABLED) {
803 v.xres_virtual = v.xres_virtual & ~7ul;
804 } else {
805 pitch = ((v.xres_virtual * ((v.bits_per_pixel + 1) / 8) + 0x3f)
806 & ~(0x3f)) >> 6;
807 v.xres_virtual = (pitch << 6) / ((v.bits_per_pixel + 1) / 8);
808 }
809
810 if (((v.xres_virtual * v.yres_virtual * nom) / den) > rinfo->mapped_vram)
811 return -EINVAL;
812
813 if (v.xres_virtual < v.xres)
814 v.xres = v.xres_virtual;
815
816 if (v.xoffset < 0)
817 v.xoffset = 0;
818 if (v.yoffset < 0)
819 v.yoffset = 0;
820
821 if (v.xoffset > v.xres_virtual - v.xres)
822 v.xoffset = v.xres_virtual - v.xres - 1;
823
824 if (v.yoffset > v.yres_virtual - v.yres)
825 v.yoffset = v.yres_virtual - v.yres - 1;
826
827 v.red.msb_right = v.green.msb_right = v.blue.msb_right =
828 v.transp.offset = v.transp.length =
829 v.transp.msb_right = 0;
830
831 memcpy(var, &v, sizeof(v));
832
833 return 0;
834 }
835
836
837 static int radeonfb_pan_display (struct fb_var_screeninfo *var,
838 struct fb_info *info)
839 {
840 struct radeonfb_info *rinfo = info->par;
841
842 if ((var->xoffset + var->xres > var->xres_virtual)
843 || (var->yoffset + var->yres > var->yres_virtual))
844 return -EINVAL;
845
846 if (rinfo->asleep)
847 return 0;
848
849 radeon_fifo_wait(2);
850 OUTREG(CRTC_OFFSET, ((var->yoffset * var->xres_virtual + var->xoffset)
851 * var->bits_per_pixel / 8) & ~7);
852 return 0;
853 }
854
855
856 static int radeonfb_ioctl (struct fb_info *info, unsigned int cmd,
857 unsigned long arg)
858 {
859 struct radeonfb_info *rinfo = info->par;
860 unsigned int tmp;
861 u32 value = 0;
862 int rc;
863
864 switch (cmd) {
865 /*
866 * TODO: set mirror accordingly for non-Mobility chipsets with 2 CRTC's
867 * and do something better using 2nd CRTC instead of just hackish
868 * routing to second output
869 */
870 case FBIO_RADEON_SET_MIRROR:
871 if (!rinfo->is_mobility)
872 return -EINVAL;
873
874 rc = get_user(value, (__u32 __user *)arg);
875
876 if (rc)
877 return rc;
878
879 radeon_fifo_wait(2);
880 if (value & 0x01) {
881 tmp = INREG(LVDS_GEN_CNTL);
882
883 tmp |= (LVDS_ON | LVDS_BLON);
884 } else {
885 tmp = INREG(LVDS_GEN_CNTL);
886
887 tmp &= ~(LVDS_ON | LVDS_BLON);
888 }
889
890 OUTREG(LVDS_GEN_CNTL, tmp);
891
892 if (value & 0x02) {
893 tmp = INREG(CRTC_EXT_CNTL);
894 tmp |= CRTC_CRT_ON;
895
896 mirror = 1;
897 } else {
898 tmp = INREG(CRTC_EXT_CNTL);
899 tmp &= ~CRTC_CRT_ON;
900
901 mirror = 0;
902 }
903
904 OUTREG(CRTC_EXT_CNTL, tmp);
905
906 return 0;
907 case FBIO_RADEON_GET_MIRROR:
908 if (!rinfo->is_mobility)
909 return -EINVAL;
910
911 tmp = INREG(LVDS_GEN_CNTL);
912 if ((LVDS_ON | LVDS_BLON) & tmp)
913 value |= 0x01;
914
915 tmp = INREG(CRTC_EXT_CNTL);
916 if (CRTC_CRT_ON & tmp)
917 value |= 0x02;
918
919 return put_user(value, (__u32 __user *)arg);
920 default:
921 return -EINVAL;
922 }
923
924 return -EINVAL;
925 }
926
927
928 int radeon_screen_blank(struct radeonfb_info *rinfo, int blank, int mode_switch)
929 {
930 u32 val;
931 u32 tmp_pix_clks;
932 int unblank = 0;
933
934 if (rinfo->lock_blank)
935 return 0;
936
937 radeon_engine_idle();
938
939 val = INREG(CRTC_EXT_CNTL);
940 val &= ~(CRTC_DISPLAY_DIS | CRTC_HSYNC_DIS |
941 CRTC_VSYNC_DIS);
942 switch (blank) {
943 case FB_BLANK_VSYNC_SUSPEND:
944 val |= (CRTC_DISPLAY_DIS | CRTC_VSYNC_DIS);
945 break;
946 case FB_BLANK_HSYNC_SUSPEND:
947 val |= (CRTC_DISPLAY_DIS | CRTC_HSYNC_DIS);
948 break;
949 case FB_BLANK_POWERDOWN:
950 val |= (CRTC_DISPLAY_DIS | CRTC_VSYNC_DIS |
951 CRTC_HSYNC_DIS);
952 break;
953 case FB_BLANK_NORMAL:
954 val |= CRTC_DISPLAY_DIS;
955 break;
956 case FB_BLANK_UNBLANK:
957 default:
958 unblank = 1;
959 }
960 OUTREG(CRTC_EXT_CNTL, val);
961
962
963 switch (rinfo->mon1_type) {
964 case MT_DFP:
965 if (unblank)
966 OUTREGP(FP_GEN_CNTL, (FP_FPON | FP_TMDS_EN),
967 ~(FP_FPON | FP_TMDS_EN));
968 else {
969 if (mode_switch || blank == FB_BLANK_NORMAL)
970 break;
971 OUTREGP(FP_GEN_CNTL, 0, ~(FP_FPON | FP_TMDS_EN));
972 }
973 break;
974 case MT_LCD:
975 del_timer_sync(&rinfo->lvds_timer);
976 val = INREG(LVDS_GEN_CNTL);
977 if (unblank) {
978 u32 target_val = (val & ~LVDS_DISPLAY_DIS) | LVDS_BLON | LVDS_ON
979 | LVDS_EN | (rinfo->init_state.lvds_gen_cntl
980 & (LVDS_DIGON | LVDS_BL_MOD_EN));
981 if ((val ^ target_val) == LVDS_DISPLAY_DIS)
982 OUTREG(LVDS_GEN_CNTL, target_val);
983 else if ((val ^ target_val) != 0) {
984 OUTREG(LVDS_GEN_CNTL, target_val
985 & ~(LVDS_ON | LVDS_BL_MOD_EN));
986 rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
987 rinfo->init_state.lvds_gen_cntl |=
988 target_val & LVDS_STATE_MASK;
989 if (mode_switch) {
990 radeon_msleep(rinfo->panel_info.pwr_delay);
991 OUTREG(LVDS_GEN_CNTL, target_val);
992 }
993 else {
994 rinfo->pending_lvds_gen_cntl = target_val;
995 mod_timer(&rinfo->lvds_timer,
996 jiffies +
997 msecs_to_jiffies(rinfo->panel_info.pwr_delay));
998 }
999 }
1000 } else {
1001 val |= LVDS_DISPLAY_DIS;
1002 OUTREG(LVDS_GEN_CNTL, val);
1003
1004 /* We don't do a full switch-off on a simple mode switch */
1005 if (mode_switch || blank == FB_BLANK_NORMAL)
1006 break;
1007
1008 /* Asic bug, when turning off LVDS_ON, we have to make sure
1009 * RADEON_PIXCLK_LVDS_ALWAYS_ON bit is off
1010 */
1011 tmp_pix_clks = INPLL(PIXCLKS_CNTL);
1012 if (rinfo->is_mobility || rinfo->is_IGP)
1013 OUTPLLP(PIXCLKS_CNTL, 0, ~PIXCLK_LVDS_ALWAYS_ONb);
1014 val &= ~(LVDS_BL_MOD_EN);
1015 OUTREG(LVDS_GEN_CNTL, val);
1016 udelay(100);
1017 val &= ~(LVDS_ON | LVDS_EN);
1018 OUTREG(LVDS_GEN_CNTL, val);
1019 val &= ~LVDS_DIGON;
1020 rinfo->pending_lvds_gen_cntl = val;
1021 mod_timer(&rinfo->lvds_timer,
1022 jiffies +
1023 msecs_to_jiffies(rinfo->panel_info.pwr_delay));
1024 rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
1025 rinfo->init_state.lvds_gen_cntl |= val & LVDS_STATE_MASK;
1026 if (rinfo->is_mobility || rinfo->is_IGP)
1027 OUTPLL(PIXCLKS_CNTL, tmp_pix_clks);
1028 }
1029 break;
1030 case MT_CRT:
1031 // todo: powerdown DAC
1032 default:
1033 break;
1034 }
1035
1036 return 0;
1037 }
1038
1039 static int radeonfb_blank (int blank, struct fb_info *info)
1040 {
1041 struct radeonfb_info *rinfo = info->par;
1042
1043 if (rinfo->asleep)
1044 return 0;
1045
1046 return radeon_screen_blank(rinfo, blank, 0);
1047 }
1048
1049 static int radeon_setcolreg (unsigned regno, unsigned red, unsigned green,
1050 unsigned blue, unsigned transp,
1051 struct radeonfb_info *rinfo)
1052 {
1053 u32 pindex;
1054 unsigned int i;
1055
1056
1057 if (regno > 255)
1058 return -EINVAL;
1059
1060 red >>= 8;
1061 green >>= 8;
1062 blue >>= 8;
1063 rinfo->palette[regno].red = red;
1064 rinfo->palette[regno].green = green;
1065 rinfo->palette[regno].blue = blue;
1066
1067 /* default */
1068 pindex = regno;
1069
1070 if (!rinfo->asleep) {
1071 radeon_fifo_wait(9);
1072
1073 if (rinfo->bpp == 16) {
1074 pindex = regno * 8;
1075
1076 if (rinfo->depth == 16 && regno > 63)
1077 return -EINVAL;
1078 if (rinfo->depth == 15 && regno > 31)
1079 return -EINVAL;
1080
1081 /* For 565, the green component is mixed one order
1082 * below
1083 */
1084 if (rinfo->depth == 16) {
1085 OUTREG(PALETTE_INDEX, pindex>>1);
1086 OUTREG(PALETTE_DATA,
1087 (rinfo->palette[regno>>1].red << 16) |
1088 (green << 8) |
1089 (rinfo->palette[regno>>1].blue));
1090 green = rinfo->palette[regno<<1].green;
1091 }
1092 }
1093
1094 if (rinfo->depth != 16 || regno < 32) {
1095 OUTREG(PALETTE_INDEX, pindex);
1096 OUTREG(PALETTE_DATA, (red << 16) |
1097 (green << 8) | blue);
1098 }
1099 }
1100 if (regno < 16) {
1101 u32 *pal = rinfo->info->pseudo_palette;
1102 switch (rinfo->depth) {
1103 case 15:
1104 pal[regno] = (regno << 10) | (regno << 5) | regno;
1105 break;
1106 case 16:
1107 pal[regno] = (regno << 11) | (regno << 5) | regno;
1108 break;
1109 case 24:
1110 pal[regno] = (regno << 16) | (regno << 8) | regno;
1111 break;
1112 case 32:
1113 i = (regno << 8) | regno;
1114 pal[regno] = (i << 16) | i;
1115 break;
1116 }
1117 }
1118 return 0;
1119 }
1120
1121 static int radeonfb_setcolreg (unsigned regno, unsigned red, unsigned green,
1122 unsigned blue, unsigned transp,
1123 struct fb_info *info)
1124 {
1125 struct radeonfb_info *rinfo = info->par;
1126 u32 dac_cntl2, vclk_cntl = 0;
1127 int rc;
1128
1129 if (!rinfo->asleep) {
1130 if (rinfo->is_mobility) {
1131 vclk_cntl = INPLL(VCLK_ECP_CNTL);
1132 OUTPLL(VCLK_ECP_CNTL,
1133 vclk_cntl & ~PIXCLK_DAC_ALWAYS_ONb);
1134 }
1135
1136 /* Make sure we are on first palette */
1137 if (rinfo->has_CRTC2) {
1138 dac_cntl2 = INREG(DAC_CNTL2);
1139 dac_cntl2 &= ~DAC2_PALETTE_ACCESS_CNTL;
1140 OUTREG(DAC_CNTL2, dac_cntl2);
1141 }
1142 }
1143
1144 rc = radeon_setcolreg (regno, red, green, blue, transp, rinfo);
1145
1146 if (!rinfo->asleep && rinfo->is_mobility)
1147 OUTPLL(VCLK_ECP_CNTL, vclk_cntl);
1148
1149 return rc;
1150 }
1151
1152 static int radeonfb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
1153 {
1154 struct radeonfb_info *rinfo = info->par;
1155 u16 *red, *green, *blue, *transp;
1156 u32 dac_cntl2, vclk_cntl = 0;
1157 int i, start, rc = 0;
1158
1159 if (!rinfo->asleep) {
1160 if (rinfo->is_mobility) {
1161 vclk_cntl = INPLL(VCLK_ECP_CNTL);
1162 OUTPLL(VCLK_ECP_CNTL,
1163 vclk_cntl & ~PIXCLK_DAC_ALWAYS_ONb);
1164 }
1165
1166 /* Make sure we are on first palette */
1167 if (rinfo->has_CRTC2) {
1168 dac_cntl2 = INREG(DAC_CNTL2);
1169 dac_cntl2 &= ~DAC2_PALETTE_ACCESS_CNTL;
1170 OUTREG(DAC_CNTL2, dac_cntl2);
1171 }
1172 }
1173
1174 red = cmap->red;
1175 green = cmap->green;
1176 blue = cmap->blue;
1177 transp = cmap->transp;
1178 start = cmap->start;
1179
1180 for (i = 0; i < cmap->len; i++) {
1181 u_int hred, hgreen, hblue, htransp = 0xffff;
1182
1183 hred = *red++;
1184 hgreen = *green++;
1185 hblue = *blue++;
1186 if (transp)
1187 htransp = *transp++;
1188 rc = radeon_setcolreg (start++, hred, hgreen, hblue, htransp,
1189 rinfo);
1190 if (rc)
1191 break;
1192 }
1193
1194 if (!rinfo->asleep && rinfo->is_mobility)
1195 OUTPLL(VCLK_ECP_CNTL, vclk_cntl);
1196
1197 return rc;
1198 }
1199
1200 static void radeon_save_state (struct radeonfb_info *rinfo,
1201 struct radeon_regs *save)
1202 {
1203 /* CRTC regs */
1204 save->crtc_gen_cntl = INREG(CRTC_GEN_CNTL);
1205 save->crtc_ext_cntl = INREG(CRTC_EXT_CNTL);
1206 save->crtc_more_cntl = INREG(CRTC_MORE_CNTL);
1207 save->dac_cntl = INREG(DAC_CNTL);
1208 save->crtc_h_total_disp = INREG(CRTC_H_TOTAL_DISP);
1209 save->crtc_h_sync_strt_wid = INREG(CRTC_H_SYNC_STRT_WID);
1210 save->crtc_v_total_disp = INREG(CRTC_V_TOTAL_DISP);
1211 save->crtc_v_sync_strt_wid = INREG(CRTC_V_SYNC_STRT_WID);
1212 save->crtc_pitch = INREG(CRTC_PITCH);
1213 save->surface_cntl = INREG(SURFACE_CNTL);
1214
1215 /* FP regs */
1216 save->fp_crtc_h_total_disp = INREG(FP_CRTC_H_TOTAL_DISP);
1217 save->fp_crtc_v_total_disp = INREG(FP_CRTC_V_TOTAL_DISP);
1218 save->fp_gen_cntl = INREG(FP_GEN_CNTL);
1219 save->fp_h_sync_strt_wid = INREG(FP_H_SYNC_STRT_WID);
1220 save->fp_horz_stretch = INREG(FP_HORZ_STRETCH);
1221 save->fp_v_sync_strt_wid = INREG(FP_V_SYNC_STRT_WID);
1222 save->fp_vert_stretch = INREG(FP_VERT_STRETCH);
1223 save->lvds_gen_cntl = INREG(LVDS_GEN_CNTL);
1224 save->lvds_pll_cntl = INREG(LVDS_PLL_CNTL);
1225 save->tmds_crc = INREG(TMDS_CRC);
1226 save->tmds_transmitter_cntl = INREG(TMDS_TRANSMITTER_CNTL);
1227 save->vclk_ecp_cntl = INPLL(VCLK_ECP_CNTL);
1228
1229 /* PLL regs */
1230 save->clk_cntl_index = INREG(CLOCK_CNTL_INDEX) & ~0x3f;
1231 radeon_pll_errata_after_index(rinfo);
1232 save->ppll_div_3 = INPLL(PPLL_DIV_3);
1233 save->ppll_ref_div = INPLL(PPLL_REF_DIV);
1234 }
1235
1236
1237 static void radeon_write_pll_regs(struct radeonfb_info *rinfo, struct radeon_regs *mode)
1238 {
1239 int i;
1240
1241 radeon_fifo_wait(20);
1242
1243 /* Workaround from XFree */
1244 if (rinfo->is_mobility) {
1245 /* A temporal workaround for the occational blanking on certain laptop
1246 * panels. This appears to related to the PLL divider registers
1247 * (fail to lock?). It occurs even when all dividers are the same
1248 * with their old settings. In this case we really don't need to
1249 * fiddle with PLL registers. By doing this we can avoid the blanking
1250 * problem with some panels.
1251 */
1252 if ((mode->ppll_ref_div == (INPLL(PPLL_REF_DIV) & PPLL_REF_DIV_MASK)) &&
1253 (mode->ppll_div_3 == (INPLL(PPLL_DIV_3) &
1254 (PPLL_POST3_DIV_MASK | PPLL_FB3_DIV_MASK)))) {
1255 /* We still have to force a switch to selected PPLL div thanks to
1256 * an XFree86 driver bug which will switch it away in some cases
1257 * even when using UseFDev */
1258 OUTREGP(CLOCK_CNTL_INDEX,
1259 mode->clk_cntl_index & PPLL_DIV_SEL_MASK,
1260 ~PPLL_DIV_SEL_MASK);
1261 radeon_pll_errata_after_index(rinfo);
1262 radeon_pll_errata_after_data(rinfo);
1263 return;
1264 }
1265 }
1266
1267 /* Swich VCKL clock input to CPUCLK so it stays fed while PPLL updates*/
1268 OUTPLLP(VCLK_ECP_CNTL, VCLK_SRC_SEL_CPUCLK, ~VCLK_SRC_SEL_MASK);
1269
1270 /* Reset PPLL & enable atomic update */
1271 OUTPLLP(PPLL_CNTL,
1272 PPLL_RESET | PPLL_ATOMIC_UPDATE_EN | PPLL_VGA_ATOMIC_UPDATE_EN,
1273 ~(PPLL_RESET | PPLL_ATOMIC_UPDATE_EN | PPLL_VGA_ATOMIC_UPDATE_EN));
1274
1275 /* Switch to selected PPLL divider */
1276 OUTREGP(CLOCK_CNTL_INDEX,
1277 mode->clk_cntl_index & PPLL_DIV_SEL_MASK,
1278 ~PPLL_DIV_SEL_MASK);
1279 radeon_pll_errata_after_index(rinfo);
1280 radeon_pll_errata_after_data(rinfo);
1281
1282 /* Set PPLL ref. div */
1283 if (rinfo->family == CHIP_FAMILY_R300 ||
1284 rinfo->family == CHIP_FAMILY_RS300 ||
1285 rinfo->family == CHIP_FAMILY_R350 ||
1286 rinfo->family == CHIP_FAMILY_RV350) {
1287 if (mode->ppll_ref_div & R300_PPLL_REF_DIV_ACC_MASK) {
1288 /* When restoring console mode, use saved PPLL_REF_DIV
1289 * setting.
1290 */
1291 OUTPLLP(PPLL_REF_DIV, mode->ppll_ref_div, 0);
1292 } else {
1293 /* R300 uses ref_div_acc field as real ref divider */
1294 OUTPLLP(PPLL_REF_DIV,
1295 (mode->ppll_ref_div << R300_PPLL_REF_DIV_ACC_SHIFT),
1296 ~R300_PPLL_REF_DIV_ACC_MASK);
1297 }
1298 } else
1299 OUTPLLP(PPLL_REF_DIV, mode->ppll_ref_div, ~PPLL_REF_DIV_MASK);
1300
1301 /* Set PPLL divider 3 & post divider*/
1302 OUTPLLP(PPLL_DIV_3, mode->ppll_div_3, ~PPLL_FB3_DIV_MASK);
1303 OUTPLLP(PPLL_DIV_3, mode->ppll_div_3, ~PPLL_POST3_DIV_MASK);
1304
1305 /* Write update */
1306 while (INPLL(PPLL_REF_DIV) & PPLL_ATOMIC_UPDATE_R)
1307 ;
1308 OUTPLLP(PPLL_REF_DIV, PPLL_ATOMIC_UPDATE_W, ~PPLL_ATOMIC_UPDATE_W);
1309
1310 /* Wait read update complete */
1311 /* FIXME: Certain revisions of R300 can't recover here. Not sure of
1312 the cause yet, but this workaround will mask the problem for now.
1313 Other chips usually will pass at the very first test, so the
1314 workaround shouldn't have any effect on them. */
1315 for (i = 0; (i < 10000 && INPLL(PPLL_REF_DIV) & PPLL_ATOMIC_UPDATE_R); i++)
1316 ;
1317
1318 OUTPLL(HTOTAL_CNTL, 0);
1319
1320 /* Clear reset & atomic update */
1321 OUTPLLP(PPLL_CNTL, 0,
1322 ~(PPLL_RESET | PPLL_SLEEP | PPLL_ATOMIC_UPDATE_EN | PPLL_VGA_ATOMIC_UPDATE_EN));
1323
1324 /* We may want some locking ... oh well */
1325 radeon_msleep(5);
1326
1327 /* Switch back VCLK source to PPLL */
1328 OUTPLLP(VCLK_ECP_CNTL, VCLK_SRC_SEL_PPLLCLK, ~VCLK_SRC_SEL_MASK);
1329 }
1330
1331 /*
1332 * Timer function for delayed LVDS panel power up/down
1333 */
1334 static void radeon_lvds_timer_func(unsigned long data)
1335 {
1336 struct radeonfb_info *rinfo = (struct radeonfb_info *)data;
1337
1338 radeon_engine_idle();
1339
1340 OUTREG(LVDS_GEN_CNTL, rinfo->pending_lvds_gen_cntl);
1341 }
1342
1343 /*
1344 * Apply a video mode. This will apply the whole register set, including
1345 * the PLL registers, to the card
1346 */
1347 void radeon_write_mode (struct radeonfb_info *rinfo, struct radeon_regs *mode,
1348 int regs_only)
1349 {
1350 int i;
1351 int primary_mon = PRIMARY_MONITOR(rinfo);
1352
1353 if (nomodeset)
1354 return;
1355
1356 if (!regs_only)
1357 radeon_screen_blank(rinfo, FB_BLANK_NORMAL, 0);
1358
1359 radeon_fifo_wait(31);
1360 for (i=0; i<10; i++)
1361 OUTREG(common_regs[i].reg, common_regs[i].val);
1362
1363 /* Apply surface registers */
1364 for (i=0; i<8; i++) {
1365 OUTREG(SURFACE0_LOWER_BOUND + 0x10*i, mode->surf_lower_bound[i]);
1366 OUTREG(SURFACE0_UPPER_BOUND + 0x10*i, mode->surf_upper_bound[i]);
1367 OUTREG(SURFACE0_INFO + 0x10*i, mode->surf_info[i]);
1368 }
1369
1370 OUTREG(CRTC_GEN_CNTL, mode->crtc_gen_cntl);
1371 OUTREGP(CRTC_EXT_CNTL, mode->crtc_ext_cntl,
1372 ~(CRTC_HSYNC_DIS | CRTC_VSYNC_DIS | CRTC_DISPLAY_DIS));
1373 OUTREG(CRTC_MORE_CNTL, mode->crtc_more_cntl);
1374 OUTREGP(DAC_CNTL, mode->dac_cntl, DAC_RANGE_CNTL | DAC_BLANKING);
1375 OUTREG(CRTC_H_TOTAL_DISP, mode->crtc_h_total_disp);
1376 OUTREG(CRTC_H_SYNC_STRT_WID, mode->crtc_h_sync_strt_wid);
1377 OUTREG(CRTC_V_TOTAL_DISP, mode->crtc_v_total_disp);
1378 OUTREG(CRTC_V_SYNC_STRT_WID, mode->crtc_v_sync_strt_wid);
1379 OUTREG(CRTC_OFFSET, 0);
1380 OUTREG(CRTC_OFFSET_CNTL, 0);
1381 OUTREG(CRTC_PITCH, mode->crtc_pitch);
1382 OUTREG(SURFACE_CNTL, mode->surface_cntl);
1383
1384 radeon_write_pll_regs(rinfo, mode);
1385
1386 if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD)) {
1387 radeon_fifo_wait(10);
1388 OUTREG(FP_CRTC_H_TOTAL_DISP, mode->fp_crtc_h_total_disp);
1389 OUTREG(FP_CRTC_V_TOTAL_DISP, mode->fp_crtc_v_total_disp);
1390 OUTREG(FP_H_SYNC_STRT_WID, mode->fp_h_sync_strt_wid);
1391 OUTREG(FP_V_SYNC_STRT_WID, mode->fp_v_sync_strt_wid);
1392 OUTREG(FP_HORZ_STRETCH, mode->fp_horz_stretch);
1393 OUTREG(FP_VERT_STRETCH, mode->fp_vert_stretch);
1394 OUTREG(FP_GEN_CNTL, mode->fp_gen_cntl);
1395 OUTREG(TMDS_CRC, mode->tmds_crc);
1396 OUTREG(TMDS_TRANSMITTER_CNTL, mode->tmds_transmitter_cntl);
1397 }
1398
1399 if (!regs_only)
1400 radeon_screen_blank(rinfo, FB_BLANK_UNBLANK, 0);
1401
1402 radeon_fifo_wait(2);
1403 OUTPLL(VCLK_ECP_CNTL, mode->vclk_ecp_cntl);
1404
1405 return;
1406 }
1407
1408 /*
1409 * Calculate the PLL values for a given mode
1410 */
1411 static void radeon_calc_pll_regs(struct radeonfb_info *rinfo, struct radeon_regs *regs,
1412 unsigned long freq)
1413 {
1414 const struct {
1415 int divider;
1416 int bitvalue;
1417 } *post_div,
1418 post_divs[] = {
1419 { 1, 0 },
1420 { 2, 1 },
1421 { 4, 2 },
1422 { 8, 3 },
1423 { 3, 4 },
1424 { 16, 5 },
1425 { 6, 6 },
1426 { 12, 7 },
1427 { 0, 0 },
1428 };
1429 int fb_div, pll_output_freq = 0;
1430 int uses_dvo = 0;
1431
1432 /* Check if the DVO port is enabled and sourced from the primary CRTC. I'm
1433 * not sure which model starts having FP2_GEN_CNTL, I assume anything more
1434 * recent than an r(v)100...
1435 */
1436 #if 1
1437 /* XXX I had reports of flicker happening with the cinema display
1438 * on TMDS1 that seem to be fixed if I also forbit odd dividers in
1439 * this case. This could just be a bandwidth calculation issue, I
1440 * haven't implemented the bandwidth code yet, but in the meantime,
1441 * forcing uses_dvo to 1 fixes it and shouln't have bad side effects,
1442 * I haven't seen a case were were absolutely needed an odd PLL
1443 * divider. I'll find a better fix once I have more infos on the
1444 * real cause of the problem.
1445 */
1446 while (rinfo->has_CRTC2) {
1447 u32 fp2_gen_cntl = INREG(FP2_GEN_CNTL);
1448 u32 disp_output_cntl;
1449 int source;
1450
1451 /* FP2 path not enabled */
1452 if ((fp2_gen_cntl & FP2_ON) == 0)
1453 break;
1454 /* Not all chip revs have the same format for this register,
1455 * extract the source selection
1456 */
1457 if (rinfo->family == CHIP_FAMILY_R200 ||
1458 rinfo->family == CHIP_FAMILY_R300 ||
1459 rinfo->family == CHIP_FAMILY_R350 ||
1460 rinfo->family == CHIP_FAMILY_RV350) {
1461 source = (fp2_gen_cntl >> 10) & 0x3;
1462 /* sourced from transform unit, check for transform unit
1463 * own source
1464 */
1465 if (source == 3) {
1466 disp_output_cntl = INREG(DISP_OUTPUT_CNTL);
1467 source = (disp_output_cntl >> 12) & 0x3;
1468 }
1469 } else
1470 source = (fp2_gen_cntl >> 13) & 0x1;
1471 /* sourced from CRTC2 -> exit */
1472 if (source == 1)
1473 break;
1474
1475 /* so we end up on CRTC1, let's set uses_dvo to 1 now */
1476 uses_dvo = 1;
1477 break;
1478 }
1479 #else
1480 uses_dvo = 1;
1481 #endif
1482 if (freq > rinfo->pll.ppll_max)
1483 freq = rinfo->pll.ppll_max;
1484 if (freq*12 < rinfo->pll.ppll_min)
1485 freq = rinfo->pll.ppll_min / 12;
1486 RTRACE("freq = %lu, PLL min = %u, PLL max = %u\n",
1487 freq, rinfo->pll.ppll_min, rinfo->pll.ppll_max);
1488
1489 for (post_div = &post_divs[0]; post_div->divider; ++post_div) {
1490 pll_output_freq = post_div->divider * freq;
1491 /* If we output to the DVO port (external TMDS), we don't allow an
1492 * odd PLL divider as those aren't supported on this path
1493 */
1494 if (uses_dvo && (post_div->divider & 1))
1495 continue;
1496 if (pll_output_freq >= rinfo->pll.ppll_min &&
1497 pll_output_freq <= rinfo->pll.ppll_max)
1498 break;
1499 }
1500
1501 /* If we fall through the bottom, try the "default value"
1502 given by the terminal post_div->bitvalue */
1503 if ( !post_div->divider ) {
1504 post_div = &post_divs[post_div->bitvalue];
1505 pll_output_freq = post_div->divider * freq;
1506 }
1507 RTRACE("ref_div = %d, ref_clk = %d, output_freq = %d\n",
1508 rinfo->pll.ref_div, rinfo->pll.ref_clk,
1509 pll_output_freq);
1510
1511 /* If we fall through the bottom, try the "default value"
1512 given by the terminal post_div->bitvalue */
1513 if ( !post_div->divider ) {
1514 post_div = &post_divs[post_div->bitvalue];
1515 pll_output_freq = post_div->divider * freq;
1516 }
1517 RTRACE("ref_div = %d, ref_clk = %d, output_freq = %d\n",
1518 rinfo->pll.ref_div, rinfo->pll.ref_clk,
1519 pll_output_freq);
1520
1521 fb_div = round_div(rinfo->pll.ref_div*pll_output_freq,
1522 rinfo->pll.ref_clk);
1523 regs->ppll_ref_div = rinfo->pll.ref_div;
1524 regs->ppll_div_3 = fb_div | (post_div->bitvalue << 16);
1525
1526 RTRACE("post div = 0x%x\n", post_div->bitvalue);
1527 RTRACE("fb_div = 0x%x\n", fb_div);
1528 RTRACE("ppll_div_3 = 0x%x\n", regs->ppll_div_3);
1529 }
1530
1531 static int radeonfb_set_par(struct fb_info *info)
1532 {
1533 struct radeonfb_info *rinfo = info->par;
1534 struct fb_var_screeninfo *mode = &info->var;
1535 struct radeon_regs *newmode;
1536 int hTotal, vTotal, hSyncStart, hSyncEnd,
1537 hSyncPol, vSyncStart, vSyncEnd, vSyncPol, cSync;
1538 u8 hsync_adj_tab[] = {0, 0x12, 9, 9, 6, 5};
1539 u8 hsync_fudge_fp[] = {2, 2, 0, 0, 5, 5};
1540 u32 sync, h_sync_pol, v_sync_pol, dotClock, pixClock;
1541 int i, freq;
1542 int format = 0;
1543 int nopllcalc = 0;
1544 int hsync_start, hsync_fudge, bytpp, hsync_wid, vsync_wid;
1545 int primary_mon = PRIMARY_MONITOR(rinfo);
1546 int depth = var_to_depth(mode);
1547 int use_rmx = 0;
1548
1549 newmode = kmalloc(sizeof(struct radeon_regs), GFP_KERNEL);
1550 if (!newmode)
1551 return -ENOMEM;
1552
1553 /* We always want engine to be idle on a mode switch, even
1554 * if we won't actually change the mode
1555 */
1556 radeon_engine_idle();
1557
1558 hSyncStart = mode->xres + mode->right_margin;
1559 hSyncEnd = hSyncStart + mode->hsync_len;
1560 hTotal = hSyncEnd + mode->left_margin;
1561
1562 vSyncStart = mode->yres + mode->lower_margin;
1563 vSyncEnd = vSyncStart + mode->vsync_len;
1564 vTotal = vSyncEnd + mode->upper_margin;
1565 pixClock = mode->pixclock;
1566
1567 sync = mode->sync;
1568 h_sync_pol = sync & FB_SYNC_HOR_HIGH_ACT ? 0 : 1;
1569 v_sync_pol = sync & FB_SYNC_VERT_HIGH_ACT ? 0 : 1;
1570
1571 if (primary_mon == MT_DFP || primary_mon == MT_LCD) {
1572 if (rinfo->panel_info.xres < mode->xres)
1573 mode->xres = rinfo->panel_info.xres;
1574 if (rinfo->panel_info.yres < mode->yres)
1575 mode->yres = rinfo->panel_info.yres;
1576
1577 hTotal = mode->xres + rinfo->panel_info.hblank;
1578 hSyncStart = mode->xres + rinfo->panel_info.hOver_plus;
1579 hSyncEnd = hSyncStart + rinfo->panel_info.hSync_width;
1580
1581 vTotal = mode->yres + rinfo->panel_info.vblank;
1582 vSyncStart = mode->yres + rinfo->panel_info.vOver_plus;
1583 vSyncEnd = vSyncStart + rinfo->panel_info.vSync_width;
1584
1585 h_sync_pol = !rinfo->panel_info.hAct_high;
1586 v_sync_pol = !rinfo->panel_info.vAct_high;
1587
1588 pixClock = 100000000 / rinfo->panel_info.clock;
1589
1590 if (rinfo->panel_info.use_bios_dividers) {
1591 nopllcalc = 1;
1592 newmode->ppll_div_3 = rinfo->panel_info.fbk_divider |
1593 (rinfo->panel_info.post_divider << 16);
1594 newmode->ppll_ref_div = rinfo->panel_info.ref_divider;
1595 }
1596 }
1597 dotClock = 1000000000 / pixClock;
1598 freq = dotClock / 10; /* x100 */
1599
1600 RTRACE("hStart = %d, hEnd = %d, hTotal = %d\n",
1601 hSyncStart, hSyncEnd, hTotal);
1602 RTRACE("vStart = %d, vEnd = %d, vTotal = %d\n",
1603 vSyncStart, vSyncEnd, vTotal);
1604
1605 hsync_wid = (hSyncEnd - hSyncStart) / 8;
1606 vsync_wid = vSyncEnd - vSyncStart;
1607 if (hsync_wid == 0)
1608 hsync_wid = 1;
1609 else if (hsync_wid > 0x3f) /* max */
1610 hsync_wid = 0x3f;
1611
1612 if (vsync_wid == 0)
1613 vsync_wid = 1;
1614 else if (vsync_wid > 0x1f) /* max */
1615 vsync_wid = 0x1f;
1616
1617 hSyncPol = mode->sync & FB_SYNC_HOR_HIGH_ACT ? 0 : 1;
1618 vSyncPol = mode->sync & FB_SYNC_VERT_HIGH_ACT ? 0 : 1;
1619
1620 cSync = mode->sync & FB_SYNC_COMP_HIGH_ACT ? (1 << 4) : 0;
1621
1622 format = radeon_get_dstbpp(depth);
1623 bytpp = mode->bits_per_pixel >> 3;
1624
1625 if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD))
1626 hsync_fudge = hsync_fudge_fp[format-1];
1627 else
1628 hsync_fudge = hsync_adj_tab[format-1];
1629
1630 hsync_start = hSyncStart - 8 + hsync_fudge;
1631
1632 newmode->crtc_gen_cntl = CRTC_EXT_DISP_EN | CRTC_EN |
1633 (format << 8);
1634
1635 /* Clear auto-center etc... */
1636 newmode->crtc_more_cntl = rinfo->init_state.crtc_more_cntl;
1637 newmode->crtc_more_cntl &= 0xfffffff0;
1638
1639 if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD)) {
1640 newmode->crtc_ext_cntl = VGA_ATI_LINEAR | XCRT_CNT_EN;
1641 if (mirror)
1642 newmode->crtc_ext_cntl |= CRTC_CRT_ON;
1643
1644 newmode->crtc_gen_cntl &= ~(CRTC_DBL_SCAN_EN |
1645 CRTC_INTERLACE_EN);
1646 } else {
1647 newmode->crtc_ext_cntl = VGA_ATI_LINEAR | XCRT_CNT_EN |
1648 CRTC_CRT_ON;
1649 }
1650
1651 newmode->dac_cntl = /* INREG(DAC_CNTL) | */ DAC_MASK_ALL | DAC_VGA_ADR_EN |
1652 DAC_8BIT_EN;
1653
1654 newmode->crtc_h_total_disp = ((((hTotal / 8) - 1) & 0x3ff) |
1655 (((mode->xres / 8) - 1) << 16));
1656
1657 newmode->crtc_h_sync_strt_wid = ((hsync_start & 0x1fff) |
1658 (hsync_wid << 16) | (h_sync_pol << 23));
1659
1660 newmode->crtc_v_total_disp = ((vTotal - 1) & 0xffff) |
1661 ((mode->yres - 1) << 16);
1662
1663 newmode->crtc_v_sync_strt_wid = (((vSyncStart - 1) & 0xfff) |
1664 (vsync_wid << 16) | (v_sync_pol << 23));
1665
1666 if (!(info->flags & FBINFO_HWACCEL_DISABLED)) {
1667 /* We first calculate the engine pitch */
1668 rinfo->pitch = ((mode->xres_virtual * ((mode->bits_per_pixel + 1) / 8) + 0x3f)
1669 & ~(0x3f)) >> 6;
1670
1671 /* Then, re-multiply it to get the CRTC pitch */
1672 newmode->crtc_pitch = (rinfo->pitch << 3) / ((mode->bits_per_pixel + 1) / 8);
1673 } else
1674 newmode->crtc_pitch = (mode->xres_virtual >> 3);
1675
1676 newmode->crtc_pitch |= (newmode->crtc_pitch << 16);
1677
1678 /*
1679 * It looks like recent chips have a problem with SURFACE_CNTL,
1680 * setting SURF_TRANSLATION_DIS completely disables the
1681 * swapper as well, so we leave it unset now.
1682 */
1683 newmode->surface_cntl = 0;
1684
1685 #if defined(__BIG_ENDIAN)
1686
1687 /* Setup swapping on both apertures, though we currently
1688 * only use aperture 0, enabling swapper on aperture 1
1689 * won't harm
1690 */
1691 switch (mode->bits_per_pixel) {
1692 case 16:
1693 newmode->surface_cntl |= NONSURF_AP0_SWP_16BPP;
1694 newmode->surface_cntl |= NONSURF_AP1_SWP_16BPP;
1695 break;
1696 case 24:
1697 case 32:
1698 newmode->surface_cntl |= NONSURF_AP0_SWP_32BPP;
1699 newmode->surface_cntl |= NONSURF_AP1_SWP_32BPP;
1700 break;
1701 }
1702 #endif
1703
1704 /* Clear surface registers */
1705 for (i=0; i<8; i++) {
1706 newmode->surf_lower_bound[i] = 0;
1707 newmode->surf_upper_bound[i] = 0x1f;
1708 newmode->surf_info[i] = 0;
1709 }
1710
1711 RTRACE("h_total_disp = 0x%x\t hsync_strt_wid = 0x%x\n",
1712 newmode->crtc_h_total_disp, newmode->crtc_h_sync_strt_wid);
1713 RTRACE("v_total_disp = 0x%x\t vsync_strt_wid = 0x%x\n",
1714 newmode->crtc_v_total_disp, newmode->crtc_v_sync_strt_wid);
1715
1716 rinfo->bpp = mode->bits_per_pixel;
1717 rinfo->depth = depth;
1718
1719 RTRACE("pixclock = %lu\n", (unsigned long)pixClock);
1720 RTRACE("freq = %lu\n", (unsigned long)freq);
1721
1722 /* We use PPLL_DIV_3 */
1723 newmode->clk_cntl_index = 0x300;
1724
1725 /* Calculate PPLL value if necessary */
1726 if (!nopllcalc)
1727 radeon_calc_pll_regs(rinfo, newmode, freq);
1728
1729 newmode->vclk_ecp_cntl = rinfo->init_state.vclk_ecp_cntl;
1730
1731 if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD)) {
1732 unsigned int hRatio, vRatio;
1733
1734 if (mode->xres > rinfo->panel_info.xres)
1735 mode->xres = rinfo->panel_info.xres;
1736 if (mode->yres > rinfo->panel_info.yres)
1737 mode->yres = rinfo->panel_info.yres;
1738
1739 newmode->fp_horz_stretch = (((rinfo->panel_info.xres / 8) - 1)
1740 << HORZ_PANEL_SHIFT);
1741 newmode->fp_vert_stretch = ((rinfo->panel_info.yres - 1)
1742 << VERT_PANEL_SHIFT);
1743
1744 if (mode->xres != rinfo->panel_info.xres) {
1745 hRatio = round_div(mode->xres * HORZ_STRETCH_RATIO_MAX,
1746 rinfo->panel_info.xres);
1747 newmode->fp_horz_stretch = (((((unsigned long)hRatio) & HORZ_STRETCH_RATIO_MASK)) |
1748 (newmode->fp_horz_stretch &
1749 (HORZ_PANEL_SIZE | HORZ_FP_LOOP_STRETCH |
1750 HORZ_AUTO_RATIO_INC)));
1751 newmode->fp_horz_stretch |= (HORZ_STRETCH_BLEND |
1752 HORZ_STRETCH_ENABLE);
1753 use_rmx = 1;
1754 }
1755 newmode->fp_horz_stretch &= ~HORZ_AUTO_RATIO;
1756
1757 if (mode->yres != rinfo->panel_info.yres) {
1758 vRatio = round_div(mode->yres * VERT_STRETCH_RATIO_MAX,
1759 rinfo->panel_info.yres);
1760 newmode->fp_vert_stretch = (((((unsigned long)vRatio) & VERT_STRETCH_RATIO_MASK)) |
1761 (newmode->fp_vert_stretch &
1762 (VERT_PANEL_SIZE | VERT_STRETCH_RESERVED)));
1763 newmode->fp_vert_stretch |= (VERT_STRETCH_BLEND |
1764 VERT_STRETCH_ENABLE);
1765 use_rmx = 1;
1766 }
1767 newmode->fp_vert_stretch &= ~VERT_AUTO_RATIO_EN;
1768
1769 newmode->fp_gen_cntl = (rinfo->init_state.fp_gen_cntl & (u32)
1770 ~(FP_SEL_CRTC2 |
1771 FP_RMX_HVSYNC_CONTROL_EN |
1772 FP_DFP_SYNC_SEL |
1773 FP_CRT_SYNC_SEL |
1774 FP_CRTC_LOCK_8DOT |
1775 FP_USE_SHADOW_EN |
1776 FP_CRTC_USE_SHADOW_VEND |
1777 FP_CRT_SYNC_ALT));
1778
1779 newmode->fp_gen_cntl |= (FP_CRTC_DONT_SHADOW_VPAR |
1780 FP_CRTC_DONT_SHADOW_HEND |
1781 FP_PANEL_FORMAT);
1782
1783 if (IS_R300_VARIANT(rinfo) ||
1784 (rinfo->family == CHIP_FAMILY_R200)) {
1785 newmode->fp_gen_cntl &= ~R200_FP_SOURCE_SEL_MASK;
1786 if (use_rmx)
1787 newmode->fp_gen_cntl |= R200_FP_SOURCE_SEL_RMX;
1788 else
1789 newmode->fp_gen_cntl |= R200_FP_SOURCE_SEL_CRTC1;
1790 } else
1791 newmode->fp_gen_cntl |= FP_SEL_CRTC1;
1792
1793 newmode->lvds_gen_cntl = rinfo->init_state.lvds_gen_cntl;
1794 newmode->lvds_pll_cntl = rinfo->init_state.lvds_pll_cntl;
1795 newmode->tmds_crc = rinfo->init_state.tmds_crc;
1796 newmode->tmds_transmitter_cntl = rinfo->init_state.tmds_transmitter_cntl;
1797
1798 if (primary_mon == MT_LCD) {
1799 newmode->lvds_gen_cntl |= (LVDS_ON | LVDS_BLON);
1800 newmode->fp_gen_cntl &= ~(FP_FPON | FP_TMDS_EN);
1801 } else {
1802 /* DFP */
1803 newmode->fp_gen_cntl |= (FP_FPON | FP_TMDS_EN);
1804 newmode->tmds_transmitter_cntl &= ~(TMDS_PLLRST);
1805 /* TMDS_PLL_EN bit is reversed on RV (and mobility) chips */
1806 if (IS_R300_VARIANT(rinfo) ||
1807 (rinfo->family == CHIP_FAMILY_R200) || !rinfo->has_CRTC2)
1808 newmode->tmds_transmitter_cntl &= ~TMDS_PLL_EN;
1809 else
1810 newmode->tmds_transmitter_cntl |= TMDS_PLL_EN;
1811 newmode->crtc_ext_cntl &= ~CRTC_CRT_ON;
1812 }
1813
1814 newmode->fp_crtc_h_total_disp = (((rinfo->panel_info.hblank / 8) & 0x3ff) |
1815 (((mode->xres / 8) - 1) << 16));
1816 newmode->fp_crtc_v_total_disp = (rinfo->panel_info.vblank & 0xffff) |
1817 ((mode->yres - 1) << 16);
1818 newmode->fp_h_sync_strt_wid = ((rinfo->panel_info.hOver_plus & 0x1fff) |
1819 (hsync_wid << 16) | (h_sync_pol << 23));
1820 newmode->fp_v_sync_strt_wid = ((rinfo->panel_info.vOver_plus & 0xfff) |
1821 (vsync_wid << 16) | (v_sync_pol << 23));
1822 }
1823
1824 /* do it! */
1825 if (!rinfo->asleep) {
1826 memcpy(&rinfo->state, newmode, sizeof(*newmode));
1827 radeon_write_mode (rinfo, newmode, 0);
1828 /* (re)initialize the engine */
1829 if (!(info->flags & FBINFO_HWACCEL_DISABLED))
1830 radeonfb_engine_init (rinfo);
1831 }
1832 /* Update fix */
1833 if (!(info->flags & FBINFO_HWACCEL_DISABLED))
1834 info->fix.line_length = rinfo->pitch*64;
1835 else
1836 info->fix.line_length = mode->xres_virtual
1837 * ((mode->bits_per_pixel + 1) / 8);
1838 info->fix.visual = rinfo->depth == 8 ? FB_VISUAL_PSEUDOCOLOR
1839 : FB_VISUAL_DIRECTCOLOR;
1840
1841 #ifdef CONFIG_BOOTX_TEXT
1842 /* Update debug text engine */
1843 btext_update_display(rinfo->fb_base_phys, mode->xres, mode->yres,
1844 rinfo->depth, info->fix.line_length);
1845 #endif
1846
1847 kfree(newmode);
1848 return 0;
1849 }
1850
1851
1852 static struct fb_ops radeonfb_ops = {
1853 .owner = THIS_MODULE,
1854 .fb_check_var = radeonfb_check_var,
1855 .fb_set_par = radeonfb_set_par,
1856 .fb_setcolreg = radeonfb_setcolreg,
1857 .fb_setcmap = radeonfb_setcmap,
1858 .fb_pan_display = radeonfb_pan_display,
1859 .fb_blank = radeonfb_blank,
1860 .fb_ioctl = radeonfb_ioctl,
1861 .fb_sync = radeonfb_sync,
1862 .fb_fillrect = radeonfb_fillrect,
1863 .fb_copyarea = radeonfb_copyarea,
1864 .fb_imageblit = radeonfb_imageblit,
1865 };
1866
1867
1868 static int __devinit radeon_set_fbinfo (struct radeonfb_info *rinfo)
1869 {
1870 struct fb_info *info = rinfo->info;
1871
1872 info->par = rinfo;
1873 info->pseudo_palette = rinfo->pseudo_palette;
1874 info->flags = FBINFO_DEFAULT
1875 | FBINFO_HWACCEL_COPYAREA
1876 | FBINFO_HWACCEL_FILLRECT
1877 | FBINFO_HWACCEL_XPAN
1878 | FBINFO_HWACCEL_YPAN;
1879 info->fbops = &radeonfb_ops;
1880 info->screen_base = rinfo->fb_base;
1881 info->screen_size = rinfo->mapped_vram;
1882 /* Fill fix common fields */
1883 strlcpy(info->fix.id, rinfo->name, sizeof(info->fix.id));
1884 info->fix.smem_start = rinfo->fb_base_phys;
1885 info->fix.smem_len = rinfo->video_ram;
1886 info->fix.type = FB_TYPE_PACKED_PIXELS;
1887 info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
1888 info->fix.xpanstep = 8;
1889 info->fix.ypanstep = 1;
1890 info->fix.ywrapstep = 0;
1891 info->fix.type_aux = 0;
1892 info->fix.mmio_start = rinfo->mmio_base_phys;
1893 info->fix.mmio_len = RADEON_REGSIZE;
1894 info->fix.accel = FB_ACCEL_ATI_RADEON;
1895
1896 fb_alloc_cmap(&info->cmap, 256, 0);
1897
1898 if (noaccel)
1899 info->flags |= FBINFO_HWACCEL_DISABLED;
1900
1901 return 0;
1902 }
1903
1904 /*
1905 * This reconfigure the card's internal memory map. In theory, we'd like
1906 * to setup the card's memory at the same address as it's PCI bus address,
1907 * and the AGP aperture right after that so that system RAM on 32 bits
1908 * machines at least, is directly accessible. However, doing so would
1909 * conflict with the current XFree drivers...
1910 * Ultimately, I hope XFree, GATOS and ATI binary drivers will all agree
1911 * on the proper way to set this up and duplicate this here. In the meantime,
1912 * I put the card's memory at 0 in card space and AGP at some random high
1913 * local (0xe0000000 for now) that will be changed by XFree/DRI anyway
1914 */
1915 #ifdef CONFIG_PPC_OF
1916 #undef SET_MC_FB_FROM_APERTURE
1917 static void fixup_memory_mappings(struct radeonfb_info *rinfo)
1918 {
1919 u32 save_crtc_gen_cntl, save_crtc2_gen_cntl = 0;
1920 u32 save_crtc_ext_cntl;
1921 u32 aper_base, aper_size;
1922 u32 agp_base;
1923
1924 /* First, we disable display to avoid interfering */
1925 if (rinfo->has_CRTC2) {
1926 save_crtc2_gen_cntl = INREG(CRTC2_GEN_CNTL);
1927 OUTREG(CRTC2_GEN_CNTL, save_crtc2_gen_cntl | CRTC2_DISP_REQ_EN_B);
1928 }
1929 save_crtc_gen_cntl = INREG(CRTC_GEN_CNTL);
1930 save_crtc_ext_cntl = INREG(CRTC_EXT_CNTL);
1931
1932 OUTREG(CRTC_EXT_CNTL, save_crtc_ext_cntl | CRTC_DISPLAY_DIS);
1933 OUTREG(CRTC_GEN_CNTL, save_crtc_gen_cntl | CRTC_DISP_REQ_EN_B);
1934 mdelay(100);
1935
1936 aper_base = INREG(CONFIG_APER_0_BASE);
1937 aper_size = INREG(CONFIG_APER_SIZE);
1938
1939 #ifdef SET_MC_FB_FROM_APERTURE
1940 /* Set framebuffer to be at the same address as set in PCI BAR */
1941 OUTREG(MC_FB_LOCATION,
1942 ((aper_base + aper_size - 1) & 0xffff0000) | (aper_base >> 16));
1943 rinfo->fb_local_base = aper_base;
1944 #else
1945 OUTREG(MC_FB_LOCATION, 0x7fff0000);
1946 rinfo->fb_local_base = 0;
1947 #endif
1948 agp_base = aper_base + aper_size;
1949 if (agp_base & 0xf0000000)
1950 agp_base = (aper_base | 0x0fffffff) + 1;
1951
1952 /* Set AGP to be just after the framebuffer on a 256Mb boundary. This
1953 * assumes the FB isn't mapped to 0xf0000000 or above, but this is
1954 * always the case on PPCs afaik.
1955 */
1956 #ifdef SET_MC_FB_FROM_APERTURE
1957 OUTREG(MC_AGP_LOCATION, 0xffff0000 | (agp_base >> 16));
1958 #else
1959 OUTREG(MC_AGP_LOCATION, 0xffffe000);
1960 #endif
1961
1962 /* Fixup the display base addresses & engine offsets while we
1963 * are at it as well
1964 */
1965 #ifdef SET_MC_FB_FROM_APERTURE
1966 OUTREG(DISPLAY_BASE_ADDR, aper_base);
1967 if (rinfo->has_CRTC2)
1968 OUTREG(CRTC2_DISPLAY_BASE_ADDR, aper_base);
1969 OUTREG(OV0_BASE_ADDR, aper_base);
1970 #else
1971 OUTREG(DISPLAY_BASE_ADDR, 0);
1972 if (rinfo->has_CRTC2)
1973 OUTREG(CRTC2_DISPLAY_BASE_ADDR, 0);
1974 OUTREG(OV0_BASE_ADDR, 0);
1975 #endif
1976 mdelay(100);
1977
1978 /* Restore display settings */
1979 OUTREG(CRTC_GEN_CNTL, save_crtc_gen_cntl);
1980 OUTREG(CRTC_EXT_CNTL, save_crtc_ext_cntl);
1981 if (rinfo->has_CRTC2)
1982 OUTREG(CRTC2_GEN_CNTL, save_crtc2_gen_cntl);
1983
1984 RTRACE("aper_base: %08x MC_FB_LOC to: %08x, MC_AGP_LOC to: %08x\n",
1985 aper_base,
1986 ((aper_base + aper_size - 1) & 0xffff0000) | (aper_base >> 16),
1987 0xffff0000 | (agp_base >> 16));
1988 }
1989 #endif /* CONFIG_PPC_OF */
1990
1991
1992 static void radeon_identify_vram(struct radeonfb_info *rinfo)
1993 {
1994 u32 tmp;
1995
1996 /* framebuffer size */
1997 if ((rinfo->family == CHIP_FAMILY_RS100) ||
1998 (rinfo->family == CHIP_FAMILY_RS200) ||
1999 (rinfo->family == CHIP_FAMILY_RS300) ||
2000 (rinfo->family == CHIP_FAMILY_RS480) ) {
2001 u32 tom = INREG(NB_TOM);
2002 tmp = ((((tom >> 16) - (tom & 0xffff) + 1) << 6) * 1024);
2003
2004 radeon_fifo_wait(6);
2005 OUTREG(MC_FB_LOCATION, tom);
2006 OUTREG(DISPLAY_BASE_ADDR, (tom & 0xffff) << 16);
2007 OUTREG(CRTC2_DISPLAY_BASE_ADDR, (tom & 0xffff) << 16);
2008 OUTREG(OV0_BASE_ADDR, (tom & 0xffff) << 16);
2009
2010 /* This is supposed to fix the crtc2 noise problem. */
2011 OUTREG(GRPH2_BUFFER_CNTL, INREG(GRPH2_BUFFER_CNTL) & ~0x7f0000);
2012
2013 if ((rinfo->family == CHIP_FAMILY_RS100) ||
2014 (rinfo->family == CHIP_FAMILY_RS200)) {
2015 /* This is to workaround the asic bug for RMX, some versions
2016 of BIOS dosen't have this register initialized correctly.
2017 */
2018 OUTREGP(CRTC_MORE_CNTL, CRTC_H_CUTOFF_ACTIVE_EN,
2019 ~CRTC_H_CUTOFF_ACTIVE_EN);
2020 }
2021 } else {
2022 tmp = INREG(CONFIG_MEMSIZE);
2023 }
2024
2025 /* mem size is bits [28:0], mask off the rest */
2026 rinfo->video_ram = tmp & CONFIG_MEMSIZE_MASK;
2027
2028 /*
2029 * Hack to get around some busted production M6's
2030 * reporting no ram
2031 */
2032 if (rinfo->video_ram == 0) {
2033 switch (rinfo->pdev->device) {
2034 case PCI_CHIP_RADEON_LY:
2035 case PCI_CHIP_RADEON_LZ:
2036 rinfo->video_ram = 8192 * 1024;
2037 break;
2038 default:
2039 break;
2040 }
2041 }
2042
2043
2044 /*
2045 * Now try to identify VRAM type
2046 */
2047 if (rinfo->is_IGP || (rinfo->family >= CHIP_FAMILY_R300) ||
2048 (INREG(MEM_SDRAM_MODE_REG) & (1<<30)))
2049 rinfo->vram_ddr = 1;
2050 else
2051 rinfo->vram_ddr = 0;
2052
2053 tmp = INREG(MEM_CNTL);
2054 if (IS_R300_VARIANT(rinfo)) {
2055 tmp &= R300_MEM_NUM_CHANNELS_MASK;
2056 switch (tmp) {
2057 case 0: rinfo->vram_width = 64; break;
2058 case 1: rinfo->vram_width = 128; break;
2059 case 2: rinfo->vram_width = 256; break;
2060 default: rinfo->vram_width = 128; break;
2061 }
2062 } else if ((rinfo->family == CHIP_FAMILY_RV100) ||
2063 (rinfo->family == CHIP_FAMILY_RS100) ||
2064 (rinfo->family == CHIP_FAMILY_RS200)){
2065 if (tmp & RV100_MEM_HALF_MODE)
2066 rinfo->vram_width = 32;
2067 else
2068 rinfo->vram_width = 64;
2069 } else {
2070 if (tmp & MEM_NUM_CHANNELS_MASK)
2071 rinfo->vram_width = 128;
2072 else
2073 rinfo->vram_width = 64;
2074 }
2075
2076 /* This may not be correct, as some cards can have half of channel disabled
2077 * ToDo: identify these cases
2078 */
2079
2080 RTRACE("radeonfb (%s): Found %ldk of %s %d bits wide videoram\n",
2081 pci_name(rinfo->pdev),
2082 rinfo->video_ram / 1024,
2083 rinfo->vram_ddr ? "DDR" : "SDRAM",
2084 rinfo->vram_width);
2085 }
2086
2087 /*
2088 * Sysfs
2089 */
2090
2091 static ssize_t radeon_show_one_edid(char *buf, loff_t off, size_t count, const u8 *edid)
2092 {
2093 if (off > EDID_LENGTH)
2094 return 0;
2095
2096 if (off + count > EDID_LENGTH)
2097 count = EDID_LENGTH - off;
2098
2099 memcpy(buf, edid + off, count);
2100
2101 return count;
2102 }
2103
2104
2105 static ssize_t radeon_show_edid1(struct kobject *kobj, char *buf, loff_t off, size_t count)
2106 {
2107 struct device *dev = container_of(kobj, struct device, kobj);
2108 struct pci_dev *pdev = to_pci_dev(dev);
2109 struct fb_info *info = pci_get_drvdata(pdev);
2110 struct radeonfb_info *rinfo = info->par;
2111
2112 return radeon_show_one_edid(buf, off, count, rinfo->mon1_EDID);
2113 }
2114
2115
2116 static ssize_t radeon_show_edid2(struct kobject *kobj, char *buf, loff_t off, size_t count)
2117 {
2118 struct device *dev = container_of(kobj, struct device, kobj);
2119 struct pci_dev *pdev = to_pci_dev(dev);
2120 struct fb_info *info = pci_get_drvdata(pdev);
2121 struct radeonfb_info *rinfo = info->par;
2122
2123 return radeon_show_one_edid(buf, off, count, rinfo->mon2_EDID);
2124 }
2125
2126 static struct bin_attribute edid1_attr = {
2127 .attr = {
2128 .name = "edid1",
2129 .owner = THIS_MODULE,
2130 .mode = 0444,
2131 },
2132 .size = EDID_LENGTH,
2133 .read = radeon_show_edid1,
2134 };
2135
2136 static struct bin_attribute edid2_attr = {
2137 .attr = {
2138 .name = "edid2",
2139 .owner = THIS_MODULE,
2140 .mode = 0444,
2141 },
2142 .size = EDID_LENGTH,
2143 .read = radeon_show_edid2,
2144 };
2145
2146
2147 static int __devinit radeonfb_pci_register (struct pci_dev *pdev,
2148 const struct pci_device_id *ent)
2149 {
2150 struct fb_info *info;
2151 struct radeonfb_info *rinfo;
2152 int ret;
2153
2154 RTRACE("radeonfb_pci_register BEGIN\n");
2155
2156 /* Enable device in PCI config */
2157 ret = pci_enable_device(pdev);
2158 if (ret < 0) {
2159 printk(KERN_ERR "radeonfb (%s): Cannot enable PCI device\n",
2160 pci_name(pdev));
2161 goto err_out;
2162 }
2163
2164 info = framebuffer_alloc(sizeof(struct radeonfb_info), &pdev->dev);
2165 if (!info) {
2166 printk (KERN_ERR "radeonfb (%s): could not allocate memory\n",
2167 pci_name(pdev));
2168 ret = -ENOMEM;
2169 goto err_disable;
2170 }
2171 rinfo = info->par;
2172 rinfo->info = info;
2173 rinfo->pdev = pdev;
2174
2175 spin_lock_init(&rinfo->reg_lock);
2176 init_timer(&rinfo->lvds_timer);
2177 rinfo->lvds_timer.function = radeon_lvds_timer_func;
2178 rinfo->lvds_timer.data = (unsigned long)rinfo;
2179
2180 strcpy(rinfo->name, "ATI Radeon XX ");
2181 rinfo->name[11] = ent->device >> 8;
2182 rinfo->name[12] = ent->device & 0xFF;
2183 rinfo->family = ent->driver_data & CHIP_FAMILY_MASK;
2184 rinfo->chipset = pdev->device;
2185 rinfo->has_CRTC2 = (ent->driver_data & CHIP_HAS_CRTC2) != 0;
2186 rinfo->is_mobility = (ent->driver_data & CHIP_IS_MOBILITY) != 0;
2187 rinfo->is_IGP = (ent->driver_data & CHIP_IS_IGP) != 0;
2188
2189 /* Set base addrs */
2190 rinfo->fb_base_phys = pci_resource_start (pdev, 0);
2191 rinfo->mmio_base_phys = pci_resource_start (pdev, 2);
2192
2193 /* request the mem regions */
2194 ret = pci_request_region(pdev, 0, "radeonfb framebuffer");
2195 if (ret < 0) {
2196 printk( KERN_ERR "radeonfb (%s): cannot request region 0.\n",
2197 pci_name(rinfo->pdev));
2198 goto err_release_fb;
2199 }
2200
2201 ret = pci_request_region(pdev, 2, "radeonfb mmio");
2202 if (ret < 0) {
2203 printk( KERN_ERR "radeonfb (%s): cannot request region 2.\n",
2204 pci_name(rinfo->pdev));
2205 goto err_release_pci0;
2206 }
2207
2208 /* map the regions */
2209 rinfo->mmio_base = ioremap(rinfo->mmio_base_phys, RADEON_REGSIZE);
2210 if (!rinfo->mmio_base) {
2211 printk(KERN_ERR "radeonfb (%s): cannot map MMIO\n",
2212 pci_name(rinfo->pdev));
2213 ret = -EIO;
2214 goto err_release_pci2;
2215 }
2216
2217 rinfo->fb_local_base = INREG(MC_FB_LOCATION) << 16;
2218
2219 /*
2220 * Check for errata
2221 */
2222 rinfo->errata = 0;
2223 if (rinfo->family == CHIP_FAMILY_R300 &&
2224 (INREG(CONFIG_CNTL) & CFG_ATI_REV_ID_MASK)
2225 == CFG_ATI_REV_A11)
2226 rinfo->errata |= CHIP_ERRATA_R300_CG;
2227
2228 if (rinfo->family == CHIP_FAMILY_RV200 ||
2229 rinfo->family == CHIP_FAMILY_RS200)
2230 rinfo->errata |= CHIP_ERRATA_PLL_DUMMYREADS;
2231
2232 if (rinfo->family == CHIP_FAMILY_RV100 ||
2233 rinfo->family == CHIP_FAMILY_RS100 ||
2234 rinfo->family == CHIP_FAMILY_RS200)
2235 rinfo->errata |= CHIP_ERRATA_PLL_DELAY;
2236
2237 #if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
2238 /* On PPC, we obtain the OF device-node pointer to the firmware
2239 * data for this chip
2240 */
2241 rinfo->of_node = pci_device_to_OF_node(pdev);
2242 if (rinfo->of_node == NULL)
2243 printk(KERN_WARNING "radeonfb (%s): Cannot match card to OF node !\n",
2244 pci_name(rinfo->pdev));
2245
2246 #endif /* CONFIG_PPC_OF || CONFIG_SPARC */
2247 #ifdef CONFIG_PPC_OF
2248 /* On PPC, the firmware sets up a memory mapping that tends
2249 * to cause lockups when enabling the engine. We reconfigure
2250 * the card internal memory mappings properly
2251 */
2252 fixup_memory_mappings(rinfo);
2253 #endif /* CONFIG_PPC_OF */
2254
2255 /* Get VRAM size and type */
2256 radeon_identify_vram(rinfo);
2257
2258 rinfo->mapped_vram = min_t(unsigned long, MAX_MAPPED_VRAM, rinfo->video_ram);
2259
2260 do {
2261 rinfo->fb_base = ioremap (rinfo->fb_base_phys,
2262 rinfo->mapped_vram);
2263 } while ( rinfo->fb_base == 0 &&
2264 ((rinfo->mapped_vram /=2) >= MIN_MAPPED_VRAM) );
2265
2266 if (rinfo->fb_base == NULL) {
2267 printk (KERN_ERR "radeonfb (%s): cannot map FB\n",
2268 pci_name(rinfo->pdev));
2269 ret = -EIO;
2270 goto err_unmap_rom;
2271 }
2272
2273 RTRACE("radeonfb (%s): mapped %ldk videoram\n", pci_name(rinfo->pdev),
2274 rinfo->mapped_vram/1024);
2275
2276 /*
2277 * Map the BIOS ROM if any and retrieve PLL parameters from
2278 * the BIOS. We skip that on mobility chips as the real panel
2279 * values we need aren't in the ROM but in the BIOS image in
2280 * memory. This is definitely not the best meacnism though,
2281 * we really need the arch code to tell us which is the "primary"
2282 * video adapter to use the memory image (or better, the arch
2283 * should provide us a copy of the BIOS image to shield us from
2284 * archs who would store that elsewhere and/or could initialize
2285 * more than one adapter during boot).
2286 */
2287 if (!rinfo->is_mobility)
2288 radeon_map_ROM(rinfo, pdev);
2289
2290 /*
2291 * On x86, the primary display on laptop may have it's BIOS
2292 * ROM elsewhere, try to locate it at the legacy memory hole.
2293 * We probably need to make sure this is the primary display,
2294 * but that is difficult without some arch support.
2295 */
2296 #ifdef CONFIG_X86
2297 if (rinfo->bios_seg == NULL)
2298 radeon_find_mem_vbios(rinfo);
2299 #endif
2300
2301 /* If both above failed, try the BIOS ROM again for mobility
2302 * chips
2303 */
2304 if (rinfo->bios_seg == NULL && rinfo->is_mobility)
2305 radeon_map_ROM(rinfo, pdev);
2306
2307 /* Get informations about the board's PLL */
2308 radeon_get_pllinfo(rinfo);
2309
2310 #ifdef CONFIG_FB_RADEON_I2C
2311 /* Register I2C bus */
2312 radeon_create_i2c_busses(rinfo);
2313 #endif
2314
2315 /* set all the vital stuff */
2316 radeon_set_fbinfo (rinfo);
2317
2318 /* Probe screen types */
2319 radeon_probe_screens(rinfo, monitor_layout, ignore_edid);
2320
2321 /* Build mode list, check out panel native model */
2322 radeon_check_modes(rinfo, mode_option);
2323
2324 /* Register some sysfs stuff (should be done better) */
2325 if (rinfo->mon1_EDID)
2326 sysfs_create_bin_file(&rinfo->pdev->dev.kobj, &edid1_attr);
2327 if (rinfo->mon2_EDID)
2328 sysfs_create_bin_file(&rinfo->pdev->dev.kobj, &edid2_attr);
2329
2330 /* save current mode regs before we switch into the new one
2331 * so we can restore this upon __exit
2332 */
2333 radeon_save_state (rinfo, &rinfo->init_state);
2334 memcpy(&rinfo->state, &rinfo->init_state, sizeof(struct radeon_regs));
2335
2336 /* Setup Power Management capabilities */
2337 if (default_dynclk < -1) {
2338 /* -2 is special: means ON on mobility chips and do not
2339 * change on others
2340 */
2341 radeonfb_pm_init(rinfo, rinfo->is_mobility ? 1 : -1, ignore_devlist, force_sleep);
2342 } else
2343 radeonfb_pm_init(rinfo, default_dynclk, ignore_devlist, force_sleep);
2344
2345 pci_set_drvdata(pdev, info);
2346
2347 /* Register with fbdev layer */
2348 ret = register_framebuffer(info);
2349 if (ret < 0) {
2350 printk (KERN_ERR "radeonfb (%s): could not register framebuffer\n",
2351 pci_name(rinfo->pdev));
2352 goto err_unmap_fb;
2353 }
2354
2355 #ifdef CONFIG_MTRR
2356 rinfo->mtrr_hdl = nomtrr ? -1 : mtrr_add(rinfo->fb_base_phys,
2357 rinfo->video_ram,
2358 MTRR_TYPE_WRCOMB, 1);
2359 #endif
2360
2361 if (backlight)
2362 radeonfb_bl_init(rinfo);
2363
2364 printk ("radeonfb (%s): %s\n", pci_name(rinfo->pdev), rinfo->name);
2365
2366 if (rinfo->bios_seg)
2367 radeon_unmap_ROM(rinfo, pdev);
2368 RTRACE("radeonfb_pci_register END\n");
2369
2370 return 0;
2371 err_unmap_fb:
2372 iounmap(rinfo->fb_base);
2373 err_unmap_rom:
2374 kfree(rinfo->mon1_EDID);
2375 kfree(rinfo->mon2_EDID);
2376 if (rinfo->mon1_modedb)
2377 fb_destroy_modedb(rinfo->mon1_modedb);
2378 fb_dealloc_cmap(&info->cmap);
2379 #ifdef CONFIG_FB_RADEON_I2C
2380 radeon_delete_i2c_busses(rinfo);
2381 #endif
2382 if (rinfo->bios_seg)
2383 radeon_unmap_ROM(rinfo, pdev);
2384 iounmap(rinfo->mmio_base);
2385 err_release_pci2:
2386 pci_release_region(pdev, 2);
2387 err_release_pci0:
2388 pci_release_region(pdev, 0);
2389 err_release_fb:
2390 framebuffer_release(info);
2391 err_disable:
2392 err_out:
2393 return ret;
2394 }
2395
2396
2397
2398 static void __devexit radeonfb_pci_unregister (struct pci_dev *pdev)
2399 {
2400 struct fb_info *info = pci_get_drvdata(pdev);
2401 struct radeonfb_info *rinfo = info->par;
2402
2403 if (!rinfo)
2404 return;
2405
2406 radeonfb_pm_exit(rinfo);
2407
2408 if (rinfo->mon1_EDID)
2409 sysfs_remove_bin_file(&rinfo->pdev->dev.kobj, &edid1_attr);
2410 if (rinfo->mon2_EDID)
2411 sysfs_remove_bin_file(&rinfo->pdev->dev.kobj, &edid2_attr);
2412
2413 #if 0
2414 /* restore original state
2415 *
2416 * Doesn't quite work yet, I suspect if we come from a legacy
2417 * VGA mode (or worse, text mode), we need to do some VGA black
2418 * magic here that I know nothing about. --BenH
2419 */
2420 radeon_write_mode (rinfo, &rinfo->init_state, 1);
2421 #endif
2422
2423 del_timer_sync(&rinfo->lvds_timer);
2424
2425 #ifdef CONFIG_MTRR
2426 if (rinfo->mtrr_hdl >= 0)
2427 mtrr_del(rinfo->mtrr_hdl, 0, 0);
2428 #endif
2429
2430 unregister_framebuffer(info);
2431
2432 radeonfb_bl_exit(rinfo);
2433
2434 iounmap(rinfo->mmio_base);
2435 iounmap(rinfo->fb_base);
2436
2437 pci_release_region(pdev, 2);
2438 pci_release_region(pdev, 0);
2439
2440 kfree(rinfo->mon1_EDID);
2441 kfree(rinfo->mon2_EDID);
2442 if (rinfo->mon1_modedb)
2443 fb_destroy_modedb(rinfo->mon1_modedb);
2444 #ifdef CONFIG_FB_RADEON_I2C
2445 radeon_delete_i2c_busses(rinfo);
2446 #endif
2447 fb_dealloc_cmap(&info->cmap);
2448 framebuffer_release(info);
2449 }
2450
2451
2452 static struct pci_driver radeonfb_driver = {
2453 .name = "radeonfb",
2454 .id_table = radeonfb_pci_table,
2455 .probe = radeonfb_pci_register,
2456 .remove = __devexit_p(radeonfb_pci_unregister),
2457 #ifdef CONFIG_PM
2458 .suspend = radeonfb_pci_suspend,
2459 .resume = radeonfb_pci_resume,
2460 #endif /* CONFIG_PM */
2461 };
2462
2463 #ifndef MODULE
2464 static int __init radeonfb_setup (char *options)
2465 {
2466 char *this_opt;
2467
2468 if (!options || !*options)
2469 return 0;
2470
2471 while ((this_opt = strsep (&options, ",")) != NULL) {
2472 if (!*this_opt)
2473 continue;
2474
2475 if (!strncmp(this_opt, "noaccel", 7)) {
2476 noaccel = 1;
2477 } else if (!strncmp(this_opt, "mirror", 6)) {
2478 mirror = 1;
2479 } else if (!strncmp(this_opt, "force_dfp", 9)) {
2480 force_dfp = 1;
2481 } else if (!strncmp(this_opt, "panel_yres:", 11)) {
2482 panel_yres = simple_strtoul((this_opt+11), NULL, 0);
2483 } else if (!strncmp(this_opt, "backlight:", 10)) {
2484 backlight = simple_strtoul(this_opt+10, NULL, 0);
2485 #ifdef CONFIG_MTRR
2486 } else if (!strncmp(this_opt, "nomtrr", 6)) {
2487 nomtrr = 1;
2488 #endif
2489 } else if (!strncmp(this_opt, "nomodeset", 9)) {
2490 nomodeset = 1;
2491 } else if (!strncmp(this_opt, "force_measure_pll", 17)) {
2492 force_measure_pll = 1;
2493 } else if (!strncmp(this_opt, "ignore_edid", 11)) {
2494 ignore_edid = 1;
2495 #if defined(CONFIG_PM) && defined(CONFIG_X86)
2496 } else if (!strncmp(this_opt, "force_sleep", 11)) {
2497 force_sleep = 1;
2498 } else if (!strncmp(this_opt, "ignore_devlist", 14)) {
2499 ignore_devlist = 1;
2500 #endif
2501 } else
2502 mode_option = this_opt;
2503 }
2504 return 0;
2505 }
2506 #endif /* MODULE */
2507
2508 static int __init radeonfb_init (void)
2509 {
2510 #ifndef MODULE
2511 char *option = NULL;
2512
2513 if (fb_get_options("radeonfb", &option))
2514 return -ENODEV;
2515 radeonfb_setup(option);
2516 #endif
2517 return pci_register_driver (&radeonfb_driver);
2518 }
2519
2520
2521 static void __exit radeonfb_exit (void)
2522 {
2523 pci_unregister_driver (&radeonfb_driver);
2524 }
2525
2526 module_init(radeonfb_init);
2527 module_exit(radeonfb_exit);
2528
2529 MODULE_AUTHOR("Ani Joshi");
2530 MODULE_DESCRIPTION("framebuffer driver for ATI Radeon chipset");
2531 MODULE_LICENSE("GPL");
2532 module_param(noaccel, bool, 0);
2533 module_param(default_dynclk, int, 0);
2534 MODULE_PARM_DESC(default_dynclk, "int: -2=enable on mobility only,-1=do not change,0=off,1=on");
2535 MODULE_PARM_DESC(noaccel, "bool: disable acceleration");
2536 module_param(nomodeset, bool, 0);
2537 MODULE_PARM_DESC(nomodeset, "bool: disable actual setting of video mode");
2538 module_param(mirror, bool, 0);
2539 MODULE_PARM_DESC(mirror, "bool: mirror the display to both monitors");
2540 module_param(force_dfp, bool, 0);
2541 MODULE_PARM_DESC(force_dfp, "bool: force display to dfp");
2542 module_param(ignore_edid, bool, 0);
2543 MODULE_PARM_DESC(ignore_edid, "bool: Ignore EDID data when doing DDC probe");
2544 module_param(monitor_layout, charp, 0);
2545 MODULE_PARM_DESC(monitor_layout, "Specify monitor mapping (like XFree86)");
2546 module_param(force_measure_pll, bool, 0);
2547 MODULE_PARM_DESC(force_measure_pll, "Force measurement of PLL (debug)");
2548 #ifdef CONFIG_MTRR
2549 module_param(nomtrr, bool, 0);
2550 MODULE_PARM_DESC(nomtrr, "bool: disable use of MTRR registers");
2551 #endif
2552 module_param(panel_yres, int, 0);
2553 MODULE_PARM_DESC(panel_yres, "int: set panel yres");
2554 module_param(mode_option, charp, 0);
2555 MODULE_PARM_DESC(mode_option, "Specify resolution as \"<xres>x<yres>[-<bpp>][@<refresh>]\" ");
2556 #if defined(CONFIG_PM) && defined(CONFIG_X86)
2557 module_param(force_sleep, bool, 0);
2558 MODULE_PARM_DESC(force_sleep, "bool: force D2 sleep mode on all hardware");
2559 module_param(ignore_devlist, bool, 0);
2560 MODULE_PARM_DESC(ignore_devlist, "bool: ignore workarounds for bugs in specific laptops");
2561 #endif
Verdex Pro support