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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
mach64_gx.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：21k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

mach64_gx.c：源码内容
  2. /*
  3.  *  ATI Mach64 GX Support
  4.  */
  6. #include <linux/delay.h>
  7. #include <linux/fb.h>
  8. #include <linux/sched.h>
  10. #include <asm/io.h>
  12. #include <video/fbcon.h>
  14. #include "mach64.h"
  15. #include "atyfb.h"
  17. /* Definitions for the ICS 2595 == ATI 18818_1 Clockchip */
  19. #define REF_FREQ_2595       1432  /*  14.33 MHz  (exact   14.31818) */
  20. #define REF_DIV_2595          46  /* really 43 on ICS 2595 !!!  */
  21.                                   /* ohne Prescaler */
  22. #define MAX_FREQ_2595      15938  /* 159.38 MHz  (really 170.486) */
  23. #define MIN_FREQ_2595       8000  /*  80.00 MHz  (        85.565) */
  24.                                   /* mit Prescaler 2, 4, 8 */
  25. #define ABS_MIN_FREQ_2595   1000  /*  10.00 MHz  (really  10.697) */
  26. #define N_ADJ_2595           257
  28. #define STOP_BITS_2595     0x1800
  31. #define MIN_N_408 2
  33. #define MIN_N_1703 6
  35. #define MIN_M 2
  36. #define MAX_M 30
  37. #define MIN_N 35
  38. #define MAX_N 255-8
  41.     /*
  42.      *  Support Functions
  43.      */
  45. static void aty_dac_waste4(const struct fb_info_aty *info)
  46. {
  47.   (void)aty_ld_8(DAC_REGS, info);
  49.   (void)aty_ld_8(DAC_REGS + 2, info);
  50.   (void)aty_ld_8(DAC_REGS + 2, info);
  51.   (void)aty_ld_8(DAC_REGS + 2, info);
  52.   (void)aty_ld_8(DAC_REGS + 2, info);
  53. }
  55. static void aty_StrobeClock(const struct fb_info_aty *info)
  56. {
  57.     u8 tmp;
  59.     udelay(26);
  61.     tmp = aty_ld_8(CLOCK_CNTL, info);
  62.     aty_st_8(CLOCK_CNTL + info->clk_wr_offset, tmp | CLOCK_STROBE, info);
  64.     return;
  65. }
  68.     /*
  69.      *  IBM RGB514 DAC and Clock Chip
  70.      */
  72. static void aty_st_514(int offset, u8 val, const struct fb_info_aty *info)
  73. {
  74.     aty_st_8(DAC_CNTL, 1, info);
  75.     /* right addr byte */
  76.     aty_st_8(DAC_W_INDEX, offset & 0xff, info);
  77.     /* left addr byte */
  78.     aty_st_8(DAC_DATA, (offset >> 8) & 0xff, info);
  79.     aty_st_8(DAC_MASK, val, info);
  80.     aty_st_8(DAC_CNTL, 0, info);
  81. }
  83. static int aty_set_dac_514(const struct fb_info_aty *info,
  84.    const union aty_pll *pll, u32 bpp, u32 accel)
  85. {
  86.     static struct {
  87. u8 pixel_dly;
  88. u8 misc2_cntl;
  89. u8 pixel_rep;
  90. u8 pixel_cntl_index;
  91. u8 pixel_cntl_v1;
  92.     } tab[3] = {
  93. { 0, 0x41, 0x03, 0x71, 0x45 }, /* 8 bpp */
  94. { 0, 0x45, 0x04, 0x0c, 0x01 }, /* 555 */
  95. { 0, 0x45, 0x06, 0x0e, 0x00 }, /* XRGB */
  96.     };
  97.     int i;
  99.     switch (bpp) {
  100. case 8:
  101. default:
  102.     i = 0;
  103.     break;
  104. case 16:
  105.     i = 1;
  106.     break;
  107. case 32:
  108.     i = 2;
  109.     break;
  110.     }
  111.     aty_st_514(0x90, 0x00, info); /* VRAM Mask Low */
  112.     aty_st_514(0x04, tab[i].pixel_dly, info); /* Horizontal Sync Control */
  113.     aty_st_514(0x05, 0x00, info); /* Power Management */
  114.     aty_st_514(0x02, 0x01, info); /* Misc Clock Control */
  115.     aty_st_514(0x71, tab[i].misc2_cntl, info); /* Misc Control 2 */
  116.     aty_st_514(0x0a, tab[i].pixel_rep, info); /* Pixel Format */
  117.     aty_st_514(tab[i].pixel_cntl_index, tab[i].pixel_cntl_v1, info);
  118. /* Misc Control 2 / 16 BPP Control / 32 BPP Control */
  119.     return 0;
  120. }
  122. static int aty_var_to_pll_514(const struct fb_info_aty *info, u32 vclk_per,
  123.       u8 bpp, union aty_pll *pll)
  124. {
  125.     /*
  126.      *  FIXME: use real calculations instead of using fixed values from the old
  127.      *        driver
  128.      */
  129.     static struct {
  130. u32 limit; /* pixlock rounding limit (arbitrary) */
  131. u8 m; /* (df<<6) | vco_div_count */
  132. u8 n; /* ref_div_count */
  133.     } RGB514_clocks[7] = {
  134. {  8000, (3<<6) | 20, 9 }, /*  7395 ps / 135.2273 MHz */
  135. { 10000, (1<<6) | 19, 3 }, /*  9977 ps / 100.2273 MHz */
  136. { 13000, (1<<6) |  2, 3 }, /* 12509 ps /  79.9432 MHz */
  137. { 14000, (2<<6) |  8, 7 }, /* 13394 ps /  74.6591 MHz */
  138. { 16000, (1<<6) | 44, 6 }, /* 15378 ps /  65.0284 MHz */
  139. { 25000, (1<<6) | 15, 5 }, /* 17460 ps /  57.2727 MHz */
  140. { 50000, (0<<6) | 53, 7 }, /* 33145 ps /  30.1705 MHz */
  141.     };
  142.     int i;
  144.     for (i = 0; i < sizeof(RGB514_clocks)/sizeof(*RGB514_clocks); i++)
  145. if (vclk_per <= RGB514_clocks[i].limit) {
  146.     pll->ibm514.m = RGB514_clocks[i].m;
  147.     pll->ibm514.n = RGB514_clocks[i].n;
  148.     return 0;
  149. }
  150.     return -EINVAL;
  151. }
  153. static u32 aty_pll_514_to_var(const struct fb_info_aty *info,
  154.                       const union aty_pll *pll)
  155. {
  156.     u8 df, vco_div_count, ref_div_count;
  158.     df = pll->ibm514.m >> 6;
  159.     vco_div_count = pll->ibm514.m & 0x3f;
  160.     ref_div_count = pll->ibm514.n;
  162.     return ((info->ref_clk_per*ref_div_count)<<(3-df))/(vco_div_count+65);
  163. }
  165. static void aty_set_pll_514(const struct fb_info_aty *info,
  166.     const union aty_pll *pll)
  167. {
  168.     aty_st_514(0x06, 0x02, info); /* DAC Operation */
  169.     aty_st_514(0x10, 0x01, info); /* PLL Control 1 */
  170.     aty_st_514(0x70, 0x01, info); /* Misc Control 1 */
  171.     aty_st_514(0x8f, 0x1f, info); /* PLL Ref. Divider Input */
  172.     aty_st_514(0x03, 0x00, info); /* Sync Control */
  173.     aty_st_514(0x05, 0x00, info); /* Power Management */
  174.     aty_st_514(0x20, pll->ibm514.m, info); /* F0 / M0 */
  175.     aty_st_514(0x21, pll->ibm514.n, info); /* F1 / N0 */
  176. }
  178. const struct aty_dac_ops aty_dac_ibm514 = {
  179.     set_dac: aty_set_dac_514,
  180. };
  182. const struct aty_pll_ops aty_pll_ibm514 = {
  183.     var_to_pll: aty_var_to_pll_514,
  184.     pll_to_var: aty_pll_514_to_var,
  185.     set_pll: aty_set_pll_514,
  186. };
  189.     /*
  190.      *  ATI 68860-B DAC
  191.      */
  193. static int aty_set_dac_ATI68860_B(const struct fb_info_aty *info,
  194.   const union aty_pll *pll, u32 bpp, u32 accel)
  195. {
  196.     u32 gModeReg, devSetupRegA, temp, mask;
  198.     gModeReg = 0;
  199.     devSetupRegA = 0;
  201.     switch (bpp) {
  202. case 8:
  203.     gModeReg = 0x83;
  204.     devSetupRegA = 0x60 | 0x00 /*(info->mach64DAC8Bit ? 0x00 : 0x01) */;
  205.     break;
  206. case 15:
  207.     gModeReg = 0xA0;
  208.     devSetupRegA = 0x60;
  209.     break;
  210. case 16:
  211.     gModeReg = 0xA1;
  212.     devSetupRegA = 0x60;
  213.     break;
  214. case 24:
  215.     gModeReg = 0xC0;
  216.     devSetupRegA = 0x60;
  217.     break;
  218. case 32:
  219.     gModeReg = 0xE3;
  220.     devSetupRegA = 0x60;
  221.     break;
  222.     }
  224.     if (!accel) {
  225. gModeReg = 0x80;
  226. devSetupRegA = 0x61;
  227.     }
  229.     temp = aty_ld_8(DAC_CNTL, info);
  230.     aty_st_8(DAC_CNTL, (temp & ~DAC_EXT_SEL_RS2) | DAC_EXT_SEL_RS3, info);
  232.     aty_st_8(DAC_REGS + 2, 0x1D, info);
  233.     aty_st_8(DAC_REGS + 3, gModeReg, info);
  234.     aty_st_8(DAC_REGS, 0x02, info);
  236.     temp = aty_ld_8(DAC_CNTL, info);
  237.     aty_st_8(DAC_CNTL, temp | DAC_EXT_SEL_RS2 | DAC_EXT_SEL_RS3, info);
  239.     if (info->total_vram < MEM_SIZE_1M)
  240. mask = 0x04;
  241.     else if (info->total_vram == MEM_SIZE_1M)
  242. mask = 0x08;
  243.     else
  244. mask = 0x0C;
  246.     /* The following assumes that the BIOS has correctly set R7 of the
  247.      * Device Setup Register A at boot time.
  248.      */
  249. #define A860_DELAY_L 0x80
  251.     temp = aty_ld_8(DAC_REGS, info);
  252.     aty_st_8(DAC_REGS, (devSetupRegA | mask) | (temp & A860_DELAY_L), info);
  253.     temp = aty_ld_8(DAC_CNTL, info);
  254.     aty_st_8(DAC_CNTL, (temp & ~(DAC_EXT_SEL_RS2 | DAC_EXT_SEL_RS3)), info);
  256.     aty_st_le32(BUS_CNTL, 0x890e20f1, info);
  257.     aty_st_le32(DAC_CNTL, 0x47052100, info);
  259.     return 0;
  260. }
  262. const struct aty_dac_ops aty_dac_ati68860b = {
  263.     set_dac: aty_set_dac_ATI68860_B,
  264. };
  267.     /*
  268.      *  AT&T 21C498 DAC
  269.      */
  271. static int aty_set_dac_ATT21C498(const struct fb_info_aty *info,
  272.  const union aty_pll *pll, u32 bpp, u32 accel)
  273. {
  274.     u32 dotClock;
  275.     int muxmode = 0;
  276.     int DACMask = 0;
  278.     dotClock = 100000000 / pll->ics2595.period_in_ps;
  280.     switch (bpp) {
  281. case 8:
  282.     if (dotClock > 8000) {
  283. DACMask = 0x24;
  284. muxmode = 1;
  285.     } else
  286. DACMask = 0x04;
  287.     break;
  288. case 15:
  289.     DACMask = 0x16;
  290.     break;
  291. case 16:
  292.     DACMask = 0x36;
  293.     break;
  294. case 24:
  295.     DACMask = 0xE6;
  296.     break;
  297. case 32:
  298.     DACMask = 0xE6;
  299.     break;
  300.     }
  302.     if (1 /* info->mach64DAC8Bit */)
  303. DACMask |= 0x02;
  305.     aty_dac_waste4(info);
  306.     aty_st_8(DAC_REGS + 2, DACMask, info);
  308.     aty_st_le32(BUS_CNTL, 0x890e20f1, info);
  309.     aty_st_le32(DAC_CNTL, 0x00072000, info);
  310.     return muxmode;
  311. }
  313. const struct aty_dac_ops aty_dac_att21c498 = {
  314.     set_dac: aty_set_dac_ATT21C498,
  315. };
  318.     /*
  319.      *  ATI 18818 / ICS 2595 Clock Chip
  320.      */
  322. static int aty_var_to_pll_18818(const struct fb_info_aty *info, u32 vclk_per,
  323. u8 bpp, union aty_pll *pll)
  324. {
  325.     u32 MHz100; /* in 0.01 MHz */
  326.     u32 program_bits;
  327.     u32 post_divider;
  329.     /* Calculate the programming word */
  330.     MHz100 = 100000000 / vclk_per;
  332.     program_bits = -1;
  333.     post_divider = 1;
  335.     if (MHz100 > MAX_FREQ_2595) {
  336. MHz100 = MAX_FREQ_2595;
  337. return -EINVAL;
  338.     } else if (MHz100 < ABS_MIN_FREQ_2595) {
  339. program_bits = 0; /* MHz100 = 257 */
  340. return -EINVAL;
  341.     } else {
  342. while (MHz100 < MIN_FREQ_2595) {
  343.     MHz100 *= 2;
  344.     post_divider *= 2;
  345. }
  346.     }
  347.     MHz100 *= 1000;
  348.     MHz100 = (REF_DIV_2595 * MHz100) / REF_FREQ_2595;
  350.     MHz100 += 500;    /* + 0.5 round */
  351.     MHz100 /= 1000;
  353.     if (program_bits == -1) {
  354. program_bits = MHz100 - N_ADJ_2595;
  355. switch (post_divider) {
  356.     case 1:
  357. program_bits |= 0x0600;
  358. break;
  359.     case 2:
  360. program_bits |= 0x0400;
  361. break;
  362.     case 4:
  363. program_bits |= 0x0200;
  364. break;
  365.     case 8:
  366.     default:
  367. break;
  368. }
  369.     }
  371.     program_bits |= STOP_BITS_2595;
  373.     pll->ics2595.program_bits = program_bits;
  374.     pll->ics2595.locationAddr = 0;
  375.     pll->ics2595.post_divider = post_divider;
  376.     pll->ics2595.period_in_ps = vclk_per;
  378.     return 0;
  379. }
  381. static u32 aty_pll_18818_to_var(const struct fb_info_aty *info,
  382. const union aty_pll *pll)
  383. {
  384.     return(pll->ics2595.period_in_ps);  /* default for now */
  385. }
  387. static void aty_ICS2595_put1bit(u8 data, const struct fb_info_aty *info)
  388. {
  389.     u8 tmp;
  391.     data &= 0x01;
  392.     tmp = aty_ld_8(CLOCK_CNTL, info);
  393.     aty_st_8(CLOCK_CNTL + info->clk_wr_offset, (tmp & ~0x04) | (data << 2),
  394.      info);
  396.     tmp = aty_ld_8(CLOCK_CNTL, info);
  397.     aty_st_8(CLOCK_CNTL + info->clk_wr_offset, (tmp & ~0x08) | (0 << 3), info);
  399.     aty_StrobeClock(info);
  401.     tmp = aty_ld_8(CLOCK_CNTL, info);
  402.     aty_st_8(CLOCK_CNTL + info->clk_wr_offset, (tmp & ~0x08) | (1 << 3), info);
  404.     aty_StrobeClock(info);
  406.     return;
  407. }
  409. static void aty_set_pll18818(const struct fb_info_aty *info,
  410.      const union aty_pll *pll)
  411. {
  412.     u32 program_bits;
  413.     u32 locationAddr;
  415.     u32 i;
  417.     u8 old_clock_cntl;
  418.     u8 old_crtc_ext_disp;
  420.     old_clock_cntl = aty_ld_8(CLOCK_CNTL, info);
  421.     aty_st_8(CLOCK_CNTL + info->clk_wr_offset, 0, info);
  423.     old_crtc_ext_disp = aty_ld_8(CRTC_GEN_CNTL + 3, info);
  424.     aty_st_8(CRTC_GEN_CNTL + 3, old_crtc_ext_disp | (CRTC_EXT_DISP_EN >> 24),
  425.      info);
  427.     mdelay(15); /* delay for 50 (15) ms */
  429.     program_bits = pll->ics2595.program_bits;
  430.     locationAddr = pll->ics2595.locationAddr;
  432.     /* Program the clock chip */
  433.     aty_st_8(CLOCK_CNTL + info->clk_wr_offset, 0, info);  /* Strobe = 0 */
  434.     aty_StrobeClock(info);
  435.     aty_st_8(CLOCK_CNTL + info->clk_wr_offset, 1, info);  /* Strobe = 0 */
  436.     aty_StrobeClock(info);
  438.     aty_ICS2595_put1bit(1, info);    /* Send start bits */
  439.     aty_ICS2595_put1bit(0, info);    /* Start bit */
  440.     aty_ICS2595_put1bit(0, info);    /* Read / ~Write */
  442.     for (i = 0; i < 5; i++) { /* Location 0..4 */
  443. aty_ICS2595_put1bit(locationAddr & 1, info);
  444. locationAddr >>= 1;
  445.     }
  447.     for (i = 0; i < 8 + 1 + 2 + 2; i++) {
  448. aty_ICS2595_put1bit(program_bits & 1, info);
  449. program_bits >>= 1;
  450.     }
  452.     mdelay(1); /* delay for 1 ms */
  454.     (void)aty_ld_8(DAC_REGS, info); /* Clear DAC Counter */
  455.     aty_st_8(CRTC_GEN_CNTL + 3, old_crtc_ext_disp, info);
  456.     aty_st_8(CLOCK_CNTL + info->clk_wr_offset, old_clock_cntl | CLOCK_STROBE,
  457.      info);
  459.     mdelay(50); /* delay for 50 (15) ms */
  460.     aty_st_8(CLOCK_CNTL + info->clk_wr_offset,
  461.      ((pll->ics2595.locationAddr & 0x0F) | CLOCK_STROBE), info);
  463.     return;
  464. }
  466. const struct aty_pll_ops aty_pll_ati18818_1 = {
  467.     var_to_pll: aty_var_to_pll_18818,
  468.     pll_to_var: aty_pll_18818_to_var,
  469.     set_pll: aty_set_pll18818,
  470. };
  473.     /*
  474.      *  STG 1703 Clock Chip
  475.      */
  477. static int aty_var_to_pll_1703(const struct fb_info_aty *info, u32 vclk_per,
  478.        u8 bpp, union aty_pll *pll)
  479. {
  480.     u32 mhz100; /* in 0.01 MHz */
  481.     u32 program_bits;
  482.     /* u32 post_divider; */
  483.     u32 mach64MinFreq, mach64MaxFreq, mach64RefFreq;
  484.     u32 temp, tempB;
  485.     u16 remainder, preRemainder;
  486.     short divider = 0, tempA;
  488.     /* Calculate the programming word */
  489.     mhz100 = 100000000 / vclk_per;
  490.     mach64MinFreq = MIN_FREQ_2595;
  491.     mach64MaxFreq = MAX_FREQ_2595;
  492.     mach64RefFreq = REF_FREQ_2595; /* 14.32 MHz */
  494.     /* Calculate program word */
  495.     if (mhz100 == 0)
  496. program_bits = 0xE0;
  497.     else {
  498. if (mhz100 < mach64MinFreq)
  499.     mhz100 = mach64MinFreq;
  500. if (mhz100 > mach64MaxFreq)
  501.     mhz100 = mach64MaxFreq;
  503. divider = 0;
  504. while (mhz100 < (mach64MinFreq << 3)) {
  505.     mhz100 <<= 1;
  506.     divider += 0x20;
  507. }
  509. temp = (unsigned int)(mhz100);
  510. temp = (unsigned int)(temp * (MIN_N_1703 + 2));
  511. temp -= (short)(mach64RefFreq << 1);
  513. tempA = MIN_N_1703;
  514. preRemainder = 0xffff;
  516. do {
  517.     tempB = temp;
  518.     remainder = tempB % mach64RefFreq;
  519.     tempB = tempB / mach64RefFreq;
  521.     if ((tempB & 0xffff) <= 127 && (remainder <= preRemainder)) {
  522. preRemainder = remainder;
  523. divider &= ~0x1f;
  524. divider |= tempA;
  525. divider = (divider & 0x00ff) + ((tempB & 0xff) << 8);
  526.     }
  528.     temp += mhz100;
  529.     tempA++;
  530. } while (tempA <= (MIN_N_1703 << 1));
  532. program_bits = divider;
  533.     }
  535.       pll->ics2595.program_bits = program_bits;
  536.       pll->ics2595.locationAddr = 0;
  537.       pll->ics2595.post_divider = divider;  /* fuer nix */
  538.       pll->ics2595.period_in_ps = vclk_per;
  540.       return 0;
  541. }
  543. static u32 aty_pll_1703_to_var(const struct fb_info_aty *info,
  544.        const union aty_pll *pll)
  545. {
  546.     return(pll->ics2595.period_in_ps);  /* default for now */
  547. }
  549. static void aty_set_pll_1703(const struct fb_info_aty *info,
  550.      const union aty_pll *pll)
  551. {
  552.     u32 program_bits;
  553.     u32 locationAddr;
  555.     char old_crtc_ext_disp;
  557.     old_crtc_ext_disp = aty_ld_8(CRTC_GEN_CNTL + 3, info);
  558.     aty_st_8(CRTC_GEN_CNTL + 3, old_crtc_ext_disp | (CRTC_EXT_DISP_EN >> 24),
  559.      info);
  561.     program_bits = pll->ics2595.program_bits;
  562.     locationAddr = pll->ics2595.locationAddr;
  564.     /* Program clock */
  565.     aty_dac_waste4(info);
  567.     (void)aty_ld_8(DAC_REGS + 2, info);
  568.     aty_st_8(DAC_REGS+2, (locationAddr << 1) + 0x20, info);
  569.     aty_st_8(DAC_REGS+2, 0, info);
  570.     aty_st_8(DAC_REGS+2, (program_bits & 0xFF00) >> 8, info);
  571.     aty_st_8(DAC_REGS+2, (program_bits & 0xFF), info);
  573.     (void)aty_ld_8(DAC_REGS, info); /* Clear DAC Counter */
  574.     aty_st_8(CRTC_GEN_CNTL + 3, old_crtc_ext_disp, info);
  576.     return;
  577. }
  579. const struct aty_pll_ops aty_pll_stg1703 = {
  580.     var_to_pll: aty_var_to_pll_1703,
  581.     pll_to_var: aty_pll_1703_to_var,
  582.     set_pll: aty_set_pll_1703,
  583. };
  586.     /*
  587.      *  Chrontel 8398 Clock Chip
  588.      */
  590. static int aty_var_to_pll_8398(const struct fb_info_aty *info, u32 vclk_per,
  591.        u8 bpp, union aty_pll *pll)
  592. {
  593.     u32 tempA, tempB, fOut, longMHz100, diff, preDiff;
  595.     u32 mhz100; /* in 0.01 MHz */
  596.     u32 program_bits;
  597.     /* u32 post_divider; */
  598.     u32 mach64MinFreq, mach64MaxFreq, mach64RefFreq;
  599.     u16 m, n, k=0, save_m, save_n, twoToKth;
  601.     /* Calculate the programming word */
  602.     mhz100 = 100000000 / vclk_per;
  603.     mach64MinFreq = MIN_FREQ_2595;
  604.     mach64MaxFreq = MAX_FREQ_2595;
  605.     mach64RefFreq = REF_FREQ_2595; /* 14.32 MHz */
  607.     save_m = 0;
  608.     save_n = 0;
  610.     /* Calculate program word */
  611.     if (mhz100 == 0)
  612. program_bits = 0xE0;
  613.     else
  614.     {
  615. if (mhz100 < mach64MinFreq)
  616.     mhz100 = mach64MinFreq;
  617. if (mhz100 > mach64MaxFreq)
  618.     mhz100 = mach64MaxFreq;
  620. longMHz100 = mhz100 * 256 / 100;   /* 8 bit scale this */
  622. while (mhz100 < (mach64MinFreq << 3))
  623.         {
  624.     mhz100 <<= 1;
  625.     k++;
  626. }
  628. twoToKth = 1 << k;
  629. diff = 0;
  630. preDiff = 0xFFFFFFFF;
  632. for (m = MIN_M; m <= MAX_M; m++)
  633.         {
  634.     for (n = MIN_N; n <= MAX_N; n++)
  635.             {
  636. tempA = (14.31818 * 65536);
  637. tempA *= (n + 8);  /* 43..256 */
  638. tempB = twoToKth * 256;
  639. tempB *= (m + 2);  /* 4..32 */
  640. fOut = tempA / tempB;  /* 8 bit scale */
  642. if (longMHz100 > fOut)
  643.     diff = longMHz100 - fOut;
  644. else
  645.     diff = fOut - longMHz100;
  647. if (diff < preDiff)
  648.                 {
  649.     save_m = m;
  650.     save_n = n;
  651.     preDiff = diff;
  652. }
  653.     }
  654. }
  656. program_bits = (k << 6) + (save_m) + (save_n << 8);
  657.     }
  659.     pll->ics2595.program_bits = program_bits;
  660.     pll->ics2595.locationAddr = 0;
  661.     pll->ics2595.post_divider = 0;
  662.     pll->ics2595.period_in_ps = vclk_per;
  664.     return 0;
  665. }
  667. static u32 aty_pll_8398_to_var(const struct fb_info_aty *info,
  668.        const union aty_pll *pll)
  669. {
  670.     return(pll->ics2595.period_in_ps);  /* default for now */
  671. }
  673. static void aty_set_pll_8398(const struct fb_info_aty *info,
  674.      const union aty_pll *pll)
  675. {
  676.     u32 program_bits;
  677.     u32 locationAddr;
  679.     char old_crtc_ext_disp;
  680.     char tmp;
  682.     old_crtc_ext_disp = aty_ld_8(CRTC_GEN_CNTL + 3, info);
  683.     aty_st_8(CRTC_GEN_CNTL + 3, old_crtc_ext_disp | (CRTC_EXT_DISP_EN >> 24),
  684.      info);
  686.     program_bits = pll->ics2595.program_bits;
  687.     locationAddr = pll->ics2595.locationAddr;
  689.     /* Program clock */
  690.     tmp = aty_ld_8(DAC_CNTL, info);
  691.     aty_st_8(DAC_CNTL, tmp | DAC_EXT_SEL_RS2 | DAC_EXT_SEL_RS3, info);
  693.     aty_st_8(DAC_REGS, locationAddr, info);
  694.     aty_st_8(DAC_REGS+1, (program_bits & 0xff00) >> 8, info);
  695.     aty_st_8(DAC_REGS+1, (program_bits & 0xff), info);
  697.     tmp = aty_ld_8(DAC_CNTL, info);
  698.     aty_st_8(DAC_CNTL, (tmp & ~DAC_EXT_SEL_RS2) | DAC_EXT_SEL_RS3, info);
  700.     (void)aty_ld_8(DAC_REGS, info); /* Clear DAC Counter */
  701.     aty_st_8(CRTC_GEN_CNTL + 3, old_crtc_ext_disp, info);
  703.     return;
  704. }
  706. const struct aty_pll_ops aty_pll_ch8398 = {
  707.     var_to_pll: aty_var_to_pll_8398,
  708.     pll_to_var: aty_pll_8398_to_var,
  709.     set_pll: aty_set_pll_8398,
  710. };
  713.     /*
  714.      *  AT&T 20C408 Clock Chip
  715.      */
  717. static int aty_var_to_pll_408(const struct fb_info_aty *info, u32 vclk_per,
  718.       u8 bpp, union aty_pll *pll)
  719. {
  720.     u32 mhz100; /* in 0.01 MHz */
  721.     u32 program_bits;
  722.     /* u32 post_divider; */
  723.     u32 mach64MinFreq, mach64MaxFreq, mach64RefFreq;
  724.     u32 temp, tempB;
  725.     u16 remainder, preRemainder;
  726.     short divider = 0, tempA;
  728.     /* Calculate the programming word */
  729.     mhz100 = 100000000 / vclk_per;
  730.     mach64MinFreq = MIN_FREQ_2595;
  731.     mach64MaxFreq = MAX_FREQ_2595;
  732.     mach64RefFreq = REF_FREQ_2595; /* 14.32 MHz */
  734.     /* Calculate program word */
  735.     if (mhz100 == 0)
  736. program_bits = 0xFF;
  737.     else {
  738. if (mhz100 < mach64MinFreq)
  739.     mhz100 = mach64MinFreq;
  740. if (mhz100 > mach64MaxFreq)
  741.     mhz100 = mach64MaxFreq;
  743. while (mhz100 < (mach64MinFreq << 3)) {
  744.     mhz100 <<= 1;
  745.     divider += 0x40;
  746. }
  748. temp = (unsigned int)mhz100;
  749. temp = (unsigned int)(temp * (MIN_N_408 + 2));
  750. temp -= ((short)(mach64RefFreq << 1));
  752. tempA = MIN_N_408;
  753. preRemainder = 0xFFFF;
  755. do {
  756.     tempB = temp;
  757.     remainder = tempB % mach64RefFreq;
  758.     tempB = tempB / mach64RefFreq;
  759.     if (((tempB & 0xFFFF) <= 255) && (remainder <= preRemainder)) {
  760. preRemainder = remainder;
  761. divider &= ~0x3f;
  762. divider |= tempA;
  763. divider = (divider & 0x00FF) + ((tempB & 0xFF) << 8);
  764.     }
  765.     temp += mhz100;
  766.     tempA++;
  767. } while(tempA <= 32);
  769. program_bits = divider;
  770.     }
  772.     pll->ics2595.program_bits = program_bits;
  773.     pll->ics2595.locationAddr = 0;
  774.     pll->ics2595.post_divider = divider; /* fuer nix */
  775.     pll->ics2595.period_in_ps = vclk_per;
  777.     return 0;
  778. }
  780. static u32 aty_pll_408_to_var(const struct fb_info_aty *info,
  781.       const union aty_pll *pll)
  782. {
  783.     return(pll->ics2595.period_in_ps);  /* default for now */
  784. }
  786. static void aty_set_pll_408(const struct fb_info_aty *info,
  787.     const union aty_pll *pll)
  788. {
  789.     u32 program_bits;
  790.     u32 locationAddr;
  792.     u8 tmpA, tmpB, tmpC;
  793.     char old_crtc_ext_disp;
  795.     old_crtc_ext_disp = aty_ld_8(CRTC_GEN_CNTL + 3, info);
  796.     aty_st_8(CRTC_GEN_CNTL + 3, old_crtc_ext_disp | (CRTC_EXT_DISP_EN >> 24),
  797.      info);
  799.     program_bits = pll->ics2595.program_bits;
  800.     locationAddr = pll->ics2595.locationAddr;
  802.     /* Program clock */
  803.     aty_dac_waste4(info);
  804.     tmpB = aty_ld_8(DAC_REGS + 2, info) | 1;
  805.     aty_dac_waste4(info);
  806.     aty_st_8(DAC_REGS + 2, tmpB, info);
  808.     tmpA = tmpB;
  809.     tmpC = tmpA;
  810.     tmpA |= 8;
  811.     tmpB = 1;
  813.     aty_st_8(DAC_REGS, tmpB, info);
  814.     aty_st_8(DAC_REGS + 2, tmpA, info);
  816.     udelay(400); /* delay for 400 us */
  818.     locationAddr = (locationAddr << 2) + 0x40;
  819.     tmpB = locationAddr;
  820.     tmpA = program_bits >> 8;
  822.     aty_st_8(DAC_REGS, tmpB, info);
  823.     aty_st_8(DAC_REGS + 2, tmpA, info);
  825.     tmpB = locationAddr + 1;
  826.     tmpA = (u8)program_bits;
  828.     aty_st_8(DAC_REGS, tmpB, info);
  829.     aty_st_8(DAC_REGS + 2, tmpA, info);
  831.     tmpB = locationAddr + 2;
  832.     tmpA = 0x77;
  834.     aty_st_8(DAC_REGS, tmpB, info);
  835.     aty_st_8(DAC_REGS + 2, tmpA, info);
  837.     udelay(400); /* delay for 400 us */
  838.     tmpA = tmpC & (~(1 | 8));
  839.     tmpB = 1;
  841.     aty_st_8(DAC_REGS, tmpB, info);
  842.     aty_st_8(DAC_REGS + 2, tmpA, info);
  844.     (void)aty_ld_8(DAC_REGS, info); /* Clear DAC Counter */
  845.     aty_st_8(CRTC_GEN_CNTL + 3, old_crtc_ext_disp, info);
  847.     return;
  848. }
  850. const struct aty_pll_ops aty_pll_att20c408 = {
  851.     var_to_pll: aty_var_to_pll_408,
  852.     pll_to_var: aty_pll_408_to_var,
  853.     set_pll: aty_set_pll_408,
  854. };
  857.     /*
  858.      *  Unsupported DAC and Clock Chip
  859.      */
  861. static int aty_set_dac_unsupported(const struct fb_info_aty *info,
  862.    const union aty_pll *pll, u32 bpp,
  863.    u32 accel)
  864. {
  865.     aty_st_le32(BUS_CNTL, 0x890e20f1, info);
  866.     aty_st_le32(DAC_CNTL, 0x47052100, info);
  867.     /* new in 2.2.3p1 from Geert. ???????? */
  868.     aty_st_le32(BUS_CNTL, 0x590e10ff, info);
  869.     aty_st_le32(DAC_CNTL, 0x47012100, info);
  870.     return 0;
  871. }
  873. static int dummy(void)
  874. {
  875.     return 0;
  876. }
  878. const struct aty_dac_ops aty_dac_unsupported = {
  879.     set_dac: aty_set_dac_unsupported,
  880. };
  882. const struct aty_pll_ops aty_pll_unsupported = {
  883.     var_to_pll: (void *)dummy,
  884.     pll_to_var: (void *)dummy,
  885.     set_pll: (void *)dummy,
  886. };