Merge git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc

* git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc: (78 commits)
  [PATCH] powerpc: Add FSL SEC node to documentation
  [PATCH] macintosh: tidy-up driver_register() return values
  [PATCH] powerpc: tidy-up of_register_driver()/driver_register() return values
  [PATCH] powerpc: via-pmu warning fix
  [PATCH] macintosh: cleanup the use of i2c headers
  [PATCH] powerpc: dont allow old RTC to be selected
  [PATCH] powerpc: make powerbook_sleep_grackle static
  [PATCH] powerpc: Fix warning in add_memory
  [PATCH] powerpc: update mailing list addresses
  [PATCH] powerpc: Remove calculation of io hole
  [PATCH] powerpc: iseries: Add bootargs to /chosen
  [PATCH] powerpc: iseries: Add /system-id, /model and /compatible
  [PATCH] powerpc: Add strne2a() to convert a string from EBCDIC to ASCII
  [PATCH] powerpc: iseries: Make more stuff static in platforms/iseries/mf.c
  [PATCH] powerpc: iseries: Remove pointless iSeries_(restart|power_off|halt)
  [PATCH] powerpc: iseries: mf related cleanups
  [PATCH] powerpc: Replace platform_is_lpar() with a firmware feature
  [PATCH] powerpc: trivial: Cleanup whitespace in cputable.h
  [PATCH] powerpc: Remove unused iommu_off logic from pSeries_init_early()
  [PATCH] powerpc: Unconfuse htab_bolt_mapping() callers
  ...
This commit is contained in:
Linus Torvalds 2006-03-22 22:20:46 -08:00
commit 2e6e33bab6
366 changed files with 6576 additions and 1471 deletions

View File

@ -1365,6 +1365,78 @@ platforms are moved over to use the flattened-device-tree model.
}; };
g) Freescale SOC SEC Security Engines
Required properties:
- device_type : Should be "crypto"
- model : Model of the device. Should be "SEC1" or "SEC2"
- compatible : Should be "talitos"
- reg : Offset and length of the register set for the device
- interrupts : <a b> where a is the interrupt number and b is a
field that represents an encoding of the sense and level
information for the interrupt. This should be encoded based on
the information in section 2) depending on the type of interrupt
controller you have.
- interrupt-parent : the phandle for the interrupt controller that
services interrupts for this device.
- num-channels : An integer representing the number of channels
available.
- channel-fifo-len : An integer representing the number of
descriptor pointers each channel fetch fifo can hold.
- exec-units-mask : The bitmask representing what execution units
(EUs) are available. It's a single 32 bit cell. EU information
should be encoded following the SEC's Descriptor Header Dword
EU_SEL0 field documentation, i.e. as follows:
bit 0 = reserved - should be 0
bit 1 = set if SEC has the ARC4 EU (AFEU)
bit 2 = set if SEC has the DES/3DES EU (DEU)
bit 3 = set if SEC has the message digest EU (MDEU)
bit 4 = set if SEC has the random number generator EU (RNG)
bit 5 = set if SEC has the public key EU (PKEU)
bit 6 = set if SEC has the AES EU (AESU)
bit 7 = set if SEC has the Kasumi EU (KEU)
bits 8 through 31 are reserved for future SEC EUs.
- descriptor-types-mask : The bitmask representing what descriptors
are available. It's a single 32 bit cell. Descriptor type
information should be encoded following the SEC's Descriptor
Header Dword DESC_TYPE field documentation, i.e. as follows:
bit 0 = set if SEC supports the aesu_ctr_nonsnoop desc. type
bit 1 = set if SEC supports the ipsec_esp descriptor type
bit 2 = set if SEC supports the common_nonsnoop desc. type
bit 3 = set if SEC supports the 802.11i AES ccmp desc. type
bit 4 = set if SEC supports the hmac_snoop_no_afeu desc. type
bit 5 = set if SEC supports the srtp descriptor type
bit 6 = set if SEC supports the non_hmac_snoop_no_afeu desc.type
bit 7 = set if SEC supports the pkeu_assemble descriptor type
bit 8 = set if SEC supports the aesu_key_expand_output desc.type
bit 9 = set if SEC supports the pkeu_ptmul descriptor type
bit 10 = set if SEC supports the common_nonsnoop_afeu desc. type
bit 11 = set if SEC supports the pkeu_ptadd_dbl descriptor type
..and so on and so forth.
Example:
/* MPC8548E */
crypto@30000 {
device_type = "crypto";
model = "SEC2";
compatible = "talitos";
reg = <30000 10000>;
interrupts = <1d 3>;
interrupt-parent = <40000>;
num-channels = <4>;
channel-fifo-len = <24>;
exec-units-mask = <000000fe>;
descriptor-types-mask = <073f1127>;
};
More devices will be defined as this spec matures. More devices will be defined as this spec matures.

View File

@ -121,7 +121,7 @@ accomplished.
EEH must be enabled in the PHB's very early during the boot process, EEH must be enabled in the PHB's very early during the boot process,
and if a PCI slot is hot-plugged. The former is performed by and if a PCI slot is hot-plugged. The former is performed by
eeh_init() in arch/ppc64/kernel/eeh.c, and the later by eeh_init() in arch/powerpc/platforms/pseries/eeh.c, and the later by
drivers/pci/hotplug/pSeries_pci.c calling in to the eeh.c code. drivers/pci/hotplug/pSeries_pci.c calling in to the eeh.c code.
EEH must be enabled before a PCI scan of the device can proceed. EEH must be enabled before a PCI scan of the device can proceed.
Current Power5 hardware will not work unless EEH is enabled; Current Power5 hardware will not work unless EEH is enabled;
@ -133,7 +133,7 @@ error. Given an arbitrary address, the routine
pci_get_device_by_addr() will find the pci device associated pci_get_device_by_addr() will find the pci device associated
with that address (if any). with that address (if any).
The default include/asm-ppc64/io.h macros readb(), inb(), insb(), The default include/asm-powerpc/io.h macros readb(), inb(), insb(),
etc. include a check to see if the i/o read returned all-0xff's. etc. include a check to see if the i/o read returned all-0xff's.
If so, these make a call to eeh_dn_check_failure(), which in turn If so, these make a call to eeh_dn_check_failure(), which in turn
asks the firmware if the all-ff's value is the sign of a true EEH asks the firmware if the all-ff's value is the sign of a true EEH
@ -143,11 +143,12 @@ seen in /proc/ppc64/eeh (subject to change). Normally, almost
all of these occur during boot, when the PCI bus is scanned, where all of these occur during boot, when the PCI bus is scanned, where
a large number of 0xff reads are part of the bus scan procedure. a large number of 0xff reads are part of the bus scan procedure.
If a frozen slot is detected, code in arch/ppc64/kernel/eeh.c will If a frozen slot is detected, code in
print a stack trace to syslog (/var/log/messages). This stack trace arch/powerpc/platforms/pseries/eeh.c will print a stack trace to
has proven to be very useful to device-driver authors for finding syslog (/var/log/messages). This stack trace has proven to be very
out at what point the EEH error was detected, as the error itself useful to device-driver authors for finding out at what point the EEH
usually occurs slightly beforehand. error was detected, as the error itself usually occurs slightly
beforehand.
Next, it uses the Linux kernel notifier chain/work queue mechanism to Next, it uses the Linux kernel notifier chain/work queue mechanism to
allow any interested parties to find out about the failure. Device allow any interested parties to find out about the failure. Device

View File

@ -558,9 +558,9 @@ partitions.
The proper channel for reporting bugs is either through the Linux OS The proper channel for reporting bugs is either through the Linux OS
distribution company that provided your OS or by posting issues to the distribution company that provided your OS or by posting issues to the
ppc64 development mailing list at: PowerPC development mailing list at:
linuxppc64-dev@lists.linuxppc.org linuxppc-dev@ozlabs.org
This request is to provide a documented and searchable public exchange This request is to provide a documented and searchable public exchange
of the problems and solutions surrounding this driver for the benefit of of the problems and solutions surrounding this driver for the benefit of

View File

@ -534,7 +534,7 @@ S: Supported
BROADBAND PROCESSOR ARCHITECTURE BROADBAND PROCESSOR ARCHITECTURE
P: Arnd Bergmann P: Arnd Bergmann
M: arnd@arndb.de M: arnd@arndb.de
L: linuxppc64-dev@ozlabs.org L: linuxppc-dev@ozlabs.org
W: http://linuxppc64.org W: http://linuxppc64.org
S: Supported S: Supported
@ -1624,7 +1624,7 @@ P: Anton Blanchard
M: anton@samba.org M: anton@samba.org
M: anton@au.ibm.com M: anton@au.ibm.com
W: http://linuxppc64.org W: http://linuxppc64.org
L: linuxppc64-dev@ozlabs.org L: linuxppc-dev@ozlabs.org
S: Supported S: Supported
LINUX SECURITY MODULE (LSM) FRAMEWORK LINUX SECURITY MODULE (LSM) FRAMEWORK

View File

@ -127,6 +127,12 @@ config PPC_83xx
select 83xx select 83xx
select PPC_FPU select PPC_FPU
config PPC_85xx
bool "Freescale 85xx"
select E500
select FSL_SOC
select 85xx
config 40x config 40x
bool "AMCC 40x" bool "AMCC 40x"
@ -139,8 +145,6 @@ config 8xx
config E200 config E200
bool "Freescale e200" bool "Freescale e200"
config E500
bool "Freescale e500"
endchoice endchoice
config POWER4_ONLY config POWER4_ONLY
@ -168,6 +172,13 @@ config 6xx
config 83xx config 83xx
bool bool
# this is temp to handle compat with arch=ppc
config 85xx
bool
config E500
bool
config PPC_FPU config PPC_FPU
bool bool
default y if PPC64 default y if PPC64
@ -217,6 +228,7 @@ config ALTIVEC
config SPE config SPE
bool "SPE Support" bool "SPE Support"
depends on E200 || E500 depends on E200 || E500
default y
---help--- ---help---
This option enables kernel support for the Signal Processing This option enables kernel support for the Signal Processing
Extensions (SPE) to the PowerPC processor. The kernel currently Extensions (SPE) to the PowerPC processor. The kernel currently
@ -238,6 +250,21 @@ config PPC_STD_MMU_32
def_bool y def_bool y
depends on PPC_STD_MMU && PPC32 depends on PPC_STD_MMU && PPC32
config VIRT_CPU_ACCOUNTING
bool "Deterministic task and CPU time accounting"
depends on PPC64
default y
help
Select this option to enable more accurate task and CPU time
accounting. This is done by reading a CPU counter on each
kernel entry and exit and on transitions within the kernel
between system, softirq and hardirq state, so there is a
small performance impact. This also enables accounting of
stolen time on logically-partitioned systems running on
IBM POWER5-based machines.
If in doubt, say Y here.
config SMP config SMP
depends on PPC_STD_MMU depends on PPC_STD_MMU
bool "Symmetric multi-processing support" bool "Symmetric multi-processing support"
@ -734,13 +761,12 @@ config GENERIC_ISA_DMA
config PPC_I8259 config PPC_I8259
bool bool
default y if 85xx
default n default n
config PPC_INDIRECT_PCI config PPC_INDIRECT_PCI
bool bool
depends on PCI depends on PCI
default y if 40x || 44x || 85xx default y if 40x || 44x
default n default n
config EISA config EISA
@ -757,8 +783,8 @@ config MCA
bool bool
config PCI config PCI
bool "PCI support" if 40x || CPM2 || PPC_83xx || 85xx || PPC_MPC52xx || (EMBEDDED && PPC_ISERIES) bool "PCI support" if 40x || CPM2 || PPC_83xx || PPC_85xx || PPC_MPC52xx || (EMBEDDED && PPC_ISERIES)
default y if !40x && !CPM2 && !8xx && !APUS && !PPC_83xx && !85xx default y if !40x && !CPM2 && !8xx && !APUS && !PPC_83xx && !PPC_85xx
default PCI_PERMEDIA if !4xx && !CPM2 && !8xx && APUS default PCI_PERMEDIA if !4xx && !CPM2 && !8xx && APUS
default PCI_QSPAN if !4xx && !CPM2 && 8xx default PCI_QSPAN if !4xx && !CPM2 && 8xx
help help

View File

@ -148,7 +148,7 @@ all: $(KBUILD_IMAGE)
CPPFLAGS_vmlinux.lds := -Upowerpc CPPFLAGS_vmlinux.lds := -Upowerpc
BOOT_TARGETS = zImage zImage.initrd znetboot znetboot.initrd vmlinux.sm uImage BOOT_TARGETS = zImage zImage.initrd znetboot znetboot.initrd vmlinux.sm uImage vmlinux.bin
.PHONY: $(BOOT_TARGETS) .PHONY: $(BOOT_TARGETS)

View File

@ -1,7 +1,5 @@
#!/bin/sh #!/bin/sh
# #
# arch/ppc64/boot/install.sh
#
# This file is subject to the terms and conditions of the GNU General Public # This file is subject to the terms and conditions of the GNU General Public
# License. See the file "COPYING" in the main directory of this archive # License. See the file "COPYING" in the main directory of this archive
# for more details. # for more details.

View File

@ -152,7 +152,7 @@ static int is_elf64(void *hdr)
elf64ph = (Elf64_Phdr *)((unsigned long)elf64 + elf64ph = (Elf64_Phdr *)((unsigned long)elf64 +
(unsigned long)elf64->e_phoff); (unsigned long)elf64->e_phoff);
for (i = 0; i < (unsigned int)elf64->e_phnum; i++, elf64ph++) for (i = 0; i < (unsigned int)elf64->e_phnum; i++, elf64ph++)
if (elf64ph->p_type == PT_LOAD && elf64ph->p_offset != 0) if (elf64ph->p_type == PT_LOAD)
break; break;
if (i >= (unsigned int)elf64->e_phnum) if (i >= (unsigned int)elf64->e_phnum)
return 0; return 0;
@ -193,7 +193,7 @@ static int is_elf32(void *hdr)
elf32 = (Elf32_Ehdr *)elfheader; elf32 = (Elf32_Ehdr *)elfheader;
elf32ph = (Elf32_Phdr *) ((unsigned long)elf32 + elf32->e_phoff); elf32ph = (Elf32_Phdr *) ((unsigned long)elf32 + elf32->e_phoff);
for (i = 0; i < elf32->e_phnum; i++, elf32ph++) for (i = 0; i < elf32->e_phnum; i++, elf32ph++)
if (elf32ph->p_type == PT_LOAD && elf32ph->p_offset != 0) if (elf32ph->p_type == PT_LOAD)
break; break;
if (i >= elf32->e_phnum) if (i >= elf32->e_phnum)
return 0; return 0;

View File

@ -0,0 +1,721 @@
#
# Automatically generated make config: don't edit
# Linux kernel version:
# Sat Jan 14 15:57:54 2006
#
# CONFIG_PPC64 is not set
CONFIG_PPC32=y
CONFIG_PPC_MERGE=y
CONFIG_MMU=y
CONFIG_GENERIC_HARDIRQS=y
CONFIG_RWSEM_XCHGADD_ALGORITHM=y
CONFIG_GENERIC_CALIBRATE_DELAY=y
CONFIG_PPC=y
CONFIG_EARLY_PRINTK=y
CONFIG_GENERIC_NVRAM=y
CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y
CONFIG_ARCH_MAY_HAVE_PC_FDC=y
CONFIG_PPC_OF=y
CONFIG_PPC_UDBG_16550=y
# CONFIG_GENERIC_TBSYNC is not set
#
# Processor support
#
# CONFIG_CLASSIC32 is not set
# CONFIG_PPC_52xx is not set
# CONFIG_PPC_82xx is not set
# CONFIG_PPC_83xx is not set
CONFIG_PPC_85xx=y
# CONFIG_40x is not set
# CONFIG_44x is not set
# CONFIG_8xx is not set
# CONFIG_E200 is not set
CONFIG_85xx=y
CONFIG_E500=y
CONFIG_BOOKE=y
CONFIG_FSL_BOOKE=y
# CONFIG_PHYS_64BIT is not set
CONFIG_SPE=y
#
# Code maturity level options
#
CONFIG_EXPERIMENTAL=y
CONFIG_CLEAN_COMPILE=y
CONFIG_BROKEN_ON_SMP=y
CONFIG_INIT_ENV_ARG_LIMIT=32
#
# General setup
#
CONFIG_LOCALVERSION=""
CONFIG_LOCALVERSION_AUTO=y
CONFIG_SWAP=y
CONFIG_SYSVIPC=y
# CONFIG_POSIX_MQUEUE is not set
# CONFIG_BSD_PROCESS_ACCT is not set
CONFIG_SYSCTL=y
# CONFIG_AUDIT is not set
# CONFIG_IKCONFIG is not set
CONFIG_INITRAMFS_SOURCE=""
# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
CONFIG_EMBEDDED=y
CONFIG_KALLSYMS=y
# CONFIG_KALLSYMS_ALL is not set
# CONFIG_KALLSYMS_EXTRA_PASS is not set
CONFIG_HOTPLUG=y
CONFIG_PRINTK=y
CONFIG_BUG=y
CONFIG_ELF_CORE=y
CONFIG_BASE_FULL=y
CONFIG_FUTEX=y
CONFIG_EPOLL=y
CONFIG_SHMEM=y
CONFIG_CC_ALIGN_FUNCTIONS=0
CONFIG_CC_ALIGN_LABELS=0
CONFIG_CC_ALIGN_LOOPS=0
CONFIG_CC_ALIGN_JUMPS=0
CONFIG_SLAB=y
# CONFIG_TINY_SHMEM is not set
CONFIG_BASE_SMALL=0
# CONFIG_SLOB is not set
#
# Loadable module support
#
# CONFIG_MODULES is not set
#
# Block layer
#
# CONFIG_LBD is not set
#
# IO Schedulers
#
CONFIG_IOSCHED_NOOP=y
CONFIG_IOSCHED_AS=y
CONFIG_IOSCHED_DEADLINE=y
CONFIG_IOSCHED_CFQ=y
CONFIG_DEFAULT_AS=y
# CONFIG_DEFAULT_DEADLINE is not set
# CONFIG_DEFAULT_CFQ is not set
# CONFIG_DEFAULT_NOOP is not set
CONFIG_DEFAULT_IOSCHED="anticipatory"
CONFIG_MPIC=y
# CONFIG_WANT_EARLY_SERIAL is not set
#
# Platform support
#
CONFIG_MPC8540_ADS=y
CONFIG_MPC8540=y
CONFIG_PPC_INDIRECT_PCI_BE=y
#
# Kernel options
#
# CONFIG_HIGHMEM is not set
# CONFIG_HZ_100 is not set
CONFIG_HZ_250=y
# CONFIG_HZ_1000 is not set
CONFIG_HZ=250
CONFIG_PREEMPT_NONE=y
# CONFIG_PREEMPT_VOLUNTARY is not set
# CONFIG_PREEMPT is not set
CONFIG_BINFMT_ELF=y
CONFIG_BINFMT_MISC=y
CONFIG_MATH_EMULATION=y
CONFIG_ARCH_FLATMEM_ENABLE=y
CONFIG_SELECT_MEMORY_MODEL=y
CONFIG_FLATMEM_MANUAL=y
# CONFIG_DISCONTIGMEM_MANUAL is not set
# CONFIG_SPARSEMEM_MANUAL is not set
CONFIG_FLATMEM=y
CONFIG_FLAT_NODE_MEM_MAP=y
# CONFIG_SPARSEMEM_STATIC is not set
CONFIG_SPLIT_PTLOCK_CPUS=4
CONFIG_PROC_DEVICETREE=y
# CONFIG_CMDLINE_BOOL is not set
# CONFIG_PM is not set
# CONFIG_SOFTWARE_SUSPEND is not set
# CONFIG_SECCOMP is not set
CONFIG_ISA_DMA_API=y
#
# Bus options
#
# CONFIG_PPC_I8259 is not set
CONFIG_PPC_INDIRECT_PCI=y
CONFIG_FSL_SOC=y
# CONFIG_PCI is not set
# CONFIG_PCI_DOMAINS is not set
#
# PCCARD (PCMCIA/CardBus) support
#
# CONFIG_PCCARD is not set
#
# PCI Hotplug Support
#
#
# Advanced setup
#
# CONFIG_ADVANCED_OPTIONS is not set
#
# Default settings for advanced configuration options are used
#
CONFIG_HIGHMEM_START=0xfe000000
CONFIG_LOWMEM_SIZE=0x30000000
CONFIG_KERNEL_START=0xc0000000
CONFIG_TASK_SIZE=0x80000000
CONFIG_BOOT_LOAD=0x00800000
#
# Networking
#
CONFIG_NET=y
#
# Networking options
#
CONFIG_PACKET=y
# CONFIG_PACKET_MMAP is not set
CONFIG_UNIX=y
# CONFIG_NET_KEY is not set
CONFIG_INET=y
CONFIG_IP_MULTICAST=y
# CONFIG_IP_ADVANCED_ROUTER is not set
CONFIG_IP_FIB_HASH=y
CONFIG_IP_PNP=y
CONFIG_IP_PNP_DHCP=y
CONFIG_IP_PNP_BOOTP=y
# CONFIG_IP_PNP_RARP is not set
# CONFIG_NET_IPIP is not set
# CONFIG_NET_IPGRE is not set
# CONFIG_IP_MROUTE is not set
# CONFIG_ARPD is not set
CONFIG_SYN_COOKIES=y
# CONFIG_INET_AH is not set
# CONFIG_INET_ESP is not set
# CONFIG_INET_IPCOMP is not set
# CONFIG_INET_TUNNEL is not set
CONFIG_INET_DIAG=y
CONFIG_INET_TCP_DIAG=y
# CONFIG_TCP_CONG_ADVANCED is not set
CONFIG_TCP_CONG_BIC=y
# CONFIG_IPV6 is not set
# CONFIG_NETFILTER is not set
#
# DCCP Configuration (EXPERIMENTAL)
#
# CONFIG_IP_DCCP is not set
#
# SCTP Configuration (EXPERIMENTAL)
#
# CONFIG_IP_SCTP is not set
# CONFIG_ATM is not set
# CONFIG_BRIDGE is not set
# CONFIG_VLAN_8021Q is not set
# CONFIG_DECNET is not set
# CONFIG_LLC2 is not set
# CONFIG_IPX is not set
# CONFIG_ATALK is not set
# CONFIG_X25 is not set
# CONFIG_LAPB is not set
#
# TIPC Configuration (EXPERIMENTAL)
#
# CONFIG_TIPC is not set
# CONFIG_NET_DIVERT is not set
# CONFIG_ECONET is not set
# CONFIG_WAN_ROUTER is not set
#
# QoS and/or fair queueing
#
# CONFIG_NET_SCHED is not set
#
# Network testing
#
# CONFIG_NET_PKTGEN is not set
# CONFIG_HAMRADIO is not set
# CONFIG_IRDA is not set
# CONFIG_BT is not set
# CONFIG_IEEE80211 is not set
#
# Device Drivers
#
#
# Generic Driver Options
#
CONFIG_STANDALONE=y
CONFIG_PREVENT_FIRMWARE_BUILD=y
# CONFIG_FW_LOADER is not set
# CONFIG_DEBUG_DRIVER is not set
#
# Connector - unified userspace <-> kernelspace linker
#
# CONFIG_CONNECTOR is not set
#
# Memory Technology Devices (MTD)
#
# CONFIG_MTD is not set
#
# Parallel port support
#
# CONFIG_PARPORT is not set
#
# Plug and Play support
#
#
# Block devices
#
# CONFIG_BLK_DEV_FD is not set
# CONFIG_BLK_DEV_COW_COMMON is not set
CONFIG_BLK_DEV_LOOP=y
# CONFIG_BLK_DEV_CRYPTOLOOP is not set
# CONFIG_BLK_DEV_NBD is not set
CONFIG_BLK_DEV_RAM=y
CONFIG_BLK_DEV_RAM_COUNT=16
CONFIG_BLK_DEV_RAM_SIZE=32768
CONFIG_BLK_DEV_INITRD=y
# CONFIG_CDROM_PKTCDVD is not set
# CONFIG_ATA_OVER_ETH is not set
#
# ATA/ATAPI/MFM/RLL support
#
# CONFIG_IDE is not set
#
# SCSI device support
#
# CONFIG_RAID_ATTRS is not set
# CONFIG_SCSI is not set
#
# Multi-device support (RAID and LVM)
#
# CONFIG_MD is not set
#
# Fusion MPT device support
#
# CONFIG_FUSION is not set
#
# IEEE 1394 (FireWire) support
#
#
# I2O device support
#
#
# Macintosh device drivers
#
# CONFIG_WINDFARM is not set
#
# Network device support
#
CONFIG_NETDEVICES=y
# CONFIG_DUMMY is not set
# CONFIG_BONDING is not set
# CONFIG_EQUALIZER is not set
# CONFIG_TUN is not set
#
# PHY device support
#
CONFIG_PHYLIB=y
#
# MII PHY device drivers
#
# CONFIG_MARVELL_PHY is not set
# CONFIG_DAVICOM_PHY is not set
# CONFIG_QSEMI_PHY is not set
# CONFIG_LXT_PHY is not set
# CONFIG_CICADA_PHY is not set
#
# Ethernet (10 or 100Mbit)
#
CONFIG_NET_ETHERNET=y
CONFIG_MII=y
#
# Ethernet (1000 Mbit)
#
CONFIG_GIANFAR=y
CONFIG_GFAR_NAPI=y
#
# Ethernet (10000 Mbit)
#
#
# Token Ring devices
#
#
# Wireless LAN (non-hamradio)
#
# CONFIG_NET_RADIO is not set
#
# Wan interfaces
#
# CONFIG_WAN is not set
# CONFIG_PPP is not set
# CONFIG_SLIP is not set
# CONFIG_SHAPER is not set
# CONFIG_NETCONSOLE is not set
# CONFIG_NETPOLL is not set
# CONFIG_NET_POLL_CONTROLLER is not set
#
# ISDN subsystem
#
# CONFIG_ISDN is not set
#
# Telephony Support
#
# CONFIG_PHONE is not set
#
# Input device support
#
CONFIG_INPUT=y
#
# Userland interfaces
#
# CONFIG_INPUT_MOUSEDEV is not set
# CONFIG_INPUT_JOYDEV is not set
# CONFIG_INPUT_TSDEV is not set
# CONFIG_INPUT_EVDEV is not set
# CONFIG_INPUT_EVBUG is not set
#
# Input Device Drivers
#
# CONFIG_INPUT_KEYBOARD is not set
# CONFIG_INPUT_MOUSE is not set
# CONFIG_INPUT_JOYSTICK is not set
# CONFIG_INPUT_TOUCHSCREEN is not set
# CONFIG_INPUT_MISC is not set
#
# Hardware I/O ports
#
# CONFIG_SERIO is not set
# CONFIG_GAMEPORT is not set
#
# Character devices
#
# CONFIG_VT is not set
# CONFIG_SERIAL_NONSTANDARD is not set
#
# Serial drivers
#
CONFIG_SERIAL_8250=y
CONFIG_SERIAL_8250_CONSOLE=y
CONFIG_SERIAL_8250_NR_UARTS=4
CONFIG_SERIAL_8250_RUNTIME_UARTS=4
# CONFIG_SERIAL_8250_EXTENDED is not set
#
# Non-8250 serial port support
#
CONFIG_SERIAL_CORE=y
CONFIG_SERIAL_CORE_CONSOLE=y
CONFIG_UNIX98_PTYS=y
CONFIG_LEGACY_PTYS=y
CONFIG_LEGACY_PTY_COUNT=256
#
# IPMI
#
# CONFIG_IPMI_HANDLER is not set
#
# Watchdog Cards
#
# CONFIG_WATCHDOG is not set
# CONFIG_NVRAM is not set
CONFIG_GEN_RTC=y
# CONFIG_GEN_RTC_X is not set
# CONFIG_DTLK is not set
# CONFIG_R3964 is not set
#
# Ftape, the floppy tape device driver
#
# CONFIG_AGP is not set
# CONFIG_RAW_DRIVER is not set
#
# TPM devices
#
# CONFIG_TCG_TPM is not set
# CONFIG_TELCLOCK is not set
#
# I2C support
#
# CONFIG_I2C is not set
#
# Dallas's 1-wire bus
#
# CONFIG_W1 is not set
#
# Hardware Monitoring support
#
CONFIG_HWMON=y
# CONFIG_HWMON_VID is not set
# CONFIG_HWMON_DEBUG_CHIP is not set
#
# Misc devices
#
#
# Multimedia Capabilities Port drivers
#
#
# Multimedia devices
#
# CONFIG_VIDEO_DEV is not set
#
# Digital Video Broadcasting Devices
#
# CONFIG_DVB is not set
#
# Graphics support
#
# CONFIG_FB is not set
#
# Sound
#
# CONFIG_SOUND is not set
#
# USB support
#
# CONFIG_USB_ARCH_HAS_HCD is not set
# CONFIG_USB_ARCH_HAS_OHCI is not set
#
# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
#
#
# USB Gadget Support
#
# CONFIG_USB_GADGET is not set
#
# MMC/SD Card support
#
# CONFIG_MMC is not set
#
# InfiniBand support
#
#
# SN Devices
#
#
# File systems
#
CONFIG_EXT2_FS=y
# CONFIG_EXT2_FS_XATTR is not set
# CONFIG_EXT2_FS_XIP is not set
CONFIG_EXT3_FS=y
CONFIG_EXT3_FS_XATTR=y
# CONFIG_EXT3_FS_POSIX_ACL is not set
# CONFIG_EXT3_FS_SECURITY is not set
CONFIG_JBD=y
# CONFIG_JBD_DEBUG is not set
CONFIG_FS_MBCACHE=y
# CONFIG_REISERFS_FS is not set
# CONFIG_JFS_FS is not set
# CONFIG_FS_POSIX_ACL is not set
# CONFIG_XFS_FS is not set
# CONFIG_OCFS2_FS is not set
# CONFIG_MINIX_FS is not set
# CONFIG_ROMFS_FS is not set
CONFIG_INOTIFY=y
# CONFIG_QUOTA is not set
CONFIG_DNOTIFY=y
# CONFIG_AUTOFS_FS is not set
# CONFIG_AUTOFS4_FS is not set
# CONFIG_FUSE_FS is not set
#
# CD-ROM/DVD Filesystems
#
# CONFIG_ISO9660_FS is not set
# CONFIG_UDF_FS is not set
#
# DOS/FAT/NT Filesystems
#
# CONFIG_MSDOS_FS is not set
# CONFIG_VFAT_FS is not set
# CONFIG_NTFS_FS is not set
#
# Pseudo filesystems
#
CONFIG_PROC_FS=y
CONFIG_PROC_KCORE=y
CONFIG_SYSFS=y
CONFIG_TMPFS=y
# CONFIG_HUGETLB_PAGE is not set
CONFIG_RAMFS=y
# CONFIG_RELAYFS_FS is not set
# CONFIG_CONFIGFS_FS is not set
#
# Miscellaneous filesystems
#
# CONFIG_ADFS_FS is not set
# CONFIG_AFFS_FS is not set
# CONFIG_HFS_FS is not set
# CONFIG_HFSPLUS_FS is not set
# CONFIG_BEFS_FS is not set
# CONFIG_BFS_FS is not set
# CONFIG_EFS_FS is not set
# CONFIG_CRAMFS is not set
# CONFIG_VXFS_FS is not set
# CONFIG_HPFS_FS is not set
# CONFIG_QNX4FS_FS is not set
# CONFIG_SYSV_FS is not set
# CONFIG_UFS_FS is not set
#
# Network File Systems
#
CONFIG_NFS_FS=y
# CONFIG_NFS_V3 is not set
# CONFIG_NFS_V4 is not set
# CONFIG_NFS_DIRECTIO is not set
# CONFIG_NFSD is not set
CONFIG_ROOT_NFS=y
CONFIG_LOCKD=y
CONFIG_NFS_COMMON=y
CONFIG_SUNRPC=y
# CONFIG_RPCSEC_GSS_KRB5 is not set
# CONFIG_RPCSEC_GSS_SPKM3 is not set
# CONFIG_SMB_FS is not set
# CONFIG_CIFS is not set
# CONFIG_NCP_FS is not set
# CONFIG_CODA_FS is not set
# CONFIG_AFS_FS is not set
# CONFIG_9P_FS is not set
#
# Partition Types
#
CONFIG_PARTITION_ADVANCED=y
# CONFIG_ACORN_PARTITION is not set
# CONFIG_OSF_PARTITION is not set
# CONFIG_AMIGA_PARTITION is not set
# CONFIG_ATARI_PARTITION is not set
# CONFIG_MAC_PARTITION is not set
# CONFIG_MSDOS_PARTITION is not set
# CONFIG_LDM_PARTITION is not set
# CONFIG_SGI_PARTITION is not set
# CONFIG_ULTRIX_PARTITION is not set
# CONFIG_SUN_PARTITION is not set
# CONFIG_EFI_PARTITION is not set
#
# Native Language Support
#
# CONFIG_NLS is not set
#
# Library routines
#
# CONFIG_CRC_CCITT is not set
# CONFIG_CRC16 is not set
CONFIG_CRC32=y
# CONFIG_LIBCRC32C is not set
#
# Instrumentation Support
#
# CONFIG_PROFILING is not set
#
# Kernel hacking
#
# CONFIG_PRINTK_TIME is not set
# CONFIG_MAGIC_SYSRQ is not set
CONFIG_DEBUG_KERNEL=y
CONFIG_LOG_BUF_SHIFT=14
CONFIG_DETECT_SOFTLOCKUP=y
# CONFIG_SCHEDSTATS is not set
# CONFIG_DEBUG_SLAB is not set
CONFIG_DEBUG_MUTEXES=y
# CONFIG_DEBUG_SPINLOCK is not set
# CONFIG_DEBUG_SPINLOCK_SLEEP is not set
# CONFIG_DEBUG_KOBJECT is not set
# CONFIG_DEBUG_INFO is not set
# CONFIG_DEBUG_FS is not set
# CONFIG_DEBUG_VM is not set
# CONFIG_RCU_TORTURE_TEST is not set
# CONFIG_DEBUGGER is not set
# CONFIG_BDI_SWITCH is not set
# CONFIG_BOOTX_TEXT is not set
# CONFIG_PPC_EARLY_DEBUG_LPAR is not set
# CONFIG_PPC_EARLY_DEBUG_G5 is not set
# CONFIG_PPC_EARLY_DEBUG_RTAS is not set
# CONFIG_PPC_EARLY_DEBUG_MAPLE is not set
# CONFIG_PPC_EARLY_DEBUG_ISERIES is not set
#
# Security options
#
# CONFIG_KEYS is not set
# CONFIG_SECURITY is not set
#
# Cryptographic options
#
# CONFIG_CRYPTO is not set
#
# Hardware crypto devices
#

