es7000_32.c 18 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * Written by: Garry Forsgren, Unisys Corporation
 *             Natalie Protasevich, Unisys Corporation
 * This file contains the code to configure and interface
 * with Unisys ES7000 series hardware system manager.
 *
 * Copyright (c) 2003 Unisys Corporation.  All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write the Free Software Foundation, Inc., 59
 * Temple Place - Suite 330, Boston MA 02111-1307, USA.
 *
 * Contact information: Unisys Corporation, Township Line & Union Meeting
 * Roads-A, Unisys Way, Blue Bell, Pennsylvania, 19424, or:
 *
 * http://www.unisys.com
 */

Ingo Molnar's avatar
Ingo Molnar committed
27 28 29 30
#include <linux/notifier.h>
#include <linux/spinlock.h>
#include <linux/cpumask.h>
#include <linux/threads.h>
Linus Torvalds's avatar
Linus Torvalds committed
31
#include <linux/kernel.h>
Ingo Molnar's avatar
Ingo Molnar committed
32 33
#include <linux/module.h>
#include <linux/reboot.h>
Linus Torvalds's avatar
Linus Torvalds committed
34
#include <linux/string.h>
Ingo Molnar's avatar
Ingo Molnar committed
35
#include <linux/types.h>
Linus Torvalds's avatar
Linus Torvalds committed
36 37
#include <linux/errno.h>
#include <linux/acpi.h>
Ingo Molnar's avatar
Ingo Molnar committed
38 39 40
#include <linux/init.h>
#include <linux/smp.h>

Linus Torvalds's avatar
Linus Torvalds committed
41
#include <asm/apicdef.h>
Ingo Molnar's avatar
Ingo Molnar committed
42 43 44
#include <asm/atomic.h>
#include <asm/fixmap.h>
#include <asm/mpspec.h>
45
#include <asm/setup.h>
Ingo Molnar's avatar
Ingo Molnar committed
46 47 48 49 50
#include <asm/apic.h>
#include <asm/ipi.h>
#include <asm/nmi.h>
#include <asm/smp.h>
#include <asm/io.h>
Linus Torvalds's avatar
Linus Torvalds committed
51

52 53 54 55
/*
 * ES7000 chipsets
 */

Ingo Molnar's avatar
Ingo Molnar committed
56 57 58
#define NON_UNISYS			0
#define ES7000_CLASSIC			1
#define ES7000_ZORRO			2
59

Ingo Molnar's avatar
Ingo Molnar committed
60 61
#define	MIP_REG				1
#define	MIP_PSAI_REG			4
62

Ingo Molnar's avatar
Ingo Molnar committed
63 64 65
#define	MIP_BUSY			1
#define	MIP_SPIN			0xf0000
#define	MIP_VALID			0x0100000000000000ULL
66

Ingo Molnar's avatar
Ingo Molnar committed
67
#define	MIP_PORT(val)			((val >> 32) & 0xffff)
68

Ingo Molnar's avatar
Ingo Molnar committed
69
#define	MIP_RD_LO(val)			(val & 0xffffffff)
70 71

struct mip_reg_info {
Ingo Molnar's avatar
Ingo Molnar committed
72 73 74 75
	unsigned long long		mip_info;
	unsigned long long		delivery_info;
	unsigned long long		host_reg;
	unsigned long long		mip_reg;
76 77 78
};

struct part_info {
Ingo Molnar's avatar
Ingo Molnar committed
79 80 81 82 83 84 85 86
	unsigned char			type;
	unsigned char			length;
	unsigned char			part_id;
	unsigned char			apic_mode;
	unsigned long			snum;
	char				ptype[16];
	char				sname[64];
	char				pname[64];
87 88 89
};

struct psai {
Ingo Molnar's avatar
Ingo Molnar committed
90 91 92
	unsigned long long		entry_type;
	unsigned long long		addr;
	unsigned long long		bep_addr;
93 94 95
};

struct es7000_mem_info {
Ingo Molnar's avatar
Ingo Molnar committed
96 97 98 99 100
	unsigned char			type;
	unsigned char			length;
	unsigned char			resv[6];
	unsigned long long		start;
	unsigned long long		size;
101 102 103
};

