Kernel/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2025-01-09 14:43:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6

Browse Source 
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6:
  sparc: video drivers: add facility level
  sparc: tcx.c make tcx_init and tcx_exit static
  sparc: ffb.c make ffb_init and ffb_exit static
  sparc: cg14.c make cg14_init and cg15_exit static
  sparc: bw2.c fix bw2_exit
  sparc64: Fix accidental syscall restart on child return from clone/fork/vfork.
  sparc64: Clean up handling of pt_regs trap type encoding.
  sparc: Remove old style signal frame support.
  sparc64: Kill bogus RT_ALIGNEDSZ macro from signal.c
  sparc: sunzilog.c remove unused argument
  sparc: fix drivers/video/tcx.c warning
  sparc64: Kill unused local ISA bus layer.
  input: Rewrite sparcspkr device probing.
  sparc64: Do not ignore 'pmu' device ranges.
  sparc64: Kill ISA_FLOPPY_WORKS code.
  sparc64: Kill CONFIG_SPARC32_COMPAT
  sparc64: Cleanups and corrections for arch/sparc64/Kconfig
  sparc64: Fix wedged irq regression.
This commit is contained in:
Linus Torvalds 2008-04-28 09:45:57 -07:00
commit e945e849e1
32 changed files with 319 additions and 1062 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arch/sparc/kernel/process.c
View File