View File

@ -136,6 +136,9 @@ int main(void)
DEFINE(PACAEMERGSP, offsetof(struct paca_struct, emergency_sp)); DEFINE(PACAEMERGSP, offsetof(struct paca_struct, emergency_sp));
DEFINE(PACALPPACAPTR, offsetof(struct paca_struct, lppaca_ptr)); DEFINE(PACALPPACAPTR, offsetof(struct paca_struct, lppaca_ptr));
DEFINE(PACAHWCPUID, offsetof(struct paca_struct, hw_cpu_id)); DEFINE(PACAHWCPUID, offsetof(struct paca_struct, hw_cpu_id));
DEFINE(PACA_STARTPURR, offsetof(struct paca_struct, startpurr));
DEFINE(PACA_USER_TIME, offsetof(struct paca_struct, user_time));
DEFINE(PACA_SYSTEM_TIME, offsetof(struct paca_struct, system_time));
DEFINE(LPPACASRR0, offsetof(struct lppaca, saved_srr0)); DEFINE(LPPACASRR0, offsetof(struct lppaca, saved_srr0));
DEFINE(LPPACASRR1, offsetof(struct lppaca, saved_srr1)); DEFINE(LPPACASRR1, offsetof(struct lppaca, saved_srr1));

View File

@ -894,7 +894,7 @@ struct cpu_spec cpu_specs[] = {
.platform = "ppc405", .platform = "ppc405",
}, },
{ /* Xilinx Virtex-II Pro */ { /* Xilinx Virtex-II Pro */
.pvr_mask = 0xffff0000, .pvr_mask = 0xfffff000,
.pvr_value = 0x20010000, .pvr_value = 0x20010000,
.cpu_name = "Virtex-II Pro", .cpu_name = "Virtex-II Pro",
.cpu_features = CPU_FTRS_40X, .cpu_features = CPU_FTRS_40X,
@ -904,6 +904,16 @@ struct cpu_spec cpu_specs[] = {
.dcache_bsize = 32, .dcache_bsize = 32,
.platform = "ppc405", .platform = "ppc405",
}, },
{ /* Xilinx Virtex-4 FX */
.pvr_mask = 0xfffff000,
.pvr_value = 0x20011000,
.cpu_name = "Virtex-4 FX",
.cpu_features = CPU_FTRS_40X,
.cpu_user_features = PPC_FEATURE_32 |
PPC_FEATURE_HAS_MMU | PPC_FEATURE_HAS_4xxMAC,
.icache_bsize = 32,
.dcache_bsize = 32,
},
{ /* 405EP */ { /* 405EP */
.pvr_mask = 0xffff0000, .pvr_mask = 0xffff0000,
.pvr_value = 0x51210000, .pvr_value = 0x51210000,

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc64/kernel/entry.S
*
* PowerPC version * PowerPC version
* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
* Rewritten by Cort Dougan (cort@cs.nmt.edu) for PReP * Rewritten by Cort Dougan (cort@cs.nmt.edu) for PReP
@ -63,6 +61,7 @@ system_call_common:
std r12,_MSR(r1) std r12,_MSR(r1)
std r0,GPR0(r1) std r0,GPR0(r1)
std r10,GPR1(r1) std r10,GPR1(r1)
ACCOUNT_CPU_USER_ENTRY(r10, r11)
std r2,GPR2(r1) std r2,GPR2(r1)
std r3,GPR3(r1) std r3,GPR3(r1)
std r4,GPR4(r1) std r4,GPR4(r1)
@ -170,8 +169,9 @@ syscall_error_cont:
stdcx. r0,0,r1 /* to clear the reservation */ stdcx. r0,0,r1 /* to clear the reservation */
andi. r6,r8,MSR_PR andi. r6,r8,MSR_PR
ld r4,_LINK(r1) ld r4,_LINK(r1)
beq- 1f /* only restore r13 if */ beq- 1f
ld r13,GPR13(r1) /* returning to usermode */ ACCOUNT_CPU_USER_EXIT(r11, r12)
ld r13,GPR13(r1) /* only restore r13 if returning to usermode */
1: ld r2,GPR2(r1) 1: ld r2,GPR2(r1)
li r12,MSR_RI li r12,MSR_RI
andc r11,r10,r12 andc r11,r10,r12
@ -322,7 +322,7 @@ _GLOBAL(ret_from_fork)
* the fork code also. * the fork code also.
* *
* The code which creates the new task context is in 'copy_thread' * The code which creates the new task context is in 'copy_thread'
* in arch/ppc64/kernel/process.c * in arch/powerpc/kernel/process.c
*/ */
.align 7 .align 7
_GLOBAL(_switch) _GLOBAL(_switch)
@ -486,6 +486,7 @@ restore:
* userspace * userspace
*/ */
beq 1f beq 1f
ACCOUNT_CPU_USER_EXIT(r3, r4)
REST_GPR(13, r1) REST_GPR(13, r1)
1: 1:
ld r3,_CTR(r1) ld r3,_CTR(r1)

View File

@ -18,28 +18,3 @@
#include <asm/firmware.h> #include <asm/firmware.h>
unsigned long ppc64_firmware_features; unsigned long ppc64_firmware_features;
#ifdef CONFIG_PPC_PSERIES
firmware_feature_t firmware_features_table[FIRMWARE_MAX_FEATURES] = {
{FW_FEATURE_PFT, "hcall-pft"},
{FW_FEATURE_TCE, "hcall-tce"},
{FW_FEATURE_SPRG0, "hcall-sprg0"},
{FW_FEATURE_DABR, "hcall-dabr"},
{FW_FEATURE_COPY, "hcall-copy"},
{FW_FEATURE_ASR, "hcall-asr"},
{FW_FEATURE_DEBUG, "hcall-debug"},
{FW_FEATURE_PERF, "hcall-perf"},
{FW_FEATURE_DUMP, "hcall-dump"},
{FW_FEATURE_INTERRUPT, "hcall-interrupt"},
{FW_FEATURE_MIGRATE, "hcall-migrate"},
{FW_FEATURE_PERFMON, "hcall-perfmon"},
{FW_FEATURE_CRQ, "hcall-crq"},
{FW_FEATURE_VIO, "hcall-vio"},
{FW_FEATURE_RDMA, "hcall-rdma"},
{FW_FEATURE_LLAN, "hcall-lLAN"},
{FW_FEATURE_BULK, "hcall-bulk"},
{FW_FEATURE_XDABR, "hcall-xdabr"},
{FW_FEATURE_MULTITCE, "hcall-multi-tce"},
{FW_FEATURE_SPLPAR, "hcall-splpar"},
};
#endif

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/kernel/head_44x.S
*
* Kernel execution entry point code. * Kernel execution entry point code.
* *
* Copyright (c) 1995-1996 Gary Thomas <gdt@linuxppc.org> * Copyright (c) 1995-1996 Gary Thomas <gdt@linuxppc.org>

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc64/kernel/head.S
*
* PowerPC version * PowerPC version
* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
* *
@ -279,6 +277,7 @@ exception_marker:
std r10,0(r1); /* make stack chain pointer */ \ std r10,0(r1); /* make stack chain pointer */ \
std r0,GPR0(r1); /* save r0 in stackframe */ \ std r0,GPR0(r1); /* save r0 in stackframe */ \
std r10,GPR1(r1); /* save r1 in stackframe */ \ std r10,GPR1(r1); /* save r1 in stackframe */ \
ACCOUNT_CPU_USER_ENTRY(r9, r10); \
std r2,GPR2(r1); /* save r2 in stackframe */ \ std r2,GPR2(r1); /* save r2 in stackframe */ \
SAVE_4GPRS(3, r1); /* save r3 - r6 in stackframe */ \ SAVE_4GPRS(3, r1); /* save r3 - r6 in stackframe */ \
SAVE_2GPRS(7, r1); /* save r7, r8 in stackframe */ \ SAVE_2GPRS(7, r1); /* save r7, r8 in stackframe */ \
@ -846,6 +845,14 @@ fast_exception_return:
ld r11,_NIP(r1) ld r11,_NIP(r1)
andi. r3,r12,MSR_RI /* check if RI is set */ andi. r3,r12,MSR_RI /* check if RI is set */
beq- unrecov_fer beq- unrecov_fer
#ifdef CONFIG_VIRT_CPU_ACCOUNTING
andi. r3,r12,MSR_PR
beq 2f
ACCOUNT_CPU_USER_EXIT(r3, r4)
2:
#endif
ld r3,_CCR(r1) ld r3,_CCR(r1)
ld r4,_LINK(r1) ld r4,_LINK(r1)
ld r5,_CTR(r1) ld r5,_CTR(r1)

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/kernel/except_8xx.S
*
* PowerPC version * PowerPC version
* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
* Rewritten by Cort Dougan (cort@cs.nmt.edu) for PReP * Rewritten by Cort Dougan (cort@cs.nmt.edu) for PReP

View File

@ -0,0 +1,363 @@
#ifndef __HEAD_BOOKE_H__
#define __HEAD_BOOKE_H__
/*
* Macros used for common Book-e exception handling
*/
#define SET_IVOR(vector_number, vector_label) \
li r26,vector_label@l; \
mtspr SPRN_IVOR##vector_number,r26; \
sync
#define NORMAL_EXCEPTION_PROLOG \
mtspr SPRN_SPRG0,r10; /* save two registers to work with */\
mtspr SPRN_SPRG1,r11; \
mtspr SPRN_SPRG4W,r1; \
mfcr r10; /* save CR in r10 for now */\
mfspr r11,SPRN_SRR1; /* check whether user or kernel */\
andi. r11,r11,MSR_PR; \
beq 1f; \
mfspr r1,SPRN_SPRG3; /* if from user, start at top of */\
lwz r1,THREAD_INFO-THREAD(r1); /* this thread's kernel stack */\
addi r1,r1,THREAD_SIZE; \
1: subi r1,r1,INT_FRAME_SIZE; /* Allocate an exception frame */\
mr r11,r1; \
stw r10,_CCR(r11); /* save various registers */\
stw r12,GPR12(r11); \
stw r9,GPR9(r11); \
mfspr r10,SPRN_SPRG0; \
stw r10,GPR10(r11); \
mfspr r12,SPRN_SPRG1; \
stw r12,GPR11(r11); \
mflr r10; \
stw r10,_LINK(r11); \
mfspr r10,SPRN_SPRG4R; \
mfspr r12,SPRN_SRR0; \
stw r10,GPR1(r11); \
mfspr r9,SPRN_SRR1; \
stw r10,0(r11); \
rlwinm r9,r9,0,14,12; /* clear MSR_WE (necessary?) */\
stw r0,GPR0(r11); \
SAVE_4GPRS(3, r11); \
SAVE_2GPRS(7, r11)
/* To handle the additional exception priority levels on 40x and Book-E
* processors we allocate a 4k stack per additional priority level. The various
* head_xxx.S files allocate space (exception_stack_top) for each priority's
* stack times the number of CPUs
*
* On 40x critical is the only additional level
* On 44x/e500 we have critical and machine check
* On e200 we have critical and debug (machine check occurs via critical)
*
* Additionally we reserve a SPRG for each priority level so we can free up a
* GPR to use as the base for indirect access to the exception stacks. This
* is necessary since the MMU is always on, for Book-E parts, and the stacks
* are offset from KERNELBASE.
*
*/
#define BOOKE_EXCEPTION_STACK_SIZE (8192)
/* CRIT_SPRG only used in critical exception handling */
#define CRIT_SPRG SPRN_SPRG2
/* MCHECK_SPRG only used in machine check exception handling */
#define MCHECK_SPRG SPRN_SPRG6W
#define MCHECK_STACK_TOP (exception_stack_top - 4096)
#define CRIT_STACK_TOP (exception_stack_top)
/* only on e200 for now */
#define DEBUG_STACK_TOP (exception_stack_top - 4096)
#define DEBUG_SPRG SPRN_SPRG6W
#ifdef CONFIG_SMP
#define BOOKE_LOAD_EXC_LEVEL_STACK(level) \
mfspr r8,SPRN_PIR; \
mulli r8,r8,BOOKE_EXCEPTION_STACK_SIZE; \
neg r8,r8; \
addis r8,r8,level##_STACK_TOP@ha; \
addi r8,r8,level##_STACK_TOP@l
#else
#define BOOKE_LOAD_EXC_LEVEL_STACK(level) \
lis r8,level##_STACK_TOP@h; \
ori r8,r8,level##_STACK_TOP@l
#endif
/*
* Exception prolog for critical/machine check exceptions. This is a
* little different from the normal exception prolog above since a
* critical/machine check exception can potentially occur at any point
* during normal exception processing. Thus we cannot use the same SPRG
* registers as the normal prolog above. Instead we use a portion of the
* critical/machine check exception stack at low physical addresses.
*/
#define EXC_LEVEL_EXCEPTION_PROLOG(exc_level, exc_level_srr0, exc_level_srr1) \
mtspr exc_level##_SPRG,r8; \
BOOKE_LOAD_EXC_LEVEL_STACK(exc_level);/* r8 points to the exc_level stack*/ \
stw r10,GPR10-INT_FRAME_SIZE(r8); \
stw r11,GPR11-INT_FRAME_SIZE(r8); \
mfcr r10; /* save CR in r10 for now */\
mfspr r11,exc_level_srr1; /* check whether user or kernel */\
andi. r11,r11,MSR_PR; \
mr r11,r8; \
mfspr r8,exc_level##_SPRG; \
beq 1f; \
/* COMING FROM USER MODE */ \
mfspr r11,SPRN_SPRG3; /* if from user, start at top of */\
lwz r11,THREAD_INFO-THREAD(r11); /* this thread's kernel stack */\
addi r11,r11,THREAD_SIZE; \
1: subi r11,r11,INT_FRAME_SIZE; /* Allocate an exception frame */\
stw r10,_CCR(r11); /* save various registers */\
stw r12,GPR12(r11); \
stw r9,GPR9(r11); \
mflr r10; \
stw r10,_LINK(r11); \
mfspr r12,SPRN_DEAR; /* save DEAR and ESR in the frame */\
stw r12,_DEAR(r11); /* since they may have had stuff */\
mfspr r9,SPRN_ESR; /* in them at the point where the */\
stw r9,_ESR(r11); /* exception was taken */\
mfspr r12,exc_level_srr0; \
stw r1,GPR1(r11); \
mfspr r9,exc_level_srr1; \
stw r1,0(r11); \
mr r1,r11; \
rlwinm r9,r9,0,14,12; /* clear MSR_WE (necessary?) */\
stw r0,GPR0(r11); \
SAVE_4GPRS(3, r11); \
SAVE_2GPRS(7, r11)
#define CRITICAL_EXCEPTION_PROLOG \
EXC_LEVEL_EXCEPTION_PROLOG(CRIT, SPRN_CSRR0, SPRN_CSRR1)
#define DEBUG_EXCEPTION_PROLOG \
EXC_LEVEL_EXCEPTION_PROLOG(DEBUG, SPRN_DSRR0, SPRN_DSRR1)
#define MCHECK_EXCEPTION_PROLOG \
EXC_LEVEL_EXCEPTION_PROLOG(MCHECK, SPRN_MCSRR0, SPRN_MCSRR1)
/*
* Exception vectors.
*/
#define START_EXCEPTION(label) \
.align 5; \
label:
#define FINISH_EXCEPTION(func) \
bl transfer_to_handler_full; \
.long func; \
.long ret_from_except_full
#define EXCEPTION(n, label, hdlr, xfer) \
START_EXCEPTION(label); \
NORMAL_EXCEPTION_PROLOG; \
addi r3,r1,STACK_FRAME_OVERHEAD; \
xfer(n, hdlr)
#define CRITICAL_EXCEPTION(n, label, hdlr) \
START_EXCEPTION(label); \
CRITICAL_EXCEPTION_PROLOG; \
addi r3,r1,STACK_FRAME_OVERHEAD; \
EXC_XFER_TEMPLATE(hdlr, n+2, (MSR_KERNEL & ~(MSR_ME|MSR_DE|MSR_CE)), \
NOCOPY, crit_transfer_to_handler, \
ret_from_crit_exc)
#define MCHECK_EXCEPTION(n, label, hdlr) \
START_EXCEPTION(label); \
MCHECK_EXCEPTION_PROLOG; \
mfspr r5,SPRN_ESR; \
stw r5,_ESR(r11); \
addi r3,r1,STACK_FRAME_OVERHEAD; \
EXC_XFER_TEMPLATE(hdlr, n+2, (MSR_KERNEL & ~(MSR_ME|MSR_DE|MSR_CE)), \
NOCOPY, mcheck_transfer_to_handler, \
ret_from_mcheck_exc)
#define EXC_XFER_TEMPLATE(hdlr, trap, msr, copyee, tfer, ret) \
li r10,trap; \
stw r10,_TRAP(r11); \
lis r10,msr@h; \
ori r10,r10,msr@l; \
copyee(r10, r9); \
bl tfer; \
.long hdlr; \
.long ret
#define COPY_EE(d, s) rlwimi d,s,0,16,16
#define NOCOPY(d, s)
#define EXC_XFER_STD(n, hdlr) \
EXC_XFER_TEMPLATE(hdlr, n, MSR_KERNEL, NOCOPY, transfer_to_handler_full, \
ret_from_except_full)
#define EXC_XFER_LITE(n, hdlr) \
EXC_XFER_TEMPLATE(hdlr, n+1, MSR_KERNEL, NOCOPY, transfer_to_handler, \
ret_from_except)
#define EXC_XFER_EE(n, hdlr) \
EXC_XFER_TEMPLATE(hdlr, n, MSR_KERNEL, COPY_EE, transfer_to_handler_full, \
ret_from_except_full)
#define EXC_XFER_EE_LITE(n, hdlr) \
EXC_XFER_TEMPLATE(hdlr, n+1, MSR_KERNEL, COPY_EE, transfer_to_handler, \
ret_from_except)
/* Check for a single step debug exception while in an exception
* handler before state has been saved. This is to catch the case
* where an instruction that we are trying to single step causes
* an exception (eg ITLB/DTLB miss) and thus the first instruction of
* the exception handler generates a single step debug exception.
*
* If we get a debug trap on the first instruction of an exception handler,
* we reset the MSR_DE in the _exception handler's_ MSR (the debug trap is
* a critical exception, so we are using SPRN_CSRR1 to manipulate the MSR).
* The exception handler was handling a non-critical interrupt, so it will
* save (and later restore) the MSR via SPRN_CSRR1, which will still have
* the MSR_DE bit set.
*/
#ifdef CONFIG_E200
#define DEBUG_EXCEPTION \
START_EXCEPTION(Debug); \
DEBUG_EXCEPTION_PROLOG; \
\
/* \
* If there is a single step or branch-taken exception in an \
* exception entry sequence, it was probably meant to apply to \
* the code where the exception occurred (since exception entry \
* doesn't turn off DE automatically). We simulate the effect \
* of turning off DE on entry to an exception handler by turning \
* off DE in the CSRR1 value and clearing the debug status. \
*/ \
mfspr r10,SPRN_DBSR; /* check single-step/branch taken */ \
andis. r10,r10,DBSR_IC@h; \
beq+ 2f; \
\
lis r10,KERNELBASE@h; /* check if exception in vectors */ \
ori r10,r10,KERNELBASE@l; \
cmplw r12,r10; \
blt+ 2f; /* addr below exception vectors */ \
\
lis r10,Debug@h; \
ori r10,r10,Debug@l; \
cmplw r12,r10; \
bgt+ 2f; /* addr above exception vectors */ \
\
/* here it looks like we got an inappropriate debug exception. */ \
1: rlwinm r9,r9,0,~MSR_DE; /* clear DE in the CDRR1 value */ \
lis r10,DBSR_IC@h; /* clear the IC event */ \
mtspr SPRN_DBSR,r10; \
/* restore state and get out */ \
lwz r10,_CCR(r11); \
lwz r0,GPR0(r11); \
lwz r1,GPR1(r11); \
mtcrf 0x80,r10; \
mtspr SPRN_DSRR0,r12; \
mtspr SPRN_DSRR1,r9; \
lwz r9,GPR9(r11); \
lwz r12,GPR12(r11); \
mtspr DEBUG_SPRG,r8; \
BOOKE_LOAD_EXC_LEVEL_STACK(DEBUG); /* r8 points to the debug stack */ \
lwz r10,GPR10-INT_FRAME_SIZE(r8); \
lwz r11,GPR11-INT_FRAME_SIZE(r8); \
mfspr r8,DEBUG_SPRG; \
\
RFDI; \
b .; \
\
/* continue normal handling for a critical exception... */ \
2: mfspr r4,SPRN_DBSR; \
addi r3,r1,STACK_FRAME_OVERHEAD; \
EXC_XFER_TEMPLATE(DebugException, 0x2002, (MSR_KERNEL & ~(MSR_ME|MSR_DE|MSR_CE)), NOCOPY, debug_transfer_to_handler, ret_from_debug_exc)
#else
#define DEBUG_EXCEPTION \
START_EXCEPTION(Debug); \
CRITICAL_EXCEPTION_PROLOG; \
\
/* \
* If there is a single step or branch-taken exception in an \
* exception entry sequence, it was probably meant to apply to \
* the code where the exception occurred (since exception entry \
* doesn't turn off DE automatically). We simulate the effect \
* of turning off DE on entry to an exception handler by turning \
* off DE in the CSRR1 value and clearing the debug status. \
*/ \
mfspr r10,SPRN_DBSR; /* check single-step/branch taken */ \
andis. r10,r10,DBSR_IC@h; \
beq+ 2f; \
\
lis r10,KERNELBASE@h; /* check if exception in vectors */ \
ori r10,r10,KERNELBASE@l; \
cmplw r12,r10; \
blt+ 2f; /* addr below exception vectors */ \
\
lis r10,Debug@h; \
ori r10,r10,Debug@l; \
cmplw r12,r10; \
bgt+ 2f; /* addr above exception vectors */ \
\
/* here it looks like we got an inappropriate debug exception. */ \
1: rlwinm r9,r9,0,~MSR_DE; /* clear DE in the CSRR1 value */ \
lis r10,DBSR_IC@h; /* clear the IC event */ \
mtspr SPRN_DBSR,r10; \
/* restore state and get out */ \
lwz r10,_CCR(r11); \
lwz r0,GPR0(r11); \
lwz r1,GPR1(r11); \
mtcrf 0x80,r10; \
mtspr SPRN_CSRR0,r12; \
mtspr SPRN_CSRR1,r9; \
lwz r9,GPR9(r11); \
lwz r12,GPR12(r11); \
mtspr CRIT_SPRG,r8; \
BOOKE_LOAD_EXC_LEVEL_STACK(CRIT); /* r8 points to the debug stack */ \
lwz r10,GPR10-INT_FRAME_SIZE(r8); \
lwz r11,GPR11-INT_FRAME_SIZE(r8); \
mfspr r8,CRIT_SPRG; \
\
rfci; \
b .; \
\
/* continue normal handling for a critical exception... */ \
2: mfspr r4,SPRN_DBSR; \
addi r3,r1,STACK_FRAME_OVERHEAD; \
EXC_XFER_TEMPLATE(DebugException, 0x2002, (MSR_KERNEL & ~(MSR_ME|MSR_DE|MSR_CE)), NOCOPY, crit_transfer_to_handler, ret_from_crit_exc)
#endif
#define INSTRUCTION_STORAGE_EXCEPTION \
START_EXCEPTION(InstructionStorage) \
NORMAL_EXCEPTION_PROLOG; \
mfspr r5,SPRN_ESR; /* Grab the ESR and save it */ \
stw r5,_ESR(r11); \
mr r4,r12; /* Pass SRR0 as arg2 */ \
li r5,0; /* Pass zero as arg3 */ \
EXC_XFER_EE_LITE(0x0400, handle_page_fault)
#define ALIGNMENT_EXCEPTION \
START_EXCEPTION(Alignment) \
NORMAL_EXCEPTION_PROLOG; \
mfspr r4,SPRN_DEAR; /* Grab the DEAR and save it */ \
stw r4,_DEAR(r11); \
addi r3,r1,STACK_FRAME_OVERHEAD; \
EXC_XFER_EE(0x0600, alignment_exception)
#define PROGRAM_EXCEPTION \
START_EXCEPTION(Program) \
NORMAL_EXCEPTION_PROLOG; \
mfspr r4,SPRN_ESR; /* Grab the ESR and save it */ \
stw r4,_ESR(r11); \
addi r3,r1,STACK_FRAME_OVERHEAD; \
EXC_XFER_STD(0x0700, program_check_exception)
#define DECREMENTER_EXCEPTION \
START_EXCEPTION(Decrementer) \
NORMAL_EXCEPTION_PROLOG; \
lis r0,TSR_DIS@h; /* Setup the DEC interrupt mask */ \
mtspr SPRN_TSR,r0; /* Clear the DEC interrupt */ \
addi r3,r1,STACK_FRAME_OVERHEAD; \
EXC_XFER_LITE(0x0900, timer_interrupt)
#define FP_UNAVAILABLE_EXCEPTION \
START_EXCEPTION(FloatingPointUnavailable) \
NORMAL_EXCEPTION_PROLOG; \
bne load_up_fpu; /* if from user, just load it up */ \
addi r3,r1,STACK_FRAME_OVERHEAD; \
EXC_XFER_EE_LITE(0x800, kernel_fp_unavailable_exception)
#endif /* __HEAD_BOOKE_H__ */

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/kernel/head_fsl_booke.S
*
* Kernel execution entry point code. * Kernel execution entry point code.
* *
* Copyright (c) 1995-1996 Gary Thomas <gdt@linuxppc.org> * Copyright (c) 1995-1996 Gary Thomas <gdt@linuxppc.org>
@ -316,6 +314,7 @@ skpinv: addi r6,r6,1 /* Increment */
*/ */
lis r2,DBCR0_IDM@h lis r2,DBCR0_IDM@h
mtspr SPRN_DBCR0,r2 mtspr SPRN_DBCR0,r2
isync
/* clear any residual debug events */ /* clear any residual debug events */
li r2,-1 li r2,-1
mtspr SPRN_DBSR,r2 mtspr SPRN_DBSR,r2
@ -1002,12 +1001,15 @@ _GLOBAL(giveup_fpu)
_GLOBAL(abort) _GLOBAL(abort)
li r13,0 li r13,0
mtspr SPRN_DBCR0,r13 /* disable all debug events */ mtspr SPRN_DBCR0,r13 /* disable all debug events */
isync
mfmsr r13 mfmsr r13
ori r13,r13,MSR_DE@l /* Enable Debug Events */ ori r13,r13,MSR_DE@l /* Enable Debug Events */
mtmsr r13 mtmsr r13
isync
mfspr r13,SPRN_DBCR0 mfspr r13,SPRN_DBCR0
lis r13,(DBCR0_IDM|DBCR0_RST_CHIP)@h lis r13,(DBCR0_IDM|DBCR0_RST_CHIP)@h
mtspr SPRN_DBCR0,r13 mtspr SPRN_DBCR0,r13
isync
_GLOBAL(set_context) _GLOBAL(set_context)

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc64/kernel/iomap.c
*
* ppc64 "iomap" interface implementation. * ppc64 "iomap" interface implementation.
* *
* (C) Copyright 2004 Linus Torvalds * (C) Copyright 2004 Linus Torvalds

View File

@ -1,5 +1,4 @@
/* /*
* arch/ppc64/kernel/iommu.c
* Copyright (C) 2001 Mike Corrigan & Dave Engebretsen, IBM Corporation * Copyright (C) 2001 Mike Corrigan & Dave Engebretsen, IBM Corporation
* *
* Rewrite, cleanup, new allocation schemes, virtual merging: * Rewrite, cleanup, new allocation schemes, virtual merging:

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/kernel/irq.c
*
* Derived from arch/i386/kernel/irq.c * Derived from arch/i386/kernel/irq.c
* Copyright (C) 1992 Linus Torvalds * Copyright (C) 1992 Linus Torvalds
* Adapted from arch/i386 by Gary Thomas * Adapted from arch/i386 by Gary Thomas
@ -371,6 +369,7 @@ unsigned int real_irq_to_virt_slowpath(unsigned int real_irq)
return NO_IRQ; return NO_IRQ;
} }
#endif /* CONFIG_PPC64 */
#ifdef CONFIG_IRQSTACKS #ifdef CONFIG_IRQSTACKS
struct thread_info *softirq_ctx[NR_CPUS]; struct thread_info *softirq_ctx[NR_CPUS];
@ -394,10 +393,24 @@ void irq_ctx_init(void)
} }
} }
static inline void do_softirq_onstack(void)
{
struct thread_info *curtp, *irqtp;
curtp = current_thread_info();
irqtp = softirq_ctx[smp_processor_id()];
irqtp->task = curtp->task;
call_do_softirq(irqtp);
irqtp->task = NULL;
}
#else
#define do_softirq_onstack() __do_softirq()
#endif /* CONFIG_IRQSTACKS */
void do_softirq(void) void do_softirq(void)
{ {
unsigned long flags; unsigned long flags;
struct thread_info *curtp, *irqtp;
if (in_interrupt()) if (in_interrupt())
return; return;
@ -405,19 +418,18 @@ void do_softirq(void)
local_irq_save(flags); local_irq_save(flags);
if (local_softirq_pending()) { if (local_softirq_pending()) {
curtp = current_thread_info(); account_system_vtime(current);
irqtp = softirq_ctx[smp_processor_id()]; local_bh_disable();
irqtp->task = curtp->task; do_softirq_onstack();
call_do_softirq(irqtp); account_system_vtime(current);
irqtp->task = NULL; __local_bh_enable();
} }
local_irq_restore(flags); local_irq_restore(flags);
} }
EXPORT_SYMBOL(do_softirq); EXPORT_SYMBOL(do_softirq);
#endif /* CONFIG_IRQSTACKS */ #ifdef CONFIG_PPC64
static int __init setup_noirqdistrib(char *str) static int __init setup_noirqdistrib(char *str)
{ {
distribute_irqs = 0; distribute_irqs = 0;

View File

@ -1,6 +1,5 @@
/* /*
* Kernel Probes (KProbes) * Kernel Probes (KProbes)
* arch/ppc64/kernel/kprobes.c
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by

View File

@ -147,15 +147,12 @@ postcore_initcall(of_bus_driver_init);
int of_register_driver(struct of_platform_driver *drv) int of_register_driver(struct of_platform_driver *drv)
{ {
int count = 0;
/* initialize common driver fields */ /* initialize common driver fields */
drv->driver.name = drv->name; drv->driver.name = drv->name;
drv->driver.bus = &of_platform_bus_type; drv->driver.bus = &of_platform_bus_type;
/* register with core */ /* register with core */
count = driver_register(&drv->driver); return driver_register(&drv->driver);
return count ? count : 1;
} }
void of_unregister_driver(struct of_platform_driver *drv) void of_unregister_driver(struct of_platform_driver *drv)

