diff options
Diffstat (limited to 'arch/x86')
-rw-r--r-- | arch/x86/Kconfig | 10 | ||||
-rw-r--r-- | arch/x86/include/asm/mca.h | 43 | ||||
-rw-r--r-- | arch/x86/include/asm/mca_dma.h | 201 | ||||
-rw-r--r-- | arch/x86/include/asm/mpspec.h | 2 | ||||
-rw-r--r-- | arch/x86/include/asm/mpspec_def.h | 3 | ||||
-rw-r--r-- | arch/x86/kernel/Makefile | 1 | ||||
-rw-r--r-- | arch/x86/kernel/acpi/boot.c | 2 | ||||
-rw-r--r-- | arch/x86/kernel/apic/io_apic.c | 17 | ||||
-rw-r--r-- | arch/x86/kernel/mca_32.c | 476 | ||||
-rw-r--r-- | arch/x86/kernel/mpparse.c | 11 | ||||
-rw-r--r-- | arch/x86/kernel/nmi.c | 12 | ||||
-rw-r--r-- | arch/x86/kernel/setup.c | 8 | ||||
-rw-r--r-- | arch/x86/kernel/time.c | 6 | ||||
-rw-r--r-- | arch/x86/kernel/traps.c | 4 |
14 files changed, 9 insertions, 787 deletions
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 4d37072c498a..d6168994e115 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig | |||
@@ -2037,16 +2037,6 @@ config EISA | |||
2037 | 2037 | ||
2038 | source "drivers/eisa/Kconfig" | 2038 | source "drivers/eisa/Kconfig" |
2039 | 2039 | ||
2040 | config MCA | ||
2041 | bool "MCA support" | ||
2042 | ---help--- | ||
2043 | MicroChannel Architecture is found in some IBM PS/2 machines and | ||
2044 | laptops. It is a bus system similar to PCI or ISA. See | ||
2045 | <file:Documentation/mca.txt> (and especially the web page given | ||
2046 | there) before attempting to build an MCA bus kernel. | ||
2047 | |||
2048 | source "drivers/mca/Kconfig" | ||
2049 | |||
2050 | config SCx200 | 2040 | config SCx200 |
2051 | tristate "NatSemi SCx200 support" | 2041 | tristate "NatSemi SCx200 support" |
2052 | ---help--- | 2042 | ---help--- |
diff --git a/arch/x86/include/asm/mca.h b/arch/x86/include/asm/mca.h deleted file mode 100644 index eedbb6cc1efb..000000000000 --- a/arch/x86/include/asm/mca.h +++ /dev/null | |||
@@ -1,43 +0,0 @@ | |||
1 | /* -*- mode: c; c-basic-offset: 8 -*- */ | ||
2 | |||
3 | /* Platform specific MCA defines */ | ||
4 | #ifndef _ASM_X86_MCA_H | ||
5 | #define _ASM_X86_MCA_H | ||
6 | |||
7 | /* Maximal number of MCA slots - actually, some machines have less, but | ||
8 | * they all have sufficient number of POS registers to cover 8. | ||
9 | */ | ||
10 | #define MCA_MAX_SLOT_NR 8 | ||
11 | |||
12 | /* Most machines have only one MCA bus. The only multiple bus machines | ||
13 | * I know have at most two */ | ||
14 | #define MAX_MCA_BUSSES 2 | ||
15 | |||
16 | #define MCA_PRIMARY_BUS 0 | ||
17 | #define MCA_SECONDARY_BUS 1 | ||
18 | |||
19 | /* Dummy slot numbers on primary MCA for integrated functions */ | ||
20 | #define MCA_INTEGSCSI (MCA_MAX_SLOT_NR) | ||
21 | #define MCA_INTEGVIDEO (MCA_MAX_SLOT_NR+1) | ||
22 | #define MCA_MOTHERBOARD (MCA_MAX_SLOT_NR+2) | ||
23 | |||
24 | /* Dummy POS values for integrated functions */ | ||
25 | #define MCA_DUMMY_POS_START 0x10000 | ||
26 | #define MCA_INTEGSCSI_POS (MCA_DUMMY_POS_START+1) | ||
27 | #define MCA_INTEGVIDEO_POS (MCA_DUMMY_POS_START+2) | ||
28 | #define MCA_MOTHERBOARD_POS (MCA_DUMMY_POS_START+3) | ||
29 | |||
30 | /* MCA registers */ | ||
31 | |||
32 | #define MCA_MOTHERBOARD_SETUP_REG 0x94 | ||
33 | #define MCA_ADAPTER_SETUP_REG 0x96 | ||
34 | #define MCA_POS_REG(n) (0x100+(n)) | ||
35 | |||
36 | #define MCA_ENABLED 0x01 /* POS 2, set if adapter enabled */ | ||
37 | |||
38 | /* Max number of adapters, including both slots and various integrated | ||
39 | * things. | ||
40 | */ | ||
41 | #define MCA_NUMADAPTERS (MCA_MAX_SLOT_NR+3) | ||
42 | |||
43 | #endif /* _ASM_X86_MCA_H */ | ||
diff --git a/arch/x86/include/asm/mca_dma.h b/arch/x86/include/asm/mca_dma.h deleted file mode 100644 index 45271aef82dd..000000000000 --- a/arch/x86/include/asm/mca_dma.h +++ /dev/null | |||
@@ -1,201 +0,0 @@ | |||
1 | #ifndef _ASM_X86_MCA_DMA_H | ||
2 | #define _ASM_X86_MCA_DMA_H | ||
3 | |||
4 | #include <asm/io.h> | ||
5 | #include <linux/ioport.h> | ||
6 | |||
7 | /* | ||
8 | * Microchannel specific DMA stuff. DMA on an MCA machine is fairly similar to | ||
9 | * standard PC dma, but it certainly has its quirks. DMA register addresses | ||
10 | * are in a different place and there are some added functions. Most of this | ||
11 | * should be pretty obvious on inspection. Note that the user must divide | ||
12 | * count by 2 when using 16-bit dma; that is not handled by these functions. | ||
13 | * | ||
14 | * Ramen Noodles are yummy. | ||
15 | * | ||
16 | * 1998 Tymm Twillman <tymm@computer.org> | ||
17 | */ | ||
18 | |||
19 | /* | ||
20 | * Registers that are used by the DMA controller; FN is the function register | ||
21 | * (tell the controller what to do) and EXE is the execution register (how | ||
22 | * to do it) | ||
23 | */ | ||
24 | |||
25 | #define MCA_DMA_REG_FN 0x18 | ||
26 | #define MCA_DMA_REG_EXE 0x1A | ||
27 | |||
28 | /* | ||
29 | * Functions that the DMA controller can do | ||
30 | */ | ||
31 | |||
32 | #define MCA_DMA_FN_SET_IO 0x00 | ||
33 | #define MCA_DMA_FN_SET_ADDR 0x20 | ||
34 | #define MCA_DMA_FN_GET_ADDR 0x30 | ||
35 | #define MCA_DMA_FN_SET_COUNT 0x40 | ||
36 | #define MCA_DMA_FN_GET_COUNT 0x50 | ||
37 | #define MCA_DMA_FN_GET_STATUS 0x60 | ||
38 | #define MCA_DMA_FN_SET_MODE 0x70 | ||
39 | #define MCA_DMA_FN_SET_ARBUS 0x80 | ||
40 | #define MCA_DMA_FN_MASK 0x90 | ||
41 | #define MCA_DMA_FN_RESET_MASK 0xA0 | ||
42 | #define MCA_DMA_FN_MASTER_CLEAR 0xD0 | ||
43 | |||
44 | /* | ||
45 | * Modes (used by setting MCA_DMA_FN_MODE in the function register) | ||
46 | * | ||
47 | * Note that the MODE_READ is read from memory (write to device), and | ||
48 | * MODE_WRITE is vice-versa. | ||
49 | */ | ||
50 | |||
51 | #define MCA_DMA_MODE_XFER 0x04 /* read by default */ | ||
52 | #define MCA_DMA_MODE_READ 0x04 /* same as XFER */ | ||
53 | #define MCA_DMA_MODE_WRITE 0x08 /* OR with MODE_XFER to use */ | ||
54 | #define MCA_DMA_MODE_IO 0x01 /* DMA from IO register */ | ||
55 | #define MCA_DMA_MODE_16 0x40 /* 16 bit xfers */ | ||
56 | |||
57 | |||
58 | /** | ||
59 | * mca_enable_dma - channel to enable DMA on | ||
60 | * @dmanr: DMA channel | ||
61 | * | ||
62 | * Enable the MCA bus DMA on a channel. This can be called from | ||
63 | * IRQ context. | ||
64 | */ | ||
65 | |||
66 | static inline void mca_enable_dma(unsigned int dmanr) | ||
67 | { | ||
68 | outb(MCA_DMA_FN_RESET_MASK | dmanr, MCA_DMA_REG_FN); | ||
69 | } | ||
70 | |||
71 | /** | ||
72 | * mca_disble_dma - channel to disable DMA on | ||
73 | * @dmanr: DMA channel | ||
74 | * | ||
75 | * Enable the MCA bus DMA on a channel. This can be called from | ||
76 | * IRQ context. | ||
77 | */ | ||
78 | |||
79 | static inline void mca_disable_dma(unsigned int dmanr) | ||
80 | { | ||
81 | outb(MCA_DMA_FN_MASK | dmanr, MCA_DMA_REG_FN); | ||
82 | } | ||
83 | |||
84 | /** | ||
85 | * mca_set_dma_addr - load a 24bit DMA address | ||
86 | * @dmanr: DMA channel | ||
87 | * @a: 24bit bus address | ||
88 | * | ||
89 | * Load the address register in the DMA controller. This has a 24bit | ||
90 | * limitation (16Mb). | ||
91 | */ | ||
92 | |||
93 | static inline void mca_set_dma_addr(unsigned int dmanr, unsigned int a) | ||
94 | { | ||
95 | outb(MCA_DMA_FN_SET_ADDR | dmanr, MCA_DMA_REG_FN); | ||
96 | outb(a & 0xff, MCA_DMA_REG_EXE); | ||
97 | outb((a >> 8) & 0xff, MCA_DMA_REG_EXE); | ||
98 | outb((a >> 16) & 0xff, MCA_DMA_REG_EXE); | ||
99 | } | ||
100 | |||
101 | /** | ||
102 | * mca_get_dma_addr - load a 24bit DMA address | ||
103 | * @dmanr: DMA channel | ||
104 | * | ||
105 | * Read the address register in the DMA controller. This has a 24bit | ||
106 | * limitation (16Mb). The return is a bus address. | ||
107 | */ | ||
108 | |||
109 | static inline unsigned int mca_get_dma_addr(unsigned int dmanr) | ||
110 | { | ||
111 | unsigned int addr; | ||
112 | |||
113 | outb(MCA_DMA_FN_GET_ADDR | dmanr, MCA_DMA_REG_FN); | ||
114 | addr = inb(MCA_DMA_REG_EXE); | ||
115 | addr |= inb(MCA_DMA_REG_EXE) << 8; | ||
116 | addr |= inb(MCA_DMA_REG_EXE) << 16; | ||
117 | |||
118 | return addr; | ||
119 | } | ||
120 | |||
121 | /** | ||
122 | * mca_set_dma_count - load a 16bit transfer count | ||
123 | * @dmanr: DMA channel | ||
124 | * @count: count | ||
125 | * | ||
126 | * Set the DMA count for this channel. This can be up to 64Kbytes. | ||
127 | * Setting a count of zero will not do what you expect. | ||
128 | */ | ||
129 | |||
130 | static inline void mca_set_dma_count(unsigned int dmanr, unsigned int count) | ||
131 | { | ||
132 | count--; /* transfers one more than count -- correct for this */ | ||
133 | |||
134 | outb(MCA_DMA_FN_SET_COUNT | dmanr, MCA_DMA_REG_FN); | ||
135 | outb(count & 0xff, MCA_DMA_REG_EXE); | ||
136 | outb((count >> 8) & 0xff, MCA_DMA_REG_EXE); | ||
137 | } | ||
138 | |||
139 | /** | ||
140 | * mca_get_dma_residue - get the remaining bytes to transfer | ||
141 | * @dmanr: DMA channel | ||
142 | * | ||
143 | * This function returns the number of bytes left to transfer | ||
144 | * on this DMA channel. | ||
145 | */ | ||
146 | |||
147 | static inline unsigned int mca_get_dma_residue(unsigned int dmanr) | ||
148 | { | ||
149 | unsigned short count; | ||
150 | |||
151 | outb(MCA_DMA_FN_GET_COUNT | dmanr, MCA_DMA_REG_FN); | ||
152 | count = 1 + inb(MCA_DMA_REG_EXE); | ||
153 | count += inb(MCA_DMA_REG_EXE) << 8; | ||
154 | |||
155 | return count; | ||
156 | } | ||
157 | |||
158 | /** | ||
159 | * mca_set_dma_io - set the port for an I/O transfer | ||
160 | * @dmanr: DMA channel | ||
161 | * @io_addr: an I/O port number | ||
162 | * | ||
163 | * Unlike the ISA bus DMA controllers the DMA on MCA bus can transfer | ||
164 | * with an I/O port target. | ||
165 | */ | ||
166 | |||
167 | static inline void mca_set_dma_io(unsigned int dmanr, unsigned int io_addr) | ||
168 | { | ||
169 | /* | ||
170 | * DMA from a port address -- set the io address | ||
171 | */ | ||
172 | |||
173 | outb(MCA_DMA_FN_SET_IO | dmanr, MCA_DMA_REG_FN); | ||
174 | outb(io_addr & 0xff, MCA_DMA_REG_EXE); | ||
175 | outb((io_addr >> 8) & 0xff, MCA_DMA_REG_EXE); | ||
176 | } | ||
177 | |||
178 | /** | ||
179 | * mca_set_dma_mode - set the DMA mode | ||
180 | * @dmanr: DMA channel | ||
181 | * @mode: mode to set | ||
182 | * | ||
183 | * The DMA controller supports several modes. The mode values you can | ||
184 | * set are- | ||
185 | * | ||
186 | * %MCA_DMA_MODE_READ when reading from the DMA device. | ||
187 | * | ||
188 | * %MCA_DMA_MODE_WRITE to writing to the DMA device. | ||
189 | * | ||
190 | * %MCA_DMA_MODE_IO to do DMA to or from an I/O port. | ||
191 | * | ||
192 | * %MCA_DMA_MODE_16 to do 16bit transfers. | ||
193 | */ | ||
194 | |||
195 | static inline void mca_set_dma_mode(unsigned int dmanr, unsigned int mode) | ||
196 | { | ||
197 | outb(MCA_DMA_FN_SET_MODE | dmanr, MCA_DMA_REG_FN); | ||
198 | outb(mode, MCA_DMA_REG_EXE); | ||
199 | } | ||
200 | |||
201 | #endif /* _ASM_X86_MCA_DMA_H */ | ||
diff --git a/arch/x86/include/asm/mpspec.h b/arch/x86/include/asm/mpspec.h index 9c7d95f6174b..3e2f42a4b872 100644 --- a/arch/x86/include/asm/mpspec.h +++ b/arch/x86/include/asm/mpspec.h | |||
@@ -40,7 +40,7 @@ extern int quad_local_to_mp_bus_id [NR_CPUS/4][4]; | |||
40 | 40 | ||
41 | #endif /* CONFIG_X86_64 */ | 41 | #endif /* CONFIG_X86_64 */ |
42 | 42 | ||
43 | #if defined(CONFIG_MCA) || defined(CONFIG_EISA) | 43 | #ifdef CONFIG_EISA |
44 | extern int mp_bus_id_to_type[MAX_MP_BUSSES]; | 44 | extern int mp_bus_id_to_type[MAX_MP_BUSSES]; |
45 | #endif | 45 | #endif |
46 | 46 | ||
diff --git a/arch/x86/include/asm/mpspec_def.h b/arch/x86/include/asm/mpspec_def.h index c0a955a9a087..b31f8c098271 100644 --- a/arch/x86/include/asm/mpspec_def.h +++ b/arch/x86/include/asm/mpspec_def.h | |||
@@ -84,7 +84,7 @@ struct mpc_bus { | |||
84 | #define BUSTYPE_EISA "EISA" | 84 | #define BUSTYPE_EISA "EISA" |
85 | #define BUSTYPE_ISA "ISA" | 85 | #define BUSTYPE_ISA "ISA" |
86 | #define BUSTYPE_INTERN "INTERN" /* Internal BUS */ | 86 | #define BUSTYPE_INTERN "INTERN" /* Internal BUS */ |
87 | #define BUSTYPE_MCA "MCA" | 87 | #define BUSTYPE_MCA "MCA" /* Obsolete */ |
88 | #define BUSTYPE_VL "VL" /* Local bus */ | 88 | #define BUSTYPE_VL "VL" /* Local bus */ |
89 | #define BUSTYPE_PCI "PCI" | 89 | #define BUSTYPE_PCI "PCI" |
90 | #define BUSTYPE_PCMCIA "PCMCIA" | 90 | #define BUSTYPE_PCMCIA "PCMCIA" |
@@ -169,6 +169,5 @@ enum mp_bustype { | |||
169 | MP_BUS_ISA = 1, | 169 | MP_BUS_ISA = 1, |
170 | MP_BUS_EISA, | 170 | MP_BUS_EISA, |
171 | MP_BUS_PCI, | 171 | MP_BUS_PCI, |
172 | MP_BUS_MCA, | ||
173 | }; | 172 | }; |
174 | #endif /* _ASM_X86_MPSPEC_DEF_H */ | 173 | #endif /* _ASM_X86_MPSPEC_DEF_H */ |
diff --git a/arch/x86/kernel/Makefile b/arch/x86/kernel/Makefile index 56ebd1f98447..bb8529275aab 100644 --- a/arch/x86/kernel/Makefile +++ b/arch/x86/kernel/Makefile | |||
@@ -49,7 +49,6 @@ obj-y += cpu/ | |||
49 | obj-y += acpi/ | 49 | obj-y += acpi/ |
50 | obj-y += reboot.o | 50 | obj-y += reboot.o |
51 | obj-$(CONFIG_X86_32) += reboot_32.o | 51 | obj-$(CONFIG_X86_32) += reboot_32.o |
52 | obj-$(CONFIG_MCA) += mca_32.o | ||
53 | obj-$(CONFIG_X86_MSR) += msr.o | 52 | obj-$(CONFIG_X86_MSR) += msr.o |
54 | obj-$(CONFIG_X86_CPUID) += cpuid.o | 53 | obj-$(CONFIG_X86_CPUID) += cpuid.o |
55 | obj-$(CONFIG_PCI) += early-quirks.o | 54 | obj-$(CONFIG_PCI) += early-quirks.o |
diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c index 7c439fe4941b..8afb69319815 100644 --- a/arch/x86/kernel/acpi/boot.c +++ b/arch/x86/kernel/acpi/boot.c | |||
@@ -990,7 +990,7 @@ void __init mp_config_acpi_legacy_irqs(void) | |||
990 | int i; | 990 | int i; |
991 | struct mpc_intsrc mp_irq; | 991 | struct mpc_intsrc mp_irq; |
992 | 992 | ||
993 | #if defined (CONFIG_MCA) || defined (CONFIG_EISA) | 993 | #ifdef CONFIG_EISA |
994 | /* | 994 | /* |
995 | * Fabricate the legacy ISA bus (bus #31). | 995 | * Fabricate the legacy ISA bus (bus #31). |
996 | */ | 996 | */ |
diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c index ffdc152e507d..ac96561d1a99 100644 --- a/arch/x86/kernel/apic/io_apic.c +++ b/arch/x86/kernel/apic/io_apic.c | |||
@@ -140,7 +140,7 @@ int mp_irq_entries; | |||
140 | /* GSI interrupts */ | 140 | /* GSI interrupts */ |
141 | static int nr_irqs_gsi = NR_IRQS_LEGACY; | 141 | static int nr_irqs_gsi = NR_IRQS_LEGACY; |
142 | 142 | ||
143 | #if defined (CONFIG_MCA) || defined (CONFIG_EISA) | 143 | #ifdef CONFIG_EISA |
144 | int mp_bus_id_to_type[MAX_MP_BUSSES]; | 144 | int mp_bus_id_to_type[MAX_MP_BUSSES]; |
145 | #endif | 145 | #endif |
146 | 146 | ||
@@ -835,7 +835,7 @@ static int __init find_isa_irq_apic(int irq, int type) | |||
835 | return -1; | 835 | return -1; |
836 | } | 836 | } |
837 | 837 | ||
838 | #if defined(CONFIG_EISA) || defined(CONFIG_MCA) | 838 | #ifdef CONFIG_EISA |
839 | /* | 839 | /* |
840 | * EISA Edge/Level control register, ELCR | 840 | * EISA Edge/Level control register, ELCR |
841 | */ | 841 | */ |
@@ -872,12 +872,6 @@ static int EISA_ELCR(unsigned int irq) | |||
872 | #define default_PCI_trigger(idx) (1) | 872 | #define default_PCI_trigger(idx) (1) |
873 | #define default_PCI_polarity(idx) (1) | 873 | #define default_PCI_polarity(idx) (1) |
874 | 874 | ||
875 | /* MCA interrupts are always polarity zero level triggered, | ||
876 | * when listed as conforming in the MP table. */ | ||
877 | |||
878 | #define default_MCA_trigger(idx) (1) | ||
879 | #define default_MCA_polarity(idx) default_ISA_polarity(idx) | ||
880 | |||
881 | static int irq_polarity(int idx) | 875 | static int irq_polarity(int idx) |
882 | { | 876 | { |
883 | int bus = mp_irqs[idx].srcbus; | 877 | int bus = mp_irqs[idx].srcbus; |
@@ -935,7 +929,7 @@ static int irq_trigger(int idx) | |||
935 | trigger = default_ISA_trigger(idx); | 929 | trigger = default_ISA_trigger(idx); |
936 | else | 930 | else |
937 | trigger = default_PCI_trigger(idx); | 931 | trigger = default_PCI_trigger(idx); |
938 | #if defined(CONFIG_EISA) || defined(CONFIG_MCA) | 932 | #ifdef CONFIG_EISA |
939 | switch (mp_bus_id_to_type[bus]) { | 933 | switch (mp_bus_id_to_type[bus]) { |
940 | case MP_BUS_ISA: /* ISA pin */ | 934 | case MP_BUS_ISA: /* ISA pin */ |
941 | { | 935 | { |
@@ -952,11 +946,6 @@ static int irq_trigger(int idx) | |||
952 | /* set before the switch */ | 946 | /* set before the switch */ |
953 | break; | 947 | break; |
954 | } | 948 | } |
955 | case MP_BUS_MCA: /* MCA pin */ | ||
956 | { | ||
957 | trigger = default_MCA_trigger(idx); | ||
958 | break; | ||
959 | } | ||
960 | default: | 949 | default: |
961 | { | 950 | { |
962 | printk(KERN_WARNING "broken BIOS!!\n"); | 951 | printk(KERN_WARNING "broken BIOS!!\n"); |
diff --git a/arch/x86/kernel/mca_32.c b/arch/x86/kernel/mca_32.c deleted file mode 100644 index 7eb1e2b97827..000000000000 --- a/arch/x86/kernel/mca_32.c +++ /dev/null | |||
@@ -1,476 +0,0 @@ | |||
1 | /* | ||
2 | * Written by Martin Kolinek, February 1996 | ||
3 | * | ||
4 | * Changes: | ||
5 | * | ||
6 | * Chris Beauregard July 28th, 1996 | ||
7 | * - Fixed up integrated SCSI detection | ||
8 | * | ||
9 | * Chris Beauregard August 3rd, 1996 | ||
10 | * - Made mca_info local | ||
11 | * - Made integrated registers accessible through standard function calls | ||
12 | * - Added name field | ||
13 | * - More sanity checking | ||
14 | * | ||
15 | * Chris Beauregard August 9th, 1996 | ||
16 | * - Rewrote /proc/mca | ||
17 | * | ||
18 | * Chris Beauregard January 7th, 1997 | ||
19 | * - Added basic NMI-processing | ||
20 | * - Added more information to mca_info structure | ||
21 | * | ||
22 | * David Weinehall October 12th, 1998 | ||
23 | * - Made a lot of cleaning up in the source | ||
24 | * - Added use of save_flags / restore_flags | ||
25 | * - Added the 'driver_loaded' flag in MCA_adapter | ||
26 | * - Added an alternative implemention of ZP Gu's mca_find_unused_adapter | ||
27 | * | ||
28 | * David Weinehall March 24th, 1999 | ||
29 | * - Fixed the output of 'Driver Installed' in /proc/mca/pos | ||
30 | * - Made the Integrated Video & SCSI show up even if they have id 0000 | ||
31 | * | ||
32 | * Alexander Viro November 9th, 1999 | ||
33 | * - Switched to regular procfs methods | ||
34 | * | ||
35 | * Alfred Arnold & David Weinehall August 23rd, 2000 | ||
36 | * - Added support for Planar POS-registers | ||
37 | */ | ||
38 | |||
39 | #include <linux/module.h> | ||
40 | #include <linux/types.h> | ||
41 | #include <linux/errno.h> | ||
42 | #include <linux/kernel.h> | ||
43 | #include <linux/mca.h> | ||
44 | #include <linux/kprobes.h> | ||
45 | #include <linux/slab.h> | ||
46 | #include <asm/io.h> | ||
47 | #include <linux/proc_fs.h> | ||
48 | #include <linux/mman.h> | ||
49 | #include <linux/mm.h> | ||
50 | #include <linux/pagemap.h> | ||
51 | #include <linux/ioport.h> | ||
52 | #include <asm/uaccess.h> | ||
53 | #include <linux/init.h> | ||
54 | |||
55 | static unsigned char which_scsi; | ||
56 | |||
57 | int MCA_bus; | ||
58 | EXPORT_SYMBOL(MCA_bus); | ||
59 | |||
60 | /* | ||
61 | * Motherboard register spinlock. Untested on SMP at the moment, but | ||
62 | * are there any MCA SMP boxes? | ||
63 | * | ||
64 | * Yes - Alan | ||
65 | */ | ||
66 | static DEFINE_SPINLOCK(mca_lock); | ||
67 | |||
68 | /* Build the status info for the adapter */ | ||
69 | |||
70 | static void mca_configure_adapter_status(struct mca_device *mca_dev) | ||
71 | { | ||
72 | mca_dev->status = MCA_ADAPTER_NONE; | ||
73 | |||
74 | mca_dev->pos_id = mca_dev->pos[0] | ||
75 | + (mca_dev->pos[1] << 8); | ||
76 | |||
77 | if (!mca_dev->pos_id && mca_dev->slot < MCA_MAX_SLOT_NR) { | ||
78 | |||
79 | /* | ||
80 | * id = 0x0000 usually indicates hardware failure, | ||
81 | * however, ZP Gu (zpg@castle.net> reports that his 9556 | ||
82 | * has 0x0000 as id and everything still works. There | ||
83 | * also seem to be an adapter with id = 0x0000; the | ||
84 | * NCR Parallel Bus Memory Card. Until this is confirmed, | ||
85 | * however, this code will stay. | ||
86 | */ | ||
87 | |||
88 | mca_dev->status = MCA_ADAPTER_ERROR; | ||
89 | |||
90 | return; | ||
91 | } else if (mca_dev->pos_id != 0xffff) { | ||
92 | |||
93 | /* | ||
94 | * 0xffff usually indicates that there's no adapter, | ||
95 | * however, some integrated adapters may have 0xffff as | ||
96 | * their id and still be valid. Examples are on-board | ||
97 | * VGA of the 55sx, the integrated SCSI of the 56 & 57, | ||
98 | * and possibly also the 95 ULTIMEDIA. | ||
99 | */ | ||
100 | |||
101 | mca_dev->status = MCA_ADAPTER_NORMAL; | ||
102 | } | ||
103 | |||
104 | if ((mca_dev->pos_id == 0xffff || | ||
105 | mca_dev->pos_id == 0x0000) && mca_dev->slot >= MCA_MAX_SLOT_NR) { | ||
106 | int j; | ||
107 | |||
108 | for (j = 2; j < 8; j++) { | ||
109 | if (mca_dev->pos[j] != 0xff) { | ||
110 | mca_dev->status = MCA_ADAPTER_NORMAL; | ||
111 | break; | ||
112 | } | ||
113 | } | ||
114 | } | ||
115 | |||
116 | if (!(mca_dev->pos[2] & MCA_ENABLED)) { | ||
117 | |||
118 | /* enabled bit is in POS 2 */ | ||
119 | |||
120 | mca_dev->status = MCA_ADAPTER_DISABLED; | ||
121 | } | ||
122 | } /* mca_configure_adapter_status */ | ||
123 | |||
124 | /*--------------------------------------------------------------------*/ | ||
125 | |||
126 | static struct resource mca_standard_resources[] = { | ||
127 | { .start = 0x60, .end = 0x60, .name = "system control port B (MCA)" }, | ||
128 | { .start = 0x90, .end = 0x90, .name = "arbitration (MCA)" }, | ||
129 | { .start = 0x91, .end = 0x91, .name = "card Select Feedback (MCA)" }, | ||
130 | { .start = 0x92, .end = 0x92, .name = "system Control port A (MCA)" }, | ||
131 | { .start = 0x94, .end = 0x94, .name = "system board setup (MCA)" }, | ||
132 | { .start = 0x96, .end = 0x97, .name = "POS (MCA)" }, | ||
133 | { .start = 0x100, .end = 0x107, .name = "POS (MCA)" } | ||
134 | }; | ||
135 | |||
136 | #define MCA_STANDARD_RESOURCES ARRAY_SIZE(mca_standard_resources) | ||
137 | |||
138 | /* | ||
139 | * mca_read_and_store_pos - read the POS registers into a memory buffer | ||
140 | * @pos: a char pointer to 8 bytes, contains the POS register value on | ||
141 | * successful return | ||
142 | * | ||
143 | * Returns 1 if a card actually exists (i.e. the pos isn't | ||
144 | * all 0xff) or 0 otherwise | ||
145 | */ | ||
146 | static int mca_read_and_store_pos(unsigned char *pos) | ||
147 | { | ||
148 | int j; | ||
149 | int found = 0; | ||
150 | |||
151 | for (j = 0; j < 8; j++) { | ||
152 | pos[j] = inb_p(MCA_POS_REG(j)); | ||
153 | if (pos[j] != 0xff) { | ||
154 | /* 0xff all across means no device. 0x00 means | ||
155 | * something's broken, but a device is | ||
156 | * probably there. However, if you get 0x00 | ||
157 | * from a motherboard register it won't matter | ||
158 | * what we find. For the record, on the | ||
159 | * 57SLC, the integrated SCSI adapter has | ||
160 | * 0xffff for the adapter ID, but nonzero for | ||
161 | * other registers. */ | ||
162 | |||
163 | found = 1; | ||
164 | } | ||
165 | } | ||
166 | return found; | ||
167 | } | ||
168 | |||
169 | static unsigned char mca_pc_read_pos(struct mca_device *mca_dev, int reg) | ||
170 | { | ||
171 | unsigned char byte; | ||
172 | unsigned long flags; | ||
173 | |||
174 | if (reg < 0 || reg >= 8) | ||
175 | return 0; | ||
176 | |||
177 | spin_lock_irqsave(&mca_lock, flags); | ||
178 | if (mca_dev->pos_register) { | ||
179 | /* Disable adapter setup, enable motherboard setup */ | ||
180 | |||
181 | outb_p(0, MCA_ADAPTER_SETUP_REG); | ||
182 | outb_p(mca_dev->pos_register, MCA_MOTHERBOARD_SETUP_REG); | ||
183 | |||
184 | byte = inb_p(MCA_POS_REG(reg)); | ||
185 | outb_p(0xff, MCA_MOTHERBOARD_SETUP_REG); | ||
186 | } else { | ||
187 | |||
188 | /* Make sure motherboard setup is off */ | ||
189 | |||
190 | outb_p(0xff, MCA_MOTHERBOARD_SETUP_REG); | ||
191 | |||
192 | /* Read the appropriate register */ | ||
193 | |||
194 | outb_p(0x8|(mca_dev->slot & 0xf), MCA_ADAPTER_SETUP_REG); | ||
195 | byte = inb_p(MCA_POS_REG(reg)); | ||
196 | outb_p(0, MCA_ADAPTER_SETUP_REG); | ||
197 | } | ||
198 | spin_unlock_irqrestore(&mca_lock, flags); | ||
199 | |||
200 | mca_dev->pos[reg] = byte; | ||
201 | |||
202 | return byte; | ||
203 | } | ||
204 | |||
205 | static void mca_pc_write_pos(struct mca_device *mca_dev, int reg, | ||
206 | unsigned char byte) | ||
207 | { | ||
208 | unsigned long flags; | ||
209 | |||
210 | if (reg < 0 || reg >= 8) | ||
211 | return; | ||
212 | |||
213 | spin_lock_irqsave(&mca_lock, flags); | ||
214 | |||
215 | /* Make sure motherboard setup is off */ | ||
216 | |||
217 | outb_p(0xff, MCA_MOTHERBOARD_SETUP_REG); | ||
218 | |||
219 | /* Read in the appropriate register */ | ||
220 | |||
221 | outb_p(0x8|(mca_dev->slot&0xf), MCA_ADAPTER_SETUP_REG); | ||
222 | outb_p(byte, MCA_POS_REG(reg)); | ||
223 | outb_p(0, MCA_ADAPTER_SETUP_REG); | ||
224 | |||
225 | spin_unlock_irqrestore(&mca_lock, flags); | ||
226 | |||
227 | /* Update the global register list, while we have the byte */ | ||
228 | |||
229 | mca_dev->pos[reg] = byte; | ||
230 | |||
231 | } | ||
232 | |||
233 | /* for the primary MCA bus, we have identity transforms */ | ||
234 | static int mca_dummy_transform_irq(struct mca_device *mca_dev, int irq) | ||
235 | { | ||
236 | return irq; | ||
237 | } | ||
238 | |||
239 | static int mca_dummy_transform_ioport(struct mca_device *mca_dev, int port) | ||
240 | { | ||
241 | return port; | ||
242 | } | ||
243 | |||
244 | static void *mca_dummy_transform_memory(struct mca_device *mca_dev, void *mem) | ||
245 | { | ||
246 | return mem; | ||
247 | } | ||
248 | |||
249 | |||
250 | static int __init mca_init(void) | ||
251 | { | ||
252 | unsigned int i, j; | ||
253 | struct mca_device *mca_dev; | ||
254 | unsigned char pos[8]; | ||
255 | short mca_builtin_scsi_ports[] = {0xf7, 0xfd, 0x00}; | ||
256 | struct mca_bus *bus; | ||
257 | |||
258 | /* | ||
259 | * WARNING: Be careful when making changes here. Putting an adapter | ||
260 | * and the motherboard simultaneously into setup mode may result in | ||
261 | * damage to chips (according to The Indispensable PC Hardware Book | ||
262 | * by Hans-Peter Messmer). Also, we disable system interrupts (so | ||
263 | * that we are not disturbed in the middle of this). | ||
264 | */ | ||
265 | |||
266 | /* Make sure the MCA bus is present */ | ||
267 | |||
268 | if (mca_system_init()) { | ||
269 | printk(KERN_ERR "MCA bus system initialisation failed\n"); | ||
270 | return -ENODEV; | ||
271 | } | ||
272 | |||
273 | if (!MCA_bus) | ||
274 | return -ENODEV; | ||
275 | |||
276 | printk(KERN_INFO "Micro Channel bus detected.\n"); | ||
277 | |||
278 | /* All MCA systems have at least a primary bus */ | ||
279 | bus = mca_attach_bus(MCA_PRIMARY_BUS); | ||
280 | if (!bus) | ||
281 | goto out_nomem; | ||
282 | bus->default_dma_mask = 0xffffffffLL; | ||
283 | bus->f.mca_write_pos = mca_pc_write_pos; | ||
284 | bus->f.mca_read_pos = mca_pc_read_pos; | ||
285 | bus->f.mca_transform_irq = mca_dummy_transform_irq; | ||
286 | bus->f.mca_transform_ioport = mca_dummy_transform_ioport; | ||
287 | bus->f.mca_transform_memory = mca_dummy_transform_memory; | ||
288 | |||
289 | /* get the motherboard device */ | ||
290 | mca_dev = kzalloc(sizeof(struct mca_device), GFP_KERNEL); | ||
291 | if (unlikely(!mca_dev)) | ||
292 | goto out_nomem; | ||
293 | |||
294 | /* | ||
295 | * We do not expect many MCA interrupts during initialization, | ||
296 | * but let us be safe: | ||
297 | */ | ||
298 | spin_lock_irq(&mca_lock); | ||
299 | |||
300 | /* Make sure adapter setup is off */ | ||
301 | |||
302 | outb_p(0, MCA_ADAPTER_SETUP_REG); | ||
303 | |||
304 | /* Read motherboard POS registers */ | ||
305 | |||
306 | mca_dev->pos_register = 0x7f; | ||
307 | outb_p(mca_dev->pos_register, MCA_MOTHERBOARD_SETUP_REG); | ||
308 | mca_dev->name[0] = 0; | ||
309 | mca_read_and_store_pos(mca_dev->pos); | ||
310 | mca_configure_adapter_status(mca_dev); | ||
311 | /* fake POS and slot for a motherboard */ | ||
312 | mca_dev->pos_id = MCA_MOTHERBOARD_POS; | ||
313 | mca_dev->slot = MCA_MOTHERBOARD; | ||
314 | mca_register_device(MCA_PRIMARY_BUS, mca_dev); | ||
315 | |||
316 | mca_dev = kzalloc(sizeof(struct mca_device), GFP_ATOMIC); | ||
317 | if (unlikely(!mca_dev)) | ||
318 | goto out_unlock_nomem; | ||
319 | |||
320 | /* Put motherboard into video setup mode, read integrated video | ||
321 | * POS registers, and turn motherboard setup off. | ||
322 | */ | ||
323 | |||
324 | mca_dev->pos_register = 0xdf; | ||
325 | outb_p(mca_dev->pos_register, MCA_MOTHERBOARD_SETUP_REG); | ||
326 | mca_dev->name[0] = 0; | ||
327 | mca_read_and_store_pos(mca_dev->pos); | ||
328 | mca_configure_adapter_status(mca_dev); | ||
329 | /* fake POS and slot for the integrated video */ | ||
330 | mca_dev->pos_id = MCA_INTEGVIDEO_POS; | ||
331 | mca_dev->slot = MCA_INTEGVIDEO; | ||
332 | mca_register_device(MCA_PRIMARY_BUS, mca_dev); | ||
333 | |||
334 | /* | ||
335 | * Put motherboard into scsi setup mode, read integrated scsi | ||
336 | * POS registers, and turn motherboard setup off. | ||
337 | * | ||
338 | * It seems there are two possible SCSI registers. Martin says that | ||
339 | * for the 56,57, 0xf7 is the one, but fails on the 76. | ||
340 | * Alfredo (apena@vnet.ibm.com) says | ||
341 | * 0xfd works on his machine. We'll try both of them. I figure it's | ||
342 | * a good bet that only one could be valid at a time. This could | ||
343 | * screw up though if one is used for something else on the other | ||
344 | * machine. | ||
345 | */ | ||
346 | |||
347 | for (i = 0; (which_scsi = mca_builtin_scsi_ports[i]) != 0; i++) { | ||
348 | outb_p(which_scsi, MCA_MOTHERBOARD_SETUP_REG); | ||
349 | if (mca_read_and_store_pos(pos)) | ||
350 | break; | ||
351 | } | ||
352 | if (which_scsi) { | ||
353 | /* found a scsi card */ | ||
354 | mca_dev = kzalloc(sizeof(struct mca_device), GFP_ATOMIC); | ||
355 | if (unlikely(!mca_dev)) | ||
356 | goto out_unlock_nomem; | ||
357 | |||
358 | for (j = 0; j < 8; j++) | ||
359 | mca_dev->pos[j] = pos[j]; | ||
360 | |||
361 | mca_configure_adapter_status(mca_dev); | ||
362 | /* fake POS and slot for integrated SCSI controller */ | ||
363 | mca_dev->pos_id = MCA_INTEGSCSI_POS; | ||
364 | mca_dev->slot = MCA_INTEGSCSI; | ||
365 | mca_dev->pos_register = which_scsi; | ||
366 | mca_register_device(MCA_PRIMARY_BUS, mca_dev); | ||
367 | } | ||
368 | |||
369 | /* Turn off motherboard setup */ | ||
370 | |||
371 | outb_p(0xff, MCA_MOTHERBOARD_SETUP_REG); | ||
372 | |||
373 | /* | ||
374 | * Now loop over MCA slots: put each adapter into setup mode, and | ||
375 | * read its POS registers. Then put adapter setup off. | ||
376 | */ | ||
377 | |||
378 | for (i = 0; i < MCA_MAX_SLOT_NR; i++) { | ||
379 | outb_p(0x8|(i&0xf), MCA_ADAPTER_SETUP_REG); | ||
380 | if (!mca_read_and_store_pos(pos)) | ||
381 | continue; | ||
382 | |||
383 | mca_dev = kzalloc(sizeof(struct mca_device), GFP_ATOMIC); | ||
384 | if (unlikely(!mca_dev)) | ||
385 | goto out_unlock_nomem; | ||
386 | |||
387 | for (j = 0; j < 8; j++) | ||
388 | mca_dev->pos[j] = pos[j]; | ||
389 | |||
390 | mca_dev->driver_loaded = 0; | ||
391 | mca_dev->slot = i; | ||
392 | mca_dev->pos_register = 0; | ||
393 | mca_configure_adapter_status(mca_dev); | ||
394 | mca_register_device(MCA_PRIMARY_BUS, mca_dev); | ||
395 | } | ||
396 | outb_p(0, MCA_ADAPTER_SETUP_REG); | ||
397 | |||
398 | /* Enable interrupts and return memory start */ | ||
399 | spin_unlock_irq(&mca_lock); | ||
400 | |||
401 | for (i = 0; i < MCA_STANDARD_RESOURCES; i++) | ||
402 | request_resource(&ioport_resource, mca_standard_resources + i); | ||
403 | |||
404 | mca_do_proc_init(); | ||
405 | |||
406 | return 0; | ||
407 | |||
408 | out_unlock_nomem: | ||
409 | spin_unlock_irq(&mca_lock); | ||
410 | out_nomem: | ||
411 | printk(KERN_EMERG "Failed memory allocation in MCA setup!\n"); | ||
412 | return -ENOMEM; | ||
413 | } | ||
414 | |||
415 | subsys_initcall(mca_init); | ||
416 | |||
417 | /*--------------------------------------------------------------------*/ | ||
418 | |||
419 | static __kprobes void | ||
420 | mca_handle_nmi_device(struct mca_device *mca_dev, int check_flag) | ||
421 | { | ||
422 | int slot = mca_dev->slot; | ||
423 | |||
424 | if (slot == MCA_INTEGSCSI) { | ||
425 | printk(KERN_CRIT "NMI: caused by MCA integrated SCSI adapter (%s)\n", | ||
426 | mca_dev->name); | ||
427 | } else if (slot == MCA_INTEGVIDEO) { | ||
428 | printk(KERN_CRIT "NMI: caused by MCA integrated video adapter (%s)\n", | ||
429 | mca_dev->name); | ||
430 | } else if (slot == MCA_MOTHERBOARD) { | ||
431 | printk(KERN_CRIT "NMI: caused by motherboard (%s)\n", | ||
432 | mca_dev->name); | ||
433 | } | ||
434 | |||
435 | /* More info available in POS 6 and 7? */ | ||
436 | |||
437 | if (check_flag) { | ||
438 | unsigned char pos6, pos7; | ||
439 | |||
440 | pos6 = mca_device_read_pos(mca_dev, 6); | ||
441 | pos7 = mca_device_read_pos(mca_dev, 7); | ||
442 | |||
443 | printk(KERN_CRIT "NMI: POS 6 = 0x%x, POS 7 = 0x%x\n", pos6, pos7); | ||
444 | } | ||
445 | |||
446 | } /* mca_handle_nmi_slot */ | ||
447 | |||
448 | /*--------------------------------------------------------------------*/ | ||
449 | |||
450 | static int __kprobes mca_handle_nmi_callback(struct device *dev, void *data) | ||
451 | { | ||
452 | struct mca_device *mca_dev = to_mca_device(dev); | ||
453 | unsigned char pos5; | ||
454 | |||
455 | pos5 = mca_device_read_pos(mca_dev, 5); | ||
456 | |||
457 | if (!(pos5 & 0x80)) { | ||
458 | /* | ||
459 | * Bit 7 of POS 5 is reset when this adapter has a hardware | ||
460 | * error. Bit 7 it reset if there's error information | ||
461 | * available in POS 6 and 7. | ||
462 | */ | ||
463 | mca_handle_nmi_device(mca_dev, !(pos5 & 0x40)); | ||
464 | return 1; | ||
465 | } | ||
466 | return 0; | ||
467 | } | ||
468 | |||
469 | void __kprobes mca_handle_nmi(void) | ||
470 | { | ||
471 | /* | ||
472 | * First try - scan the various adapters and see if a specific | ||
473 | * adapter was responsible for the error. | ||
474 | */ | ||
475 | bus_for_each_dev(&mca_bus_type, NULL, NULL, mca_handle_nmi_callback); | ||
476 | } | ||
diff --git a/arch/x86/kernel/mpparse.c b/arch/x86/kernel/mpparse.c index ca470e4c92dc..b02d4dd6b8a3 100644 --- a/arch/x86/kernel/mpparse.c +++ b/arch/x86/kernel/mpparse.c | |||
@@ -97,7 +97,7 @@ static void __init MP_bus_info(struct mpc_bus *m) | |||
97 | 97 | ||
98 | set_bit(m->busid, mp_bus_not_pci); | 98 | set_bit(m->busid, mp_bus_not_pci); |
99 | if (strncmp(str, BUSTYPE_ISA, sizeof(BUSTYPE_ISA) - 1) == 0) { | 99 | if (strncmp(str, BUSTYPE_ISA, sizeof(BUSTYPE_ISA) - 1) == 0) { |
100 | #if defined(CONFIG_EISA) || defined(CONFIG_MCA) | 100 | #ifdef CONFIG_EISA |
101 | mp_bus_id_to_type[m->busid] = MP_BUS_ISA; | 101 | mp_bus_id_to_type[m->busid] = MP_BUS_ISA; |
102 | #endif | 102 | #endif |
103 | } else if (strncmp(str, BUSTYPE_PCI, sizeof(BUSTYPE_PCI) - 1) == 0) { | 103 | } else if (strncmp(str, BUSTYPE_PCI, sizeof(BUSTYPE_PCI) - 1) == 0) { |
@@ -105,12 +105,10 @@ static void __init MP_bus_info(struct mpc_bus *m) | |||
105 | x86_init.mpparse.mpc_oem_pci_bus(m); | 105 | x86_init.mpparse.mpc_oem_pci_bus(m); |
106 | 106 | ||
107 | clear_bit(m->busid, mp_bus_not_pci); | 107 | clear_bit(m->busid, mp_bus_not_pci); |
108 | #if defined(CONFIG_EISA) || defined(CONFIG_MCA) | 108 | #ifdef CONFIG_EISA |
109 | mp_bus_id_to_type[m->busid] = MP_BUS_PCI; | 109 | mp_bus_id_to_type[m->busid] = MP_BUS_PCI; |
110 | } else if (strncmp(str, BUSTYPE_EISA, sizeof(BUSTYPE_EISA) - 1) == 0) { | 110 | } else if (strncmp(str, BUSTYPE_EISA, sizeof(BUSTYPE_EISA) - 1) == 0) { |
111 | mp_bus_id_to_type[m->busid] = MP_BUS_EISA; | 111 | mp_bus_id_to_type[m->busid] = MP_BUS_EISA; |
112 | } else if (strncmp(str, BUSTYPE_MCA, sizeof(BUSTYPE_MCA) - 1) == 0) { | ||
113 | mp_bus_id_to_type[m->busid] = MP_BUS_MCA; | ||
114 | #endif | 112 | #endif |
115 | } else | 113 | } else |
116 | printk(KERN_WARNING "Unknown bustype %s - ignoring\n", str); | 114 | printk(KERN_WARNING "Unknown bustype %s - ignoring\n", str); |
@@ -368,9 +366,6 @@ static void __init construct_ioapic_table(int mpc_default_type) | |||
368 | case 3: | 366 | case 3: |
369 | memcpy(bus.bustype, "EISA ", 6); | 367 | memcpy(bus.bustype, "EISA ", 6); |
370 | break; | 368 | break; |
371 | case 4: | ||
372 | case 7: | ||
373 | memcpy(bus.bustype, "MCA ", 6); | ||
374 | } | 369 | } |
375 | MP_bus_info(&bus); | 370 | MP_bus_info(&bus); |
376 | if (mpc_default_type > 4) { | 371 | if (mpc_default_type > 4) { |
@@ -623,7 +618,7 @@ void __init default_find_smp_config(void) | |||
623 | return; | 618 | return; |
624 | /* | 619 | /* |
625 | * If it is an SMP machine we should know now, unless the | 620 | * If it is an SMP machine we should know now, unless the |
626 | * configuration is in an EISA/MCA bus machine with an | 621 | * configuration is in an EISA bus machine with an |
627 | * extended bios data area. | 622 | * extended bios data area. |
628 | * | 623 | * |
629 | * there is a real-mode segmented pointer pointing to the | 624 | * there is a real-mode segmented pointer pointing to the |
diff --git a/arch/x86/kernel/nmi.c b/arch/x86/kernel/nmi.c index bffdfd48c1f2..90875279ef3d 100644 --- a/arch/x86/kernel/nmi.c +++ b/arch/x86/kernel/nmi.c | |||
@@ -19,8 +19,6 @@ | |||
19 | #include <linux/slab.h> | 19 | #include <linux/slab.h> |
20 | #include <linux/export.h> | 20 | #include <linux/export.h> |
21 | 21 | ||
22 | #include <linux/mca.h> | ||
23 | |||
24 | #if defined(CONFIG_EDAC) | 22 | #if defined(CONFIG_EDAC) |
25 | #include <linux/edac.h> | 23 | #include <linux/edac.h> |
26 | #endif | 24 | #endif |
@@ -247,16 +245,6 @@ unknown_nmi_error(unsigned char reason, struct pt_regs *regs) | |||
247 | 245 | ||
248 | __this_cpu_add(nmi_stats.unknown, 1); | 246 | __this_cpu_add(nmi_stats.unknown, 1); |
249 | 247 | ||
250 | #ifdef CONFIG_MCA | ||
251 | /* | ||
252 | * Might actually be able to figure out what the guilty party | ||
253 | * is: | ||
254 | */ | ||
255 | if (MCA_bus) { | ||
256 | mca_handle_nmi(); | ||
257 | return; | ||
258 | } | ||
259 | #endif | ||
260 | pr_emerg("Uhhuh. NMI received for unknown reason %02x on CPU %d.\n", | 248 | pr_emerg("Uhhuh. NMI received for unknown reason %02x on CPU %d.\n", |
261 | reason, smp_processor_id()); | 249 | reason, smp_processor_id()); |
262 | 250 | ||
diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c index 9b4204e06665..366c688d619e 100644 --- a/arch/x86/kernel/setup.c +++ b/arch/x86/kernel/setup.c | |||
@@ -34,7 +34,6 @@ | |||
34 | #include <linux/memblock.h> | 34 | #include <linux/memblock.h> |
35 | #include <linux/seq_file.h> | 35 | #include <linux/seq_file.h> |
36 | #include <linux/console.h> | 36 | #include <linux/console.h> |
37 | #include <linux/mca.h> | ||
38 | #include <linux/root_dev.h> | 37 | #include <linux/root_dev.h> |
39 | #include <linux/highmem.h> | 38 | #include <linux/highmem.h> |
40 | #include <linux/module.h> | 39 | #include <linux/module.h> |
@@ -179,12 +178,6 @@ struct cpuinfo_x86 new_cpu_data __cpuinitdata = {0, 0, 0, 0, -1, 1, 0, 0, -1}; | |||
179 | /* common cpu data for all cpus */ | 178 | /* common cpu data for all cpus */ |
180 | struct cpuinfo_x86 boot_cpu_data __read_mostly = {0, 0, 0, 0, -1, 1, 0, 0, -1}; | 179 | struct cpuinfo_x86 boot_cpu_data __read_mostly = {0, 0, 0, 0, -1, 1, 0, 0, -1}; |
181 | EXPORT_SYMBOL(boot_cpu_data); | 180 | EXPORT_SYMBOL(boot_cpu_data); |
182 | static void set_mca_bus(int x) | ||
183 | { | ||
184 | #ifdef CONFIG_MCA | ||
185 | MCA_bus = x; | ||
186 | #endif | ||
187 | } | ||
188 | 181 | ||
189 | unsigned int def_to_bigsmp; | 182 | unsigned int def_to_bigsmp; |
190 | 183 | ||
@@ -716,7 +709,6 @@ void __init setup_arch(char **cmdline_p) | |||
716 | apm_info.bios = boot_params.apm_bios_info; | 709 | apm_info.bios = boot_params.apm_bios_info; |
717 | ist_info = boot_params.ist_info; | 710 | ist_info = boot_params.ist_info; |
718 | if (boot_params.sys_desc_table.length != 0) { | 711 | if (boot_params.sys_desc_table.length != 0) { |
719 | set_mca_bus(boot_params.sys_desc_table.table[3] & 0x2); | ||
720 | machine_id = boot_params.sys_desc_table.table[0]; | 712 | machine_id = boot_params.sys_desc_table.table[0]; |
721 | machine_submodel_id = boot_params.sys_desc_table.table[1]; | 713 | machine_submodel_id = boot_params.sys_desc_table.table[1]; |
722 | BIOS_revision = boot_params.sys_desc_table.table[2]; | 714 | BIOS_revision = boot_params.sys_desc_table.table[2]; |
diff --git a/arch/x86/kernel/time.c b/arch/x86/kernel/time.c index c6eba2b42673..24d3c91e9812 100644 --- a/arch/x86/kernel/time.c +++ b/arch/x86/kernel/time.c | |||
@@ -14,7 +14,6 @@ | |||
14 | #include <linux/i8253.h> | 14 | #include <linux/i8253.h> |
15 | #include <linux/time.h> | 15 | #include <linux/time.h> |
16 | #include <linux/export.h> | 16 | #include <linux/export.h> |
17 | #include <linux/mca.h> | ||
18 | 17 | ||
19 | #include <asm/vsyscall.h> | 18 | #include <asm/vsyscall.h> |
20 | #include <asm/x86_init.h> | 19 | #include <asm/x86_init.h> |
@@ -58,11 +57,6 @@ EXPORT_SYMBOL(profile_pc); | |||
58 | static irqreturn_t timer_interrupt(int irq, void *dev_id) | 57 | static irqreturn_t timer_interrupt(int irq, void *dev_id) |
59 | { | 58 | { |
60 | global_clock_event->event_handler(global_clock_event); | 59 | global_clock_event->event_handler(global_clock_event); |
61 | |||
62 | /* MCA bus quirk: Acknowledge irq0 by setting bit 7 in port 0x61 */ | ||
63 | if (MCA_bus) | ||
64 | outb_p(inb_p(0x61)| 0x80, 0x61); | ||
65 | |||
66 | return IRQ_HANDLED; | 60 | return IRQ_HANDLED; |
67 | } | 61 | } |
68 | 62 | ||
diff --git a/arch/x86/kernel/traps.c b/arch/x86/kernel/traps.c index 92d5756d85fc..ff08457a025d 100644 --- a/arch/x86/kernel/traps.c +++ b/arch/x86/kernel/traps.c | |||
@@ -37,10 +37,6 @@ | |||
37 | #include <linux/eisa.h> | 37 | #include <linux/eisa.h> |
38 | #endif | 38 | #endif |
39 | 39 | ||
40 | #ifdef CONFIG_MCA | ||
41 | #include <linux/mca.h> | ||
42 | #endif | ||
43 | |||
44 | #if defined(CONFIG_EDAC) | 40 | #if defined(CONFIG_EDAC) |
45 | #include <linux/edac.h> | 41 | #include <linux/edac.h> |
46 | #endif | 42 | #endif |