2 * drivers/video/radeonfb.c
3 * framebuffer driver for ATI Radeon chipset video boards
5 * Copyright 2003 Ben. Herrenschmidt <benh@kernel.crashing.org>
6 * Copyright 2000 Ani Joshi <ajoshi@kernel.crashing.org>
8 * i2c bits from Luca Tettamanti <kronos@kronoz.cjb.net>
10 * Special thanks to ATI DevRel team for their hardware donations.
12 * ...Insert GPL boilerplate here...
14 * Significant portions of this driver apdated from XFree86 Radeon
15 * driver which has the following copyright notice:
17 * Copyright 2000 ATI Technologies Inc., Markham, Ontario, and
18 * VA Linux Systems Inc., Fremont, California.
20 * All Rights Reserved.
22 * Permission is hereby granted, free of charge, to any person obtaining
23 * a copy of this software and associated documentation files (the
24 * "Software"), to deal in the Software without restriction, including
25 * without limitation on the rights to use, copy, modify, merge,
26 * publish, distribute, sublicense, and/or sell copies of the Software,
27 * and to permit persons to whom the Software is furnished to do so,
28 * subject to the following conditions:
30 * The above copyright notice and this permission notice (including the
31 * next paragraph) shall be included in all copies or substantial
32 * portions of the Software.
34 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
35 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
36 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
37 * NON-INFRINGEMENT. IN NO EVENT SHALL ATI, VA LINUX SYSTEMS AND/OR
38 * THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
39 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
40 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
41 * DEALINGS IN THE SOFTWARE.
43 * XFree86 driver authors:
45 * Kevin E. Martin <martin@xfree86.org>
46 * Rickard E. Faith <faith@valinux.com>
47 * Alan Hourihane <alanh@fairlite.demon.co.uk>
52 #define RADEON_VERSION "0.2.0"
54 #include <linux/config.h>
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>
61 #include <linux/tty.h>
62 #include <linux/slab.h>
63 #include <linux/delay.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 #include <linux/i2c.h>
73 #include <asm/uaccess.h>
78 #include <asm/pci-bridge.h>
79 #include "../macmodes.h"
81 #ifdef CONFIG_PMAC_BACKLIGHT
82 #include <asm/backlight.h>
85 #ifdef CONFIG_BOOTX_TEXT
86 #include <asm/btext.h>
89 #endif /* CONFIG_PPC_OF */
95 #include <video/radeon.h>
96 #include <linux/radeonfb.h>
98 #include "../edid.h" // MOVE THAT TO include/video
100 #include "radeonfb.h"
102 #define MAX_MAPPED_VRAM (2048*2048*4)
103 #define MIN_MAPPED_VRAM (1024*768*1)
105 #define CHIP_DEF(id, family, flags) \
106 { PCI_VENDOR_ID_ATI, id, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (flags) | (CHIP_FAMILY_##family) }
108 static struct pci_device_id radeonfb_pci_table[] = {
110 CHIP_DEF(PCI_CHIP_RADEON_LY, RV100, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
111 CHIP_DEF(PCI_CHIP_RADEON_LZ, RV100, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
113 CHIP_DEF(PCI_CHIP_RV100_QY, RV100, CHIP_HAS_CRTC2),
114 CHIP_DEF(PCI_CHIP_RV100_QZ, RV100, CHIP_HAS_CRTC2),
115 /* Radeon IGP320M (U1) */
116 CHIP_DEF(PCI_CHIP_RS100_4336, RS100, CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
117 /* Radeon IGP320 (A3) */
118 CHIP_DEF(PCI_CHIP_RS100_4136, RS100, CHIP_HAS_CRTC2 | CHIP_IS_IGP),
119 /* IGP330M/340M/350M (U2) */
120 CHIP_DEF(PCI_CHIP_RS200_4337, RS200, CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
121 /* IGP330/340/350 (A4) */
122 CHIP_DEF(PCI_CHIP_RS200_4137, RS200, CHIP_HAS_CRTC2 | CHIP_IS_IGP),
123 /* Mobility 7000 IGP */
124 CHIP_DEF(PCI_CHIP_RS250_4437, RS200, CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
126 CHIP_DEF(PCI_CHIP_RS250_4237, RS200, CHIP_HAS_CRTC2 | CHIP_IS_IGP),
128 CHIP_DEF(PCI_CHIP_R200_BB, R200, CHIP_HAS_CRTC2),
129 CHIP_DEF(PCI_CHIP_R200_BC, R200, CHIP_HAS_CRTC2),
131 CHIP_DEF(PCI_CHIP_R200_QH, R200, CHIP_HAS_CRTC2),
133 CHIP_DEF(PCI_CHIP_R200_QL, R200, CHIP_HAS_CRTC2),
135 CHIP_DEF(PCI_CHIP_R200_QM, R200, CHIP_HAS_CRTC2),
137 CHIP_DEF(PCI_CHIP_RADEON_LW, RV200, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
138 CHIP_DEF(PCI_CHIP_RADEON_LX, RV200, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
140 CHIP_DEF(PCI_CHIP_RV200_QW, RV200, CHIP_HAS_CRTC2),
141 CHIP_DEF(PCI_CHIP_RV200_QX, RV200, CHIP_HAS_CRTC2),
143 CHIP_DEF(PCI_CHIP_RV250_Ld, RV250, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
144 CHIP_DEF(PCI_CHIP_RV250_Le, RV250, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
145 CHIP_DEF(PCI_CHIP_RV250_Lf, RV250, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
146 CHIP_DEF(PCI_CHIP_RV250_Lg, RV250, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
148 CHIP_DEF(PCI_CHIP_RV250_If, RV250, CHIP_HAS_CRTC2),
149 CHIP_DEF(PCI_CHIP_RV250_Ig, RV250, CHIP_HAS_CRTC2),
150 /* Mobility 9100 IGP (U3) */
151 CHIP_DEF(PCI_CHIP_RS300_5835, RS300, CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
153 CHIP_DEF(PCI_CHIP_RS300_5834, RS300, CHIP_HAS_CRTC2 | CHIP_IS_IGP),
154 /* Mobility 9200 (M9+) */
155 CHIP_DEF(PCI_CHIP_RV280_5C61, RV280, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
156 CHIP_DEF(PCI_CHIP_RV280_5C63, RV280, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
158 CHIP_DEF(PCI_CHIP_RV280_5960, RV280, CHIP_HAS_CRTC2),
159 CHIP_DEF(PCI_CHIP_RV280_5961, RV280, CHIP_HAS_CRTC2),
160 CHIP_DEF(PCI_CHIP_RV280_5962, RV280, CHIP_HAS_CRTC2),
161 CHIP_DEF(PCI_CHIP_RV280_5964, RV280, CHIP_HAS_CRTC2),
163 CHIP_DEF(PCI_CHIP_R300_AD, R300, CHIP_HAS_CRTC2),
164 CHIP_DEF(PCI_CHIP_R300_AE, R300, CHIP_HAS_CRTC2),
165 /* 9600TX / FireGL Z1 */
166 CHIP_DEF(PCI_CHIP_R300_AF, R300, CHIP_HAS_CRTC2),
167 CHIP_DEF(PCI_CHIP_R300_AG, R300, CHIP_HAS_CRTC2),
168 /* 9700/9500/Pro/FireGL X1 */
169 CHIP_DEF(PCI_CHIP_R300_ND, R300, CHIP_HAS_CRTC2),
170 CHIP_DEF(PCI_CHIP_R300_NE, R300, CHIP_HAS_CRTC2),
171 CHIP_DEF(PCI_CHIP_R300_NF, R300, CHIP_HAS_CRTC2),
172 CHIP_DEF(PCI_CHIP_R300_NG, R300, CHIP_HAS_CRTC2),
173 /* Mobility M10/M11 */
174 CHIP_DEF(PCI_CHIP_RV350_NP, RV350, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
175 CHIP_DEF(PCI_CHIP_RV350_NQ, RV350, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
176 CHIP_DEF(PCI_CHIP_RV350_NR, RV350, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
177 CHIP_DEF(PCI_CHIP_RV350_NS, RV350, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
178 CHIP_DEF(PCI_CHIP_RV350_NT, RV350, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
179 CHIP_DEF(PCI_CHIP_RV350_NV, RV350, CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
181 CHIP_DEF(PCI_CHIP_RV350_AP, RV350, CHIP_HAS_CRTC2),
182 CHIP_DEF(PCI_CHIP_RV350_AQ, RV350, CHIP_HAS_CRTC2),
183 CHIP_DEF(PCI_CHIP_RV360_AR, RV350, CHIP_HAS_CRTC2),
184 CHIP_DEF(PCI_CHIP_RV350_AS, RV350, CHIP_HAS_CRTC2),
185 CHIP_DEF(PCI_CHIP_RV350_AT, RV350, CHIP_HAS_CRTC2),
186 CHIP_DEF(PCI_CHIP_RV350_AV, RV350, CHIP_HAS_CRTC2),
187 /* 9800/Pro/FileGL X2 */
188 CHIP_DEF(PCI_CHIP_R350_AH, R350, CHIP_HAS_CRTC2),
189 CHIP_DEF(PCI_CHIP_R350_AI, R350, CHIP_HAS_CRTC2),
190 CHIP_DEF(PCI_CHIP_R350_AJ, R350, CHIP_HAS_CRTC2),
191 CHIP_DEF(PCI_CHIP_R350_AK, R350, CHIP_HAS_CRTC2),
192 CHIP_DEF(PCI_CHIP_R350_NH, R350, CHIP_HAS_CRTC2),
193 CHIP_DEF(PCI_CHIP_R350_NI, R350, CHIP_HAS_CRTC2),
194 CHIP_DEF(PCI_CHIP_R360_NJ, R350, CHIP_HAS_CRTC2),
195 CHIP_DEF(PCI_CHIP_R350_NK, R350, CHIP_HAS_CRTC2),
196 /* Original Radeon/7200 */
197 CHIP_DEF(PCI_CHIP_RADEON_QD, RADEON, 0),
198 CHIP_DEF(PCI_CHIP_RADEON_QE, RADEON, 0),
199 CHIP_DEF(PCI_CHIP_RADEON_QF, RADEON, 0),
200 CHIP_DEF(PCI_CHIP_RADEON_QG, RADEON, 0),
203 MODULE_DEVICE_TABLE(pci, radeonfb_pci_table);
212 /* these common regs are cleared before mode setting so they do not
213 * interfere with anything
215 static reg_val common_regs[] = {
217 { OVR_WID_LEFT_RIGHT, 0 },
218 { OVR_WID_TOP_BOTTOM, 0 },
219 { OV0_SCALE_CNTL, 0 },
224 { CAP0_TRIG_CNTL, 0 },
225 { CAP1_TRIG_CNTL, 0 },
232 static char *mode_option;
233 static char *monitor_layout;
234 static int noaccel = 0;
235 static int nomodeset = 0;
236 static int ignore_edid = 0;
237 static int mirror = 0;
238 static int panel_yres = 0;
239 static int force_dfp = 0;
240 static int force_measure_pll = 0;
242 static int nomtrr = 0;
245 int radeonfb_noaccel = 0;
254 #ifdef CONFIG_PMAC_BACKLIGHT
255 static int radeon_set_backlight_enable(int on, int level, void *data);
256 static int radeon_set_backlight_level(int level, void *data);
257 static struct backlight_controller radeon_backlight_controller = {
258 radeon_set_backlight_enable,
259 radeon_set_backlight_level
261 #endif /* CONFIG_PMAC_BACKLIGHT */
263 #endif /* CONFIG_PPC_OF */
265 static void __devexit radeon_unmap_ROM(struct radeonfb_info *rinfo, struct pci_dev *dev)
267 // leave it disabled and unassigned
268 struct resource *r = &dev->resource[PCI_ROM_RESOURCE];
270 if (!rinfo->bios_seg)
272 iounmap(rinfo->bios_seg);
274 /* Release the ROM resource if we used it in the first place */
275 if (r->parent && r->flags & PCI_ROM_ADDRESS_ENABLE) {
277 r->flags &= ~PCI_ROM_ADDRESS_ENABLE;
281 /* This will disable and set address to unassigned */
282 pci_write_config_dword(dev, dev->rom_base_reg, 0);
285 static int __devinit radeon_map_ROM(struct radeonfb_info *rinfo, struct pci_dev *dev)
292 /* If this is a primary card, there is a shadow copy of the
293 * ROM somewhere in the first meg. We will just ignore the copy
294 * and use the ROM directly.
297 /* Fix from ATI for problem with Radeon hardware not leaving ROM enabled */
299 temp = INREG(MPP_TB_CONFIG);
302 OUTREG(MPP_TB_CONFIG, temp);
303 temp = INREG(MPP_TB_CONFIG);
305 /* no need to search for the ROM, just ask the card where it is. */
306 r = &dev->resource[PCI_ROM_RESOURCE];
308 /* assign the ROM an address if it doesn't have one */
309 if (r->parent == NULL)
310 pci_assign_resource(dev, PCI_ROM_RESOURCE);
312 /* enable if needed */
313 if (!(r->flags & PCI_ROM_ADDRESS_ENABLE)) {
314 pci_write_config_dword(dev, dev->rom_base_reg,
315 r->start | PCI_ROM_ADDRESS_ENABLE);
316 r->flags |= PCI_ROM_ADDRESS_ENABLE;
319 rom = ioremap(r->start, r->end - r->start + 1);
321 printk(KERN_ERR "radeonfb: ROM failed to map\n");
325 rinfo->bios_seg = rom;
327 /* Very simple test to make sure it appeared */
328 if (BIOS_IN16(0) != 0xaa55) {
329 printk(KERN_ERR "radeonfb: Invalid ROM signature %x should be 0xaa55\n",
333 /* Look for the PCI data to check the ROM type */
334 dptr = BIOS_IN16(0x18);
336 /* Check the PCI data signature. If it's wrong, we still assume a normal x86 ROM
337 * for now, until I've verified this works everywhere. The goal here is more
338 * to phase out Open Firmware images.
340 * Currently, we only look at the first PCI data, we could iteratre and deal with
341 * them all, and we should use fb_bios_start relative to start of image and not
342 * relative start of ROM, but so far, I never found a dual-image ATI card
345 * u32 signature; + 0x00
348 * u16 reserved_1; + 0x08
350 * u8 drevision; + 0x0c
351 * u8 class_hi; + 0x0d
352 * u16 class_lo; + 0x0e
354 * u16 irevision; + 0x12
356 * u8 indicator; + 0x15
357 * u16 reserved_2; + 0x16
360 if (BIOS_IN32(dptr) != (('R' << 24) | ('I' << 16) | ('C' << 8) | 'P')) {
361 printk(KERN_WARNING "radeonfb: PCI DATA signature in ROM incorrect: %08x\n",
365 rom_type = BIOS_IN8(dptr + 0x14);
368 printk(KERN_INFO "radeonfb: Found Intel x86 BIOS ROM Image\n");
371 printk(KERN_INFO "radeonfb: Found Open Firmware ROM Image\n");
374 printk(KERN_INFO "radeonfb: Found HP PA-RISC ROM Image\n");
377 printk(KERN_INFO "radeonfb: Found unknown type %d ROM Image\n", rom_type);
381 /* Locate the flat panel infos, do some sanity checking !!! */
382 rinfo->fp_bios_start = BIOS_IN16(0x48);
386 rinfo->bios_seg = NULL;
387 radeon_unmap_ROM(rinfo, dev);
392 static int __devinit radeon_find_mem_vbios(struct radeonfb_info *rinfo)
394 /* I simplified this code as we used to miss the signatures in
395 * a lot of case. It's now closer to XFree, we just don't check
396 * for signatures at all... Something better will have to be done
397 * if we end up having conflicts
400 unsigned char *rom_base = NULL;
402 for(segstart=0x000c0000; segstart<0x000f0000; segstart+=0x00001000) {
403 rom_base = (char *)ioremap(segstart, 0x10000);
404 if (rom_base == NULL)
406 if ((*rom_base == 0x55) && (((*(rom_base + 1)) & 0xff) == 0xaa))
411 if (rom_base == NULL)
414 /* Locate the flat panel infos, do some sanity checking !!! */
415 rinfo->bios_seg = rom_base;
416 rinfo->fp_bios_start = BIOS_IN16(0x48);
420 #endif /* __i386__ */
424 * Read XTAL (ref clock), SCLK and MCLK from Open Firmware device
425 * tree. Hopefully, ATI OF driver is kind enough to fill these
427 static int __devinit radeon_read_xtal_OF (struct radeonfb_info *rinfo)
429 struct device_node *dp;
432 dp = pci_device_to_OF_node(rinfo->pdev);
434 printk(KERN_WARNING "radeonfb: Cannot match card to OF node !\n");
437 val = (u32 *) get_property(dp, "ATY,RefCLK", 0);
439 printk(KERN_WARNING "radeonfb: No ATY,RefCLK property !\n");
443 rinfo->pll.ref_clk = (*val) / 10;
445 val = (u32 *) get_property(dp, "ATY,SCLK", 0);
447 rinfo->pll.sclk = (*val) / 10;
449 val = (u32 *) get_property(dp, "ATY,MCLK", 0);
451 rinfo->pll.mclk = (*val) / 10;
455 #endif /* CONFIG_PPC_OF */
458 * Read PLL infos from chip registers
460 static int __devinit radeon_probe_pll_params(struct radeonfb_info *rinfo)
462 unsigned char ppll_div_sel;
464 unsigned sclk, mclk, tmp, ref_div;
465 int hTotal, vTotal, num, denom, m, n;
466 unsigned long long hz, vclk;
468 struct timeval start_tv, stop_tv;
469 long total_secs, total_usecs;
472 /* Ugh, we cut interrupts, bad bad bad, but we want some precision
476 /* Flush PCI buffers ? */
477 tmp = INREG(DEVICE_ID);
481 for(i=0; i<1000000; i++)
482 if (((INREG(CRTC_VLINE_CRNT_VLINE) >> 16) & 0x3ff) == 0)
485 do_gettimeofday(&start_tv);
487 for(i=0; i<1000000; i++)
488 if (((INREG(CRTC_VLINE_CRNT_VLINE) >> 16) & 0x3ff) != 0)
491 for(i=0; i<1000000; i++)
492 if (((INREG(CRTC_VLINE_CRNT_VLINE) >> 16) & 0x3ff) == 0)
495 do_gettimeofday(&stop_tv);
499 total_secs = stop_tv.tv_sec - start_tv.tv_sec;
502 total_usecs = stop_tv.tv_usec - start_tv.tv_usec;
503 total_usecs += total_secs * 1000000;
505 total_usecs = -total_usecs;
506 hz = 1000000/total_usecs;
508 hTotal = ((INREG(CRTC_H_TOTAL_DISP) & 0x1ff) + 1) * 8;
509 vTotal = ((INREG(CRTC_V_TOTAL_DISP) & 0x3ff) + 1);
510 vclk = (long long)hTotal * (long long)vTotal * hz;
512 switch((INPLL(PPLL_REF_DIV) & 0x30000) >> 16) {
519 n = ((INPLL(X_MPLL_REF_FB_DIV) >> 16) & 0xff);
520 m = (INPLL(X_MPLL_REF_FB_DIV) & 0xff);
525 n = ((INPLL(X_MPLL_REF_FB_DIV) >> 8) & 0xff);
526 m = (INPLL(X_MPLL_REF_FB_DIV) & 0xff);
532 OUTREG8(CLOCK_CNTL_INDEX, 1);
533 ppll_div_sel = INREG8(CLOCK_CNTL_DATA + 1) & 0x3;
535 n = (INPLL(PPLL_DIV_0 + ppll_div_sel) & 0x7ff);
536 m = (INPLL(PPLL_REF_DIV) & 0x3ff);
541 switch ((INPLL(PPLL_DIV_0 + ppll_div_sel) >> 16) & 0x7) {
563 do_div(vclk, 1000 * num);
566 if ((xtal > 26900) && (xtal < 27100))
568 else if ((xtal > 14200) && (xtal < 14400))
570 else if ((xtal > 29400) && (xtal < 29600))
573 printk(KERN_WARNING "xtal calculation failed: %ld\n", xtal);
577 tmp = INPLL(X_MPLL_REF_FB_DIV);
578 ref_div = INPLL(PPLL_REF_DIV) & 0x3ff;
580 Ns = (tmp & 0xff0000) >> 16;
581 Nm = (tmp & 0xff00) >> 8;
583 sclk = round_div((2 * Ns * xtal), (2 * M));
584 mclk = round_div((2 * Nm * xtal), (2 * M));
586 /* we're done, hopefully these are sane values */
587 rinfo->pll.ref_clk = xtal;
588 rinfo->pll.ref_div = ref_div;
589 rinfo->pll.sclk = sclk;
590 rinfo->pll.mclk = mclk;
596 * Retreive PLL infos by different means (BIOS, Open Firmware, register probing...)
598 static void __devinit radeon_get_pllinfo(struct radeonfb_info *rinfo)
602 * Retreive PLL infos from Open Firmware first
604 if (!force_measure_pll && radeon_read_xtal_OF(rinfo) == 0) {
605 printk(KERN_INFO "radeonfb: Retreived PLL infos from Open Firmware\n");
606 rinfo->pll.ref_div = INPLL(PPLL_REF_DIV) & 0x3ff;
607 /* FIXME: Max clock may be higher on newer chips */
608 rinfo->pll.ppll_min = 12000;
609 rinfo->pll.ppll_max = 35000;
612 #endif /* CONFIG_PPC_OF */
615 * Check out if we have an X86 which gave us some PLL informations
616 * and if yes, retreive them
618 if (!force_measure_pll && rinfo->bios_seg) {
619 u16 pll_info_block = BIOS_IN16(rinfo->fp_bios_start + 0x30);
621 rinfo->pll.sclk = BIOS_IN16(pll_info_block + 0x08);
622 rinfo->pll.mclk = BIOS_IN16(pll_info_block + 0x0a);
623 rinfo->pll.ref_clk = BIOS_IN16(pll_info_block + 0x0e);
624 rinfo->pll.ref_div = BIOS_IN16(pll_info_block + 0x10);
625 rinfo->pll.ppll_min = BIOS_IN32(pll_info_block + 0x12);
626 rinfo->pll.ppll_max = BIOS_IN32(pll_info_block + 0x16);
628 printk(KERN_INFO "radeonfb: Retreived PLL infos from BIOS\n");
633 * We didn't get PLL parameters from either OF or BIOS, we try to
636 if (radeon_probe_pll_params(rinfo) == 0) {
637 printk(KERN_INFO "radeonfb: Retreived PLL infos from registers\n");
638 /* FIXME: Max clock may be higher on newer chips */
639 rinfo->pll.ppll_min = 12000;
640 rinfo->pll.ppll_max = 35000;
645 * Neither of the above worked, we have a few default values, though
646 * that's mostly incomplete
648 switch (rinfo->chipset) {
649 case PCI_DEVICE_ID_ATI_RADEON_QW:
650 case PCI_DEVICE_ID_ATI_RADEON_QX:
651 rinfo->pll.ppll_max = 35000;
652 rinfo->pll.ppll_min = 12000;
653 rinfo->pll.mclk = 23000;
654 rinfo->pll.sclk = 23000;
655 rinfo->pll.ref_clk = 2700;
657 case PCI_DEVICE_ID_ATI_RADEON_QL:
658 case PCI_DEVICE_ID_ATI_RADEON_QN:
659 case PCI_DEVICE_ID_ATI_RADEON_QO:
660 case PCI_DEVICE_ID_ATI_RADEON_Ql:
661 case PCI_DEVICE_ID_ATI_RADEON_BB:
662 rinfo->pll.ppll_max = 35000;
663 rinfo->pll.ppll_min = 12000;
664 rinfo->pll.mclk = 27500;
665 rinfo->pll.sclk = 27500;
666 rinfo->pll.ref_clk = 2700;
668 case PCI_DEVICE_ID_ATI_RADEON_Id:
669 case PCI_DEVICE_ID_ATI_RADEON_Ie:
670 case PCI_DEVICE_ID_ATI_RADEON_If:
671 case PCI_DEVICE_ID_ATI_RADEON_Ig:
672 rinfo->pll.ppll_max = 35000;
673 rinfo->pll.ppll_min = 12000;
674 rinfo->pll.mclk = 25000;
675 rinfo->pll.sclk = 25000;
676 rinfo->pll.ref_clk = 2700;
678 case PCI_DEVICE_ID_ATI_RADEON_ND:
679 case PCI_DEVICE_ID_ATI_RADEON_NE:
680 case PCI_DEVICE_ID_ATI_RADEON_NF:
681 case PCI_DEVICE_ID_ATI_RADEON_NG:
682 rinfo->pll.ppll_max = 40000;
683 rinfo->pll.ppll_min = 20000;
684 rinfo->pll.mclk = 27000;
685 rinfo->pll.sclk = 27000;
686 rinfo->pll.ref_clk = 2700;
688 case PCI_DEVICE_ID_ATI_RADEON_QD:
689 case PCI_DEVICE_ID_ATI_RADEON_QE:
690 case PCI_DEVICE_ID_ATI_RADEON_QF:
691 case PCI_DEVICE_ID_ATI_RADEON_QG:
693 rinfo->pll.ppll_max = 35000;
694 rinfo->pll.ppll_min = 12000;
695 rinfo->pll.mclk = 16600;
696 rinfo->pll.sclk = 16600;
697 rinfo->pll.ref_clk = 2700;
700 rinfo->pll.ref_div = INPLL(PPLL_REF_DIV) & 0x3ff;
702 printk(KERN_INFO "radeonfb: Used default PLL infos\n");
706 * Some methods fail to retreive SCLK and MCLK values, we apply default
707 * settings in this case (200Mhz). If that really happne often, we could
708 * fetch from registers instead...
710 if (rinfo->pll.mclk == 0)
711 rinfo->pll.mclk = 20000;
712 if (rinfo->pll.sclk == 0)
713 rinfo->pll.sclk = 20000;
715 printk("radeonfb: Reference=%d.%02d MHz (RefDiv=%d) Memory=%d.%02d Mhz, System=%d.%02d MHz\n",
716 rinfo->pll.ref_clk / 100, rinfo->pll.ref_clk % 100,
718 rinfo->pll.mclk / 100, rinfo->pll.mclk % 100,
719 rinfo->pll.sclk / 100, rinfo->pll.sclk % 100);
722 static int radeonfb_check_var (struct fb_var_screeninfo *var, struct fb_info *info)
724 struct radeonfb_info *rinfo = info->par;
725 struct fb_var_screeninfo v;
729 if (radeon_match_mode(rinfo, &v, var))
732 switch (v.bits_per_pixel) {
734 v.bits_per_pixel = 8;
737 v.bits_per_pixel = 16;
740 #if 0 /* Doesn't seem to work */
741 v.bits_per_pixel = 24;
746 v.bits_per_pixel = 32;
752 switch (var_to_depth(&v)) {
755 v.red.offset = v.green.offset = v.blue.offset = 0;
756 v.red.length = v.green.length = v.blue.length = 8;
757 v.transp.offset = v.transp.length = 0;
765 v.red.length = v.green.length = v.blue.length = 5;
766 v.transp.offset = v.transp.length = 0;
777 v.transp.offset = v.transp.length = 0;
785 v.red.length = v.blue.length = v.green.length = 8;
786 v.transp.offset = v.transp.length = 0;
794 v.red.length = v.blue.length = v.green.length = 8;
795 v.transp.offset = 24;
799 printk ("radeonfb: mode %dx%dx%d rejected, color depth invalid\n",
800 var->xres, var->yres, var->bits_per_pixel);
804 if (v.yres_virtual < v.yres)
805 v.yres_virtual = v.yres;
806 if (v.xres_virtual < v.xres)
807 v.xres_virtual = v.xres;
810 /* XXX I'm adjusting xres_virtual to the pitch, that may help XFree
811 * with some panels, though I don't quite like this solution
813 if (radeon_accel_disabled()) {
814 v.xres_virtual = v.xres_virtual & ~7ul;
817 pitch = ((v.xres_virtual * ((v.bits_per_pixel + 1) / 8) + 0x3f)
819 v.xres_virtual = (pitch << 6) / ((v.bits_per_pixel + 1) / 8);
822 if (((v.xres_virtual * v.yres_virtual * nom) / den) > rinfo->mapped_vram)
825 if (v.xres_virtual < v.xres)
826 v.xres = v.xres_virtual;
833 if (v.xoffset > v.xres_virtual - v.xres)
834 v.xoffset = v.xres_virtual - v.xres - 1;
836 if (v.yoffset > v.yres_virtual - v.yres)
837 v.yoffset = v.yres_virtual - v.yres - 1;
839 v.red.msb_right = v.green.msb_right = v.blue.msb_right =
840 v.transp.offset = v.transp.length =
841 v.transp.msb_right = 0;
843 memcpy(var, &v, sizeof(v));
849 static int radeonfb_pan_display (struct fb_var_screeninfo *var,
850 struct fb_info *info)
852 struct radeonfb_info *rinfo = info->par;
854 if ((var->xoffset + var->xres > var->xres_virtual)
855 || (var->yoffset + var->yres > var->yres_virtual))
861 OUTREG(CRTC_OFFSET, ((var->yoffset * var->xres_virtual + var->xoffset)
862 * var->bits_per_pixel / 8) & ~7);
867 static int radeonfb_ioctl (struct inode *inode, struct file *file, unsigned int cmd,
868 unsigned long arg, struct fb_info *info)
870 struct radeonfb_info *rinfo = info->par;
877 * TODO: set mirror accordingly for non-Mobility chipsets with 2 CRTC's
878 * and do something better using 2nd CRTC instead of just hackish
879 * routing to second output
881 case FBIO_RADEON_SET_MIRROR:
882 if (!rinfo->is_mobility)
885 rc = get_user(value, (__u32*)arg);
891 tmp = INREG(LVDS_GEN_CNTL);
893 tmp |= (LVDS_ON | LVDS_BLON);
895 tmp = INREG(LVDS_GEN_CNTL);
897 tmp &= ~(LVDS_ON | LVDS_BLON);
900 OUTREG(LVDS_GEN_CNTL, tmp);
903 tmp = INREG(CRTC_EXT_CNTL);
908 tmp = INREG(CRTC_EXT_CNTL);
914 OUTREG(CRTC_EXT_CNTL, tmp);
917 case FBIO_RADEON_GET_MIRROR:
918 if (!rinfo->is_mobility)
921 tmp = INREG(LVDS_GEN_CNTL);
922 if ((LVDS_ON | LVDS_BLON) & tmp)
925 tmp = INREG(CRTC_EXT_CNTL);
926 if (CRTC_CRT_ON & tmp)
929 return put_user(value, (__u32*)arg);
938 static int radeon_screen_blank (struct radeonfb_info *rinfo, int blank)
940 u32 val = INREG(CRTC_EXT_CNTL);
943 if (rinfo->mon1_type == MT_LCD)
944 val2 = INREG(LVDS_GEN_CNTL) & ~LVDS_DISPLAY_DIS;
947 val &= ~(CRTC_DISPLAY_DIS | CRTC_HSYNC_DIS |
951 case VESA_NO_BLANKING:
953 case VESA_VSYNC_SUSPEND:
954 val |= (CRTC_DISPLAY_DIS | CRTC_VSYNC_DIS);
956 case VESA_HSYNC_SUSPEND:
957 val |= (CRTC_DISPLAY_DIS | CRTC_HSYNC_DIS);
960 val |= (CRTC_DISPLAY_DIS | CRTC_VSYNC_DIS |
962 val2 |= (LVDS_DISPLAY_DIS);
966 switch (rinfo->mon1_type) {
968 OUTREG(LVDS_GEN_CNTL, val2);
972 OUTREG(CRTC_EXT_CNTL, val);
979 int radeonfb_blank (int blank, struct fb_info *info)
981 struct radeonfb_info *rinfo = info->par;
986 #ifdef CONFIG_PMAC_BACKLIGHT
987 if (rinfo->mon1_type == MT_LCD && _machine == _MACH_Pmac && blank)
988 set_backlight_enable(0);
991 radeon_screen_blank(rinfo, blank);
993 #ifdef CONFIG_PMAC_BACKLIGHT
994 if (rinfo->mon1_type == MT_LCD && _machine == _MACH_Pmac && !blank)
995 set_backlight_enable(1);
1001 static int radeonfb_setcolreg (unsigned regno, unsigned red, unsigned green,
1002 unsigned blue, unsigned transp, struct fb_info *info)
1004 struct radeonfb_info *rinfo = info->par;
1014 rinfo->palette[regno].red = red;
1015 rinfo->palette[regno].green = green;
1016 rinfo->palette[regno].blue = blue;
1021 if (!rinfo->asleep) {
1022 u32 dac_cntl2, vclk_cntl = 0;
1024 if (rinfo->is_mobility) {
1025 vclk_cntl = INPLL(VCLK_ECP_CNTL);
1026 OUTPLL(VCLK_ECP_CNTL, vclk_cntl & ~PIXCLK_DAC_ALWAYS_ONb);
1029 /* Make sure we are on first palette */
1030 if (rinfo->has_CRTC2) {
1031 dac_cntl2 = INREG(DAC_CNTL2);
1032 dac_cntl2 &= ~DAC2_PALETTE_ACCESS_CNTL;
1033 OUTREG(DAC_CNTL2, dac_cntl2);
1036 if (rinfo->bpp == 16) {
1039 if (rinfo->depth == 16 && regno > 63)
1041 if (rinfo->depth == 15 && regno > 31)
1044 /* For 565, the green component is mixed one order below */
1045 if (rinfo->depth == 16) {
1046 OUTREG(PALETTE_INDEX, pindex>>1);
1047 OUTREG(PALETTE_DATA, (rinfo->palette[regno>>1].red << 16) |
1048 (green << 8) | (rinfo->palette[regno>>1].blue));
1049 green = rinfo->palette[regno<<1].green;
1053 if (rinfo->depth != 16 || regno < 32) {
1054 OUTREG(PALETTE_INDEX, pindex);
1055 OUTREG(PALETTE_DATA, (red << 16) | (green << 8) | blue);
1057 if (rinfo->is_mobility)
1058 OUTPLL(VCLK_ECP_CNTL, vclk_cntl);
1061 u32 *pal = info->pseudo_palette;
1062 switch (rinfo->depth) {
1064 pal[regno] = (regno << 10) | (regno << 5) | regno;
1067 pal[regno] = (regno << 11) | (regno << 5) | regno;
1070 pal[regno] = (regno << 16) | (regno << 8) | regno;
1073 i = (regno << 8) | regno;
1074 pal[regno] = (i << 16) | i;
1082 static void radeon_save_state (struct radeonfb_info *rinfo, struct radeon_regs *save)
1085 save->crtc_gen_cntl = INREG(CRTC_GEN_CNTL);
1086 save->crtc_ext_cntl = INREG(CRTC_EXT_CNTL);
1087 save->crtc_more_cntl = INREG(CRTC_MORE_CNTL);
1088 save->dac_cntl = INREG(DAC_CNTL);
1089 save->crtc_h_total_disp = INREG(CRTC_H_TOTAL_DISP);
1090 save->crtc_h_sync_strt_wid = INREG(CRTC_H_SYNC_STRT_WID);
1091 save->crtc_v_total_disp = INREG(CRTC_V_TOTAL_DISP);
1092 save->crtc_v_sync_strt_wid = INREG(CRTC_V_SYNC_STRT_WID);
1093 save->crtc_pitch = INREG(CRTC_PITCH);
1094 save->surface_cntl = INREG(SURFACE_CNTL);
1097 save->fp_crtc_h_total_disp = INREG(FP_CRTC_H_TOTAL_DISP);
1098 save->fp_crtc_v_total_disp = INREG(FP_CRTC_V_TOTAL_DISP);
1099 save->fp_gen_cntl = INREG(FP_GEN_CNTL);
1100 save->fp_h_sync_strt_wid = INREG(FP_H_SYNC_STRT_WID);
1101 save->fp_horz_stretch = INREG(FP_HORZ_STRETCH);
1102 save->fp_v_sync_strt_wid = INREG(FP_V_SYNC_STRT_WID);
1103 save->fp_vert_stretch = INREG(FP_VERT_STRETCH);
1104 save->lvds_gen_cntl = INREG(LVDS_GEN_CNTL);
1105 save->lvds_pll_cntl = INREG(LVDS_PLL_CNTL);
1106 save->tmds_crc = INREG(TMDS_CRC); save->tmds_transmitter_cntl = INREG(TMDS_TRANSMITTER_CNTL);
1107 save->vclk_ecp_cntl = INPLL(VCLK_ECP_CNTL);
1111 static void radeon_write_pll_regs(struct radeonfb_info *rinfo, struct radeon_regs *mode)
1115 /* Workaround from XFree */
1116 if (rinfo->is_mobility) {
1117 /* A temporal workaround for the occational blanking on certain laptop panels.
1118 This appears to related to the PLL divider registers (fail to lock?).
1119 It occurs even when all dividers are the same with their old settings.
1120 In this case we really don't need to fiddle with PLL registers.
1121 By doing this we can avoid the blanking problem with some panels.
1123 if ((mode->ppll_ref_div == (INPLL(PPLL_REF_DIV) & PPLL_REF_DIV_MASK)) &&
1124 (mode->ppll_div_3 == (INPLL(PPLL_DIV_3) &
1125 (PPLL_POST3_DIV_MASK | PPLL_FB3_DIV_MASK)))) {
1126 /* We still have to force a switch to PPLL div 3 thanks to
1127 * an XFree86 driver bug which will switch it away in some cases
1128 * even when using UseFDev */
1129 OUTREGP(CLOCK_CNTL_INDEX, PPLL_DIV_SEL_MASK, ~PPLL_DIV_SEL_MASK);
1134 /* Swich VCKL clock input to CPUCLK so it stays fed while PPLL updates*/
1135 OUTPLLP(VCLK_ECP_CNTL, VCLK_SRC_SEL_CPUCLK, ~VCLK_SRC_SEL_MASK);
1137 /* Reset PPLL & enable atomic update */
1139 PPLL_RESET | PPLL_ATOMIC_UPDATE_EN | PPLL_VGA_ATOMIC_UPDATE_EN,
1140 ~(PPLL_RESET | PPLL_ATOMIC_UPDATE_EN | PPLL_VGA_ATOMIC_UPDATE_EN));
1142 /* Switch to PPLL div 3 */
1143 OUTREGP(CLOCK_CNTL_INDEX, PPLL_DIV_SEL_MASK, ~PPLL_DIV_SEL_MASK);
1145 /* Set PPLL ref. div */
1146 if (rinfo->family == CHIP_FAMILY_R300 ||
1147 rinfo->family == CHIP_FAMILY_RS300 ||
1148 rinfo->family == CHIP_FAMILY_R350 ||
1149 rinfo->family == CHIP_FAMILY_RV350) {
1150 if (mode->ppll_ref_div & R300_PPLL_REF_DIV_ACC_MASK) {
1151 /* When restoring console mode, use saved PPLL_REF_DIV
1154 OUTPLLP(PPLL_REF_DIV, mode->ppll_ref_div, 0);
1156 /* R300 uses ref_div_acc field as real ref divider */
1157 OUTPLLP(PPLL_REF_DIV,
1158 (mode->ppll_ref_div << R300_PPLL_REF_DIV_ACC_SHIFT),
1159 ~R300_PPLL_REF_DIV_ACC_MASK);
1162 OUTPLLP(PPLL_REF_DIV, mode->ppll_ref_div, ~PPLL_REF_DIV_MASK);
1164 /* Set PPLL divider 3 & post divider*/
1165 OUTPLLP(PPLL_DIV_3, mode->ppll_div_3, ~PPLL_FB3_DIV_MASK);
1166 OUTPLLP(PPLL_DIV_3, mode->ppll_div_3, ~PPLL_POST3_DIV_MASK);
1169 while (INPLL(PPLL_REF_DIV) & PPLL_ATOMIC_UPDATE_R)
1171 OUTPLLP(PPLL_REF_DIV, PPLL_ATOMIC_UPDATE_W, ~PPLL_ATOMIC_UPDATE_W);
1173 /* Wait read update complete */
1174 /* FIXME: Certain revisions of R300 can't recover here. Not sure of
1175 the cause yet, but this workaround will mask the problem for now.
1176 Other chips usually will pass at the very first test, so the
1177 workaround shouldn't have any effect on them. */
1178 for (i = 0; (i < 10000 && INPLL(PPLL_REF_DIV) & PPLL_ATOMIC_UPDATE_R); i++)
1181 OUTPLL(HTOTAL_CNTL, 0);
1183 /* Clear reset & atomic update */
1184 OUTPLLP(PPLL_CNTL, 0,
1185 ~(PPLL_RESET | PPLL_SLEEP | PPLL_ATOMIC_UPDATE_EN | PPLL_VGA_ATOMIC_UPDATE_EN));
1187 /* We may want some locking ... oh well */
1190 /* Switch back VCLK source to PPLL */
1191 OUTPLLP(VCLK_ECP_CNTL, VCLK_SRC_SEL_PPLLCLK, ~VCLK_SRC_SEL_MASK);
1195 * Timer function for delayed LVDS panel power up/down
1197 static void radeon_lvds_timer_func(unsigned long data)
1199 struct radeonfb_info *rinfo = (struct radeonfb_info *)data;
1201 OUTREG(LVDS_GEN_CNTL, rinfo->pending_lvds_gen_cntl);
1202 if (rinfo->pending_pixclks_cntl) {
1203 OUTPLL(PIXCLKS_CNTL, rinfo->pending_pixclks_cntl);
1204 rinfo->pending_pixclks_cntl = 0;
1209 * Apply a video mode. This will apply the whole register set, including
1210 * the PLL registers, to the card
1212 static void radeon_write_mode (struct radeonfb_info *rinfo,
1213 struct radeon_regs *mode)
1216 int primary_mon = PRIMARY_MONITOR(rinfo);
1221 del_timer_sync(&rinfo->lvds_timer);
1223 radeon_screen_blank(rinfo, VESA_POWERDOWN);
1225 for (i=0; i<10; i++)
1226 OUTREG(common_regs[i].reg, common_regs[i].val);
1228 /* Apply surface registers */
1229 for (i=0; i<8; i++) {
1230 OUTREG(SURFACE0_LOWER_BOUND + 0x10*i, mode->surf_lower_bound[i]);
1231 OUTREG(SURFACE0_UPPER_BOUND + 0x10*i, mode->surf_upper_bound[i]);
1232 OUTREG(SURFACE0_INFO + 0x10*i, mode->surf_info[i]);
1235 OUTREG(CRTC_GEN_CNTL, mode->crtc_gen_cntl);
1236 OUTREGP(CRTC_EXT_CNTL, mode->crtc_ext_cntl,
1237 ~(CRTC_HSYNC_DIS | CRTC_VSYNC_DIS | CRTC_DISPLAY_DIS));
1238 OUTREG(CRTC_MORE_CNTL, mode->crtc_more_cntl);
1239 OUTREGP(DAC_CNTL, mode->dac_cntl, DAC_RANGE_CNTL | DAC_BLANKING);
1240 OUTREG(CRTC_H_TOTAL_DISP, mode->crtc_h_total_disp);
1241 OUTREG(CRTC_H_SYNC_STRT_WID, mode->crtc_h_sync_strt_wid);
1242 OUTREG(CRTC_V_TOTAL_DISP, mode->crtc_v_total_disp);
1243 OUTREG(CRTC_V_SYNC_STRT_WID, mode->crtc_v_sync_strt_wid);
1244 OUTREG(CRTC_OFFSET, 0);
1245 OUTREG(CRTC_OFFSET_CNTL, 0);
1246 OUTREG(CRTC_PITCH, mode->crtc_pitch);
1247 OUTREG(SURFACE_CNTL, mode->surface_cntl);
1249 radeon_write_pll_regs(rinfo, mode);
1251 if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD)) {
1252 OUTREG(FP_CRTC_H_TOTAL_DISP, mode->fp_crtc_h_total_disp);
1253 OUTREG(FP_CRTC_V_TOTAL_DISP, mode->fp_crtc_v_total_disp);
1254 OUTREG(FP_H_SYNC_STRT_WID, mode->fp_h_sync_strt_wid);
1255 OUTREG(FP_V_SYNC_STRT_WID, mode->fp_v_sync_strt_wid);
1256 OUTREG(FP_HORZ_STRETCH, mode->fp_horz_stretch);
1257 OUTREG(FP_VERT_STRETCH, mode->fp_vert_stretch);
1258 OUTREG(FP_GEN_CNTL, mode->fp_gen_cntl);
1259 OUTREG(TMDS_CRC, mode->tmds_crc);
1260 OUTREG(TMDS_TRANSMITTER_CNTL, mode->tmds_transmitter_cntl);
1262 if (primary_mon == MT_LCD) {
1263 unsigned int tmp = INREG(LVDS_GEN_CNTL);
1265 /* HACK: The backlight control code may have modified init_state.lvds_gen_cntl,
1266 * so we update ourselves
1268 mode->lvds_gen_cntl &= ~LVDS_STATE_MASK;
1269 mode->lvds_gen_cntl |= (rinfo->init_state.lvds_gen_cntl & LVDS_STATE_MASK);
1271 if ((tmp & (LVDS_ON | LVDS_BLON)) ==
1272 (mode->lvds_gen_cntl & (LVDS_ON | LVDS_BLON))) {
1273 OUTREG(LVDS_GEN_CNTL, mode->lvds_gen_cntl);
1275 rinfo->pending_pixclks_cntl = INPLL(PIXCLKS_CNTL);
1276 if (rinfo->is_mobility || rinfo->is_IGP)
1277 OUTPLLP(PIXCLKS_CNTL, 0, ~PIXCLK_LVDS_ALWAYS_ONb);
1278 if (!(tmp & (LVDS_ON | LVDS_BLON)))
1279 OUTREG(LVDS_GEN_CNTL, mode->lvds_gen_cntl | LVDS_BLON);
1280 rinfo->pending_lvds_gen_cntl = mode->lvds_gen_cntl;
1281 mod_timer(&rinfo->lvds_timer,
1282 jiffies + MS_TO_HZ(rinfo->panel_info.pwr_delay));
1287 RTRACE("lvds_gen_cntl: %08x\n", INREG(LVDS_GEN_CNTL));
1289 radeon_screen_blank(rinfo, VESA_NO_BLANKING);
1291 OUTPLL(VCLK_ECP_CNTL, mode->vclk_ecp_cntl);
1297 * Calculate the PLL values for a given mode
1299 static void radeon_calc_pll_regs(struct radeonfb_info *rinfo, struct radeon_regs *regs,
1317 int fb_div, pll_output_freq = 0;
1320 /* Check if the DVO port is enabled and sourced from the primary CRTC. I'm
1321 * not sure which model starts having FP2_GEN_CNTL, I assume anything more
1322 * recent than an r(v)100...
1325 /* XXX I had reports of flicker happening with the cinema display
1326 * on TMDS1 that seem to be fixed if I also forbit odd dividers in
1327 * this case. This could just be a bandwidth calculation issue, I
1328 * haven't implemented the bandwidth code yet, but in the meantime,
1329 * forcing uses_dvo to 1 fixes it and shouln't have bad side effects,
1330 * I haven't seen a case were were absolutely needed an odd PLL
1331 * divider. I'll find a better fix once I have more infos on the
1332 * real cause of the problem.
1334 while (rinfo->has_CRTC2) {
1335 u32 fp2_gen_cntl = INREG(FP2_GEN_CNTL);
1336 u32 disp_output_cntl;
1339 /* FP2 path not enabled */
1340 if ((fp2_gen_cntl & FP2_ON) == 0)
1342 /* Not all chip revs have the same format for this register,
1343 * extract the source selection
1345 if (rinfo->family == CHIP_FAMILY_R200 ||
1346 rinfo->family == CHIP_FAMILY_R300 ||
1347 rinfo->family == CHIP_FAMILY_R350 ||
1348 rinfo->family == CHIP_FAMILY_RV350) {
1349 source = (fp2_gen_cntl >> 10) & 0x3;
1350 /* sourced from transform unit, check for transform unit
1354 disp_output_cntl = INREG(DISP_OUTPUT_CNTL);
1355 source = (disp_output_cntl >> 12) & 0x3;
1358 source = (fp2_gen_cntl >> 13) & 0x1;
1359 /* sourced from CRTC2 -> exit */
1363 /* so we end up on CRTC1, let's set uses_dvo to 1 now */
1370 if (freq > rinfo->pll.ppll_max)
1371 freq = rinfo->pll.ppll_max;
1372 if (freq*12 < rinfo->pll.ppll_min)
1373 freq = rinfo->pll.ppll_min / 12;
1375 for (post_div = &post_divs[0]; post_div->divider; ++post_div) {
1376 pll_output_freq = post_div->divider * freq;
1377 /* If we output to the DVO port (external TMDS), we don't allow an
1378 * odd PLL divider as those aren't supported on this path
1380 if (uses_dvo && (post_div->divider & 1))
1382 if (pll_output_freq >= rinfo->pll.ppll_min &&
1383 pll_output_freq <= rinfo->pll.ppll_max)
1387 fb_div = round_div(rinfo->pll.ref_div*pll_output_freq,
1388 rinfo->pll.ref_clk);
1389 regs->ppll_ref_div = rinfo->pll.ref_div;
1390 regs->ppll_div_3 = fb_div | (post_div->bitvalue << 16);
1392 RTRACE("post div = 0x%x\n", post_div->bitvalue);
1393 RTRACE("fb_div = 0x%x\n", fb_div);
1394 RTRACE("ppll_div_3 = 0x%x\n", regs->ppll_div_3);
1397 int radeonfb_set_par(struct fb_info *info)
1399 struct radeonfb_info *rinfo = info->par;
1400 struct fb_var_screeninfo *mode = &info->var;
1401 struct radeon_regs newmode;
1402 int hTotal, vTotal, hSyncStart, hSyncEnd,
1403 hSyncPol, vSyncStart, vSyncEnd, vSyncPol, cSync;
1404 u8 hsync_adj_tab[] = {0, 0x12, 9, 9, 6, 5};
1405 u8 hsync_fudge_fp[] = {2, 2, 0, 0, 5, 5};
1406 u32 sync, h_sync_pol, v_sync_pol, dotClock, pixClock;
1410 int hsync_start, hsync_fudge, bytpp, hsync_wid, vsync_wid;
1411 int primary_mon = PRIMARY_MONITOR(rinfo);
1412 int depth = var_to_depth(mode);
1414 /* We always want engine to be idle on a mode switch, even
1415 * if we won't actually change the mode
1417 radeon_engine_idle();
1419 hSyncStart = mode->xres + mode->right_margin;
1420 hSyncEnd = hSyncStart + mode->hsync_len;
1421 hTotal = hSyncEnd + mode->left_margin;
1423 vSyncStart = mode->yres + mode->lower_margin;
1424 vSyncEnd = vSyncStart + mode->vsync_len;
1425 vTotal = vSyncEnd + mode->upper_margin;
1426 pixClock = mode->pixclock;
1429 h_sync_pol = sync & FB_SYNC_HOR_HIGH_ACT ? 0 : 1;
1430 v_sync_pol = sync & FB_SYNC_VERT_HIGH_ACT ? 0 : 1;
1432 if (primary_mon == MT_DFP || primary_mon == MT_LCD) {
1433 if (rinfo->panel_info.xres < mode->xres)
1434 mode->xres = rinfo->panel_info.xres;
1435 if (rinfo->panel_info.yres < mode->yres)
1436 mode->yres = rinfo->panel_info.yres;
1438 hTotal = mode->xres + rinfo->panel_info.hblank;
1439 hSyncStart = mode->xres + rinfo->panel_info.hOver_plus;
1440 hSyncEnd = hSyncStart + rinfo->panel_info.hSync_width;
1442 vTotal = mode->yres + rinfo->panel_info.vblank;
1443 vSyncStart = mode->yres + rinfo->panel_info.vOver_plus;
1444 vSyncEnd = vSyncStart + rinfo->panel_info.vSync_width;
1446 h_sync_pol = !rinfo->panel_info.hAct_high;
1447 v_sync_pol = !rinfo->panel_info.vAct_high;
1449 pixClock = 100000000 / rinfo->panel_info.clock;
1451 if (rinfo->panel_info.use_bios_dividers) {
1453 newmode.ppll_div_3 = rinfo->panel_info.fbk_divider |
1454 (rinfo->panel_info.post_divider << 16);
1455 newmode.ppll_ref_div = rinfo->panel_info.ref_divider;
1458 dotClock = 1000000000 / pixClock;
1459 freq = dotClock / 10; /* x100 */
1461 RTRACE("hStart = %d, hEnd = %d, hTotal = %d\n",
1462 hSyncStart, hSyncEnd, hTotal);
1463 RTRACE("vStart = %d, vEnd = %d, vTotal = %d\n",
1464 vSyncStart, vSyncEnd, vTotal);
1466 hsync_wid = (hSyncEnd - hSyncStart) / 8;
1467 vsync_wid = vSyncEnd - vSyncStart;
1470 else if (hsync_wid > 0x3f) /* max */
1475 else if (vsync_wid > 0x1f) /* max */
1478 hSyncPol = mode->sync & FB_SYNC_HOR_HIGH_ACT ? 0 : 1;
1479 vSyncPol = mode->sync & FB_SYNC_VERT_HIGH_ACT ? 0 : 1;
1481 cSync = mode->sync & FB_SYNC_COMP_HIGH_ACT ? (1 << 4) : 0;
1483 format = radeon_get_dstbpp(depth);
1484 bytpp = mode->bits_per_pixel >> 3;
1486 if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD))
1487 hsync_fudge = hsync_fudge_fp[format-1];
1489 hsync_fudge = hsync_adj_tab[format-1];
1491 hsync_start = hSyncStart - 8 + hsync_fudge;
1493 newmode.crtc_gen_cntl = CRTC_EXT_DISP_EN | CRTC_EN |
1496 /* Clear auto-center etc... */
1497 newmode.crtc_more_cntl = rinfo->init_state.crtc_more_cntl;
1498 newmode.crtc_more_cntl &= 0xfffffff0;
1500 if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD)) {
1501 newmode.crtc_ext_cntl = VGA_ATI_LINEAR | XCRT_CNT_EN;
1503 newmode.crtc_ext_cntl |= CRTC_CRT_ON;
1505 newmode.crtc_gen_cntl &= ~(CRTC_DBL_SCAN_EN |
1508 newmode.crtc_ext_cntl = VGA_ATI_LINEAR | XCRT_CNT_EN |
1512 newmode.dac_cntl = /* INREG(DAC_CNTL) | */ DAC_MASK_ALL | DAC_VGA_ADR_EN |
1515 newmode.crtc_h_total_disp = ((((hTotal / 8) - 1) & 0x3ff) |
1516 (((mode->xres / 8) - 1) << 16));
1518 newmode.crtc_h_sync_strt_wid = ((hsync_start & 0x1fff) |
1519 (hsync_wid << 16) | (h_sync_pol << 23));
1521 newmode.crtc_v_total_disp = ((vTotal - 1) & 0xffff) |
1522 ((mode->yres - 1) << 16);
1524 newmode.crtc_v_sync_strt_wid = (((vSyncStart - 1) & 0xfff) |
1525 (vsync_wid << 16) | (v_sync_pol << 23));
1527 if (!radeon_accel_disabled()) {
1528 /* We first calculate the engine pitch */
1529 rinfo->pitch = ((mode->xres_virtual * ((mode->bits_per_pixel + 1) / 8) + 0x3f)
1532 /* Then, re-multiply it to get the CRTC pitch */
1533 newmode.crtc_pitch = (rinfo->pitch << 3) / ((mode->bits_per_pixel + 1) / 8);
1535 newmode.crtc_pitch = (mode->xres_virtual >> 3);
1537 newmode.crtc_pitch |= (newmode.crtc_pitch << 16);
1540 * It looks like recent chips have a problem with SURFACE_CNTL,
1541 * setting SURF_TRANSLATION_DIS completely disables the
1542 * swapper as well, so we leave it unset now.
1544 newmode.surface_cntl = 0;
1546 #if defined(__BIG_ENDIAN)
1548 /* Setup swapping on both apertures, though we currently
1549 * only use aperture 0, enabling swapper on aperture 1
1552 switch (mode->bits_per_pixel) {
1554 newmode.surface_cntl |= NONSURF_AP0_SWP_16BPP;
1555 newmode.surface_cntl |= NONSURF_AP1_SWP_16BPP;
1559 newmode.surface_cntl |= NONSURF_AP0_SWP_32BPP;
1560 newmode.surface_cntl |= NONSURF_AP1_SWP_32BPP;
1565 /* Clear surface registers */
1566 for (i=0; i<8; i++) {
1567 newmode.surf_lower_bound[i] = 0;
1568 newmode.surf_upper_bound[i] = 0x1f;
1569 newmode.surf_info[i] = 0;
1572 RTRACE("h_total_disp = 0x%x\t hsync_strt_wid = 0x%x\n",
1573 newmode.crtc_h_total_disp, newmode.crtc_h_sync_strt_wid);
1574 RTRACE("v_total_disp = 0x%x\t vsync_strt_wid = 0x%x\n",
1575 newmode.crtc_v_total_disp, newmode.crtc_v_sync_strt_wid);
1577 rinfo->bpp = mode->bits_per_pixel;
1578 rinfo->depth = depth;
1580 RTRACE("pixclock = %lu\n", (unsigned long)pixClock);
1581 RTRACE("freq = %lu\n", (unsigned long)freq);
1584 radeon_calc_pll_regs(rinfo, &newmode, freq);
1586 newmode.vclk_ecp_cntl = rinfo->init_state.vclk_ecp_cntl;
1588 if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD)) {
1589 unsigned int hRatio, vRatio;
1591 if (mode->xres > rinfo->panel_info.xres)
1592 mode->xres = rinfo->panel_info.xres;
1593 if (mode->yres > rinfo->panel_info.yres)
1594 mode->yres = rinfo->panel_info.yres;
1596 newmode.fp_horz_stretch = (((rinfo->panel_info.xres / 8) - 1)
1597 << HORZ_PANEL_SHIFT);
1598 newmode.fp_vert_stretch = ((rinfo->panel_info.yres - 1)
1599 << VERT_PANEL_SHIFT);
1601 if (mode->xres != rinfo->panel_info.xres) {
1602 hRatio = round_div(mode->xres * HORZ_STRETCH_RATIO_MAX,
1603 rinfo->panel_info.xres);
1604 newmode.fp_horz_stretch = (((((unsigned long)hRatio) & HORZ_STRETCH_RATIO_MASK)) |
1605 (newmode.fp_horz_stretch &
1606 (HORZ_PANEL_SIZE | HORZ_FP_LOOP_STRETCH |
1607 HORZ_AUTO_RATIO_INC)));
1608 newmode.fp_horz_stretch |= (HORZ_STRETCH_BLEND |
1609 HORZ_STRETCH_ENABLE);
1611 newmode.fp_horz_stretch &= ~HORZ_AUTO_RATIO;
1613 if (mode->yres != rinfo->panel_info.yres) {
1614 vRatio = round_div(mode->yres * VERT_STRETCH_RATIO_MAX,
1615 rinfo->panel_info.yres);
1616 newmode.fp_vert_stretch = (((((unsigned long)vRatio) & VERT_STRETCH_RATIO_MASK)) |
1617 (newmode.fp_vert_stretch &
1618 (VERT_PANEL_SIZE | VERT_STRETCH_RESERVED)));
1619 newmode.fp_vert_stretch |= (VERT_STRETCH_BLEND |
1620 VERT_STRETCH_ENABLE);
1622 newmode.fp_vert_stretch &= ~VERT_AUTO_RATIO_EN;
1624 newmode.fp_gen_cntl = (rinfo->init_state.fp_gen_cntl & (u32)
1626 FP_RMX_HVSYNC_CONTROL_EN |
1631 FP_CRTC_USE_SHADOW_VEND |
1634 newmode.fp_gen_cntl |= (FP_CRTC_DONT_SHADOW_VPAR |
1635 FP_CRTC_DONT_SHADOW_HEND);
1637 newmode.lvds_gen_cntl = rinfo->init_state.lvds_gen_cntl;
1638 newmode.lvds_pll_cntl = rinfo->init_state.lvds_pll_cntl;
1639 newmode.tmds_crc = rinfo->init_state.tmds_crc;
1640 newmode.tmds_transmitter_cntl = rinfo->init_state.tmds_transmitter_cntl;
1642 if (primary_mon == MT_LCD) {
1643 newmode.lvds_gen_cntl |= (LVDS_ON | LVDS_BLON);
1644 newmode.fp_gen_cntl &= ~(FP_FPON | FP_TMDS_EN);
1647 newmode.fp_gen_cntl |= (FP_FPON | FP_TMDS_EN);
1648 newmode.tmds_transmitter_cntl = (TMDS_RAN_PAT_RST | TMDS_ICHCSEL) &
1650 /* TMDS_PLL_EN bit is reversed on RV (and mobility) chips */
1651 if ((rinfo->family == CHIP_FAMILY_R300) ||
1652 (rinfo->family == CHIP_FAMILY_R350) ||
1653 (rinfo->family == CHIP_FAMILY_RV350) ||
1654 (rinfo->family == CHIP_FAMILY_R200) || !rinfo->has_CRTC2)
1655 newmode.tmds_transmitter_cntl &= ~TMDS_PLL_EN;
1657 newmode.tmds_transmitter_cntl |= TMDS_PLL_EN;
1658 newmode.crtc_ext_cntl &= ~CRTC_CRT_ON;
1661 newmode.fp_crtc_h_total_disp = (((rinfo->panel_info.hblank / 8) & 0x3ff) |
1662 (((mode->xres / 8) - 1) << 16));
1663 newmode.fp_crtc_v_total_disp = (rinfo->panel_info.vblank & 0xffff) |
1664 ((mode->yres - 1) << 16);
1665 newmode.fp_h_sync_strt_wid = ((rinfo->panel_info.hOver_plus & 0x1fff) |
1666 (hsync_wid << 16) | (h_sync_pol << 23));
1667 newmode.fp_v_sync_strt_wid = ((rinfo->panel_info.vOver_plus & 0xfff) |
1668 (vsync_wid << 16) | (v_sync_pol << 23));
1672 if (!rinfo->asleep) {
1673 radeon_write_mode (rinfo, &newmode);
1674 /* (re)initialize the engine */
1675 if (!radeon_accel_disabled())
1676 radeonfb_engine_init (rinfo);
1680 if (!radeon_accel_disabled())
1681 info->fix.line_length = rinfo->pitch*64;
1683 info->fix.line_length = mode->xres_virtual
1684 * ((mode->bits_per_pixel + 1) / 8);
1685 info->fix.visual = rinfo->depth == 8 ? FB_VISUAL_PSEUDOCOLOR
1686 : FB_VISUAL_DIRECTCOLOR;
1688 #ifdef CONFIG_BOOTX_TEXT
1689 /* Update debug text engine */
1690 btext_update_display(rinfo->fb_base_phys, mode->xres, mode->yres,
1691 rinfo->depth, info->fix.line_length);
1699 static ssize_t radeonfb_read(struct file *file, char *buf, size_t count, loff_t *ppos)
1701 unsigned long p = *ppos;
1702 struct inode *inode = file->f_dentry->d_inode;
1703 int fbidx = iminor(inode);
1704 struct fb_info *info = registered_fb[fbidx];
1705 struct radeonfb_info *rinfo = info->par;
1707 if (p >= rinfo->mapped_vram)
1709 if (count >= rinfo->mapped_vram)
1710 count = rinfo->mapped_vram;
1711 if (count + p > rinfo->mapped_vram)
1712 count = rinfo->mapped_vram - p;
1713 radeonfb_sync(info);
1717 base_addr = info->screen_base;
1718 count -= copy_to_user(buf, base_addr+p, count);
1726 static ssize_t radeonfb_write(struct file *file, const char *buf, size_t count,
1729 unsigned long p = *ppos;
1730 struct inode *inode = file->f_dentry->d_inode;
1731 int fbidx = iminor(inode);
1732 struct fb_info *info = registered_fb[fbidx];
1733 struct radeonfb_info *rinfo = info->par;
1736 if (p > rinfo->mapped_vram)
1738 if (count >= rinfo->mapped_vram)
1739 count = rinfo->mapped_vram;
1741 if (count + p > rinfo->mapped_vram) {
1742 count = rinfo->mapped_vram - p;
1745 radeonfb_sync(info);
1749 base_addr = info->screen_base;
1750 count -= copy_from_user(base_addr+p, buf, count);
1760 static struct fb_ops radeonfb_ops = {
1761 .owner = THIS_MODULE,
1762 .fb_check_var = radeonfb_check_var,
1763 .fb_set_par = radeonfb_set_par,
1764 .fb_setcolreg = radeonfb_setcolreg,
1765 .fb_pan_display = radeonfb_pan_display,
1766 .fb_blank = radeonfb_blank,
1767 .fb_ioctl = radeonfb_ioctl,
1768 .fb_sync = radeonfb_sync,
1769 .fb_fillrect = radeonfb_fillrect,
1770 .fb_copyarea = radeonfb_copyarea,
1771 .fb_imageblit = radeonfb_imageblit,
1772 .fb_read = radeonfb_read,
1773 .fb_write = radeonfb_write,
1774 .fb_cursor = soft_cursor,
1778 static int __devinit radeon_set_fbinfo (struct radeonfb_info *rinfo)
1780 struct fb_info *info = rinfo->info;
1784 info->pseudo_palette = rinfo->pseudo_palette;
1785 info->flags = FBINFO_FLAG_DEFAULT;
1786 info->fbops = &radeonfb_ops;
1787 info->screen_base = (char *)rinfo->fb_base;
1789 /* Fill fix common fields */
1790 strlcpy(info->fix.id, rinfo->name, sizeof(info->fix.id));
1791 info->fix.smem_start = rinfo->fb_base_phys;
1792 info->fix.smem_len = rinfo->video_ram;
1793 info->fix.type = FB_TYPE_PACKED_PIXELS;
1794 info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
1795 info->fix.xpanstep = 8;
1796 info->fix.ypanstep = 1;
1797 info->fix.ywrapstep = 0;
1798 info->fix.type_aux = 0;
1799 info->fix.mmio_start = rinfo->mmio_base_phys;
1800 info->fix.mmio_len = RADEON_REGSIZE;
1801 if (radeon_accel_disabled())
1802 info->fix.accel = FB_ACCEL_NONE;
1804 info->fix.accel = FB_ACCEL_ATI_RADEON;
1806 fb_alloc_cmap(&info->cmap, 256, 0);
1808 if (radeon_accel_disabled())
1809 info->var.accel_flags &= ~FB_ACCELF_TEXT;
1811 info->var.accel_flags |= FB_ACCELF_TEXT;
1817 #ifdef CONFIG_PMAC_BACKLIGHT
1819 /* TODO: Dbl check these tables, we don't go up to full ON backlight
1820 * in these, possibly because we noticed MacOS doesn't, but I'd prefer
1821 * having some more official numbers from ATI
1823 static int backlight_conv_m6[] = {
1824 0xff, 0xc0, 0xb5, 0xaa, 0x9f, 0x94, 0x89, 0x7e,
1825 0x73, 0x68, 0x5d, 0x52, 0x47, 0x3c, 0x31, 0x24
1827 static int backlight_conv_m7[] = {
1828 0x00, 0x3f, 0x4a, 0x55, 0x60, 0x6b, 0x76, 0x81,
1829 0x8c, 0x97, 0xa2, 0xad, 0xb8, 0xc3, 0xce, 0xd9
1832 #define BACKLIGHT_LVDS_OFF
1833 #undef BACKLIGHT_DAC_OFF
1835 /* We turn off the LCD completely instead of just dimming the backlight.
1836 * This provides some greater power saving and the display is useless
1837 * without backlight anyway.
1839 static int radeon_set_backlight_enable(int on, int level, void *data)
1841 struct radeonfb_info *rinfo = (struct radeonfb_info *)data;
1842 unsigned int lvds_gen_cntl = INREG(LVDS_GEN_CNTL);
1843 unsigned long tmpPixclksCntl = INPLL(PIXCLKS_CNTL);
1846 if (rinfo->mon1_type != MT_LCD)
1849 /* Pardon me for that hack... maybe some day we can figure
1850 * out in what direction backlight should work on a given
1853 if ((rinfo->family == CHIP_FAMILY_RV200 ||
1854 rinfo->family == CHIP_FAMILY_RV250 ||
1855 rinfo->family == CHIP_FAMILY_RV280 ||
1856 rinfo->family == CHIP_FAMILY_RV350) &&
1857 !machine_is_compatible("PowerBook4,3") &&
1858 !machine_is_compatible("PowerBook6,3") &&
1859 !machine_is_compatible("PowerBook6,5"))
1860 conv_table = backlight_conv_m7;
1862 conv_table = backlight_conv_m6;
1864 del_timer_sync(&rinfo->lvds_timer);
1866 lvds_gen_cntl |= (LVDS_BL_MOD_EN | LVDS_BLON);
1867 if (on && (level > BACKLIGHT_OFF)) {
1868 lvds_gen_cntl |= LVDS_DIGON;
1869 if (!(lvds_gen_cntl & LVDS_ON)) {
1870 lvds_gen_cntl &= ~LVDS_BLON;
1871 OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
1872 (void)INREG(LVDS_GEN_CNTL);
1873 mdelay(rinfo->panel_info.pwr_delay);/* OUCH !!! FIXME */
1874 lvds_gen_cntl |= LVDS_BLON;
1875 OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
1877 lvds_gen_cntl &= ~LVDS_BL_MOD_LEVEL_MASK;
1878 lvds_gen_cntl |= (conv_table[level] <<
1879 LVDS_BL_MOD_LEVEL_SHIFT);
1880 lvds_gen_cntl |= (LVDS_ON | LVDS_EN);
1881 lvds_gen_cntl &= ~LVDS_DISPLAY_DIS;
1883 /* Asic bug, when turning off LVDS_ON, we have to make sure
1884 RADEON_PIXCLK_LVDS_ALWAYS_ON bit is off
1886 if (rinfo->is_mobility || rinfo->is_IGP)
1887 OUTPLLP(PIXCLKS_CNTL, 0, ~PIXCLK_LVDS_ALWAYS_ONb);
1888 lvds_gen_cntl &= ~LVDS_BL_MOD_LEVEL_MASK;
1889 lvds_gen_cntl |= (conv_table[0] <<
1890 LVDS_BL_MOD_LEVEL_SHIFT);
1891 lvds_gen_cntl |= LVDS_DISPLAY_DIS | LVDS_BLON;
1892 OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
1893 mdelay(rinfo->panel_info.pwr_delay);/* OUCH !!! FIXME */
1894 lvds_gen_cntl &= ~(LVDS_ON | LVDS_EN | LVDS_BLON | LVDS_DIGON);
1897 OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
1898 if (rinfo->is_mobility || rinfo->is_IGP)
1899 OUTPLL(PIXCLKS_CNTL, tmpPixclksCntl);
1900 rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
1901 rinfo->init_state.lvds_gen_cntl |= (lvds_gen_cntl & LVDS_STATE_MASK);
1907 static int radeon_set_backlight_level(int level, void *data)
1909 return radeon_set_backlight_enable(1, level, data);
1911 #endif /* CONFIG_PMAC_BACKLIGHT */
1915 * This reconfigure the card's internal memory map. In theory, we'd like
1916 * to setup the card's memory at the same address as it's PCI bus address,
1917 * and the AGP aperture right after that so that system RAM on 32 bits
1918 * machines at least, is directly accessible. However, doing so would
1919 * conflict with the current XFree drivers...
1920 * Ultimately, I hope XFree, GATOS and ATI binary drivers will all agree
1921 * on the proper way to set this up and duplicate this here. In the meantime,
1922 * I put the card's memory at 0 in card space and AGP at some random high
1923 * local (0xe0000000 for now) that will be changed by XFree/DRI anyway
1925 #ifdef CONFIG_PPC_OF
1926 #undef SET_MC_FB_FROM_APERTURE
1927 static void fixup_memory_mappings(struct radeonfb_info *rinfo)
1929 u32 save_crtc_gen_cntl, save_crtc2_gen_cntl;
1930 u32 save_crtc_ext_cntl;
1931 u32 aper_base, aper_size;
1934 /* First, we disable display to avoid interfering */
1935 if (rinfo->has_CRTC2) {
1936 save_crtc2_gen_cntl = INREG(CRTC2_GEN_CNTL);
1937 OUTREG(CRTC2_GEN_CNTL, save_crtc2_gen_cntl | CRTC2_DISP_REQ_EN_B);
1939 save_crtc_gen_cntl = INREG(CRTC_GEN_CNTL);
1940 save_crtc_ext_cntl = INREG(CRTC_EXT_CNTL);
1942 OUTREG(CRTC_EXT_CNTL, save_crtc_ext_cntl | CRTC_DISPLAY_DIS);
1943 OUTREG(CRTC_GEN_CNTL, save_crtc_gen_cntl | CRTC_DISP_REQ_EN_B);
1946 aper_base = INREG(CONFIG_APER_0_BASE);
1947 aper_size = INREG(CONFIG_APER_SIZE);
1949 #ifdef SET_MC_FB_FROM_APERTURE
1950 /* Set framebuffer to be at the same address as set in PCI BAR */
1951 OUTREG(MC_FB_LOCATION,
1952 ((aper_base + aper_size - 1) & 0xffff0000) | (aper_base >> 16));
1953 rinfo->fb_local_base = aper_base;
1955 OUTREG(MC_FB_LOCATION, 0x7fff0000);
1956 rinfo->fb_local_base = 0;
1958 agp_base = aper_base + aper_size;
1959 if (agp_base & 0xf0000000)
1960 agp_base = (aper_base | 0x0fffffff) + 1;
1962 /* Set AGP to be just after the framebuffer on a 256Mb boundary. This
1963 * assumes the FB isn't mapped to 0xf0000000 or above, but this is
1964 * always the case on PPCs afaik.
1966 #ifdef SET_MC_FB_FROM_APERTURE
1967 OUTREG(MC_AGP_LOCATION, 0xffff0000 | (agp_base >> 16));
1969 OUTREG(MC_AGP_LOCATION, 0xffffe000);
1972 /* Fixup the display base addresses & engine offsets while we
1975 #ifdef SET_MC_FB_FROM_APERTURE
1976 OUTREG(DISPLAY_BASE_ADDR, aper_base);
1977 if (rinfo->has_CRTC2)
1978 OUTREG(CRTC2_DISPLAY_BASE_ADDR, aper_base);
1980 OUTREG(DISPLAY_BASE_ADDR, 0);
1981 if (rinfo->has_CRTC2)
1982 OUTREG(CRTC2_DISPLAY_BASE_ADDR, 0);
1986 /* Restore display settings */
1987 OUTREG(CRTC_GEN_CNTL, save_crtc_gen_cntl);
1988 OUTREG(CRTC_EXT_CNTL, save_crtc_ext_cntl);
1989 if (rinfo->has_CRTC2)
1990 OUTREG(CRTC2_GEN_CNTL, save_crtc2_gen_cntl);
1992 RTRACE("aper_base: %08x MC_FB_LOC to: %08x, MC_AGP_LOC to: %08x\n",
1994 ((aper_base + aper_size - 1) & 0xffff0000) | (aper_base >> 16),
1995 0xffff0000 | (agp_base >> 16));
1997 #endif /* CONFIG_PPC_OF */
2004 static ssize_t radeon_show_one_edid(char *buf, loff_t off, size_t count, const u8 *edid)
2006 if (off > EDID_LENGTH)
2009 if (off + count > EDID_LENGTH)
2010 count = EDID_LENGTH - off;
2012 memcpy(buf, edid + off, count);
2018 static ssize_t radeon_show_edid1(struct kobject *kobj, char *buf, loff_t off, size_t count)
2020 struct device *dev = container_of(kobj, struct device, kobj);
2021 struct pci_dev *pdev = to_pci_dev(dev);
2022 struct fb_info *info = pci_get_drvdata(pdev);
2023 struct radeonfb_info *rinfo = info->par;
2025 return radeon_show_one_edid(buf, off, count, rinfo->mon1_EDID);
2029 static ssize_t radeon_show_edid2(struct kobject *kobj, char *buf, loff_t off, size_t count)
2031 struct device *dev = container_of(kobj, struct device, kobj);
2032 struct pci_dev *pdev = to_pci_dev(dev);
2033 struct fb_info *info = pci_get_drvdata(pdev);
2034 struct radeonfb_info *rinfo = info->par;
2036 return radeon_show_one_edid(buf, off, count, rinfo->mon2_EDID);
2039 static struct bin_attribute edid1_attr = {
2042 .owner = THIS_MODULE,
2045 .size = EDID_LENGTH,
2046 .read = radeon_show_edid1,
2049 static struct bin_attribute edid2_attr = {
2052 .owner = THIS_MODULE,
2055 .size = EDID_LENGTH,
2056 .read = radeon_show_edid2,
2060 static int radeonfb_pci_register (struct pci_dev *pdev,
2061 const struct pci_device_id *ent)
2063 struct fb_info *info;
2064 struct radeonfb_info *rinfo;
2067 RTRACE("radeonfb_pci_register BEGIN\n");
2069 /* Enable device in PCI config */
2070 if (pci_enable_device(pdev) != 0) {
2071 printk(KERN_ERR "radeonfb: Cannot enable PCI device\n");
2075 info = framebuffer_alloc(sizeof(struct radeonfb_info), &pdev->dev);
2077 printk (KERN_ERR "radeonfb: could not allocate memory\n");
2084 spin_lock_init(&rinfo->reg_lock);
2085 init_timer(&rinfo->lvds_timer);
2086 rinfo->lvds_timer.function = radeon_lvds_timer_func;
2087 rinfo->lvds_timer.data = (unsigned long)rinfo;
2089 strcpy(rinfo->name, "ATI Radeon XX ");
2090 rinfo->name[11] = ent->device >> 8;
2091 rinfo->name[12] = ent->device & 0xFF;
2092 rinfo->family = ent->driver_data & CHIP_FAMILY_MASK;
2093 rinfo->chipset = pdev->device;
2094 rinfo->has_CRTC2 = (ent->driver_data & CHIP_HAS_CRTC2) != 0;
2095 rinfo->is_mobility = (ent->driver_data & CHIP_IS_MOBILITY) != 0;
2096 rinfo->is_IGP = (ent->driver_data & CHIP_IS_IGP) != 0;
2098 /* Set base addrs */
2099 rinfo->fb_base_phys = pci_resource_start (pdev, 0);
2100 rinfo->mmio_base_phys = pci_resource_start (pdev, 2);
2102 /* request the mem regions */
2103 if (!request_mem_region (rinfo->fb_base_phys,
2104 pci_resource_len(pdev, 0), "radeonfb")) {
2105 printk (KERN_ERR "radeonfb: cannot reserve FB region\n");
2109 if (!request_mem_region (rinfo->mmio_base_phys,
2110 pci_resource_len(pdev, 2), "radeonfb")) {
2111 printk (KERN_ERR "radeonfb: cannot reserve MMIO region\n");
2115 /* map the regions */
2116 rinfo->mmio_base = (unsigned long) ioremap (rinfo->mmio_base_phys, RADEON_REGSIZE);
2117 if (!rinfo->mmio_base) {
2118 printk (KERN_ERR "radeonfb: cannot map MMIO\n");
2122 /* On PPC, the firmware sets up a memory mapping that tends
2123 * to cause lockups when enabling the engine. We reconfigure
2124 * the card internal memory mappings properly
2126 #ifdef CONFIG_PPC_OF
2127 fixup_memory_mappings(rinfo);
2129 rinfo->fb_local_base = INREG(MC_FB_LOCATION) << 16;
2130 #endif /* CONFIG_PPC_OF */
2132 /* framebuffer size */
2133 if ((rinfo->family == CHIP_FAMILY_RS100) ||
2134 (rinfo->family == CHIP_FAMILY_RS200) ||
2135 (rinfo->family == CHIP_FAMILY_RS300)) {
2136 u32 tom = INREG(NB_TOM);
2137 tmp = ((((tom >> 16) - (tom & 0xffff) + 1) << 6) * 1024);
2139 OUTREG(MC_FB_LOCATION, tom);
2140 OUTREG(DISPLAY_BASE_ADDR, (tom & 0xffff) << 16);
2141 OUTREG(CRTC2_DISPLAY_BASE_ADDR, (tom & 0xffff) << 16);
2142 OUTREG(OV0_BASE_ADDR, (tom & 0xffff) << 16);
2144 /* This is supposed to fix the crtc2 noise problem. */
2145 OUTREG(GRPH2_BUFFER_CNTL, INREG(GRPH2_BUFFER_CNTL) & ~0x7f0000);
2147 if ((rinfo->family == CHIP_FAMILY_RS100) ||
2148 (rinfo->family == CHIP_FAMILY_RS200)) {
2149 /* This is to workaround the asic bug for RMX, some versions
2150 of BIOS dosen't have this register initialized correctly.
2152 OUTREGP(CRTC_MORE_CNTL, CRTC_H_CUTOFF_ACTIVE_EN,
2153 ~CRTC_H_CUTOFF_ACTIVE_EN);
2156 tmp = INREG(CONFIG_MEMSIZE);
2159 /* mem size is bits [28:0], mask off the rest */
2160 rinfo->video_ram = tmp & CONFIG_MEMSIZE_MASK;
2163 tmp = INREG(MEM_SDRAM_MODE_REG);
2164 switch ((MEM_CFG_TYPE & tmp) >> 30) {
2166 /* SDR SGRAM (2:1) */
2167 strcpy(rinfo->ram_type, "SDR SGRAM");
2170 rinfo->ram.trcd = 1;
2174 rinfo->ram.loop_latency = 16;
2175 rinfo->ram.rloop = 16;
2179 strcpy(rinfo->ram_type, "DDR SGRAM");
2182 rinfo->ram.trcd = 3;
2186 rinfo->ram.tr2w = 1;
2187 rinfo->ram.loop_latency = 16;
2188 rinfo->ram.rloop = 16;
2191 /* 64-bit SDR SGRAM */
2192 strcpy(rinfo->ram_type, "SDR SGRAM 64");
2195 rinfo->ram.trcd = 3;
2199 rinfo->ram.tr2w = 1;
2200 rinfo->ram.loop_latency = 17;
2201 rinfo->ram.rloop = 17;
2206 * Hack to get around some busted production M6's
2209 if (rinfo->video_ram == 0) {
2210 switch (pdev->device) {
2211 case PCI_CHIP_RADEON_LY:
2212 case PCI_CHIP_RADEON_LZ:
2213 rinfo->video_ram = 8192 * 1024;
2220 RTRACE("radeonfb: probed %s %ldk videoram\n", (rinfo->ram_type), (rinfo->video_ram/1024));
2222 rinfo->mapped_vram = MAX_MAPPED_VRAM;
2223 if (rinfo->video_ram < rinfo->mapped_vram)
2224 rinfo->mapped_vram = rinfo->video_ram;
2226 rinfo->fb_base = (unsigned long) ioremap (rinfo->fb_base_phys,
2227 rinfo->mapped_vram);
2228 if (rinfo->fb_base == 0 && rinfo->mapped_vram > MIN_MAPPED_VRAM) {
2229 rinfo->mapped_vram /= 2;
2232 memset_io(rinfo->fb_base, 0, rinfo->mapped_vram);
2236 if (!rinfo->fb_base) {
2237 printk (KERN_ERR "radeonfb: cannot map FB\n");
2241 RTRACE("radeonfb: mapped %ldk videoram\n", rinfo->mapped_vram/1024);
2244 /* Argh. Scary arch !!! */
2246 rinfo->fb_base = IO_TOKEN_TO_ADDR(rinfo->fb_base);
2250 * Check for required workaround for PLL accesses
2252 rinfo->R300_cg_workaround = (rinfo->family == CHIP_FAMILY_R300 &&
2253 (INREG(CONFIG_CNTL) & CFG_ATI_REV_ID_MASK)
2254 == CFG_ATI_REV_A11);
2257 * Map the BIOS ROM if any and retreive PLL parameters from
2258 * either BIOS or Open Firmware
2260 radeon_map_ROM(rinfo, pdev);
2263 * On x86, the primary display on laptop may have it's BIOS
2264 * ROM elsewhere, try to locate it at the legacy memory hole.
2265 * We probably need to make sure this is the primary dispay,
2266 * but that is difficult without some arch support.
2269 if (rinfo->bios_seg == NULL)
2270 radeon_find_mem_vbios(rinfo);
2271 #endif /* __i386__ */
2273 /* Get informations about the board's PLL */
2274 radeon_get_pllinfo(rinfo);
2276 #ifdef CONFIG_FB_RADEON_I2C
2277 /* Register I2C bus */
2278 radeon_create_i2c_busses(rinfo);
2281 /* set all the vital stuff */
2282 radeon_set_fbinfo (rinfo);
2284 /* Probe screen types */
2285 radeon_probe_screens(rinfo, monitor_layout, ignore_edid);
2287 /* Build mode list, check out panel native model */
2288 radeon_check_modes(rinfo, mode_option);
2290 /* Register some sysfs stuff (should be done better) */
2291 if (rinfo->mon1_EDID)
2292 sysfs_create_bin_file(&rinfo->pdev->dev.kobj, &edid1_attr);
2293 if (rinfo->mon2_EDID)
2294 sysfs_create_bin_file(&rinfo->pdev->dev.kobj, &edid2_attr);
2296 /* save current mode regs before we switch into the new one
2297 * so we can restore this upon __exit
2299 radeon_save_state (rinfo, &rinfo->init_state);
2301 pci_set_drvdata(pdev, info);
2303 /* Enable PM on mobility chips */
2304 if (rinfo->is_mobility) {
2305 /* Find PM registers in config space */
2306 rinfo->pm_reg = pci_find_capability(pdev, PCI_CAP_ID_PM);
2307 /* Enable dynamic PM of chip clocks */
2308 radeon_pm_enable_dynamic_mode(rinfo);
2309 printk("radeonfb: Power Management enabled for Mobility chipsets\n");
2312 if (register_framebuffer(info) < 0) {
2313 printk (KERN_ERR "radeonfb: could not register framebuffer\n");
2318 rinfo->mtrr_hdl = nomtrr ? -1 : mtrr_add(rinfo->fb_base_phys,
2320 MTRR_TYPE_WRCOMB, 1);
2323 #ifdef CONFIG_PMAC_BACKLIGHT
2324 if (rinfo->mon1_type == MT_LCD) {
2325 register_backlight_controller(&radeon_backlight_controller,
2327 register_backlight_controller(&radeon_backlight_controller,
2332 printk ("radeonfb: %s %s %ld MB\n", rinfo->name, rinfo->ram_type,
2333 (rinfo->video_ram/(1024*1024)));
2335 if (rinfo->bios_seg)
2336 radeon_unmap_ROM(rinfo, pdev);
2337 RTRACE("radeonfb_pci_register END\n");
2341 iounmap ((void*)rinfo->fb_base);
2343 if (rinfo->mon1_EDID)
2344 kfree(rinfo->mon1_EDID);
2345 if (rinfo->mon2_EDID)
2346 kfree(rinfo->mon2_EDID);
2347 if (rinfo->mon1_modedb)
2348 fb_destroy_modedb(rinfo->mon1_modedb);
2349 #ifdef CONFIG_FB_RADEON_I2C
2350 radeon_delete_i2c_busses(rinfo);
2352 if (rinfo->bios_seg)
2353 radeon_unmap_ROM(rinfo, pdev);
2354 iounmap ((void*)rinfo->mmio_base);
2356 release_mem_region (rinfo->mmio_base_phys,
2357 pci_resource_len(pdev, 2));
2359 release_mem_region (rinfo->fb_base_phys,
2360 pci_resource_len(pdev, 0));
2362 framebuffer_release(info);
2368 static void __devexit radeonfb_pci_unregister (struct pci_dev *pdev)
2370 struct fb_info *info = pci_get_drvdata(pdev);
2371 struct radeonfb_info *rinfo = info->par;
2376 /* restore original state
2378 * Doesn't quite work yet, possibly because of the PPC hacking
2379 * I do on startup, disable for now. --BenH
2381 radeon_write_mode (rinfo, &rinfo->init_state);
2383 del_timer_sync(&rinfo->lvds_timer);
2386 if (rinfo->mtrr_hdl >= 0)
2387 mtrr_del(rinfo->mtrr_hdl, 0, 0);
2390 unregister_framebuffer(info);
2392 iounmap ((void*)rinfo->mmio_base);
2393 iounmap ((void*)rinfo->fb_base);
2395 release_mem_region (rinfo->mmio_base_phys,
2396 pci_resource_len(pdev, 2));
2397 release_mem_region (rinfo->fb_base_phys,
2398 pci_resource_len(pdev, 0));
2400 if (rinfo->mon1_EDID)
2401 kfree(rinfo->mon1_EDID);
2402 if (rinfo->mon2_EDID)
2403 kfree(rinfo->mon2_EDID);
2404 if (rinfo->mon1_modedb)
2405 fb_destroy_modedb(rinfo->mon1_modedb);
2406 #ifdef CONFIG_FB_RADEON_I2C
2407 radeon_delete_i2c_busses(rinfo);
2409 framebuffer_release(info);
2413 static struct pci_driver radeonfb_driver = {
2415 .id_table = radeonfb_pci_table,
2416 .probe = radeonfb_pci_register,
2417 .remove = __devexit_p(radeonfb_pci_unregister),
2419 .suspend = radeonfb_pci_suspend,
2420 .resume = radeonfb_pci_resume,
2421 #endif /* CONFIG_PM */
2425 int __init radeonfb_init (void)
2427 radeonfb_noaccel = noaccel;
2428 return pci_module_init (&radeonfb_driver);
2432 void __exit radeonfb_exit (void)
2434 pci_unregister_driver (&radeonfb_driver);
2437 int __init radeonfb_setup (char *options)
2441 if (!options || !*options)
2444 while ((this_opt = strsep (&options, ",")) != NULL) {
2448 if (!strncmp(this_opt, "noaccel", 7)) {
2449 noaccel = radeonfb_noaccel = 1;
2450 } else if (!strncmp(this_opt, "mirror", 6)) {
2452 } else if (!strncmp(this_opt, "force_dfp", 9)) {
2454 } else if (!strncmp(this_opt, "panel_yres:", 11)) {
2455 panel_yres = simple_strtoul((this_opt+11), NULL, 0);
2457 } else if (!strncmp(this_opt, "nomtrr", 6)) {
2460 } else if (!strncmp(this_opt, "nomodeset", 9)) {
2462 } else if (!strncmp(this_opt, "force_measure_pll", 17)) {
2463 force_measure_pll = 1;
2464 } else if (!strncmp(this_opt, "ignore_edid", 11)) {
2467 mode_option = this_opt;
2474 module_init(radeonfb_init);
2475 module_exit(radeonfb_exit);
2478 MODULE_AUTHOR("Ani Joshi");
2479 MODULE_DESCRIPTION("framebuffer driver for ATI Radeon chipset");
2480 MODULE_LICENSE("GPL");
2481 module_param(noaccel, bool, 0);
2482 MODULE_PARM_DESC(noaccel, "bool: disable acceleration");
2483 module_param(nomodeset, bool, 0);
2484 MODULE_PARM_DESC(nomodeset, "bool: disable actual setting of video mode");
2485 module_param(mirror, bool, 0);
2486 MODULE_PARM_DESC(mirror, "bool: mirror the display to both monitors");
2487 module_param(force_dfp, bool, 0);
2488 MODULE_PARM_DESC(force_dfp, "bool: force display to dfp");
2489 module_param(ignore_edid, bool, 0);
2490 MODULE_PARM_DESC(ignore_edid, "bool: Ignore EDID data when doing DDC probe");
2491 module_param(monitor_layout, charp, 0);
2492 MODULE_PARM_DESC(monitor_layout, "Specify monitor mapping (like XFree86)");
2493 module_param(force_measure_pll, bool, 0);
2494 MODULE_PARM_DESC(force_measure_pll, "Force measurement of PLL (debug)");
2496 module_param(nomtrr, bool, 0);
2497 MODULE_PARM_DESC(nomtrr, "bool: disable use of MTRR registers");
2499 module_param(panel_yres, int, 0);
2500 MODULE_PARM_DESC(panel_yres, "int: set panel yres");
2501 module_param(mode_option, charp, 0);
2502 MODULE_PARM_DESC(mode_option, "Specify resolution as \"<xres>x<yres>[-<bpp>][@<refresh>]\" ");