Merge branch 'fix/opl3sa2-suspend' into topic/isa-misc
[linux-2.6] / arch / x86 / kernel / es7000_32.c
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>
41 #include <asm/atomic.h>
42 #include <asm/apicdef.h>
43 #include <mach_mpparse.h>
44 #include <asm/genapic.h>
45 #include <asm/setup.h>
46
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);
115 extern void unmap_unisys_acpi_oem_table(unsigned long oem_addr);
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
132 /*
133  * ES7000 Globals
134  */
135
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;
141
142 int es7000_plat;
143
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 {
153         if (es7000_plat == ES7000_ZORRO)
154                 return gsi;
155
156         if (!base) {
157                 int i;
158                 for (i = 0; i < nr_ioapics; i++)
159                         base += nr_ioapic_registers[i];
160         }
161
162         if (!ioapic && (gsi < 16))
163                 gsi += base;
164         return gsi;
165 }
166
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 }
184
185 static void noop_wait_for_deassert(atomic_t *deassert_not_used)
186 {
187 }
188
189 static int __init es7000_update_genapic(void)
190 {
191         genapic->wakeup_cpu = wakeup_secondary_cpu_via_mip;
192
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();
197                 genapic->wait_for_init_deassert = noop_wait_for_deassert;
198                 genapic->wakeup_cpu = wakeup_secondary_cpu_via_mip;
199         }
200
201         return 0;
202 }
203
204 void __init
205 setup_unisys(void)
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))
215                 es7000_plat = ES7000_ZORRO;
216         else
217                 es7000_plat = ES7000_CLASSIC;
218         ioapic_renumber_irq = es7000_rename_gsi;
219
220         x86_quirks->update_genapic = es7000_update_genapic;
221 }
222
223 /*
224  * Parse the OEM Table
225  */
226
227 int __init
228 parse_unisys_oem (char *oemptr)
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
243         for (i=0; i <= 6; i++) {
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);
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);
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                 }
278                 tp += size;
279         }
280
281         if (success < 2) {
282                 es7000_plat = NON_UNISYS;
283         } else
284                 setup_unisys();
285         return es7000_plat;
286 }
287
288 #ifdef CONFIG_ACPI
289 static unsigned long oem_addrX;
290 static unsigned long oem_size;
291 int __init find_unisys_acpi_oem_table(unsigned long *oem_addr)
292 {
293         struct acpi_table_header *header = NULL;
294         int i = 0;
295
296         while (ACPI_SUCCESS(acpi_get_table("OEM1", i++, &header))) {
297                 if (!memcmp((char *) &header->oem_id, "UNISYS", 6)) {
298                         struct oem_table *t = (struct oem_table *)header;
299
300                         oem_addrX = t->OEMTableAddr;
301                         oem_size = t->OEMTableSize;
302
303                         *oem_addr = (unsigned long)__acpi_map_table(oem_addrX,
304                                                                     oem_size);
305                         return 0;
306                 }
307         }
308         return -1;
309 }
310
311 void __init unmap_unisys_acpi_oem_table(unsigned long oem_addr)
312 {
313 }
314 #endif
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
362 void __init
363 es7000_sw_apic(void)
364 {
365         if (es7000_plat) {
366                 int mip_status;
367                 struct mip_reg es7000_mip_reg;
368
369                 printk("ES7000: Enabling APIC mode.\n");
370                 memset(&es7000_mip_reg, 0, sizeof(struct mip_reg));
371                 es7000_mip_reg.off_0 = MIP_SW_APIC;
372                 es7000_mip_reg.off_38 = (MIP_VALID);
373                 while ((mip_status = es7000_mip_write(&es7000_mip_reg)) != 0)
374                         printk("es7000_sw_apic: command failed, status = %x\n",
375                                 mip_status);
376                 return;
377         }
378 }