@ -357,8 +357,6 @@ void flush_thread(void)
{
current_thread_info()->w_saved = 0;
/* No new signal delivery by default */
current->thread.new_signal = 0;
#ifndef CONFIG_SMP
if(last_task_used_math == current) {
#else

260
arch/sparc/kernel/signal.c
View File

@ -1,5 +1,4 @@
/* $Id: signal.c,v 1.110 2002/02/08 03:57:14 davem Exp $
* linux/arch/sparc/kernel/signal.c
/* linux/arch/sparc/kernel/signal.c
*
* Copyright (C) 1991, 1992 Linus Torvalds
* Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
@ -32,37 +31,7 @@ extern void fpsave(unsigned long *fpregs, unsigned long *fsr,
void *fpqueue, unsigned long *fpqdepth);
extern void fpload(unsigned long *fpregs, unsigned long *fsr);
/* Signal frames: the original one (compatible with SunOS):
*
* Set up a signal frame... Make the stack look the way SunOS
* expects it to look which is basically:
*
* ---------------------------------- <-- %sp at signal time
* Struct sigcontext
* Signal address
* Ptr to sigcontext area above
* Signal code
* The signal number itself
* One register window
* ---------------------------------- <-- New %sp
*/
struct signal_sframe {
struct reg_window sig_window;
int sig_num;
int sig_code;
struct sigcontext __user *sig_scptr;
int sig_address;
struct sigcontext sig_context;
unsigned int extramask[_NSIG_WORDS - 1];
};
/*
* And the new one, intended to be used for Linux applications only
* (we have enough in there to work with clone).
* All the interesting bits are in the info field.
*/
struct new_signal_frame {
struct signal_frame {
struct sparc_stackf ss;
__siginfo_t info;
__siginfo_fpu_t __user *fpu_save;
@ -85,8 +54,7 @@ struct rt_signal_frame {
};
/* Align macros */
#define SF_ALIGNEDSZ (((sizeof(struct signal_sframe) + 7) & (~7)))
#define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame) + 7) & (~7)))
#define SF_ALIGNEDSZ (((sizeof(struct signal_frame) + 7) & (~7)))
#define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
static int _sigpause_common(old_sigset_t set)
@ -141,15 +109,20 @@ restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
return err;
}
static inline void do_new_sigreturn (struct pt_regs *regs)
asmlinkage void do_sigreturn(struct pt_regs *regs)
{
struct new_signal_frame __user *sf;
struct signal_frame __user *sf;
unsigned long up_psr, pc, npc;
sigset_t set;
__siginfo_fpu_t __user *fpu_save;
int err;
sf = (struct new_signal_frame __user *) regs->u_regs[UREG_FP];
/* Always make any pending restarted system calls return -EINTR */
current_thread_info()->restart_block.fn = do_no_restart_syscall;
synchronize_user_stack();
sf = (struct signal_frame __user *) regs->u_regs[UREG_FP];
/* 1. Make sure we are not getting garbage from the user */
if (!access_ok(VERIFY_READ, sf, sizeof(*sf)))
@ -198,73 +171,6 @@ segv_and_exit:
force_sig(SIGSEGV, current);
}
asmlinkage void do_sigreturn(struct pt_regs *regs)
{
struct sigcontext __user *scptr;
unsigned long pc, npc, psr;
sigset_t set;
int err;
/* Always make any pending restarted system calls return -EINTR */
current_thread_info()->restart_block.fn = do_no_restart_syscall;
synchronize_user_stack();
if (current->thread.new_signal) {
do_new_sigreturn(regs);
return;
}
scptr = (struct sigcontext __user *) regs->u_regs[UREG_I0];
/* Check sanity of the user arg. */
if (!access_ok(VERIFY_READ, scptr, sizeof(struct sigcontext)) ||
(((unsigned long) scptr) & 3))
goto segv_and_exit;
err = __get_user(pc, &scptr->sigc_pc);
err |= __get_user(npc, &scptr->sigc_npc);
if ((pc | npc) & 3)
goto segv_and_exit;
/* This is pretty much atomic, no amount locking would prevent
* the races which exist anyways.
*/
err |= __get_user(set.sig[0], &scptr->sigc_mask);
/* Note that scptr + 1 points to extramask */
err |= __copy_from_user(&set.sig[1], scptr + 1,
(_NSIG_WORDS - 1) * sizeof(unsigned int));
if (err)
goto segv_and_exit;
sigdelsetmask(&set, ~_BLOCKABLE);
spin_lock_irq(&current->sighand->siglock);
current->blocked = set;
recalc_sigpending();
spin_unlock_irq(&current->sighand->siglock);
regs->pc = pc;
regs->npc = npc;
err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp);
err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0);
err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1);
/* User can only change condition codes in %psr. */
err |= __get_user(psr, &scptr->sigc_psr);
if (err)
goto segv_and_exit;
regs->psr &= ~(PSR_ICC);
regs->psr |= (psr & PSR_ICC);
return;
segv_and_exit:
force_sig(SIGSEGV, current);
}
asmlinkage void do_rt_sigreturn(struct pt_regs *regs)
{
struct rt_signal_frame __user *sf;
@ -351,128 +257,6 @@ static inline void __user *get_sigframe(struct sigaction *sa, struct pt_regs *re
return (void __user *)(sp - framesize);
}
static inline void
setup_frame(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info)
{
struct signal_sframe __user *sframep;
struct sigcontext __user *sc;
int window = 0, err;
unsigned long pc = regs->pc;
unsigned long npc = regs->npc;
struct thread_info *tp = current_thread_info();
void __user *sig_address;
int sig_code;
synchronize_user_stack();
sframep = (struct signal_sframe __user *)
get_sigframe(sa, regs, SF_ALIGNEDSZ);
if (invalid_frame_pointer(sframep, sizeof(*sframep))){
/* Don't change signal code and address, so that
* post mortem debuggers can have a look.
*/
goto sigill_and_return;
}
sc = &sframep->sig_context;
/* We've already made sure frame pointer isn't in kernel space... */
err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK),
&sc->sigc_onstack);
err |= __put_user(oldset->sig[0], &sc->sigc_mask);
err |= __copy_to_user(sframep->extramask, &oldset->sig[1],
(_NSIG_WORDS - 1) * sizeof(unsigned int));
err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp);
err |= __put_user(pc, &sc->sigc_pc);
err |= __put_user(npc, &sc->sigc_npc);
err |= __put_user(regs->psr, &sc->sigc_psr);
err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1);
err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0);
err |= __put_user(tp->w_saved, &sc->sigc_oswins);
if (tp->w_saved)
for (window = 0; window < tp->w_saved; window++) {
put_user((char *)tp->rwbuf_stkptrs[window],
&sc->sigc_spbuf[window]);
err |= __copy_to_user(&sc->sigc_wbuf[window],
&tp->reg_window[window],
sizeof(struct reg_window));
}
else
err |= __copy_to_user(sframep, (char *) regs->u_regs[UREG_FP],
sizeof(struct reg_window));
tp->w_saved = 0; /* So process is allowed to execute. */
err |= __put_user(signr, &sframep->sig_num);
sig_address = NULL;
sig_code = 0;
if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) {
sig_address = info->si_addr;
switch (signr) {
case SIGSEGV:
switch (info->si_code) {
case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break;
default: sig_code = SUBSIG_PROTECTION; break;
}
break;
case SIGILL:
switch (info->si_code) {
case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break;
case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break;
case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP(info->si_trapno); break;
default: sig_code = SUBSIG_STACK; break;
}
break;
case SIGFPE:
switch (info->si_code) {
case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break;
case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break;
case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break;
case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break;
case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break;
case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break;
case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break;
default: sig_code = SUBSIG_FPERROR; break;
}
break;
case SIGBUS:
switch (info->si_code) {
case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break;
case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break;
default: sig_code = SUBSIG_BUSTIMEOUT; break;
}
break;
case SIGEMT:
switch (info->si_code) {
case EMT_TAGOVF: sig_code = SUBSIG_TAG; break;
}
break;
case SIGSYS:
if (info->si_code == (__SI_FAULT|0x100)) {
sig_code = info->si_trapno;
break;
}
default:
sig_address = NULL;
}
}
err |= __put_user((unsigned long)sig_address, &sframep->sig_address);
err |= __put_user(sig_code, &sframep->sig_code);
err |= __put_user(sc, &sframep->sig_scptr);
if (err)
goto sigsegv;
regs->u_regs[UREG_FP] = (unsigned long) sframep;
regs->pc = (unsigned long) sa->sa_handler;
regs->npc = (regs->pc + 4);
return;
sigill_and_return:
do_exit(SIGILL);
sigsegv:
force_sigsegv(signr, current);
}
static inline int
save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
{
@ -508,21 +292,20 @@ save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
return err;
}
static inline void
new_setup_frame(struct k_sigaction *ka, struct pt_regs *regs,
int signo, sigset_t *oldset)
static void setup_frame(struct k_sigaction *ka, struct pt_regs *regs,
int signo, sigset_t *oldset)
{
struct new_signal_frame __user *sf;
struct signal_frame __user *sf;
int sigframe_size, err;
/* 1. Make sure everything is clean */
synchronize_user_stack();
sigframe_size = NF_ALIGNEDSZ;
sigframe_size = SF_ALIGNEDSZ;
if (!used_math())
sigframe_size -= sizeof(__siginfo_fpu_t);
sf = (struct new_signal_frame __user *)
sf = (struct signal_frame __user *)
get_sigframe(&ka->sa, regs, sigframe_size);
if (invalid_frame_pointer(sf, sigframe_size))
@ -586,9 +369,8 @@ sigsegv:
force_sigsegv(signo, current);
}
static inline void
new_setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
int signo, sigset_t *oldset, siginfo_t *info)
static void setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
int signo, sigset_t *oldset, siginfo_t *info)
{
struct rt_signal_frame __user *sf;
int sigframe_size;
@ -674,11 +456,9 @@ handle_signal(unsigned long signr, struct k_sigaction *ka,
siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
{
if (ka->sa.sa_flags & SA_SIGINFO)
new_setup_rt_frame(ka, regs, signr, oldset, info);
else if (current->thread.new_signal)
new_setup_frame(ka, regs, signr, oldset);
setup_rt_frame(ka, regs, signr, oldset, info);
else
setup_frame(&ka->sa, regs, signr, oldset, info);
setup_frame(ka, regs, signr, oldset);
spin_lock_irq(&current->sighand->siglock);
sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);

14
arch/sparc/kernel/sys_sparc.c
View File

@ -1,5 +1,4 @@
/* $Id: sys_sparc.c,v 1.70 2001/04/14 01:12:02 davem Exp $
* linux/arch/sparc/kernel/sys_sparc.c
/* linux/arch/sparc/kernel/sys_sparc.c
*
* This file contains various random system calls that
* have a non-standard calling sequence on the Linux/sparc
@ -395,10 +394,8 @@ sparc_sigaction (int sig, const struct old_sigaction __user *act,
struct k_sigaction new_ka, old_ka;
int ret;
if (sig < 0) {
current->thread.new_signal = 1;
sig = -sig;
}
WARN_ON_ONCE(sig >= 0);
sig = -sig;
if (act) {
unsigned long mask;
@ -446,11 +443,6 @@ sys_rt_sigaction(int sig,
if (sigsetsize != sizeof(sigset_t))
return -EINVAL;
/* All tasks which use RT signals (effectively) use
* new style signals.
*/
current->thread.new_signal = 1;
if (act) {
new_ka.ka_restorer = restorer;
if (copy_from_user(&new_ka.sa, act, sizeof(*act)))

85
arch/sparc64/Kconfig
View File

@ -1,9 +1,5 @@
# $Id: config.in,v 1.158 2002/01/24 22:14:44 davem Exp $
# For a description of the syntax of this configuration file,
# see the Configure script.
#
mainmenu "Linux/UltraSPARC Kernel Configuration"
# sparc64 configuration
mainmenu "Linux Kernel Configuration for 64-bit SPARC"
config SPARC
bool
@ -17,12 +13,6 @@ config SPARC64
default y
select HAVE_IDE
select HAVE_LMB
help
SPARC is a family of RISC microprocessors designed and marketed by
Sun Microsystems, incorporated. This port covers the newer 64-bit
UltraSPARC. The UltraLinux project maintains both the SPARC32 and
SPARC64 ports; its web page is available at
<http://www.ultralinux.org/>.
config GENERIC_TIME
bool
@ -97,7 +87,7 @@ config SPARC64_PAGE_SIZE_8KB
help
This lets you select the page size of the kernel.
8KB and 64KB work quite well, since Sparc ELF sections
8KB and 64KB work quite well, since SPARC ELF sections
provide for up to 64KB alignment.
Therefore, 512KB and 4MB are for expert hackers only.
@ -138,7 +128,7 @@ config HOTPLUG_CPU
bool "Support for hot-pluggable CPUs"
depends on SMP
select HOTPLUG
---help---
help
Say Y here to experiment with turning CPUs off and on. CPUs
can be controlled through /sys/devices/system/cpu/cpu#.
Say N if you want to disable CPU hotplug.
@ -155,23 +145,16 @@ source "kernel/time/Kconfig"
config SMP
bool "Symmetric multi-processing support"
---help---
help
This enables support for systems with more than one CPU. If you have
a system with only one CPU, say N. If you have a system with more than
one CPU, say Y.
If you say N here, the kernel will run on single and multiprocessor
machines, but will use only one CPU of a multiprocessor machine. If
you say Y here, the kernel will run on many, but not all,
singleprocessor machines. On a singleprocessor machine, the kernel
will run faster if you say N here.
People using multiprocessor machines who say Y here should also say
Y to "Enhanced Real Time Clock Support", below. The "Advanced Power
Management" code will be disabled if you say Y here.
See also <file:Documentation/nmi_watchdog.txt> and the SMP-HOWTO
available at <http://www.tldp.org/docs.html#howto>.
you say Y here, the kernel will run on single-processor machines.
On a single-processor machine, the kernel will run faster if you say
N here.
If you don't know what to do here, say N.
@ -284,50 +267,19 @@ source "mm/Kconfig"
config ISA
bool
help
Find out whether you have ISA slots on your motherboard. ISA is the
name of a bus system, i.e. the way the CPU talks to the other stuff
inside your box. Other bus systems are PCI, EISA, MicroChannel
(MCA) or VESA. ISA is an older system, now being displaced by PCI;
newer boards don't support it. If you have ISA, say Y, otherwise N.
config ISAPNP
bool
help
Say Y here if you would like support for ISA Plug and Play devices.
Some information is in <file:Documentation/isapnp.txt>.
To compile this driver as a module, choose M here: the
module will be called isapnp.
If unsure, say Y.
config EISA
bool
---help---
The Extended Industry Standard Architecture (EISA) bus was
developed as an open alternative to the IBM MicroChannel bus.
The EISA bus provided some of the features of the IBM MicroChannel
bus while maintaining backward compatibility with cards made for
the older ISA bus. The EISA bus saw limited use between 1988 and
1995 when it was made obsolete by the PCI bus.
Say Y here if you are building a kernel for an EISA-based machine.
Otherwise, say N.
config MCA
bool
help
MicroChannel Architecture is found in some IBM PS/2 machines and
laptops. It is a bus system similar to PCI or ISA. See
<file:Documentation/mca.txt> (and especially the web page given
there) before attempting to build an MCA bus kernel.
config PCMCIA
tristate
---help---
help
Say Y here if you want to attach PCMCIA- or PC-cards to your Linux
computer. These are credit-card size devices such as network cards,
modems or hard drives often used with laptops computers. There are
@ -369,10 +321,10 @@ config PCI
bool "PCI support"
select ARCH_SUPPORTS_MSI
help
Find out whether you have a PCI motherboard. PCI is the name of a
bus system, i.e. the way the CPU talks to the other stuff inside
your box. Other bus systems are ISA, EISA, MicroChannel (MCA) or
VESA. If you have PCI, say Y, otherwise N.
Find out whether your system includes a PCI bus. PCI is the name of
a bus system, i.e. the way the CPU talks to the other stuff inside
your box. If you say Y here, the kernel will include drivers and
infrastructure code to support PCI bus devices.
config PCI_DOMAINS
def_bool PCI
@ -396,15 +348,8 @@ menu "Executable file formats"
source "fs/Kconfig.binfmt"
config SPARC32_COMPAT
bool "Kernel support for Linux/Sparc 32bit binary compatibility"
help
This allows you to run 32-bit binaries on your Ultra.
Everybody wants this; say Y.
config COMPAT
bool
depends on SPARC32_COMPAT
default y
select COMPAT_BINFMT_ELF
@ -421,8 +366,8 @@ config SCHED_SMT
default y
help
SMT scheduler support improves the CPU scheduler's decision making
when dealing with UltraSPARC cpus at a cost of slightly increased
overhead in some places. If unsure say N here.
when dealing with SPARC cpus at a cost of slightly increased overhead
in some places. If unsure say N here.
config SCHED_MC
bool "Multi-core scheduler support"

23
arch/sparc64/defconfig
View File

@ -1,7 +1,7 @@
#
# Automatically generated make config: don't edit
# Linux kernel version: 2.6.25-numa
# Wed Apr 23 04:49:08 2008
# Linux kernel version: 2.6.25
# Sat Apr 26 03:11:06 2008
#
CONFIG_SPARC=y
CONFIG_SPARC64=y
@ -152,7 +152,9 @@ CONFIG_GENERIC_CALIBRATE_DELAY=y
CONFIG_HUGETLB_PAGE_SIZE_4MB=y
# CONFIG_HUGETLB_PAGE_SIZE_512K is not set
# CONFIG_HUGETLB_PAGE_SIZE_64K is not set
# CONFIG_NUMA is not set
CONFIG_NUMA=y
CONFIG_NODES_SHIFT=4
CONFIG_NODES_SPAN_OTHER_NODES=y
CONFIG_ARCH_POPULATES_NODE_MAP=y
CONFIG_ARCH_SELECT_MEMORY_MODEL=y
CONFIG_ARCH_SPARSEMEM_ENABLE=y
@ -162,12 +164,14 @@ CONFIG_SELECT_MEMORY_MODEL=y
# CONFIG_DISCONTIGMEM_MANUAL is not set
CONFIG_SPARSEMEM_MANUAL=y
CONFIG_SPARSEMEM=y
CONFIG_NEED_MULTIPLE_NODES=y
CONFIG_HAVE_MEMORY_PRESENT=y
# CONFIG_SPARSEMEM_STATIC is not set
CONFIG_SPARSEMEM_EXTREME=y
CONFIG_SPARSEMEM_VMEMMAP_ENABLE=y
CONFIG_SPARSEMEM_VMEMMAP=y
CONFIG_SPLIT_PTLOCK_CPUS=4
CONFIG_MIGRATION=y
CONFIG_RESOURCES_64BIT=y
CONFIG_ZONE_DMA_FLAG=0
CONFIG_NR_QUICK=1
@ -191,7 +195,6 @@ CONFIG_SUN_OPENPROMFS=m
CONFIG_BINFMT_ELF=y
CONFIG_COMPAT_BINFMT_ELF=y
CONFIG_BINFMT_MISC=m
CONFIG_SPARC32_COMPAT=y
CONFIG_COMPAT=y
CONFIG_SYSVIPC_COMPAT=y
CONFIG_SCHED_SMT=y
@ -746,13 +749,7 @@ CONFIG_DEVPORT=y
CONFIG_I2C=y
CONFIG_I2C_BOARDINFO=y
# CONFIG_I2C_CHARDEV is not set
#
# I2C Algorithms
#
CONFIG_I2C_ALGOBIT=y
# CONFIG_I2C_ALGOPCF is not set
# CONFIG_I2C_ALGOPCA is not set
#
# I2C Hardware Bus support
@ -780,6 +777,7 @@ CONFIG_I2C_ALGOBIT=y
# CONFIG_I2C_VIA is not set
# CONFIG_I2C_VIAPRO is not set
# CONFIG_I2C_VOODOO3 is not set
# CONFIG_I2C_PCA_PLATFORM is not set
#
# Miscellaneous I2C Chip support
@ -1026,6 +1024,7 @@ CONFIG_SND_ALI5451=m
# CONFIG_SND_AU8810 is not set
# CONFIG_SND_AU8820 is not set
# CONFIG_SND_AU8830 is not set
# CONFIG_SND_AW2 is not set
# CONFIG_SND_AZT3328 is not set
# CONFIG_SND_BT87X is not set
# CONFIG_SND_CA0106 is not set
@ -1096,10 +1095,6 @@ CONFIG_SND_SUN_CS4231=m
#
# CONFIG_SND_SOC is not set
#
# SoC Audio support for SuperH
#
#
# ALSA SoC audio for Freescale SOCs
#

6
arch/sparc64/kernel/Makefile
View File

@ -15,17 +15,17 @@ obj-y := process.o setup.o cpu.o idprom.o \
visemul.o prom.o of_device.o hvapi.o sstate.o mdesc.o
obj-$(CONFIG_STACKTRACE) += stacktrace.o
obj-$(CONFIG_PCI) += ebus.o isa.o pci_common.o \
obj-$(CONFIG_PCI) += ebus.o pci_common.o \
pci_psycho.o pci_sabre.o pci_schizo.o \
pci_sun4v.o pci_sun4v_asm.o pci_fire.o
obj-$(CONFIG_PCI_MSI) += pci_msi.o
obj-$(CONFIG_SMP) += smp.o trampoline.o hvtramp.o
obj-$(CONFIG_SPARC32_COMPAT) += sys32.o sys_sparc32.o signal32.o
obj-$(CONFIG_COMPAT) += sys32.o sys_sparc32.o signal32.o
obj-$(CONFIG_MODULES) += module.o
obj-$(CONFIG_US3_FREQ) += us3_cpufreq.o
obj-$(CONFIG_US2E_FREQ) += us2e_cpufreq.o
obj-$(CONFIG_KPROBES) += kprobes.o
obj-$(CONFIG_SUN_LDOMS) += ldc.o vio.o viohs.o ds.o
obj-$(CONFIG_AUDIT) += audit.o
obj-$(CONFIG_AUDIT)$(CONFIG_SPARC32_COMPAT) += compat_audit.o
obj-$(CONFIG_AUDIT)$(CONFIG_COMPAT) += compat_audit.o
obj-y += $(obj-yy)

6
arch/sparc64/kernel/audit.c
View File

@ -30,7 +30,7 @@ static unsigned signal_class[] = {
int audit_classify_arch(int arch)
{
#ifdef CONFIG_SPARC32_COMPAT
#ifdef CONFIG_COMPAT
if (arch == AUDIT_ARCH_SPARC)
return 1;
#endif
@ -39,7 +39,7 @@ int audit_classify_arch(int arch)
int audit_classify_syscall(int abi, unsigned syscall)
{
#ifdef CONFIG_SPARC32_COMPAT
#ifdef CONFIG_COMPAT
extern int sparc32_classify_syscall(unsigned);
if (abi == AUDIT_ARCH_SPARC)
return sparc32_classify_syscall(syscall);
@ -60,7 +60,7 @@ int audit_classify_syscall(int abi, unsigned syscall)
static int __init audit_classes_init(void)
{
#ifdef CONFIG_SPARC32_COMPAT
#ifdef CONFIG_COMPAT
extern __u32 sparc32_dir_class[];
extern __u32 sparc32_write_class[];
extern __u32 sparc32_read_class[];

3
arch/sparc64/kernel/irq.c
View File

@ -1,6 +1,6 @@
/* irq.c: UltraSparc IRQ handling/init/registry.
*
* Copyright (C) 1997, 2007 David S. Miller (davem@davemloft.net)
* Copyright (C) 1997, 2007, 2008 David S. Miller (davem@davemloft.net)
* Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be)
* Copyright (C) 1998 Jakub Jelinek (jj@ultra.linux.cz)
*/
@ -308,6 +308,7 @@ static void sun4u_irq_enable(unsigned int virt_irq)
IMAP_AID_SAFARI | IMAP_NID_SAFARI);
val |= tid | IMAP_VALID;
upa_writeq(val, imap);
upa_writeq(ICLR_IDLE, data->iclr);
}
}

191
arch/sparc64/kernel/isa.c
View File

@ -1,191 +0,0 @@
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/slab.h>
#include <asm/oplib.h>
#include <asm/prom.h>
#include <asm/of_device.h>
#include <asm/isa.h>
struct sparc_isa_bridge *isa_chain;
static void __init fatal_err(const char *reason)
{
prom_printf("ISA: fatal error, %s.\n", reason);
}
static void __init report_dev(struct sparc_isa_device *isa_dev, int child)
{
if (child)
printk(" (%s)", isa_dev->prom_node->name);
else
printk(" [%s", isa_dev->prom_node->name);
}
static void __init isa_dev_get_resource(struct sparc_isa_device *isa_dev)
{
struct of_device *op = of_find_device_by_node(isa_dev->prom_node);
memcpy(&isa_dev->resource, &op->resource[0], sizeof(struct resource));
}
static void __init isa_dev_get_irq(struct sparc_isa_device *isa_dev)
{
struct of_device *op = of_find_device_by_node(isa_dev->prom_node);
if (!op || !op->num_irqs) {
isa_dev->irq = PCI_IRQ_NONE;
} else {
isa_dev->irq = op->irqs[0];
}
}
static void __init isa_fill_children(struct sparc_isa_device *parent_isa_dev)
{
struct device_node *dp = parent_isa_dev->prom_node->child;
if (!dp)
return;
printk(" ->");
while (dp) {
struct sparc_isa_device *isa_dev;
isa_dev = kzalloc(sizeof(*isa_dev), GFP_KERNEL);
if (!isa_dev) {
fatal_err("cannot allocate child isa_dev");
prom_halt();
}
/* Link it in to parent. */
isa_dev->next = parent_isa_dev->child;
parent_isa_dev->child = isa_dev;
isa_dev->bus = parent_isa_dev->bus;
isa_dev->prom_node = dp;
isa_dev_get_resource(isa_dev);
isa_dev_get_irq(isa_dev);
report_dev(isa_dev, 1);
dp = dp->sibling;
}
}
static void __init isa_fill_devices(struct sparc_isa_bridge *isa_br)
{
struct device_node *dp = isa_br->prom_node->child;
while (dp) {
struct sparc_isa_device *isa_dev;
struct dev_archdata *sd;
isa_dev = kzalloc(sizeof(*isa_dev), GFP_KERNEL);
if (!isa_dev) {
printk(KERN_DEBUG "ISA: cannot allocate isa_dev");
return;
}
sd = &isa_dev->ofdev.dev.archdata;
sd->prom_node = dp;
sd->op = &isa_dev->ofdev;
sd->iommu = isa_br->ofdev.dev.parent->archdata.iommu;
sd->stc = isa_br->ofdev.dev.parent->archdata.stc;
sd->numa_node = isa_br->ofdev.dev.parent->archdata.numa_node;
isa_dev->ofdev.node = dp;
isa_dev->ofdev.dev.parent = &isa_br->ofdev.dev;
isa_dev->ofdev.dev.bus = &isa_bus_type;
sprintf(isa_dev->ofdev.dev.bus_id, "isa[%08x]", dp->node);
/* Register with core */
if (of_device_register(&isa_dev->ofdev) != 0) {
printk(KERN_DEBUG "isa: device registration error for %s!\n",
dp->path_component_name);
kfree(isa_dev);
goto next_sibling;
}
/* Link it in. */
isa_dev->next = NULL;
if (isa_br->devices == NULL) {
isa_br->devices = isa_dev;
} else {
struct sparc_isa_device *tmp = isa_br->devices;
while (tmp->next)
tmp = tmp->next;
tmp->next = isa_dev;
}
isa_dev->bus = isa_br;
isa_dev->prom_node = dp;
isa_dev_get_resource(isa_dev);
isa_dev_get_irq(isa_dev);
report_dev(isa_dev, 0);
isa_fill_children(isa_dev);
printk("]");
next_sibling:
dp = dp->sibling;
}
}
void __init isa_init(void)
{
struct pci_dev *pdev;
unsigned short vendor, device;
int index = 0;
vendor = PCI_VENDOR_ID_AL;
device = PCI_DEVICE_ID_AL_M1533;
pdev = NULL;
while ((pdev = pci_get_device(vendor, device, pdev)) != NULL) {
struct sparc_isa_bridge *isa_br;
struct device_node *dp;
dp = pci_device_to_OF_node(pdev);
isa_br = kzalloc(sizeof(*isa_br), GFP_KERNEL);
if (!isa_br) {
printk(KERN_DEBUG "isa: cannot allocate sparc_isa_bridge");
pci_dev_put(pdev);
return;
}
isa_br->ofdev.node = dp;
isa_br->ofdev.dev.parent = &pdev->dev;
isa_br->ofdev.dev.bus = &isa_bus_type;
sprintf(isa_br->ofdev.dev.bus_id, "isa%d", index);
/* Register with core */
if (of_device_register(&isa_br->ofdev) != 0) {
printk(KERN_DEBUG "isa: device registration error for %s!\n",
dp->path_component_name);
kfree(isa_br);
pci_dev_put(pdev);
return;
}
/* Link it in. */
isa_br->next = isa_chain;
isa_chain = isa_br;
isa_br->self = pdev;
isa_br->index = index++;
isa_br->prom_node = dp;
printk("isa%d:", isa_br->index);
isa_fill_devices(isa_br);
printk("\n");
}
}

6
arch/sparc64/kernel/of_device.c
View File

@ -412,12 +412,6 @@ static int __init build_one_resource(struct device_node *parent,
static int __init use_1to1_mapping(struct device_node *pp)
{
/* If this is on the PMU bus, don't try to translate it even
* if a ranges property exists.
*/
if (!strcmp(pp->name, "pmu"))
return 1;
/* If we have a ranges property in the parent, use it. */
if (of_find_property(pp, "ranges", NULL) != NULL)
return 0;

2
arch/sparc64/kernel/pci.c
View File

@ -23,7 +23,6 @@
#include <asm/pgtable.h>
#include <asm/irq.h>
#include <asm/ebus.h>
#include <asm/isa.h>
#include <asm/prom.h>
#include <asm/apb.h>
@ -885,7 +884,6 @@ static int __init pcibios_init(void)
pci_scan_each_controller_bus();
isa_init();
ebus_init();
power_init();

12
arch/sparc64/kernel/process.c
View File

@ -1,5 +1,4 @@
/* $Id: process.c,v 1.131 2002/02/09 19:49:30 davem Exp $
* arch/sparc64/kernel/process.c
/* arch/sparc64/kernel/process.c
*
* Copyright (C) 1995, 1996 David S. Miller (davem@caip.rutgers.edu)
* Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
@ -368,9 +367,6 @@ void flush_thread(void)
if (get_thread_current_ds() != ASI_AIUS)
set_fs(USER_DS);
/* Init new signal delivery disposition. */
clear_thread_flag(TIF_NEWSIGNALS);
}
/* It's a bit more tricky when 64-bit tasks are involved... */
@ -595,6 +591,12 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
if (clone_flags & CLONE_SETTLS)
t->kregs->u_regs[UREG_G7] = regs->u_regs[UREG_I3];
/* We do not want to accidently trigger system call restart
* handling in the new thread. Therefore, clear out the trap
* type, which will make pt_regs_regs_is_syscall() return false.
*/
pt_regs_clear_trap_type(t->kregs);
return 0;
}

16
arch/sparc64/kernel/signal.c
View File

@ -8,7 +8,7 @@
* Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
*/
#ifdef CONFIG_SPARC32_COMPAT
#ifdef CONFIG_COMPAT
#include <linux/compat.h> /* for compat_old_sigset_t */
#endif
#include <linux/sched.h>
@ -236,9 +236,6 @@ struct rt_signal_frame {
__siginfo_fpu_t fpu_state;
};
/* Align macros */
#define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
static long _sigpause_common(old_sigset_t set)
{
set &= _BLOCKABLE;
@ -400,7 +397,7 @@ setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
synchronize_user_stack();
save_and_clear_fpu();
sigframe_size = RT_ALIGNEDSZ;
sigframe_size = sizeof(struct rt_signal_frame);
if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
sigframe_size -= sizeof(__siginfo_fpu_t);
@ -516,11 +513,10 @@ static void do_signal(struct pt_regs *regs, unsigned long orig_i0)
struct k_sigaction ka;
sigset_t *oldset;
siginfo_t info;
int signr, tt;
int signr;
tt = regs->magic & 0x1ff;
if (tt == 0x110 || tt == 0x111 || tt == 0x16d) {
regs->magic &= ~0x1ff;
if (pt_regs_is_syscall(regs)) {
pt_regs_clear_trap_type(regs);
cookie.restart_syscall = 1;
} else
cookie.restart_syscall = 0;
@ -531,7 +527,7 @@ static void do_signal(struct pt_regs *regs, unsigned long orig_i0)
else
oldset = &current->blocked;
#ifdef CONFIG_SPARC32_COMPAT
#ifdef CONFIG_COMPAT
if (test_thread_flag(TIF_32BIT)) {
extern void do_signal32(sigset_t *, struct pt_regs *,
struct signal_deliver_cookie *);

272
arch/sparc64/kernel/signal32.c
View File

@ -1,5 +1,4 @@
/* $Id: signal32.c,v 1.74 2002/02/09 19:49:30 davem Exp $
* arch/sparc64/kernel/signal32.c
/* arch/sparc64/kernel/signal32.c
*
* Copyright (C) 1991, 1992 Linus Torvalds
* Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
@ -31,30 +30,6 @@
#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
/* Signal frames: the original one (compatible with SunOS):
*
* Set up a signal frame... Make the stack look the way SunOS
* expects it to look which is basically:
*
* ---------------------------------- <-- %sp at signal time
* Struct sigcontext
* Signal address
* Ptr to sigcontext area above
* Signal code
* The signal number itself
* One register window
* ---------------------------------- <-- New %sp
*/
struct signal_sframe32 {
struct reg_window32 sig_window;
int sig_num;
int sig_code;
/* struct sigcontext32 * */ u32 sig_scptr;
int sig_address;
struct sigcontext32 sig_context;
unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
};
/* This magic should be in g_upper[0] for all upper parts
* to be valid.
*/
@ -65,12 +40,7 @@ typedef struct {
unsigned int asi;
} siginfo_extra_v8plus_t;
/*
* And the new one, intended to be used for Linux applications only
* (we have enough in there to work with clone).
* All the interesting bits are in the info field.
*/
struct new_signal_frame32 {
struct signal_frame32 {
struct sparc_stackf32 ss;
__siginfo32_t info;
/* __siginfo_fpu32_t * */ u32 fpu_save;
@ -149,8 +119,7 @@ struct rt_signal_frame32 {
};
/* Align macros */
#define SF_ALIGNEDSZ (((sizeof(struct signal_sframe32) + 7) & (~7)))
#define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame32) + 7) & (~7)))
#define SF_ALIGNEDSZ (((sizeof(struct signal_frame32) + 7) & (~7)))
#define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame32) + 7) & (~7)))
int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
@ -241,17 +210,22 @@ static int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu
return err;
}
void do_new_sigreturn32(struct pt_regs *regs)
void do_sigreturn32(struct pt_regs *regs)
{
struct new_signal_frame32 __user *sf;
struct signal_frame32 __user *sf;
unsigned int psr;
unsigned pc, npc, fpu_save;
sigset_t set;
unsigned seta[_COMPAT_NSIG_WORDS];
int err, i;
/* Always make any pending restarted system calls return -EINTR */
current_thread_info()->restart_block.fn = do_no_restart_syscall;
synchronize_user_stack();
regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
sf = (struct new_signal_frame32 __user *) regs->u_regs[UREG_FP];
sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
/* 1. Make sure we are not getting garbage from the user */
if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
@ -319,76 +293,6 @@ segv:
force_sig(SIGSEGV, current);
}
asmlinkage void do_sigreturn32(struct pt_regs *regs)
{
struct sigcontext32 __user *scptr;
unsigned int pc, npc, psr;
sigset_t set;
unsigned int seta[_COMPAT_NSIG_WORDS];
int err;
/* Always make any pending restarted system calls return -EINTR */
current_thread_info()->restart_block.fn = do_no_restart_syscall;
synchronize_user_stack();
if (test_thread_flag(TIF_NEWSIGNALS)) {
do_new_sigreturn32(regs);
return;
}
scptr = (struct sigcontext32 __user *)
(regs->u_regs[UREG_I0] & 0x00000000ffffffffUL);
/* Check sanity of the user arg. */
if (!access_ok(VERIFY_READ, scptr, sizeof(struct sigcontext32)) ||
(((unsigned long) scptr) & 3))
goto segv;
err = __get_user(pc, &scptr->sigc_pc);
err |= __get_user(npc, &scptr->sigc_npc);
if ((pc | npc) & 3)
goto segv; /* Nice try. */
err |= __get_user(seta[0], &scptr->sigc_mask);
/* Note that scptr + 1 points to extramask */
err |= copy_from_user(seta+1, scptr + 1,
(_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
if (err)
goto segv;
switch (_NSIG_WORDS) {
case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
}
sigdelsetmask(&set, ~_BLOCKABLE);
spin_lock_irq(&current->sighand->siglock);
current->blocked = set;
recalc_sigpending();
spin_unlock_irq(&current->sighand->siglock);
if (test_thread_flag(TIF_32BIT)) {
pc &= 0xffffffff;
npc &= 0xffffffff;
}
regs->tpc = pc;
regs->tnpc = npc;
err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp);
err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0);
err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1);
/* User can only change condition codes in %tstate. */
err |= __get_user(psr, &scptr->sigc_psr);
if (err)
goto segv;
regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
regs->tstate |= psr_to_tstate_icc(psr);
return;
segv:
force_sig(SIGSEGV, current);
}
asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
{
struct rt_signal_frame32 __user *sf;
@ -504,145 +408,6 @@ static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, uns
return (void __user *)(sp - framesize);
}
static void
setup_frame32(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info)
{
struct signal_sframe32 __user *sframep;
struct sigcontext32 __user *sc;
unsigned int seta[_COMPAT_NSIG_WORDS];
int err = 0;
void __user *sig_address;
int sig_code;
unsigned long pc = regs->tpc;
unsigned long npc = regs->tnpc;
unsigned int psr;
if (test_thread_flag(TIF_32BIT)) {
pc &= 0xffffffff;
npc &= 0xffffffff;
}
synchronize_user_stack();
save_and_clear_fpu();
sframep = (struct signal_sframe32 __user *)
get_sigframe(sa, regs, SF_ALIGNEDSZ);
if (invalid_frame_pointer(sframep, sizeof(*sframep))){
/* Don't change signal code and address, so that
* post mortem debuggers can have a look.
*/
do_exit(SIGILL);
}
sc = &sframep->sig_context;
/* We've already made sure frame pointer isn't in kernel space... */
err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK),
&sc->sigc_onstack);
switch (_NSIG_WORDS) {
case 4: seta[7] = (oldset->sig[3] >> 32);
seta[6] = oldset->sig[3];
case 3: seta[5] = (oldset->sig[2] >> 32);
seta[4] = oldset->sig[2];
case 2: seta[3] = (oldset->sig[1] >> 32);
seta[2] = oldset->sig[1];
case 1: seta[1] = (oldset->sig[0] >> 32);
seta[0] = oldset->sig[0];
}
err |= __put_user(seta[0], &sc->sigc_mask);
err |= __copy_to_user(sframep->extramask, seta + 1,
(_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp);
err |= __put_user(pc, &sc->sigc_pc);
err |= __put_user(npc, &sc->sigc_npc);
psr = tstate_to_psr(regs->tstate);
if (current_thread_info()->fpsaved[0] & FPRS_FEF)
psr |= PSR_EF;
err |= __put_user(psr, &sc->sigc_psr);
err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1);
err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0);
err |= __put_user(get_thread_wsaved(), &sc->sigc_oswins);
err |= copy_in_user((u32 __user *)sframep,
(u32 __user *)(regs->u_regs[UREG_FP]),
sizeof(struct reg_window32));
set_thread_wsaved(0); /* So process is allowed to execute. */
err |= __put_user(signr, &sframep->sig_num);
sig_address = NULL;
sig_code = 0;
if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) {
sig_address = info->si_addr;
switch (signr) {
case SIGSEGV:
switch (info->si_code) {
case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break;
default: sig_code = SUBSIG_PROTECTION; break;
}
break;
case SIGILL:
switch (info->si_code) {
case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break;
case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break;
case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP(info->si_trapno); break;
default: sig_code = SUBSIG_STACK; break;
}
break;
case SIGFPE:
switch (info->si_code) {
case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break;
case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break;
case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break;
case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break;
case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break;
case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break;
case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break;
default: sig_code = SUBSIG_FPERROR; break;
}
break;
case SIGBUS:
switch (info->si_code) {
case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break;
case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break;
default: sig_code = SUBSIG_BUSTIMEOUT; break;
}
break;
case SIGEMT:
switch (info->si_code) {
case EMT_TAGOVF: sig_code = SUBSIG_TAG; break;
}
break;
case SIGSYS:
if (info->si_code == (__SI_FAULT|0x100)) {
/* See sys_sunos32.c */
sig_code = info->si_trapno;
break;
}
default:
sig_address = NULL;
}
}
err |= __put_user(ptr_to_compat(sig_address), &sframep->sig_address);
err |= __put_user(sig_code, &sframep->sig_code);
err |= __put_user(ptr_to_compat(sc), &sframep->sig_scptr);
if (err)
goto sigsegv;
regs->u_regs[UREG_FP] = (unsigned long) sframep;
regs->tpc = (unsigned long) sa->sa_handler;
regs->tnpc = (regs->tpc + 4);
if (test_thread_flag(TIF_32BIT)) {
regs->tpc &= 0xffffffff;
regs->tnpc &= 0xffffffff;
}
return;
sigsegv:
force_sigsegv(signr, current);
}
static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
{
unsigned long *fpregs = current_thread_info()->fpregs;
@ -663,10 +428,10 @@ static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
return err;
}
static void new_setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
int signo, sigset_t *oldset)
static void setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
int signo, sigset_t *oldset)
{
struct new_signal_frame32 __user *sf;
struct signal_frame32 __user *sf;
int sigframe_size;
u32 psr;
int i, err;
@ -676,11 +441,11 @@ static void new_setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
synchronize_user_stack();
save_and_clear_fpu();
sigframe_size = NF_ALIGNEDSZ;
sigframe_size = SF_ALIGNEDSZ;
if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
sigframe_size -= sizeof(__siginfo_fpu_t);
sf = (struct new_signal_frame32 __user *)
sf = (struct signal_frame32 __user *)
get_sigframe(&ka->sa, regs, sigframe_size);
if (invalid_frame_pointer(sf, sigframe_size))
@ -944,10 +709,9 @@ static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
{
if (ka->sa.sa_flags & SA_SIGINFO)
setup_rt_frame32(ka, regs, signr, oldset, info);
else if (test_thread_flag(TIF_NEWSIGNALS))
new_setup_frame32(ka, regs, signr, oldset);
else
setup_frame32(&ka->sa, regs, signr, oldset, info);
setup_frame32(ka, regs, signr, oldset);
spin_lock_irq(&current->sighand->siglock);
sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
if (!(ka->sa.sa_flags & SA_NOMASK))

2
arch/sparc64/kernel/sparc64_ksyms.c
View File

@ -49,7 +49,6 @@
#endif
#ifdef CONFIG_PCI
#include <asm/ebus.h>
#include <asm/isa.h>
#endif
#include <asm/ns87303.h>
#include <asm/timer.h>
@ -187,7 +186,6 @@ EXPORT_SYMBOL(insw);
EXPORT_SYMBOL(insl);
#ifdef CONFIG_PCI
EXPORT_SYMBOL(ebus_chain);
EXPORT_SYMBOL(isa_chain);
EXPORT_SYMBOL(pci_alloc_consistent);
EXPORT_SYMBOL(pci_free_consistent);
EXPORT_SYMBOL(pci_map_single);

11
arch/sparc64/kernel/sys_sparc32.c
View File

@ -554,10 +554,8 @@ asmlinkage long compat_sys_sigaction(int sig, struct old_sigaction32 __user *act
struct k_sigaction new_ka, old_ka;
int ret;
if (sig < 0) {
set_thread_flag(TIF_NEWSIGNALS);
sig = -sig;
}
WARN_ON_ONCE(sig >= 0);
sig = -sig;
if (act) {
compat_old_sigset_t mask;
@ -601,11 +599,6 @@ asmlinkage long compat_sys_rt_sigaction(int sig,
if (sigsetsize != sizeof(compat_sigset_t))
return -EINVAL;
/* All tasks which use RT signals (effectively) use
* new style signals.
*/
set_thread_flag(TIF_NEWSIGNALS);
if (act) {
u32 u_handler, u_restorer;

264
drivers/input/misc/sparcspkr.c
View File

@ -2,33 +2,69 @@
* Driver for PC-speaker like devices found on various Sparc systems.
*
* Copyright (c) 2002 Vojtech Pavlik
* Copyright (c) 2002, 2006 David S. Miller (davem@davemloft.net)
* Copyright (c) 2002, 2006, 2008 David S. Miller (davem@davemloft.net)
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/platform_device.h>
#include <linux/of_device.h>
#include <asm/io.h>
#include <asm/ebus.h>
#include <asm/isa.h>
MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
MODULE_DESCRIPTION("Sparc Speaker beeper driver");
MODULE_LICENSE("GPL");
struct grover_beep_info {
void __iomem *freq_regs;
void __iomem *enable_reg;
};
struct bbc_beep_info {
u32 clock_freq;
void __iomem *regs;
};
struct sparcspkr_state {
const char *name;
unsigned long iobase;
int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
spinlock_t lock;
struct input_dev *input_dev;
union {
struct grover_beep_info grover;
struct bbc_beep_info bbc;
} u;
};
static int ebus_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
static u32 bbc_count_to_reg(struct bbc_beep_info *info, unsigned int count)
{
u32 val, clock_freq = info->clock_freq;
int i;
if (!count)
return 0;
if (count <= clock_freq >> 20)
return 1 << 18;
if (count >= clock_freq >> 12)
return 1 << 10;
val = 1 << 18;
for (i = 19; i >= 11; i--) {
val >>= 1;
if (count <= clock_freq >> i)
break;
}
return val;
}
static int bbc_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
struct sparcspkr_state *state = dev_get_drvdata(dev->dev.parent);
struct bbc_beep_info *info = &state->u.bbc;
unsigned int count = 0;
unsigned long flags;
@ -44,24 +80,29 @@ static int ebus_spkr_event(struct input_dev *dev, unsigned int type, unsigned in
if (value > 20 && value < 32767)
count = 1193182 / value;
count = bbc_count_to_reg(info, count);
spin_lock_irqsave(&state->lock, flags);
/* EBUS speaker only has on/off state, the frequency does not
* appear to be programmable.
*/
if (state->iobase & 0x2UL)
outb(!!count, state->iobase);
else
outl(!!count, state->iobase);
if (count) {
outb(0x01, info->regs + 0);
outb(0x00, info->regs + 2);
outb((count >> 16) & 0xff, info->regs + 3);
outb((count >> 8) & 0xff, info->regs + 4);
outb(0x00, info->regs + 5);
} else {
outb(0x00, info->regs + 0);
}
spin_unlock_irqrestore(&state->lock, flags);
return 0;
}
static int isa_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
static int grover_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
struct sparcspkr_state *state = dev_get_drvdata(dev->dev.parent);
struct grover_beep_info *info = &state->u.grover;
unsigned int count = 0;
unsigned long flags;
@ -81,15 +122,15 @@ static int isa_spkr_event(struct input_dev *dev, unsigned int type, unsigned int
if (count) {
/* enable counter 2 */
outb(inb(state->iobase + 0x61) | 3, state->iobase + 0x61);
outb(inb(info->enable_reg) | 3, info->enable_reg);
/* set command for counter 2, 2 byte write */
outb(0xB6, state->iobase + 0x43);
outb(0xB6, info->freq_regs + 1);
/* select desired HZ */
outb(count & 0xff, state->iobase + 0x42);
outb((count >> 8) & 0xff, state->iobase + 0x42);
outb(count & 0xff, info->freq_regs + 0);
outb((count >> 8) & 0xff, info->freq_regs + 0);
} else {
/* disable counter 2 */
outb(inb_p(state->iobase + 0x61) & 0xFC, state->iobase + 0x61);
outb(inb_p(info->enable_reg) & 0xFC, info->enable_reg);
}
spin_unlock_irqrestore(&state->lock, flags);
@ -131,22 +172,6 @@ static int __devinit sparcspkr_probe(struct device *dev)
return 0;
}
static int __devexit sparcspkr_remove(struct of_device *dev)
{
struct sparcspkr_state *state = dev_get_drvdata(&dev->dev);
struct input_dev *input_dev = state->input_dev;
/* turn off the speaker */
state->event(input_dev, EV_SND, SND_BELL, 0);
input_unregister_device(input_dev);
dev_set_drvdata(&dev->dev, NULL);
kfree(state);
return 0;
}
static int sparcspkr_shutdown(struct of_device *dev)
{
struct sparcspkr_state *state = dev_get_drvdata(&dev->dev);
@ -158,96 +183,177 @@ static int sparcspkr_shutdown(struct of_device *dev)
return 0;
}
static int __devinit ebus_beep_probe(struct of_device *dev, const struct of_device_id *match)
static int __devinit bbc_beep_probe(struct of_device *op, const struct of_device_id *match)
{
struct linux_ebus_device *edev = to_ebus_device(&dev->dev);
struct sparcspkr_state *state;
int err;
struct bbc_beep_info *info;
struct device_node *dp;
int err = -ENOMEM;
state = kzalloc(sizeof(*state), GFP_KERNEL);
if (!state)
return -ENOMEM;
goto out_err;
state->name = "Sparc EBUS Speaker";
state->iobase = edev->resource[0].start;
state->event = ebus_spkr_event;
state->name = "Sparc BBC Speaker";
state->event = bbc_spkr_event;
spin_lock_init(&state->lock);
dev_set_drvdata(&dev->dev, state);
dp = of_find_node_by_path("/");
err = -ENODEV;
if (!dp)
goto out_free;
err = sparcspkr_probe(&dev->dev);
if (err) {
dev_set_drvdata(&dev->dev, NULL);
kfree(state);
}
info = &state->u.bbc;
info->clock_freq = of_getintprop_default(dp, "clock-frequency", 0);
if (!info->clock_freq)
goto out_free;
info->regs = of_ioremap(&op->resource[0], 0, 6, "bbc beep");
if (!info->regs)
goto out_free;
dev_set_drvdata(&op->dev, state);
err = sparcspkr_probe(&op->dev);
if (err)
goto out_clear_drvdata;
return 0;
out_clear_drvdata:
dev_set_drvdata(&op->dev, NULL);
of_iounmap(&op->resource[0], info->regs, 6);
out_free:
kfree(state);
out_err:
return err;
}
static int bbc_remove(struct of_device *op)
{
struct sparcspkr_state *state = dev_get_drvdata(&op->dev);
struct input_dev *input_dev = state->input_dev;
struct bbc_beep_info *info = &state->u.bbc;
/* turn off the speaker */
state->event(input_dev, EV_SND, SND_BELL, 0);
input_unregister_device(input_dev);
of_iounmap(&op->resource[0], info->regs, 6);
dev_set_drvdata(&op->dev, NULL);
kfree(state);
return 0;
}
static struct of_device_id ebus_beep_match[] = {
static struct of_device_id bbc_beep_match[] = {
{
.name = "beep",
.compatible = "SUNW,bbc-beep",
},
{},
};
static struct of_platform_driver ebus_beep_driver = {
.name = "beep",
.match_table = ebus_beep_match,
.probe = ebus_beep_probe,
.remove = __devexit_p(sparcspkr_remove),
static struct of_platform_driver bbc_beep_driver = {
.name = "bbcbeep",
.match_table = bbc_beep_match,
.probe = bbc_beep_probe,
.remove = __devexit_p(bbc_remove),
.shutdown = sparcspkr_shutdown,
};
static int __devinit isa_beep_probe(struct of_device *dev, const struct of_device_id *match)
static int __devinit grover_beep_probe(struct of_device *op, const struct of_device_id *match)
{
struct sparc_isa_device *idev = to_isa_device(&dev->dev);
struct sparcspkr_state *state;
int err;
struct grover_beep_info *info;
int err = -ENOMEM;
state = kzalloc(sizeof(*state), GFP_KERNEL);
if (!state)
return -ENOMEM;
goto out_err;
state->name = "Sparc ISA Speaker";
state->iobase = idev->resource.start;
state->event = isa_spkr_event;
state->name = "Sparc Grover Speaker";
state->event = grover_spkr_event;
spin_lock_init(&state->lock);
dev_set_drvdata(&dev->dev, state);
info = &state->u.grover;
info->freq_regs = of_ioremap(&op->resource[2], 0, 2, "grover beep freq");
if (!info->freq_regs)
goto out_free;
err = sparcspkr_probe(&dev->dev);
if (err) {
dev_set_drvdata(&dev->dev, NULL);
kfree(state);
}
info->enable_reg = of_ioremap(&op->resource[3], 0, 1, "grover beep enable");
if (!info->enable_reg)
goto out_unmap_freq_regs;
dev_set_drvdata(&op->dev, state);
err = sparcspkr_probe(&op->dev);
if (err)
goto out_clear_drvdata;
return 0;
out_clear_drvdata:
dev_set_drvdata(&op->dev, NULL);
of_iounmap(&op->resource[3], info->enable_reg, 1);
out_unmap_freq_regs:
of_iounmap(&op->resource[2], info->freq_regs, 2);
out_free:
kfree(state);
out_err:
return err;
}
static int grover_remove(struct of_device *op)
{
struct sparcspkr_state *state = dev_get_drvdata(&op->dev);
struct grover_beep_info *info = &state->u.grover;
struct input_dev *input_dev = state->input_dev;
/* turn off the speaker */
state->event(input_dev, EV_SND, SND_BELL, 0);
input_unregister_device(input_dev);
of_iounmap(&op->resource[3], info->enable_reg, 1);
of_iounmap(&op->resource[2], info->freq_regs, 2);
dev_set_drvdata(&op->dev, NULL);
kfree(state);
return 0;
}
static struct of_device_id isa_beep_match[] = {
static struct of_device_id grover_beep_match[] = {
{
.name = "dma",
.name = "beep",
.compatible = "SUNW,smbus-beep",
},
{},
};
static struct of_platform_driver isa_beep_driver = {
.name = "beep",
.match_table = isa_beep_match,
.probe = isa_beep_probe,
.remove = __devexit_p(sparcspkr_remove),
static struct of_platform_driver grover_beep_driver = {
.name = "groverbeep",
.match_table = grover_beep_match,
.probe = grover_beep_probe,
.remove = __devexit_p(grover_remove),
.shutdown = sparcspkr_shutdown,
};
static int __init sparcspkr_init(void)
{
int err = of_register_driver(&ebus_beep_driver, &ebus_bus_type);
int err = of_register_driver(&bbc_beep_driver,
&of_platform_bus_type);
if (!err) {
err = of_register_driver(&isa_beep_driver, &isa_bus_type);
err = of_register_driver(&grover_beep_driver,
&of_platform_bus_type);
if (err)
of_unregister_driver(&ebus_beep_driver);
of_unregister_driver(&bbc_beep_driver);
}
return err;
@ -255,8 +361,8 @@ static int __init sparcspkr_init(void)
static void __exit sparcspkr_exit(void)
{
of_unregister_driver(&ebus_beep_driver);
of_unregister_driver(&isa_beep_driver);
of_unregister_driver(&bbc_beep_driver);
of_unregister_driver(&grover_beep_driver);
}
module_init(sparcspkr_init);

4
drivers/serial/sunzilog.c
View File

@ -1231,7 +1231,7 @@ static inline struct console *SUNZILOG_CONSOLE(void)
#define SUNZILOG_CONSOLE() (NULL)
#endif
static void __devinit sunzilog_init_kbdms(struct uart_sunzilog_port *up, int channel)
static void __devinit sunzilog_init_kbdms(struct uart_sunzilog_port *up)
{
int baud, brg;
@ -1305,7 +1305,7 @@ static void __devinit sunzilog_init_hw(struct uart_sunzilog_port *up)
up->curregs[R7] = 0x7E; /* SDLC Flag */
up->curregs[R9] = NV;
up->curregs[R7p] = 0x00;
sunzilog_init_kbdms(up, up->port.line);
sunzilog_init_kbdms(up);
/* Only enable interrupts if an ISR handler available */
if (up->flags & SUNZILOG_FLAG_ISR_HANDLER)
up->curregs[R9] |= MIE;

5
drivers/video/bw2.c
View File

@ -339,7 +339,7 @@ static int __devinit bw2_probe(struct of_device *op, const struct of_device_id *
dev_set_drvdata(&op->dev, info);
printk("%s: bwtwo at %lx:%lx\n",
printk(KERN_INFO "%s: bwtwo at %lx:%lx\n",
dp->full_name, par->which_io, par->physbase);
return 0;
@ -399,10 +399,9 @@ static int __init bw2_init(void)
static void __exit bw2_exit(void)
{
return of_unregister_driver(&bw2_driver);
of_unregister_driver(&bw2_driver);
}
module_init(bw2_init);
module_exit(bw2_exit);

6
drivers/video/cg14.c
View File

@ -556,7 +556,7 @@ static int __devinit cg14_probe(struct of_device *op, const struct of_device_id
dev_set_drvdata(&op->dev, info);
printk("%s: cgfourteen at %lx:%lx, %dMB\n",
printk(KERN_INFO "%s: cgfourteen at %lx:%lx, %dMB\n",
dp->full_name,
par->iospace, par->physbase,
par->ramsize >> 20);
@ -605,7 +605,7 @@ static struct of_platform_driver cg14_driver = {
.remove = __devexit_p(cg14_remove),
};
int __init cg14_init(void)
static int __init cg14_init(void)
{
if (fb_get_options("cg14fb", NULL))
return -ENODEV;
@ -613,7 +613,7 @@ int __init cg14_init(void)
return of_register_driver(&cg14_driver, &of_bus_type);
}
void __exit cg14_exit(void)
static void __exit cg14_exit(void)
{
of_unregister_driver(&cg14_driver);
}

2
drivers/video/cg3.c
View File

@ -419,7 +419,7 @@ static int __devinit cg3_probe(struct of_device *op,
dev_set_drvdata(&op->dev, info);
printk("%s: cg3 at %lx:%lx\n",
printk(KERN_INFO "%s: cg3 at %lx:%lx\n",
dp->full_name, par->which_io, par->physbase);
return 0;

2
drivers/video/cg6.c
View File

@ -781,7 +781,7 @@ static int __devinit cg6_probe(struct of_device *op,
dev_set_drvdata(&op->dev, info);
printk("%s: CGsix [%s] at %lx:%lx\n",
printk(KERN_INFO "%s: CGsix [%s] at %lx:%lx\n",
dp->full_name, info->fix.id,
par->which_io, par->physbase);

7
drivers/video/ffb.c
View File

@ -32,7 +32,6 @@
static int ffb_setcolreg(unsigned, unsigned, unsigned, unsigned,
unsigned, struct fb_info *);
static int ffb_blank(int, struct fb_info *);
static void ffb_init_fix(struct fb_info *);
static void ffb_imageblit(struct fb_info *, const struct fb_image *);
static void ffb_fillrect(struct fb_info *, const struct fb_fillrect *);
@ -1001,7 +1000,7 @@ static int __devinit ffb_probe(struct of_device *op,
dev_set_drvdata(&op->dev, info);
printk("%s: %s at %016lx, type %d, "
printk(KERN_INFO "%s: %s at %016lx, type %d, "
"DAC pnum[%x] rev[%d] manuf_rev[%d]\n",
dp->full_name,
((par->flags & FFB_FLAG_AFB) ? "AFB" : "FFB"),
@ -1062,7 +1061,7 @@ static struct of_platform_driver ffb_driver = {
.remove = __devexit_p(ffb_remove),
};
int __init ffb_init(void)
static int __init ffb_init(void)
{
if (fb_get_options("ffb", NULL))
return -ENODEV;
@ -1070,7 +1069,7 @@ int __init ffb_init(void)
return of_register_driver(&ffb_driver, &of_bus_type);
}
void __exit ffb_exit(void)
static void __exit ffb_exit(void)
{
of_unregister_driver(&ffb_driver);
}

2
drivers/video/leo.c
View File

@ -614,7 +614,7 @@ static int __devinit leo_probe(struct of_device *op, const struct of_device_id *
dev_set_drvdata(&op->dev, info);
printk("%s: leo at %lx:%lx\n",
printk(KERN_INFO "%s: leo at %lx:%lx\n",
dp->full_name,
par->which_io, par->physbase);

2
drivers/video/p9100.c
View File

@ -310,7 +310,7 @@ static int __devinit p9100_probe(struct of_device *op, const struct of_device_id
dev_set_drvdata(&op->dev, info);
printk("%s: p9100 at %lx:%lx\n",
printk(KERN_INFO "%s: p9100 at %lx:%lx\n",
dp->full_name,
par->which_io, par->physbase);

10
drivers/video/tcx.c
View File

@ -419,7 +419,7 @@ static int __devinit tcx_init_one(struct of_device *op)
par->mmap_map[6].size = SBUS_MMAP_EMPTY;
}
par->physbase = 0;
par->physbase = op->resource[0].start;
par->which_io = op->resource[0].flags & IORESOURCE_BITS;
for (i = 0; i < TCX_MMAP_ENTRIES; i++) {
@ -470,10 +470,10 @@ static int __devinit tcx_init_one(struct of_device *op)
dev_set_drvdata(&op->dev, info);
printk("%s: TCX at %lx:%lx, %s\n",
printk(KERN_INFO "%s: TCX at %lx:%lx, %s\n",
dp->full_name,
par->which_io,
op->resource[0].start,
par->physbase,
par->lowdepth ? "8-bit only" : "24-bit depth");
return 0;
@ -527,7 +527,7 @@ static struct of_platform_driver tcx_driver = {
.remove = __devexit_p(tcx_remove),
};
int __init tcx_init(void)
static int __init tcx_init(void)
{
if (fb_get_options("tcxfb", NULL))
return -ENODEV;
@ -535,7 +535,7 @@ int __init tcx_init(void)
return of_register_driver(&tcx_driver, &of_bus_type);
}
void __exit tcx_exit(void)
static void __exit tcx_exit(void)
{
of_unregister_driver(&tcx_driver);
}

4
include/asm-sparc/processor.h
View File

@ -1,5 +1,4 @@
/* $Id: processor.h,v 1.83 2001/10/08 09:32:13 davem Exp $
* include/asm-sparc/processor.h
/* include/asm-sparc/processor.h
*
* Copyright (C) 1994 David S. Miller (davem@caip.rutgers.edu)
*/
@ -65,7 +64,6 @@ struct thread_struct {
struct fpq fpqueue[16];
unsigned long flags;
mm_segment_t current_ds;
int new_signal;
};
#define SPARC_FLAG_KTHREAD 0x1 /* task is a kernel thread */

84
include/asm-sparc64/floppy.h
View File

@ -293,7 +293,6 @@ static int sun_fd_eject(int drive)
#ifdef CONFIG_PCI
#include <asm/ebus.h>
#include <asm/isa.h>
#include <asm/ns87303.h>
static struct ebus_dma_info sun_pci_fd_ebus_dma;
@ -558,82 +557,6 @@ static int __init ebus_fdthree_p(struct linux_ebus_device *edev)
}
#endif
#ifdef CONFIG_PCI
#undef ISA_FLOPPY_WORKS
#ifdef ISA_FLOPPY_WORKS
static unsigned long __init isa_floppy_init(void)
{
struct sparc_isa_bridge *isa_br;
struct sparc_isa_device *isa_dev = NULL;
for_each_isa(isa_br) {
for_each_isadev(isa_dev, isa_br) {
if (!strcmp(isa_dev->prom_node->name, "dma")) {
struct sparc_isa_device *child =
isa_dev->child;
while (child) {
if (!strcmp(child->prom_node->name,
"floppy")) {
isa_dev = child;
goto isa_done;
}
child = child->next;
}
}
}
}
isa_done:
if (!isa_dev)
return 0;
/* We could use DMA on devices behind the ISA bridge, but...
*
* There is a slight problem. Normally on x86 kit the x86 processor
* delays I/O port instructions when the ISA bus "dma in progress"
* signal is active. Well, sparc64 systems do not monitor this
* signal thus we would need to block all I/O port accesses in software
* when a dma transfer is active for some device.
*/
sun_fdc = (struct sun_flpy_controller *)isa_dev->resource.start;
FLOPPY_IRQ = isa_dev->irq;
sun_fdops.fd_inb = sun_pci_fd_inb;
sun_fdops.fd_outb = sun_pci_fd_outb;
can_use_virtual_dma = use_virtual_dma = 1;
sun_fdops.fd_enable_dma = sun_fd_enable_dma;
sun_fdops.fd_disable_dma = sun_fd_disable_dma;
sun_fdops.fd_set_dma_mode = sun_fd_set_dma_mode;
sun_fdops.fd_set_dma_addr = sun_fd_set_dma_addr;
sun_fdops.fd_set_dma_count = sun_fd_set_dma_count;
sun_fdops.get_dma_residue = sun_get_dma_residue;
sun_fdops.fd_request_irq = sun_fd_request_irq;
sun_fdops.fd_free_irq = sun_fd_free_irq;
/* Floppy eject is manual. Actually, could determine this
* via presence of 'manual' property in OBP node.
*/
sun_fdops.fd_eject = sun_pci_fd_eject;
fdc_status = (unsigned long) &sun_fdc->status_82077;
allowed_drive_mask = 0;
sun_floppy_types[0] = 0;
sun_floppy_types[1] = 4;
sun_pci_broken_drive = 1;
sun_fdops.fd_outb = sun_pci_fd_broken_outb;
return sun_floppy_types[0];
}
#endif /* ISA_FLOPPY_WORKS */
#endif
static unsigned long __init sun_floppy_init(void)
{
char state[128];
@ -667,13 +590,8 @@ static unsigned long __init sun_floppy_init(void)
}
}
ebus_done:
if (!edev) {
#ifdef ISA_FLOPPY_WORKS
return isa_floppy_init();
#else
if (!edev)
return 0;
#endif
}
state_prop = of_get_property(edev->prom_node, "status", NULL);
if (state_prop && !strncmp(state_prop, "disabled", 8))

47
include/asm-sparc64/isa.h
View File

@ -1,47 +0,0 @@
/* $Id: isa.h,v 1.1 2001/05/11 04:31:55 davem Exp $
* isa.h: Sparc64 layer for PCI to ISA bridge devices.
*
* Copyright (C) 2001 David S. Miller (davem@redhat.com)
*/
#ifndef __SPARC64_ISA_H
#define __SPARC64_ISA_H
#include <asm/oplib.h>
#include <asm/prom.h>
#include <asm/of_device.h>
struct sparc_isa_bridge;
struct sparc_isa_device {
struct of_device ofdev;
struct sparc_isa_device *next;
struct sparc_isa_device *child;
struct sparc_isa_bridge *bus;
struct device_node *prom_node;
struct resource resource;
unsigned int irq;
};
#define to_isa_device(d) container_of(d, struct sparc_isa_device, ofdev.dev)
struct sparc_isa_bridge {
struct of_device ofdev;
struct sparc_isa_bridge *next;
struct sparc_isa_device *devices;
struct pci_dev *self;
int index;
struct device_node *prom_node;
};
#define to_isa_bridge(d) container_of(d, struct sparc_isa_bridge, ofdev.dev)
extern struct sparc_isa_bridge *isa_chain;
extern void isa_init(void);
#define for_each_isa(bus) \
for((bus) = isa_chain; (bus); (bus) = (bus)->next)
#define for_each_isadev(dev, bus) \
for((dev) = (bus)->devices; (dev); (dev) = (dev)->next)
#endif /* !(__SPARC64_ISA_H) */

23
include/asm-sparc64/ptrace.h
View File

@ -1,4 +1,3 @@
/* $Id: ptrace.h,v 1.14 2002/02/09 19:49:32 davem Exp $ */
#ifndef _SPARC64_PTRACE_H
#define _SPARC64_PTRACE_H
@ -8,10 +7,15 @@
* stack during a system call and basically all traps.
*/
/* This magic value must have the low 9 bits clear,
* as that is where we encode the %tt value, see below.
*/
#define PT_REGS_MAGIC 0x57ac6c00
#ifndef __ASSEMBLY__
#include <linux/types.h>
struct pt_regs {
unsigned long u_regs[16]; /* globals and ins */
unsigned long tstate;
@ -33,6 +37,23 @@ struct pt_regs {
unsigned int magic;
};
static inline int pt_regs_trap_type(struct pt_regs *regs)
{
return regs->magic & 0x1ff;
}
static inline int pt_regs_clear_trap_type(struct pt_regs *regs)
{
return regs->magic &= ~0x1ff;
}
static inline bool pt_regs_is_syscall(struct pt_regs *regs)
{
int tt = pt_regs_trap_type(regs);
return (tt == 0x110 || tt == 0x111 || tt == 0x16d);
}
struct pt_regs32 {
unsigned int psr;
unsigned int pc;

6
include/asm-sparc64/thread_info.h
View File

@ -1,5 +1,4 @@
/* $Id: thread_info.h,v 1.1 2002/02/10 00:00:58 davem Exp $
* thread_info.h: sparc64 low-level thread information
/* thread_info.h: sparc64 low-level thread information
*
* Copyright (C) 2002 David S. Miller (davem@redhat.com)
*/
@ -223,7 +222,7 @@ register struct thread_info *current_thread_info_reg asm("g6");
#define TIF_NEED_RESCHED 3 /* rescheduling necessary */
#define TIF_PERFCTR 4 /* performance counters active */
#define TIF_UNALIGNED 5 /* allowed to do unaligned accesses */
#define TIF_NEWSIGNALS 6 /* wants new-style signals */
/* flag bit 6 is available */
#define TIF_32BIT 7 /* 32-bit binary */
/* flag bit 8 is available */
#define TIF_SECCOMP 9 /* secure computing */
@ -242,7 +241,6 @@ register struct thread_info *current_thread_info_reg asm("g6");
#define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED)
#define _TIF_PERFCTR (1<<TIF_PERFCTR)
#define _TIF_UNALIGNED (1<<TIF_UNALIGNED)
#define _TIF_NEWSIGNALS (1<<TIF_NEWSIGNALS)
#define _TIF_32BIT (1<<TIF_32BIT)
#define _TIF_SECCOMP (1<<TIF_SECCOMP)
#define _TIF_SYSCALL_AUDIT (1<<TIF_SYSCALL_AUDIT)

2
init/Kconfig
View File

@ -517,7 +517,7 @@ menuconfig EMBEDDED
config UID16
bool "Enable 16-bit UID system calls" if EMBEDDED
depends on ARM || BLACKFIN || CRIS || FRV || H8300 || X86_32 || M68K || (S390 && !64BIT) || SUPERH || SPARC32 || (SPARC64 && SPARC32_COMPAT) || UML || (X86_64 && IA32_EMULATION)
depends on ARM || BLACKFIN || CRIS || FRV || H8300 || X86_32 || M68K || (S390 && !64BIT) || SUPERH || SPARC32 || (SPARC64 && COMPAT) || UML || (X86_64 && IA32_EMULATION)
default y
help
This enables the legacy 16-bit UID syscall wrappers.