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