View File

@ -1,5 +1,4 @@
/* /*
* arch/ppc64/kernel/pci_iommu.c
* Copyright (C) 2001 Mike Corrigan & Dave Engebretsen, IBM Corporation * Copyright (C) 2001 Mike Corrigan & Dave Engebretsen, IBM Corporation
* *
* Rewrite, cleanup, new allocation schemes: * Rewrite, cleanup, new allocation schemes:

View File

@ -57,7 +57,6 @@ extern void machine_check_exception(struct pt_regs *regs);
extern void alignment_exception(struct pt_regs *regs); extern void alignment_exception(struct pt_regs *regs);
extern void program_check_exception(struct pt_regs *regs); extern void program_check_exception(struct pt_regs *regs);
extern void single_step_exception(struct pt_regs *regs); extern void single_step_exception(struct pt_regs *regs);
extern int pmac_newworld;
extern int sys_sigreturn(struct pt_regs *regs); extern int sys_sigreturn(struct pt_regs *regs);
EXPORT_SYMBOL(clear_pages); EXPORT_SYMBOL(clear_pages);

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/kernel/process.c
*
* Derived from "arch/i386/kernel/process.c" * Derived from "arch/i386/kernel/process.c"
* Copyright (C) 1995 Linus Torvalds * Copyright (C) 1995 Linus Torvalds
* *
@ -47,9 +45,9 @@
#include <asm/mmu.h> #include <asm/mmu.h>
#include <asm/prom.h> #include <asm/prom.h>
#include <asm/machdep.h> #include <asm/machdep.h>
#include <asm/time.h>
#ifdef CONFIG_PPC64 #ifdef CONFIG_PPC64
#include <asm/firmware.h> #include <asm/firmware.h>
#include <asm/time.h>
#endif #endif
extern unsigned long _get_SP(void); extern unsigned long _get_SP(void);
@ -330,6 +328,11 @@ struct task_struct *__switch_to(struct task_struct *prev,
#endif #endif
local_irq_save(flags); local_irq_save(flags);
account_system_vtime(current);
account_process_vtime(current);
calculate_steal_time();
last = _switch(old_thread, new_thread); last = _switch(old_thread, new_thread);
local_irq_restore(flags); local_irq_restore(flags);

View File

@ -829,10 +829,6 @@ void __init unflatten_device_tree(void)
/* Allocate memory for the expanded device tree */ /* Allocate memory for the expanded device tree */
mem = lmb_alloc(size + 4, __alignof__(struct device_node)); mem = lmb_alloc(size + 4, __alignof__(struct device_node));
if (!mem) {
DBG("Couldn't allocate memory with lmb_alloc()!\n");
panic("Couldn't allocate memory with lmb_alloc()!\n");
}
mem = (unsigned long) __va(mem); mem = (unsigned long) __va(mem);
((u32 *)mem)[size / 4] = 0xdeadbeef; ((u32 *)mem)[size / 4] = 0xdeadbeef;

View File

