[PATCH] i386: inline asm cleanup
[linux-3.10.git] / arch / i386 / kernel / cpu / cyrix.c
1 #include <linux/init.h>
2 #include <linux/bitops.h>
3 #include <linux/delay.h>
4 #include <linux/pci.h>
5 #include <asm/dma.h>
6 #include <asm/io.h>
7 #include <asm/processor.h>
8 #include <asm/timer.h>
9
10 #include "cpu.h"
11
12 /*
13  * Read NSC/Cyrix DEVID registers (DIR) to get more detailed info. about the CPU
14  */
15 static void __init do_cyrix_devid(unsigned char *dir0, unsigned char *dir1)
16 {
17         unsigned char ccr2, ccr3;
18         unsigned long flags;
19         
20         /* we test for DEVID by checking whether CCR3 is writable */
21         local_irq_save(flags);
22         ccr3 = getCx86(CX86_CCR3);
23         setCx86(CX86_CCR3, ccr3 ^ 0x80);
24         getCx86(0xc0);   /* dummy to change bus */
25
26         if (getCx86(CX86_CCR3) == ccr3) {       /* no DEVID regs. */
27                 ccr2 = getCx86(CX86_CCR2);
28                 setCx86(CX86_CCR2, ccr2 ^ 0x04);
29                 getCx86(0xc0);  /* dummy */
30
31                 if (getCx86(CX86_CCR2) == ccr2) /* old Cx486SLC/DLC */
32                         *dir0 = 0xfd;
33                 else {                          /* Cx486S A step */
34                         setCx86(CX86_CCR2, ccr2);
35                         *dir0 = 0xfe;
36                 }
37         }
38         else {
39                 setCx86(CX86_CCR3, ccr3);  /* restore CCR3 */
40
41                 /* read DIR0 and DIR1 CPU registers */
42                 *dir0 = getCx86(CX86_DIR0);
43                 *dir1 = getCx86(CX86_DIR1);
44         }
45         local_irq_restore(flags);
46 }
47
48 /*
49  * Cx86_dir0_msb is a HACK needed by check_cx686_cpuid/slop in bugs.h in
50  * order to identify the Cyrix CPU model after we're out of setup.c
51  *
52  * Actually since bugs.h doesn't even reference this perhaps someone should
53  * fix the documentation ???
54  */
55 static unsigned char Cx86_dir0_msb __initdata = 0;
56
57 static char Cx86_model[][9] __initdata = {
58         "Cx486", "Cx486", "5x86 ", "6x86", "MediaGX ", "6x86MX ",
59         "M II ", "Unknown"
60 };
61 static char Cx486_name[][5] __initdata = {
62         "SLC", "DLC", "SLC2", "DLC2", "SRx", "DRx",
63         "SRx2", "DRx2"
64 };
65 static char Cx486S_name[][4] __initdata = {
66         "S", "S2", "Se", "S2e"
67 };
68 static char Cx486D_name[][4] __initdata = {
69         "DX", "DX2", "?", "?", "?", "DX4"
70 };
71 static char Cx86_cb[] __initdata = "?.5x Core/Bus Clock";
72 static char cyrix_model_mult1[] __initdata = "12??43";
73 static char cyrix_model_mult2[] __initdata = "12233445";
74
75 /*
76  * Reset the slow-loop (SLOP) bit on the 686(L) which is set by some old
77  * BIOSes for compatibility with DOS games.  This makes the udelay loop
78  * work correctly, and improves performance.
79  *
80  * FIXME: our newer udelay uses the tsc. We don't need to frob with SLOP
81  */
82
83 extern void calibrate_delay(void) __init;
84
85 static void __init check_cx686_slop(struct cpuinfo_x86 *c)
86 {
87         unsigned long flags;
88         
89         if (Cx86_dir0_msb == 3) {
90                 unsigned char ccr3, ccr5;
91
92                 local_irq_save(flags);
93                 ccr3 = getCx86(CX86_CCR3);
94                 setCx86(CX86_CCR3, (ccr3 & 0x0f) | 0x10); /* enable MAPEN  */
95                 ccr5 = getCx86(CX86_CCR5);
96                 if (ccr5 & 2)
97                         setCx86(CX86_CCR5, ccr5 & 0xfd);  /* reset SLOP */
98                 setCx86(CX86_CCR3, ccr3);                 /* disable MAPEN */
99                 local_irq_restore(flags);
100
101                 if (ccr5 & 2) { /* possible wrong calibration done */
102                         printk(KERN_INFO "Recalibrating delay loop with SLOP bit reset\n");
103                         calibrate_delay();
104                         c->loops_per_jiffy = loops_per_jiffy;
105                 }
106         }
107 }
108
109
110 static void __init set_cx86_reorder(void)
111 {
112         u8 ccr3;
113
114         printk(KERN_INFO "Enable Memory access reorder on Cyrix/NSC processor.\n");
115         ccr3 = getCx86(CX86_CCR3);
116         setCx86(CX86_CCR3, (ccr3 & 0x0f) | 0x10); /* enable MAPEN  */
117
118         /* Load/Store Serialize to mem access disable (=reorder it)  */
119         setCx86(CX86_PCR0, getCx86(CX86_PCR0) & ~0x80);
120         /* set load/store serialize from 1GB to 4GB */
121         ccr3 |= 0xe0;
122         setCx86(CX86_CCR3, ccr3);
123 }
124
125 static void __init set_cx86_memwb(void)
126 {
127         u32 cr0;
128
129         printk(KERN_INFO "Enable Memory-Write-back mode on Cyrix/NSC processor.\n");
130
131         /* CCR2 bit 2: unlock NW bit */
132         setCx86(CX86_CCR2, getCx86(CX86_CCR2) & ~0x04);
133         /* set 'Not Write-through' */
134         cr0 = 0x20000000;
135         write_cr0(read_cr0() | cr0);
136         /* CCR2 bit 2: lock NW bit and set WT1 */
137         setCx86(CX86_CCR2, getCx86(CX86_CCR2) | 0x14 );
138 }
139
140 static void __init set_cx86_inc(void)
141 {
142         unsigned char ccr3;
143
144         printk(KERN_INFO "Enable Incrementor on Cyrix/NSC processor.\n");
145
146         ccr3 = getCx86(CX86_CCR3);
147         setCx86(CX86_CCR3, (ccr3 & 0x0f) | 0x10); /* enable MAPEN  */
148         /* PCR1 -- Performance Control */
149         /* Incrementor on, whatever that is */
150         setCx86(CX86_PCR1, getCx86(CX86_PCR1) | 0x02);
151         /* PCR0 -- Performance Control */
152         /* Incrementor Margin 10 */
153         setCx86(CX86_PCR0, getCx86(CX86_PCR0) | 0x04); 
154         setCx86(CX86_CCR3, ccr3);       /* disable MAPEN */
155 }
156
157 /*
158  *      Configure later MediaGX and/or Geode processor.
159  */
160
161 static void __init geode_configure(void)
162 {
163         unsigned long flags;
164         u8 ccr3, ccr4;
165         local_irq_save(flags);
166
167         /* Suspend on halt power saving and enable #SUSP pin */
168         setCx86(CX86_CCR2, getCx86(CX86_CCR2) | 0x88);
169
170         ccr3 = getCx86(CX86_CCR3);
171         setCx86(CX86_CCR3, (ccr3 & 0x0f) | 0x10);       /* Enable */
172         
173         ccr4 = getCx86(CX86_CCR4);
174         ccr4 |= 0x38;           /* FPU fast, DTE cache, Mem bypass */
175         
176         setCx86(CX86_CCR3, ccr3);
177         
178         set_cx86_memwb();
179         set_cx86_reorder();     
180         set_cx86_inc();
181         
182         local_irq_restore(flags);
183 }
184
185
186 #ifdef CONFIG_PCI
187 static struct pci_device_id cyrix_55x0[] = {
188         { PCI_DEVICE(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5510) },
189         { PCI_DEVICE(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5520) },
190         { },
191 };
192 #endif
193
194 static void __init init_cyrix(struct cpuinfo_x86 *c)
195 {
196         unsigned char dir0, dir0_msn, dir0_lsn, dir1 = 0;
197         char *buf = c->x86_model_id;
198         const char *p = NULL;
199
200         /* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
201            3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
202         clear_bit(0*32+31, c->x86_capability);
203
204         /* Cyrix used bit 24 in extended (AMD) CPUID for Cyrix MMX extensions */
205         if ( test_bit(1*32+24, c->x86_capability) ) {
206                 clear_bit(1*32+24, c->x86_capability);
207                 set_bit(X86_FEATURE_CXMMX, c->x86_capability);
208         }
209
210         do_cyrix_devid(&dir0, &dir1);
211
212         check_cx686_slop(c);
213
214         Cx86_dir0_msb = dir0_msn = dir0 >> 4; /* identifies CPU "family"   */
215         dir0_lsn = dir0 & 0xf;                /* model or clock multiplier */
216
217         /* common case step number/rev -- exceptions handled below */
218         c->x86_model = (dir1 >> 4) + 1;
219         c->x86_mask = dir1 & 0xf;
220
221         /* Now cook; the original recipe is by Channing Corn, from Cyrix.
222          * We do the same thing for each generation: we work out
223          * the model, multiplier and stepping.  Black magic included,
224          * to make the silicon step/rev numbers match the printed ones.
225          */
226          
227         switch (dir0_msn) {
228                 unsigned char tmp;
229
230         case 0: /* Cx486SLC/DLC/SRx/DRx */
231                 p = Cx486_name[dir0_lsn & 7];
232                 break;
233
234         case 1: /* Cx486S/DX/DX2/DX4 */
235                 p = (dir0_lsn & 8) ? Cx486D_name[dir0_lsn & 5]
236                         : Cx486S_name[dir0_lsn & 3];
237                 break;
238
239         case 2: /* 5x86 */
240                 Cx86_cb[2] = cyrix_model_mult1[dir0_lsn & 5];
241                 p = Cx86_cb+2;
242                 break;
243
244         case 3: /* 6x86/6x86L */
245                 Cx86_cb[1] = ' ';
246                 Cx86_cb[2] = cyrix_model_mult1[dir0_lsn & 5];
247                 if (dir1 > 0x21) { /* 686L */
248                         Cx86_cb[0] = 'L';
249                         p = Cx86_cb;
250                         (c->x86_model)++;
251                 } else             /* 686 */
252                         p = Cx86_cb+1;
253                 /* Emulate MTRRs using Cyrix's ARRs. */
254                 set_bit(X86_FEATURE_CYRIX_ARR, c->x86_capability);
255                 /* 6x86's contain this bug */
256                 c->coma_bug = 1;
257                 break;
258
259         case 4: /* MediaGX/GXm or Geode GXM/GXLV/GX1 */
260 #ifdef CONFIG_PCI
261                 /* It isn't really a PCI quirk directly, but the cure is the
262                    same. The MediaGX has deep magic SMM stuff that handles the
263                    SB emulation. It thows away the fifo on disable_dma() which
264                    is wrong and ruins the audio. 
265
266                    Bug2: VSA1 has a wrap bug so that using maximum sized DMA 
267                    causes bad things. According to NatSemi VSA2 has another
268                    bug to do with 'hlt'. I've not seen any boards using VSA2
269                    and X doesn't seem to support it either so who cares 8).
270                    VSA1 we work around however.
271                 */
272
273                 printk(KERN_INFO "Working around Cyrix MediaGX virtual DMA bugs.\n");
274                 isa_dma_bridge_buggy = 2;
275 #endif          
276                 c->x86_cache_size=16;   /* Yep 16K integrated cache thats it */
277  
278                 /*
279                  *  The 5510/5520 companion chips have a funky PIT.
280                  */  
281                 if (pci_dev_present(cyrix_55x0))
282                         pit_latch_buggy = 1;
283
284                 /* GXm supports extended cpuid levels 'ala' AMD */
285                 if (c->cpuid_level == 2) {
286                         /* Enable cxMMX extensions (GX1 Datasheet 54) */
287                         setCx86(CX86_CCR7, getCx86(CX86_CCR7)|1);
288                         
289                         /* GXlv/GXm/GX1 */
290                         if((dir1 >= 0x50 && dir1 <= 0x54) || dir1 >= 0x63)
291                                 geode_configure();
292                         get_model_name(c);  /* get CPU marketing name */
293                         return;
294                 }
295                 else {  /* MediaGX */
296                         Cx86_cb[2] = (dir0_lsn & 1) ? '3' : '4';
297                         p = Cx86_cb+2;
298                         c->x86_model = (dir1 & 0x20) ? 1 : 2;
299                 }
300                 break;
301
302         case 5: /* 6x86MX/M II */
303                 if (dir1 > 7)
304                 {
305                         dir0_msn++;  /* M II */
306                         /* Enable MMX extensions (App note 108) */
307                         setCx86(CX86_CCR7, getCx86(CX86_CCR7)|1);
308                 }
309                 else
310                 {
311                         c->coma_bug = 1;      /* 6x86MX, it has the bug. */
312                 }
313                 tmp = (!(dir0_lsn & 7) || dir0_lsn & 1) ? 2 : 0;
314                 Cx86_cb[tmp] = cyrix_model_mult2[dir0_lsn & 7];
315                 p = Cx86_cb+tmp;
316                 if (((dir1 & 0x0f) > 4) || ((dir1 & 0xf0) == 0x20))
317                         (c->x86_model)++;
318                 /* Emulate MTRRs using Cyrix's ARRs. */
319                 set_bit(X86_FEATURE_CYRIX_ARR, c->x86_capability);
320                 break;
321
322         case 0xf:  /* Cyrix 486 without DEVID registers */
323                 switch (dir0_lsn) {
324                 case 0xd:  /* either a 486SLC or DLC w/o DEVID */
325                         dir0_msn = 0;
326                         p = Cx486_name[(c->hard_math) ? 1 : 0];
327                         break;
328
329                 case 0xe:  /* a 486S A step */
330                         dir0_msn = 0;
331                         p = Cx486S_name[0];
332                         break;
333                 }
334                 break;
335
336         default:  /* unknown (shouldn't happen, we know everyone ;-) */
337                 dir0_msn = 7;
338                 break;
339         }
340         strcpy(buf, Cx86_model[dir0_msn & 7]);
341         if (p) strcat(buf, p);
342         return;
343 }
344
345 /*
346  * Cyrix CPUs without cpuid or with cpuid not yet enabled can be detected
347  * by the fact that they preserve the flags across the division of 5/2.
348  * PII and PPro exhibit this behavior too, but they have cpuid available.
349  */
350  
351 /*
352  * Perform the Cyrix 5/2 test. A Cyrix won't change
353  * the flags, while other 486 chips will.
354  */
355 static inline int test_cyrix_52div(void)
356 {
357         unsigned int test;
358
359         __asm__ __volatile__(
360              "sahf\n\t"         /* clear flags (%eax = 0x0005) */
361              "div %b2\n\t"      /* divide 5 by 2 */
362              "lahf"             /* store flags into %ah */
363              : "=a" (test)
364              : "0" (5), "q" (2)
365              : "cc");
366
367         /* AH is 0x02 on Cyrix after the divide.. */
368         return (unsigned char) (test >> 8) == 0x02;
369 }
370
371 static void cyrix_identify(struct cpuinfo_x86 * c)
372 {
373         /* Detect Cyrix with disabled CPUID */
374         if ( c->x86 == 4 && test_cyrix_52div() ) {
375                 unsigned char dir0, dir1;
376                 
377                 strcpy(c->x86_vendor_id, "CyrixInstead");
378                 c->x86_vendor = X86_VENDOR_CYRIX;
379                 
380                 /* Actually enable cpuid on the older cyrix */
381             
382                 /* Retrieve CPU revisions */
383                 
384                 do_cyrix_devid(&dir0, &dir1);
385
386                 dir0>>=4;               
387                 
388                 /* Check it is an affected model */
389                 
390                 if (dir0 == 5 || dir0 == 3)
391                 {
392                         unsigned char ccr3, ccr4;
393                         unsigned long flags;
394                         printk(KERN_INFO "Enabling CPUID on Cyrix processor.\n");
395                         local_irq_save(flags);
396                         ccr3 = getCx86(CX86_CCR3);
397                         setCx86(CX86_CCR3, (ccr3 & 0x0f) | 0x10); /* enable MAPEN  */
398                         ccr4 = getCx86(CX86_CCR4);
399                         setCx86(CX86_CCR4, ccr4 | 0x80);          /* enable cpuid  */
400                         setCx86(CX86_CCR3, ccr3);                 /* disable MAPEN */
401                         local_irq_restore(flags);
402                 }
403         }
404         generic_identify(c);
405 }
406
407 static struct cpu_dev cyrix_cpu_dev __initdata = {
408         .c_vendor       = "Cyrix",
409         .c_ident        = { "CyrixInstead" },
410         .c_init         = init_cyrix,
411         .c_identify     = cyrix_identify,
412 };
413
414 int __init cyrix_init_cpu(void)
415 {
416         cpu_devs[X86_VENDOR_CYRIX] = &cyrix_cpu_dev;
417         return 0;
418 }
419
420 //early_arch_initcall(cyrix_init_cpu);
421
422 static struct cpu_dev nsc_cpu_dev __initdata = {
423         .c_vendor       = "NSC",
424         .c_ident        = { "Geode by NSC" },
425         .c_init         = init_cyrix,
426         .c_identify     = generic_identify,
427 };
428
429 int __init nsc_init_cpu(void)
430 {
431         cpu_devs[X86_VENDOR_NSC] = &nsc_cpu_dev;
432         return 0;
433 }
434
435 //early_arch_initcall(nsc_init_cpu);