开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
radeonfb.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：81k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

radeonfb.c：源码内容
  1. /*
  2.  * drivers/video/radeonfb.c
  3.  * framebuffer driver for ATI Radeon chipset video boards
  4.  *
  5.  * Copyright 2000 Ani Joshi <ajoshi@unixbox.com>
  6.  *
  7.  *
  8.  * ChangeLog:
  9.  * 2000-08-03 initial version 0.0.1
  10.  * 2000-09-10 more bug fixes, public release 0.0.5
  11.  * 2001-02-19 mode bug fixes, 0.0.7
  12.  * 2001-07-05 fixed scrolling issues, engine initialization,
  13.  * and minor mode tweaking, 0.0.9
  14.  * 2001-09-07 Radeon VE support, Nick Kurshev
  15.  * blanking, pan_display, and cmap fixes, 0.1.0
  16.  * 2001-10-10 Radeon 7500 and 8500 support, and experimental
  17.  * flat panel support, 0.1.1
  18.  * 2001-11-17 Radeon M6 (ppc) support, Daniel Berlin, 0.1.2
  19.  * 2001-11-18 DFP fixes, Kevin Hendricks, 0.1.3
  20.  * 2001-11-29 more cmap, backlight fixes, Benjamin Herrenschmidt
  21.  * 2002-01-18 DFP panel detection via BIOS, Michael Clark, 0.1.4
  22.  *
  23.  * Special thanks to ATI DevRel team for their hardware donations.
  24.  *
  25.  */
  28. #define RADEON_VERSION "0.1.4"
  31. #include <linux/config.h>
  32. #include <linux/module.h>
  33. #include <linux/kernel.h>
  34. #include <linux/errno.h>
  35. #include <linux/string.h>
  36. #include <linux/mm.h>
  37. #include <linux/tty.h>
  38. #include <linux/slab.h>
  39. #include <linux/delay.h>
  40. #include <linux/fb.h>
  41. #include <linux/console.h>
  42. #include <linux/selection.h>
  43. #include <linux/ioport.h>
  44. #include <linux/init.h>
  45. #include <linux/pci.h>
  46. #include <linux/vmalloc.h>
  48. #include <asm/io.h>
  49. #if defined(__powerpc__)
  50. #include <asm/prom.h>
  51. #include <asm/pci-bridge.h>
  52. #include <video/macmodes.h>
  54. #ifdef CONFIG_NVRAM
  55. #include <linux/nvram.h>
  56. #endif
  58. #ifdef CONFIG_PMAC_BACKLIGHT
  59. #include <asm/backlight.h>
  60. #endif
  62. #ifdef CONFIG_BOOTX_TEXT
  63. #include <asm/btext.h>
  64. #endif
  66. #ifdef CONFIG_ADB_PMU
  67. #include <linux/adb.h>
  68. #include <linux/pmu.h>
  69. #endif
  71. #endif /* __powerpc__ */
  73. #include <video/fbcon.h> 
  74. #include <video/fbcon-cfb8.h>
  75. #include <video/fbcon-cfb16.h>
  76. #include <video/fbcon-cfb24.h>
  77. #include <video/fbcon-cfb32.h>
  79. #include "radeon.h"
  82. #define DEBUG 0
  84. #if DEBUG
  85. #define RTRACE printk
  86. #else
  87. #define RTRACE if(0) printk
  88. #endif
  92. enum radeon_chips {
  93. RADEON_QD, /* Radeon R100 */
  94. RADEON_QE, /* Radeon R100 */
  95. RADEON_QF, /* Radeon R100 */
  96. RADEON_QG, /* Radeon R100 */
  97. RADEON_QY, /* Radeon RV100 (VE) */
  98. RADEON_QZ, /* Radeon RV100 (VE) */
  99. RADEON_QL, /* Radeon R200 (8500) */
  100. RADEON_QW, /* Radeon RV200 (7500) */
  101. RADEON_LW, /* Radeon Mobility M7 */
  102. RADEON_LY, /* Radeon Mobility M6 */
  103. RADEON_LZ /* Radeon Mobility M6 */
  104. };
  107. enum radeon_montype
  108. {
  109. MT_NONE,
  110. MT_CRT, /* CRT */
  111. MT_LCD, /* LCD */
  112. MT_DFP, /* DVI */
  113. MT_CTV, /* composite TV */
  114. MT_STV /* S-Video out */
  115. };
  118. static struct pci_device_id radeonfb_pci_table[] __devinitdata = {
  119. { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_RADEON_QD, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RADEON_QD},
  120. { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_RADEON_QE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RADEON_QE},
  121. { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_RADEON_QF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RADEON_QF},
  122. { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_RADEON_QG, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RADEON_QG},
  123. { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_RADEON_QY, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RADEON_QY},
  124. { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_RADEON_QZ, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RADEON_QZ},
  125. { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_RADEON_QL, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RADEON_QL},
  126. { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_RADEON_QW, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RADEON_QW},
  127. { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_RADEON_LW, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RADEON_LW},
  128. { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_RADEON_LY, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RADEON_LY},
  129. { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_RADEON_LZ, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RADEON_LZ},
  130. { 0, }
  131. };
  132. MODULE_DEVICE_TABLE(pci, radeonfb_pci_table);
  135. typedef struct {
  136. u16 reg;
  137. u32 val;
  138. } reg_val;
  141. /* these common regs are cleared before mode setting so they do not
  142.  * interfere with anything
  143.  */
  144. reg_val common_regs[] = {
  145. { OVR_CLR, 0 },
  146. { OVR_WID_LEFT_RIGHT, 0 },
  147. { OVR_WID_TOP_BOTTOM, 0 },
  148. { OV0_SCALE_CNTL, 0 },
  149. { SUBPIC_CNTL, 0 },
  150. { VIPH_CONTROL, 0 },
  151. { I2C_CNTL_1, 0 },
  152. { GEN_INT_CNTL, 0 },
  153. { CAP0_TRIG_CNTL, 0 },
  154. };
  156. #define COMMON_REGS_SIZE = (sizeof(common_regs)/sizeof(common_regs[0]))
  158. typedef struct {
  159.         u8 clock_chip_type;
  160.         u8 struct_size;
  161.         u8 accelerator_entry;
  162.         u8 VGA_entry;
  163.         u16 VGA_table_offset;
  164.         u16 POST_table_offset;
  165.         u16 XCLK;
  166.         u16 MCLK;
  167.         u8 num_PLL_blocks;
  168.         u8 size_PLL_blocks;
  169.         u16 PCLK_ref_freq;
  170.         u16 PCLK_ref_divider;
  171.         u32 PCLK_min_freq;
  172.         u32 PCLK_max_freq;
  173.         u16 MCLK_ref_freq;
  174.         u16 MCLK_ref_divider;
  175.         u32 MCLK_min_freq;
  176.         u32 MCLK_max_freq;
  177.         u16 XCLK_ref_freq;
  178.         u16 XCLK_ref_divider;
  179.         u32 XCLK_min_freq;
  180.         u32 XCLK_max_freq;
  181. } __attribute__ ((packed)) PLL_BLOCK;
  184. struct pll_info {
  185. int ppll_max;
  186. int ppll_min;
  187. int xclk;
  188. int ref_div;
  189. int ref_clk;
  190. };
  193. struct ram_info {
  194. int ml;
  195. int mb;
  196. int trcd;
  197. int trp;
  198. int twr;
  199. int cl;
  200. int tr2w;
  201. int loop_latency;
  202. int rloop;
  203. };
  206. struct radeon_regs {
  207. /* CRTC regs */
  208. u32 crtc_h_total_disp;
  209. u32 crtc_h_sync_strt_wid;
  210. u32 crtc_v_total_disp;
  211. u32 crtc_v_sync_strt_wid;
  212. u32 crtc_pitch;
  213. u32 crtc_gen_cntl;
  214. u32 crtc_ext_cntl;
  215. u32 dac_cntl;
  217. u32 flags;
  218. u32 pix_clock;
  219. int xres, yres;
  221. /* DDA regs */
  222. u32 dda_config;
  223. u32 dda_on_off;
  225. /* PLL regs */
  226. u32 ppll_div_3;
  227. u32 ppll_ref_div;
  229. /* Flat panel regs */
  230. u32 fp_crtc_h_total_disp;
  231. u32 fp_crtc_v_total_disp;
  232. u32 fp_gen_cntl;
  233. u32 fp_h_sync_strt_wid;
  234. u32 fp_horz_stretch;
  235. u32 fp_panel_cntl;
  236. u32 fp_v_sync_strt_wid;
  237. u32 fp_vert_stretch;
  238. u32 lvds_gen_cntl;
  239. u32 lvds_pll_cntl;
  240. u32 tmds_crc;
  241. u32 tmds_transmitter_cntl;
  243. #if defined(__BIG_ENDIAN)
  244. u32 surface_cntl;
  245. #endif
  246. };
  249. struct radeonfb_info {
  250. struct fb_info info;
  252. struct radeon_regs state;
  253. struct radeon_regs init_state;
  255. char name[17];
  256. char ram_type[12];
  258. u32 mmio_base_phys;
  259. u32 fb_base_phys;
  261. u32 mmio_base;
  262. u32 fb_base;
  264. struct pci_dev *pdev;
  266. unsigned char *EDID;
  267. unsigned char *bios_seg;
  269. struct display disp;
  270. int currcon;
  271. struct display *currcon_display;
  273. struct { u8 red, green, blue, pad; } palette[256];
  275. int chipset;
  276. int video_ram;
  277. u8 rev;
  278. int pitch, bpp, depth;
  279. int xres, yres, pixclock;
  281. int use_default_var;
  282. int got_dfpinfo;
  284. int hasCRTC2;
  285. int crtDisp_type;
  286. int dviDisp_type;
  288. int panel_xres, panel_yres;
  289. int clock;
  290. int hOver_plus, hSync_width, hblank;
  291. int vOver_plus, vSync_width, vblank;
  292. int hAct_high, vAct_high, interlaced;
  293. int synct, misc;
  295. u32 dp_gui_master_cntl;
  297. struct pll_info pll;
  298. int pll_output_freq, post_div, fb_div;
  300. struct ram_info ram;
  302.         u32 hack_crtc_ext_cntl;
  303.         u32 hack_crtc_v_sync_strt_wid;
  305. #if defined(FBCON_HAS_CFB16) || defined(FBCON_HAS_CFB32)
  306.         union {
  307. #if defined(FBCON_HAS_CFB16)
  308.                 u_int16_t cfb16[16];
  309. #endif
  310. #if defined(FBCON_HAS_CFB24)
  311.                 u_int32_t cfb24[16];
  312. #endif  
  313. #if defined(FBCON_HAS_CFB32)
  314.                 u_int32_t cfb32[16];
  315. #endif  
  316.         } con_cmap;
  317. #endif  
  319. #ifdef CONFIG_PMAC_PBOOK
  320. unsigned char *save_framebuffer;
  321. int pm_reg;
  322. #endif
  324. struct radeonfb_info *next;
  325. };
  328. static struct fb_var_screeninfo radeonfb_default_var = {
  329.         640, 480, 640, 480, 0, 0, 8, 0,
  330.         {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
  331.         0, 0, -1, -1, 0, 39721, 40, 24, 32, 11, 96, 2,
  332.         0, FB_VMODE_NONINTERLACED
  333. };
  336. /*
  337.  * IO macros
  338.  */
  340. #define INREG8(addr) readb((rinfo->mmio_base)+addr)
  341. #define OUTREG8(addr,val) writeb(val, (rinfo->mmio_base)+addr)
  342. #define INREG(addr) readl((rinfo->mmio_base)+addr)
  343. #define OUTREG(addr,val) writel(val, (rinfo->mmio_base)+addr)
  345. #define OUTPLL(addr,val) OUTREG8(CLOCK_CNTL_INDEX, (addr & 0x0000001f) | 0x00000080); 
  346. OUTREG(CLOCK_CNTL_DATA, val)
  347. #define OUTPLLP(addr,val,mask)  
  348. do {
  349. unsigned int _tmp = INPLL(addr);
  350. _tmp &= (mask);
  351. _tmp |= (val);
  352. OUTPLL(addr, _tmp);
  353. } while (0)
  355. #define OUTREGP(addr,val,mask)  
  356. do {
  357. unsigned int _tmp = INREG(addr);
  358. _tmp &= (mask);
  359. _tmp |= (val);
  360. OUTREG(addr, _tmp);
  361. } while (0)
  364. static __inline__ u32 _INPLL(struct radeonfb_info *rinfo, u32 addr)
  365. {
  366. OUTREG8(CLOCK_CNTL_INDEX, addr & 0x0000001f);
  367. return (INREG(CLOCK_CNTL_DATA));
  368. }
  370. #define INPLL(addr) _INPLL(rinfo, addr)
  372. #define PRIMARY_MONITOR(rinfo) ((rinfo->dviDisp_type != MT_NONE) &&
  373.  (rinfo->dviDisp_type != MT_STV) &&
  374.  (rinfo->dviDisp_type != MT_CTV) ?
  375.  rinfo->dviDisp_type : rinfo->crtDisp_type)
  377. static char *GET_MON_NAME(int type)
  378. {
  379. char *pret = NULL;
  381. switch (type) {
  382. case MT_NONE:
  383. pret = "no";
  384. break;
  385. case MT_CRT:
  386. pret = "CRT";
  387. break;
  388. case MT_DFP:
  389. pret = "DFP";
  390. break;
  391. case MT_LCD:
  392. pret = "LCD";
  393. break;
  394. case MT_CTV:
  395. pret = "CTV";
  396. break;
  397. case MT_STV:
  398. pret = "STV";
  399. break;
  400. }
  402. return pret;
  403. }
  406. /*
  407.  * 2D engine routines
  408.  */
  410. static __inline__ void radeon_engine_flush (struct radeonfb_info *rinfo)
  411. {
  412. int i;
  414. /* initiate flush */
  415. OUTREGP(RB2D_DSTCACHE_CTLSTAT, RB2D_DC_FLUSH_ALL,
  416.         ~RB2D_DC_FLUSH_ALL);
  418. for (i=0; i < 2000000; i++) {
  419. if (!(INREG(RB2D_DSTCACHE_CTLSTAT) & RB2D_DC_BUSY))
  420. break;
  421. }
  422. }
  425. static __inline__ void _radeon_fifo_wait (struct radeonfb_info *rinfo, int entries)
  426. {
  427. int i;
  429. for (i=0; i<2000000; i++)
  430. if ((INREG(RBBM_STATUS) & 0x7f) >= entries)
  431. return;
  432. }
  435. static __inline__ void _radeon_engine_idle (struct radeonfb_info *rinfo)
  436. {
  437. int i;
  439. /* ensure FIFO is empty before waiting for idle */
  440. _radeon_fifo_wait (rinfo, 64);
  442. for (i=0; i<2000000; i++) {
  443. if (((INREG(RBBM_STATUS) & GUI_ACTIVE)) == 0) {
  444. radeon_engine_flush (rinfo);
  445. return;
  446. }
  447. }
  448. }
  451. #define radeon_engine_idle() _radeon_engine_idle(rinfo)
  452. #define radeon_fifo_wait(entries) _radeon_fifo_wait(rinfo,entries)
  456. /*
  457.  * helper routines
  458.  */
  460. static __inline__ u32 radeon_get_dstbpp(u16 depth)
  461. {
  462. switch (depth) {
  463. case 8:
  464. return DST_8BPP;
  465. case 15:
  466. return DST_15BPP;
  467. case 16:
  468. return DST_16BPP;
  469. case 32:
  470. return DST_32BPP;
  471. default:
  472. return 0;
  473. }
  474. }
  477. static inline int var_to_depth(const struct fb_var_screeninfo *var)
  478. {
  479. if (var->bits_per_pixel != 16)
  480. return var->bits_per_pixel;
  481. return (var->green.length == 6) ? 16 : 15;
  482. }
  485. static void _radeon_engine_reset(struct radeonfb_info *rinfo)
  486. {
  487. u32 clock_cntl_index, mclk_cntl, rbbm_soft_reset;
  489. radeon_engine_flush (rinfo);
  491. clock_cntl_index = INREG(CLOCK_CNTL_INDEX);
  492. mclk_cntl = INPLL(MCLK_CNTL);
  494. OUTPLL(MCLK_CNTL, (mclk_cntl |
  495.    FORCEON_MCLKA |
  496.    FORCEON_MCLKB |
  497.    FORCEON_YCLKA |
  498.    FORCEON_YCLKB |
  499.    FORCEON_MC |
  500.    FORCEON_AIC));
  501. rbbm_soft_reset = INREG(RBBM_SOFT_RESET);
  503. OUTREG(RBBM_SOFT_RESET, rbbm_soft_reset |
  504. SOFT_RESET_CP |
  505. SOFT_RESET_HI |
  506. SOFT_RESET_SE |
  507. SOFT_RESET_RE |
  508. SOFT_RESET_PP |
  509. SOFT_RESET_E2 |
  510. SOFT_RESET_RB |
  511. SOFT_RESET_HDP);
  512. INREG(RBBM_SOFT_RESET);
  513. OUTREG(RBBM_SOFT_RESET, rbbm_soft_reset & (u32)
  514. ~(SOFT_RESET_CP |
  515.   SOFT_RESET_HI |
  516.   SOFT_RESET_SE |
  517.   SOFT_RESET_RE |
  518.   SOFT_RESET_PP |
  519.   SOFT_RESET_E2 |
  520.   SOFT_RESET_RB |
  521.   SOFT_RESET_HDP));
  522. INREG(RBBM_SOFT_RESET);
  524. OUTPLL(MCLK_CNTL, mclk_cntl);
  525. OUTREG(CLOCK_CNTL_INDEX, clock_cntl_index);
  526. OUTREG(RBBM_SOFT_RESET, rbbm_soft_reset);
  528. return;
  529. }
  531. #define radeon_engine_reset() _radeon_engine_reset(rinfo)
  534. static __inline__ u8 radeon_get_post_div_bitval(int post_div)
  535. {
  536.         switch (post_div) {
  537.                 case 1:
  538.                         return 0x00;
  539.                 case 2: 
  540.                         return 0x01;
  541.                 case 3: 
  542.                         return 0x04;
  543.                 case 4:
  544.                         return 0x02;
  545.                 case 6:
  546.                         return 0x06;
  547.                 case 8:
  548.                         return 0x03;
  549.                 case 12:
  550.                         return 0x07;
  551.                 default:
  552.                         return 0x02;
  553.         }
  554. }
  558. static __inline__ int round_div(int num, int den)
  559. {
  560.         return (num + (den / 2)) / den;
  561. }
  565. static __inline__ int min_bits_req(int val)
  566. {
  567.         int bits_req = 0;
  568.                 
  569.         if (val == 0)
  570.                 bits_req = 1;
  571.                         
  572.         while (val) {
  573.                 val >>= 1;
  574.                 bits_req++;
  575.         }       
  577.         return (bits_req);
  578. }
  581. static __inline__ int _max(int val1, int val2)
  582. {
  583.         if (val1 >= val2)
  584.                 return val1;
  585.         else
  586.                 return val2;
  587. }                       
  591. /*
  592.  * globals
  593.  */
  594.         
  595. static char fontname[40] __initdata;
  596. static char *mode_option __initdata;
  597. static char noaccel __initdata = 0;
  598. static int panel_yres __initdata = 0;
  599. static char force_dfp __initdata = 0;
  600. static struct radeonfb_info *board_list = NULL;
  602. #ifdef FBCON_HAS_CFB8
  603. static struct display_switch fbcon_radeon8;
  604. #endif
  607. /*
  608.  * prototypes
  609.  */
  611. static int radeonfb_get_fix (struct fb_fix_screeninfo *fix, int con,
  612.                              struct fb_info *info);
  613. static int radeonfb_get_var (struct fb_var_screeninfo *var, int con,
  614.                              struct fb_info *info);
  615. static int radeonfb_set_var (struct fb_var_screeninfo *var, int con,
  616.                              struct fb_info *info);
  617. static int radeonfb_get_cmap (struct fb_cmap *cmap, int kspc, int con,
  618.                               struct fb_info *info);
  619. static int radeonfb_set_cmap (struct fb_cmap *cmap, int kspc, int con,
  620.                               struct fb_info *info);
  621. static int radeonfb_pan_display (struct fb_var_screeninfo *var, int con,
  622.                                  struct fb_info *info);
  623. static int radeonfb_ioctl (struct inode *inode, struct file *file, unsigned int cmd,
  624.                            unsigned long arg, int con, struct fb_info *info);
  625. static int radeonfb_switch (int con, struct fb_info *info);
  626. static int radeonfb_updatevar (int con, struct fb_info *info);
  627. static void radeonfb_blank (int blank, struct fb_info *info);
  628. static int radeon_get_cmap_len (const struct fb_var_screeninfo *var);
  629. static int radeon_getcolreg (unsigned regno, unsigned *red, unsigned *green,
  630.                              unsigned *blue, unsigned *transp,
  631.                              struct fb_info *info);
  632. static int radeon_setcolreg (unsigned regno, unsigned red, unsigned green,
  633.                              unsigned blue, unsigned transp, struct fb_info *info);
  634. static void radeon_set_dispsw (struct radeonfb_info *rinfo, struct display *disp);
  635. static void radeon_save_state (struct radeonfb_info *rinfo,
  636.                                struct radeon_regs *save);
  637. static void radeon_engine_init (struct radeonfb_info *rinfo);
  638. static void radeon_load_video_mode (struct radeonfb_info *rinfo,
  639.                                     struct fb_var_screeninfo *mode);
  640. static void radeon_write_mode (struct radeonfb_info *rinfo,
  641.                                struct radeon_regs *mode);
  642. static int __devinit radeon_set_fbinfo (struct radeonfb_info *rinfo);
  643. static int __devinit radeon_init_disp (struct radeonfb_info *rinfo);
  644. static int radeon_init_disp_var (struct radeonfb_info *rinfo);
  645. static int radeonfb_pci_register (struct pci_dev *pdev,
  646.                                  const struct pci_device_id *ent);
  647. static void __devexit radeonfb_pci_unregister (struct pci_dev *pdev);
  648. static char *radeon_find_rom(struct radeonfb_info *rinfo);
  649. static void radeon_get_pllinfo(struct radeonfb_info *rinfo, char *bios_seg);
  650. static void radeon_get_moninfo (struct radeonfb_info *rinfo);
  651. static int radeon_get_dfpinfo (struct radeonfb_info *rinfo);
  652. static int radeon_get_dfpinfo_BIOS(struct radeonfb_info *rinfo);
  653. static void radeon_get_EDID(struct radeonfb_info *rinfo);
  654. static int radeon_dfp_parse_EDID(struct radeonfb_info *rinfo);
  655. static void radeon_update_default_var(struct radeonfb_info *rinfo);
  658. #ifdef CONFIG_ALL_PPC
  659. static int radeon_read_OF (struct radeonfb_info *rinfo);
  660. static int radeon_get_EDID_OF(struct radeonfb_info *rinfo);
  661. extern struct device_node *pci_device_to_OF_node(struct pci_dev *dev);
  663. #ifdef CONFIG_PMAC_PBOOK
  664. int radeon_sleep_notify(struct pmu_sleep_notifier *self, int when);
  665. static struct pmu_sleep_notifier radeon_sleep_notifier = {
  666. radeon_sleep_notify, SLEEP_LEVEL_VIDEO,
  667. };
  668. static int radeon_set_backlight_enable(int on, int level, void *data);
  669. static int radeon_set_backlight_level(int level, void *data);
  670. static struct backlight_controller radeon_backlight_controller = {
  671. radeon_set_backlight_enable,
  672. radeon_set_backlight_level
  673. };
  674. #endif /* CONFIG_PMAC_PBOOK */
  676. #endif /* CONFIG_ALL_PPC */
  678. static struct fb_ops radeon_fb_ops = {
  679. fb_get_fix: radeonfb_get_fix,
  680. fb_get_var: radeonfb_get_var,
  681. fb_set_var: radeonfb_set_var,
  682. fb_get_cmap: radeonfb_get_cmap,
  683. fb_set_cmap: radeonfb_set_cmap,
  684. fb_pan_display: radeonfb_pan_display,
  685. fb_ioctl: radeonfb_ioctl,
  686. };
  689. static struct pci_driver radeonfb_driver = {
  690. name: "radeonfb",
  691. id_table: radeonfb_pci_table,
  692. probe: radeonfb_pci_register,
  693. remove: __devexit_p(radeonfb_pci_unregister),
  694. };
  697. int __init radeonfb_init (void)
  698. {
  699. return pci_module_init (&radeonfb_driver);
  700. }
  703. void __exit radeonfb_exit (void)
  704. {
  705. pci_unregister_driver (&radeonfb_driver);
  706. }
  709. int __init radeonfb_setup (char *options)
  710. {
  711.         char *this_opt;
  713.         if (!options || !*options)
  714.                 return 0;
  715.  
  716. while ((this_opt = strsep (&options, ",")) != NULL) {
  717. if (!*this_opt)
  718. continue;
  719.                 if (!strncmp (this_opt, "font:", 5)) {
  720.                         char *p;
  721.                         int i;
  722.         
  723.                         p = this_opt + 5;
  724.                         for (i=0; i<sizeof (fontname) - 1; i++)
  725.                                 if (!*p || *p == ' ' || *p == ',')
  726.                                         break;
  727.                         memcpy(fontname, this_opt + 5, i);
  728.                 } else if (!strncmp(this_opt, "noaccel", 7)) {
  729. noaccel = 1;
  730. } else if (!strncmp(this_opt, "dfp", 3)) {
  731. force_dfp = 1;
  732. } else if (!strncmp(this_opt, "panel_yres:", 11)) {
  733. panel_yres = simple_strtoul((this_opt+11), NULL, 0);
  734.                 } else
  735. mode_option = this_opt;
  736.         }
  738. return 0;
  739. }
  741. #ifdef MODULE
  742. module_init(radeonfb_init);
  743. module_exit(radeonfb_exit);
  744. #endif
  747. MODULE_AUTHOR("Ani Joshi");
  748. MODULE_DESCRIPTION("framebuffer driver for ATI Radeon chipset");
  749. MODULE_LICENSE("GPL");
  751. static int radeonfb_pci_register (struct pci_dev *pdev,
  752.   const struct pci_device_id *ent)
  753. {
  754. struct radeonfb_info *rinfo;
  755. u32 tmp;
  756. int i, j;
  758. RTRACE("radeonfb_pci_register BEGINn");
  760. rinfo = kmalloc (sizeof (struct radeonfb_info), GFP_KERNEL);
  761. if (!rinfo) {
  762. printk ("radeonfb: could not allocate memoryn");
  763. return -ENODEV;
  764. }
  766. memset (rinfo, 0, sizeof (struct radeonfb_info));
  768. rinfo->pdev = pdev;
  770. /* enable device */
  771. {
  772. int err;
  774. if ((err = pci_enable_device(pdev))) {
  775. printk("radeonfb: cannot enable devicen");
  776. kfree (rinfo);
  777. return -ENODEV;
  778. }
  779. }
  781. /* set base addrs */
  782. rinfo->fb_base_phys = pci_resource_start (pdev, 0);
  783. rinfo->mmio_base_phys = pci_resource_start (pdev, 2);
  785. /* request the mem regions */
  786. if (!request_mem_region (rinfo->fb_base_phys,
  787.  pci_resource_len(pdev, 0), "radeonfb")) {
  788. printk ("radeonfb: cannot reserve FB regionn");
  789. kfree (rinfo);
  790. return -ENODEV;
  791. }
  793. if (!request_mem_region (rinfo->mmio_base_phys,
  794.  pci_resource_len(pdev, 2), "radeonfb")) {
  795. printk ("radeonfb: cannot reserve MMIO regionn");
  796. release_mem_region (rinfo->fb_base_phys,
  797.     pci_resource_len(pdev, 0));
  798. kfree (rinfo);
  799. return -ENODEV;
  800. }
  802. /* map the regions */
  803. rinfo->mmio_base = (u32) ioremap (rinfo->mmio_base_phys,
  804.          RADEON_REGSIZE);
  805. if (!rinfo->mmio_base) {
  806. printk ("radeonfb: cannot map MMIOn");
  807. release_mem_region (rinfo->mmio_base_phys,
  808.     pci_resource_len(pdev, 2));
  809. release_mem_region (rinfo->fb_base_phys,
  810.     pci_resource_len(pdev, 0));
  811. kfree (rinfo);
  812. return -ENODEV;
  813. }
  815. rinfo->chipset = pdev->device;
  817. /* chipset */
  818. switch (pdev->device) {
  819. case PCI_DEVICE_ID_RADEON_QD:
  820. strcpy(rinfo->name, "Radeon QD ");
  821. break;
  822. case PCI_DEVICE_ID_RADEON_QE:
  823. strcpy(rinfo->name, "Radeon QE ");
  824. break;
  825. case PCI_DEVICE_ID_RADEON_QF:
  826. strcpy(rinfo->name, "Radeon QF ");
  827. break;
  828. case PCI_DEVICE_ID_RADEON_QG:
  829. strcpy(rinfo->name, "Radeon QG ");
  830. break;
  831. case PCI_DEVICE_ID_RADEON_QY:
  832. strcpy(rinfo->name, "Radeon QY VE ");
  833. rinfo->hasCRTC2 = 1;
  834. break;
  835. case PCI_DEVICE_ID_RADEON_QZ:
  836. strcpy(rinfo->name, "Radeon QZ VE ");
  837. rinfo->hasCRTC2 = 1;
  838. break;
  839. case PCI_DEVICE_ID_RADEON_QW:
  840. strcpy(rinfo->name, "Radeon 7500 QW ");
  841. rinfo->hasCRTC2 = 1;
  842. break;
  843. case PCI_DEVICE_ID_RADEON_QL:
  844. strcpy(rinfo->name, "Radeon 8500 QL ");
  845. rinfo->hasCRTC2 = 1;
  846. break;
  847. case PCI_DEVICE_ID_RADEON_LW:
  848. strcpy(rinfo->name, "Radeon M7 LW ");
  849. rinfo->hasCRTC2 = 1;
  850. break;
  851. case PCI_DEVICE_ID_RADEON_LY:
  852. strcpy(rinfo->name, "Radeon M6 LY ");
  853. rinfo->hasCRTC2 = 1;
  854. break;
  855. case PCI_DEVICE_ID_RADEON_LZ:
  856. strcpy(rinfo->name, "Radeon M6 LZ ");
  857. rinfo->hasCRTC2 = 1;
  858. break;
  859. default:
  860. return -ENODEV;
  861. }
  863. /* framebuffer size */
  864. tmp = INREG(CONFIG_MEMSIZE);
  866. /* mem size is bits [28:0], mask off the rest */
  867. rinfo->video_ram = tmp & CONFIG_MEMSIZE_MASK;
  869. /* ram type */
  870. tmp = INREG(MEM_SDRAM_MODE_REG);
  871. switch ((MEM_CFG_TYPE & tmp) >> 30) {
  872. case 0:
  873. /* SDR SGRAM (2:1) */
  874. strcpy(rinfo->ram_type, "SDR SGRAM");
  875. rinfo->ram.ml = 4;
  876. rinfo->ram.mb = 4;
  877. rinfo->ram.trcd = 1;
  878. rinfo->ram.trp = 2;
  879. rinfo->ram.twr = 1;
  880. rinfo->ram.cl = 2;
  881. rinfo->ram.loop_latency = 16;
  882. rinfo->ram.rloop = 16;
  884. break;
  885. case 1:
  886. /* DDR SGRAM */
  887. strcpy(rinfo->ram_type, "DDR SGRAM");
  888. rinfo->ram.ml = 4;
  889. rinfo->ram.mb = 4;
  890. rinfo->ram.trcd = 3;
  891. rinfo->ram.trp = 3;
  892. rinfo->ram.twr = 2;
  893. rinfo->ram.cl = 3;
  894. rinfo->ram.tr2w = 1;
  895. rinfo->ram.loop_latency = 16;
  896. rinfo->ram.rloop = 16;
  898. break;
  899. default:
  900. /* 64-bit SDR SGRAM */
  901. strcpy(rinfo->ram_type, "SDR SGRAM 64");
  902. rinfo->ram.ml = 4;
  903. rinfo->ram.mb = 8;
  904. rinfo->ram.trcd = 3;
  905. rinfo->ram.trp = 3;
  906. rinfo->ram.twr = 1;
  907. rinfo->ram.cl = 3;
  908. rinfo->ram.tr2w = 1;
  909. rinfo->ram.loop_latency = 17;
  910. rinfo->ram.rloop = 17;
  912. break;
  913. }
  915. rinfo->bios_seg = radeon_find_rom(rinfo);
  916. radeon_get_pllinfo(rinfo, rinfo->bios_seg);
  918. RTRACE("radeonfb: probed %s %dk videoramn", (rinfo->ram_type), (rinfo->video_ram/1024));
  920. #if !defined(__powerpc__)
  921. radeon_get_moninfo(rinfo);
  922. #else
  923. switch (pdev->device) {
  924. case PCI_DEVICE_ID_RADEON_LW:
  925. case PCI_DEVICE_ID_RADEON_LY:
  926. case PCI_DEVICE_ID_RADEON_LZ:
  927. rinfo->dviDisp_type = MT_LCD;
  928. break;
  929. default:
  930. radeon_get_moninfo(rinfo);
  931. break;
  932. }
  933. #endif
  935. radeon_get_EDID(rinfo);
  937. if ((rinfo->dviDisp_type == MT_DFP) || (rinfo->dviDisp_type == MT_LCD) ||
  938.     (rinfo->crtDisp_type == MT_DFP)) {
  939. if (!radeon_get_dfpinfo(rinfo)) {
  940. iounmap ((void*)rinfo->mmio_base);
  941. release_mem_region (rinfo->mmio_base_phys,
  942.     pci_resource_len(pdev, 2));
  943. release_mem_region (rinfo->fb_base_phys,
  944.     pci_resource_len(pdev, 0));
  945. kfree (rinfo);
  946. return -ENODEV;
  947. }
  948. }
  950. rinfo->fb_base = (u32) ioremap (rinfo->fb_base_phys,
  951.      rinfo->video_ram);
  952. if (!rinfo->fb_base) {
  953. printk ("radeonfb: cannot map FBn");
  954. iounmap ((void*)rinfo->mmio_base);
  955. release_mem_region (rinfo->mmio_base_phys,
  956.     pci_resource_len(pdev, 2));
  957. release_mem_region (rinfo->fb_base_phys,
  958.     pci_resource_len(pdev, 0));
  959. kfree (rinfo);
  960. return -ENODEV;
  961. }
  963. /* XXX turn off accel for now, blts aren't working right */
  964. noaccel = 1;
  966. /* currcon not yet configured, will be set by first switch */
  967. rinfo->currcon = -1;
  969. /* set all the vital stuff */
  970. radeon_set_fbinfo (rinfo);
  972. /* save current mode regs before we switch into the new one
  973.  * so we can restore this upon __exit
  974.  */
  975. radeon_save_state (rinfo, &rinfo->init_state);
  977. /* init palette */
  978. for (i=0; i<16; i++) {
  979. j = color_table[i];
  980. rinfo->palette[i].red = default_red[j];
  981. rinfo->palette[i].green = default_grn[j];
  982. rinfo->palette[i].blue = default_blu[j];
  983. }
  985. pci_set_drvdata(pdev, rinfo);
  986. rinfo->next = board_list;
  987. board_list = rinfo;
  989. if (register_framebuffer ((struct fb_info *) rinfo) < 0) {
  990. printk ("radeonfb: could not register framebuffern");
  991. iounmap ((void*)rinfo->fb_base);
  992. iounmap ((void*)rinfo->mmio_base);
  993. release_mem_region (rinfo->mmio_base_phys,
  994.     pci_resource_len(pdev, 2));
  995. release_mem_region (rinfo->fb_base_phys,
  996.     pci_resource_len(pdev, 0));
  997. kfree (rinfo);
  998. return -ENODEV;
  999. }
  1001. if (!noaccel) {
  1002. /* initialize the engine */
  1003. radeon_engine_init (rinfo);
  1004. }
  1006. #ifdef CONFIG_PMAC_BACKLIGHT
  1007. if (rinfo->dviDisp_type == MT_LCD)
  1008. register_backlight_controller(&radeon_backlight_controller,
  1009.       rinfo, "ati");
  1010. #endif
  1012. #ifdef CONFIG_PMAC_PBOOK
  1013. if (rinfo->dviDisp_type == MT_LCD) {
  1014. rinfo->pm_reg = pci_find_capability(pdev, PCI_CAP_ID_PM);
  1015. pmu_register_sleep_notifier(&radeon_sleep_notifier);
  1016. }
  1017. #endif
  1019. printk ("radeonfb: ATI %s %s %d MBn", rinfo->name, rinfo->ram_type,
  1020. (rinfo->video_ram/(1024*1024)));
  1022. if (rinfo->hasCRTC2) {
  1023. printk("radeonfb: DVI port %s monitor connectedn",
  1024. GET_MON_NAME(rinfo->dviDisp_type));
  1025. printk("radeonfb: CRT port %s monitor connectedn",
  1026. GET_MON_NAME(rinfo->crtDisp_type));
  1027. } else {
  1028. printk("radeonfb: CRT port %s monitor connectedn",
  1029. GET_MON_NAME(rinfo->crtDisp_type));
  1030. }
  1032. RTRACE("radeonfb_pci_register ENDn");
  1034. return 0;
  1035. }
  1039. static void __devexit radeonfb_pci_unregister (struct pci_dev *pdev)
  1040. {
  1041.         struct radeonfb_info *rinfo = pci_get_drvdata(pdev);
  1042.  
  1043.         if (!rinfo)
  1044.                 return;
  1045.  
  1046. /* restore original state */
  1047.         radeon_write_mode (rinfo, &rinfo->init_state);
  1048.  
  1049.         unregister_framebuffer ((struct fb_info *) rinfo);
  1050.                 
  1051.         iounmap ((void*)rinfo->mmio_base);
  1052.         iounmap ((void*)rinfo->fb_base);
  1053.  
  1054. release_mem_region (rinfo->mmio_base_phys,
  1055.     pci_resource_len(pdev, 2));
  1056. release_mem_region (rinfo->fb_base_phys,
  1057.     pci_resource_len(pdev, 0));
  1058.         
  1059.         kfree (rinfo);
  1060. }
  1064. static char *radeon_find_rom(struct radeonfb_info *rinfo)
  1065. {       
  1066. #if defined(__i386__)
  1067.         u32  segstart;
  1068.         char *rom_base;
  1069.         char *rom;
  1070.         int  stage;
  1071.         int  i,j;       
  1072.         char aty_rom_sig[] = "761295520";
  1073.         char *radeon_sig[] = {
  1074.           "RG6",
  1075.           "RADEON"
  1076.         };
  1077.                                                 
  1078.         for(segstart=0x000c0000; segstart<0x000f0000; segstart+=0x00001000) {
  1079.                         
  1080.                 stage = 1;
  1081.                 
  1082.                 rom_base = (char *)ioremap(segstart, 0x1000);
  1084.                 if ((*rom_base == 0x55) && (((*(rom_base + 1)) & 0xff) == 0xaa))
  1085.                         stage = 2;
  1086.                 
  1087.                     
  1088.                 if (stage != 2) {
  1089.                         iounmap(rom_base);
  1090.                         continue;
  1091.                 }
  1092.                                               
  1093.                 rom = rom_base;
  1094.                      
  1095.                 for (i = 0; (i < 128 - strlen(aty_rom_sig)) && (stage != 3); i++) {
  1096.                         if (aty_rom_sig[0] == *rom)
  1097.                                 if (strncmp(aty_rom_sig, rom,
  1098.                                                 strlen(aty_rom_sig)) == 0)
  1099.                                         stage = 3;
  1100.                         rom++;
  1101.                 }
  1102.                 if (stage != 3) {
  1103.                         iounmap(rom_base);
  1104.                         continue;
  1105.                 }
  1106.                 rom = rom_base;
  1107.         
  1108.                 for (i = 0; (i < 512) && (stage != 4); i++) {
  1109.                     for(j = 0;j < sizeof(radeon_sig)/sizeof(char *);j++) {
  1110.                         if (radeon_sig[j][0] == *rom)
  1111.                                 if (strncmp(radeon_sig[j], rom,
  1112.                                             strlen(radeon_sig[j])) == 0) {
  1113.                                               stage = 4;
  1114.                                               break;
  1115.                                             }
  1116.                     }                           
  1117.                         rom++;
  1118.                 }       
  1119.                 if (stage != 4) {
  1120.                         iounmap(rom_base);
  1121.                         continue;
  1122.                 }       
  1123.                 
  1124.                 return rom_base;
  1125.         }
  1126. #endif          
  1127.         return NULL;
  1128. }
  1133. static void radeon_get_pllinfo(struct radeonfb_info *rinfo, char *bios_seg)
  1134. {
  1135.         void *bios_header;
  1136.         void *header_ptr;
  1137.         u16 bios_header_offset, pll_info_offset;
  1138.         PLL_BLOCK pll;
  1140. if (bios_seg) {
  1141.         bios_header = bios_seg + 0x48L;
  1142.         header_ptr  = bios_header;
  1143.         
  1144.          bios_header_offset = readw(header_ptr);
  1145.         bios_header = bios_seg + bios_header_offset;
  1146.          bios_header += 0x30;
  1147.         
  1148.          header_ptr = bios_header;
  1149.          pll_info_offset = readw(header_ptr);
  1150.          header_ptr = bios_seg + pll_info_offset;
  1151.         
  1152.          memcpy_fromio(&pll, header_ptr, 50);
  1153.         
  1154.          rinfo->pll.xclk = (u32)pll.XCLK;
  1155.          rinfo->pll.ref_clk = (u32)pll.PCLK_ref_freq;
  1156.          rinfo->pll.ref_div = (u32)pll.PCLK_ref_divider;
  1157.          rinfo->pll.ppll_min = pll.PCLK_min_freq;
  1158.          rinfo->pll.ppll_max = pll.PCLK_max_freq;
  1160. printk("radeonfb: ref_clk=%d, ref_div=%d, xclk=%d from BIOSn",
  1161. rinfo->pll.ref_clk, rinfo->pll.ref_div, rinfo->pll.xclk);
  1162. } else {
  1163. #ifdef CONFIG_ALL_PPC
  1164. if (radeon_read_OF(rinfo)) {
  1165. unsigned int tmp, Nx, M, ref_div, xclk;
  1167. tmp = INPLL(M_SPLL_REF_FB_DIV);
  1168. ref_div = INPLL(PPLL_REF_DIV) & 0x3ff;
  1170. Nx = (tmp & 0xff00) >> 8;
  1171. M = (tmp & 0xff);
  1172. xclk = ((((2 * Nx * rinfo->pll.ref_clk) + (M)) /
  1173. (2 * M)));
  1175. rinfo->pll.xclk = xclk;
  1176. rinfo->pll.ref_div = ref_div;
  1177. rinfo->pll.ppll_min = 12000;
  1178. rinfo->pll.ppll_max = 35000;
  1180. printk("radeonfb: ref_clk=%d, ref_div=%d, xclk=%d from OFn",
  1181. rinfo->pll.ref_clk, rinfo->pll.ref_div, rinfo->pll.xclk);
  1183. return;
  1184. }
  1185. #endif
  1186. /* no BIOS or BIOS not found, use defaults */
  1187. switch (rinfo->chipset) {
  1188. case PCI_DEVICE_ID_RADEON_QW:
  1189. rinfo->pll.ppll_max = 35000;
  1190. rinfo->pll.ppll_min = 12000;
  1191. rinfo->pll.xclk = 23000;
  1192. rinfo->pll.ref_div = 12;
  1193. rinfo->pll.ref_clk = 2700;
  1194. break;
  1195. case PCI_DEVICE_ID_RADEON_QL:
  1196. rinfo->pll.ppll_max = 35000;
  1197. rinfo->pll.ppll_min = 12000;
  1198. rinfo->pll.xclk = 27500;
  1199. rinfo->pll.ref_div = 12;
  1200. rinfo->pll.ref_clk = 2700;
  1201. break;
  1202. case PCI_DEVICE_ID_RADEON_QD:
  1203. case PCI_DEVICE_ID_RADEON_QE:
  1204. case PCI_DEVICE_ID_RADEON_QF:
  1205. case PCI_DEVICE_ID_RADEON_QG:
  1206. default:
  1207. rinfo->pll.ppll_max = 35000;
  1208. rinfo->pll.ppll_min = 12000;
  1209. rinfo->pll.xclk = 16600;
  1210. rinfo->pll.ref_div = 67;
  1211. rinfo->pll.ref_clk = 2700;
  1212. break;
  1213. }
  1215. printk("radeonfb: ref_clk=%d, ref_div=%d, xclk=%d defaultsn",
  1216. rinfo->pll.ref_clk, rinfo->pll.ref_div, rinfo->pll.xclk);
  1217. }
  1218. }
  1221. static void radeon_get_moninfo (struct radeonfb_info *rinfo)
  1222. {
  1223. unsigned int tmp;
  1225. if (force_dfp) {
  1226. rinfo->dviDisp_type = MT_DFP;
  1227. return;
  1228. }
  1230. tmp = INREG(RADEON_BIOS_4_SCRATCH);
  1232. if (rinfo->hasCRTC2) {
  1233. /* primary DVI port */
  1234. if (tmp & 0x08)
  1235. rinfo->dviDisp_type = MT_DFP;
  1236. else if (tmp & 0x4)
  1237. rinfo->dviDisp_type = MT_LCD;
  1238. else if (tmp & 0x200)
  1239. rinfo->dviDisp_type = MT_CRT;
  1240. else if (tmp & 0x10)
  1241. rinfo->dviDisp_type = MT_CTV;
  1242. else if (tmp & 0x20)
  1243. rinfo->dviDisp_type = MT_STV;
  1245. /* secondary CRT port */
  1246. if (tmp & 0x2)
  1247. rinfo->crtDisp_type = MT_CRT;
  1248. else if (tmp & 0x800)
  1249. rinfo->crtDisp_type = MT_DFP;
  1250. else if (tmp & 0x400)
  1251. rinfo->crtDisp_type = MT_LCD;
  1252. else if (tmp & 0x1000)
  1253. rinfo->crtDisp_type = MT_CTV;
  1254. else if (tmp & 0x2000)
  1255. rinfo->crtDisp_type = MT_STV;
  1256. } else {
  1257. rinfo->dviDisp_type = MT_NONE;
  1259. tmp = INREG(FP_GEN_CNTL);
  1261. if (tmp & FP_EN_TMDS)
  1262. rinfo->crtDisp_type = MT_DFP;
  1263. else
  1264. rinfo->crtDisp_type = MT_CRT;
  1265. }
  1266. }
  1270. static void radeon_get_EDID(struct radeonfb_info *rinfo)
  1271. {
  1272. #ifdef CONFIG_ALL_PPC
  1273. if (!radeon_get_EDID_OF(rinfo))
  1274. RTRACE("radeonfb: could not retrieve EDID from OFn");
  1275. #else
  1276. /* XXX use other methods later */
  1277. #endif
  1278. }
  1281. #ifdef CONFIG_ALL_PPC
  1282. static int radeon_get_EDID_OF(struct radeonfb_info *rinfo)
  1283. {
  1284. struct device_node *dp;
  1285. unsigned char *pedid = NULL;
  1287. dp = pci_device_to_OF_node(rinfo->pdev);
  1288. pedid = (unsigned char *) get_property(dp, "DFP,EDID", 0);
  1289. if (!pedid)
  1290. pedid = (unsigned char *) get_property(dp, "LCD,EDID", 0);
  1291. if (!pedid)
  1292. pedid = (unsigned char *) get_property(dp, "EDID", 0);
  1294. if (pedid) {
  1295. rinfo->EDID = pedid;
  1296. return 1;
  1297. } else
  1298. return 0;
  1299. }
  1300. #endif /* CONFIG_ALL_PPC */
  1303. static int radeon_dfp_parse_EDID(struct radeonfb_info *rinfo)
  1304. {
  1305. unsigned char *block = rinfo->EDID;
  1307. if (!block)
  1308. return 0;
  1310. /* jump to the detailed timing block section */
  1311. block += 54;
  1313. rinfo->clock = (block[0] + (block[1] << 8));
  1314. rinfo->panel_xres = (block[2] + ((block[4] & 0xf0) << 4));
  1315. rinfo->hblank = (block[3] + ((block[4] & 0x0f) << 8));
  1316. rinfo->panel_yres = (block[5] + ((block[7] & 0xf0) << 4));
  1317. rinfo->vblank = (block[6] + ((block[7] & 0x0f) << 8));
  1318. rinfo->hOver_plus = (block[8] + ((block[11] & 0xc0) << 2));
  1319. rinfo->hSync_width = (block[9] + ((block[11] & 0x30) << 4));
  1320. rinfo->vOver_plus = ((block[10] >> 4) + ((block[11] & 0x0c) << 2));
  1321. rinfo->vSync_width = ((block[10] & 0x0f) + ((block[11] & 0x03) << 4));
  1322. rinfo->interlaced = ((block[17] & 0x80) >> 7);
  1323. rinfo->synct = ((block[17] & 0x18) >> 3);
  1324. rinfo->misc = ((block[17] & 0x06) >> 1);
  1325. rinfo->hAct_high = rinfo->vAct_high = 0;
  1326. if (rinfo->synct == 3) {
  1327. if (rinfo->misc & 2)
  1328. rinfo->hAct_high = 1;
  1329. if (rinfo->misc & 1)
  1330. rinfo->vAct_high = 1;
  1331. }
  1333. printk("radeonfb: detected DFP panel size from EDID: %dx%dn",
  1334. rinfo->panel_xres, rinfo->panel_yres);
  1336. rinfo->got_dfpinfo = 1;
  1338. return 1;
  1339. }
  1342. static void radeon_update_default_var(struct radeonfb_info *rinfo)
  1343. {
  1344. struct fb_var_screeninfo *var = &radeonfb_default_var;
  1346. var->xres = rinfo->panel_xres;
  1347. var->yres = rinfo->panel_yres;
  1348. var->xres_virtual = rinfo->panel_xres;
  1349. var->yres_virtual = rinfo->panel_yres;
  1350. var->xoffset = var->yoffset = 0;
  1351. var->bits_per_pixel = 8;
  1352. var->pixclock = 100000000 / rinfo->clock;
  1353. var->left_margin = (rinfo->hblank - rinfo->hOver_plus - rinfo->hSync_width);
  1354. var->right_margin = rinfo->hOver_plus;
  1355. var->upper_margin = (rinfo->vblank - rinfo->vOver_plus - rinfo->vSync_width);
  1356. var->lower_margin = rinfo->vOver_plus;
  1357. var->hsync_len = rinfo->hSync_width;
  1358. var->vsync_len = rinfo->vSync_width;
  1359. var->sync = 0;
  1360. if (rinfo->synct == 3) {
  1361. if (rinfo->hAct_high)
  1362. var->sync |= FB_SYNC_HOR_HIGH_ACT;
  1363. if (rinfo->vAct_high)
  1364. var->sync |= FB_SYNC_VERT_HIGH_ACT;
  1365. }
  1367. var->vmode = 0;
  1368. if (rinfo->interlaced)
  1369. var->vmode |= FB_VMODE_INTERLACED;
  1371. rinfo->use_default_var = 1;
  1372. }
  1375. static int radeon_get_dfpinfo_BIOS(struct radeonfb_info *rinfo)
  1376. {
  1377. char *fpbiosstart, *tmp, *tmp0;
  1378. char stmp[30];
  1379. int i;
  1381. if (!rinfo->bios_seg)
  1382. return 0;
  1384. if (!(fpbiosstart = rinfo->bios_seg + readw(rinfo->bios_seg + 0x48))) {
  1385. printk("radeonfb: Failed to detect DFP panel info using BIOSn");
  1386. return 0;
  1387. }
  1389. if (!(tmp = rinfo->bios_seg + readw(fpbiosstart + 0x40))) {
  1390. printk("radeonfb: Failed to detect DFP panel info using BIOSn");
  1391. return 0;
  1392. }
  1394. for(i=0; i<24; i++)
  1395. stmp[i] = readb(tmp+i+1);
  1396. stmp[24] = 0;
  1397. printk("radeonfb: panel ID string: %sn", stmp);
  1398. rinfo->panel_xres = readw(tmp + 25);
  1399. rinfo->panel_yres = readw(tmp + 27);
  1400. printk("radeonfb: detected DFP panel size from BIOS: %dx%dn",
  1401. rinfo->panel_xres, rinfo->panel_yres);
  1403. for(i=0; i<20; i++) {
  1404. tmp0 = rinfo->bios_seg + readw(tmp+64+i*2);
  1405. if (tmp0 == 0)
  1406. break;
  1407. if ((readw(tmp0) == rinfo->panel_xres) &&
  1408.     (readw(tmp0+2) == rinfo->panel_yres)) {
  1409. rinfo->hblank = (readw(tmp0+17) - readw(tmp0+19)) * 8;
  1410. rinfo->hOver_plus = ((readw(tmp0+21) - readw(tmp0+19) -1) * 8) & 0x7fff;
  1411. rinfo->hSync_width = readb(tmp0+23) * 8;
  1412. rinfo->vblank = readw(tmp0+24) - readw(tmp0+26);
  1413. rinfo->vOver_plus = (readw(tmp0+28) & 0x7ff) - readw(tmp0+26);
  1414. rinfo->vSync_width = (readw(tmp0+28) & 0xf800) >> 11;
  1415. rinfo->clock = readw(tmp0+9);
  1417. rinfo->got_dfpinfo = 1;
  1418. return 1;
  1419. }
  1420. }
  1422. return 0;
  1423. }
  1427. static int radeon_get_dfpinfo (struct radeonfb_info *rinfo)
  1428. {
  1429. unsigned int tmp;
  1430. unsigned short a, b;
  1432. if (radeon_get_dfpinfo_BIOS(rinfo))
  1433. radeon_update_default_var(rinfo);
  1435. if (radeon_dfp_parse_EDID(rinfo))
  1436. radeon_update_default_var(rinfo);
  1438. if (!rinfo->got_dfpinfo) {
  1439. /*
  1440.  * it seems all else has failed now and we
  1441.  * resort to probing registers for our DFP info
  1442.          */
  1443. if (panel_yres) {
  1444. rinfo->panel_yres = panel_yres;
  1445. } else {
  1446. tmp = INREG(FP_VERT_STRETCH);
  1447. tmp &= 0x00fff000;
  1448. rinfo->panel_yres = (unsigned short)(tmp >> 0x0c) + 1;
  1449. }
  1451. switch (rinfo->panel_yres) {
  1452. case 480:
  1453. rinfo->panel_xres = 640;
  1454. break;
  1455. case 600:
  1456. rinfo->panel_xres = 800;
  1457. break;
  1458. case 768:
  1459. #if defined(__powerpc__)
  1460. if (rinfo->dviDisp_type == MT_LCD)
  1461. rinfo->panel_xres = 1152;
  1462. else
  1463. #endif
  1464. rinfo->panel_xres = 1024;
  1465. break;
  1466. case 1024:
  1467. rinfo->panel_xres = 1280;
  1468. break;
  1469. case 1050:
  1470. rinfo->panel_xres = 1400;
  1471. break;
  1472. case 1200:
  1473. rinfo->panel_xres = 1600;
  1474. break;
  1475. default:
  1476. printk("radeonfb: Failed to detect DFP panel sizen");
  1477. return 0;
  1478. }
  1480. printk("radeonfb: detected DFP panel size from registers: %dx%dn",
  1481. rinfo->panel_xres, rinfo->panel_yres);
  1483. tmp = INREG(FP_CRTC_H_TOTAL_DISP);
  1484. a = (tmp & FP_CRTC_H_TOTAL_MASK) + 4;
  1485. b = (tmp & 0x01ff0000) >> FP_CRTC_H_DISP_SHIFT;
  1486. rinfo->hblank = (a - b + 1) * 8;
  1488. tmp = INREG(FP_H_SYNC_STRT_WID);
  1489. rinfo->hOver_plus = (unsigned short) ((tmp & FP_H_SYNC_STRT_CHAR_MASK) >>
  1490. FP_H_SYNC_STRT_CHAR_SHIFT) - b - 1;
  1491. rinfo->hOver_plus *= 8;
  1492. rinfo->hSync_width = (unsigned short) ((tmp & FP_H_SYNC_WID_MASK) >>
  1493. FP_H_SYNC_WID_SHIFT);
  1494. rinfo->hSync_width *= 8;
  1495. tmp = INREG(FP_CRTC_V_TOTAL_DISP);
  1496. a = (tmp & FP_CRTC_V_TOTAL_MASK) + 1;
  1497. b = (tmp & FP_CRTC_V_DISP_MASK) >> FP_CRTC_V_DISP_SHIFT;
  1498. rinfo->vblank = a - b /* + 24 */ ;
  1500. tmp = INREG(FP_V_SYNC_STRT_WID);
  1501. rinfo->vOver_plus = (unsigned short) (tmp & FP_V_SYNC_STRT_MASK)
  1502. - b + 1;
  1503. rinfo->vSync_width = (unsigned short) ((tmp & FP_V_SYNC_WID_MASK) >>
  1504. FP_V_SYNC_WID_SHIFT);
  1506. return 1;
  1507. }
  1509. return 1;
  1510. }
  1513. #ifdef CONFIG_ALL_PPC
  1514. static int radeon_read_OF (struct radeonfb_info *rinfo)
  1515. {
  1516. struct device_node *dp;
  1517. unsigned int *xtal;
  1519. dp = pci_device_to_OF_node(rinfo->pdev);
  1521. xtal = (unsigned int *) get_property(dp, "ATY,RefCLK", 0);
  1523. rinfo->pll.ref_clk = *xtal / 10;
  1525. if (*xtal)
  1526. return 1;
  1527. else
  1528. return 0;
  1529. }
  1530. #endif
  1533. static void radeon_engine_init (struct radeonfb_info *rinfo)
  1534. {
  1535. u32 temp;
  1537. /* disable 3D engine */
  1538. OUTREG(RB3D_CNTL, 0);
  1540. radeon_engine_reset ();
  1542. radeon_fifo_wait (1);
  1543. OUTREG(DSTCACHE_MODE, 0);
  1545. /* XXX */
  1546. rinfo->pitch = ((rinfo->xres * (rinfo->bpp / 8) + 0x3f)) >> 6;
  1548. radeon_fifo_wait (1);
  1549. temp = INREG(DEFAULT_PITCH_OFFSET);
  1550. OUTREG(DEFAULT_PITCH_OFFSET, ((temp & 0xc0000000) | 
  1551.       (rinfo->pitch << 0x16)));
  1553. radeon_fifo_wait (1);
  1554. OUTREGP(DP_DATATYPE, 0, ~HOST_BIG_ENDIAN_EN);
  1556. radeon_fifo_wait (1);
  1557. OUTREG(DEFAULT_SC_BOTTOM_RIGHT, (DEFAULT_SC_RIGHT_MAX |
  1558.  DEFAULT_SC_BOTTOM_MAX));
  1560. temp = radeon_get_dstbpp(rinfo->depth);
  1561. rinfo->dp_gui_master_cntl = ((temp << 8) | GMC_CLR_CMP_CNTL_DIS);
  1562. radeon_fifo_wait (1);
  1563. OUTREG(DP_GUI_MASTER_CNTL, (rinfo->dp_gui_master_cntl |
  1564.     GMC_BRUSH_SOLID_COLOR |
  1565.     GMC_SRC_DATATYPE_COLOR));
  1567. radeon_fifo_wait (7);
  1569. /* clear line drawing regs */
  1570. OUTREG(DST_LINE_START, 0);
  1571. OUTREG(DST_LINE_END, 0);
  1573. /* set brush color regs */
  1574. OUTREG(DP_BRUSH_FRGD_CLR, 0xffffffff);
  1575. OUTREG(DP_BRUSH_BKGD_CLR, 0x00000000);
  1577. /* set source color regs */
  1578. OUTREG(DP_SRC_FRGD_CLR, 0xffffffff);
  1579. OUTREG(DP_SRC_BKGD_CLR, 0x00000000);
  1581. /* default write mask */
  1582. OUTREG(DP_WRITE_MSK, 0xffffffff);
  1584. radeon_engine_idle ();
  1585. }
  1589. static int __devinit radeon_set_fbinfo (struct radeonfb_info *rinfo)
  1590. {
  1591. struct fb_info *info;
  1593. info = &rinfo->info;
  1595. strcpy (info->modename, rinfo->name);
  1596.         info->node = -1;
  1597.         info->flags = FBINFO_FLAG_DEFAULT;
  1598.         info->fbops = &radeon_fb_ops;
  1599.         info->display_fg = NULL;
  1600.         strncpy (info->fontname, fontname, sizeof (info->fontname));
  1601.         info->fontname[sizeof (info->fontname) - 1] = 0;
  1602.         info->changevar = NULL;
  1603.         info->switch_con = radeonfb_switch;
  1604.         info->updatevar = radeonfb_updatevar;
  1605.         info->blank = radeonfb_blank;
  1607.         if (radeon_init_disp (rinfo) < 0)
  1608.                 return -1;   
  1610.         return 0;
  1611. }
  1615. static int __devinit radeon_init_disp (struct radeonfb_info *rinfo)
  1616. {
  1617.         struct fb_info *info;
  1618.         struct display *disp;
  1620.         info = &rinfo->info;
  1621.         disp = &rinfo->disp;
  1622.         
  1623.         disp->var = radeonfb_default_var;
  1624. #if defined(__powerpc__)
  1625. if (rinfo->dviDisp_type == MT_LCD) {
  1626. if (mac_vmode_to_var(VMODE_1152_768_60, CMODE_8, &disp->var))
  1627. disp->var = radeonfb_default_var;
  1628. }
  1629. #endif
  1631. rinfo->depth = var_to_depth(&disp->var);
  1632. rinfo->bpp = disp->var.bits_per_pixel;
  1634.         info->disp = disp;
  1636.         radeon_set_dispsw (rinfo, disp);
  1638. if (noaccel)
  1639.         disp->scrollmode = SCROLL_YREDRAW;
  1640. else
  1641. disp->scrollmode = 0;
  1642.         
  1643.         rinfo->currcon_display = disp;
  1645.         if ((radeon_init_disp_var (rinfo)) < 0)
  1646.                 return -1;
  1647.         
  1648.         return 0;
  1649. }
  1653. static int radeon_init_disp_var (struct radeonfb_info *rinfo)
  1654. {
  1655. #ifndef MODULE
  1656.         if (mode_option)
  1657.                 fb_find_mode (&rinfo->disp.var, &rinfo->info, mode_option,
  1658.                               NULL, 0, NULL, 8);
  1659.         else
  1660. #endif
  1661. #if defined(__powerpc__)
  1662. if (rinfo->dviDisp_type == MT_LCD) {
  1663. if (mac_vmode_to_var(VMODE_1152_768_60, CMODE_8, &rinfo->disp.var))
  1664. rinfo->disp.var = radeonfb_default_var;
  1665. }
  1666. else
  1667. #endif
  1668. if (rinfo->use_default_var)
  1669. /* We will use the modified default far */
  1670. rinfo->disp.var = radeonfb_default_var;
  1671. else
  1673.                 fb_find_mode (&rinfo->disp.var, &rinfo->info, "640x480-8@60",
  1674.                               NULL, 0, NULL, 0);
  1676. if (noaccel)
  1677. rinfo->disp.var.accel_flags &= ~FB_ACCELF_TEXT;
  1678. else
  1679. rinfo->disp.var.accel_flags |= FB_ACCELF_TEXT;
  1680.  
  1681.         return 0;
  1682. }
  1686. static void radeon_set_dispsw (struct radeonfb_info *rinfo, struct display *disp)
  1688. {
  1689.         int accel;  
  1690.                 
  1691.         accel = disp->var.accel_flags & FB_ACCELF_TEXT;
  1692.                 
  1693.         disp->dispsw_data = NULL;
  1694.         
  1695.         disp->screen_base = (char*)rinfo->fb_base;
  1696.         disp->type = FB_TYPE_PACKED_PIXELS;
  1697.         disp->type_aux = 0;
  1698.         disp->ypanstep = 1;
  1699.         disp->ywrapstep = 0;
  1700.         disp->can_soft_blank = 1;
  1701.         disp->inverse = 0;
  1703.         switch (disp->var.bits_per_pixel) {
  1704. #ifdef FBCON_HAS_CFB8
  1705.                 case 8:
  1706.                         disp->dispsw = &fbcon_cfb8;
  1707.                         disp->visual = FB_VISUAL_PSEUDOCOLOR;
  1708.                         disp->line_length = disp->var.xres_virtual;
  1709.                         break;
  1710. #endif
  1711. #ifdef FBCON_HAS_CFB16
  1712.                 case 16:
  1713.                         disp->dispsw = &fbcon_cfb16;
  1714.                         disp->dispsw_data = &rinfo->con_cmap.cfb16;
  1715.                         disp->visual = FB_VISUAL_DIRECTCOLOR;
  1716.                         disp->line_length = disp->var.xres_virtual * 2;
  1717.                         break;
  1718. #endif  
  1719. #ifdef FBCON_HAS_CFB32       
  1720.                 case 24:
  1721.                         disp->dispsw = &fbcon_cfb24;
  1722.                         disp->dispsw_data = &rinfo->con_cmap.cfb24;
  1723.                         disp->visual = FB_VISUAL_DIRECTCOLOR;
  1724.                         disp->line_length = disp->var.xres_virtual * 4;
  1725.                         break;
  1726. #endif
  1727. #ifdef FBCON_HAS_CFB32
  1728.                 case 32:
  1729.                         disp->dispsw = &fbcon_cfb32;
  1730.                         disp->dispsw_data = &rinfo->con_cmap.cfb32;
  1731.                         disp->visual = FB_VISUAL_DIRECTCOLOR;
  1732.                         disp->line_length = disp->var.xres_virtual * 4;
  1733.                         break;   
  1734. #endif
  1735.                 default:
  1736.                         printk ("radeonfb: setting fbcon_dummy renderern");
  1737.                         disp->dispsw = &fbcon_dummy;
  1738.         }
  1739.                 
  1740.         return;
  1741. }
  1742.                         
  1745. static void do_install_cmap(int con, struct fb_info *info)
  1746. {
  1747.         struct radeonfb_info *rinfo = (struct radeonfb_info *) info;
  1748.                 
  1749.         if (con != rinfo->currcon)
  1750.                 return;
  1751.                 
  1752.         if (fb_display[con].cmap.len)
  1753.                 fb_set_cmap(&fb_display[con].cmap, 1, radeon_setcolreg, info);
  1754.         else {
  1755. int size = radeon_get_cmap_len(&fb_display[con].var);
  1756.                 fb_set_cmap(fb_default_cmap(size), 1, radeon_setcolreg, info);
  1757.         }
  1758. }
  1762. static int radeonfb_do_maximize(struct radeonfb_info *rinfo,
  1763.                                 struct fb_var_screeninfo *var,
  1764.                                 struct fb_var_screeninfo *v,
  1765.                                 int nom, int den)
  1766. {
  1767.         static struct {
  1768.                 int xres, yres;
  1769.         } modes[] = {
  1770.                 {1600, 1280},
  1771.                 {1280, 1024},
  1772.                 {1024, 768},
  1773.                 {800, 600},
  1774.                 {640, 480},
  1775.                 {-1, -1}
  1776.         };
  1777.         int i;
  1778.                 
  1779.         /* use highest possible virtual resolution */
  1780.         if (v->xres_virtual == -1 && v->yres_virtual == -1) {
  1781.                 printk("radeonfb: using max availabe virtual resolutionn");
  1782.                 for (i=0; modes[i].xres != -1; i++) {
  1783.                         if (modes[i].xres * nom / den * modes[i].yres <
  1784.                             rinfo->video_ram / 2)
  1785.                                 break;
  1786.                 }
  1787.                 if (modes[i].xres == -1) {
  1788.                         printk("radeonfb: could not find virtual resolution that fits into video memory!n");
  1789.                         return -EINVAL;
  1790.                 }
  1791.                 v->xres_virtual = modes[i].xres;  
  1792.                 v->yres_virtual = modes[i].yres;
  1793.                 
  1794.                 printk("radeonfb: virtual resolution set to max of %dx%dn",
  1795.                         v->xres_virtual, v->yres_virtual);
  1796.         } else if (v->xres_virtual == -1) {
  1797.                 v->xres_virtual = (rinfo->video_ram * den /   
  1798.                                 (nom * v->yres_virtual * 2)) & ~15;
  1799.         } else if (v->yres_virtual == -1) {
  1800.                 v->xres_virtual = (v->xres_virtual + 15) & ~15;
  1801.                 v->yres_virtual = rinfo->video_ram * den /
  1802.                         (nom * v->xres_virtual *2);
  1803.         } else {
  1804.                 if (v->xres_virtual * nom / den * v->yres_virtual >
  1805.                         rinfo->video_ram) {
  1806.                         return -EINVAL;
  1807.                 }
  1808.         }
  1809.                 
  1810.         if (v->xres_virtual * nom / den >= 8192) {
  1811.                 v->xres_virtual = 8192 * den / nom - 16;
  1812.         }       
  1813.         
  1814.         if (v->xres_virtual < v->xres)
  1815.                 return -EINVAL;
  1816.                 
  1817.         if (v->yres_virtual < v->yres)
  1818.                 return -EINVAL;
  1819.                                 
  1820.         return 0;
  1821. }
  1822.                         
  1825. /*
  1826.  * fb ops
  1827.  */
  1829. static int radeonfb_get_fix (struct fb_fix_screeninfo *fix, int con,
  1830.                              struct fb_info *info)
  1831. {
  1832.         struct radeonfb_info *rinfo = (struct radeonfb_info *) info;
  1833.         struct display *disp;  
  1834.         
  1835.         disp = (con < 0) ? rinfo->info.disp : &fb_display[con];
  1837.         memset (fix, 0, sizeof (struct fb_fix_screeninfo));
  1838. strcpy (fix->id, rinfo->name);
  1839.         
  1840.         fix->smem_start = rinfo->fb_base_phys;
  1841.         fix->smem_len = rinfo->video_ram;
  1843.         fix->type = disp->type;
  1844.         fix->type_aux = disp->type_aux;
  1845.         fix->visual = disp->visual;
  1847.         fix->xpanstep = 8;
  1848.         fix->ypanstep = 1;
  1849.         fix->ywrapstep = 0;
  1850.         
  1851.         fix->line_length = disp->line_length;
  1852.  
  1853.         fix->mmio_start = rinfo->mmio_base_phys;
  1854.         fix->mmio_len = RADEON_REGSIZE;
  1855. if (noaccel)
  1856.         fix->accel = FB_ACCEL_NONE;
  1857. else
  1858. fix->accel = 40; /* XXX */
  1859.         
  1860.         return 0;
  1861. }
  1865. static int radeonfb_get_var (struct fb_var_screeninfo *var, int con,
  1866.                              struct fb_info *info)
  1867. {
  1868.         struct radeonfb_info *rinfo = (struct radeonfb_info *) info;
  1869.         
  1870.         *var = (con < 0) ? rinfo->disp.var : fb_display[con].var;
  1871.         
  1872.         return 0;
  1873. }
  1877. static int radeonfb_set_var (struct fb_var_screeninfo *var, int con,
  1878.                              struct fb_info *info)
  1879. {
  1880.         struct radeonfb_info *rinfo = (struct radeonfb_info *) info;
  1881.         struct display *disp;
  1882.         struct fb_var_screeninfo v;
  1883.         int nom, den, accel;
  1884.         unsigned chgvar = 0;
  1886.         disp = (con < 0) ? rinfo->info.disp : &fb_display[con];
  1888.         accel = var->accel_flags & FB_ACCELF_TEXT;
  1890.         if (con >= 0) {
  1891.                 chgvar = ((disp->var.xres != var->xres) ||
  1892.                           (disp->var.yres != var->yres) ||
  1893.                           (disp->var.xres_virtual != var->xres_virtual) ||
  1894.                           (disp->var.yres_virtual != var->yres_virtual) ||
  1895.                           (disp->var.bits_per_pixel != var->bits_per_pixel) ||
  1896.                           memcmp (&disp->var.red, &var->red, sizeof (var->red)) ||
  1897.                           memcmp (&disp->var.green, &var->green, sizeof (var->green)) ||
  1898.                           memcmp (&disp->var.blue, &var->blue, sizeof (var->blue)));
  1899.         }
  1901.         memcpy (&v, var, sizeof (v));
  1903.         switch (v.bits_per_pixel) {
  1904. case 0 ... 8:
  1905. v.bits_per_pixel = 8;
  1906. break;
  1907. case 9 ... 16:
  1908. v.bits_per_pixel = 16;
  1909. break;
  1910. case 17 ... 24:
  1911. v.bits_per_pixel = 24;
  1912. break;
  1913. case 25 ... 32:
  1914. v.bits_per_pixel = 32;
  1915. break;
  1916. default:
  1917. return -EINVAL;
  1918. }
  1920. switch (var_to_depth(&v)) {
  1921. #ifdef FBCON_HAS_CFB8
  1922.                 case 8:
  1923.                         nom = den = 1;
  1924.                         disp->line_length = v.xres_virtual;
  1925.                         disp->visual = FB_VISUAL_PSEUDOCOLOR; 
  1926.                         v.red.offset = v.green.offset = v.blue.offset = 0;
  1927.                         v.red.length = v.green.length = v.blue.length = 8;
  1928.                         v.transp.offset = v.transp.length = 0;
  1929.                         break;
  1930. #endif
  1931.                         
  1932. #ifdef FBCON_HAS_CFB16
  1933. case 15:
  1934. nom = 2;
  1935. den = 1;
  1936. disp->line_length = v.xres_virtual * 2;
  1937. disp->visual = FB_VISUAL_DIRECTCOLOR;
  1938. v.red.offset = 10;
  1939. v.green.offset = 5;
  1940. v.red.offset = 0;
  1941. v.red.length = v.green.length = v.blue.length = 5;
  1942. v.transp.offset = v.transp.length = 0;
  1943. break;
  1944.                 case 16:
  1945.                         nom = 2;
  1946.                         den = 1;
  1947.                         disp->line_length = v.xres_virtual * 2;
  1948.                         disp->visual = FB_VISUAL_DIRECTCOLOR;
  1949.                         v.red.offset = 11;
  1950.                         v.green.offset = 5;
  1951.                         v.blue.offset = 0;
  1952.                         v.red.length = 5;
  1953.                         v.green.length = 6;
  1954.                         v.blue.length = 5;
  1955.                         v.transp.offset = v.transp.length = 0;
  1956.                         break;  
  1957. #endif
  1958.                         
  1959. #ifdef FBCON_HAS_CFB24
  1960.                 case 24:
  1961.                         nom = 4;
  1962.                         den = 1;
  1963.                         disp->line_length = v.xres_virtual * 3;
  1964.                         disp->visual = FB_VISUAL_DIRECTCOLOR;
  1965.                         v.red.offset = 16;
  1966.                         v.green.offset = 8;
  1967.                         v.blue.offset = 0;
  1968.                         v.red.length = v.blue.length = v.green.length = 8;
  1969.                         v.transp.offset = v.transp.length = 0;
  1970.                         break;
  1971. #endif
  1972. #ifdef FBCON_HAS_CFB32
  1973.                 case 32:
  1974.                         nom = 4;
  1975.                         den = 1;
  1976.                         disp->line_length = v.xres_virtual * 4;
  1977.                         disp->visual = FB_VISUAL_DIRECTCOLOR;
  1978.                         v.red.offset = 16;
  1979.                         v.green.offset = 8;
  1980.                         v.blue.offset = 0;
  1981.                         v.red.length = v.blue.length = v.green.length = 8;
  1982.                         v.transp.offset = 24;
  1983.                         v.transp.length = 8;
  1984.                         break;
  1985. #endif
  1986.                 default:
  1987.                         printk ("radeonfb: mode %dx%dx%d rejected, color depth invalidn",
  1988.                                 var->xres, var->yres, var->bits_per_pixel);
  1989.                         return -EINVAL;
  1990.         }
  1992.         if (radeonfb_do_maximize(rinfo, var, &v, nom, den) < 0)
  1993.                 return -EINVAL;  
  1994.                 
  1995.         if (v.xoffset < 0)
  1996.                 v.xoffset = 0;
  1997.         if (v.yoffset < 0)
  1998.                 v.yoffset = 0;
  1999.          
  2000.         if (v.xoffset > v.xres_virtual - v.xres)
  2001.                 v.xoffset = v.xres_virtual - v.xres - 1;
  2002.                         
  2003.         if (v.yoffset > v.yres_virtual - v.yres)
  2004.                 v.yoffset = v.yres_virtual - v.yres - 1;
  2005.          
  2006.         v.red.msb_right = v.green.msb_right = v.blue.msb_right =
  2007.                           v.transp.offset = v.transp.length =
  2008.                           v.transp.msb_right = 0;
  2009.                         
  2010.         switch (v.activate & FB_ACTIVATE_MASK) {
  2011.                 case FB_ACTIVATE_TEST:
  2012.                         return 0;
  2013.                 case FB_ACTIVATE_NXTOPEN:
  2014.                 case FB_ACTIVATE_NOW:
  2015.                         break;
  2016.                 default:
  2017.                         return -EINVAL;
  2018.         }
  2019.         
  2020.         memcpy (&disp->var, &v, sizeof (v));
  2021.         
  2022.         if (chgvar) {     
  2023.                 radeon_set_dispsw(rinfo, disp);
  2025.                 if (noaccel)
  2026.                         disp->scrollmode = SCROLL_YREDRAW;
  2027.                 else
  2028.                         disp->scrollmode = 0;
  2029.                 
  2030.                 if (info && info->changevar)
  2031.                         info->changevar(con);
  2032.         }
  2033.          
  2034.         radeon_load_video_mode (rinfo, &v);
  2035.                 
  2036.         do_install_cmap(con, info);
  2037.   
  2038.         return 0;
  2039. }
  2043. static int radeonfb_get_cmap (struct fb_cmap *cmap, int kspc, int con,
  2044.                               struct fb_info *info)
  2045. {
  2046.         struct radeonfb_info *rinfo = (struct radeonfb_info *) info;
  2047.         struct display *disp;
  2048.                 
  2049.         disp = (con < 0) ? rinfo->info.disp : &fb_display[con];
  2050.         
  2051.         if (con == rinfo->currcon) {
  2052.                 int rc = fb_get_cmap (cmap, kspc, radeon_getcolreg, info);
  2053.                 return rc;
  2054.         } else if (disp->cmap.len)
  2055.                 fb_copy_cmap (&disp->cmap, cmap, kspc ? 0 : 2);
  2056.         else
  2057.                 fb_copy_cmap (fb_default_cmap (radeon_get_cmap_len (&disp->var)),
  2058.                               cmap, kspc ? 0 : 2);
  2059.                         
  2060.         return 0;
  2061. }
  2065. static int radeonfb_set_cmap (struct fb_cmap *cmap, int kspc, int con,
  2066.                               struct fb_info *info)
  2067. {
  2068.         struct radeonfb_info *rinfo = (struct radeonfb_info *) info;
  2069.         struct display *disp;
  2070.         unsigned int cmap_len;
  2071.                 
  2072.         disp = (con < 0) ? rinfo->info.disp : &fb_display[con];
  2073.   
  2074.         cmap_len = radeon_get_cmap_len (&disp->var);
  2075.         if (disp->cmap.len != cmap_len) {
  2076.                 int err = fb_alloc_cmap (&disp->cmap, cmap_len, 0);
  2077.                 if (err)
  2078.                         return err;
  2079.         }
  2080.  
  2081.         if (con == rinfo->currcon) {
  2082.                 int rc = fb_set_cmap (cmap, kspc, radeon_setcolreg, info);
  2083.                 return rc;
  2084.         } else
  2085.                 fb_copy_cmap (cmap, &disp->cmap, kspc ? 0 : 1);
  2086.         
  2087.         return 0;
  2088. }               
  2092. static int radeonfb_pan_display (struct fb_var_screeninfo *var, int con,
  2093.                                  struct fb_info *info)
  2094. {
  2095.         struct radeonfb_info *rinfo = (struct radeonfb_info *) info;
  2096.         u32 offset, xoffset, yoffset;
  2097.                 
  2098.         xoffset = (var->xoffset + 7) & ~7;
  2099.         yoffset = var->yoffset;
  2100.                 
  2101.         if ((xoffset + var->xres > var->xres_virtual) || (yoffset+var->yres >
  2102.                 var->yres_virtual))
  2103.                 return -EINVAL;
  2104.                 
  2105.         offset = ((yoffset * var->xres + xoffset) * var->bits_per_pixel) >> 6;
  2106.          
  2107.         OUTREG(CRTC_OFFSET, offset);
  2108.         
  2109.         return 0;
  2110. }
  2113. static int radeonfb_ioctl (struct inode *inode, struct file *file, unsigned int cmd,
  2114.                            unsigned long arg, int con, struct fb_info *info)
  2115. {
  2116. return -EINVAL;
  2117. }
  2120. static int radeonfb_switch (int con, struct fb_info *info)
  2121. {
  2122.         struct radeonfb_info *rinfo = (struct radeonfb_info *) info;
  2123.         struct display *disp;
  2124.         struct fb_cmap *cmap;
  2125.         int switchmode = 0;
  2126.         
  2127.         disp = (con < 0) ? rinfo->info.disp : &fb_display[con];
  2128.                 
  2129.         if (rinfo->currcon >= 0) {
  2130.                 cmap = &(rinfo->currcon_display->cmap);
  2131.                 if (cmap->len)
  2132.                         fb_get_cmap (cmap, 1, radeon_getcolreg, info);
  2133.         }   
  2134.                 
  2135. switchmode = (con != rinfo->currcon);
  2137. rinfo->currcon = con;
  2138. rinfo->currcon_display = disp;
  2139. disp->var.activate = FB_ACTIVATE_NOW;
  2140.         
  2141.         if (switchmode) {
  2142.                 radeonfb_set_var (&disp->var, con, info);
  2143.                 radeon_set_dispsw (rinfo, disp);
  2144.                 do_install_cmap(con, info);
  2145.         }       
  2147.         /* XXX absurd hack for X to restore console */
  2148.         {   
  2149. OUTREGP(CRTC_EXT_CNTL, rinfo->hack_crtc_ext_cntl,
  2150. CRTC_HSYNC_DIS | CRTC_VSYNC_DIS | CRTC_DISPLAY_DIS);
  2151.                 OUTREG(CRTC_V_SYNC_STRT_WID, rinfo->hack_crtc_v_sync_strt_wid);
  2152.         }
  2154.         return 0;
  2155. }
  2159. static int radeonfb_updatevar (int con, struct fb_info *info)
  2160. {
  2161.         int rc;
  2162.                 
  2163.         rc = (con < 0) ? -EINVAL : radeonfb_pan_display (&fb_display[con].var,
  2164.                                                          con, info);
  2165.         
  2166.         return rc;
  2167. }
  2169. static void radeonfb_blank (int blank, struct fb_info *info)
  2170. {
  2171.         struct radeonfb_info *rinfo = (struct radeonfb_info *) info;
  2172.         u32 val = INREG(CRTC_EXT_CNTL);
  2173. u32 val2 = INREG(LVDS_GEN_CNTL);
  2175. #ifdef CONFIG_PMAC_BACKLIGHT
  2176. if (rinfo->dviDisp_type == MT_LCD && _machine == _MACH_Pmac) {
  2177. set_backlight_enable(!blank);
  2178. return;
  2179. }
  2180. #endif
  2181.                         
  2182.         /* reset it */
  2183.         val &= ~(CRTC_DISPLAY_DIS | CRTC_HSYNC_DIS |
  2184.                  CRTC_VSYNC_DIS);
  2185. val2 &= ~(LVDS_DISPLAY_DIS);
  2187.         switch (blank) {
  2188.                 case VESA_NO_BLANKING:
  2189.                         break;
  2190.                 case VESA_VSYNC_SUSPEND:
  2191.                         val |= (CRTC_DISPLAY_DIS | CRTC_VSYNC_DIS);
  2192.                         break;
  2193.                 case VESA_HSYNC_SUSPEND:
  2194.                         val |= (CRTC_DISPLAY_DIS | CRTC_HSYNC_DIS);
  2195.                         break;
  2196.                 case VESA_POWERDOWN:
  2197.                         val |= (CRTC_DISPLAY_DIS | CRTC_VSYNC_DIS | 
  2198.                                 CRTC_HSYNC_DIS);
  2199. val2 |= (LVDS_DISPLAY_DIS);
  2200.                         break;
  2201.         }
  2203. switch (rinfo->dviDisp_type) {
  2204. case MT_LCD:
  2205. OUTREG(LVDS_GEN_CNTL, val2);
  2206. break;
  2207. case MT_CRT:
  2208. default:
  2209.         OUTREG(CRTC_EXT_CNTL, val);
  2210. break;
  2211. }
  2212. }
  2215. static int radeon_get_cmap_len (const struct fb_var_screeninfo *var)
  2216. {
  2217.         int rc = 256;            /* reasonable default */
  2218.         
  2219.         switch (var_to_depth(var)) {
  2220.                 case 15:
  2221.                         rc = 32;
  2222.                         break;
  2223. case 16:
  2224. rc = 64;
  2225. break;
  2226.         }
  2227.                 
  2228.         return rc;
  2229. }
  2233. static int radeon_getcolreg (unsigned regno, unsigned *red, unsigned *green,
  2234.                              unsigned *blue, unsigned *transp,
  2235.                              struct fb_info *info)
  2236. {
  2237.         struct radeonfb_info *rinfo = (struct radeonfb_info *) info;
  2239. if (regno > 255)
  2240. return 1;
  2241.      
  2242.   *red = (rinfo->palette[regno].red<<8) | rinfo->palette[regno].red; 
  2243.      *green = (rinfo->palette[regno].green<<8) | rinfo->palette[regno].green;
  2244.      *blue = (rinfo->palette[regno].blue<<8) | rinfo->palette[regno].blue;
  2245.      *transp = 0;
  2247. return 0;
  2248. }                            
  2252. static int radeon_setcolreg (unsigned regno, unsigned red, unsigned green,
  2253.                              unsigned blue, unsigned transp, struct fb_info *info)
  2254. {
  2255.         struct radeonfb_info *rinfo = (struct radeonfb_info *) info;
  2256. u32 pindex;
  2258. if (regno > 255)
  2259. return 1;
  2261. red >>= 8;
  2262. green >>= 8;
  2263. blue >>= 8;
  2264. rinfo->palette[regno].red = red;
  2265. rinfo->palette[regno].green = green;
  2266. rinfo->palette[regno].blue = blue;
  2268.         /* default */
  2269.         pindex = regno;
  2270.         
  2271. if (rinfo->bpp == 16) {
  2272. pindex = regno * 8;
  2274. if (rinfo->depth == 16 && regno > 63)
  2275. return 1;
  2276. if (rinfo->depth == 15 && regno > 31)
  2277. return 1;
  2279. /* For 565, the green component is mixed one order below */
  2280. if (rinfo->depth == 16) {
  2281.                 OUTREG(PALETTE_INDEX, pindex>>1);
  2282.                   OUTREG(PALETTE_DATA, (rinfo->palette[regno>>1].red << 16) |
  2283.                          (green << 8) | (rinfo->palette[regno>>1].blue));
  2284.                  green = rinfo->palette[regno<<1].green;
  2285.          }
  2286. }
  2288. if (rinfo->depth != 16 || regno < 32) {
  2289. OUTREG(PALETTE_INDEX, pindex);
  2290. OUTREG(PALETTE_DATA, (red << 16) | (green << 8) | blue);
  2291. }
  2293.   if (regno < 16) {
  2294.          switch (rinfo->depth) {
  2295. #ifdef FBCON_HAS_CFB16
  2296.         case 15:
  2297.          rinfo->con_cmap.cfb16[regno] = (regno << 10) | (regno << 5) |
  2298.                             regno;   
  2299.         break;
  2300.         case 16:
  2301.          rinfo->con_cmap.cfb16[regno] = (regno << 11) | (regno << 5) |
  2302.                             regno;   
  2303.         break;
  2304. #endif
  2305. #ifdef FBCON_HAS_CFB24
  2306.                         case 24:
  2307.                                 rinfo->con_cmap.cfb24[regno] = (regno << 16) | (regno << 8) | regno;
  2308.                                 break;
  2309. #endif
  2310. #ifdef FBCON_HAS_CFB32
  2311.          case 32: {
  2312.              u32 i;    
  2313.    
  2314.            i = (regno << 8) | regno;
  2315.              rinfo->con_cmap.cfb32[regno] = (i << 16) | i;
  2316.          break;
  2317.          }
  2318. #endif
  2319. }
  2320.         }
  2321. return 0;
  2322. }
  2326. static void radeon_save_state (struct radeonfb_info *rinfo,
  2327.                                struct radeon_regs *save)
  2328. {
  2329. /* CRTC regs */
  2330. save->crtc_gen_cntl = INREG(CRTC_GEN_CNTL);
  2331. save->crtc_ext_cntl = INREG(CRTC_EXT_CNTL);
  2332. save->dac_cntl = INREG(DAC_CNTL);
  2333.         save->crtc_h_total_disp = INREG(CRTC_H_TOTAL_DISP);
  2334.         save->crtc_h_sync_strt_wid = INREG(CRTC_H_SYNC_STRT_WID);
  2335.         save->crtc_v_total_disp = INREG(CRTC_V_TOTAL_DISP);
  2336.         save->crtc_v_sync_strt_wid = INREG(CRTC_V_SYNC_STRT_WID);
  2337. save->crtc_pitch = INREG(CRTC_PITCH);
  2338. #if defined(__BIG_ENDIAN)
  2339. save->surface_cntl = INREG(SURFACE_CNTL);
  2340. #endif
  2342. /* FP regs */
  2343. save->fp_crtc_h_total_disp = INREG(FP_CRTC_H_TOTAL_DISP);
  2344. save->fp_crtc_v_total_disp = INREG(FP_CRTC_V_TOTAL_DISP);
  2345. save->fp_gen_cntl = INREG(FP_GEN_CNTL);
  2346. save->fp_h_sync_strt_wid = INREG(FP_H_SYNC_STRT_WID);
  2347. save->fp_horz_stretch = INREG(FP_HORZ_STRETCH);
  2348. save->fp_v_sync_strt_wid = INREG(FP_V_SYNC_STRT_WID);
  2349. save->fp_vert_stretch = INREG(FP_VERT_STRETCH);
  2350. save->lvds_gen_cntl = INREG(LVDS_GEN_CNTL);
  2351. save->lvds_pll_cntl = INREG(LVDS_PLL_CNTL);
  2352. save->tmds_crc = INREG(TMDS_CRC);
  2353. save->tmds_transmitter_cntl = INREG(TMDS_TRANSMITTER_CNTL);
  2354. }
  2358. static void radeon_load_video_mode (struct radeonfb_info *rinfo,
  2359.                                     struct fb_var_screeninfo *mode)
  2360. {
  2361. struct radeon_regs newmode;
  2362. int hTotal, vTotal, hSyncStart, hSyncEnd,
  2363.     hSyncPol, vSyncStart, vSyncEnd, vSyncPol, cSync;
  2364. u8 hsync_adj_tab[] = {0, 0x12, 9, 9, 6, 5};
  2365. u8 hsync_fudge_fp[] = {2, 2, 0, 0, 5, 5};
  2366. u32 dotClock = 1000000000 / mode->pixclock,
  2367.     sync, h_sync_pol, v_sync_pol;
  2368. int freq = dotClock / 10;  /* x 100 */
  2369.         int xclk_freq, vclk_freq, xclk_per_trans, xclk_per_trans_precise;
  2370.         int useable_precision, roff, ron;
  2371.         int min_bits, format = 0;
  2372. int hsync_start, hsync_fudge, bytpp, hsync_wid, vsync_wid;
  2373. int primary_mon = PRIMARY_MONITOR(rinfo);
  2374. int depth = var_to_depth(mode);
  2376. rinfo->xres = mode->xres;
  2377. rinfo->yres = mode->yres;
  2378. rinfo->pixclock = mode->pixclock;
  2380. hSyncStart = mode->xres + mode->right_margin;
  2381. hSyncEnd = hSyncStart + mode->hsync_len;
  2382. hTotal = hSyncEnd + mode->left_margin;
  2384. vSyncStart = mode->yres + mode->lower_margin;
  2385. vSyncEnd = vSyncStart + mode->vsync_len;
  2386. vTotal = vSyncEnd + mode->upper_margin;
  2388. if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD)) {
  2389. if (rinfo->panel_xres < mode->xres)
  2390. rinfo->xres = mode->xres = rinfo->panel_xres;
  2391. if (rinfo->panel_yres < mode->yres)
  2392. rinfo->yres = mode->yres = rinfo->panel_yres;
  2394. hTotal = mode->xres + rinfo->hblank;
  2395. hSyncStart = mode->xres + rinfo->hOver_plus;
  2396. hSyncEnd = hSyncStart + rinfo->hSync_width;
  2398. vTotal = mode->yres + rinfo->vblank;
  2399. vSyncStart = mode->yres + rinfo->vOver_plus;
  2400. vSyncEnd = vSyncStart + rinfo->vSync_width;
  2401. }
  2403. sync = mode->sync;
  2404. h_sync_pol = sync & FB_SYNC_HOR_HIGH_ACT ? 0 : 1;
  2405. v_sync_pol = sync & FB_SYNC_VERT_HIGH_ACT ? 0 : 1;
  2407. RTRACE("hStart = %d, hEnd = %d, hTotal = %dn",
  2408. hSyncStart, hSyncEnd, hTotal);
  2409. RTRACE("vStart = %d, vEnd = %d, vTotal = %dn",
  2410. vSyncStart, vSyncEnd, vTotal);
  2412. hsync_wid = (hSyncEnd - hSyncStart) / 8;
  2413. vsync_wid = vSyncEnd - vSyncStart;
  2414. if (hsync_wid == 0)
  2415. hsync_wid = 1;
  2416. else if (hsync_wid > 0x3f) /* max */
  2417. hsync_wid = 0x3f;
  2419. if (vsync_wid == 0)
  2420. vsync_wid = 1;
  2421. else if (vsync_wid > 0x1f) /* max */
  2422. vsync_wid = 0x1f;
  2424. hSyncPol = mode->sync & FB_SYNC_HOR_HIGH_ACT ? 0 : 1;
  2425. vSyncPol = mode->sync & FB_SYNC_VERT_HIGH_ACT ? 0 : 1;
  2427. cSync = mode->sync & FB_SYNC_COMP_HIGH_ACT ? (1 << 4) : 0;
  2429. format = radeon_get_dstbpp(depth);
  2430. bytpp = mode->bits_per_pixel >> 3;
  2432. if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD))
  2433. hsync_fudge = hsync_fudge_fp[format-1];
  2434. else
  2435. hsync_fudge = hsync_adj_tab[format-1];
  2437. hsync_start = hSyncStart - 8 + hsync_fudge;
  2439. newmode.crtc_gen_cntl = CRTC_EXT_DISP_EN | CRTC_EN |
  2440. (format << 8);
  2442. if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD)) {
  2443. newmode.crtc_ext_cntl = VGA_ATI_LINEAR | XCRT_CNT_EN;
  2444. newmode.crtc_gen_cntl &= ~(CRTC_DBL_SCAN_EN |
  2445.    CRTC_INTERLACE_EN);
  2446. } else {
  2447. newmode.crtc_ext_cntl = VGA_ATI_LINEAR | XCRT_CNT_EN |
  2448. CRTC_CRT_ON;
  2449. }
  2451. newmode.dac_cntl = /* INREG(DAC_CNTL) | */ DAC_MASK_ALL | DAC_VGA_ADR_EN |
  2452.    DAC_8BIT_EN;
  2454. newmode.crtc_h_total_disp = ((((hTotal / 8) - 1) & 0x3ff) |
  2455.      (((mode->xres / 8) - 1) << 16));
  2457. newmode.crtc_h_sync_strt_wid = ((hsync_start & 0x1fff) |
  2458. (hsync_wid << 16) | (h_sync_pol << 23));
  2460. newmode.crtc_v_total_disp = ((vTotal - 1) & 0xffff) |
  2461.     ((mode->yres - 1) << 16);
  2463. newmode.crtc_v_sync_strt_wid = (((vSyncStart - 1) & 0xfff) |
  2464.  (vsync_wid << 16) | (v_sync_pol  << 23));
  2466. newmode.crtc_pitch = (mode->xres >> 3);
  2467. newmode.crtc_pitch |= (newmode.crtc_pitch << 16);
  2469. #if defined(__BIG_ENDIAN)
  2470. newmode.surface_cntl = SURF_TRANSLATION_DIS;
  2471. switch (mode->bits_per_pixel) {
  2472. case 16:
  2473. newmode.surface_cntl |= NONSURF_AP0_SWP_16BPP;
  2474. break;
  2475. case 24:
  2476. case 32:
  2477. newmode.surface_cntl |= NONSURF_AP0_SWP_32BPP;
  2478. break;
  2479. }
  2480. #endif
  2482. rinfo->pitch = ((mode->xres * ((mode->bits_per_pixel + 1) / 8) + 0x3f)
  2483. & ~(0x3f)) / 64;
  2485. RTRACE("h_total_disp = 0x%xt   hsync_strt_wid = 0x%xn",
  2486. newmode.crtc_h_total_disp, newmode.crtc_h_sync_strt_wid);
  2487. RTRACE("v_total_disp = 0x%xt   vsync_strt_wid = 0x%xn",
  2488. newmode.crtc_v_total_disp, newmode.crtc_v_sync_strt_wid);
  2490. newmode.xres = mode->xres;
  2491. newmode.yres = mode->yres;
  2493. rinfo->bpp = mode->bits_per_pixel;
  2494. rinfo->depth = depth;
  2496. rinfo->hack_crtc_ext_cntl = newmode.crtc_ext_cntl;
  2497. rinfo->hack_crtc_v_sync_strt_wid = newmode.crtc_v_sync_strt_wid;
  2499. if (freq > rinfo->pll.ppll_max)
  2500. freq = rinfo->pll.ppll_max;
  2501. if (freq*12 < rinfo->pll.ppll_min)
  2502. freq = rinfo->pll.ppll_min / 12;
  2504. {
  2505. struct {
  2506. int divider;
  2507. int bitvalue;
  2508. } *post_div,
  2509.   post_divs[] = {
  2510. { 1,  0 },
  2511. { 2,  1 },
  2512. { 4,  2 },
  2513. { 8,  3 },
  2514. { 3,  4 },
  2515. { 16, 5 },
  2516. { 6,  6 },
  2517. { 12, 7 },
  2518. { 0,  0 },
  2519. };
  2521. for (post_div = &post_divs[0]; post_div->divider; ++post_div) {
  2522. rinfo->pll_output_freq = post_div->divider * freq;
  2523. if (rinfo->pll_output_freq >= rinfo->pll.ppll_min  &&
  2524.     rinfo->pll_output_freq <= rinfo->pll.ppll_max)
  2525. break;
  2526. }
  2528. rinfo->post_div = post_div->divider;
  2529. rinfo->fb_div = round_div(rinfo->pll.ref_div*rinfo->pll_output_freq,
  2530.   rinfo->pll.ref_clk);
  2531. newmode.ppll_ref_div = rinfo->pll.ref_div;
  2532. newmode.ppll_div_3 = rinfo->fb_div | (post_div->bitvalue << 16);
  2533. }
  2535. RTRACE("post div = 0x%xn", rinfo->post_div);
  2536. RTRACE("fb_div = 0x%xn", rinfo->fb_div);
  2537. RTRACE("ppll_div_3 = 0x%xn", newmode.ppll_div_3);
  2539. /* DDA */
  2540. vclk_freq = round_div(rinfo->pll.ref_clk * rinfo->fb_div,
  2541.       rinfo->pll.ref_div * rinfo->post_div);
  2542. xclk_freq = rinfo->pll.xclk;
  2544. xclk_per_trans = round_div(xclk_freq * 128, vclk_freq * mode->bits_per_pixel);
  2546. min_bits = min_bits_req(xclk_per_trans);
  2547. useable_precision = min_bits + 1;
  2549. xclk_per_trans_precise = round_div((xclk_freq * 128) << (11 - useable_precision),
  2550.    vclk_freq * mode->bits_per_pixel);
  2552. ron = (4 * rinfo->ram.mb + 3 * _max(rinfo->ram.trcd - 2, 0) +
  2553.        2 * rinfo->ram.trp + rinfo->ram.twr + rinfo->ram.cl + rinfo->ram.tr2w +
  2554.        xclk_per_trans) << (11 - useable_precision);
  2555. roff = xclk_per_trans_precise * (32 - 4);
  2557. RTRACE("ron = %d, roff = %dn", ron, roff);
  2558. RTRACE("vclk_freq = %d, per = %dn", vclk_freq, xclk_per_trans_precise);
  2560. if ((ron + rinfo->ram.rloop) >= roff) {
  2561. printk("radeonfb: error ron out of rangen");
  2562. return;
  2563. }
  2565. newmode.dda_config = (xclk_per_trans_precise |
  2566.       (useable_precision << 16) |
  2567.       (rinfo->ram.rloop << 20));
  2568. newmode.dda_on_off = (ron << 16) | roff;
  2570. if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD)) {
  2571. unsigned int hRatio, vRatio;
  2573. if (mode->xres > rinfo->panel_xres)
  2574. mode->xres = rinfo->panel_xres;
  2575. if (mode->yres > rinfo->panel_yres)
  2576. mode->yres = rinfo->panel_yres;
  2578. newmode.fp_horz_stretch = (((rinfo->panel_xres / 8) - 1)
  2579.    << HORZ_PANEL_SHIFT);
  2580. newmode.fp_vert_stretch = ((rinfo->panel_yres - 1)
  2581.    << VERT_PANEL_SHIFT);
  2583. if (mode->xres != rinfo->panel_xres) {
  2584. hRatio = round_div(mode->xres * HORZ_STRETCH_RATIO_MAX,
  2585.    rinfo->panel_xres);
  2586. newmode.fp_horz_stretch = (((((unsigned long)hRatio) & HORZ_STRETCH_RATIO_MASK)) |
  2587.    (newmode.fp_horz_stretch &
  2588.     (HORZ_PANEL_SIZE | HORZ_FP_LOOP_STRETCH |
  2589.      HORZ_AUTO_RATIO_INC)));
  2590. newmode.fp_horz_stretch |= (HORZ_STRETCH_BLEND |
  2591.     HORZ_STRETCH_ENABLE);
  2592. }
  2593. newmode.fp_horz_stretch &= ~HORZ_AUTO_RATIO;
  2595. if (mode->yres != rinfo->panel_yres) {
  2596. vRatio = round_div(mode->yres * VERT_STRETCH_RATIO_MAX,
  2597.    rinfo->panel_yres);
  2598. newmode.fp_vert_stretch = (((((unsigned long)vRatio) & VERT_STRETCH_RATIO_MASK)) |
  2599.    (newmode.fp_vert_stretch &
  2600.    (VERT_PANEL_SIZE | VERT_STRETCH_RESERVED)));
  2601. newmode.fp_vert_stretch |= (VERT_STRETCH_BLEND |
  2602.     VERT_STRETCH_ENABLE);
  2603. }
  2604. newmode.fp_vert_stretch &= ~VERT_AUTO_RATIO_EN;
  2606. newmode.fp_gen_cntl = (rinfo->init_state.fp_gen_cntl & (u32)
  2607.        ~(FP_SEL_CRTC2 |
  2608.  FP_RMX_HVSYNC_CONTROL_EN |
  2609.  FP_DFP_SYNC_SEL |
  2610.  FP_CRT_SYNC_SEL |
  2611.  FP_CRTC_LOCK_8DOT |
  2612.  FP_USE_SHADOW_EN |
  2613.  FP_CRTC_USE_SHADOW_VEND |
  2614.  FP_CRT_SYNC_ALT));
  2616. newmode.fp_gen_cntl |= (FP_CRTC_DONT_SHADOW_VPAR |
  2617. FP_CRTC_DONT_SHADOW_HEND);
  2619. newmode.lvds_gen_cntl = rinfo->init_state.lvds_gen_cntl;
  2620. newmode.lvds_pll_cntl = rinfo->init_state.lvds_pll_cntl;
  2621. newmode.tmds_crc = rinfo->init_state.tmds_crc;
  2622. newmode.tmds_transmitter_cntl = rinfo->init_state.tmds_transmitter_cntl;
  2624. if (primary_mon == MT_LCD) {
  2625. newmode.lvds_gen_cntl |= (LVDS_ON | LVDS_BLON);
  2626. newmode.fp_gen_cntl &= ~(FP_FPON | FP_TMDS_EN);
  2627. } else {
  2628. /* DFP */
  2629. newmode.fp_gen_cntl |= (FP_FPON | FP_TMDS_EN);
  2630. newmode.tmds_transmitter_cntl = (TMDS_RAN_PAT_RST |
  2631.  ICHCSEL) & ~(TMDS_PLLRST);
  2632. newmode.crtc_ext_cntl &= ~CRTC_CRT_ON;
  2633. }
  2635. newmode.fp_crtc_h_total_disp = newmode.crtc_h_total_disp;
  2636. newmode.fp_crtc_v_total_disp = newmode.crtc_v_total_disp;
  2637. newmode.fp_h_sync_strt_wid = newmode.crtc_h_sync_strt_wid;
  2638. newmode.fp_v_sync_strt_wid = newmode.crtc_v_sync_strt_wid;
  2639. }
  2641. /* do it! */
  2642. radeon_write_mode (rinfo, &newmode);
  2644. #if defined(CONFIG_BOOTX_TEXT)
  2645. btext_update_display(rinfo->fb_base_phys, mode->xres, mode->yres,
  2646.      rinfo->depth, rinfo->pitch*64);
  2647. #endif
  2649. return;
  2650. }
  2653. static void radeon_write_mode (struct radeonfb_info *rinfo,
  2654.                                struct radeon_regs *mode)
  2655. {
  2656. int i;
  2657. int primary_mon = PRIMARY_MONITOR(rinfo);
  2659. /* blank screen */
  2660. OUTREGP(CRTC_EXT_CNTL, CRTC_DISPLAY_DIS | CRTC_VSYNC_DIS | CRTC_HSYNC_DIS,
  2661. ~(CRTC_DISPLAY_DIS | CRTC_VSYNC_DIS | CRTC_HSYNC_DIS));
  2663. for (i=0; i<9; i++)
  2664. OUTREG(common_regs[i].reg, common_regs[i].val);
  2666. OUTREG(CRTC_GEN_CNTL, mode->crtc_gen_cntl);
  2667. OUTREGP(CRTC_EXT_CNTL, mode->crtc_ext_cntl,
  2668. CRTC_HSYNC_DIS | CRTC_VSYNC_DIS | CRTC_DISPLAY_DIS);
  2669. OUTREGP(DAC_CNTL, mode->dac_cntl, DAC_RANGE_CNTL | DAC_BLANKING);
  2670. OUTREG(CRTC_H_TOTAL_DISP, mode->crtc_h_total_disp);
  2671. OUTREG(CRTC_H_SYNC_STRT_WID, mode->crtc_h_sync_strt_wid);
  2672. OUTREG(CRTC_V_TOTAL_DISP, mode->crtc_v_total_disp);
  2673. OUTREG(CRTC_V_SYNC_STRT_WID, mode->crtc_v_sync_strt_wid);
  2674. OUTREG(CRTC_OFFSET, 0);
  2675. OUTREG(CRTC_OFFSET_CNTL, 0);
  2676. OUTREG(CRTC_PITCH, mode->crtc_pitch);
  2678. #if defined(__BIG_ENDIAN)
  2679. OUTREG(SURFACE_CNTL, mode->surface_cntl);
  2680. #endif
  2682. while ((INREG(CLOCK_CNTL_INDEX) & PPLL_DIV_SEL_MASK) !=
  2683.        PPLL_DIV_SEL_MASK) {
  2684. OUTREGP(CLOCK_CNTL_INDEX, PPLL_DIV_SEL_MASK, 0xffff);
  2685. }
  2687. OUTPLLP(PPLL_CNTL, PPLL_RESET, 0xffff);
  2689. while ((INPLL(PPLL_REF_DIV) & PPLL_REF_DIV_MASK) !=
  2690.        (mode->ppll_ref_div & PPLL_REF_DIV_MASK)) {
  2691. OUTPLLP(PPLL_REF_DIV, mode->ppll_ref_div, ~PPLL_REF_DIV_MASK);
  2692. }
  2694. while ((INPLL(PPLL_DIV_3) & PPLL_FB3_DIV_MASK) !=
  2695.        (mode->ppll_div_3 & PPLL_FB3_DIV_MASK)) {
  2696. OUTPLLP(PPLL_DIV_3, mode->ppll_div_3, ~PPLL_FB3_DIV_MASK);
  2697. }
  2699. while ((INPLL(PPLL_DIV_3) & PPLL_POST3_DIV_MASK) !=
  2700.        (mode->ppll_div_3 & PPLL_POST3_DIV_MASK)) {
  2701. OUTPLLP(PPLL_DIV_3, mode->ppll_div_3, ~PPLL_POST3_DIV_MASK);
  2702. }
  2704. OUTPLL(HTOTAL_CNTL, 0);
  2706. OUTPLLP(PPLL_CNTL, 0, ~PPLL_RESET);
  2708. OUTREG(DDA_CONFIG, mode->dda_config);
  2709. OUTREG(DDA_ON_OFF, mode->dda_on_off);
  2711. if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD)) {
  2712. OUTREG(FP_CRTC_H_TOTAL_DISP, mode->fp_crtc_h_total_disp);
  2713. OUTREG(FP_CRTC_V_TOTAL_DISP, mode->fp_crtc_v_total_disp);
  2714. OUTREG(FP_H_SYNC_STRT_WID, mode->fp_h_sync_strt_wid);
  2715. OUTREG(FP_V_SYNC_STRT_WID, mode->fp_v_sync_strt_wid);
  2716. OUTREG(FP_HORZ_STRETCH, mode->fp_horz_stretch);
  2717. OUTREG(FP_VERT_STRETCH, mode->fp_vert_stretch);
  2718. OUTREG(FP_GEN_CNTL, mode->fp_gen_cntl);
  2719. OUTREG(TMDS_CRC, mode->tmds_crc);
  2720. OUTREG(TMDS_TRANSMITTER_CNTL, mode->tmds_transmitter_cntl);
  2722. if (primary_mon == MT_LCD) {
  2723. unsigned int tmp = INREG(LVDS_GEN_CNTL);
  2725. mode->lvds_gen_cntl &= ~LVDS_STATE_MASK;
  2726. mode->lvds_gen_cntl |= (rinfo->init_state.lvds_gen_cntl & LVDS_STATE_MASK);
  2728. if ((tmp & (LVDS_ON | LVDS_BLON)) ==
  2729.     (mode->lvds_gen_cntl & (LVDS_ON | LVDS_BLON))) {
  2730. OUTREG(LVDS_GEN_CNTL, mode->lvds_gen_cntl);
  2731. } else {
  2732. if (mode->lvds_gen_cntl & (LVDS_ON | LVDS_BLON)) {
  2733. udelay(1000);
  2734. OUTREG(LVDS_GEN_CNTL, mode->lvds_gen_cntl);
  2735. } else {
  2736. OUTREG(LVDS_GEN_CNTL, mode->lvds_gen_cntl |
  2737.        LVDS_BLON);
  2738. udelay(1000);
  2739. OUTREG(LVDS_GEN_CNTL, mode->lvds_gen_cntl);
  2740. }
  2741. }
  2742. }
  2743. }
  2745. /* unblank screen */
  2746. OUTREG8(CRTC_EXT_CNTL + 1, 0);
  2748. return;
  2749. }
  2752. #ifdef CONFIG_PMAC_BACKLIGHT
  2754. static int backlight_conv[] = {
  2755. 0xff, 0xc0, 0xb5, 0xaa, 0x9f, 0x94, 0x89, 0x7e,
  2756. 0x73, 0x68, 0x5d, 0x52, 0x47, 0x3c, 0x31, 0x24
  2757. };
  2759. #define BACKLIGHT_LVDS_OFF
  2760. #undef BACKLIGHT_DAC_OFF
  2762. /* We turn off the LCD completely instead of just dimming the backlight.
  2763.  * This provides some greater power saving and the display is useless
  2764.  * without backlight anyway.
  2765.  */
  2767. static int radeon_set_backlight_enable(int on, int level, void *data)
  2768. {
  2769. struct radeonfb_info *rinfo = (struct radeonfb_info *)data;
  2770. unsigned int lvds_gen_cntl = INREG(LVDS_GEN_CNTL);
  2772. lvds_gen_cntl |= (LVDS_BL_MOD_EN | LVDS_BLON);
  2773. if (on && (level > BACKLIGHT_OFF)) {
  2774. lvds_gen_cntl |= LVDS_DIGON;
  2775. if (!lvds_gen_cntl & LVDS_ON) {
  2776. lvds_gen_cntl &= ~LVDS_BLON;
  2777. OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
  2778. (void)INREG(LVDS_GEN_CNTL);
  2779. mdelay(10);
  2780. lvds_gen_cntl |= LVDS_BLON;
  2781. OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
  2782. }
  2783. lvds_gen_cntl &= ~LVDS_BL_MOD_LEVEL_MASK;
  2784. lvds_gen_cntl |= (backlight_conv[level] <<
  2785.   LVDS_BL_MOD_LEVEL_SHIFT);
  2786. lvds_gen_cntl |= (LVDS_ON | LVDS_EN);
  2787. lvds_gen_cntl &= ~LVDS_DISPLAY_DIS;
  2788. } else {
  2789. lvds_gen_cntl &= ~LVDS_BL_MOD_LEVEL_MASK;
  2790. lvds_gen_cntl |= (backlight_conv[0] <<
  2791.   LVDS_BL_MOD_LEVEL_SHIFT);
  2792. lvds_gen_cntl |= LVDS_DISPLAY_DIS;
  2793. OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
  2794. udelay(10);
  2795. lvds_gen_cntl &= ~(LVDS_ON | LVDS_EN | LVDS_BLON | LVDS_DIGON);
  2796. }
  2798. OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
  2799. rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
  2800. rinfo->init_state.lvds_gen_cntl |= (lvds_gen_cntl & LVDS_STATE_MASK);
  2802. return 0;
  2803. }
  2805. static int radeon_set_backlight_level(int level, void *data)
  2806. {
  2807. return radeon_set_backlight_enable(1, level, data);
  2808. }
  2809. #endif /* CONFIG_PMAC_BACKLIGHT */
  2812. #ifdef CONFIG_PMAC_PBOOK
  2813. static void radeon_set_suspend(struct radeonfb_info *rinfo, int suspend)
  2814. {
  2815. u16 pwr_cmd;
  2817. if (!rinfo->pm_reg)
  2818. return;
  2820. /* Set the chip into appropriate suspend mode (we use D2,
  2821.  * D3 would require a compete re-initialization of the chip,
  2822.  * including PCI config registers, clocks, AGP conf, ...)
  2823.  */
  2824. if (suspend) {
  2825. /* Make sure CRTC2 is reset.  Remove that the day
  2826.  * we decide to actually use CRTC2 and replace it with
  2827.  * real code for disabling the CRTC2 output during sleep.
  2828.  */
  2830. pci_read_config_word(rinfo->pdev, rinfo->pm_reg+PCI_PM_CTRL,
  2831.      &pwr_cmd);
  2833. /* Switch PCI power managment to D2 */
  2834. pci_write_config_word(rinfo->pdev, rinfo->pm_reg+PCI_PM_CTRL,
  2835.       (pwr_cmd & ~PCI_PM_CTRL_STATE_MASK)
  2836.       | 2);
  2837. pci_read_config_word(rinfo->pdev, rinfo->pm_reg+PCI_PM_CTRL,
  2838.      &pwr_cmd);
  2839. } else {
  2840. /* Switch back PCI powermanagment to D0 */
  2841. mdelay(100);
  2842. pci_write_config_word(rinfo->pdev, rinfo->pm_reg+PCI_PM_CTRL, 0);
  2843. mdelay(100);
  2844. pci_read_config_word(rinfo->pdev, rinfo->pm_reg+PCI_PM_CTRL,
  2845.      &pwr_cmd);
  2846. mdelay(100);
  2847. }
  2848. }
  2850. /*
  2851.  * Save the contents of the framebuffer when we go to sleep,
  2852.  * and restore it when we wake up again.
  2853.  */
  2855. int radeon_sleep_notify(struct pmu_sleep_notifier *self, int when)
  2856. {
  2857. struct radeonfb_info *rinfo;
  2859. for (rinfo = board_list; rinfo != NULL; rinfo = rinfo->next) {
  2860. struct fb_fix_screeninfo fix;
  2861. int nb;
  2863. switch (rinfo->chipset) {
  2864. case PCI_DEVICE_ID_RADEON_LW:
  2865. case PCI_DEVICE_ID_RADEON_LY:
  2866. case PCI_DEVICE_ID_RADEON_LZ:
  2867. break;
  2868. default:
  2869. return PBOOK_SLEEP_REFUSE;
  2870. }
  2872. radeonfb_get_fix(&fix, fg_console, (struct fb_info *)rinfo);
  2873. nb = fb_display[fg_console].var.yres * fix.line_length;
  2875. switch (when) {
  2876. case PBOOK_SLEEP_REQUEST:
  2877. #if 0
  2878. rinfo->save_framebuffer = vmalloc(nb);
  2879. if (rinfo->save_framebuffer == NULL)
  2880. return PBOOK_SLEEP_REFUSE;
  2881. #endif
  2882. break;
  2883. case PBOOK_SLEEP_REJECT:
  2884. #if 0
  2885. if (rinfo->save_framebuffer) {
  2886. vfree(rinfo->save_framebuffer);
  2887. rinfo->save_framebuffer = 0;
  2888. }
  2889. #endif
  2890. break;
  2891. case PBOOK_SLEEP_NOW:
  2892. radeon_engine_idle();
  2893. radeon_engine_reset();
  2894. radeon_engine_idle();
  2896. #if 0
  2897. /* Backup framebuffer content */
  2898. if (rinfo->save_framebuffer)
  2899. memcpy_fromio(rinfo->save_framebuffer,
  2900.       (void *)rinfo->fb_base,
  2901.       nb);
  2902. #endif
  2904. /* Blank display and LCD */
  2905. radeonfb_blank(VESA_POWERDOWN+1,
  2906.        (struct fb_info *)rinfo);
  2908. /* Sleep */
  2909. radeon_set_suspend(rinfo, 1);
  2911. break;
  2912. case PBOOK_WAKE:
  2913. /* Wakeup */
  2914. radeon_set_suspend(rinfo, 0);
  2916. radeon_engine_reset();
  2917. if (!noaccel) {
  2918. radeon_engine_init(rinfo);
  2919. radeon_engine_reset();
  2920. }
  2922. #if 0
  2923. /* Restore framebuffer content */
  2924. if (rinfo->save_framebuffer) {
  2925. memcpy_toio((void *)rinfo->fb_base,
  2926.     rinfo->save_framebuffer,
  2927.     nb);
  2928. vfree(rinfo->save_framebuffer);
  2929. rinfo->save_framebuffer = 0;
  2930. }
  2931. #endif
  2933. if (rinfo->currcon_display) {
  2934. radeonfb_set_var(&rinfo->currcon_display->var, rinfo->currcon,
  2935.  (struct fb_info *) rinfo);
  2936. radeon_set_dispsw(rinfo, rinfo->currcon_display);
  2937. do_install_cmap(rinfo->currcon,
  2938. (struct fb_info *)rinfo);
  2939. }
  2941. radeonfb_blank(0, (struct fb_info *)rinfo);
  2942. break;
  2943. }
  2944. }
  2946. return PBOOK_SLEEP_OK;
  2947. }
  2949. #endif /* CONFIG_PMAC_PBOOK */
  2951. /*
  2952.  * text console acceleration
  2953.  */
  2956. static void fbcon_radeon_bmove(struct display *p, int srcy, int srcx,
  2957.        int dsty, int dstx, int height, int width)
  2958. {
  2959. struct radeonfb_info *rinfo = (struct radeonfb_info *)(p->fb_info);
  2960. u32 dp_cntl = DST_LAST_PEL;
  2962. srcx *= fontwidth(p);
  2963. srcy *= fontheight(p);
  2964. dstx *= fontwidth(p);
  2965. dsty *= fontheight(p);
  2966. width *= fontwidth(p);
  2967. height *= fontheight(p);
  2969. if (srcy < dsty) {
  2970. srcy += height - 1;
  2971. dsty += height - 1;
  2972. } else
  2973. dp_cntl |= DST_Y_TOP_TO_BOTTOM;
  2975. if (srcx < dstx) {
  2976. srcx += width - 1;
  2977. dstx += width - 1;
  2978. } else
  2979. dp_cntl |= DST_X_LEFT_TO_RIGHT;
  2981. radeon_fifo_wait(6);
  2982. OUTREG(DP_GUI_MASTER_CNTL, (rinfo->dp_gui_master_cntl |
  2983.     GMC_BRUSH_NONE |
  2984.     GMC_SRC_DATATYPE_COLOR |
  2985.     ROP3_S |
  2986.     DP_SRC_SOURCE_MEMORY));
  2987. OUTREG(DP_WRITE_MSK, 0xffffffff);
  2988. OUTREG(DP_CNTL, dp_cntl);
  2989. OUTREG(SRC_Y_X, (srcy << 16) | srcx);
  2990. OUTREG(DST_Y_X, (dsty << 16) | dstx);
  2991. OUTREG(DST_HEIGHT_WIDTH, (height << 16) | width);
  2992. }
  2996. static void fbcon_radeon_clear(struct vc_data *conp, struct display *p,
  2997.        int srcy, int srcx, int height, int width)
  2998. {
  2999. struct radeonfb_info *rinfo = (struct radeonfb_info *)(p->fb_info);
  3000. u32 clr;
  3002. clr = attr_bgcol_ec(p, conp);
  3003. clr |= (clr << 8);
  3004. clr |= (clr << 16);
  3006. srcx *= fontwidth(p);
  3007. srcy *= fontheight(p);
  3008. width *= fontwidth(p);
  3009. height *= fontheight(p);
  3011. radeon_fifo_wait(6);
  3012. OUTREG(DP_GUI_MASTER_CNTL, (rinfo->dp_gui_master_cntl |
  3013.     GMC_BRUSH_SOLID_COLOR |
  3014.     GMC_SRC_DATATYPE_COLOR |
  3015.     ROP3_P));
  3016. OUTREG(DP_BRUSH_FRGD_CLR, clr);
  3017. OUTREG(DP_WRITE_MSK, 0xffffffff);
  3018. OUTREG(DP_CNTL, (DST_X_LEFT_TO_RIGHT | DST_Y_TOP_TO_BOTTOM));
  3019. OUTREG(DST_Y_X, (srcy << 16) | srcx);
  3020. OUTREG(DST_WIDTH_HEIGHT, (width << 16) | height);
  3021. }
  3025. #ifdef FBCON_HAS_CFB8
  3026. static struct display_switch fbcon_radeon8 = {
  3027. setup: fbcon_cfb8_setup,
  3028. bmove: fbcon_radeon_bmove,
  3029. clear: fbcon_radeon_clear,
  3030. putc: fbcon_cfb8_putc,
  3031. putcs: fbcon_cfb8_putcs,
  3032. revc: fbcon_cfb8_revc,
  3033. clear_margins: fbcon_cfb8_clear_margins,
  3034. fontwidthmask: FONTWIDTH(4)|FONTWIDTH(8)|FONTWIDTH(12)|FONTWIDTH(16)
  3035. };
  3036. #endif