Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Written by: Garry Forsgren, Unisys Corporation | |
3 | * Natalie Protasevich, Unisys Corporation | |
4 | * This file contains the code to configure and interface | |
5 | * with Unisys ES7000 series hardware system manager. | |
6 | * | |
7 | * Copyright (c) 2003 Unisys Corporation. All Rights Reserved. | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify it | |
10 | * under the terms of version 2 of the GNU General Public License as | |
11 | * published by the Free Software Foundation. | |
12 | * | |
13 | * This program is distributed in the hope that it would be useful, but | |
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License along | |
18 | * with this program; if not, write the Free Software Foundation, Inc., 59 | |
19 | * Temple Place - Suite 330, Boston MA 02111-1307, USA. | |
20 | * | |
21 | * Contact information: Unisys Corporation, Township Line & Union Meeting | |
22 | * Roads-A, Unisys Way, Blue Bell, Pennsylvania, 19424, or: | |
23 | * | |
24 | * http://www.unisys.com | |
25 | */ | |
26 | ||
27 | #include <linux/module.h> | |
28 | #include <linux/types.h> | |
29 | #include <linux/kernel.h> | |
30 | #include <linux/smp.h> | |
31 | #include <linux/string.h> | |
32 | #include <linux/spinlock.h> | |
33 | #include <linux/errno.h> | |
34 | #include <linux/notifier.h> | |
35 | #include <linux/reboot.h> | |
36 | #include <linux/init.h> | |
37 | #include <linux/acpi.h> | |
38 | #include <asm/io.h> | |
39 | #include <asm/nmi.h> | |
40 | #include <asm/smp.h> | |
b5fe363b | 41 | #include <asm/atomic.h> |
1da177e4 | 42 | #include <asm/apicdef.h> |
071922c0 | 43 | #include <mach_mpparse.h> |
54ac14a8 | 44 | #include <asm/genapic.h> |
569712b2 | 45 | #include <asm/setup.h> |
1da177e4 | 46 | |
1625324d YL |
47 | /* |
48 | * ES7000 chipsets | |
49 | */ | |
50 | ||
51 | #define NON_UNISYS 0 | |
52 | #define ES7000_CLASSIC 1 | |
53 | #define ES7000_ZORRO 2 | |
54 | ||
55 | ||
56 | #define MIP_REG 1 | |
57 | #define MIP_PSAI_REG 4 | |
58 | ||
59 | #define MIP_BUSY 1 | |
60 | #define MIP_SPIN 0xf0000 | |
61 | #define MIP_VALID 0x0100000000000000ULL | |
62 | #define MIP_PORT(VALUE) ((VALUE >> 32) & 0xffff) | |
63 | ||
64 | #define MIP_RD_LO(VALUE) (VALUE & 0xffffffff) | |
65 | ||
66 | struct mip_reg_info { | |
67 | unsigned long long mip_info; | |
68 | unsigned long long delivery_info; | |
69 | unsigned long long host_reg; | |
70 | unsigned long long mip_reg; | |
71 | }; | |
72 | ||
73 | struct part_info { | |
74 | unsigned char type; | |
75 | unsigned char length; | |
76 | unsigned char part_id; | |
77 | unsigned char apic_mode; | |
78 | unsigned long snum; | |
79 | char ptype[16]; | |
80 | char sname[64]; | |
81 | char pname[64]; | |
82 | }; | |
83 | ||
84 | struct psai { | |
85 | unsigned long long entry_type; | |
86 | unsigned long long addr; | |
87 | unsigned long long bep_addr; | |
88 | }; | |
89 | ||
90 | struct es7000_mem_info { | |
91 | unsigned char type; | |
92 | unsigned char length; | |
93 | unsigned char resv[6]; | |
94 | unsigned long long start; | |
95 | unsigned long long size; | |
96 | }; | |
97 | ||
98 | struct es7000_oem_table { | |
99 | unsigned long long hdr; | |
100 | struct mip_reg_info mip; | |
101 | struct part_info pif; | |
102 | struct es7000_mem_info shm; | |
103 | struct psai psai; | |
104 | }; | |
105 | ||
106 | #ifdef CONFIG_ACPI | |
107 | ||
108 | struct oem_table { | |
109 | struct acpi_table_header Header; | |
110 | u32 OEMTableAddr; | |
111 | u32 OEMTableSize; | |
112 | }; | |
113 | ||
114 | extern int find_unisys_acpi_oem_table(unsigned long *oem_addr); | |
a73aaedd | 115 | extern void unmap_unisys_acpi_oem_table(unsigned long oem_addr); |
1625324d YL |
116 | #endif |
117 | ||
118 | struct mip_reg { | |
119 | unsigned long long off_0; | |
120 | unsigned long long off_8; | |
121 | unsigned long long off_10; | |
122 | unsigned long long off_18; | |
123 | unsigned long long off_20; | |
124 | unsigned long long off_28; | |
125 | unsigned long long off_30; | |
126 | unsigned long long off_38; | |
127 | }; | |
128 | ||
129 | #define MIP_SW_APIC 0x1020b | |
130 | #define MIP_FUNC(VALUE) (VALUE & 0xff) | |
131 | ||
1da177e4 LT |
132 | /* |
133 | * ES7000 Globals | |
134 | */ | |
135 | ||
fb7ae26d AB |
136 | static volatile unsigned long *psai = NULL; |
137 | static struct mip_reg *mip_reg; | |
138 | static struct mip_reg *host_reg; | |
139 | static int mip_port; | |
140 | static unsigned long mip_addr, host_addr; | |
1da177e4 | 141 | |
32c50612 AS |
142 | int es7000_plat; |
143 | ||
1da177e4 LT |
144 | /* |
145 | * GSI override for ES7000 platforms. | |
146 | */ | |
147 | ||
148 | static unsigned int base; | |
149 | ||
150 | static int | |
151 | es7000_rename_gsi(int ioapic, int gsi) | |
152 | { | |
9338316c NP |
153 | if (es7000_plat == ES7000_ZORRO) |
154 | return gsi; | |
155 | ||
1da177e4 LT |
156 | if (!base) { |
157 | int i; | |
158 | for (i = 0; i < nr_ioapics; i++) | |
159 | base += nr_ioapic_registers[i]; | |
160 | } | |
161 | ||
c7e7964c | 162 | if (!ioapic && (gsi < 16)) |
1da177e4 LT |
163 | gsi += base; |
164 | return gsi; | |
165 | } | |
166 | ||
569712b2 YL |
167 | static int wakeup_secondary_cpu_via_mip(int cpu, unsigned long eip) |
168 | { | |
169 | unsigned long vect = 0, psaival = 0; | |
170 | ||
171 | if (psai == NULL) | |
172 | return -1; | |
173 | ||
174 | vect = ((unsigned long)__pa(eip)/0x1000) << 16; | |
175 | psaival = (0x1000000 | vect | cpu); | |
176 | ||
177 | while (*psai & 0x1000000) | |
178 | ; | |
179 | ||
180 | *psai = psaival; | |
181 | ||
182 | return 0; | |
183 | } | |
54ac14a8 | 184 | |
b5fe363b YL |
185 | static void noop_wait_for_deassert(atomic_t *deassert_not_used) |
186 | { | |
187 | } | |
188 | ||
54ac14a8 YL |
189 | static int __init es7000_update_genapic(void) |
190 | { | |
c8d46cf0 | 191 | apic->wakeup_cpu = wakeup_secondary_cpu_via_mip; |
54ac14a8 | 192 | |
b5fe363b YL |
193 | /* MPENTIUMIII */ |
194 | if (boot_cpu_data.x86 == 6 && | |
195 | (boot_cpu_data.x86_model >= 7 || boot_cpu_data.x86_model <= 11)) { | |
196 | es7000_update_genapic_to_cluster(); | |
c8d46cf0 IM |
197 | apic->wait_for_init_deassert = noop_wait_for_deassert; |
198 | apic->wakeup_cpu = wakeup_secondary_cpu_via_mip; | |
b5fe363b YL |
199 | } |
200 | ||
54ac14a8 YL |
201 | return 0; |
202 | } | |
569712b2 | 203 | |
56f1d5d5 | 204 | void __init |
9338316c | 205 | setup_unisys(void) |
56f1d5d5 NP |
206 | { |
207 | /* | |
208 | * Determine the generation of the ES7000 currently running. | |
209 | * | |
210 | * es7000_plat = 1 if the machine is a 5xx ES7000 box | |
211 | * es7000_plat = 2 if the machine is a x86_64 ES7000 box | |
212 | * | |
213 | */ | |
214 | if (!(boot_cpu_data.x86 <= 15 && boot_cpu_data.x86_model <= 2)) | |
9338316c | 215 | es7000_plat = ES7000_ZORRO; |
56f1d5d5 | 216 | else |
9338316c | 217 | es7000_plat = ES7000_CLASSIC; |
56f1d5d5 | 218 | ioapic_renumber_irq = es7000_rename_gsi; |
54ac14a8 | 219 | |
54ac14a8 | 220 | x86_quirks->update_genapic = es7000_update_genapic; |
56f1d5d5 NP |
221 | } |
222 | ||
1da177e4 LT |
223 | /* |
224 | * Parse the OEM Table | |
225 | */ | |
226 | ||
227 | int __init | |
56f1d5d5 | 228 | parse_unisys_oem (char *oemptr) |
1da177e4 LT |
229 | { |
230 | int i; | |
231 | int success = 0; | |
232 | unsigned char type, size; | |
233 | unsigned long val; | |
234 | char *tp = NULL; | |
235 | struct psai *psaip = NULL; | |
236 | struct mip_reg_info *mi; | |
237 | struct mip_reg *host, *mip; | |
238 | ||
239 | tp = oemptr; | |
240 | ||
241 | tp += 8; | |
242 | ||
56f1d5d5 | 243 | for (i=0; i <= 6; i++) { |
1da177e4 LT |
244 | type = *tp++; |
245 | size = *tp++; | |
246 | tp -= 2; | |
247 | switch (type) { | |
248 | case MIP_REG: | |
249 | mi = (struct mip_reg_info *)tp; | |
250 | val = MIP_RD_LO(mi->host_reg); | |
251 | host_addr = val; | |
252 | host = (struct mip_reg *)val; | |
253 | host_reg = __va(host); | |
254 | val = MIP_RD_LO(mi->mip_reg); | |
255 | mip_port = MIP_PORT(mi->mip_info); | |
256 | mip_addr = val; | |
257 | mip = (struct mip_reg *)val; | |
258 | mip_reg = __va(mip); | |
5171c304 TG |
259 | pr_debug("es7000_mipcfg: host_reg = 0x%lx \n", |
260 | (unsigned long)host_reg); | |
261 | pr_debug("es7000_mipcfg: mip_reg = 0x%lx \n", | |
262 | (unsigned long)mip_reg); | |
1da177e4 LT |
263 | success++; |
264 | break; | |
265 | case MIP_PSAI_REG: | |
266 | psaip = (struct psai *)tp; | |
267 | if (tp != NULL) { | |
268 | if (psaip->addr) | |
269 | psai = __va(psaip->addr); | |
270 | else | |
271 | psai = NULL; | |
272 | success++; | |
273 | } | |
274 | break; | |
275 | default: | |
276 | break; | |
277 | } | |
1da177e4 LT |
278 | tp += size; |
279 | } | |
280 | ||
281 | if (success < 2) { | |
9338316c | 282 | es7000_plat = NON_UNISYS; |
56f1d5d5 NP |
283 | } else |
284 | setup_unisys(); | |
1da177e4 LT |
285 | return es7000_plat; |
286 | } | |
287 | ||
e5428ede | 288 | #ifdef CONFIG_ACPI |
a73aaedd YL |
289 | static unsigned long oem_addrX; |
290 | static unsigned long oem_size; | |
291 | int __init find_unisys_acpi_oem_table(unsigned long *oem_addr) | |
1da177e4 | 292 | { |
ceb6c468 AS |
293 | struct acpi_table_header *header = NULL; |
294 | int i = 0; | |
a73aaedd | 295 | |
d3c6aa1e | 296 | while (ACPI_SUCCESS(acpi_get_table("OEM1", i++, &header))) { |
ceb6c468 AS |
297 | if (!memcmp((char *) &header->oem_id, "UNISYS", 6)) { |
298 | struct oem_table *t = (struct oem_table *)header; | |
a73aaedd YL |
299 | |
300 | oem_addrX = t->OEMTableAddr; | |
301 | oem_size = t->OEMTableSize; | |
a73aaedd YL |
302 | |
303 | *oem_addr = (unsigned long)__acpi_map_table(oem_addrX, | |
304 | oem_size); | |
ceb6c468 | 305 | return 0; |
1da177e4 LT |
306 | } |
307 | } | |
1da177e4 LT |
308 | return -1; |
309 | } | |
a73aaedd YL |
310 | |
311 | void __init unmap_unisys_acpi_oem_table(unsigned long oem_addr) | |
312 | { | |
a73aaedd | 313 | } |
e5428ede | 314 | #endif |
1da177e4 LT |
315 | |
316 | static void | |
317 | es7000_spin(int n) | |
318 | { | |
319 | int i = 0; | |
320 | ||
321 | while (i++ < n) | |
322 | rep_nop(); | |
323 | } | |
324 | ||
325 | static int __init | |
326 | es7000_mip_write(struct mip_reg *mip_reg) | |
327 | { | |
328 | int status = 0; | |
329 | int spin; | |
330 | ||
331 | spin = MIP_SPIN; | |
332 | while (((unsigned long long)host_reg->off_38 & | |
333 | (unsigned long long)MIP_VALID) != 0) { | |
334 | if (--spin <= 0) { | |
335 | printk("es7000_mip_write: Timeout waiting for Host Valid Flag"); | |
336 | return -1; | |
337 | } | |
338 | es7000_spin(MIP_SPIN); | |
339 | } | |
340 | ||
341 | memcpy(host_reg, mip_reg, sizeof(struct mip_reg)); | |
342 | outb(1, mip_port); | |
343 | ||
344 | spin = MIP_SPIN; | |
345 | ||
346 | while (((unsigned long long)mip_reg->off_38 & | |
347 | (unsigned long long)MIP_VALID) == 0) { | |
348 | if (--spin <= 0) { | |
349 | printk("es7000_mip_write: Timeout waiting for MIP Valid Flag"); | |
350 | return -1; | |
351 | } | |
352 | es7000_spin(MIP_SPIN); | |
353 | } | |
354 | ||
355 | status = ((unsigned long long)mip_reg->off_0 & | |
356 | (unsigned long long)0xffff0000000000ULL) >> 48; | |
357 | mip_reg->off_38 = ((unsigned long long)mip_reg->off_38 & | |
358 | (unsigned long long)~MIP_VALID); | |
359 | return status; | |
360 | } | |
361 | ||
b0b20e5a | 362 | void __init es7000_enable_apic_mode(void) |
1da177e4 | 363 | { |
b0b20e5a IM |
364 | struct mip_reg es7000_mip_reg; |
365 | int mip_status; | |
366 | ||
367 | if (!es7000_plat) | |
1da177e4 | 368 | return; |
b0b20e5a IM |
369 | |
370 | printk("ES7000: Enabling APIC mode.\n"); | |
371 | memset(&es7000_mip_reg, 0, sizeof(struct mip_reg)); | |
372 | es7000_mip_reg.off_0 = MIP_SW_APIC; | |
373 | es7000_mip_reg.off_38 = MIP_VALID; | |
374 | ||
375 | while ((mip_status = es7000_mip_write(&es7000_mip_reg)) != 0) { | |
376 | printk("es7000_enable_apic_mode: command failed, status = %x\n", | |
377 | mip_status); | |
1da177e4 LT |
378 | } |
379 | } |