struct es7000_oem_table {
Ingo Molnar's avatar
Ingo Molnar committed
104 105 106 107 108
	unsigned long long		hdr;
	struct mip_reg_info		mip;
	struct part_info		pif;
	struct es7000_mem_info		shm;
	struct psai			psai;
109 110 111 112 113
};

#ifdef CONFIG_ACPI

struct oem_table {
Ingo Molnar's avatar
Ingo Molnar committed
114 115 116
	struct acpi_table_header	Header;
	u32				OEMTableAddr;
	u32				OEMTableSize;
117 118 119
};

extern int find_unisys_acpi_oem_table(unsigned long *oem_addr);
120
extern void unmap_unisys_acpi_oem_table(unsigned long oem_addr);
121 122 123
#endif

struct mip_reg {
Ingo Molnar's avatar
Ingo Molnar committed
124 125 126 127 128 129 130 131
	unsigned long long		off_0x00;
	unsigned long long		off_0x08;
	unsigned long long		off_0x10;
	unsigned long long		off_0x18;
	unsigned long long		off_0x20;
	unsigned long long		off_0x28;
	unsigned long long		off_0x30;
	unsigned long long		off_0x38;
132 133
};

Ingo Molnar's avatar
Ingo Molnar committed
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
#define	MIP_SW_APIC			0x1020b
#define	MIP_FUNC(VALUE)			(VALUE & 0xff)

#define APIC_DFR_VALUE_CLUSTER		(APIC_DFR_CLUSTER)
#define INT_DELIVERY_MODE_CLUSTER	(dest_LowestPrio)
#define INT_DEST_MODE_CLUSTER		(1) /* logical delivery broadcast to all procs */

#define APIC_DFR_VALUE			(APIC_DFR_FLAT)

extern void es7000_enable_apic_mode(void);
extern int parse_unisys_oem (char *oemptr);
extern int find_unisys_acpi_oem_table(unsigned long *oem_addr);
extern void unmap_unisys_acpi_oem_table(unsigned long oem_addr);
extern void setup_unisys(void);

Linus Torvalds's avatar
Linus Torvalds committed
149 150 151 152
/*
 * ES7000 Globals
 */

Ingo Molnar's avatar
Ingo Molnar committed
153 154 155 156 157
static volatile unsigned long		*psai = NULL;
static struct mip_reg			*mip_reg;
static struct mip_reg			*host_reg;
static int 				mip_port;
static unsigned long			mip_addr, host_addr;
Linus Torvalds's avatar
Linus Torvalds committed
158

Ingo Molnar's avatar
Ingo Molnar committed
159
int					es7000_plat;
160

Linus Torvalds's avatar
Linus Torvalds committed
161 162 163 164
/*
 * GSI override for ES7000 platforms.
 */

Ingo Molnar's avatar
Ingo Molnar committed
165
static unsigned int			base;
Linus Torvalds's avatar
Linus Torvalds committed
166 167 168 169

static int
es7000_rename_gsi(int ioapic, int gsi)
{
170 171 172
	if (es7000_plat == ES7000_ZORRO)
		return gsi;

Linus Torvalds's avatar
Linus Torvalds committed
173 174 175 176 177 178
	if (!base) {
		int i;
		for (i = 0; i < nr_ioapics; i++)
			base += nr_ioapic_registers[i];
	}

Yinghai Lu's avatar
Yinghai Lu committed
179
	if (!ioapic && (gsi < 16))
Linus Torvalds's avatar
Linus Torvalds committed
180
		gsi += base;
Ingo Molnar's avatar
Ingo Molnar committed
181

Linus Torvalds's avatar
Linus Torvalds committed
182 183 184
	return gsi;
}

185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
static int wakeup_secondary_cpu_via_mip(int cpu, unsigned long eip)
{
	unsigned long vect = 0, psaival = 0;

	if (psai == NULL)
		return -1;

	vect = ((unsigned long)__pa(eip)/0x1000) << 16;
	psaival = (0x1000000 | vect | cpu);

	while (*psai & 0x1000000)
		;

	*psai = psaival;

	return 0;
}
202 203 204

static int __init es7000_update_genapic(void)
{
205
	apic->wakeup_cpu = wakeup_secondary_cpu_via_mip;
206

207 208 209 210
	/* MPENTIUMIII */
	if (boot_cpu_data.x86 == 6 &&
	    (boot_cpu_data.x86_model >= 7 || boot_cpu_data.x86_model <= 11)) {
		es7000_update_genapic_to_cluster();
211
		apic->wait_for_init_deassert = NULL;
212
		apic->wakeup_cpu = wakeup_secondary_cpu_via_mip;
213 214
	}

215 216
	return 0;
}
217

