intelfb: align with changes from my X driver.

This just realigns the PLL calculation routines with the ones from my X.org
driver.

Signed-off-by: Dave Airlie <airlied@linux.ie>

diff --git a/drivers/video/intelfb/intelfbhw.c b/drivers/video/intelfb/intelfbhw.c
index 82a2b9048df9941356610677707cb172a2e89395..5a621df5bf0224bdfb96da65f53178e6a02e9e33 100644 (file)
--- a/drivers/video/intelfb/intelfbhw.c
+++ b/drivers/video/intelfb/intelfbhw.c
@@ -600,23 +600,19 @@ static int calc_vclock3(int index, int m, int n, int p)
 
 static int calc_vclock(int index, int m1, int m2, int n, int p1, int p2, int lvds)
 {
-       int p2_val;
-       switch(index)
-       {
-       case PLLS_I9xx:
-               if (p1 == 0)
-                       return 0;
-               if (lvds)
-                       p2_val = p2 ? 7 : 14;
-               else
-                       p2_val = p2 ? 5 : 10;
-               return ((plls[index].ref_clk * (5 * (m1 + 2) + (m2 + 2)) / (n + 2) /
-                        ((p1)) * (p2_val)));
-       case PLLS_I8xx:
-       default:
-               return ((plls[index].ref_clk * (5 * (m1 + 2) + (m2 + 2)) / (n + 2) /
-                        ((p1+2) * (1 << (p2 + 1)))));
+       struct pll_min_max *pll = &plls[index];
+       u32 m, vco, p;
+
+       m = (5 * (m1 + 2)) + (m2 + 2);
+       n += 2;
+       vco = pll->ref_clk * m / n;
+
+       if (index == PLLS_I8xx) {
+               p = ((p1 + 2) * (1 << (p2 + 1)));
+       } else {
+               p = ((p1) * (p2 ? 5 : 10));
        }
+       return vco / p;
 }
 
 void
@@ -852,9 +848,11 @@ splitm(int index, unsigned int m, unsigned int *retm1, unsigned int *retm2)
 {
        int m1, m2;
        int testm;
+       struct pll_min_max *pll = &plls[index];
+
        /* no point optimising too much - brute force m */
-       for (m1 = plls[index].min_m1; m1 < plls[index].max_m1+1; m1++) {
-               for (m2 = plls[index].min_m2; m2 < plls[index].max_m2+1; m2++) {
+       for (m1 = pll->min_m1; m1 < pll->max_m1 + 1; m1++) {
+               for (m2 = pll->min_m2; m2 < pll->max_m2 + 1; m2++) {
                        testm = (5 * (m1 + 2)) + (m2 + 2);
                        if (testm == m) {
                                *retm1 = (unsigned int)m1;
@@ -871,6 +869,7 @@ static int
 splitp(int index, unsigned int p, unsigned int *retp1, unsigned int *retp2)
 {
        int p1, p2;
+       struct pll_min_max *pll = &plls[index];
 
        if (index == PLLS_I9xx) {
                p2 = (p % 10) ? 1 : 0;
@@ -882,27 +881,23 @@ splitp(int index, unsigned int p, unsigned int *retp1, unsigned int *retp2)
                return 0;
        }
 
-       if (index == PLLS_I8xx) {
-               if (p % 4 == 0)
-                       p2 = 1;
-               else
-                       p2 = 0;
+       if (p % 4 == 0)
+               p2 = 1;
+       else
+               p2 = 0;
+       p1 = (p / (1 << (p2 + 1))) - 2;
+       if (p % 4 == 0 && p1 < pll->min_p1) {
+               p2 = 0;
                p1 = (p / (1 << (p2 + 1))) - 2;
-               if (p % 4 == 0 && p1 < plls[index].min_p1) {
-                       p2 = 0;
-                       p1 = (p / (1 << (p2 + 1))) - 2;
-               }
-               if (p1 < plls[index].min_p1 ||
-                   p1 > plls[index].max_p1 ||
-                   (p1 + 2) * (1 << (p2 + 1)) != p) {
-                       return 1;
-               } else {
-                       *retp1 = (unsigned int)p1;
-                       *retp2 = (unsigned int)p2;
-                       return 0;
-               }
        }
-       return 1;
+       if (p1 < pll->min_p1 || p1 > pll->max_p1 ||
+           (p1 + 2) * (1 << (p2 + 1)) != p) {
+               return 1;
+       } else {
+               *retp1 = (unsigned int)p1;
+               *retp2 = (unsigned int)p2;
+               return 0;
+       }
 }
 
 static int
@@ -952,7 +947,7 @@ calc_pll_params(int index, int clock, u32 *retm1, u32 *retm2, u32 *retn, u32 *re
                                m = pll->max_m - 1;
                        for (testm = m - 1; testm <= m; testm++) {
                                f_out = calc_vclock3(index, m, n, p);
-                               if (splitm(index, m, &m1, &m2)) {
+                               if (splitm(index, testm, &m1, &m2)) {
                                        WRN_MSG("cannot split m = %d\n", m);
                                        n++;
                                        continue;
@@ -963,7 +958,7 @@ calc_pll_params(int index, int clock, u32 *retm1, u32 *retm2, u32 *retn, u32 *re
                                        f_err = f_out - clock + 1;
 
                                if (f_err < err_best) {
-                                       m_best = m;
+                                       m_best = testm;
                                        n_best = n;
                                        p_best = p;
                                        f_best = f_out;