@ -1,6 +1,4 @@
/* /*
* linux/arch/ppc64/kernel/ptrace-common.h
*
* Copyright (c) 2002 Stephen Rothwell, IBM Coproration * Copyright (c) 2002 Stephen Rothwell, IBM Coproration
* Extracted from ptrace.c and ptrace32.c * Extracted from ptrace.c and ptrace32.c
* *

View File

@ -1,5 +1,4 @@
/* /*
* arch/ppc64/kernel/rtas-proc.c
* Copyright (C) 2000 Tilmann Bitterberg * Copyright (C) 2000 Tilmann Bitterberg
* (tilmann@bitterberg.de) * (tilmann@bitterberg.de)
* *

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc64/kernel/rtas_pci.c
*
* Copyright (C) 2001 Dave Engebretsen, IBM Corporation * Copyright (C) 2001 Dave Engebretsen, IBM Corporation
* Copyright (C) 2003 Anton Blanchard <anton@au.ibm.com>, IBM * Copyright (C) 2003 Anton Blanchard <anton@au.ibm.com>, IBM
* *

View File

@ -497,8 +497,6 @@ void __init setup_system(void)
#endif #endif
printk("-----------------------------------------------------\n"); printk("-----------------------------------------------------\n");
mm_init_ppc64();
DBG(" <- setup_system()\n"); DBG(" <- setup_system()\n");
} }

View File

@ -1,6 +1,4 @@
/* /*
* linux/arch/ppc64/kernel/signal.c
*
* PowerPC version * PowerPC version
* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
* *

View File

@ -541,7 +541,7 @@ int __devinit start_secondary(void *unused)
smp_ops->take_timebase(); smp_ops->take_timebase();
if (system_state > SYSTEM_BOOTING) if (system_state > SYSTEM_BOOTING)
per_cpu(last_jiffy, cpu) = get_tb(); snapshot_timebase();
spin_lock(&call_lock); spin_lock(&call_lock);
cpu_set(cpu, cpu_online_map); cpu_set(cpu, cpu_online_map);
@ -573,6 +573,8 @@ void __init smp_cpus_done(unsigned int max_cpus)
set_cpus_allowed(current, old_mask); set_cpus_allowed(current, old_mask);
snapshot_timebases();
dump_numa_cpu_topology(); dump_numa_cpu_topology();
} }

View File

@ -51,6 +51,7 @@
#include <linux/percpu.h> #include <linux/percpu.h>
#include <linux/rtc.h> #include <linux/rtc.h>
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/posix-timers.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/processor.h> #include <asm/processor.h>
@ -98,6 +99,7 @@ unsigned long tb_ticks_per_jiffy;
unsigned long tb_ticks_per_usec = 100; /* sane default */ unsigned long tb_ticks_per_usec = 100; /* sane default */
EXPORT_SYMBOL(tb_ticks_per_usec); EXPORT_SYMBOL(tb_ticks_per_usec);
unsigned long tb_ticks_per_sec; unsigned long tb_ticks_per_sec;
EXPORT_SYMBOL(tb_ticks_per_sec); /* for cputime_t conversions */
u64 tb_to_xs; u64 tb_to_xs;
unsigned tb_to_us; unsigned tb_to_us;
@ -135,6 +137,224 @@ unsigned long tb_last_stamp;
*/ */
DEFINE_PER_CPU(unsigned long, last_jiffy); DEFINE_PER_CPU(unsigned long, last_jiffy);
#ifdef CONFIG_VIRT_CPU_ACCOUNTING
/*
* Factors for converting from cputime_t (timebase ticks) to
* jiffies, milliseconds, seconds, and clock_t (1/USER_HZ seconds).
* These are all stored as 0.64 fixed-point binary fractions.
*/
u64 __cputime_jiffies_factor;
EXPORT_SYMBOL(__cputime_jiffies_factor);
u64 __cputime_msec_factor;
EXPORT_SYMBOL(__cputime_msec_factor);
u64 __cputime_sec_factor;
EXPORT_SYMBOL(__cputime_sec_factor);
u64 __cputime_clockt_factor;
EXPORT_SYMBOL(__cputime_clockt_factor);
static void calc_cputime_factors(void)
{
struct div_result res;
div128_by_32(HZ, 0, tb_ticks_per_sec, &res);
__cputime_jiffies_factor = res.result_low;
div128_by_32(1000, 0, tb_ticks_per_sec, &res);
__cputime_msec_factor = res.result_low;
div128_by_32(1, 0, tb_ticks_per_sec, &res);
__cputime_sec_factor = res.result_low;
div128_by_32(USER_HZ, 0, tb_ticks_per_sec, &res);
__cputime_clockt_factor = res.result_low;
}
/*
* Read the PURR on systems that have it, otherwise the timebase.
*/
static u64 read_purr(void)
{
if (cpu_has_feature(CPU_FTR_PURR))
return mfspr(SPRN_PURR);
return mftb();
}
/*
* Account time for a transition between system, hard irq
* or soft irq state.
*/
void account_system_vtime(struct task_struct *tsk)
{
u64 now, delta;
unsigned long flags;
local_irq_save(flags);
now = read_purr();
delta = now - get_paca()->startpurr;
get_paca()->startpurr = now;
if (!in_interrupt()) {
delta += get_paca()->system_time;
get_paca()->system_time = 0;
}
account_system_time(tsk, 0, delta);
local_irq_restore(flags);
}
/*
* Transfer the user and system times accumulated in the paca
* by the exception entry and exit code to the generic process
* user and system time records.
* Must be called with interrupts disabled.
*/
void account_process_vtime(struct task_struct *tsk)
{
cputime_t utime;
utime = get_paca()->user_time;
get_paca()->user_time = 0;
account_user_time(tsk, utime);
}
static void account_process_time(struct pt_regs *regs)
{
int cpu = smp_processor_id();
account_process_vtime(current);
run_local_timers();
if (rcu_pending(cpu))
rcu_check_callbacks(cpu, user_mode(regs));
scheduler_tick();
run_posix_cpu_timers(current);
}
#ifdef CONFIG_PPC_SPLPAR
/*
* Stuff for accounting stolen time.
*/
struct cpu_purr_data {
int initialized; /* thread is running */
u64 tb0; /* timebase at origin time */
u64 purr0; /* PURR at origin time */
u64 tb; /* last TB value read */
u64 purr; /* last PURR value read */
u64 stolen; /* stolen time so far */
spinlock_t lock;
};
static DEFINE_PER_CPU(struct cpu_purr_data, cpu_purr_data);
static void snapshot_tb_and_purr(void *data)
{
struct cpu_purr_data *p = &__get_cpu_var(cpu_purr_data);
p->tb0 = mftb();
p->purr0 = mfspr(SPRN_PURR);
p->tb = p->tb0;
p->purr = 0;
wmb();
p->initialized = 1;
}
/*
* Called during boot when all cpus have come up.
*/
void snapshot_timebases(void)
{
int cpu;
if (!cpu_has_feature(CPU_FTR_PURR))
return;
for_each_cpu(cpu)
spin_lock_init(&per_cpu(cpu_purr_data, cpu).lock);
on_each_cpu(snapshot_tb_and_purr, NULL, 0, 1);
}
void calculate_steal_time(void)
{
u64 tb, purr, t0;
s64 stolen;
struct cpu_purr_data *p0, *pme, *phim;
int cpu;
if (!cpu_has_feature(CPU_FTR_PURR))
return;
cpu = smp_processor_id();
pme = &per_cpu(cpu_purr_data, cpu);
if (!pme->initialized)
return; /* this can happen in early boot */
p0 = &per_cpu(cpu_purr_data, cpu & ~1);
phim = &per_cpu(cpu_purr_data, cpu ^ 1);
spin_lock(&p0->lock);
tb = mftb();
purr = mfspr(SPRN_PURR) - pme->purr0;
if (!phim->initialized || !cpu_online(cpu ^ 1)) {
stolen = (tb - pme->tb) - (purr - pme->purr);
} else {
t0 = pme->tb0;
if (phim->tb0 < t0)
t0 = phim->tb0;
stolen = phim->tb - t0 - phim->purr - purr - p0->stolen;
}
if (stolen > 0) {
account_steal_time(current, stolen);
p0->stolen += stolen;
}
pme->tb = tb;
pme->purr = purr;
spin_unlock(&p0->lock);
}
/*
* Must be called before the cpu is added to the online map when
* a cpu is being brought up at runtime.
*/
static void snapshot_purr(void)
{
int cpu;
u64 purr;
struct cpu_purr_data *p0, *pme, *phim;
unsigned long flags;
if (!cpu_has_feature(CPU_FTR_PURR))
return;
cpu = smp_processor_id();
pme = &per_cpu(cpu_purr_data, cpu);
p0 = &per_cpu(cpu_purr_data, cpu & ~1);
phim = &per_cpu(cpu_purr_data, cpu ^ 1);
spin_lock_irqsave(&p0->lock, flags);
pme->tb = pme->tb0 = mftb();
purr = mfspr(SPRN_PURR);
if (!phim->initialized) {
pme->purr = 0;
pme->purr0 = purr;
} else {
/* set p->purr and p->purr0 for no change in p0->stolen */
pme->purr = phim->tb - phim->tb0 - phim->purr - p0->stolen;
pme->purr0 = purr - pme->purr;
}
pme->initialized = 1;
spin_unlock_irqrestore(&p0->lock, flags);
}
#endif /* CONFIG_PPC_SPLPAR */
#else /* ! CONFIG_VIRT_CPU_ACCOUNTING */
#define calc_cputime_factors()
#define account_process_time(regs) update_process_times(user_mode(regs))
#define calculate_steal_time() do { } while (0)
#endif
#if !(defined(CONFIG_VIRT_CPU_ACCOUNTING) && defined(CONFIG_PPC_SPLPAR))
#define snapshot_purr() do { } while (0)
#endif
/*
* Called when a cpu comes up after the system has finished booting,
* i.e. as a result of a hotplug cpu action.
*/
void snapshot_timebase(void)
{
__get_cpu_var(last_jiffy) = get_tb();
snapshot_purr();
}
void __delay(unsigned long loops) void __delay(unsigned long loops)
{ {
unsigned long start; unsigned long start;
@ -392,6 +612,7 @@ static void iSeries_tb_recal(void)
new_tb_ticks_per_jiffy, sign, tick_diff ); new_tb_ticks_per_jiffy, sign, tick_diff );
tb_ticks_per_jiffy = new_tb_ticks_per_jiffy; tb_ticks_per_jiffy = new_tb_ticks_per_jiffy;
tb_ticks_per_sec = new_tb_ticks_per_sec; tb_ticks_per_sec = new_tb_ticks_per_sec;
calc_cputime_factors();
div128_by_32( XSEC_PER_SEC, 0, tb_ticks_per_sec, &divres ); div128_by_32( XSEC_PER_SEC, 0, tb_ticks_per_sec, &divres );
do_gtod.tb_ticks_per_sec = tb_ticks_per_sec; do_gtod.tb_ticks_per_sec = tb_ticks_per_sec;
tb_to_xs = divres.result_low; tb_to_xs = divres.result_low;
@ -440,6 +661,7 @@ void timer_interrupt(struct pt_regs * regs)
irq_enter(); irq_enter();
profile_tick(CPU_PROFILING, regs); profile_tick(CPU_PROFILING, regs);
calculate_steal_time();
#ifdef CONFIG_PPC_ISERIES #ifdef CONFIG_PPC_ISERIES
get_lppaca()->int_dword.fields.decr_int = 0; get_lppaca()->int_dword.fields.decr_int = 0;
@ -461,7 +683,7 @@ void timer_interrupt(struct pt_regs * regs)
* is the case. * is the case.
*/ */
if (!cpu_is_offline(cpu)) if (!cpu_is_offline(cpu))
update_process_times(user_mode(regs)); account_process_time(regs);
/* /*
* No need to check whether cpu is offline here; boot_cpuid * No need to check whether cpu is offline here; boot_cpuid
@ -518,13 +740,27 @@ void wakeup_decrementer(void)
void __init smp_space_timers(unsigned int max_cpus) void __init smp_space_timers(unsigned int max_cpus)
{ {
int i; int i;
unsigned long half = tb_ticks_per_jiffy / 2;
unsigned long offset = tb_ticks_per_jiffy / max_cpus; unsigned long offset = tb_ticks_per_jiffy / max_cpus;
unsigned long previous_tb = per_cpu(last_jiffy, boot_cpuid); unsigned long previous_tb = per_cpu(last_jiffy, boot_cpuid);
/* make sure tb > per_cpu(last_jiffy, cpu) for all cpus always */ /* make sure tb > per_cpu(last_jiffy, cpu) for all cpus always */
previous_tb -= tb_ticks_per_jiffy; previous_tb -= tb_ticks_per_jiffy;
/*
* The stolen time calculation for POWER5 shared-processor LPAR
* systems works better if the two threads' timebase interrupts
* are staggered by half a jiffy with respect to each other.
*/
for_each_cpu(i) { for_each_cpu(i) {
if (i != boot_cpuid) { if (i == boot_cpuid)
continue;
if (i == (boot_cpuid ^ 1))
per_cpu(last_jiffy, i) =
per_cpu(last_jiffy, boot_cpuid) - half;
else if (i & 1)
per_cpu(last_jiffy, i) =
per_cpu(last_jiffy, i ^ 1) + half;
else {
previous_tb += offset; previous_tb += offset;
per_cpu(last_jiffy, i) = previous_tb; per_cpu(last_jiffy, i) = previous_tb;
} }
@ -720,6 +956,7 @@ void __init time_init(void)
tb_ticks_per_sec = ppc_tb_freq; tb_ticks_per_sec = ppc_tb_freq;
tb_ticks_per_usec = ppc_tb_freq / 1000000; tb_ticks_per_usec = ppc_tb_freq / 1000000;
tb_to_us = mulhwu_scale_factor(ppc_tb_freq, 1000000); tb_to_us = mulhwu_scale_factor(ppc_tb_freq, 1000000);
calc_cputime_factors();
/* /*
* Calculate the length of each tick in ns. It will not be * Calculate the length of each tick in ns. It will not be

View File

@ -1,6 +1,4 @@
/* /*
* linux/arch/ppc64/kernel/vdso.c
*
* Copyright (C) 2004 Benjamin Herrenschmidt, IBM Corp. * Copyright (C) 2004 Benjamin Herrenschmidt, IBM Corp.
* <benh@kernel.crashing.org> * <benh@kernel.crashing.org>
* *

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc64/lib/copypage.S
*
* Copyright (C) 2002 Paul Mackerras, IBM Corp. * Copyright (C) 2002 Paul Mackerras, IBM Corp.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc64/lib/copyuser.S
*
* Copyright (C) 2002 Paul Mackerras, IBM Corp. * Copyright (C) 2002 Paul Mackerras, IBM Corp.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or

View File

@ -1,9 +1,7 @@
/* /*
* arch/ppc64/lib/e2a.c
*
* EBCDIC to ASCII conversion * EBCDIC to ASCII conversion
* *
* This function moved here from arch/ppc64/kernel/viopath.c * This function moved here from arch/powerpc/platforms/iseries/viopath.c
* *
* (C) Copyright 2000-2004 IBM Corporation * (C) Copyright 2000-2004 IBM Corporation
* *
@ -105,4 +103,14 @@ unsigned char e2a(unsigned char x)
} }
EXPORT_SYMBOL(e2a); EXPORT_SYMBOL(e2a);
unsigned char* strne2a(unsigned char *dest, const unsigned char *src, size_t n)
{
int i;
n = strnlen(src, n);
for (i = 0; i < n; i++)
dest[i] = e2a(src[i]);
return dest;
}

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc64/lib/memcpy.S
*
* Copyright (C) 2002 Paul Mackerras, IBM Corp. * Copyright (C) 2002 Paul Mackerras, IBM Corp.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/syslib/rheap.c
*
* A Remote Heap. Remote means that we don't touch the memory that the * A Remote Heap. Remote means that we don't touch the memory that the
* heap points to. Normal heap implementations use the memory they manage * heap points to. Normal heap implementations use the memory they manage
* to place their list. We cannot do that because the memory we manage may * to place their list. We cannot do that because the memory we manage may

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/mm/fault.c
*
* PowerPC version * PowerPC version
* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
* *

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/kernel/hashtable.S
*
* $Id: hashtable.S,v 1.6 1999/10/08 01:56:15 paulus Exp $ * $Id: hashtable.S,v 1.6 1999/10/08 01:56:15 paulus Exp $
* *
* PowerPC version * PowerPC version

View File

@ -169,7 +169,7 @@ int htab_bolt_mapping(unsigned long vstart, unsigned long vend,
#ifdef CONFIG_PPC_ISERIES #ifdef CONFIG_PPC_ISERIES
if (_machine == PLATFORM_ISERIES_LPAR) if (_machine == PLATFORM_ISERIES_LPAR)
ret = iSeries_hpte_insert(hpteg, va, ret = iSeries_hpte_insert(hpteg, va,
__pa(vaddr), paddr,
tmp_mode, tmp_mode,
HPTE_V_BOLTED, HPTE_V_BOLTED,
psize); psize);
@ -178,7 +178,7 @@ int htab_bolt_mapping(unsigned long vstart, unsigned long vend,
#ifdef CONFIG_PPC_PSERIES #ifdef CONFIG_PPC_PSERIES
if (_machine & PLATFORM_LPAR) if (_machine & PLATFORM_LPAR)
ret = pSeries_lpar_hpte_insert(hpteg, va, ret = pSeries_lpar_hpte_insert(hpteg, va,
virt_to_abs(paddr), paddr,
tmp_mode, tmp_mode,
HPTE_V_BOLTED, HPTE_V_BOLTED,
psize); psize);
@ -186,7 +186,7 @@ int htab_bolt_mapping(unsigned long vstart, unsigned long vend,
#endif #endif
#ifdef CONFIG_PPC_MULTIPLATFORM #ifdef CONFIG_PPC_MULTIPLATFORM
ret = native_hpte_insert(hpteg, va, ret = native_hpte_insert(hpteg, va,
virt_to_abs(paddr), paddr,
tmp_mode, HPTE_V_BOLTED, tmp_mode, HPTE_V_BOLTED,
psize); psize);
#endif #endif
@ -392,7 +392,7 @@ static unsigned long __init htab_get_table_size(void)
#ifdef CONFIG_MEMORY_HOTPLUG #ifdef CONFIG_MEMORY_HOTPLUG
void create_section_mapping(unsigned long start, unsigned long end) void create_section_mapping(unsigned long start, unsigned long end)
{ {
BUG_ON(htab_bolt_mapping(start, end, start, BUG_ON(htab_bolt_mapping(start, end, __pa(start),
_PAGE_ACCESSED | _PAGE_DIRTY | _PAGE_COHERENT | PP_RWXX, _PAGE_ACCESSED | _PAGE_DIRTY | _PAGE_COHERENT | PP_RWXX,
mmu_linear_psize)); mmu_linear_psize));
} }
@ -422,7 +422,7 @@ void __init htab_initialize(void)
htab_hash_mask = pteg_count - 1; htab_hash_mask = pteg_count - 1;
if (platform_is_lpar()) { if (firmware_has_feature(FW_FEATURE_LPAR)) {
/* Using a hypervisor which owns the htab */ /* Using a hypervisor which owns the htab */
htab_address = NULL; htab_address = NULL;
_SDR1 = 0; _SDR1 = 0;
@ -431,7 +431,6 @@ void __init htab_initialize(void)
* the absolute address space. * the absolute address space.
*/ */
table = lmb_alloc(htab_size_bytes, htab_size_bytes); table = lmb_alloc(htab_size_bytes, htab_size_bytes);
BUG_ON(table == 0);
DBG("Hash table allocated at %lx, size: %lx\n", table, DBG("Hash table allocated at %lx, size: %lx\n", table,
htab_size_bytes); htab_size_bytes);
@ -474,21 +473,22 @@ void __init htab_initialize(void)
if (dart_tablebase != 0 && dart_tablebase >= base if (dart_tablebase != 0 && dart_tablebase >= base
&& dart_tablebase < (base + size)) { && dart_tablebase < (base + size)) {
unsigned long dart_table_end = dart_tablebase + 16 * MB;
if (base != dart_tablebase) if (base != dart_tablebase)
BUG_ON(htab_bolt_mapping(base, dart_tablebase, BUG_ON(htab_bolt_mapping(base, dart_tablebase,
base, mode_rw, __pa(base), mode_rw,
mmu_linear_psize)); mmu_linear_psize));
if ((base + size) > (dart_tablebase + 16*MB)) if ((base + size) > dart_table_end)
BUG_ON(htab_bolt_mapping(dart_tablebase+16*MB, BUG_ON(htab_bolt_mapping(dart_tablebase+16*MB,
base + size, base + size,
dart_tablebase+16*MB, __pa(dart_table_end),
mode_rw, mode_rw,
mmu_linear_psize)); mmu_linear_psize));
continue; continue;
} }
#endif /* CONFIG_U3_DART */ #endif /* CONFIG_U3_DART */
BUG_ON(htab_bolt_mapping(base, base + size, base, BUG_ON(htab_bolt_mapping(base, base + size, __pa(base),
mode_rw, mmu_linear_psize)); mode_rw, mmu_linear_psize));
} }
/* /*
@ -505,8 +505,8 @@ void __init htab_initialize(void)
if (base + size >= tce_alloc_start) if (base + size >= tce_alloc_start)
tce_alloc_start = base + size + 1; tce_alloc_start = base + size + 1;
BUG_ON(htab_bolt_mapping(tce_alloc_start, tce_alloc_end, BUG_ON(htab_bolt_mapping(tce_alloc_start, tce_alloc_end,
tce_alloc_start, mode_rw, __pa(tce_alloc_start), mode_rw,
mmu_linear_psize)); mmu_linear_psize));
} }
@ -517,7 +517,7 @@ void __init htab_initialize(void)
void htab_initialize_secondary(void) void htab_initialize_secondary(void)
{ {
if (!platform_is_lpar()) if (!firmware_has_feature(FW_FEATURE_LPAR))
mtspr(SPRN_SDR1, _SDR1); mtspr(SPRN_SDR1, _SDR1);
} }

View File

@ -84,54 +84,6 @@
/* max amount of RAM to use */ /* max amount of RAM to use */
unsigned long __max_memory; unsigned long __max_memory;
/* info on what we think the IO hole is */
unsigned long io_hole_start;
unsigned long io_hole_size;
/*
* Do very early mm setup.
*/
void __init mm_init_ppc64(void)
{
#ifndef CONFIG_PPC_ISERIES
unsigned long i;
#endif
ppc64_boot_msg(0x100, "MM Init");
/* This is the story of the IO hole... please, keep seated,
* unfortunately, we are out of oxygen masks at the moment.
* So we need some rough way to tell where your big IO hole
* is. On pmac, it's between 2G and 4G, on POWER3, it's around
* that area as well, on POWER4 we don't have one, etc...
* We need that as a "hint" when sizing the TCE table on POWER3
* So far, the simplest way that seem work well enough for us it
* to just assume that the first discontinuity in our physical
* RAM layout is the IO hole. That may not be correct in the future
* (and isn't on iSeries but then we don't care ;)
*/
#ifndef CONFIG_PPC_ISERIES
for (i = 1; i < lmb.memory.cnt; i++) {
unsigned long base, prevbase, prevsize;
prevbase = lmb.memory.region[i-1].base;
prevsize = lmb.memory.region[i-1].size;
base = lmb.memory.region[i].base;
if (base > (prevbase + prevsize)) {
io_hole_start = prevbase + prevsize;
io_hole_size = base - (prevbase + prevsize);
break;
}
}
#endif /* CONFIG_PPC_ISERIES */
if (io_hole_start)
printk("IO Hole assumed to be %lx -> %lx\n",
io_hole_start, io_hole_start + io_hole_size - 1);
ppc64_boot_msg(0x100, "MM Init Done");
}
void free_initmem(void) void free_initmem(void)
{ {
unsigned long addr; unsigned long addr;

View File

@ -31,6 +31,8 @@
#define DBG(fmt...) #define DBG(fmt...)
#endif #endif
#define LMB_ALLOC_ANYWHERE 0
struct lmb lmb; struct lmb lmb;
void lmb_dump_all(void) void lmb_dump_all(void)
@ -225,6 +227,20 @@ unsigned long __init lmb_alloc(unsigned long size, unsigned long align)
unsigned long __init lmb_alloc_base(unsigned long size, unsigned long align, unsigned long __init lmb_alloc_base(unsigned long size, unsigned long align,
unsigned long max_addr) unsigned long max_addr)
{
unsigned long alloc;
alloc = __lmb_alloc_base(size, align, max_addr);
if (alloc == 0)
panic("ERROR: Failed to allocate 0x%lx bytes below 0x%lx.\n",
size, max_addr);
return alloc;
}
unsigned long __init __lmb_alloc_base(unsigned long size, unsigned long align,
unsigned long max_addr)
{ {
long i, j; long i, j;
unsigned long base = 0; unsigned long base = 0;

View File

@ -125,7 +125,7 @@ int __devinit add_memory(u64 start, u64 size)
nid = hot_add_scn_to_nid(start); nid = hot_add_scn_to_nid(start);
pgdata = NODE_DATA(nid); pgdata = NODE_DATA(nid);
start = __va(start); start = (unsigned long)__va(start);
create_section_mapping(start, start + size); create_section_mapping(start, start + size);
/* this should work for most non-highmem platforms */ /* this should work for most non-highmem platforms */
@ -249,7 +249,6 @@ void __init do_init_bootmem(void)
bootmap_pages = bootmem_bootmap_pages(total_pages); bootmap_pages = bootmem_bootmap_pages(total_pages);
start = lmb_alloc(bootmap_pages << PAGE_SHIFT, PAGE_SIZE); start = lmb_alloc(bootmap_pages << PAGE_SHIFT, PAGE_SIZE);
BUG_ON(!start);
boot_mapsize = init_bootmem(start >> PAGE_SHIFT, total_pages); boot_mapsize = init_bootmem(start >> PAGE_SHIFT, total_pages);

View File

@ -1,6 +1,4 @@
/* /*
* linux/arch/ppc64/mm/mmap.c
*
* flexible mmap layout support * flexible mmap layout support
* *
* Copyright 2003-2004 Red Hat Inc., Durham, North Carolina. * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.

View File

@ -129,10 +129,12 @@ void __init get_region(unsigned int nid, unsigned long *start_pfn,
*start_pfn = 0; *start_pfn = 0;
} }
static inline void map_cpu_to_node(int cpu, int node) static void __cpuinit map_cpu_to_node(int cpu, int node)
{ {
numa_cpu_lookup_table[cpu] = node; numa_cpu_lookup_table[cpu] = node;
dbg("adding cpu %d to node %d\n", cpu, node);
if (!(cpu_isset(cpu, numa_cpumask_lookup_table[node]))) if (!(cpu_isset(cpu, numa_cpumask_lookup_table[node])))
cpu_set(cpu, numa_cpumask_lookup_table[node]); cpu_set(cpu, numa_cpumask_lookup_table[node]);
} }
@ -153,7 +155,7 @@ static void unmap_cpu_from_node(unsigned long cpu)
} }
#endif /* CONFIG_HOTPLUG_CPU */ #endif /* CONFIG_HOTPLUG_CPU */
static struct device_node *find_cpu_node(unsigned int cpu) static struct device_node * __cpuinit find_cpu_node(unsigned int cpu)
{ {
unsigned int hw_cpuid = get_hard_smp_processor_id(cpu); unsigned int hw_cpuid = get_hard_smp_processor_id(cpu);
struct device_node *cpu_node = NULL; struct device_node *cpu_node = NULL;
@ -189,23 +191,29 @@ static int *of_get_associativity(struct device_node *dev)
return (unsigned int *)get_property(dev, "ibm,associativity", NULL); return (unsigned int *)get_property(dev, "ibm,associativity", NULL);
} }
static int of_node_numa_domain(struct device_node *device) /* Returns nid in the range [0..MAX_NUMNODES-1], or -1 if no useful numa
* info is found.
*/
static int of_node_to_nid(struct device_node *device)
{ {
int numa_domain; int nid = -1;
unsigned int *tmp; unsigned int *tmp;
if (min_common_depth == -1) if (min_common_depth == -1)
return 0; goto out;
tmp = of_get_associativity(device); tmp = of_get_associativity(device);
if (tmp && (tmp[0] >= min_common_depth)) { if (!tmp)
numa_domain = tmp[min_common_depth]; goto out;
} else {
dbg("WARNING: no NUMA information for %s\n", if (tmp[0] >= min_common_depth)
device->full_name); nid = tmp[min_common_depth];
numa_domain = 0;
} /* POWER4 LPAR uses 0xffff as invalid node */
return numa_domain; if (nid == 0xffff || nid >= MAX_NUMNODES)
nid = -1;
out:
return nid;
} }
/* /*
@ -246,8 +254,7 @@ static int __init find_min_common_depth(void)
if ((len >= 1) && ref_points) { if ((len >= 1) && ref_points) {
depth = ref_points[1]; depth = ref_points[1];
} else { } else {
dbg("WARNING: could not find NUMA " dbg("NUMA: ibm,associativity-reference-points not found.\n");
"associativity reference point\n");
depth = -1; depth = -1;
} }
of_node_put(rtas_root); of_node_put(rtas_root);
@ -283,9 +290,9 @@ static unsigned long __devinit read_n_cells(int n, unsigned int **buf)
* Figure out to which domain a cpu belongs and stick it there. * Figure out to which domain a cpu belongs and stick it there.
* Return the id of the domain used. * Return the id of the domain used.
*/ */
static int numa_setup_cpu(unsigned long lcpu) static int __cpuinit numa_setup_cpu(unsigned long lcpu)
{ {
int numa_domain = 0; int nid = 0;
struct device_node *cpu = find_cpu_node(lcpu); struct device_node *cpu = find_cpu_node(lcpu);
if (!cpu) { if (!cpu) {
@ -293,27 +300,16 @@ static int numa_setup_cpu(unsigned long lcpu)
goto out; goto out;
} }
numa_domain = of_node_numa_domain(cpu); nid = of_node_to_nid(cpu);
if (numa_domain >= num_online_nodes()) { if (nid < 0 || !node_online(nid))
/* nid = any_online_node(NODE_MASK_ALL);
* POWER4 LPAR uses 0xffff as invalid node,
* dont warn in this case.
*/
if (numa_domain != 0xffff)
printk(KERN_ERR "WARNING: cpu %ld "
"maps to invalid NUMA node %d\n",
lcpu, numa_domain);
numa_domain = 0;
}
out: out:
node_set_online(numa_domain); map_cpu_to_node(lcpu, nid);
map_cpu_to_node(lcpu, numa_domain);
of_node_put(cpu); of_node_put(cpu);
return numa_domain; return nid;
} }
static int cpu_numa_callback(struct notifier_block *nfb, static int cpu_numa_callback(struct notifier_block *nfb,
@ -325,10 +321,7 @@ static int cpu_numa_callback(struct notifier_block *nfb,
switch (action) { switch (action) {
case CPU_UP_PREPARE: case CPU_UP_PREPARE:
if (min_common_depth == -1 || !numa_enabled) numa_setup_cpu(lcpu);
map_cpu_to_node(lcpu, 0);
else
numa_setup_cpu(lcpu);
ret = NOTIFY_OK; ret = NOTIFY_OK;
break; break;
#ifdef CONFIG_HOTPLUG_CPU #ifdef CONFIG_HOTPLUG_CPU
@ -375,7 +368,7 @@ static int __init parse_numa_properties(void)
{ {
struct device_node *cpu = NULL; struct device_node *cpu = NULL;
struct device_node *memory = NULL; struct device_node *memory = NULL;
int max_domain; int default_nid = 0;
unsigned long i; unsigned long i;
if (numa_enabled == 0) { if (numa_enabled == 0) {
@ -385,32 +378,32 @@ static int __init parse_numa_properties(void)
min_common_depth = find_min_common_depth(); min_common_depth = find_min_common_depth();
dbg("NUMA associativity depth for CPU/Memory: %d\n", min_common_depth);
if (min_common_depth < 0) if (min_common_depth < 0)
return min_common_depth; return min_common_depth;
max_domain = numa_setup_cpu(boot_cpuid); dbg("NUMA associativity depth for CPU/Memory: %d\n", min_common_depth);
/* /*
* Even though we connect cpus to numa domains later in SMP init, * Even though we connect cpus to numa domains later in SMP
* we need to know the maximum node id now. This is because each * init, we need to know the node ids now. This is because
* node id must have NODE_DATA etc backing it. * each node to be onlined must have NODE_DATA etc backing it.
* As a result of hotplug we could still have cpus appear later on
* with larger node ids. In that case we force the cpu into node 0.
*/ */
for_each_cpu(i) { for_each_present_cpu(i) {
int numa_domain; int nid;
cpu = find_cpu_node(i); cpu = find_cpu_node(i);
BUG_ON(!cpu);
nid = of_node_to_nid(cpu);
of_node_put(cpu);
if (cpu) { /*
numa_domain = of_node_numa_domain(cpu); * Don't fall back to default_nid yet -- we will plug
of_node_put(cpu); * cpus into nodes once the memory scan has discovered
* the topology.
if (numa_domain < MAX_NUMNODES && */
max_domain < numa_domain) if (nid < 0)
max_domain = numa_domain; continue;
} node_set_online(nid);
} }
get_n_mem_cells(&n_mem_addr_cells, &n_mem_size_cells); get_n_mem_cells(&n_mem_addr_cells, &n_mem_size_cells);
@ -418,7 +411,7 @@ static int __init parse_numa_properties(void)
while ((memory = of_find_node_by_type(memory, "memory")) != NULL) { while ((memory = of_find_node_by_type(memory, "memory")) != NULL) {
unsigned long start; unsigned long start;
unsigned long size; unsigned long size;
int numa_domain; int nid;
int ranges; int ranges;
unsigned int *memcell_buf; unsigned int *memcell_buf;
unsigned int len; unsigned int len;
@ -439,18 +432,15 @@ new_range:
start = read_n_cells(n_mem_addr_cells, &memcell_buf); start = read_n_cells(n_mem_addr_cells, &memcell_buf);
size = read_n_cells(n_mem_size_cells, &memcell_buf); size = read_n_cells(n_mem_size_cells, &memcell_buf);
numa_domain = of_node_numa_domain(memory); /*
* Assumption: either all memory nodes or none will
if (numa_domain >= MAX_NUMNODES) { * have associativity properties. If none, then
if (numa_domain != 0xffff) * everything goes to default_nid.
printk(KERN_ERR "WARNING: memory at %lx maps " */
"to invalid NUMA node %d\n", start, nid = of_node_to_nid(memory);
numa_domain); if (nid < 0)
numa_domain = 0; nid = default_nid;
} node_set_online(nid);
if (max_domain < numa_domain)
max_domain = numa_domain;
if (!(size = numa_enforce_memory_limit(start, size))) { if (!(size = numa_enforce_memory_limit(start, size))) {
if (--ranges) if (--ranges)
@ -459,16 +449,13 @@ new_range:
continue; continue;
} }
add_region(numa_domain, start >> PAGE_SHIFT, add_region(nid, start >> PAGE_SHIFT,
size >> PAGE_SHIFT); size >> PAGE_SHIFT);
if (--ranges) if (--ranges)
goto new_range; goto new_range;
} }
for (i = 0; i <= max_domain; i++)
node_set_online(i);
return 0; return 0;
} }
@ -483,7 +470,6 @@ static void __init setup_nonnuma(void)
printk(KERN_INFO "Memory hole size: %ldMB\n", printk(KERN_INFO "Memory hole size: %ldMB\n",
(top_of_ram - total_ram) >> 20); (top_of_ram - total_ram) >> 20);
map_cpu_to_node(boot_cpuid, 0);
for (i = 0; i < lmb.memory.cnt; ++i) for (i = 0; i < lmb.memory.cnt; ++i)
add_region(0, lmb.memory.region[i].base >> PAGE_SHIFT, add_region(0, lmb.memory.region[i].base >> PAGE_SHIFT,
lmb_size_pages(&lmb.memory, i)); lmb_size_pages(&lmb.memory, i));
@ -570,11 +556,11 @@ static void __init *careful_allocation(int nid, unsigned long size,
unsigned long end_pfn) unsigned long end_pfn)
{ {
int new_nid; int new_nid;
unsigned long ret = lmb_alloc_base(size, align, end_pfn << PAGE_SHIFT); unsigned long ret = __lmb_alloc_base(size, align, end_pfn << PAGE_SHIFT);
/* retry over all memory */ /* retry over all memory */
if (!ret) if (!ret)
ret = lmb_alloc_base(size, align, lmb_end_of_DRAM()); ret = __lmb_alloc_base(size, align, lmb_end_of_DRAM());
if (!ret) if (!ret)
panic("numa.c: cannot allocate %lu bytes on node %d", panic("numa.c: cannot allocate %lu bytes on node %d",
@ -620,6 +606,8 @@ void __init do_init_bootmem(void)
dump_numa_memory_topology(); dump_numa_memory_topology();
register_cpu_notifier(&ppc64_numa_nb); register_cpu_notifier(&ppc64_numa_nb);
cpu_numa_callback(&ppc64_numa_nb, CPU_UP_PREPARE,
(void *)(unsigned long)boot_cpuid);
for_each_online_node(nid) { for_each_online_node(nid) {
unsigned long start_pfn, end_pfn, pages_present; unsigned long start_pfn, end_pfn, pages_present;
@ -767,10 +755,10 @@ int hot_add_scn_to_nid(unsigned long scn_addr)
{ {
struct device_node *memory = NULL; struct device_node *memory = NULL;
nodemask_t nodes; nodemask_t nodes;
int numa_domain = 0; int default_nid = any_online_node(NODE_MASK_ALL);
if (!numa_enabled || (min_common_depth < 0)) if (!numa_enabled || (min_common_depth < 0))
return numa_domain; return default_nid;
while ((memory = of_find_node_by_type(memory, "memory")) != NULL) { while ((memory = of_find_node_by_type(memory, "memory")) != NULL) {
unsigned long start, size; unsigned long start, size;
@ -787,15 +775,15 @@ int hot_add_scn_to_nid(unsigned long scn_addr)
ha_new_range: ha_new_range:
start = read_n_cells(n_mem_addr_cells, &memcell_buf); start = read_n_cells(n_mem_addr_cells, &memcell_buf);
size = read_n_cells(n_mem_size_cells, &memcell_buf); size = read_n_cells(n_mem_size_cells, &memcell_buf);
numa_domain = of_node_numa_domain(memory); nid = of_node_to_nid(memory);
/* Domains not present at boot default to 0 */ /* Domains not present at boot default to 0 */
if (!node_online(numa_domain)) if (nid < 0 || !node_online(nid))
numa_domain = any_online_node(NODE_MASK_ALL); nid = default_nid;
if ((scn_addr >= start) && (scn_addr < (start + size))) { if ((scn_addr >= start) && (scn_addr < (start + size))) {
of_node_put(memory); of_node_put(memory);
goto got_numa_domain; goto got_nid;
} }
if (--ranges) /* process all ranges in cell */ if (--ranges) /* process all ranges in cell */
@ -804,12 +792,12 @@ ha_new_range:
BUG(); /* section address should be found above */ BUG(); /* section address should be found above */
/* Temporary code to ensure that returned node is not empty */ /* Temporary code to ensure that returned node is not empty */
got_numa_domain: got_nid:
nodes_setall(nodes); nodes_setall(nodes);
while (NODE_DATA(numa_domain)->node_spanned_pages == 0) { while (NODE_DATA(nid)->node_spanned_pages == 0) {
node_clear(numa_domain, nodes); node_clear(nid, nodes);
numa_domain = any_online_node(nodes); nid = any_online_node(nodes);
} }
return numa_domain; return nid;
} }
#endif /* CONFIG_MEMORY_HOTPLUG */ #endif /* CONFIG_MEMORY_HOTPLUG */

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc64/mm/slb_low.S
*
* Low-level SLB routines * Low-level SLB routines
* *
* Copyright (C) 2004 David Gibson <dwg@au.ibm.com>, IBM * Copyright (C) 2004 David Gibson <dwg@au.ibm.com>, IBM

View File

@ -247,10 +247,6 @@ void stabs_alloc(void)
newstab = lmb_alloc_base(HW_PAGE_SIZE, HW_PAGE_SIZE, newstab = lmb_alloc_base(HW_PAGE_SIZE, HW_PAGE_SIZE,
1<<SID_SHIFT); 1<<SID_SHIFT);
if (! newstab)
panic("Unable to allocate segment table for CPU %d.\n",
cpu);
newstab = (unsigned long)__va(newstab); newstab = (unsigned long)__va(newstab);
memset((void *)newstab, 0, HW_PAGE_SIZE); memset((void *)newstab, 0, HW_PAGE_SIZE);

View File

@ -36,7 +36,7 @@
DEFINE_PER_CPU(struct ppc64_tlb_batch, ppc64_tlb_batch); DEFINE_PER_CPU(struct ppc64_tlb_batch, ppc64_tlb_batch);
/* This is declared as we are using the more or less generic /* This is declared as we are using the more or less generic
* include/asm-ppc64/tlb.h file -- tgall * include/asm-powerpc/tlb.h file -- tgall
*/ */
DEFINE_PER_CPU(struct mmu_gather, mmu_gathers); DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
DEFINE_PER_CPU(struct pte_freelist_batch *, pte_freelist_cur); DEFINE_PER_CPU(struct pte_freelist_batch *, pte_freelist_cur);

View File

@ -10,6 +10,7 @@
#include <linux/oprofile.h> #include <linux/oprofile.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/smp.h> #include <linux/smp.h>
#include <asm/firmware.h>
#include <asm/ptrace.h> #include <asm/ptrace.h>
#include <asm/system.h> #include <asm/system.h>
#include <asm/processor.h> #include <asm/processor.h>
@ -232,7 +233,7 @@ static unsigned long get_pc(struct pt_regs *regs)
mmcra = mfspr(SPRN_MMCRA); mmcra = mfspr(SPRN_MMCRA);
/* Were we in the hypervisor? */ /* Were we in the hypervisor? */
if (platform_is_lpar() && (mmcra & MMCRA_SIHV)) if (firmware_has_feature(FW_FEATURE_LPAR) && (mmcra & MMCRA_SIHV))
/* function descriptor madness */ /* function descriptor madness */
return *((unsigned long *)hypervisor_bucket); return *((unsigned long *)hypervisor_bucket);

View File

@ -1,4 +1,6 @@
# #
# Makefile for the PowerPC 83xx linux kernel. # Makefile for the PowerPC 83xx linux kernel.
# #
obj-$(CONFIG_MPC834x_SYS) += mpc834x_sys.o pci.o obj-y := misc.o
obj-$(CONFIG_PCI) += pci.o
obj-$(CONFIG_MPC834x_SYS) += mpc834x_sys.o

View File

@ -0,0 +1,55 @@
/*
* misc setup functions for MPC83xx
*
* Maintainer: Kumar Gala <galak@kernel.crashing.org>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*/
#include <linux/config.h>
#include <linux/stddef.h>
#include <linux/kernel.h>
#include <asm/io.h>
#include <asm/hw_irq.h>
#include <sysdev/fsl_soc.h>
#include "mpc83xx.h"
void mpc83xx_restart(char *cmd)
{
#define RST_OFFSET 0x00000900
#define RST_PROT_REG 0x00000018
#define RST_CTRL_REG 0x0000001c
__be32 __iomem *reg;
/* map reset register space */
reg = ioremap(get_immrbase() + 0x900, 0xff);
local_irq_disable();
/* enable software reset "RSTE" */
out_be32(reg + (RST_PROT_REG >> 2), 0x52535445);
/* set software hard reset */
out_be32(reg + (RST_CTRL_REG >> 2), 0x2);
for (;;) ;
}
long __init mpc83xx_time_init(void)
{
#define SPCR_OFFSET 0x00000110
#define SPCR_TBEN 0x00400000
__be32 __iomem *spcr = ioremap(get_immrbase() + SPCR_OFFSET, 4);
__be32 tmp;
tmp = in_be32(spcr);
out_be32(spcr, tmp | SPCR_TBEN);
iounmap(spcr);
return 0;
}

View File

@ -24,22 +24,15 @@
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/root_dev.h> #include <linux/root_dev.h>
#include <linux/module.h>
#include <linux/fsl_devices.h>
#include <asm/system.h> #include <asm/system.h>
#include <asm/pgtable.h>
#include <asm/page.h>
#include <asm/atomic.h> #include <asm/atomic.h>
#include <asm/time.h> #include <asm/time.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/machdep.h> #include <asm/machdep.h>
#include <asm/ipic.h> #include <asm/ipic.h>
#include <asm/bootinfo.h> #include <asm/bootinfo.h>
#include <asm/pci-bridge.h>
#include <asm/mpc83xx.h>
#include <asm/irq.h> #include <asm/irq.h>
#include <mm/mmu_decl.h>
#include <asm/prom.h> #include <asm/prom.h>
#include <asm/udbg.h> #include <asm/udbg.h>
#include <sysdev/fsl_soc.h> #include <sysdev/fsl_soc.h>
@ -52,8 +45,6 @@ unsigned long isa_mem_base = 0;
#endif #endif
#ifdef CONFIG_PCI #ifdef CONFIG_PCI
extern int mpc83xx_pci2_busno;
static int static int
mpc83xx_map_irq(struct pci_dev *dev, unsigned char idsel, unsigned char pin) mpc83xx_map_irq(struct pci_dev *dev, unsigned char idsel, unsigned char pin)
{ {
@ -78,26 +69,14 @@ mpc83xx_map_irq(struct pci_dev *dev, unsigned char idsel, unsigned char pin)
const long min_idsel = 0x11, max_idsel = 0x20, irqs_per_slot = 4; const long min_idsel = 0x11, max_idsel = 0x20, irqs_per_slot = 4;
return PCI_IRQ_TABLE_LOOKUP; return PCI_IRQ_TABLE_LOOKUP;
} }
#endif /* CONFIG_PCI */
static int
mpc83xx_exclude_device(u_char bus, u_char devfn)
{
if (bus == 0 && PCI_SLOT(devfn) == 0)
return PCIBIOS_DEVICE_NOT_FOUND;
if (mpc83xx_pci2_busno)
if (bus == (mpc83xx_pci2_busno) && PCI_SLOT(devfn) == 0)
return PCIBIOS_DEVICE_NOT_FOUND;
return PCIBIOS_SUCCESSFUL;
}
#endif /* CONFIG_PCI */
/* ************************************************************************ /* ************************************************************************
* *
* Setup the architecture * Setup the architecture
* *
*/ */
static void __init static void __init mpc834x_sys_setup_arch(void)
mpc834x_sys_setup_arch(void)
{ {
struct device_node *np; struct device_node *np;
@ -106,14 +85,14 @@ mpc834x_sys_setup_arch(void)
np = of_find_node_by_type(NULL, "cpu"); np = of_find_node_by_type(NULL, "cpu");
if (np != 0) { if (np != 0) {
unsigned int *fp = (int *) get_property(np, "clock-frequency", NULL); unsigned int *fp =
(int *)get_property(np, "clock-frequency", NULL);
if (fp != 0) if (fp != 0)
loops_per_jiffy = *fp / HZ; loops_per_jiffy = *fp / HZ;
else else
loops_per_jiffy = 50000000 / HZ; loops_per_jiffy = 50000000 / HZ;
of_node_put(np); of_node_put(np);
} }
#ifdef CONFIG_PCI #ifdef CONFIG_PCI
for (np = NULL; (np = of_find_node_by_type(np, "pci")) != NULL;) for (np = NULL; (np = of_find_node_by_type(np, "pci")) != NULL;)
add_bridge(np); add_bridge(np);
@ -124,14 +103,13 @@ mpc834x_sys_setup_arch(void)
#endif #endif
#ifdef CONFIG_ROOT_NFS #ifdef CONFIG_ROOT_NFS
ROOT_DEV = Root_NFS; ROOT_DEV = Root_NFS;
#else #else
ROOT_DEV = Root_HDA1; ROOT_DEV = Root_HDA1;
#endif #endif
} }
void __init void __init mpc834x_sys_init_IRQ(void)
mpc834x_sys_init_IRQ(void)
{ {
u8 senses[8] = { u8 senses[8] = {
0, /* EXT 0 */ 0, /* EXT 0 */
@ -160,64 +138,27 @@ mpc834x_sys_init_IRQ(void)
} }
#if defined(CONFIG_I2C_MPC) && defined(CONFIG_SENSORS_DS1374) #if defined(CONFIG_I2C_MPC) && defined(CONFIG_SENSORS_DS1374)
extern ulong ds1374_get_rtc_time(void); extern ulong ds1374_get_rtc_time(void);
extern int ds1374_set_rtc_time(ulong); extern int ds1374_set_rtc_time(ulong);
static int __init static int __init mpc834x_rtc_hookup(void)
mpc834x_rtc_hookup(void)
{ {
struct timespec tv; struct timespec tv;
ppc_md.get_rtc_time = ds1374_get_rtc_time; ppc_md.get_rtc_time = ds1374_get_rtc_time;
ppc_md.set_rtc_time = ds1374_set_rtc_time; ppc_md.set_rtc_time = ds1374_set_rtc_time;
tv.tv_nsec = 0; tv.tv_nsec = 0;
tv.tv_sec = (ppc_md.get_rtc_time)(); tv.tv_sec = (ppc_md.get_rtc_time) ();
do_settimeofday(&tv); do_settimeofday(&tv);
return 0; return 0;
} }
late_initcall(mpc834x_rtc_hookup); late_initcall(mpc834x_rtc_hookup);
#endif #endif
static void void __init platform_init(void)
mpc83xx_restart(char *cmd)
{
#define RST_OFFSET 0x00000900
#define RST_PROT_REG 0x00000018
#define RST_CTRL_REG 0x0000001c
__be32 __iomem *reg;
// map reset register space
reg = ioremap(get_immrbase() + 0x900, 0xff);
local_irq_disable();
/* enable software reset "RSTE" */
out_be32(reg + (RST_PROT_REG >> 2), 0x52535445);
/* set software hard reset */
out_be32(reg + (RST_CTRL_REG >> 2), 0x52535445);
for(;;);
}
static long __init
mpc83xx_time_init(void)
{
#define SPCR_OFFSET 0x00000110
#define SPCR_TBEN 0x00400000
__be32 __iomem *spcr = ioremap(get_immrbase() + SPCR_OFFSET, 4);
__be32 tmp;
tmp = in_be32(spcr);
out_be32(spcr, tmp|SPCR_TBEN);
iounmap(spcr);
return 0;
}
void __init
platform_init(void)
{ {
/* setup the PowerPC module struct */ /* setup the PowerPC module struct */
ppc_md.setup_arch = mpc834x_sys_setup_arch; ppc_md.setup_arch = mpc834x_sys_setup_arch;
@ -239,5 +180,3 @@ platform_init(void)
return; return;
} }

View File

@ -20,4 +20,4 @@
#define PIRQC MPC83xx_IRQ_EXT6 #define PIRQC MPC83xx_IRQ_EXT6
#define PIRQD MPC83xx_IRQ_EXT7 #define PIRQD MPC83xx_IRQ_EXT7
#endif /* __MACH_MPC83XX_SYS_H__ */ #endif /* __MACH_MPC83XX_SYS_H__ */

View File

@ -10,5 +10,8 @@
*/ */
extern int add_bridge(struct device_node *dev); extern int add_bridge(struct device_node *dev);
extern int mpc83xx_exclude_device(u_char bus, u_char devfn);
extern void mpc83xx_restart(char *cmd);
extern long mpc83xx_time_init(void);
#endif /* __MPC83XX_H__ */ #endif /* __MPC83XX_H__ */

View File

@ -36,7 +36,16 @@
int mpc83xx_pci2_busno; int mpc83xx_pci2_busno;
#ifdef CONFIG_PCI int mpc83xx_exclude_device(u_char bus, u_char devfn)
{
if (bus == 0 && PCI_SLOT(devfn) == 0)
return PCIBIOS_DEVICE_NOT_FOUND;
if (mpc83xx_pci2_busno)
if (bus == (mpc83xx_pci2_busno) && PCI_SLOT(devfn) == 0)
return PCIBIOS_DEVICE_NOT_FOUND;
return PCIBIOS_SUCCESSFUL;
}
int __init add_bridge(struct device_node *dev) int __init add_bridge(struct device_node *dev)
{ {
int len; int len;
@ -52,7 +61,7 @@ int __init add_bridge(struct device_node *dev)
has_address = (of_address_to_resource(dev, 0, &rsrc) == 0); has_address = (of_address_to_resource(dev, 0, &rsrc) == 0);
/* Get bus range if any */ /* Get bus range if any */
bus_range = (int *) get_property(dev, "bus-range", &len); bus_range = (int *)get_property(dev, "bus-range", &len);
if (bus_range == NULL || len < 2 * sizeof(int)) { if (bus_range == NULL || len < 2 * sizeof(int)) {
printk(KERN_WARNING "Can't get bus-range for %s, assume" printk(KERN_WARNING "Can't get bus-range for %s, assume"
" bus 0\n", dev->full_name); " bus 0\n", dev->full_name);
@ -74,7 +83,7 @@ int __init add_bridge(struct device_node *dev)
if ((rsrc.start & 0xfffff) == 0x8500) { if ((rsrc.start & 0xfffff) == 0x8500) {
setup_indirect_pci(hose, immr + 0x8300, immr + 0x8304); setup_indirect_pci(hose, immr + 0x8300, immr + 0x8304);
} }
/* PCI 2*/ /* PCI 2 */
if ((rsrc.start & 0xfffff) == 0x8600) { if ((rsrc.start & 0xfffff) == 0x8600) {
setup_indirect_pci(hose, immr + 0x8380, immr + 0x8384); setup_indirect_pci(hose, immr + 0x8380, immr + 0x8384);
primary = 0; primary = 0;
@ -84,10 +93,10 @@ int __init add_bridge(struct device_node *dev)
printk(KERN_INFO "Found MPC83xx PCI host bridge at 0x%08lx. " printk(KERN_INFO "Found MPC83xx PCI host bridge at 0x%08lx. "
"Firmware bus number: %d->%d\n", "Firmware bus number: %d->%d\n",
rsrc.start, hose->first_busno, hose->last_busno); rsrc.start, hose->first_busno, hose->last_busno);
DBG(" ->Hose at 0x%p, cfg_addr=0x%p,cfg_data=0x%p\n", DBG(" ->Hose at 0x%p, cfg_addr=0x%p,cfg_data=0x%p\n",
hose, hose->cfg_addr, hose->cfg_data); hose, hose->cfg_addr, hose->cfg_data);
/* Interpret the "ranges" property */ /* Interpret the "ranges" property */
/* This also maps the I/O region and sets isa_io/mem_base */ /* This also maps the I/O region and sets isa_io/mem_base */
@ -95,5 +104,3 @@ int __init add_bridge(struct device_node *dev)
return 0; return 0;
} }
#endif

View File

@ -1,86 +1,30 @@
config 85xx menu "Platform support"
bool depends on PPC_85xx
depends on E500
default y
config PPC_INDIRECT_PCI_BE
bool
depends on 85xx
default y
menu "Freescale 85xx options"
depends on E500
choice choice
prompt "Machine Type" prompt "Machine Type"
depends on 85xx
default MPC8540_ADS default MPC8540_ADS
config MPC8540_ADS config MPC8540_ADS
bool "Freescale MPC8540 ADS" bool "Freescale MPC8540 ADS"
help help
This option enables support for the MPC 8540 ADS evaluation board. This option enables support for the MPC 8540 ADS board
config MPC8548_CDS
bool "Freescale MPC8548 CDS"
help
This option enablese support for the MPC8548 CDS evaluation board.
config MPC8555_CDS
bool "Freescale MPC8555 CDS"
help
This option enablese support for the MPC8555 CDS evaluation board.
config MPC8560_ADS
bool "Freescale MPC8560 ADS"
help
This option enables support for the MPC 8560 ADS evaluation board.
config SBC8560
bool "WindRiver PowerQUICC III SBC8560"
help
This option enables support for the WindRiver PowerQUICC III
SBC8560 board.
config STX_GP3
bool "Silicon Turnkey Express GP3"
help
This option enables support for the Silicon Turnkey Express GP3
board.
endchoice endchoice
# It's often necessary to know the specific 85xx processor type.
# Fortunately, it is implied (so far) from the board type, so we
# don't need to ask more redundant questions.
config MPC8540 config MPC8540
bool bool
depends on MPC8540_ADS select PPC_UDBG_16550
default y select PPC_INDIRECT_PCI
default y if MPC8540_ADS
config MPC8548 config PPC_INDIRECT_PCI_BE
bool bool
depends on MPC8548_CDS depends on PPC_85xx
default y default y
config MPC8555 config MPIC
bool bool
depends on MPC8555_CDS
default y
config MPC8560
bool
depends on SBC8560 || MPC8560_ADS || STX_GP3
default y
config 85xx_PCI2
bool "Supprt for 2nd PCI host controller"
depends on MPC8555_CDS
default y
config PPC_GEN550
bool
depends on MPC8540 || SBC8560 || MPC8555
default y default y
endmenu endmenu

View File

@ -1 +1,5 @@
# empty makefile so make clean works #
# Makefile for the PowerPC 85xx linux kernel.
#
obj-$(CONFIG_PPC_85xx) += misc.o pci.o
obj-$(CONFIG_MPC8540_ADS) += mpc85xx_ads.o

View File

@ -0,0 +1,31 @@
/*
* MPC85xx generic code.
*
* Maintained by Kumar Gala (see MAINTAINERS for contact information)
*
* Copyright 2005 Freescale Semiconductor Inc.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*/
#include <linux/irq.h>
#include <linux/module.h>
#include <asm/irq.h>
extern void abort(void);
void mpc85xx_restart(char *cmd)
{
local_irq_disable();
abort();
}
/* For now this is a pass through */
phys_addr_t fixup_bigphys_addr(phys_addr_t addr, phys_addr_t size)
{
return addr;
};
EXPORT_SYMBOL(fixup_bigphys_addr);

View File

@ -0,0 +1,36 @@
/*
* arch/ppc/platforms/85xx/mpc8540_ads.h
*
* MPC8540ADS board definitions
*
* Maintainer: Kumar Gala <kumar.gala@freescale.com>
*
* Copyright 2004 Freescale Semiconductor Inc.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
*/
#ifndef __MACH_MPC8540ADS_H__
#define __MACH_MPC8540ADS_H__
#include <linux/config.h>
#include <linux/initrd.h>
#define BOARD_CCSRBAR ((uint)0xe0000000)
#define BCSR_ADDR ((uint)0xf8000000)
#define BCSR_SIZE ((uint)(32 * 1024))
/* PCI interrupt controller */
#define PIRQA MPC85xx_IRQ_EXT1
#define PIRQB MPC85xx_IRQ_EXT2
#define PIRQC MPC85xx_IRQ_EXT3
#define PIRQD MPC85xx_IRQ_EXT4
/* Offset of CPM register space */
#define CPM_MAP_ADDR (CCSRBAR + MPC85xx_CPM_OFFSET)
#endif /* __MACH_MPC8540ADS_H__ */

View File

@ -0,0 +1,18 @@
/*
* arch/ppc/platforms/85xx/mpc85xx.h
*
* MPC85xx soc definitions/function decls
*
* Maintainer: Kumar Gala <kumar.gala@freescale.com>
*
* Copyright 2005 Freescale Semiconductor Inc.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
*/
extern void mpc85xx_restart(char *);
extern int add_bridge(struct device_node *dev);

View File

@ -0,0 +1,244 @@
/*
* MPC85xx setup and early boot code plus other random bits.
*
* Maintained by Kumar Gala (see MAINTAINERS for contact information)
*
* Copyright 2005 Freescale Semiconductor Inc.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*/
#include <linux/config.h>
#include <linux/stddef.h>
#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/kdev_t.h>
#include <linux/delay.h>
#include <linux/seq_file.h>
#include <linux/root_dev.h>
#include <asm/system.h>
#include <asm/time.h>
#include <asm/machdep.h>
#include <asm/pci-bridge.h>
#include <asm/mpc85xx.h>
#include <asm/prom.h>
#include <asm/mpic.h>
#include <mm/mmu_decl.h>
#include <asm/udbg.h>
#include <sysdev/fsl_soc.h>
#include "mpc85xx.h"
#ifndef CONFIG_PCI
unsigned long isa_io_base = 0;
unsigned long isa_mem_base = 0;
#endif
/*
* Internal interrupts are all Level Sensitive, and Positive Polarity
*
* Note: Likely, this table and the following function should be
* obtained and derived from the OF Device Tree.
*/
static u_char mpc85xx_ads_openpic_initsenses[] __initdata = {
MPC85XX_INTERNAL_IRQ_SENSES,
0x0, /* External 0: */
#if defined(CONFIG_PCI)
(IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE), /* Ext 1: PCI slot 0 */
(IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE), /* Ext 2: PCI slot 1 */
(IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE), /* Ext 3: PCI slot 2 */
(IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE), /* Ext 4: PCI slot 3 */
#else
0x0, /* External 1: */
0x0, /* External 2: */
0x0, /* External 3: */
0x0, /* External 4: */
#endif
(IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE), /* External 5: PHY */
0x0, /* External 6: */
(IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE), /* External 7: PHY */
0x0, /* External 8: */
0x0, /* External 9: */
0x0, /* External 10: */
0x0, /* External 11: */
};
#ifdef CONFIG_PCI
/*
* interrupt routing
*/
int
mpc85xx_map_irq(struct pci_dev *dev, unsigned char idsel, unsigned char pin)
{
static char pci_irq_table[][4] =
/*
* This is little evil, but works around the fact
* that revA boards have IDSEL starting at 18
* and others boards (older) start at 12
*
* PCI IDSEL/INTPIN->INTLINE
* A B C D
*/
{
{PIRQA, PIRQB, PIRQC, PIRQD}, /* IDSEL 2 */
{PIRQD, PIRQA, PIRQB, PIRQC},
{PIRQC, PIRQD, PIRQA, PIRQB},
{PIRQB, PIRQC, PIRQD, PIRQA}, /* IDSEL 5 */
{0, 0, 0, 0}, /* -- */
{0, 0, 0, 0}, /* -- */
{0, 0, 0, 0}, /* -- */
{0, 0, 0, 0}, /* -- */
{0, 0, 0, 0}, /* -- */
{0, 0, 0, 0}, /* -- */
{PIRQA, PIRQB, PIRQC, PIRQD}, /* IDSEL 12 */
{PIRQD, PIRQA, PIRQB, PIRQC},
{PIRQC, PIRQD, PIRQA, PIRQB},
{PIRQB, PIRQC, PIRQD, PIRQA}, /* IDSEL 15 */
{0, 0, 0, 0}, /* -- */
{0, 0, 0, 0}, /* -- */
{PIRQA, PIRQB, PIRQC, PIRQD}, /* IDSEL 18 */
{PIRQD, PIRQA, PIRQB, PIRQC},
{PIRQC, PIRQD, PIRQA, PIRQB},
{PIRQB, PIRQC, PIRQD, PIRQA}, /* IDSEL 21 */
};
const long min_idsel = 2, max_idsel = 21, irqs_per_slot = 4;
return PCI_IRQ_TABLE_LOOKUP;
}
int
mpc85xx_exclude_device(u_char bus, u_char devfn)
{
if (bus == 0 && PCI_SLOT(devfn) == 0)
return PCIBIOS_DEVICE_NOT_FOUND;
else
return PCIBIOS_SUCCESSFUL;
}
#endif /* CONFIG_PCI */
void __init mpc85xx_ads_pic_init(void)
{
struct mpic *mpic1;
phys_addr_t OpenPIC_PAddr;
/* Determine the Physical Address of the OpenPIC regs */
OpenPIC_PAddr = get_immrbase() + MPC85xx_OPENPIC_OFFSET;
mpic1 = mpic_alloc(OpenPIC_PAddr,
MPIC_PRIMARY | MPIC_WANTS_RESET | MPIC_BIG_ENDIAN,
4, MPC85xx_OPENPIC_IRQ_OFFSET, 0, 250,
mpc85xx_ads_openpic_initsenses,
sizeof(mpc85xx_ads_openpic_initsenses),
" OpenPIC ");
BUG_ON(mpic1 == NULL);
mpic_assign_isu(mpic1, 0, OpenPIC_PAddr + 0x10200);
mpic_assign_isu(mpic1, 1, OpenPIC_PAddr + 0x10280);
mpic_assign_isu(mpic1, 2, OpenPIC_PAddr + 0x10300);
mpic_assign_isu(mpic1, 3, OpenPIC_PAddr + 0x10380);
mpic_assign_isu(mpic1, 4, OpenPIC_PAddr + 0x10400);
mpic_assign_isu(mpic1, 5, OpenPIC_PAddr + 0x10480);
mpic_assign_isu(mpic1, 6, OpenPIC_PAddr + 0x10500);
mpic_assign_isu(mpic1, 7, OpenPIC_PAddr + 0x10580);
/* dummy mappings to get to 48 */
mpic_assign_isu(mpic1, 8, OpenPIC_PAddr + 0x10600);
mpic_assign_isu(mpic1, 9, OpenPIC_PAddr + 0x10680);
mpic_assign_isu(mpic1, 10, OpenPIC_PAddr + 0x10700);
mpic_assign_isu(mpic1, 11, OpenPIC_PAddr + 0x10780);
/* External ints */
mpic_assign_isu(mpic1, 12, OpenPIC_PAddr + 0x10000);
mpic_assign_isu(mpic1, 13, OpenPIC_PAddr + 0x10080);
mpic_assign_isu(mpic1, 14, OpenPIC_PAddr + 0x10100);
mpic_init(mpic1);
}
/*
* Setup the architecture
*/
static void __init mpc85xx_ads_setup_arch(void)
{
struct device_node *cpu;
struct device_node *np;
if (ppc_md.progress)
ppc_md.progress("mpc85xx_ads_setup_arch()", 0);
cpu = of_find_node_by_type(NULL, "cpu");
if (cpu != 0) {
unsigned int *fp;
fp = (int *)get_property(cpu, "clock-frequency", NULL);
if (fp != 0)
loops_per_jiffy = *fp / HZ;
else
loops_per_jiffy = 50000000 / HZ;
of_node_put(cpu);
}
#ifdef CONFIG_PCI
for (np = NULL; (np = of_find_node_by_type(np, "pci")) != NULL;)
add_bridge(np);
ppc_md.pci_swizzle = common_swizzle;
ppc_md.pci_map_irq = mpc85xx_map_irq;
ppc_md.pci_exclude_device = mpc85xx_exclude_device;
#endif
#ifdef CONFIG_ROOT_NFS
ROOT_DEV = Root_NFS;
#else
ROOT_DEV = Root_HDA1;
#endif
}
void mpc85xx_ads_show_cpuinfo(struct seq_file *m)
{
uint pvid, svid, phid1;
uint memsize = total_memory;
pvid = mfspr(SPRN_PVR);
svid = mfspr(SPRN_SVR);
seq_printf(m, "Vendor\t\t: Freescale Semiconductor\n");
seq_printf(m, "Machine\t\t: mpc85xx\n");
seq_printf(m, "PVR\t\t: 0x%x\n", pvid);
seq_printf(m, "SVR\t\t: 0x%x\n", svid);
/* Display cpu Pll setting */
phid1 = mfspr(SPRN_HID1);
seq_printf(m, "PLL setting\t: 0x%x\n", ((phid1 >> 24) & 0x3f));
/* Display the amount of memory */
seq_printf(m, "Memory\t\t: %d MB\n", memsize / (1024 * 1024));
}
void __init platform_init(void)
{
ppc_md.setup_arch = mpc85xx_ads_setup_arch;
ppc_md.show_cpuinfo = mpc85xx_ads_show_cpuinfo;
ppc_md.init_IRQ = mpc85xx_ads_pic_init;
ppc_md.get_irq = mpic_get_irq;
ppc_md.restart = mpc85xx_restart;
ppc_md.power_off = NULL;
ppc_md.halt = NULL;
ppc_md.time_init = NULL;
ppc_md.set_rtc_time = NULL;
ppc_md.get_rtc_time = NULL;
ppc_md.calibrate_decr = generic_calibrate_decr;
ppc_md.progress = udbg_progress;
if (ppc_md.progress)
ppc_md.progress("mpc85xx_ads platform_init(): exit", 0);
}

View File

@ -0,0 +1,96 @@
/*
* FSL SoC setup code
*
* Maintained by Kumar Gala (see MAINTAINERS for contact information)
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*/
#include <linux/config.h>
#include <linux/stddef.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <linux/module.h>
#include <asm/system.h>
#include <asm/atomic.h>
#include <asm/io.h>
#include <asm/pci-bridge.h>
#include <asm/prom.h>
#include <sysdev/fsl_soc.h>
#undef DEBUG
#ifdef DEBUG
#define DBG(x...) printk(x)
#else
#define DBG(x...)
#endif
int mpc85xx_pci2_busno = 0;
#ifdef CONFIG_PCI
int __init add_bridge(struct device_node *dev)
{
int len;
struct pci_controller *hose;
struct resource rsrc;
int *bus_range;
int primary = 1, has_address = 0;
phys_addr_t immr = get_immrbase();
DBG("Adding PCI host bridge %s\n", dev->full_name);
/* Fetch host bridge registers address */
has_address = (of_address_to_resource(dev, 0, &rsrc) == 0);
/* Get bus range if any */
bus_range = (int *) get_property(dev, "bus-range", &len);
if (bus_range == NULL || len < 2 * sizeof(int)) {
printk(KERN_WARNING "Can't get bus-range for %s, assume"
" bus 0\n", dev->full_name);
}
hose = pcibios_alloc_controller();
if (!hose)
return -ENOMEM;
hose->arch_data = dev;
hose->set_cfg_type = 1;
hose->first_busno = bus_range ? bus_range[0] : 0;
hose->last_busno = bus_range ? bus_range[1] : 0xff;
/* PCI 1 */
if ((rsrc.start & 0xfffff) == 0x8000) {
setup_indirect_pci(hose, immr + 0x8000, immr + 0x8004);
}
/* PCI 2 */
if ((rsrc.start & 0xfffff) == 0x9000) {
setup_indirect_pci(hose, immr + 0x9000, immr + 0x9004);
primary = 0;
hose->bus_offset = hose->first_busno;
mpc85xx_pci2_busno = hose->first_busno;
}
printk(KERN_INFO "Found MPC85xx PCI host bridge at 0x%08lx. "
"Firmware bus number: %d->%d\n",
rsrc.start, hose->first_busno, hose->last_busno);
DBG(" ->Hose at 0x%p, cfg_addr=0x%p,cfg_data=0x%p\n",
hose, hose->cfg_addr, hose->cfg_data);
/* Interpret the "ranges" property */
/* This also maps the I/O region and sets isa_io/mem_base */
pci_process_bridge_OF_ranges(hose, dev, primary);
return 0;
}
#endif

View File

@ -8,7 +8,7 @@ endif
obj-$(CONFIG_PPC_CHRP) += chrp/ obj-$(CONFIG_PPC_CHRP) += chrp/
obj-$(CONFIG_4xx) += 4xx/ obj-$(CONFIG_4xx) += 4xx/
obj-$(CONFIG_PPC_83xx) += 83xx/ obj-$(CONFIG_PPC_83xx) += 83xx/
obj-$(CONFIG_85xx) += 85xx/ obj-$(CONFIG_PPC_85xx) += 85xx/
obj-$(CONFIG_PPC_PSERIES) += pseries/ obj-$(CONFIG_PPC_PSERIES) += pseries/
obj-$(CONFIG_PPC_ISERIES) += iseries/ obj-$(CONFIG_PPC_ISERIES) += iseries/
obj-$(CONFIG_PPC_MAPLE) += maple/ obj-$(CONFIG_PPC_MAPLE) += maple/

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/platforms/chrp_pegasos_eth.c
*
* Copyright (C) 2005 Sven Luther <sl@bplan-gmbh.de> * Copyright (C) 2005 Sven Luther <sl@bplan-gmbh.de>
* Thanks to : * Thanks to :
* Dale Farnsworth <dale@farnsworth.org> * Dale Farnsworth <dale@farnsworth.org>

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/platforms/setup.c
*
* Copyright (C) 1995 Linus Torvalds * Copyright (C) 1995 Linus Torvalds
* Adapted from 'alpha' version by Gary Thomas * Adapted from 'alpha' version by Gary Thomas
* Modified by Cort Dougan (cort@cs.nmt.edu) * Modified by Cort Dougan (cort@cs.nmt.edu)

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/platforms/chrp_time.c
*
* Copyright (C) 1991, 1992, 1995 Linus Torvalds * Copyright (C) 1991, 1992, 1995 Linus Torvalds
* *
* Adapted for PowerPC (PReP) by Gary Thomas * Adapted for PowerPC (PReP) by Gary Thomas

View File

@ -46,6 +46,7 @@
#include "setup.h" #include "setup.h"
extern int piranha_simulator; extern int piranha_simulator;
static int mf_initialized;
/* /*
* This is the structure layout for the Machine Facilites LPAR event * This is the structure layout for the Machine Facilites LPAR event
@ -143,7 +144,8 @@ static spinlock_t pending_event_spinlock;
static struct pending_event *pending_event_head; static struct pending_event *pending_event_head;
static struct pending_event *pending_event_tail; static struct pending_event *pending_event_tail;
static struct pending_event *pending_event_avail; static struct pending_event *pending_event_avail;
static struct pending_event pending_event_prealloc[16]; #define PENDING_EVENT_PREALLOC_LEN 16
static struct pending_event pending_event_prealloc[PENDING_EVENT_PREALLOC_LEN];
/* /*
* Put a pending event onto the available queue, so it can get reused. * Put a pending event onto the available queue, so it can get reused.
@ -597,7 +599,7 @@ void mf_power_off(void)
* Global kernel interface to tell the VSP object in the primary * Global kernel interface to tell the VSP object in the primary
* partition to reboot this partition. * partition to reboot this partition.
*/ */
void mf_reboot(void) void mf_reboot(char *cmd)
{ {
printk(KERN_INFO "mf.c: Preparing to bounce...\n"); printk(KERN_INFO "mf.c: Preparing to bounce...\n");
signal_ce_msg_simple(0x4e, NULL); signal_ce_msg_simple(0x4e, NULL);
@ -625,7 +627,7 @@ void mf_display_src(u32 word)
/* /*
* Display a single word SRC of the form "PROGXXXX" on the VSP control panel. * Display a single word SRC of the form "PROGXXXX" on the VSP control panel.
*/ */
void mf_display_progress(u16 value) static __init void mf_display_progress_src(u16 value)
{ {
u8 ce[12]; u8 ce[12];
u8 src[72]; u8 src[72];
@ -649,30 +651,42 @@ void mf_display_progress(u16 value)
* Clear the VSP control panel. Used to "erase" an SRC that was * Clear the VSP control panel. Used to "erase" an SRC that was
* previously displayed. * previously displayed.
*/ */
void mf_clear_src(void) static void mf_clear_src(void)
{ {
signal_ce_msg_simple(0x4b, NULL); signal_ce_msg_simple(0x4b, NULL);
} }
void __init mf_display_progress(u16 value)
{
if (piranha_simulator || !mf_initialized)
return;
if (0xFFFF == value)
mf_clear_src();
else
mf_display_progress_src(value);
}
/* /*
* Initialization code here. * Initialization code here.
*/ */
void mf_init(void) void __init mf_init(void)
{ {
int i; int i;
/* initialize */
spin_lock_init(&pending_event_spinlock); spin_lock_init(&pending_event_spinlock);
for (i = 0;
i < sizeof(pending_event_prealloc) / sizeof(*pending_event_prealloc); for (i = 0; i < PENDING_EVENT_PREALLOC_LEN; i++)
++i)
free_pending_event(&pending_event_prealloc[i]); free_pending_event(&pending_event_prealloc[i]);
HvLpEvent_registerHandler(HvLpEvent_Type_MachineFac, &hv_handler); HvLpEvent_registerHandler(HvLpEvent_Type_MachineFac, &hv_handler);
/* virtual continue ack */ /* virtual continue ack */
signal_ce_msg_simple(0x57, NULL); signal_ce_msg_simple(0x57, NULL);
/* initialization complete */ mf_initialized = 1;
mb();
printk(KERN_NOTICE "mf.c: iSeries Linux LPAR Machine Facilities " printk(KERN_NOTICE "mf.c: iSeries Linux LPAR Machine Facilities "
"initialized\n"); "initialized\n");
} }
@ -692,6 +706,43 @@ static void get_rtc_time_complete(void *token, struct ce_msg_data *ce_msg)
complete(&rtc->com); complete(&rtc->com);
} }
static int mf_set_rtc(struct rtc_time *tm)
{
char ce_time[12];
u8 day, mon, hour, min, sec, y1, y2;
unsigned year;
year = 1900 + tm->tm_year;
y1 = year / 100;
y2 = year % 100;
sec = tm->tm_sec;
min = tm->tm_min;
hour = tm->tm_hour;
day = tm->tm_mday;
mon = tm->tm_mon + 1;
BIN_TO_BCD(sec);
BIN_TO_BCD(min);
BIN_TO_BCD(hour);
BIN_TO_BCD(mon);
BIN_TO_BCD(day);
BIN_TO_BCD(y1);
BIN_TO_BCD(y2);
memset(ce_time, 0, sizeof(ce_time));
ce_time[3] = 0x41;
ce_time[4] = y1;
ce_time[5] = y2;
ce_time[6] = sec;
ce_time[7] = min;
ce_time[8] = hour;
ce_time[10] = day;
ce_time[11] = mon;
return signal_ce_msg(ce_time, NULL);
}
static int rtc_set_tm(int rc, u8 *ce_msg, struct rtc_time *tm) static int rtc_set_tm(int rc, u8 *ce_msg, struct rtc_time *tm)
{ {
tm->tm_wday = 0; tm->tm_wday = 0;
@ -747,7 +798,7 @@ static int rtc_set_tm(int rc, u8 *ce_msg, struct rtc_time *tm)
return 0; return 0;
} }
int mf_get_rtc(struct rtc_time *tm) static int mf_get_rtc(struct rtc_time *tm)
{ {
struct ce_msg_comp_data ce_complete; struct ce_msg_comp_data ce_complete;
struct rtc_time_data rtc_data; struct rtc_time_data rtc_data;
@ -780,7 +831,7 @@ static void get_boot_rtc_time_complete(void *token, struct ce_msg_data *ce_msg)
rtc->busy = 0; rtc->busy = 0;
} }
int mf_get_boot_rtc(struct rtc_time *tm) static int mf_get_boot_rtc(struct rtc_time *tm)
{ {
struct ce_msg_comp_data ce_complete; struct ce_msg_comp_data ce_complete;
struct boot_rtc_time_data rtc_data; struct boot_rtc_time_data rtc_data;
@ -802,43 +853,6 @@ int mf_get_boot_rtc(struct rtc_time *tm)
return rtc_set_tm(rtc_data.rc, rtc_data.ce_msg.ce_msg, tm); return rtc_set_tm(rtc_data.rc, rtc_data.ce_msg.ce_msg, tm);
} }
int mf_set_rtc(struct rtc_time *tm)
{
char ce_time[12];
u8 day, mon, hour, min, sec, y1, y2;
unsigned year;
year = 1900 + tm->tm_year;
y1 = year / 100;
y2 = year % 100;
sec = tm->tm_sec;
min = tm->tm_min;
hour = tm->tm_hour;
day = tm->tm_mday;
mon = tm->tm_mon + 1;
BIN_TO_BCD(sec);
BIN_TO_BCD(min);
BIN_TO_BCD(hour);
BIN_TO_BCD(mon);
BIN_TO_BCD(day);
BIN_TO_BCD(y1);
BIN_TO_BCD(y2);
memset(ce_time, 0, sizeof(ce_time));
ce_time[3] = 0x41;
ce_time[4] = y1;
ce_time[5] = y2;
ce_time[6] = sec;
ce_time[7] = min;
ce_time[8] = hour;
ce_time[10] = day;
ce_time[11] = mon;
return signal_ce_msg(ce_time, NULL);
}
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
static int proc_mf_dump_cmdline(char *page, char **start, off_t off, static int proc_mf_dump_cmdline(char *page, char **start, off_t off,

View File

@ -50,6 +50,7 @@
#include <asm/iseries/hv_call_xm.h> #include <asm/iseries/hv_call_xm.h>
#include <asm/iseries/it_lp_queue.h> #include <asm/iseries/it_lp_queue.h>
#include <asm/iseries/mf.h> #include <asm/iseries/mf.h>
#include <asm/iseries/it_exp_vpd_panel.h>
#include <asm/iseries/hv_lp_event.h> #include <asm/iseries/hv_lp_event.h>
#include <asm/iseries/lpar_map.h> #include <asm/iseries/lpar_map.h>
#include <asm/udbg.h> #include <asm/udbg.h>
@ -89,8 +90,6 @@ extern unsigned long embedded_sysmap_end;
extern unsigned long iSeries_recal_tb; extern unsigned long iSeries_recal_tb;
extern unsigned long iSeries_recal_titan; extern unsigned long iSeries_recal_titan;
static int mf_initialized;
static unsigned long cmd_mem_limit; static unsigned long cmd_mem_limit;
struct MemoryBlock { struct MemoryBlock {
@ -303,8 +302,6 @@ static void __init iSeries_init_early(void)
{ {
DBG(" -> iSeries_init_early()\n"); DBG(" -> iSeries_init_early()\n");
ppc64_firmware_features = FW_FEATURE_ISERIES;
ppc64_interrupt_controller = IC_ISERIES; ppc64_interrupt_controller = IC_ISERIES;
#if defined(CONFIG_BLK_DEV_INITRD) #if defined(CONFIG_BLK_DEV_INITRD)
@ -349,8 +346,6 @@ static void __init iSeries_init_early(void)
HvCallEvent_setLpEventQueueInterruptProc(0, 0); HvCallEvent_setLpEventQueueInterruptProc(0, 0);
mf_init(); mf_init();
mf_initialized = 1;
mb();
/* If we were passed an initrd, set the ROOT_DEV properly if the values /* If we were passed an initrd, set the ROOT_DEV properly if the values
* look sensible. If not, clear initrd reference. * look sensible. If not, clear initrd reference.
@ -560,39 +555,10 @@ static void iSeries_show_cpuinfo(struct seq_file *m)
seq_printf(m, "machine\t\t: 64-bit iSeries Logical Partition\n"); seq_printf(m, "machine\t\t: 64-bit iSeries Logical Partition\n");
} }
/*
* Document me.
*/
static void iSeries_restart(char *cmd)
{
mf_reboot();
}
/*
* Document me.
*/
static void iSeries_power_off(void)
{
mf_power_off();
}
/*
* Document me.
*/
static void iSeries_halt(void)
{
mf_power_off();
}
static void __init iSeries_progress(char * st, unsigned short code) static void __init iSeries_progress(char * st, unsigned short code)
{ {
printk("Progress: [%04x] - %s\n", (unsigned)code, st); printk("Progress: [%04x] - %s\n", (unsigned)code, st);
if (!piranha_simulator && mf_initialized) { mf_display_progress(code);
if (code != 0xffff)
mf_display_progress(code);
else
mf_clear_src();
}
} }
static void __init iSeries_fixup_klimit(void) static void __init iSeries_fixup_klimit(void)
@ -711,7 +677,13 @@ void __init iSeries_init_IRQ(void) { }
static int __init iseries_probe(int platform) static int __init iseries_probe(int platform)
{ {
return PLATFORM_ISERIES_LPAR == platform; if (PLATFORM_ISERIES_LPAR != platform)
return 0;
ppc64_firmware_features |= FW_FEATURE_ISERIES;
ppc64_firmware_features |= FW_FEATURE_LPAR;
return 1;
} }
struct machdep_calls __initdata iseries_md = { struct machdep_calls __initdata iseries_md = {
@ -721,9 +693,9 @@ struct machdep_calls __initdata iseries_md = {
.get_irq = iSeries_get_irq, .get_irq = iSeries_get_irq,
.init_early = iSeries_init_early, .init_early = iSeries_init_early,
.pcibios_fixup = iSeries_pci_final_fixup, .pcibios_fixup = iSeries_pci_final_fixup,
.restart = iSeries_restart, .restart = mf_reboot,
.power_off = iSeries_power_off, .power_off = mf_power_off,
.halt = iSeries_halt, .halt = mf_power_off,
.get_boot_time = iSeries_get_boot_time, .get_boot_time = iSeries_get_boot_time,
.set_rtc_time = iSeries_set_rtc_time, .set_rtc_time = iSeries_set_rtc_time,
.get_rtc_time = iSeries_get_rtc_time, .get_rtc_time = iSeries_get_rtc_time,
@ -917,6 +889,24 @@ void dt_cpus(struct iseries_flat_dt *dt)
dt_end_node(dt); dt_end_node(dt);
} }
void dt_model(struct iseries_flat_dt *dt)
{
char buf[16] = "IBM,";
/* "IBM," + mfgId[2:3] + systemSerial[1:5] */
strne2a(buf + 4, xItExtVpdPanel.mfgID + 2, 2);
strne2a(buf + 6, xItExtVpdPanel.systemSerial + 1, 5);
buf[11] = '\0';
dt_prop_str(dt, "system-id", buf);
/* "IBM," + machineType[0:4] */
strne2a(buf + 4, xItExtVpdPanel.machineType, 4);
buf[8] = '\0';
dt_prop_str(dt, "model", buf);
dt_prop_str(dt, "compatible", "IBM,iSeries");
}
void build_flat_dt(struct iseries_flat_dt *dt, unsigned long phys_mem_size) void build_flat_dt(struct iseries_flat_dt *dt, unsigned long phys_mem_size)
{ {
u64 tmp[2]; u64 tmp[2];
@ -927,6 +917,7 @@ void build_flat_dt(struct iseries_flat_dt *dt, unsigned long phys_mem_size)
dt_prop_u32(dt, "#address-cells", 2); dt_prop_u32(dt, "#address-cells", 2);
dt_prop_u32(dt, "#size-cells", 2); dt_prop_u32(dt, "#size-cells", 2);
dt_model(dt);
/* /memory */ /* /memory */
dt_start_node(dt, "memory@0"); dt_start_node(dt, "memory@0");
@ -940,6 +931,7 @@ void build_flat_dt(struct iseries_flat_dt *dt, unsigned long phys_mem_size)
/* /chosen */ /* /chosen */
dt_start_node(dt, "chosen"); dt_start_node(dt, "chosen");
dt_prop_u32(dt, "linux,platform", PLATFORM_ISERIES_LPAR); dt_prop_u32(dt, "linux,platform", PLATFORM_ISERIES_LPAR);
dt_prop_str(dt, "bootargs", cmd_line);
if (cmd_mem_limit) if (cmd_mem_limit)
dt_prop_u64(dt, "linux,memory-limit", cmd_mem_limit); dt_prop_u64(dt, "linux,memory-limit", cmd_mem_limit);
dt_end_node(dt); dt_end_node(dt);

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc64/kernel/maple_time.c
*
* (c) Copyright 2004 Benjamin Herrenschmidt (benh@kernel.crashing.org), * (c) Copyright 2004 Benjamin Herrenschmidt (benh@kernel.crashing.org),
* IBM Corp. * IBM Corp.
* *

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/platforms/pmac_cpufreq.c
*
* Copyright (C) 2002 - 2005 Benjamin Herrenschmidt <benh@kernel.crashing.org> * Copyright (C) 2002 - 2005 Benjamin Herrenschmidt <benh@kernel.crashing.org>
* Copyright (C) 2004 John Steele Scott <toojays@toojays.net> * Copyright (C) 2004 John Steele Scott <toojays@toojays.net>
* *

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/platforms/pmac_feature.c
*
* Copyright (C) 1996-2001 Paul Mackerras (paulus@cs.anu.edu.au) * Copyright (C) 1996-2001 Paul Mackerras (paulus@cs.anu.edu.au)
* Ben. Herrenschmidt (benh@kernel.crashing.org) * Ben. Herrenschmidt (benh@kernel.crashing.org)
* *

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/platforms/pmac_nvram.c
*
* Copyright (C) 2002 Benjamin Herrenschmidt (benh@kernel.crashing.org) * Copyright (C) 2002 Benjamin Herrenschmidt (benh@kernel.crashing.org)
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or

View File

@ -86,11 +86,10 @@ int ppc_override_l2cr = 0;
int ppc_override_l2cr_value; int ppc_override_l2cr_value;
int has_l2cache = 0; int has_l2cache = 0;
int pmac_newworld = 1; int pmac_newworld;
static int current_root_goodness = -1; static int current_root_goodness = -1;
extern int pmac_newworld;
extern struct machdep_calls pmac_md; extern struct machdep_calls pmac_md;
#define DEFAULT_ROOT_DEVICE Root_SDA1 /* sda1 - slightly silly choice */ #define DEFAULT_ROOT_DEVICE Root_SDA1 /* sda1 - slightly silly choice */
@ -308,9 +307,10 @@ static void __init pmac_setup_arch(void)
for (ic = NULL; (ic = of_find_all_nodes(ic)) != NULL; ) for (ic = NULL; (ic = of_find_all_nodes(ic)) != NULL; )
if (get_property(ic, "interrupt-controller", NULL)) if (get_property(ic, "interrupt-controller", NULL))
break; break;
pmac_newworld = (ic != NULL); if (ic) {
if (ic) pmac_newworld = 1;
of_node_put(ic); of_node_put(ic);
}
/* Lookup PCI hosts */ /* Lookup PCI hosts */
pmac_pci_init(); pmac_pci_init();

View File

@ -1,5 +1,6 @@
obj-y := pci.o lpar.o hvCall.o nvram.o reconfig.o \ obj-y := pci.o lpar.o hvCall.o nvram.o reconfig.o \
setup.o iommu.o ras.o rtasd.o pci_dlpar.o setup.o iommu.o ras.o rtasd.o pci_dlpar.o \
firmware.o
obj-$(CONFIG_SMP) += smp.o obj-$(CONFIG_SMP) += smp.o
obj-$(CONFIG_IBMVIO) += vio.o obj-$(CONFIG_IBMVIO) += vio.o
obj-$(CONFIG_XICS) += xics.o obj-$(CONFIG_XICS) += xics.o

View File

@ -0,0 +1,103 @@
/*
* pSeries firmware setup code.
*
* Portions from arch/powerpc/platforms/pseries/setup.c:
* Copyright (C) 1995 Linus Torvalds
* Adapted from 'alpha' version by Gary Thomas
* Modified by Cort Dougan (cort@cs.nmt.edu)
* Modified by PPC64 Team, IBM Corp
*
* Portions from arch/powerpc/kernel/firmware.c
* Copyright (C) 2001 Ben. Herrenschmidt (benh@kernel.crashing.org)
* Modifications for ppc64:
* Copyright (C) 2003 Dave Engebretsen <engebret@us.ibm.com>
* Copyright (C) 2005 Stephen Rothwell, IBM Corporation
*
* Copyright 2006 IBM Corporation.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*/
#undef DEBUG
#include <asm/firmware.h>
#include <asm/prom.h>
#ifdef DEBUG
#define DBG(fmt...) udbg_printf(fmt)
#else
#define DBG(fmt...)
#endif
typedef struct {
unsigned long val;
char * name;
} firmware_feature_t;
static __initdata firmware_feature_t
firmware_features_table[FIRMWARE_MAX_FEATURES] = {
{FW_FEATURE_PFT, "hcall-pft"},
{FW_FEATURE_TCE, "hcall-tce"},
{FW_FEATURE_SPRG0, "hcall-sprg0"},
{FW_FEATURE_DABR, "hcall-dabr"},
{FW_FEATURE_COPY, "hcall-copy"},
{FW_FEATURE_ASR, "hcall-asr"},
{FW_FEATURE_DEBUG, "hcall-debug"},
{FW_FEATURE_PERF, "hcall-perf"},
{FW_FEATURE_DUMP, "hcall-dump"},
{FW_FEATURE_INTERRUPT, "hcall-interrupt"},
{FW_FEATURE_MIGRATE, "hcall-migrate"},
{FW_FEATURE_PERFMON, "hcall-perfmon"},
{FW_FEATURE_CRQ, "hcall-crq"},
{FW_FEATURE_VIO, "hcall-vio"},
{FW_FEATURE_RDMA, "hcall-rdma"},
{FW_FEATURE_LLAN, "hcall-lLAN"},
{FW_FEATURE_BULK, "hcall-bulk"},
{FW_FEATURE_XDABR, "hcall-xdabr"},
{FW_FEATURE_MULTITCE, "hcall-multi-tce"},
{FW_FEATURE_SPLPAR, "hcall-splpar"},
};
/* Build up the firmware features bitmask using the contents of
* device-tree/ibm,hypertas-functions. Ultimately this functionality may
* be moved into prom.c prom_init().
*/
void __init fw_feature_init(void)
{
struct device_node *dn;
char *hypertas, *s;
int len, i;
DBG(" -> fw_feature_init()\n");
dn = of_find_node_by_path("/rtas");
if (dn == NULL) {
printk(KERN_ERR "WARNING! Cannot find RTAS in device-tree!\n");
goto out;
}
hypertas = get_property(dn, "ibm,hypertas-functions", &len);
if (hypertas == NULL)
goto out;
for (s = hypertas; s < hypertas + len; s += strlen(s) + 1) {
for (i = 0; i < FIRMWARE_MAX_FEATURES; i++) {
/* check value against table of strings */
if (!firmware_features_table[i].name ||
strcmp(firmware_features_table[i].name, s))
continue;
/* we have a match */
ppc64_firmware_features |=
firmware_features_table[i].val;
break;
}
}
out:
of_node_put(dn);
DBG(" <- fw_feature_init()\n");
}

View File

@ -0,0 +1,17 @@
/*
* Copyright 2006 IBM Corporation.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*/
#ifndef _PSERIES_FIRMWARE_H
#define _PSERIES_FIRMWARE_H
#include <asm/firmware.h>
extern void __init fw_feature_init(void);
#endif /* _PSERIES_FIRMWARE_H */

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc64/kernel/pSeries_hvCall.S
*
* This file contains the generic code to perform a call to the * This file contains the generic code to perform a call to the
* pSeries LPAR hypervisor. * pSeries LPAR hypervisor.
* NOTE: this file will go away when we move to inline this work. * NOTE: this file will go away when we move to inline this work.

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc64/kernel/pSeries_iommu.c
*
* Copyright (C) 2001 Mike Corrigan & Dave Engebretsen, IBM Corporation * Copyright (C) 2001 Mike Corrigan & Dave Engebretsen, IBM Corporation
* *
* Rewrite, cleanup: * Rewrite, cleanup:
@ -582,7 +580,7 @@ void iommu_init_early_pSeries(void)
return; return;
} }
if (platform_is_lpar()) { if (firmware_has_feature(FW_FEATURE_LPAR)) {
if (firmware_has_feature(FW_FEATURE_MULTITCE)) { if (firmware_has_feature(FW_FEATURE_MULTITCE)) {
ppc_md.tce_build = tce_buildmulti_pSeriesLP; ppc_md.tce_build = tce_buildmulti_pSeriesLP;
ppc_md.tce_free = tce_freemulti_pSeriesLP; ppc_md.tce_free = tce_freemulti_pSeriesLP;

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc64/kernel/pSeries_pci.c
*
* Copyright (C) 2001 Dave Engebretsen, IBM Corporation * Copyright (C) 2001 Dave Engebretsen, IBM Corporation
* Copyright (C) 2003 Anton Blanchard <anton@au.ibm.com>, IBM * Copyright (C) 2003 Anton Blanchard <anton@au.ibm.com>, IBM
* *

View File

@ -60,7 +60,6 @@
#include <asm/time.h> #include <asm/time.h>
#include <asm/nvram.h> #include <asm/nvram.h>
#include "xics.h" #include "xics.h"
#include <asm/firmware.h>
#include <asm/pmc.h> #include <asm/pmc.h>
#include <asm/mpic.h> #include <asm/mpic.h>
#include <asm/ppc-pci.h> #include <asm/ppc-pci.h>
@ -70,6 +69,7 @@
#include "plpar_wrappers.h" #include "plpar_wrappers.h"
#include "ras.h" #include "ras.h"
#include "firmware.h"
#ifdef DEBUG #ifdef DEBUG
#define DBG(fmt...) udbg_printf(fmt) #define DBG(fmt...) udbg_printf(fmt)
@ -246,7 +246,7 @@ static void __init pSeries_setup_arch(void)
ppc_md.idle_loop = default_idle; ppc_md.idle_loop = default_idle;
} }
if (platform_is_lpar()) if (firmware_has_feature(FW_FEATURE_LPAR))
ppc_md.enable_pmcs = pseries_lpar_enable_pmcs; ppc_md.enable_pmcs = pseries_lpar_enable_pmcs;
else else
ppc_md.enable_pmcs = power4_enable_pmcs; ppc_md.enable_pmcs = power4_enable_pmcs;
@ -262,53 +262,6 @@ static int __init pSeries_init_panel(void)
} }
arch_initcall(pSeries_init_panel); arch_initcall(pSeries_init_panel);
/* Build up the ppc64_firmware_features bitmask field
* using contents of device-tree/ibm,hypertas-functions.
* Ultimately this functionality may be moved into prom.c prom_init().
*/
static void __init fw_feature_init(void)
{
struct device_node * dn;
char * hypertas;
unsigned int len;
DBG(" -> fw_feature_init()\n");
ppc64_firmware_features = 0;
dn = of_find_node_by_path("/rtas");
if (dn == NULL) {
printk(KERN_ERR "WARNING ! Cannot find RTAS in device-tree !\n");
goto no_rtas;
}
hypertas = get_property(dn, "ibm,hypertas-functions", &len);
if (hypertas) {
while (len > 0){
int i, hypertas_len;
/* check value against table of strings */
for(i=0; i < FIRMWARE_MAX_FEATURES ;i++) {
if ((firmware_features_table[i].name) &&
(strcmp(firmware_features_table[i].name,hypertas))==0) {
/* we have a match */
ppc64_firmware_features |=
(firmware_features_table[i].val);
break;
}
}
hypertas_len = strlen(hypertas);
len -= hypertas_len +1;
hypertas+= hypertas_len +1;
}
}
of_node_put(dn);
no_rtas:
DBG(" <- fw_feature_init()\n");
}
static void __init pSeries_discover_pic(void) static void __init pSeries_discover_pic(void)
{ {
struct device_node *np; struct device_node *np;
@ -367,21 +320,16 @@ static int pseries_set_xdabr(unsigned long dabr)
*/ */
static void __init pSeries_init_early(void) static void __init pSeries_init_early(void)
{ {
int iommu_off = 0;
DBG(" -> pSeries_init_early()\n"); DBG(" -> pSeries_init_early()\n");
fw_feature_init(); fw_feature_init();
if (platform_is_lpar()) if (firmware_has_feature(FW_FEATURE_LPAR))
hpte_init_lpar(); hpte_init_lpar();
else { else
hpte_init_native(); hpte_init_native();
iommu_off = (of_chosen &&
get_property(of_chosen, "linux,iommu-off", NULL));
}
if (platform_is_lpar()) if (firmware_has_feature(FW_FEATURE_LPAR))
find_udbg_vterm(); find_udbg_vterm();
if (firmware_has_feature(FW_FEATURE_DABR)) if (firmware_has_feature(FW_FEATURE_DABR))
@ -437,6 +385,9 @@ static int __init pSeries_probe(int platform)
* it here ... * it here ...
*/ */
if (platform == PLATFORM_PSERIES_LPAR)
ppc64_firmware_features |= FW_FEATURE_LPAR;
return 1; return 1;
} }
@ -576,7 +527,7 @@ static void pseries_shared_idle(void)
static int pSeries_pci_probe_mode(struct pci_bus *bus) static int pSeries_pci_probe_mode(struct pci_bus *bus)
{ {
if (platform_is_lpar()) if (firmware_has_feature(FW_FEATURE_LPAR))
return PCI_PROBE_DEVTREE; return PCI_PROBE_DEVTREE;
return PCI_PROBE_NORMAL; return PCI_PROBE_NORMAL;
} }

View File

@ -443,7 +443,7 @@ void __init smp_init_pSeries(void)
smp_ops->cpu_die = pSeries_cpu_die; smp_ops->cpu_die = pSeries_cpu_die;
/* Processors can be added/removed only on LPAR */ /* Processors can be added/removed only on LPAR */
if (platform_is_lpar()) if (firmware_has_feature(FW_FEATURE_LPAR))
pSeries_reconfig_notifier_register(&pSeries_smp_nb); pSeries_reconfig_notifier_register(&pSeries_smp_nb);
#endif #endif

View File

@ -20,6 +20,7 @@
#include <linux/gfp.h> #include <linux/gfp.h>
#include <linux/radix-tree.h> #include <linux/radix-tree.h>
#include <linux/cpu.h> #include <linux/cpu.h>
#include <asm/firmware.h>
#include <asm/prom.h> #include <asm/prom.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/pgtable.h> #include <asm/pgtable.h>
@ -536,7 +537,7 @@ nextnode:
of_node_put(np); of_node_put(np);
} }
if (platform_is_lpar()) if (firmware_has_feature(FW_FEATURE_LPAR))
ops = &pSeriesLP_ops; ops = &pSeriesLP_ops;
else { else {
#ifdef CONFIG_SMP #ifdef CONFIG_SMP

View File

@ -194,8 +194,6 @@ static int dart_init(struct device_node *dart_node)
* prefetching into invalid pages and corrupting data * prefetching into invalid pages and corrupting data
*/ */
tmp = lmb_alloc(DART_PAGE_SIZE, DART_PAGE_SIZE); tmp = lmb_alloc(DART_PAGE_SIZE, DART_PAGE_SIZE);
if (!tmp)
panic("DART: Cannot allocate spare page!");
dart_emptyval = DARTMAP_VALID | ((tmp >> DART_PAGE_SHIFT) & dart_emptyval = DARTMAP_VALID | ((tmp >> DART_PAGE_SHIFT) &
DARTMAP_RPNMASK); DARTMAP_RPNMASK);

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/syslib/dcr.S
*
* "Indirect" DCR access * "Indirect" DCR access
* *
* Copyright (c) 2004 Eugene Surovegin <ebs@ebshome.net> * Copyright (c) 2004 Eugene Surovegin <ebs@ebshome.net>

View File

@ -40,7 +40,7 @@ phys_addr_t get_immrbase(void)
return immrbase; return immrbase;
soc = of_find_node_by_type(NULL, "soc"); soc = of_find_node_by_type(NULL, "soc");
if (soc != 0) { if (soc) {
unsigned int size; unsigned int size;
void *prop = get_property(soc, "reg", &size); void *prop = get_property(soc, "reg", &size);
immrbase = of_translate_address(soc, prop); immrbase = of_translate_address(soc, prop);
@ -49,21 +49,20 @@ phys_addr_t get_immrbase(void)
return immrbase; return immrbase;
} }
EXPORT_SYMBOL(get_immrbase); EXPORT_SYMBOL(get_immrbase);
static const char * gfar_tx_intr = "tx"; static int __init gfar_mdio_of_init(void)
static const char * gfar_rx_intr = "rx";
static const char * gfar_err_intr = "error";
static int __init gfar_of_init(void)
{ {
struct device_node *np; struct device_node *np;
unsigned int i; unsigned int i;
struct platform_device *mdio_dev, *gfar_dev; struct platform_device *mdio_dev;
struct resource res; struct resource res;
int ret; int ret;
for (np = NULL, i = 0; (np = of_find_compatible_node(np, "mdio", "gianfar")) != NULL; i++) { for (np = NULL, i = 0;
(np = of_find_compatible_node(np, "mdio", "gianfar")) != NULL;
i++) {
int k; int k;
struct device_node *child = NULL; struct device_node *child = NULL;
struct gianfar_mdio_data mdio_data; struct gianfar_mdio_data mdio_data;
@ -73,12 +72,14 @@ static int __init gfar_of_init(void)
ret = of_address_to_resource(np, 0, &res); ret = of_address_to_resource(np, 0, &res);
if (ret) if (ret)
goto mdio_err; goto err;
mdio_dev = platform_device_register_simple("fsl-gianfar_mdio", res.start, &res, 1); mdio_dev =
platform_device_register_simple("fsl-gianfar_mdio",
res.start, &res, 1);
if (IS_ERR(mdio_dev)) { if (IS_ERR(mdio_dev)) {
ret = PTR_ERR(mdio_dev); ret = PTR_ERR(mdio_dev);
goto mdio_err; goto err;
} }
for (k = 0; k < 32; k++) for (k = 0; k < 32; k++)
@ -86,17 +87,44 @@ static int __init gfar_of_init(void)
while ((child = of_get_next_child(np, child)) != NULL) { while ((child = of_get_next_child(np, child)) != NULL) {
if (child->n_intrs) { if (child->n_intrs) {
u32 *id = (u32 *) get_property(child, "reg", NULL); u32 *id =
(u32 *) get_property(child, "reg", NULL);
mdio_data.irq[*id] = child->intrs[0].line; mdio_data.irq[*id] = child->intrs[0].line;
} }
} }
ret = platform_device_add_data(mdio_dev, &mdio_data, sizeof(struct gianfar_mdio_data)); ret =
platform_device_add_data(mdio_dev, &mdio_data,
sizeof(struct gianfar_mdio_data));
if (ret) if (ret)
goto mdio_unreg; goto unreg;
} }
for (np = NULL, i = 0; (np = of_find_compatible_node(np, "network", "gianfar")) != NULL; i++) { return 0;
unreg:
platform_device_unregister(mdio_dev);
err:
return ret;
}
arch_initcall(gfar_mdio_of_init);
static const char *gfar_tx_intr = "tx";
static const char *gfar_rx_intr = "rx";
static const char *gfar_err_intr = "error";
static int __init gfar_of_init(void)
{
struct device_node *np;
unsigned int i;
struct platform_device *gfar_dev;
struct resource res;
int ret;
for (np = NULL, i = 0;
(np = of_find_compatible_node(np, "network", "gianfar")) != NULL;
i++) {
struct resource r[4]; struct resource r[4];
struct device_node *phy, *mdio; struct device_node *phy, *mdio;
struct gianfar_platform_data gfar_data; struct gianfar_platform_data gfar_data;
@ -110,7 +138,7 @@ static int __init gfar_of_init(void)
ret = of_address_to_resource(np, 0, &r[0]); ret = of_address_to_resource(np, 0, &r[0]);
if (ret) if (ret)
goto gfar_err; goto err;
r[1].start = np->intrs[0].line; r[1].start = np->intrs[0].line;
r[1].end = np->intrs[0].line; r[1].end = np->intrs[0].line;
@ -133,11 +161,13 @@ static int __init gfar_of_init(void)
r[3].flags = IORESOURCE_IRQ; r[3].flags = IORESOURCE_IRQ;
} }
gfar_dev = platform_device_register_simple("fsl-gianfar", i, &r[0], np->n_intrs + 1); gfar_dev =
platform_device_register_simple("fsl-gianfar", i, &r[0],
np->n_intrs + 1);
if (IS_ERR(gfar_dev)) { if (IS_ERR(gfar_dev)) {
ret = PTR_ERR(gfar_dev); ret = PTR_ERR(gfar_dev);
goto gfar_err; goto err;
} }
mac_addr = get_property(np, "address", NULL); mac_addr = get_property(np, "address", NULL);
@ -145,26 +175,26 @@ static int __init gfar_of_init(void)
if (model && !strcasecmp(model, "TSEC")) if (model && !strcasecmp(model, "TSEC"))
gfar_data.device_flags = gfar_data.device_flags =
FSL_GIANFAR_DEV_HAS_GIGABIT | FSL_GIANFAR_DEV_HAS_GIGABIT |
FSL_GIANFAR_DEV_HAS_COALESCE | FSL_GIANFAR_DEV_HAS_COALESCE |
FSL_GIANFAR_DEV_HAS_RMON | FSL_GIANFAR_DEV_HAS_RMON |
FSL_GIANFAR_DEV_HAS_MULTI_INTR; FSL_GIANFAR_DEV_HAS_MULTI_INTR;
if (model && !strcasecmp(model, "eTSEC")) if (model && !strcasecmp(model, "eTSEC"))
gfar_data.device_flags = gfar_data.device_flags =
FSL_GIANFAR_DEV_HAS_GIGABIT | FSL_GIANFAR_DEV_HAS_GIGABIT |
FSL_GIANFAR_DEV_HAS_COALESCE | FSL_GIANFAR_DEV_HAS_COALESCE |
FSL_GIANFAR_DEV_HAS_RMON | FSL_GIANFAR_DEV_HAS_RMON |
FSL_GIANFAR_DEV_HAS_MULTI_INTR | FSL_GIANFAR_DEV_HAS_MULTI_INTR |
FSL_GIANFAR_DEV_HAS_CSUM | FSL_GIANFAR_DEV_HAS_CSUM |
FSL_GIANFAR_DEV_HAS_VLAN | FSL_GIANFAR_DEV_HAS_VLAN |
FSL_GIANFAR_DEV_HAS_EXTENDED_HASH; FSL_GIANFAR_DEV_HAS_EXTENDED_HASH;
ph = (phandle *) get_property(np, "phy-handle", NULL); ph = (phandle *) get_property(np, "phy-handle", NULL);
phy = of_find_node_by_phandle(*ph); phy = of_find_node_by_phandle(*ph);
if (phy == NULL) { if (phy == NULL) {
ret = -ENODEV; ret = -ENODEV;
goto gfar_unreg; goto unreg;
} }
mdio = of_get_parent(phy); mdio = of_get_parent(phy);
@ -174,7 +204,7 @@ static int __init gfar_of_init(void)
if (ret) { if (ret) {
of_node_put(phy); of_node_put(phy);
of_node_put(mdio); of_node_put(mdio);
goto gfar_unreg; goto unreg;
} }
gfar_data.phy_id = *id; gfar_data.phy_id = *id;
@ -183,23 +213,22 @@ static int __init gfar_of_init(void)
of_node_put(phy); of_node_put(phy);
of_node_put(mdio); of_node_put(mdio);
ret = platform_device_add_data(gfar_dev, &gfar_data, sizeof(struct gianfar_platform_data)); ret =
platform_device_add_data(gfar_dev, &gfar_data,
sizeof(struct
gianfar_platform_data));
if (ret) if (ret)
goto gfar_unreg; goto unreg;
} }
return 0; return 0;
mdio_unreg: unreg:
platform_device_unregister(mdio_dev);
mdio_err:
return ret;
gfar_unreg:
platform_device_unregister(gfar_dev); platform_device_unregister(gfar_dev);
gfar_err: err:
return ret; return ret;
} }
arch_initcall(gfar_of_init); arch_initcall(gfar_of_init);
static int __init fsl_i2c_of_init(void) static int __init fsl_i2c_of_init(void)
@ -209,17 +238,19 @@ static int __init fsl_i2c_of_init(void)
struct platform_device *i2c_dev; struct platform_device *i2c_dev;
int ret; int ret;
for (np = NULL, i = 0; (np = of_find_compatible_node(np, "i2c", "fsl-i2c")) != NULL; i++) { for (np = NULL, i = 0;
(np = of_find_compatible_node(np, "i2c", "fsl-i2c")) != NULL;
i++) {
struct resource r[2]; struct resource r[2];
struct fsl_i2c_platform_data i2c_data; struct fsl_i2c_platform_data i2c_data;
unsigned char * flags = NULL; unsigned char *flags = NULL;
memset(&r, 0, sizeof(r)); memset(&r, 0, sizeof(r));
memset(&i2c_data, 0, sizeof(i2c_data)); memset(&i2c_data, 0, sizeof(i2c_data));
ret = of_address_to_resource(np, 0, &r[0]); ret = of_address_to_resource(np, 0, &r[0]);
if (ret) if (ret)
goto i2c_err; goto err;
r[1].start = np->intrs[0].line; r[1].start = np->intrs[0].line;
r[1].end = np->intrs[0].line; r[1].end = np->intrs[0].line;
@ -228,7 +259,7 @@ static int __init fsl_i2c_of_init(void)
i2c_dev = platform_device_register_simple("fsl-i2c", i, r, 2); i2c_dev = platform_device_register_simple("fsl-i2c", i, r, 2);
if (IS_ERR(i2c_dev)) { if (IS_ERR(i2c_dev)) {
ret = PTR_ERR(i2c_dev); ret = PTR_ERR(i2c_dev);
goto i2c_err; goto err;
} }
i2c_data.device_flags = 0; i2c_data.device_flags = 0;
@ -240,18 +271,22 @@ static int __init fsl_i2c_of_init(void)
if (flags) if (flags)
i2c_data.device_flags |= FSL_I2C_DEV_CLOCK_5200; i2c_data.device_flags |= FSL_I2C_DEV_CLOCK_5200;
ret = platform_device_add_data(i2c_dev, &i2c_data, sizeof(struct fsl_i2c_platform_data)); ret =
platform_device_add_data(i2c_dev, &i2c_data,
sizeof(struct
fsl_i2c_platform_data));
if (ret) if (ret)
goto i2c_unreg; goto unreg;
} }
return 0; return 0;
i2c_unreg: unreg:
platform_device_unregister(i2c_dev); platform_device_unregister(i2c_dev);
i2c_err: err:
return ret; return ret;
} }
arch_initcall(fsl_i2c_of_init); arch_initcall(fsl_i2c_of_init);
#ifdef CONFIG_PPC_83xx #ifdef CONFIG_PPC_83xx
@ -267,51 +302,192 @@ static int __init mpc83xx_wdt_init(void)
if (!np) { if (!np) {
ret = -ENODEV; ret = -ENODEV;
goto mpc83xx_wdt_nodev; goto nodev;
} }
soc = of_find_node_by_type(NULL, "soc"); soc = of_find_node_by_type(NULL, "soc");
if (!soc) { if (!soc) {
ret = -ENODEV; ret = -ENODEV;
goto mpc83xx_wdt_nosoc; goto nosoc;
} }
freq = (unsigned int *)get_property(soc, "bus-frequency", NULL); freq = (unsigned int *)get_property(soc, "bus-frequency", NULL);
if (!freq) { if (!freq) {
ret = -ENODEV; ret = -ENODEV;
goto mpc83xx_wdt_err; goto err;
} }
memset(&r, 0, sizeof(r)); memset(&r, 0, sizeof(r));
ret = of_address_to_resource(np, 0, &r); ret = of_address_to_resource(np, 0, &r);
if (ret) if (ret)
goto mpc83xx_wdt_err; goto err;
dev = platform_device_register_simple("mpc83xx_wdt", 0, &r, 1); dev = platform_device_register_simple("mpc83xx_wdt", 0, &r, 1);
if (IS_ERR(dev)) { if (IS_ERR(dev)) {
ret = PTR_ERR(dev); ret = PTR_ERR(dev);
goto mpc83xx_wdt_err; goto err;
} }
ret = platform_device_add_data(dev, freq, sizeof(int)); ret = platform_device_add_data(dev, freq, sizeof(int));
if (ret) if (ret)
goto mpc83xx_wdt_unreg; goto unreg;
of_node_put(soc); of_node_put(soc);
of_node_put(np); of_node_put(np);
return 0; return 0;
mpc83xx_wdt_unreg: unreg:
platform_device_unregister(dev); platform_device_unregister(dev);
mpc83xx_wdt_err: err:
of_node_put(soc); of_node_put(soc);
mpc83xx_wdt_nosoc: nosoc:
of_node_put(np); of_node_put(np);
mpc83xx_wdt_nodev: nodev:
return ret; return ret;
} }
arch_initcall(mpc83xx_wdt_init); arch_initcall(mpc83xx_wdt_init);
#endif #endif
static enum fsl_usb2_phy_modes determine_usb_phy(char * phy_type)
{
if (!phy_type)
return FSL_USB2_PHY_NONE;
if (!strcasecmp(phy_type, "ulpi"))
return FSL_USB2_PHY_ULPI;
if (!strcasecmp(phy_type, "utmi"))
return FSL_USB2_PHY_UTMI;
if (!strcasecmp(phy_type, "utmi_wide"))
return FSL_USB2_PHY_UTMI_WIDE;
if (!strcasecmp(phy_type, "serial"))
return FSL_USB2_PHY_SERIAL;
return FSL_USB2_PHY_NONE;
}
static int __init fsl_usb_of_init(void)
{
struct device_node *np;
unsigned int i;
struct platform_device *usb_dev;
int ret;
for (np = NULL, i = 0;
(np = of_find_compatible_node(np, "usb", "fsl-usb2-mph")) != NULL;
i++) {
struct resource r[2];
struct fsl_usb2_platform_data usb_data;
unsigned char *prop = NULL;
memset(&r, 0, sizeof(r));
memset(&usb_data, 0, sizeof(usb_data));
ret = of_address_to_resource(np, 0, &r[0]);
if (ret)
goto err;
r[1].start = np->intrs[0].line;
r[1].end = np->intrs[0].line;
r[1].flags = IORESOURCE_IRQ;
usb_dev =
platform_device_register_simple("fsl-usb2-mph", i, r, 2);
if (IS_ERR(usb_dev)) {
ret = PTR_ERR(usb_dev);
goto err;
}
usb_dev->dev.coherent_dma_mask = 0xffffffffUL;
usb_dev->dev.dma_mask = &usb_dev->dev.coherent_dma_mask;
usb_data.operating_mode = FSL_USB2_MPH_HOST;
prop = get_property(np, "port0", NULL);
if (prop)
usb_data.port_enables |= FSL_USB2_PORT0_ENABLED;
prop = get_property(np, "port1", NULL);
if (prop)
usb_data.port_enables |= FSL_USB2_PORT1_ENABLED;
prop = get_property(np, "phy_type", NULL);
usb_data.phy_mode = determine_usb_phy(prop);
ret =
platform_device_add_data(usb_dev, &usb_data,
sizeof(struct
fsl_usb2_platform_data));
if (ret)
goto unreg;
}
return 0;
unreg:
platform_device_unregister(usb_dev);
err:
return ret;
}
arch_initcall(fsl_usb_of_init);
static int __init fsl_usb_dr_of_init(void)
{
struct device_node *np;
unsigned int i;
struct platform_device *usb_dev;
int ret;
for (np = NULL, i = 0;
(np = of_find_compatible_node(np, "usb", "fsl-usb2-dr")) != NULL;
i++) {
struct resource r[2];
struct fsl_usb2_platform_data usb_data;
unsigned char *prop = NULL;
memset(&r, 0, sizeof(r));
memset(&usb_data, 0, sizeof(usb_data));
ret = of_address_to_resource(np, 0, &r[0]);
if (ret)
goto err;
r[1].start = np->intrs[0].line;
r[1].end = np->intrs[0].line;
r[1].flags = IORESOURCE_IRQ;
usb_dev =
platform_device_register_simple("fsl-usb2-dr", i, r, 2);
if (IS_ERR(usb_dev)) {
ret = PTR_ERR(usb_dev);
goto err;
}
usb_dev->dev.coherent_dma_mask = 0xffffffffUL;
usb_dev->dev.dma_mask = &usb_dev->dev.coherent_dma_mask;
usb_data.operating_mode = FSL_USB2_DR_HOST;
prop = get_property(np, "phy_type", NULL);
usb_data.phy_mode = determine_usb_phy(prop);
ret =
platform_device_add_data(usb_dev, &usb_data,
sizeof(struct
fsl_usb2_platform_data));
if (ret)
goto unreg;
}
return 0;
unreg:
platform_device_unregister(usb_dev);
err:
return ret;
}
arch_initcall(fsl_usb_dr_of_init);

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/kernel/ipic.h
*
* IPIC private definitions and structure. * IPIC private definitions and structure.
* *
* Maintainer: Kumar Gala <galak@kernel.crashing.org> * Maintainer: Kumar Gala <galak@kernel.crashing.org>

View File

@ -191,6 +191,7 @@ Commands:\n\
di dump instructions\n\ di dump instructions\n\
df dump float values\n\ df dump float values\n\
dd dump double values\n\ dd dump double values\n\
dr dump stream of raw bytes\n\
e print exception information\n\ e print exception information\n\
f flush cache\n\ f flush cache\n\
la lookup symbol+offset of specified address\n\ la lookup symbol+offset of specified address\n\
@ -1938,6 +1939,28 @@ bsesc(void)
return c; return c;
} }
static void xmon_rawdump (unsigned long adrs, long ndump)
{
long n, m, r, nr;
unsigned char temp[16];
for (n = ndump; n > 0;) {
r = n < 16? n: 16;
nr = mread(adrs, temp, r);
adrs += nr;
for (m = 0; m < r; ++m) {
if (m < nr)
printf("%.2x", temp[m]);
else
printf("%s", fault_chars[fault_type]);
}
n -= r;
if (nr < r)
break;
}
printf("\n");
}
#define isxdigit(c) (('0' <= (c) && (c) <= '9') \ #define isxdigit(c) (('0' <= (c) && (c) <= '9') \
|| ('a' <= (c) && (c) <= 'f') \ || ('a' <= (c) && (c) <= 'f') \
|| ('A' <= (c) && (c) <= 'F')) || ('A' <= (c) && (c) <= 'F'))
@ -1960,6 +1983,13 @@ dump(void)
nidump = MAX_DUMP; nidump = MAX_DUMP;
adrs += ppc_inst_dump(adrs, nidump, 1); adrs += ppc_inst_dump(adrs, nidump, 1);
last_cmd = "di\n"; last_cmd = "di\n";
} else if (c == 'r') {
scanhex(&ndump);
if (ndump == 0)
ndump = 64;
xmon_rawdump(adrs, ndump);
adrs += ndump;
last_cmd = "dr\n";
} else { } else {
scanhex(&ndump); scanhex(&ndump);
if (ndump == 0) if (ndump == 0)

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/4xx_io/serial_sicc.c
*
* Driver for IBM STB3xxx SICC serial port * Driver for IBM STB3xxx SICC serial port
* *
* Based on drivers/char/serial_amba.c, by ARM Ltd. * Based on drivers/char/serial_amba.c, by ARM Ltd.
@ -1639,9 +1637,8 @@ static struct SICC_info *siccuart_get(int line)
state->count++; state->count++;
if (state->info) if (state->info)
return state->info; return state->info;
info = kmalloc(sizeof(struct SICC_info), GFP_KERNEL); info = kzalloc(sizeof(struct SICC_info), GFP_KERNEL);
if (info) { if (info) {
memset(info, 0, sizeof(struct SICC_info));
init_waitqueue_head(&info->open_wait); init_waitqueue_head(&info->open_wait);
init_waitqueue_head(&info->close_wait); init_waitqueue_head(&info->close_wait);
init_waitqueue_head(&info->delta_msr_wait); init_waitqueue_head(&info->delta_msr_wait);

View File

@ -73,7 +73,7 @@ cpm_mask_irq(unsigned int irq)
{ {
int cpm_vec = irq - CPM_IRQ_OFFSET; int cpm_vec = irq - CPM_IRQ_OFFSET;
out_be32(&((immap_t *)IMAP_ADDR)->im_cpic.cpic_cimr, in_be32(&((immap_t *)IMAP_ADDR)->im_cpic.cpic_cimr) & ~(1 << cpm_vec)); clrbits32(&((immap_t *)IMAP_ADDR)->im_cpic.cpic_cimr, (1 << cpm_vec));
} }
static void static void
@ -81,7 +81,7 @@ cpm_unmask_irq(unsigned int irq)
{ {
int cpm_vec = irq - CPM_IRQ_OFFSET; int cpm_vec = irq - CPM_IRQ_OFFSET;
out_be32(&((immap_t *)IMAP_ADDR)->im_cpic.cpic_cimr, in_be32(&((immap_t *)IMAP_ADDR)->im_cpic.cpic_cimr) | (1 << cpm_vec)); setbits32(&((immap_t *)IMAP_ADDR)->im_cpic.cpic_cimr, (1 << cpm_vec));
} }
static void static void
@ -198,7 +198,7 @@ cpm_interrupt_init(void)
if (setup_irq(CPM_IRQ_OFFSET + CPMVEC_ERROR, &cpm_error_irqaction)) if (setup_irq(CPM_IRQ_OFFSET + CPMVEC_ERROR, &cpm_error_irqaction))
panic("Could not allocate CPM error IRQ!"); panic("Could not allocate CPM error IRQ!");
out_be32(&((immap_t *)IMAP_ADDR)->im_cpic.cpic_cicr, in_be32(&((immap_t *)IMAP_ADDR)->im_cpic.cpic_cicr) | CICR_IEN); setbits32(&((immap_t *)IMAP_ADDR)->im_cpic.cpic_cicr, CICR_IEN);
} }
/* /*

View File

@ -481,6 +481,53 @@ config WINCEPT
endchoice endchoice
menu "Freescale Ethernet driver platform-specific options"
depends on FS_ENET
config MPC8xx_SECOND_ETH
bool "Second Ethernet channel"
depends on (MPC885ADS || MPC86XADS)
default y
help
This enables support for second Ethernet on MPC885ADS and MPC86xADS boards.
The latter will use SCC1, for 885ADS you can select it below.
choice
prompt "Second Ethernet channel"
depends on MPC8xx_SECOND_ETH
default MPC8xx_SECOND_ETH_FEC2
config MPC8xx_SECOND_ETH_FEC2
bool "FEC2"
depends on MPC885ADS
help
Enable FEC2 to serve as 2-nd Ethernet channel. Note that SMC2
(often 2-nd UART) will not work if this is enabled.
config MPC8xx_SECOND_ETH_SCC1
bool "SCC1"
depends on MPC86XADS
select MPC8xx_SCC_ENET_FIXED
help
Enable SCC1 to serve as 2-nd Ethernet channel. Note that SMC1
(often 1-nd UART) will not work if this is enabled.
config MPC8xx_SECOND_ETH_SCC3
bool "SCC3"
depends on MPC885ADS
help
Enable SCC3 to serve as 2-nd Ethernet channel. Note that SMC1
(often 1-nd UART) will not work if this is enabled.
endchoice
config MPC8xx_SCC_ENET_FIXED
depends on MPC8xx_SECOND_ETH_SCC
default n
bool "Use fixed MII-less mode for SCC Ethernet"
endmenu
choice choice
prompt "Machine Type" prompt "Machine Type"
depends on 6xx || POWER3 depends on 6xx || POWER3

View File

@ -67,7 +67,7 @@ config SERIAL_TEXT_DEBUG
config PPC_OCP config PPC_OCP
bool bool
depends on IBM_OCP || XILINX_OCP depends on IBM_OCP
default y default y
endmenu endmenu

View File

@ -1,5 +1,5 @@
/* /*
* arch/ppc/amiga/amiints.c -- Amiga Linux interrupt handling code * Amiga Linux interrupt handling code
* *
* This file is subject to the terms and conditions of the GNU General Public * This file is subject to the terms and conditions of the GNU General Public
* License. See the file COPYING in the main directory of this archive * License. See the file COPYING in the main directory of this archive

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/amiga/bootinfo.c
*
* Extracted from arch/m68k/kernel/setup.c. * Extracted from arch/m68k/kernel/setup.c.
* Should be properly generalized and put somewhere else. * Should be properly generalized and put somewhere else.
* Jesper * Jesper

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/amiga/cia.c - CIA support
*
* Copyright (C) 1996 Roman Zippel * Copyright (C) 1996 Roman Zippel
* *
* The concept of some functions bases on the original Amiga OS function * The concept of some functions bases on the original Amiga OS function

View File

@ -1,8 +1,6 @@
#define m68k_debug_device debug_device #define m68k_debug_device debug_device
/* /*
* arch/ppc/amiga/config.c
*
* Copyright (C) 1993 Hamish Macdonald * Copyright (C) 1993 Hamish Macdonald
* *
* This file is subject to the terms and conditions of the GNU General Public * This file is subject to the terms and conditions of the GNU General Public

View File

@ -1,6 +1,4 @@
/* /*
* arch/ppc/amiga/ints.c
*
* Linux/m68k general interrupt handling code from arch/m68k/kernel/ints.c * Linux/m68k general interrupt handling code from arch/m68k/kernel/ints.c
* Needed to drive the m68k emulating IRQ hardware on the PowerUp boards. * Needed to drive the m68k emulating IRQ hardware on the PowerUp boards.
*/ */

View File

@ -1,6 +1,3 @@
#
# arch/ppc/boot/Makefile
#
# This file is subject to the terms and conditions of the GNU General Public # This file is subject to the terms and conditions of the GNU General Public
# License. See the file "COPYING" in the main directory of this archive # License. See the file "COPYING" in the main directory of this archive
# for more details. # for more details.

Some files were not shown because too many files have changed in this diff Show More