Ingo Molnar's avatar
Ingo Molnar committed
218
void __init setup_unisys(void)
219 220 221 222 223 224 225 226 227
{
	/*
	 * Determine the generation of the ES7000 currently running.
	 *
	 * es7000_plat = 1 if the machine is a 5xx ES7000 box
	 * es7000_plat = 2 if the machine is a x86_64 ES7000 box
	 *
	 */
	if (!(boot_cpu_data.x86 <= 15 && boot_cpu_data.x86_model <= 2))
228
		es7000_plat = ES7000_ZORRO;
229
	else
230
		es7000_plat = ES7000_CLASSIC;
231
	ioapic_renumber_irq = es7000_rename_gsi;
232 233

	x86_quirks->update_genapic = es7000_update_genapic;
234 235
}

Linus Torvalds's avatar
Linus Torvalds committed
236 237 238 239
/*
 * Parse the OEM Table
 */

Ingo Molnar's avatar
Ingo Molnar committed
240
int __init parse_unisys_oem (char *oemptr)
Linus Torvalds's avatar
Linus Torvalds committed
241 242 243 244 245 246 247 248 249 250 251 252 253 254
{
	int                     i;
	int 			success = 0;
	unsigned char           type, size;
	unsigned long           val;
	char                    *tp = NULL;
	struct psai             *psaip = NULL;
	struct mip_reg_info 	*mi;
	struct mip_reg		*host, *mip;

	tp = oemptr;

	tp += 8;

255
	for (i=0; i <= 6; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
		type = *tp++;
		size = *tp++;
		tp -= 2;
		switch (type) {
		case MIP_REG:
			mi = (struct mip_reg_info *)tp;
			val = MIP_RD_LO(mi->host_reg);
			host_addr = val;
			host = (struct mip_reg *)val;
			host_reg = __va(host);
			val = MIP_RD_LO(mi->mip_reg);
			mip_port = MIP_PORT(mi->mip_info);
			mip_addr = val;
			mip = (struct mip_reg *)val;
			mip_reg = __va(mip);
271 272 273 274
			pr_debug("es7000_mipcfg: host_reg = 0x%lx \n",
				 (unsigned long)host_reg);
			pr_debug("es7000_mipcfg: mip_reg = 0x%lx \n",
				 (unsigned long)mip_reg);
Linus Torvalds's avatar
Linus Torvalds committed
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
			success++;
			break;
		case MIP_PSAI_REG:
			psaip = (struct psai *)tp;
			if (tp != NULL) {
				if (psaip->addr)
					psai = __va(psaip->addr);
				else
					psai = NULL;
				success++;
			}
			break;
		default:
			break;
		}
		tp += size;
	}

	if (success < 2) {
294
		es7000_plat = NON_UNISYS;
295 296
	} else
		setup_unisys();
Ingo Molnar's avatar
Ingo Molnar committed
297

Linus Torvalds's avatar
Linus Torvalds committed
298 299 300
	return es7000_plat;
}

301
#ifdef CONFIG_ACPI
Ingo Molnar's avatar
Ingo Molnar committed
302 303 304 305

static unsigned long			oem_addrX;
static unsigned long			oem_size;

306
int __init find_unisys_acpi_oem_table(unsigned long *oem_addr)
Linus Torvalds's avatar
Linus Torvalds committed
307
{
308 309
	struct acpi_table_header *header = NULL;
	int i = 0;
310
	acpi_size tbl_size;
311

312
	while (ACPI_SUCCESS(acpi_get_table_with_size("OEM1", i++, &header, &tbl_size))) {
313 314
		if (!memcmp((char *) &header->oem_id, "UNISYS", 6)) {
			struct oem_table *t = (struct oem_table *)header;
315 316 317

			oem_addrX = t->OEMTableAddr;
			oem_size = t->OEMTableSize;
318
			early_acpi_os_unmap_memory(header, tbl_size);
319 320 321

			*oem_addr = (unsigned long)__acpi_map_table(oem_addrX,
								    oem_size);
322
			return 0;
Linus Torvalds's avatar
Linus Torvalds committed
323
		}
324
		early_acpi_os_unmap_memory(header, tbl_size);
Linus Torvalds's avatar
Linus Torvalds committed
325 326 327
	}
	return -1;
}
328 329 330

