Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 071922c08cef62e194d83db1cc4fa75892c69651

Authored by Vivek Goyal 2007-07-06 17:39:55 +0800

Committed by Linus Torvalds 2007-07-07 01:23:43 +0800

Exists in master and in 7 other branches

i386: es7000 build breakage fix

o Commit 1833d6bc72893265f22addd79cf52e6987496e0f broke the build if
  compiled with CONFIG_ES7000=y and CONFIG_X86_GENERICARCH=n

arch/i386/kernel/built-in.o(.init.text+0x4fa9): In function `acpi_parse_madt':
: undefined reference to `acpi_madt_oem_check'
arch/i386/kernel/built-in.o(.init.text+0x7406): In function `smp_read_mpc':
: undefined reference to `mps_oem_check'
arch/i386/kernel/built-in.o(.init.text+0x8990): In function
`connect_bsp_APIC':
: undefined reference to `enable_apic_mode'
make: *** [.tmp_vmlinux1] Error 1

o Fix the build issue. Provided the definitions of missing functions.

o Don't have ES7000 machine. Only compile tested.

Cc: Len Brown <lenb@kernel.org>
Cc: Natalie Protasevich <protasnb@gmail.com>
Cc: Roland Dreier <rolandd@cisco.com>
Cc: Andi Kleen <ak@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 3 changed files with 58 additions and 0 deletions Inline Diff

arch/i386/mach-es7000/es7000plat.c
include/asm-i386/mach-es7000/mach_apic.h
include/asm-i386/mach-es7000/mach_mpparse.h

arch/i386/mach-es7000/es7000plat.c

Diff comments View file @ 071922c

 /*
  * 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
  */
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/smp.h>
 #include <linux/string.h>
 #include <linux/spinlock.h>
 #include <linux/errno.h>
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/acpi.h>
 #include <asm/io.h>
 #include <asm/nmi.h>
 #include <asm/smp.h>
 #include <asm/apicdef.h>
 #include "es7000.h"
+#include <mach_mpparse.h>
 /*
  * ES7000 Globals
  */
 volatile unsigned long	*psai = NULL;
 struct mip_reg		*mip_reg;
 struct mip_reg		*host_reg;
 int 			mip_port;
 unsigned long		mip_addr, host_addr;
 /*
  * GSI override for ES7000 platforms.
  */
 static unsigned int base;
 static int
 es7000_rename_gsi(int ioapic, int gsi)
 {
 	if (es7000_plat == ES7000_ZORRO)
 		return gsi;
 	if (!base) {
 		int i;
 		for (i = 0; i < nr_ioapics; i++)
 			base += nr_ioapic_registers[i];
 	}
 	if (!ioapic && (gsi < 16))
 		gsi += base;
 	return gsi;
 }
 void __init
 setup_unisys(void)
 {
 	/*
 	 * 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))
 		es7000_plat = ES7000_ZORRO;
 	else
 		es7000_plat = ES7000_CLASSIC;
 	ioapic_renumber_irq = es7000_rename_gsi;
 }
 /*
  * Parse the OEM Table
  */
 int __init
 parse_unisys_oem (char *oemptr)
 {
 	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;
 	for (i=0; i <= 6; i++) {
 		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);
 			Dprintk("es7000_mipcfg: host_reg = 0x%lx \n",
 				(unsigned long)host_reg);
 			Dprintk("es7000_mipcfg: mip_reg = 0x%lx \n",
 				(unsigned long)mip_reg);
 			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) {
 		es7000_plat = NON_UNISYS;
 	} else
 		setup_unisys();
 	return es7000_plat;
 }
 #ifdef CONFIG_ACPI
 int __init
 find_unisys_acpi_oem_table(unsigned long *oem_addr)
 {
 	struct acpi_table_header *header = NULL;
 	int i = 0;
 	while (ACPI_SUCCESS(acpi_get_table("OEM1", i++, &header))) {
 		if (!memcmp((char *) &header->oem_id, "UNISYS", 6)) {
 			struct oem_table *t = (struct oem_table *)header;
 			*oem_addr = (unsigned long)__acpi_map_table(t->OEMTableAddr,
 								    t->OEMTableSize);
 			return 0;
 		}
 	}
 	return -1;
 }
 #endif
