Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/holtmann/bluet...
[linux-2.6] / drivers / video / matrox / g450_pll.c
1 /*
2  *
3  * Hardware accelerated Matrox PCI cards - G450/G550 PLL control.
4  *
5  * (c) 2001-2002 Petr Vandrovec <vandrove@vc.cvut.cz>
6  *
7  * Portions Copyright (c) 2001 Matrox Graphics Inc.
8  *
9  * Version: 1.64 2002/06/10
10  *
11  * This file is subject to the terms and conditions of the GNU General Public
12  * License. See the file COPYING in the main directory of this archive for
13  * more details.
14  *
15  */
16
17 #include "g450_pll.h"
18 #include "matroxfb_DAC1064.h"
19
20 static inline unsigned int g450_vco2f(unsigned char p, unsigned int fvco) {
21         return (p & 0x40) ? fvco : fvco >> ((p & 3) + 1);
22 }
23
24 static inline unsigned int g450_f2vco(unsigned char p, unsigned int fin) {
25         return (p & 0x40) ? fin : fin << ((p & 3) + 1);
26 }
27
28 static unsigned int g450_mnp2vco(CPMINFO unsigned int mnp) {
29         unsigned int m, n;
30
31         m = ((mnp >> 16) & 0x0FF) + 1;
32         n = ((mnp >>  7) & 0x1FE) + 4;
33         return (ACCESS_FBINFO(features).pll.ref_freq * n + (m >> 1)) / m;
34 }
35
36 unsigned int g450_mnp2f(CPMINFO unsigned int mnp) {
37         return g450_vco2f(mnp, g450_mnp2vco(PMINFO mnp));
38 }
39
40 static inline unsigned int pll_freq_delta(unsigned int f1, unsigned int f2) {
41         if (f2 < f1) {
42                 f2 = f1 - f2;
43         } else {
44                 f2 = f2 - f1;
45         }
46         return f2;
47 }
48
49 #define NO_MORE_MNP     0x01FFFFFF
50 #define G450_MNP_FREQBITS       (0xFFFFFF43)    /* do not mask high byte so we'll catch NO_MORE_MNP */
51
52 static unsigned int g450_nextpll(CPMINFO const struct matrox_pll_limits* pi, unsigned int* fvco, unsigned int mnp) {
53         unsigned int m, n, p;
54         unsigned int tvco = *fvco;
55
56         m = (mnp >> 16) & 0xFF;
57         p = mnp & 0xFF;
58
59         do {
60                 if (m == 0 || m == 0xFF) {
61                         if (m == 0) {
62                                 if (p & 0x40) {
63                                         return NO_MORE_MNP;
64                                 }
65                                 if (p & 3) {
66                                         p--;
67                                 } else {
68                                         p = 0x40;
69                                 }
70                                 tvco >>= 1;
71                                 if (tvco < pi->vcomin) {
72                                         return NO_MORE_MNP;
73                                 }
74                                 *fvco = tvco;
75                         }
76
77                         p &= 0x43;
78                         if (tvco < 550000) {
79 /*                              p |= 0x00; */
80                         } else if (tvco < 700000) {
81                                 p |= 0x08;
82                         } else if (tvco < 1000000) {
83                                 p |= 0x10;
84                         } else if (tvco < 1150000) {
85                                 p |= 0x18;
86                         } else {
87                                 p |= 0x20;
88                         }
89                         m = 9;
90                 } else {
91                         m--;
92                 }
93                 n = ((tvco * (m+1) + ACCESS_FBINFO(features).pll.ref_freq) / (ACCESS_FBINFO(features).pll.ref_freq * 2)) - 2;
94         } while (n < 0x03 || n > 0x7A);
95         return (m << 16) | (n << 8) | p;
96 }
97
98 static unsigned int g450_firstpll(CPMINFO const struct matrox_pll_limits* pi, unsigned int* vco, unsigned int fout) {
99         unsigned int p;
100         unsigned int vcomax;
101
102         vcomax = pi->vcomax;
103         if (fout > (vcomax / 2)) {
104                 if (fout > vcomax) {
105                         *vco = vcomax;
106                 } else {
107                         *vco = fout;
108                 }
109                 p = 0x40;
110         } else {
111                 unsigned int tvco;
112
113                 p = 3;
114                 tvco = g450_f2vco(p, fout);
115                 while (p && (tvco > vcomax)) {
116                         p--;
117                         tvco >>= 1;
118                 }
119                 if (tvco < pi->vcomin) {
120                         tvco = pi->vcomin;
121                 }
122                 *vco = tvco;
123         }
124         return g450_nextpll(PMINFO pi, vco, 0xFF0000 | p);
125 }
126
127 static inline unsigned int g450_setpll(CPMINFO unsigned int mnp, unsigned int pll) {
128         switch (pll) {
129                 case M_PIXEL_PLL_A:
130                         matroxfb_DAC_out(PMINFO M1064_XPIXPLLAM, mnp >> 16);
131                         matroxfb_DAC_out(PMINFO M1064_XPIXPLLAN, mnp >> 8);
132                         matroxfb_DAC_out(PMINFO M1064_XPIXPLLAP, mnp);
133                         return M1064_XPIXPLLSTAT;
134
135                 case M_PIXEL_PLL_B:
136                         matroxfb_DAC_out(PMINFO M1064_XPIXPLLBM, mnp >> 16);
137                         matroxfb_DAC_out(PMINFO M1064_XPIXPLLBN, mnp >> 8);
138                         matroxfb_DAC_out(PMINFO M1064_XPIXPLLBP, mnp);
139                         return M1064_XPIXPLLSTAT;
140
141                 case M_PIXEL_PLL_C:
142                         matroxfb_DAC_out(PMINFO M1064_XPIXPLLCM, mnp >> 16);
143                         matroxfb_DAC_out(PMINFO M1064_XPIXPLLCN, mnp >> 8);
144                         matroxfb_DAC_out(PMINFO M1064_XPIXPLLCP, mnp);
145                         return M1064_XPIXPLLSTAT;
146
147                 case M_SYSTEM_PLL:
148                         matroxfb_DAC_out(PMINFO DAC1064_XSYSPLLM, mnp >> 16);
149                         matroxfb_DAC_out(PMINFO DAC1064_XSYSPLLN, mnp >> 8);
150                         matroxfb_DAC_out(PMINFO DAC1064_XSYSPLLP, mnp);
151                         return DAC1064_XSYSPLLSTAT;
152
153                 case M_VIDEO_PLL:
154                         matroxfb_DAC_out(PMINFO M1064_XVIDPLLM, mnp >> 16);
155                         matroxfb_DAC_out(PMINFO M1064_XVIDPLLN, mnp >> 8);
156                         matroxfb_DAC_out(PMINFO M1064_XVIDPLLP, mnp);
157                         return M1064_XVIDPLLSTAT;
158         }
159         return 0;
160 }
161
162 static inline unsigned int g450_cmppll(CPMINFO unsigned int mnp, unsigned int pll) {
163         unsigned char m = mnp >> 16;
164         unsigned char n = mnp >> 8;
165         unsigned char p = mnp;
166
167         switch (pll) {
168                 case M_PIXEL_PLL_A:
169                         return (matroxfb_DAC_in(PMINFO M1064_XPIXPLLAM) != m ||
170                                 matroxfb_DAC_in(PMINFO M1064_XPIXPLLAN) != n ||
171                                 matroxfb_DAC_in(PMINFO M1064_XPIXPLLAP) != p);
172
173                 case M_PIXEL_PLL_B:
174                         return (matroxfb_DAC_in(PMINFO M1064_XPIXPLLBM) != m ||
175                                 matroxfb_DAC_in(PMINFO M1064_XPIXPLLBN) != n ||
176                                 matroxfb_DAC_in(PMINFO M1064_XPIXPLLBP) != p);
177
178                 case M_PIXEL_PLL_C:
179                         return (matroxfb_DAC_in(PMINFO M1064_XPIXPLLCM) != m ||
180                                 matroxfb_DAC_in(PMINFO M1064_XPIXPLLCN) != n ||
181                                 matroxfb_DAC_in(PMINFO M1064_XPIXPLLCP) != p);
182
183                 case M_SYSTEM_PLL:
184                         return (matroxfb_DAC_in(PMINFO DAC1064_XSYSPLLM) != m ||
185                                 matroxfb_DAC_in(PMINFO DAC1064_XSYSPLLN) != n ||
186                                 matroxfb_DAC_in(PMINFO DAC1064_XSYSPLLP) != p);
187
188                 case M_VIDEO_PLL:
189                         return (matroxfb_DAC_in(PMINFO M1064_XVIDPLLM) != m ||
190                                 matroxfb_DAC_in(PMINFO M1064_XVIDPLLN) != n ||
191                                 matroxfb_DAC_in(PMINFO M1064_XVIDPLLP) != p);
192         }
193         return 1;
194 }
195
196 static inline int g450_isplllocked(CPMINFO unsigned int regidx) {
197         unsigned int j;
198
199         for (j = 0; j < 1000; j++) {
200                 if (matroxfb_DAC_in(PMINFO regidx) & 0x40) {
201                         unsigned int r = 0;
202                         int i;
203
204                         for (i = 0; i < 100; i++) {
205                                 r += matroxfb_DAC_in(PMINFO regidx) & 0x40;
206                         }
207                         return r >= (90 * 0x40);
208                 }
209                 /* udelay(1)... but DAC_in is much slower... */
210         }
211         return 0;
212 }
213
214 static int g450_testpll(CPMINFO unsigned int mnp, unsigned int pll) {
215         return g450_isplllocked(PMINFO g450_setpll(PMINFO mnp, pll));
216 }
217
218 static void updatehwstate_clk(struct matrox_hw_state* hw, unsigned int mnp, unsigned int pll) {
219         switch (pll) {
220                 case M_SYSTEM_PLL:
221                         hw->DACclk[3] = mnp >> 16;
222                         hw->DACclk[4] = mnp >> 8;
223                         hw->DACclk[5] = mnp;
224                         break;
225         }
226 }
227
228 void matroxfb_g450_setpll_cond(WPMINFO unsigned int mnp, unsigned int pll) {
229         if (g450_cmppll(PMINFO mnp, pll)) {
230                 g450_setpll(PMINFO mnp, pll);
231         }
232 }
233
234 static inline unsigned int g450_findworkingpll(WPMINFO unsigned int pll, unsigned int* mnparray, unsigned int mnpcount) {
235         unsigned int found = 0;
236         unsigned int idx;
237         unsigned int mnpfound = mnparray[0];
238                 
239         for (idx = 0; idx < mnpcount; idx++) {
240                 unsigned int sarray[3];
241                 unsigned int *sptr;
242                 {
243                         unsigned int mnp;
244                 
245                         sptr = sarray;
246                         mnp = mnparray[idx];
247                         if (mnp & 0x38) {
248                                 *sptr++ = mnp - 8;
249                         }
250                         if ((mnp & 0x38) != 0x38) {
251                                 *sptr++ = mnp + 8;
252                         }
253                         *sptr = mnp;
254                 }
255                 while (sptr >= sarray) {
256                         unsigned int mnp = *sptr--;
257                 
258                         if (g450_testpll(PMINFO mnp - 0x0300, pll) &&
259                             g450_testpll(PMINFO mnp + 0x0300, pll) &&
260                             g450_testpll(PMINFO mnp - 0x0200, pll) &&
261                             g450_testpll(PMINFO mnp + 0x0200, pll) &&
262                             g450_testpll(PMINFO mnp - 0x0100, pll) &&
263                             g450_testpll(PMINFO mnp + 0x0100, pll)) {
264                                 if (g450_testpll(PMINFO mnp, pll)) {
265                                         return mnp;
266                                 }
267                         } else if (!found && g450_testpll(PMINFO mnp, pll)) {
268                                 mnpfound = mnp;
269                                 found = 1;
270                         }
271                 }
272         }
273         g450_setpll(PMINFO mnpfound, pll);
274         return mnpfound;
275 }
276
277 static void g450_addcache(struct matrox_pll_cache* ci, unsigned int mnp_key, unsigned int mnp_value) {
278         if (++ci->valid > ARRAY_SIZE(ci->data)) {
279                 ci->valid = ARRAY_SIZE(ci->data);
280         }
281         memmove(ci->data + 1, ci->data, (ci->valid - 1) * sizeof(*ci->data));
282         ci->data[0].mnp_key = mnp_key & G450_MNP_FREQBITS;
283         ci->data[0].mnp_value = mnp_value;
284 }
285
286 static int g450_checkcache(WPMINFO struct matrox_pll_cache* ci, unsigned int mnp_key) {
287         unsigned int i;
288         
289         mnp_key &= G450_MNP_FREQBITS;
290         for (i = 0; i < ci->valid; i++) {
291                 if (ci->data[i].mnp_key == mnp_key) {
292                         unsigned int mnp;
293                         
294                         mnp = ci->data[i].mnp_value;
295                         if (i) {
296                                 memmove(ci->data + 1, ci->data, i * sizeof(*ci->data));
297                                 ci->data[0].mnp_key = mnp_key;
298                                 ci->data[0].mnp_value = mnp;
299                         }
300                         return mnp;
301                 }
302         }
303         return NO_MORE_MNP;
304 }
305
306 static int __g450_setclk(WPMINFO unsigned int fout, unsigned int pll, 
307                 unsigned int* mnparray, unsigned int* deltaarray) {
308         unsigned int mnpcount;
309         unsigned int pixel_vco;
310         const struct matrox_pll_limits* pi;
311         struct matrox_pll_cache* ci;
312
313         pixel_vco = 0;
314         switch (pll) {
315                 case M_PIXEL_PLL_A:
316                 case M_PIXEL_PLL_B:
317                 case M_PIXEL_PLL_C:
318                         {
319                                 u_int8_t tmp, xpwrctrl;
320                                 unsigned long flags;
321                                 
322                                 matroxfb_DAC_lock_irqsave(flags);
323
324                                 xpwrctrl = matroxfb_DAC_in(PMINFO M1064_XPWRCTRL);
325                                 matroxfb_DAC_out(PMINFO M1064_XPWRCTRL, xpwrctrl & ~M1064_XPWRCTRL_PANELPDN);
326                                 mga_outb(M_SEQ_INDEX, M_SEQ1);
327                                 mga_outb(M_SEQ_DATA, mga_inb(M_SEQ_DATA) | M_SEQ1_SCROFF);
328                                 tmp = matroxfb_DAC_in(PMINFO M1064_XPIXCLKCTRL);
329                                 tmp |= M1064_XPIXCLKCTRL_DIS;
330                                 if (!(tmp & M1064_XPIXCLKCTRL_PLL_UP)) {
331                                         tmp |= M1064_XPIXCLKCTRL_PLL_UP;
332                                 }
333                                 matroxfb_DAC_out(PMINFO M1064_XPIXCLKCTRL, tmp);
334                                 /* DVI PLL preferred for frequencies up to
335                                    panel link max, standard PLL otherwise */
336                                 if (fout >= MINFO->max_pixel_clock_panellink)
337                                         tmp = 0;
338                                 else tmp =
339                                         M1064_XDVICLKCTRL_DVIDATAPATHSEL |
340                                         M1064_XDVICLKCTRL_C1DVICLKSEL |
341                                         M1064_XDVICLKCTRL_C1DVICLKEN |
342                                         M1064_XDVICLKCTRL_DVILOOPCTL |
343                                         M1064_XDVICLKCTRL_P1LOOPBWDTCTL;
344                                 matroxfb_DAC_out(PMINFO M1064_XDVICLKCTRL,tmp);
345                                 matroxfb_DAC_out(PMINFO M1064_XPWRCTRL,
346                                                  xpwrctrl);
347
348                                 matroxfb_DAC_unlock_irqrestore(flags);
349                         }
350                         {
351                                 u_int8_t misc;
352                 
353                                 misc = mga_inb(M_MISC_REG_READ) & ~0x0C;
354                                 switch (pll) {
355                                         case M_PIXEL_PLL_A:
356                                                 break;
357                                         case M_PIXEL_PLL_B:
358                                                 misc |=  0x04;
359                                                 break;
360                                         default:
361                                                 misc |=  0x0C;
362                                                 break;
363                                 }
364                                 mga_outb(M_MISC_REG, misc);
365                         }
366                         pi = &ACCESS_FBINFO(limits.pixel);
367                         ci = &ACCESS_FBINFO(cache.pixel);
368                         break;
369                 case M_SYSTEM_PLL:
370                         {
371                                 u_int32_t opt;
372
373                                 pci_read_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, &opt);
374                                 if (!(opt & 0x20)) {
375                                         pci_write_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, opt | 0x20);
376                                 }
377                         }
378                         pi = &ACCESS_FBINFO(limits.system);
379                         ci = &ACCESS_FBINFO(cache.system);
380                         break;
381                 case M_VIDEO_PLL:
382                         {
383                                 u_int8_t tmp;
384                                 unsigned int mnp;
385                                 unsigned long flags;
386                                 
387                                 matroxfb_DAC_lock_irqsave(flags);
388                                 tmp = matroxfb_DAC_in(PMINFO M1064_XPWRCTRL);
389                                 if (!(tmp & 2)) {
390                                         matroxfb_DAC_out(PMINFO M1064_XPWRCTRL, tmp | 2);
391                                 }
392                                 
393                                 mnp = matroxfb_DAC_in(PMINFO M1064_XPIXPLLCM) << 16;
394                                 mnp |= matroxfb_DAC_in(PMINFO M1064_XPIXPLLCN) << 8;
395                                 pixel_vco = g450_mnp2vco(PMINFO mnp);
396                                 matroxfb_DAC_unlock_irqrestore(flags);
397                         }
398                         pi = &ACCESS_FBINFO(limits.video);
399                         ci = &ACCESS_FBINFO(cache.video);
400                         break;
401                 default:
402                         return -EINVAL;
403         }
404
405         mnpcount = 0;
406         {
407                 unsigned int mnp;
408                 unsigned int xvco;
409
410                 for(mnp = g450_firstpll(PMINFO pi, &xvco, fout); mnp != NO_MORE_MNP; mnp = g450_nextpll(PMINFO pi, &xvco, mnp)) {
411                         unsigned int idx;
412                         unsigned int vco;
413                         unsigned int delta;
414
415                         vco = g450_mnp2vco(PMINFO mnp);
416 #if 0                   
417                         if (pll == M_VIDEO_PLL) {
418                                 unsigned int big, small;
419
420                                 if (vco < pixel_vco) {
421                                         small = vco;
422                                         big = pixel_vco;
423                                 } else {
424                                         small = pixel_vco;
425                                         big = vco;
426                                 }
427                                 while (big > small) {
428                                         big >>= 1;
429                                 }
430                                 if (big == small) {
431                                         continue;
432                                 }
433                         }
434 #endif                  
435                         delta = pll_freq_delta(fout, g450_vco2f(mnp, vco));
436                         for (idx = mnpcount; idx > 0; idx--) {
437                                 /* == is important; due to nextpll algorithm we get
438                                    sorted equally good frequencies from lower VCO 
439                                    frequency to higher - with <= lowest wins, while
440                                    with < highest one wins */
441                                 if (delta <= deltaarray[idx-1]) {
442                                         /* all else being equal except VCO,
443                                          * choose VCO not near (within 1/16th or so) VCOmin
444                                          * (freqs near VCOmin aren't as stable)
445                                          */
446                                         if (delta == deltaarray[idx-1]
447                                             && vco != g450_mnp2vco(PMINFO mnparray[idx-1])
448                                             && vco < (pi->vcomin * 17 / 16)) {
449                                                 break;
450                                         }
451                                         mnparray[idx] = mnparray[idx-1];
452                                         deltaarray[idx] = deltaarray[idx-1];
453                                 } else {
454                                         break;
455                                 }
456                         }
457                         mnparray[idx] = mnp;
458                         deltaarray[idx] = delta;
459                         mnpcount++;
460                 }
461         }
462         /* VideoPLL and PixelPLL matched: do nothing... In all other cases we should get at least one frequency */
463         if (!mnpcount) {
464                 return -EBUSY;
465         }
466         {
467                 unsigned long flags;
468                 unsigned int mnp;
469                 
470                 matroxfb_DAC_lock_irqsave(flags);
471                 mnp = g450_checkcache(PMINFO ci, mnparray[0]);
472                 if (mnp != NO_MORE_MNP) {
473                         matroxfb_g450_setpll_cond(PMINFO mnp, pll);
474                 } else {
475                         mnp = g450_findworkingpll(PMINFO pll, mnparray, mnpcount);
476                         g450_addcache(ci, mnparray[0], mnp);
477                 }
478                 updatehwstate_clk(&ACCESS_FBINFO(hw), mnp, pll);
479                 matroxfb_DAC_unlock_irqrestore(flags);
480                 return mnp;
481         }
482 }
483
484 /* It must be greater than number of possible PLL values.
485  * Currently there is 5(p) * 10(m) = 50 possible values. */
486 #define MNP_TABLE_SIZE  64
487
488 int matroxfb_g450_setclk(WPMINFO unsigned int fout, unsigned int pll) {
489         unsigned int* arr;
490         
491         arr = kmalloc(sizeof(*arr) * MNP_TABLE_SIZE * 2, GFP_KERNEL);
492         if (arr) {
493                 int r;
494
495                 r = __g450_setclk(PMINFO fout, pll, arr, arr + MNP_TABLE_SIZE);
496                 kfree(arr);
497                 return r;
498         }
499         return -ENOMEM;
500 }
501
502 EXPORT_SYMBOL(matroxfb_g450_setclk);
503 EXPORT_SYMBOL(g450_mnp2f);
504 EXPORT_SYMBOL(matroxfb_g450_setpll_cond);
505
506 MODULE_AUTHOR("(c) 2001-2002 Petr Vandrovec <vandrove@vc.cvut.cz>");
507 MODULE_DESCRIPTION("Matrox G450/G550 PLL driver");
508
509 MODULE_LICENSE("GPL");