void __init unmap_unisys_acpi_oem_table(unsigned long oem_addr)
{
331 332 333 334
	if (!oem_addr)
		return;

	__acpi_unmap_table((char *)oem_addr, oem_size);
335
}
336
#endif
Linus Torvalds's avatar
Linus Torvalds committed
337

Ingo Molnar's avatar
Ingo Molnar committed
338
static void es7000_spin(int n)
Linus Torvalds's avatar
Linus Torvalds committed
339 340 341 342 343 344 345 346 347 348
{
	int i = 0;

	while (i++ < n)
		rep_nop();
}

static int __init
es7000_mip_write(struct mip_reg *mip_reg)
{
Ingo Molnar's avatar
Ingo Molnar committed
349 350
	int status = 0;
	int spin;
Linus Torvalds's avatar
Linus Torvalds committed
351 352

	spin = MIP_SPIN;
Ingo Molnar's avatar
Ingo Molnar committed
353 354 355 356 357
	while ((host_reg->off_0x38 & MIP_VALID) != 0) {
		if (--spin <= 0) {
			printk("es7000_mip_write: Timeout waiting for Host Valid Flag");
			return -1;
		}
Linus Torvalds's avatar
Linus Torvalds committed
358 359 360 361 362 363 364 365
		es7000_spin(MIP_SPIN);
	}

	memcpy(host_reg, mip_reg, sizeof(struct mip_reg));
	outb(1, mip_port);

	spin = MIP_SPIN;

Ingo Molnar's avatar
Ingo Molnar committed
366
	while ((mip_reg->off_0x38 & MIP_VALID) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
367 368 369 370 371 372 373
		if (--spin <= 0) {
			printk("es7000_mip_write: Timeout waiting for MIP Valid Flag");
			return -1;
		}
		es7000_spin(MIP_SPIN);
	}

Ingo Molnar's avatar
Ingo Molnar committed
374 375 376
	status = (mip_reg->off_0x00 & 0xffff0000000000ULL) >> 48;
	mip_reg->off_0x38 &= ~MIP_VALID;

Linus Torvalds's avatar
Linus Torvalds committed
377 378 379
	return status;
}

380
void __init es7000_enable_apic_mode(void)
Linus Torvalds's avatar
Linus Torvalds committed
381
{
382 383 384 385
	struct mip_reg es7000_mip_reg;
	int mip_status;

	if (!es7000_plat)
Linus Torvalds's avatar
Linus Torvalds committed
386
		return;
387 388 389

	printk("ES7000: Enabling APIC mode.\n");
       	memset(&es7000_mip_reg, 0, sizeof(struct mip_reg));
Ingo Molnar's avatar
Ingo Molnar committed
390 391
       	es7000_mip_reg.off_0x00 = MIP_SW_APIC;
       	es7000_mip_reg.off_0x38 = MIP_VALID;
392 393 394 395

       	while ((mip_status = es7000_mip_write(&es7000_mip_reg)) != 0) {
		printk("es7000_enable_apic_mode: command failed, status = %x\n",
			mip_status);
Linus Torvalds's avatar
Linus Torvalds committed
396 397
	}
}
Ingo Molnar's avatar
Ingo Molnar committed
398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440

static void es7000_vector_allocation_domain(int cpu, cpumask_t *retmask)
{
	/* Careful. Some cpus do not strictly honor the set of cpus
	 * specified in the interrupt destination when using lowest
	 * priority interrupt delivery mode.
	 *
	 * In particular there was a hyperthreading cpu observed to
	 * deliver interrupts to the wrong hyperthread when only one
	 * hyperthread was specified in the interrupt desitination.
	 */
	*retmask = (cpumask_t){ { [0] = APIC_ALL_CPUS, } };
}


static void es7000_wait_for_init_deassert(atomic_t *deassert)
{
#ifndef CONFIG_ES7000_CLUSTERED_APIC
	while (!atomic_read(deassert))
		cpu_relax();
#endif
	return;
}

static unsigned int es7000_get_apic_id(unsigned long x)
{
	return (x >> 24) & 0xFF;
}

