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