+/*
+ * This file also gets compiled if CONFIG_X86_GENERICARCH is set. Generic
+ * arch already has got following function definitions (asm-generic/es7000.c)
+ * hence no need to define these for that case.
+ */
+#ifndef CONFIG_X86_GENERICARCH
+void es7000_sw_apic(void);
+void __init enable_apic_mode(void)
+{
+	es7000_sw_apic();
+	return;
+}
+__init int mps_oem_check(struct mp_config_table *mpc, char *oem,
+		char *productid)
+{
+	if (mpc->mpc_oemptr) {
+		struct mp_config_oemtable *oem_table =
+			(struct mp_config_oemtable *)mpc->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 */
+int __init acpi_madt_oem_check(char *oem_id, char *oem_table_id)
+{
+	unsigned long oem_addr;
+	if (!find_unisys_acpi_oem_table(&oem_addr)) {
+		if (es7000_check_dsdt())
+			return parse_unisys_oem((char *)oem_addr);
+		else {
+			setup_unisys();
+			return 1;
+		}
+	}
+	return 0;
+}
+#else
+int __init acpi_madt_oem_check(char *oem_id, char *oem_table_id)
+{
+	return 0;
+}
+#endif
+#endif /* COFIG_X86_GENERICARCH */
 static void
 es7000_spin(int n)
 {
 	int i = 0;
 	while (i++ < n)
 		rep_nop();
 }
 static int __init
 es7000_mip_write(struct mip_reg *mip_reg)
 {
 	int			status = 0;
 	int			spin;
 	spin = MIP_SPIN;
 	while (((unsigned long long)host_reg->off_38 &
 		(unsigned long long)MIP_VALID) != 0) {
 			if (--spin <= 0) {
 				printk("es7000_mip_write: Timeout waiting for Host Valid Flag");
 				return -1;
 			}
 		es7000_spin(MIP_SPIN);
 	}
 	memcpy(host_reg, mip_reg, sizeof(struct mip_reg));
 	outb(1, mip_port);
 	spin = MIP_SPIN;
 	while (((unsigned long long)mip_reg->off_38 &
 		(unsigned long long)MIP_VALID) == 0) {
 		if (--spin <= 0) {
 			printk("es7000_mip_write: Timeout waiting for MIP Valid Flag");
 			return -1;
 		}
 		es7000_spin(MIP_SPIN);
 	}
 	status = ((unsigned long long)mip_reg->off_0 &
 		(unsigned long long)0xffff0000000000ULL) >> 48;
 	mip_reg->off_38 = ((unsigned long long)mip_reg->off_38 &
 		(unsigned long long)~MIP_VALID);
 	return status;
 }
 int
 es7000_start_cpu(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;
 }
 int
 es7000_stop_cpu(int cpu)
 {
 	int startup;
 	if (psai == NULL)
 		return -1;
 	startup= (0x1000000 | cpu);
 	while ((*psai & 0xff00ffff) != startup)
 		;
 	startup = (*psai & 0xff0000) >> 16;
 	*psai &= 0xffffff;
 	return 0;
 }
 void __init
 es7000_sw_apic()
 {
 	if (es7000_plat) {
 		int mip_status;
 		struct mip_reg es7000_mip_reg;
 		printk("ES7000: Enabling APIC mode.\n");
         	memset(&es7000_mip_reg, 0, sizeof(struct mip_reg));
         	es7000_mip_reg.off_0 = MIP_SW_APIC;
         	es7000_mip_reg.off_38 = (MIP_VALID);
         	while ((mip_status = es7000_mip_write(&es7000_mip_reg)) != 0)
               		printk("es7000_sw_apic: command failed, status = %x\n",
 				mip_status);
 		return;
 	}
 }

include/asm-i386/mach-es7000/mach_apic.h

Diff comments View file @ 071922c

 #ifndef __ASM_MACH_APIC_H
 #define __ASM_MACH_APIC_H
 extern u8 bios_cpu_apicid[];
 #define xapic_phys_to_log_apicid(cpu) (bios_cpu_apicid[cpu])
 #define esr_disable (1)
 static inline int apic_id_registered(void)
 {
 	        return (1);
 }
 static inline cpumask_t target_cpus(void)
 {
 #if defined CONFIG_ES7000_CLUSTERED_APIC
 	return CPU_MASK_ALL;
 #else
 	return cpumask_of_cpu(smp_processor_id());
 #endif
 }
 #define TARGET_CPUS	(target_cpus())
 #if defined CONFIG_ES7000_CLUSTERED_APIC
 #define APIC_DFR_VALUE		(APIC_DFR_CLUSTER)
 #define INT_DELIVERY_MODE	(dest_LowestPrio)
 #define INT_DEST_MODE		(1)    /* logical delivery broadcast to all procs */
 #define NO_BALANCE_IRQ 		(1)
 #undef  WAKE_SECONDARY_VIA_INIT
 #define WAKE_SECONDARY_VIA_MIP
 #else
 #define APIC_DFR_VALUE		(APIC_DFR_FLAT)
 #define INT_DELIVERY_MODE	(dest_Fixed)
 #define INT_DEST_MODE		(0)    /* phys delivery to target procs */
 #define NO_BALANCE_IRQ 		(0)
 #undef  APIC_DEST_LOGICAL
 #define APIC_DEST_LOGICAL	0x0
 #define WAKE_SECONDARY_VIA_INIT
 #endif
 static inline unsigned long check_apicid_used(physid_mask_t bitmap, int apicid)
 {
 	return 0;
 }
 static inline unsigned long check_apicid_present(int bit)
 {
 	return physid_isset(bit, phys_cpu_present_map);
 }
 #define apicid_cluster(apicid) (apicid & 0xF0)
 static inline unsigned long calculate_ldr(int cpu)
 {
 	unsigned long id;
 	id = xapic_phys_to_log_apicid(cpu);
 	return (SET_APIC_LOGICAL_ID(id));
 }
 /*
  * 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 inline void init_apic_ldr(void)
 {
 	unsigned long val;
 	int cpu = smp_processor_id();
 	apic_write_around(APIC_DFR, APIC_DFR_VALUE);
 	val = calculate_ldr(cpu);
 	apic_write_around(APIC_LDR, val);
 }
+#ifndef CONFIG_X86_GENERICARCH
+extern void enable_apic_mode(void);
+#endif
 extern int apic_version [MAX_APICS];
 static inline void setup_apic_routing(void)
 {
 	int apic = 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(TARGET_CPUS)[0]);
 }
 static inline int multi_timer_check(int apic, int irq)
 {
 	return 0;
 }
 static inline int apicid_to_node(int logical_apicid)
 {
 	return 0;
 }
 static inline int cpu_present_to_apicid(int mps_cpu)
 {
 	if (!mps_cpu)
 		return boot_cpu_physical_apicid;
 	else if (mps_cpu < NR_CPUS)
 		return (int) bios_cpu_apicid[mps_cpu];
 	else
 		return BAD_APICID;
 }
 static inline physid_mask_t apicid_to_cpu_present(int phys_apicid)
 {
 	static int id = 0;
 	physid_mask_t mask;
 	mask = physid_mask_of_physid(id);
 	++id;
 	return mask;
 }
 extern u8 cpu_2_logical_apicid[];
 /* Mapping from cpu number to logical apicid */
 static inline int cpu_to_logical_apicid(int cpu)
 {
 #ifdef CONFIG_SMP
        if (cpu >= NR_CPUS)
 	       return BAD_APICID;
        return (int)cpu_2_logical_apicid[cpu];
 #else
 	return logical_smp_processor_id();
 #endif
 }
 static inline int mpc_apic_id(struct mpc_config_processor *m, struct mpc_config_translation *unused)
 {
 	printk("Processor #%d %ld:%ld APIC version %d\n",
 	        m->mpc_apicid,
 	        (m->mpc_cpufeature & CPU_FAMILY_MASK) >> 8,
 	        (m->mpc_cpufeature & CPU_MODEL_MASK) >> 4,
 	        m->mpc_apicver);
 	return (m->mpc_apicid);
 }
 static inline physid_mask_t 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 inline void setup_portio_remap(void)
 {
 }
 extern unsigned int boot_cpu_physical_apicid;
 static inline int check_phys_apicid_present(int cpu_physical_apicid)
 {
 	boot_cpu_physical_apicid = GET_APIC_ID(apic_read(APIC_ID));
 	return (1);
 }
 static inline unsigned int cpu_mask_to_apicid(cpumask_t cpumask)
 {
 	int num_bits_set;
 	int cpus_found = 0;
 	int cpu;
 	int apicid;
 	num_bits_set = cpus_weight(cpumask);
 	/* Return id to all */
 	if (num_bits_set == NR_CPUS)
 #if defined CONFIG_ES7000_CLUSTERED_APIC
 		return 0xFF;
 #else
 		return cpu_to_logical_apicid(0);
 #endif
 	/*
 	 * 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 = cpu_to_logical_apicid(cpu);
 	while (cpus_found < num_bits_set) {
 		if (cpu_isset(cpu, cpumask)) {
 			int new_apicid = cpu_to_logical_apicid(cpu);
 			if (apicid_cluster(apicid) !=
 					apicid_cluster(new_apicid)){
 				printk ("%s: Not a valid mask!\n",__FUNCTION__);
 #if defined CONFIG_ES7000_CLUSTERED_APIC
 				return 0xFF;
 #else
 				return cpu_to_logical_apicid(0);
 #endif
 			}
 			apicid = new_apicid;
 			cpus_found++;
 		}
 		cpu++;
 	}
 	return apicid;
 }
 static inline u32 phys_pkg_id(u32 cpuid_apic, int index_msb)
 {
 	return cpuid_apic >> index_msb;
 }
 #endif /* __ASM_MACH_APIC_H */

include/asm-i386/mach-es7000/mach_mpparse.h

Diff comments View file @ 071922c

 #ifndef __ASM_MACH_MPPARSE_H
 #define __ASM_MACH_MPPARSE_H
 #include <linux/acpi.h>
 static inline void mpc_oem_bus_info(struct mpc_config_bus *m, char *name,
 				struct mpc_config_translation *translation)
 {
 	Dprintk("Bus #%d is %s\n", m->mpc_busid, name);
 }
 static inline void mpc_oem_pci_bus(struct mpc_config_bus *m,
 				struct mpc_config_translation *translation)
 {
 }
 extern int parse_unisys_oem (char *oemptr);
 extern int find_unisys_acpi_oem_table(unsigned long *oem_addr);
 extern void setup_unisys(void);
+#ifndef CONFIG_X86_GENERICARCH
+extern int acpi_madt_oem_check(char *oem_id, char *oem_table_id);
+extern int mps_oem_check(struct mp_config_table *mpc, char *oem,
+				char *productid);
+#endif
 #ifdef CONFIG_ACPI
 static inline int es7000_check_dsdt(void)
 {
 	struct acpi_table_header header;
 	memcpy(&header, 0, sizeof(struct acpi_table_header));
 	acpi_get_table_header(ACPI_SIG_DSDT, 0, &header);
 	if (!strncmp(header.oem_id, "UNISYS", 6))
 		return 1;
 	return 0;
 }
 #endif
 #endif /* __ASM_MACH_MPPARSE_H */