#ifdef CONFIG_ACPI
static int es7000_check_dsdt(void)
{
	struct acpi_table_header header;

	if (ACPI_SUCCESS(acpi_get_table_header(ACPI_SIG_DSDT, 0, &header)) &&
	    !strncmp(header.oem_id, "UNISYS", 6))
		return 1;
	return 0;
}
#endif

static void es7000_send_IPI_mask(const struct cpumask *mask, int vector)
{
441
	default_send_IPI_mask_sequence_phys(mask, vector);
Ingo Molnar's avatar
Ingo Molnar committed
442 443 444 445
}

static void es7000_send_IPI_allbutself(int vector)
{
446
	default_send_IPI_mask_allbutself_phys(cpu_online_mask, vector);
Ingo Molnar's avatar
Ingo Molnar committed
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
}

static void es7000_send_IPI_all(int vector)
{
	es7000_send_IPI_mask(cpu_online_mask, vector);
}

static int es7000_apic_id_registered(void)
{
	        return 1;
}

static const cpumask_t *target_cpus_cluster(void)
{
	return &CPU_MASK_ALL;
}

static const cpumask_t *es7000_target_cpus(void)
{
	return &cpumask_of_cpu(smp_processor_id());
}

static unsigned long
es7000_check_apicid_used(physid_mask_t bitmap, int apicid)
{
	return 0;
}
static unsigned long es7000_check_apicid_present(int bit)
{
	return physid_isset(bit, phys_cpu_present_map);
}

static unsigned long calculate_ldr(int cpu)
{
Ingo Molnar's avatar
Ingo Molnar committed
481
	unsigned long id = per_cpu(x86_bios_cpu_apicid, cpu);
Ingo Molnar's avatar
Ingo Molnar committed
482

Ingo Molnar's avatar
Ingo Molnar committed
483
	return SET_APIC_LOGICAL_ID(id);
Ingo Molnar's avatar
Ingo Molnar committed
484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
}

/*
 * Set up the logical destination ID.
 *
 * Intel recommends to set DFR, LdR and TPR before enabling
 * an APIC.  See e.g. "AP-388 82489DX User's Manual" (Intel
 * document number 292116).  So here it goes...
 */
static void es7000_init_apic_ldr_cluster(void)
{
	unsigned long val;
	int cpu = smp_processor_id();

	apic_write(APIC_DFR, APIC_DFR_VALUE_CLUSTER);
	val = calculate_ldr(cpu);
	apic_write(APIC_LDR, val);
}

static void es7000_init_apic_ldr(void)
{
	unsigned long val;
	int cpu = smp_processor_id();

	apic_write(APIC_DFR, APIC_DFR_VALUE);
	val = calculate_ldr(cpu);
	apic_write(APIC_LDR, val);
}

static void es7000_setup_apic_routing(void)
{
	int apic = per_cpu(x86_bios_cpu_apicid, smp_processor_id());
	printk("Enabling APIC mode:  %s. Using %d I/O APICs, target cpus %lx\n",
		(apic_version[apic] == 0x14) ?
			"Physical Cluster" : "Logical Cluster",
			nr_ioapics, cpus_addr(*es7000_target_cpus())[0]);
}

static int es7000_apicid_to_node(int logical_apicid)
{
	return 0;
}


static int es7000_cpu_present_to_apicid(int mps_cpu)
{
	if (!mps_cpu)
		return boot_cpu_physical_apicid;
	else if (mps_cpu < nr_cpu_ids)
Ingo Molnar's avatar
Ingo Molnar committed
533
		return per_cpu(x86_bios_cpu_apicid, mps_cpu);
Ingo Molnar's avatar
Ingo Molnar committed
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
	else
		return BAD_APICID;
}

static physid_mask_t es7000_apicid_to_cpu_present(int phys_apicid)
{
	static int id = 0;
	physid_mask_t mask;

	mask = physid_mask_of_physid(id);
	++id;

	return mask;
}

/* Mapping from cpu number to logical apicid */
static int es7000_cpu_to_logical_apicid(int cpu)
{
#ifdef CONFIG_SMP
	if (cpu >= nr_cpu_ids)
		return BAD_APICID;
555
	return cpu_2_logical_apicid[cpu];
Ingo Molnar's avatar
Ingo Molnar committed
556 557 558 559 560 561 562 563 564 565 566 567 568 569
#else
	return logical_smp_processor_id();
#endif
}

static physid_mask_t es7000_ioapic_phys_id_map(physid_mask_t phys_map)
{
	/* For clustered we don't have a good way to do this yet - hack */
	return physids_promote(0xff);
}

static int es7000_check_phys_apicid_present(int cpu_physical_apicid)
{
	boot_cpu_physical_apicid = read_apic_id();
Ingo Molnar's avatar
Ingo Molnar committed
570
	return 1;
Ingo Molnar's avatar
Ingo Molnar committed
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
}

static unsigned int
es7000_cpu_mask_to_apicid_cluster(const struct cpumask *cpumask)
{
	int cpus_found = 0;
	int num_bits_set;
	int apicid;
	int cpu;

	num_bits_set = cpumask_weight(cpumask);
	/* Return id to all */
	if (num_bits_set == nr_cpu_ids)
		return 0xFF;
	/*
	 * The cpus in the mask must all be on the apic cluster.  If are not
	 * on the same apicid cluster return default value of target_cpus():
	 */
	cpu = cpumask_first(cpumask);
	apicid = es7000_cpu_to_logical_apicid(cpu);

	while (cpus_found < num_bits_set) {
		if (cpumask_test_cpu(cpu, cpumask)) {
			int new_apicid = es7000_cpu_to_logical_apicid(cpu);

596
			if (APIC_CLUSTER(apicid) != APIC_CLUSTER(new_apicid)) {
Ingo Molnar's avatar
Ingo Molnar committed
597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629
				printk ("%s: Not a valid mask!\n", __func__);

				return 0xFF;
			}
			apicid = new_apicid;
			cpus_found++;
		}
		cpu++;
	}
	return apicid;
}

static unsigned int es7000_cpu_mask_to_apicid(const cpumask_t *cpumask)
{
	int cpus_found = 0;
	int num_bits_set;
	int apicid;
	int cpu;

	num_bits_set = cpus_weight(*cpumask);
	/* Return id to all */
	if (num_bits_set == nr_cpu_ids)
		return es7000_cpu_to_logical_apicid(0);
	/*
	 * The cpus in the mask must all be on the apic cluster.  If are not
	 * on the same apicid cluster return default value of target_cpus():
	 */
	cpu = first_cpu(*cpumask);
	apicid = es7000_cpu_to_logical_apicid(cpu);
	while (cpus_found < num_bits_set) {
		if (cpu_isset(cpu, *cpumask)) {
			int new_apicid = es7000_cpu_to_logical_apicid(cpu);

630
			if (APIC_CLUSTER(apicid) != APIC_CLUSTER(new_apicid)) {
Ingo Molnar's avatar
Ingo Molnar committed
631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773
				printk ("%s: Not a valid mask!\n", __func__);

				return es7000_cpu_to_logical_apicid(0);
			}
			apicid = new_apicid;
			cpus_found++;
		}
		cpu++;
	}
	return apicid;
}

static unsigned int
es7000_cpu_mask_to_apicid_and(const struct cpumask *inmask,
			      const struct cpumask *andmask)
{
	int apicid = es7000_cpu_to_logical_apicid(0);
	cpumask_var_t cpumask;

	if (!alloc_cpumask_var(&cpumask, GFP_ATOMIC))
		return apicid;

	cpumask_and(cpumask, inmask, andmask);
	cpumask_and(cpumask, cpumask, cpu_online_mask);
	apicid = es7000_cpu_mask_to_apicid(cpumask);

	free_cpumask_var(cpumask);

	return apicid;
}

static int es7000_phys_pkg_id(int cpuid_apic, int index_msb)
{
	return cpuid_apic >> index_msb;
}

void __init es7000_update_genapic_to_cluster(void)
{
	apic->target_cpus = target_cpus_cluster;
	apic->irq_delivery_mode = INT_DELIVERY_MODE_CLUSTER;
	apic->irq_dest_mode = INT_DEST_MODE_CLUSTER;

	apic->init_apic_ldr = es7000_init_apic_ldr_cluster;

	apic->cpu_mask_to_apicid = es7000_cpu_mask_to_apicid_cluster;
}

static int probe_es7000(void)
{
	/* probed later in mptable/ACPI hooks */
	return 0;
}

static __init int
es7000_mps_oem_check(struct mpc_table *mpc, char *oem, char *productid)
{
	if (mpc->oemptr) {
		struct mpc_oemtable *oem_table =
			(struct mpc_oemtable *)mpc->oemptr;

		if (!strncmp(oem, "UNISYS", 6))
			return parse_unisys_oem((char *)oem_table);
	}
	return 0;
}

#ifdef CONFIG_ACPI
/* Hook from generic ACPI tables.c */
static int __init es7000_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
{
	unsigned long oem_addr = 0;
	int check_dsdt;
	int ret = 0;

	/* check dsdt at first to avoid clear fix_map for oem_addr */
	check_dsdt = es7000_check_dsdt();

	if (!find_unisys_acpi_oem_table(&oem_addr)) {
		if (check_dsdt)
			ret = parse_unisys_oem((char *)oem_addr);
		else {
			setup_unisys();
			ret = 1;
		}
		/*
		 * we need to unmap it
		 */
		unmap_unisys_acpi_oem_table(oem_addr);
	}
	return ret;
}
#else
static int __init es7000_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
{
	return 0;
}
#endif


struct genapic apic_es7000 = {

	.name				= "es7000",
	.probe				= probe_es7000,
	.acpi_madt_oem_check		= es7000_acpi_madt_oem_check,
	.apic_id_registered		= es7000_apic_id_registered,

	.irq_delivery_mode		= dest_Fixed,
	/* phys delivery to target CPUs: */
	.irq_dest_mode			= 0,

	.target_cpus			= es7000_target_cpus,
	.disable_esr			= 1,
	.dest_logical			= 0,
	.check_apicid_used		= es7000_check_apicid_used,
	.check_apicid_present		= es7000_check_apicid_present,

	.vector_allocation_domain	= es7000_vector_allocation_domain,
	.init_apic_ldr			= es7000_init_apic_ldr,

	.ioapic_phys_id_map		= es7000_ioapic_phys_id_map,
	.setup_apic_routing		= es7000_setup_apic_routing,
	.multi_timer_check		= NULL,
	.apicid_to_node			= es7000_apicid_to_node,
	.cpu_to_logical_apicid		= es7000_cpu_to_logical_apicid,
	.cpu_present_to_apicid		= es7000_cpu_present_to_apicid,
	.apicid_to_cpu_present		= es7000_apicid_to_cpu_present,
	.setup_portio_remap		= NULL,
	.check_phys_apicid_present	= es7000_check_phys_apicid_present,
	.enable_apic_mode		= es7000_enable_apic_mode,
	.phys_pkg_id			= es7000_phys_pkg_id,
	.mps_oem_check			= es7000_mps_oem_check,

	.get_apic_id			= es7000_get_apic_id,
	.set_apic_id			= NULL,
	.apic_id_mask			= 0xFF << 24,

	.cpu_mask_to_apicid		= es7000_cpu_mask_to_apicid,
	.cpu_mask_to_apicid_and		= es7000_cpu_mask_to_apicid_and,

	.send_IPI_mask			= es7000_send_IPI_mask,
	.send_IPI_mask_allbutself	= NULL,
	.send_IPI_allbutself		= es7000_send_IPI_allbutself,
	.send_IPI_all			= es7000_send_IPI_all,
774
	.send_IPI_self			= default_send_IPI_self,
Ingo Molnar's avatar
Ingo Molnar committed
775 776 777 778 779 780 781 782 783 784 785 786

	.wakeup_cpu			= NULL,

	.trampoline_phys_low		= 0x467,
	.trampoline_phys_high		= 0x469,

	.wait_for_init_deassert		= es7000_wait_for_init_deassert,

	/* Nothing to do for most platforms, since cleared by the INIT cycle: */
	.smp_callin_clear_local_apic	= NULL,
	.store_NMI_vector		= NULL,
	.inquire_remote_apic		= default_inquire_remote_apic,
Yinghai Lu's avatar
Yinghai Lu committed
787 788 789 790 791 792 793

	.read				= native_apic_mem_read,
	.write				= native_apic_mem_write,
	.icr_read			= native_apic_icr_read,
	.icr_write			= native_apic_icr_write,
	.wait_icr_idle			= native_apic_wait_icr_idle,
	.safe_wait_icr_idle		= native_safe_apic_wait_icr_idle,
Ingo Molnar's avatar
Ingo Molnar committed
794
};