1993-06-12 14:58:17 +00:00
|
|
|
/*-
|
|
|
|
* Copyright (c) 1990 William Jolitz.
|
|
|
|
* Copyright (c) 1991 The Regents of the University of California.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by the University of
|
|
|
|
* California, Berkeley and its contributors.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
ALL:
Removed patch kit headers and rcsid strings, add $Id$.
isa.c:
Removed old #ifdef notyet isa_configure code, since it will never be
used, and I have done 90% of what it attempted to.
Add conflict checking code that searchs back through the devtab's looking
for any device that has already been found that may conflict with what
we are about to probe. Checks are mode for I/O address, memory address,
IRQ, and DRQ. This should stop the screwing up of any device that has
alread been found by other device probes.
Print out messages when we are not going to probe a device due to
a conflict so the user knows WHY something was not found. For example:
aha0 not probed due to irq conflict with ahb0 at 11
Now print out a message when a device is not found so the user knows
that it was probed for, but could not be found. For example:
ed1 not found at 0x320
For devices that have I/O address < 0x100 say that they are on the
motherboard, not on isa! The 0x100 magic number is per ISA spec. It
may seem funny that pc0 and sc0 report as being on the motherboard, but
this is due to the fact that the I/O address used is that of the keyboard
controller which IS on the motherboard. We really need to split the
keyboard probe from the display probe. It is completly legal to build
a pc with out one or the other, or even with out both!
npx.c:
Return -1 from the probe routine if we are using the Emulator so
that the i/o addresses are not printed, this is the same trick used
for 486's.
Do not print the ``Errors reported via Exception 16'', and
``Errors reported via IRQ 13'' messages any more, since these just lead
to more user confusion that anything. It still prints the message
``Error reporting broken, using 387 emulator'' so that the person is
aware that there mother board is ill.
1993-10-13 15:59:30 +00:00
|
|
|
* from: @(#)npx.c 7.2 (Berkeley) 5/12/91
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1993-06-12 14:58:17 +00:00
|
|
|
*/
|
|
|
|
|
2001-07-12 06:32:51 +00:00
|
|
|
#include "opt_cpu.h"
|
1998-01-31 07:23:16 +00:00
|
|
|
#include "opt_debug_npx.h"
|
1996-01-06 23:10:57 +00:00
|
|
|
#include "opt_math_emulate.h"
|
1996-01-04 19:51:50 +00:00
|
|
|
|
1994-08-13 03:50:34 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
1999-04-16 21:22:55 +00:00
|
|
|
#include <sys/bus.h>
|
1995-10-28 13:07:28 +00:00
|
|
|
#include <sys/kernel.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/lock.h>
|
1998-02-12 21:41:10 +00:00
|
|
|
#include <sys/malloc.h>
|
1999-04-16 21:22:55 +00:00
|
|
|
#include <sys/module.h>
|
2001-01-20 02:30:58 +00:00
|
|
|
#include <sys/mutex.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/mutex.h>
|
|
|
|
#include <sys/proc.h>
|
|
|
|
#include <sys/sysctl.h>
|
1999-04-16 21:22:55 +00:00
|
|
|
#include <machine/bus.h>
|
|
|
|
#include <sys/rman.h>
|
1997-01-29 13:46:28 +00:00
|
|
|
#ifdef NPX_DEBUG
|
1994-11-14 14:59:06 +00:00
|
|
|
#include <sys/syslog.h>
|
1997-01-29 13:46:28 +00:00
|
|
|
#endif
|
1994-11-14 14:59:06 +00:00
|
|
|
#include <sys/signalvar.h>
|
2001-05-20 20:04:40 +00:00
|
|
|
#include <sys/user.h>
|
1994-10-23 21:28:03 +00:00
|
|
|
|
1997-11-18 11:32:31 +00:00
|
|
|
#ifndef SMP
|
1997-04-22 06:55:47 +00:00
|
|
|
#include <machine/asmacros.h>
|
1997-11-18 11:32:31 +00:00
|
|
|
#endif
|
1997-10-28 11:43:57 +00:00
|
|
|
#include <machine/cputypes.h>
|
|
|
|
#include <machine/frame.h>
|
1996-06-25 20:31:01 +00:00
|
|
|
#include <machine/md_var.h>
|
1997-05-31 09:27:31 +00:00
|
|
|
#include <machine/pcb.h>
|
1997-10-28 11:43:57 +00:00
|
|
|
#include <machine/psl.h>
|
1997-11-18 11:32:31 +00:00
|
|
|
#ifndef SMP
|
1994-11-14 14:59:06 +00:00
|
|
|
#include <machine/clock.h>
|
1997-11-18 11:32:31 +00:00
|
|
|
#endif
|
1999-04-16 21:22:55 +00:00
|
|
|
#include <machine/resource.h>
|
1994-08-13 03:50:34 +00:00
|
|
|
#include <machine/specialreg.h>
|
1997-10-28 11:43:57 +00:00
|
|
|
#include <machine/segments.h>
|
1994-10-23 21:28:03 +00:00
|
|
|
|
1997-11-18 11:32:31 +00:00
|
|
|
#ifndef SMP
|
1994-08-13 03:50:34 +00:00
|
|
|
#include <i386/isa/icu.h>
|
1997-06-02 08:19:06 +00:00
|
|
|
#include <i386/isa/intr_machdep.h>
|
1994-08-13 03:50:34 +00:00
|
|
|
#include <i386/isa/isa.h>
|
1997-11-18 11:32:31 +00:00
|
|
|
#endif
|
2000-05-04 23:57:32 +00:00
|
|
|
#include <isa/isavar.h>
|
1993-06-12 14:58:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 387 and 287 Numeric Coprocessor Extension (NPX) Driver.
|
|
|
|
*/
|
|
|
|
|
1996-11-11 20:39:03 +00:00
|
|
|
/* Configuration flags. */
|
|
|
|
#define NPX_DISABLE_I586_OPTIMIZED_BCOPY (1 << 0)
|
|
|
|
#define NPX_DISABLE_I586_OPTIMIZED_BZERO (1 << 1)
|
|
|
|
#define NPX_DISABLE_I586_OPTIMIZED_COPYIO (1 << 2)
|
1999-07-25 13:16:09 +00:00
|
|
|
#define NPX_PREFER_EMULATOR (1 << 3)
|
1996-11-11 20:39:03 +00:00
|
|
|
|
1993-06-12 14:58:17 +00:00
|
|
|
#ifdef __GNUC__
|
|
|
|
|
1995-01-03 04:00:06 +00:00
|
|
|
#define fldcw(addr) __asm("fldcw %0" : : "m" (*(addr)))
|
1993-06-12 14:58:17 +00:00
|
|
|
#define fnclex() __asm("fnclex")
|
|
|
|
#define fninit() __asm("fninit")
|
1998-04-15 18:58:09 +00:00
|
|
|
#define fnsave(addr) __asm __volatile("fnsave %0" : "=m" (*(addr)))
|
|
|
|
#define fnstcw(addr) __asm __volatile("fnstcw %0" : "=m" (*(addr)))
|
|
|
|
#define fnstsw(addr) __asm __volatile("fnstsw %0" : "=m" (*(addr)))
|
1995-01-03 04:00:06 +00:00
|
|
|
#define fp_divide_by_0() __asm("fldz; fld1; fdiv %st,%st(1); fnop")
|
|
|
|
#define frstor(addr) __asm("frstor %0" : : "m" (*(addr)))
|
2001-07-12 06:32:51 +00:00
|
|
|
#define fxrstor(addr) __asm("fxrstor %0" : : "m" (*(addr)))
|
|
|
|
#define fxsave(addr) __asm __volatile("fxsave %0" : "=m" (*(addr)))
|
1993-06-12 14:58:17 +00:00
|
|
|
#define start_emulating() __asm("smsw %%ax; orb %0,%%al; lmsw %%ax" \
|
|
|
|
: : "n" (CR0_TS) : "ax")
|
|
|
|
#define stop_emulating() __asm("clts")
|
|
|
|
|
|
|
|
#else /* not __GNUC__ */
|
|
|
|
|
|
|
|
void fldcw __P((caddr_t addr));
|
|
|
|
void fnclex __P((void));
|
|
|
|
void fninit __P((void));
|
|
|
|
void fnsave __P((caddr_t addr));
|
|
|
|
void fnstcw __P((caddr_t addr));
|
|
|
|
void fnstsw __P((caddr_t addr));
|
|
|
|
void fp_divide_by_0 __P((void));
|
|
|
|
void frstor __P((caddr_t addr));
|
2001-07-12 06:32:51 +00:00
|
|
|
void fxsave __P((caddr_t addr));
|
|
|
|
void fxrstor __P((caddr_t addr));
|
1993-06-12 14:58:17 +00:00
|
|
|
void start_emulating __P((void));
|
|
|
|
void stop_emulating __P((void));
|
|
|
|
|
|
|
|
#endif /* __GNUC__ */
|
|
|
|
|
2001-07-12 06:32:51 +00:00
|
|
|
#ifdef CPU_ENABLE_SSE
|
|
|
|
#define GET_FPU_CW(proc) \
|
|
|
|
(cpu_fxsr ? \
|
|
|
|
(proc)->p_addr->u_pcb.pcb_save.sv_xmm.sv_env.en_cw : \
|
|
|
|
(proc)->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_cw)
|
|
|
|
#define GET_FPU_SW(proc) \
|
|
|
|
(cpu_fxsr ? \
|
|
|
|
(proc)->p_addr->u_pcb.pcb_save.sv_xmm.sv_env.en_sw : \
|
|
|
|
(proc)->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_sw)
|
|
|
|
#define MASK_FPU_SW(proc, mask) \
|
|
|
|
(cpu_fxsr ? \
|
|
|
|
(proc)->p_addr->u_pcb.pcb_save.sv_xmm.sv_env.en_sw & (mask) : \
|
|
|
|
(proc)->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_sw & (mask))
|
|
|
|
#define GET_FPU_EXSW_PTR(pcb) \
|
|
|
|
(cpu_fxsr ? \
|
|
|
|
&(pcb)->pcb_save.sv_xmm.sv_ex_sw : \
|
|
|
|
&(pcb)->pcb_save.sv_87.sv_ex_sw)
|
|
|
|
#else /* CPU_ENABLE_SSE */
|
|
|
|
#define GET_FPU_CW(proc) \
|
|
|
|
(proc->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_cw)
|
|
|
|
#define GET_FPU_SW(proc) \
|
|
|
|
(proc->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_sw)
|
|
|
|
#define MASK_FPU_SW(proc, mask) \
|
|
|
|
((proc)->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_sw & (mask))
|
|
|
|
#define GET_FPU_EXSW_PTR(pcb) \
|
|
|
|
(&(pcb)->pcb_save.sv_87.sv_ex_sw)
|
|
|
|
#endif /* CPU_ENABLE_SSE */
|
|
|
|
|
1993-06-12 14:58:17 +00:00
|
|
|
typedef u_char bool_t;
|
|
|
|
|
1999-04-16 21:22:55 +00:00
|
|
|
static int npx_attach __P((device_t dev));
|
1999-08-22 19:52:51 +00:00
|
|
|
static void npx_identify __P((driver_t *driver, device_t parent));
|
2001-05-22 21:20:49 +00:00
|
|
|
#ifndef SMP
|
|
|
|
static void npx_intr __P((void *));
|
|
|
|
#endif
|
1999-04-16 21:22:55 +00:00
|
|
|
static int npx_probe __P((device_t dev));
|
|
|
|
static int npx_probe1 __P((device_t dev));
|
2001-07-16 06:00:23 +00:00
|
|
|
static void fpusave __P((union savefpu *));
|
|
|
|
static void fpurstor __P((union savefpu *));
|
2001-06-15 07:53:20 +00:00
|
|
|
#ifdef I586_CPU_XXX
|
1998-02-12 21:41:10 +00:00
|
|
|
static long timezero __P((const char *funcname,
|
|
|
|
void (*func)(void *buf, size_t len)));
|
1999-03-28 23:28:18 +00:00
|
|
|
#endif /* I586_CPU */
|
1993-06-12 14:58:17 +00:00
|
|
|
|
1995-01-03 04:00:06 +00:00
|
|
|
int hw_float; /* XXX currently just alias for npx_exists */
|
1995-10-28 13:07:28 +00:00
|
|
|
|
|
|
|
SYSCTL_INT(_hw,HW_FLOATINGPT, floatingpoint,
|
|
|
|
CTLFLAG_RD, &hw_float, 0,
|
|
|
|
"Floatingpoint instructions executed in hardware");
|
|
|
|
|
1998-12-07 21:58:50 +00:00
|
|
|
#ifndef SMP
|
|
|
|
static volatile u_int npx_intrs_while_probing;
|
|
|
|
static volatile u_int npx_traps_while_probing;
|
|
|
|
#endif
|
1997-06-22 16:04:22 +00:00
|
|
|
|
1993-06-12 14:58:17 +00:00
|
|
|
static bool_t npx_ex16;
|
|
|
|
static bool_t npx_exists;
|
|
|
|
static bool_t npx_irq13;
|
1999-05-15 17:58:58 +00:00
|
|
|
static int npx_irq; /* irq number */
|
1993-06-12 14:58:17 +00:00
|
|
|
|
1997-07-21 07:57:50 +00:00
|
|
|
#ifndef SMP
|
1993-06-12 14:58:17 +00:00
|
|
|
/*
|
|
|
|
* Special interrupt handlers. Someday intr0-intr15 will be used to count
|
|
|
|
* interrupts. We'll still need a special exception 16 handler. The busy
|
1995-01-03 04:00:06 +00:00
|
|
|
* latch stuff in probeintr() can be moved to npxprobe().
|
1993-06-12 14:58:17 +00:00
|
|
|
*/
|
1994-11-14 14:59:06 +00:00
|
|
|
inthand_t probeintr;
|
1998-04-19 15:39:26 +00:00
|
|
|
__asm(" \n\
|
|
|
|
.text \n\
|
|
|
|
.p2align 2,0x90 \n\
|
1999-05-06 09:44:57 +00:00
|
|
|
.type " __XSTRING(CNAME(probeintr)) ",@function \n\
|
1998-04-19 15:39:26 +00:00
|
|
|
" __XSTRING(CNAME(probeintr)) ": \n\
|
|
|
|
ss \n\
|
|
|
|
incl " __XSTRING(CNAME(npx_intrs_while_probing)) " \n\
|
|
|
|
pushl %eax \n\
|
|
|
|
movb $0x20,%al # EOI (asm in strings loses cpp features) \n\
|
|
|
|
outb %al,$0xa0 # IO_ICU2 \n\
|
|
|
|
outb %al,$0x20 # IO_ICU1 \n\
|
|
|
|
movb $0,%al \n\
|
|
|
|
outb %al,$0xf0 # clear BUSY# latch \n\
|
|
|
|
popl %eax \n\
|
|
|
|
iret \n\
|
1993-06-12 14:58:17 +00:00
|
|
|
");
|
|
|
|
|
1994-11-14 14:59:06 +00:00
|
|
|
inthand_t probetrap;
|
1998-04-19 15:39:26 +00:00
|
|
|
__asm(" \n\
|
|
|
|
.text \n\
|
|
|
|
.p2align 2,0x90 \n\
|
1999-05-06 09:44:57 +00:00
|
|
|
.type " __XSTRING(CNAME(probetrap)) ",@function \n\
|
1998-04-19 15:39:26 +00:00
|
|
|
" __XSTRING(CNAME(probetrap)) ": \n\
|
|
|
|
ss \n\
|
|
|
|
incl " __XSTRING(CNAME(npx_traps_while_probing)) " \n\
|
|
|
|
fnclex \n\
|
|
|
|
iret \n\
|
1993-06-12 14:58:17 +00:00
|
|
|
");
|
1997-07-21 07:57:50 +00:00
|
|
|
#endif /* SMP */
|
|
|
|
|
1999-08-22 19:52:51 +00:00
|
|
|
/*
|
|
|
|
* Identify routine. Create a connection point on our parent for probing.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
npx_identify(driver, parent)
|
|
|
|
driver_t *driver;
|
|
|
|
device_t parent;
|
|
|
|
{
|
|
|
|
device_t child;
|
|
|
|
|
|
|
|
child = BUS_ADD_CHILD(parent, 0, "npx", 0);
|
|
|
|
if (child == NULL)
|
|
|
|
panic("npx_identify");
|
|
|
|
}
|
|
|
|
|
2001-05-22 21:20:49 +00:00
|
|
|
#ifndef SMP
|
|
|
|
/*
|
|
|
|
* Do minimal handling of npx interrupts to convert them to traps.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
npx_intr(dummy)
|
|
|
|
void *dummy;
|
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The BUSY# latch must be cleared in all cases so that the next
|
|
|
|
* unmasked npx exception causes an interrupt.
|
|
|
|
*/
|
|
|
|
outb(0xf0, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* npxproc is normally non-null here. In that case, schedule an
|
|
|
|
* AST to finish the exception handling in the correct context
|
|
|
|
* (this interrupt may occur after the process has entered the
|
|
|
|
* kernel via a syscall or an interrupt). Otherwise, the npx
|
|
|
|
* state of the process that caused this interrupt must have been
|
|
|
|
* pushed to the process' pcb, and clearing of the busy latch
|
|
|
|
* above has finished the (essentially null) handling of this
|
|
|
|
* interrupt. Control will eventually return to the instruction
|
|
|
|
* that caused it and it will repeat. We will eventually (usually
|
|
|
|
* soon) win the race to handle the interrupt properly.
|
|
|
|
*/
|
|
|
|
p = PCPU_GET(npxproc);
|
|
|
|
if (p != NULL) {
|
|
|
|
p->p_addr->u_pcb.pcb_flags |= PCB_NPXTRAP;
|
|
|
|
mtx_lock_spin(&sched_lock);
|
|
|
|
aston(p);
|
|
|
|
mtx_unlock_spin(&sched_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX these "local" variables of npx_probe() are non-local so that
|
|
|
|
* npxprobe1() can abuse them.
|
|
|
|
*/
|
|
|
|
static int npx_intrno;
|
|
|
|
static struct gate_descriptor save_idt_npxintr;
|
|
|
|
#endif /* !SMP */
|
|
|
|
|
1993-06-12 14:58:17 +00:00
|
|
|
/*
|
|
|
|
* Probe routine. Initialize cr0 to give correct behaviour for [f]wait
|
|
|
|
* whether the device exists or not (XXX should be elsewhere). Set flags
|
|
|
|
* to tell npxattach() what to do. Modify device struct if npx doesn't
|
|
|
|
* need to use interrupts. Return 1 if device exists.
|
|
|
|
*/
|
|
|
|
static int
|
1999-04-16 21:22:55 +00:00
|
|
|
npx_probe(dev)
|
|
|
|
device_t dev;
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
1999-05-06 12:47:21 +00:00
|
|
|
#ifdef SMP
|
1997-07-21 07:57:50 +00:00
|
|
|
|
1999-05-15 17:58:58 +00:00
|
|
|
if (resource_int_value("npx", 0, "irq", &npx_irq) != 0)
|
|
|
|
npx_irq = 13;
|
1999-04-16 21:22:55 +00:00
|
|
|
return npx_probe1(dev);
|
1997-07-21 07:57:50 +00:00
|
|
|
|
|
|
|
#else /* SMP */
|
|
|
|
|
1993-06-12 14:58:17 +00:00
|
|
|
int result;
|
2001-03-28 03:06:10 +00:00
|
|
|
critical_t savecrit;
|
1993-06-12 14:58:17 +00:00
|
|
|
u_char save_icu1_mask;
|
|
|
|
u_char save_icu2_mask;
|
|
|
|
struct gate_descriptor save_idt_npxtrap;
|
|
|
|
/*
|
|
|
|
* This routine is now just a wrapper for npxprobe1(), to install
|
|
|
|
* special npx interrupt and trap handlers, to enable npx interrupts
|
|
|
|
* and to disable other interrupts. Someday isa_configure() will
|
|
|
|
* install suitable handlers and run with interrupts enabled so we
|
|
|
|
* won't need to do so much here.
|
|
|
|
*/
|
1999-05-15 17:58:58 +00:00
|
|
|
if (resource_int_value("npx", 0, "irq", &npx_irq) != 0)
|
|
|
|
npx_irq = 13;
|
|
|
|
npx_intrno = NRSVIDT + npx_irq;
|
2001-03-28 03:06:10 +00:00
|
|
|
savecrit = critical_enter();
|
1993-06-12 14:58:17 +00:00
|
|
|
save_icu1_mask = inb(IO_ICU1 + 1);
|
|
|
|
save_icu2_mask = inb(IO_ICU2 + 1);
|
|
|
|
save_idt_npxintr = idt[npx_intrno];
|
|
|
|
save_idt_npxtrap = idt[16];
|
1999-04-16 21:22:55 +00:00
|
|
|
outb(IO_ICU1 + 1, ~IRQ_SLAVE);
|
1999-05-15 17:58:58 +00:00
|
|
|
outb(IO_ICU2 + 1, ~(1 << (npx_irq - 8)));
|
1995-12-19 14:30:50 +00:00
|
|
|
setidt(16, probetrap, SDT_SYS386TGT, SEL_KPL, GSEL(GCODE_SEL, SEL_KPL));
|
|
|
|
setidt(npx_intrno, probeintr, SDT_SYS386IGT, SEL_KPL, GSEL(GCODE_SEL, SEL_KPL));
|
2000-09-07 01:33:02 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX This looks highly bogus, but it appears that npc_probe1
|
|
|
|
* needs interrupts enabled. Does this make any difference
|
|
|
|
* here?
|
|
|
|
*/
|
2001-03-28 03:06:10 +00:00
|
|
|
critical_exit(savecrit);
|
1999-04-16 21:22:55 +00:00
|
|
|
result = npx_probe1(dev);
|
2001-03-28 03:06:10 +00:00
|
|
|
savecrit = critical_enter();
|
1993-06-12 14:58:17 +00:00
|
|
|
outb(IO_ICU1 + 1, save_icu1_mask);
|
|
|
|
outb(IO_ICU2 + 1, save_icu2_mask);
|
|
|
|
idt[npx_intrno] = save_idt_npxintr;
|
|
|
|
idt[16] = save_idt_npxtrap;
|
2001-03-28 03:06:10 +00:00
|
|
|
critical_exit(savecrit);
|
1993-06-12 14:58:17 +00:00
|
|
|
return (result);
|
1997-07-21 07:57:50 +00:00
|
|
|
|
|
|
|
#endif /* SMP */
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
1999-04-16 21:22:55 +00:00
|
|
|
npx_probe1(dev)
|
|
|
|
device_t dev;
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
1998-12-07 21:58:50 +00:00
|
|
|
#ifndef SMP
|
1995-01-03 04:00:06 +00:00
|
|
|
u_short control;
|
|
|
|
u_short status;
|
1998-12-07 21:58:50 +00:00
|
|
|
#endif
|
1995-01-03 04:00:06 +00:00
|
|
|
|
1993-06-12 14:58:17 +00:00
|
|
|
/*
|
|
|
|
* Partially reset the coprocessor, if any. Some BIOS's don't reset
|
|
|
|
* it after a warm boot.
|
|
|
|
*/
|
|
|
|
outb(0xf1, 0); /* full reset on some systems, NOP on others */
|
|
|
|
outb(0xf0, 0); /* clear BUSY# latch */
|
|
|
|
/*
|
|
|
|
* Prepare to trap all ESC (i.e., NPX) instructions and all WAIT
|
|
|
|
* instructions. We must set the CR0_MP bit and use the CR0_TS
|
|
|
|
* bit to control the trap, because setting the CR0_EM bit does
|
|
|
|
* not cause WAIT instructions to trap. It's important to trap
|
|
|
|
* WAIT instructions - otherwise the "wait" variants of no-wait
|
|
|
|
* control instructions would degenerate to the "no-wait" variants
|
|
|
|
* after FP context switches but work correctly otherwise. It's
|
|
|
|
* particularly important to trap WAITs when there is no NPX -
|
|
|
|
* otherwise the "wait" variants would always degenerate.
|
|
|
|
*
|
|
|
|
* Try setting CR0_NE to get correct error reporting on 486DX's.
|
|
|
|
* Setting it should fail or do nothing on lesser processors.
|
|
|
|
*/
|
|
|
|
load_cr0(rcr0() | CR0_MP | CR0_NE);
|
|
|
|
/*
|
|
|
|
* But don't trap while we're probing.
|
|
|
|
*/
|
|
|
|
stop_emulating();
|
|
|
|
/*
|
|
|
|
* Finish resetting the coprocessor, if any. If there is an error
|
|
|
|
* pending, then we may get a bogus IRQ13, but probeintr() will handle
|
|
|
|
* it OK. Bogus halts have never been observed, but we enabled
|
|
|
|
* IRQ13 and cleared the BUSY# latch early to handle them anyway.
|
|
|
|
*/
|
|
|
|
fninit();
|
1997-07-21 07:57:50 +00:00
|
|
|
|
1999-05-06 12:47:21 +00:00
|
|
|
#ifdef SMP
|
1997-07-21 07:57:50 +00:00
|
|
|
/*
|
|
|
|
* Exception 16 MUST work for SMP.
|
|
|
|
*/
|
|
|
|
npx_irq13 = 0;
|
|
|
|
npx_ex16 = hw_float = npx_exists = 1;
|
1999-04-16 21:22:55 +00:00
|
|
|
device_set_desc(dev, "math processor");
|
|
|
|
return (0);
|
1997-07-21 07:57:50 +00:00
|
|
|
|
1999-04-16 21:22:55 +00:00
|
|
|
#else /* !SMP */
|
|
|
|
device_set_desc(dev, "math processor");
|
1997-07-21 07:57:50 +00:00
|
|
|
|
1995-02-23 17:32:38 +00:00
|
|
|
/*
|
|
|
|
* Don't use fwait here because it might hang.
|
|
|
|
* Don't use fnop here because it usually hangs if there is no FPU.
|
|
|
|
*/
|
1995-01-03 04:00:06 +00:00
|
|
|
DELAY(1000); /* wait for any IRQ13 */
|
1993-06-12 14:58:17 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (npx_intrs_while_probing != 0)
|
|
|
|
printf("fninit caused %u bogus npx interrupt(s)\n",
|
|
|
|
npx_intrs_while_probing);
|
|
|
|
if (npx_traps_while_probing != 0)
|
|
|
|
printf("fninit caused %u bogus npx trap(s)\n",
|
|
|
|
npx_traps_while_probing);
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* Check for a status of mostly zero.
|
|
|
|
*/
|
|
|
|
status = 0x5a5a;
|
|
|
|
fnstsw(&status);
|
|
|
|
if ((status & 0xb8ff) == 0) {
|
|
|
|
/*
|
|
|
|
* Good, now check for a proper control word.
|
|
|
|
*/
|
1995-05-30 08:16:23 +00:00
|
|
|
control = 0x5a5a;
|
1993-06-12 14:58:17 +00:00
|
|
|
fnstcw(&control);
|
|
|
|
if ((control & 0x1f3f) == 0x033f) {
|
1994-09-09 23:13:03 +00:00
|
|
|
hw_float = npx_exists = 1;
|
1993-06-12 14:58:17 +00:00
|
|
|
/*
|
|
|
|
* We have an npx, now divide by 0 to see if exception
|
|
|
|
* 16 works.
|
|
|
|
*/
|
|
|
|
control &= ~(1 << 2); /* enable divide by 0 trap */
|
|
|
|
fldcw(&control);
|
|
|
|
npx_traps_while_probing = npx_intrs_while_probing = 0;
|
|
|
|
fp_divide_by_0();
|
|
|
|
if (npx_traps_while_probing != 0) {
|
|
|
|
/*
|
|
|
|
* Good, exception 16 works.
|
|
|
|
*/
|
|
|
|
npx_ex16 = 1;
|
1999-04-16 21:22:55 +00:00
|
|
|
return (0);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
if (npx_intrs_while_probing != 0) {
|
1999-04-16 21:22:55 +00:00
|
|
|
int rid;
|
|
|
|
struct resource *r;
|
|
|
|
void *intr;
|
1993-06-12 14:58:17 +00:00
|
|
|
/*
|
|
|
|
* Bad, we are stuck with IRQ13.
|
|
|
|
*/
|
|
|
|
npx_irq13 = 1;
|
1999-04-16 21:22:55 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We allocate these resources permanently,
|
|
|
|
* so there is no need to keep track of them.
|
|
|
|
*/
|
|
|
|
rid = 0;
|
|
|
|
r = bus_alloc_resource(dev, SYS_RES_IOPORT,
|
|
|
|
&rid, IO_NPX, IO_NPX,
|
|
|
|
IO_NPXSIZE, RF_ACTIVE);
|
|
|
|
if (r == 0)
|
|
|
|
panic("npx: can't get ports");
|
|
|
|
rid = 0;
|
|
|
|
r = bus_alloc_resource(dev, SYS_RES_IRQ,
|
1999-05-15 17:58:58 +00:00
|
|
|
&rid, npx_irq, npx_irq,
|
1999-04-16 21:22:55 +00:00
|
|
|
1, RF_ACTIVE);
|
|
|
|
if (r == 0)
|
|
|
|
panic("npx: can't get IRQ");
|
|
|
|
BUS_SETUP_INTR(device_get_parent(dev),
|
2001-01-20 02:30:58 +00:00
|
|
|
dev, r,
|
2001-05-22 21:20:49 +00:00
|
|
|
INTR_TYPE_MISC | INTR_FAST,
|
1999-05-08 21:59:43 +00:00
|
|
|
npx_intr, 0, &intr);
|
1999-04-16 21:22:55 +00:00
|
|
|
if (intr == 0)
|
|
|
|
panic("npx: can't create intr");
|
|
|
|
|
2001-05-22 21:20:49 +00:00
|
|
|
/*
|
|
|
|
* XXX BUS_SETUP_INTR() has changed
|
|
|
|
* idt[npx_intrno] to point to Xfastintr0
|
|
|
|
* instead of Xfastintr0. Adjust
|
|
|
|
* save_idt_npxintr so that npxprobe()
|
|
|
|
* doesn't undo this.
|
|
|
|
*/
|
|
|
|
save_idt_npxintr = idt[npx_intrno];
|
|
|
|
|
1999-04-16 21:22:55 +00:00
|
|
|
return (0);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Worse, even IRQ13 is broken. Use emulator.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Probe failed, but we want to get to npxattach to initialize the
|
|
|
|
* emulator and say that it has been installed. XXX handle devices
|
|
|
|
* that aren't really devices better.
|
|
|
|
*/
|
1999-04-16 21:22:55 +00:00
|
|
|
return (0);
|
1997-07-21 07:57:50 +00:00
|
|
|
#endif /* SMP */
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attach routine - announce which it is, and wire into system
|
|
|
|
*/
|
|
|
|
int
|
1999-04-16 21:22:55 +00:00
|
|
|
npx_attach(dev)
|
|
|
|
device_t dev;
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
1999-04-16 21:22:55 +00:00
|
|
|
int flags;
|
1999-07-25 13:16:09 +00:00
|
|
|
|
|
|
|
if (resource_int_value("npx", 0, "flags", &flags) != 0)
|
|
|
|
flags = 0;
|
1998-10-22 05:58:45 +00:00
|
|
|
|
1999-09-21 10:51:47 +00:00
|
|
|
if (flags)
|
2000-01-25 21:39:20 +00:00
|
|
|
device_printf(dev, "flags 0x%x ", flags);
|
1999-04-16 21:22:55 +00:00
|
|
|
if (npx_irq13) {
|
2000-01-25 21:39:20 +00:00
|
|
|
device_printf(dev, "using IRQ 13 interface\n");
|
1999-04-16 21:22:55 +00:00
|
|
|
} else {
|
1995-05-30 08:16:23 +00:00
|
|
|
#if defined(MATH_EMULATE) || defined(GPL_MATH_EMULATE)
|
1999-07-25 13:16:09 +00:00
|
|
|
if (npx_ex16) {
|
|
|
|
if (!(flags & NPX_PREFER_EMULATOR))
|
2000-01-25 21:39:20 +00:00
|
|
|
device_printf(dev, "INT 16 interface\n");
|
1999-07-25 13:16:09 +00:00
|
|
|
else {
|
2000-01-25 21:39:20 +00:00
|
|
|
device_printf(dev, "FPU exists, but flags request "
|
1999-07-25 13:16:09 +00:00
|
|
|
"emulator\n");
|
|
|
|
hw_float = npx_exists = 0;
|
|
|
|
}
|
|
|
|
} else if (npx_exists) {
|
2000-01-25 21:39:20 +00:00
|
|
|
device_printf(dev, "error reporting broken; using 387 emulator\n");
|
1996-11-11 20:39:03 +00:00
|
|
|
hw_float = npx_exists = 0;
|
|
|
|
} else
|
2000-01-25 21:39:20 +00:00
|
|
|
device_printf(dev, "387 emulator\n");
|
1995-01-03 04:00:06 +00:00
|
|
|
#else
|
1999-07-25 13:16:09 +00:00
|
|
|
if (npx_ex16) {
|
2000-01-25 21:39:20 +00:00
|
|
|
device_printf(dev, "INT 16 interface\n");
|
1999-07-25 13:16:09 +00:00
|
|
|
if (flags & NPX_PREFER_EMULATOR) {
|
2000-01-25 21:39:20 +00:00
|
|
|
device_printf(dev, "emulator requested, but none compiled "
|
1999-07-25 13:16:09 +00:00
|
|
|
"into kernel, using FPU\n");
|
|
|
|
}
|
|
|
|
} else
|
2000-01-25 21:39:20 +00:00
|
|
|
device_printf(dev, "no 387 emulator in kernel and no FPU!\n");
|
1995-01-03 04:00:06 +00:00
|
|
|
#endif
|
1996-11-11 20:39:03 +00:00
|
|
|
}
|
1993-06-12 14:58:17 +00:00
|
|
|
npxinit(__INITIAL_NPXCW__);
|
1996-11-11 20:39:03 +00:00
|
|
|
|
2001-04-13 17:14:53 +00:00
|
|
|
#ifdef I586_CPU_XXX
|
1999-07-25 13:16:09 +00:00
|
|
|
if (cpu_class == CPUCLASS_586 && npx_ex16 && npx_exists &&
|
1998-02-12 21:41:10 +00:00
|
|
|
timezero("i586_bzero()", i586_bzero) <
|
|
|
|
timezero("bzero()", bzero) * 4 / 5) {
|
1999-04-16 21:22:55 +00:00
|
|
|
if (!(flags & NPX_DISABLE_I586_OPTIMIZED_BCOPY)) {
|
1996-11-11 20:39:03 +00:00
|
|
|
bcopy_vector = i586_bcopy;
|
|
|
|
ovbcopy_vector = i586_bcopy;
|
|
|
|
}
|
1999-04-16 21:22:55 +00:00
|
|
|
if (!(flags & NPX_DISABLE_I586_OPTIMIZED_BZERO))
|
1996-11-11 20:39:03 +00:00
|
|
|
bzero = i586_bzero;
|
1999-04-16 21:22:55 +00:00
|
|
|
if (!(flags & NPX_DISABLE_I586_OPTIMIZED_COPYIO)) {
|
1996-11-11 20:39:03 +00:00
|
|
|
copyin_vector = i586_copyin;
|
|
|
|
copyout_vector = i586_copyout;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1999-04-16 21:22:55 +00:00
|
|
|
return (0); /* XXX unused */
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize floating point unit.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
npxinit(control)
|
1995-01-03 04:00:06 +00:00
|
|
|
u_short control;
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
2001-07-17 13:06:47 +00:00
|
|
|
static union savefpu dummy;
|
2001-05-20 18:05:44 +00:00
|
|
|
critical_t savecrit;
|
1993-06-12 14:58:17 +00:00
|
|
|
|
|
|
|
if (!npx_exists)
|
|
|
|
return;
|
|
|
|
/*
|
|
|
|
* fninit has the same h/w bugs as fnsave. Use the detoxified
|
1995-01-03 04:00:06 +00:00
|
|
|
* fnsave to throw away any junk in the fpu. npxsave() initializes
|
1993-06-12 14:58:17 +00:00
|
|
|
* the fpu and sets npxproc = NULL as important side effects.
|
|
|
|
*/
|
2001-05-20 18:05:44 +00:00
|
|
|
savecrit = critical_enter();
|
1993-06-12 14:58:17 +00:00
|
|
|
npxsave(&dummy);
|
|
|
|
stop_emulating();
|
|
|
|
fldcw(&control);
|
2001-01-10 04:43:51 +00:00
|
|
|
if (PCPU_GET(curpcb) != NULL)
|
2001-07-16 06:00:23 +00:00
|
|
|
fpusave(&PCPU_GET(curpcb)->pcb_save);
|
1993-06-12 14:58:17 +00:00
|
|
|
start_emulating();
|
2001-05-20 18:05:44 +00:00
|
|
|
critical_exit(savecrit);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free coprocessor (if we have it).
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
npxexit(p)
|
|
|
|
struct proc *p;
|
|
|
|
{
|
2001-05-20 18:05:44 +00:00
|
|
|
critical_t savecrit;
|
1993-06-12 14:58:17 +00:00
|
|
|
|
2001-05-20 18:05:44 +00:00
|
|
|
savecrit = critical_enter();
|
2001-01-10 04:43:51 +00:00
|
|
|
if (p == PCPU_GET(npxproc))
|
2001-07-12 06:32:51 +00:00
|
|
|
npxsave(&PCPU_GET(curpcb)->pcb_save);
|
2001-05-20 18:05:44 +00:00
|
|
|
critical_exit(savecrit);
|
1997-01-29 13:46:28 +00:00
|
|
|
#ifdef NPX_DEBUG
|
1994-11-14 14:59:06 +00:00
|
|
|
if (npx_exists) {
|
|
|
|
u_int masked_exceptions;
|
|
|
|
|
2001-07-12 12:21:53 +00:00
|
|
|
masked_exceptions = PCPU_GET(curpcb)->pcb_save.sv_87.sv_env.en_cw
|
|
|
|
& PCPU_GET(curpcb)->pcb_save.sv_87.sv_env.en_sw & 0x7f;
|
1994-11-14 14:59:06 +00:00
|
|
|
/*
|
1997-01-29 13:46:28 +00:00
|
|
|
* Log exceptions that would have trapped with the old
|
|
|
|
* control word (overflow, divide by 0, and invalid operand).
|
1994-11-14 14:59:06 +00:00
|
|
|
*/
|
|
|
|
if (masked_exceptions & 0x0d)
|
|
|
|
log(LOG_ERR,
|
|
|
|
"pid %d (%s) exited with masked floating point exceptions 0x%02x\n",
|
|
|
|
p->p_pid, p->p_comm, masked_exceptions);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
1997-01-29 13:46:28 +00:00
|
|
|
#endif
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
1999-07-25 13:16:09 +00:00
|
|
|
/*
|
|
|
|
* The following mechanism is used to ensure that the FPE_... value
|
|
|
|
* that is passed as a trapcode to the signal handler of the user
|
|
|
|
* process does not have more than one bit set.
|
|
|
|
*
|
|
|
|
* Multiple bits may be set if the user process modifies the control
|
1999-07-26 05:47:31 +00:00
|
|
|
* word while a status word bit is already set. While this is a sign
|
1999-07-25 13:16:09 +00:00
|
|
|
* of bad coding, we have no choise than to narrow them down to one
|
|
|
|
* bit, since we must not send a trapcode that is not exactly one of
|
|
|
|
* the FPE_ macros.
|
|
|
|
*
|
1999-07-26 05:47:31 +00:00
|
|
|
* The mechanism has a static table with 127 entries. Each combination
|
1999-07-25 13:16:09 +00:00
|
|
|
* of the 7 FPU status word exception bits directly translates to a
|
|
|
|
* position in this table, where a single FPE_... value is stored.
|
|
|
|
* This FPE_... value stored there is considered the "most important"
|
1999-07-26 05:47:31 +00:00
|
|
|
* of the exception bits and will be sent as the signal code. The
|
1999-07-25 13:16:09 +00:00
|
|
|
* precedence of the bits is based upon Intel Document "Numerical
|
|
|
|
* Applications", Chapter "Special Computational Situations".
|
|
|
|
*
|
|
|
|
* The macro to choose one of these values does these steps: 1) Throw
|
1999-07-26 05:47:31 +00:00
|
|
|
* away status word bits that cannot be masked. 2) Throw away the bits
|
1999-07-25 13:16:09 +00:00
|
|
|
* currently masked in the control word, assuming the user isn't
|
1999-07-26 05:47:31 +00:00
|
|
|
* interested in them anymore. 3) Reinsert status word bit 7 (stack
|
1999-07-25 13:16:09 +00:00
|
|
|
* fault) if it is set, which cannot be masked but must be presered.
|
|
|
|
* 4) Use the remaining bits to point into the trapcode table.
|
|
|
|
*
|
|
|
|
* The 6 maskable bits in order of their preference, as stated in the
|
|
|
|
* above referenced Intel manual:
|
|
|
|
* 1 Invalid operation (FP_X_INV)
|
|
|
|
* 1a Stack underflow
|
|
|
|
* 1b Stack overflow
|
|
|
|
* 1c Operand of unsupported format
|
|
|
|
* 1d SNaN operand.
|
|
|
|
* 2 QNaN operand (not an exception, irrelavant here)
|
|
|
|
* 3 Any other invalid-operation not mentioned above or zero divide
|
|
|
|
* (FP_X_INV, FP_X_DZ)
|
|
|
|
* 4 Denormal operand (FP_X_DNML)
|
|
|
|
* 5 Numeric over/underflow (FP_X_OFL, FP_X_UFL)
|
1999-07-26 05:47:31 +00:00
|
|
|
* 6 Inexact result (FP_X_IMP)
|
|
|
|
*/
|
1999-07-25 13:16:09 +00:00
|
|
|
static char fpetable[128] = {
|
|
|
|
0,
|
1999-07-26 05:47:31 +00:00
|
|
|
FPE_FLTINV, /* 1 - INV */
|
|
|
|
FPE_FLTUND, /* 2 - DNML */
|
|
|
|
FPE_FLTINV, /* 3 - INV | DNML */
|
|
|
|
FPE_FLTDIV, /* 4 - DZ */
|
|
|
|
FPE_FLTINV, /* 5 - INV | DZ */
|
|
|
|
FPE_FLTDIV, /* 6 - DNML | DZ */
|
|
|
|
FPE_FLTINV, /* 7 - INV | DNML | DZ */
|
|
|
|
FPE_FLTOVF, /* 8 - OFL */
|
|
|
|
FPE_FLTINV, /* 9 - INV | OFL */
|
|
|
|
FPE_FLTUND, /* A - DNML | OFL */
|
|
|
|
FPE_FLTINV, /* B - INV | DNML | OFL */
|
|
|
|
FPE_FLTDIV, /* C - DZ | OFL */
|
|
|
|
FPE_FLTINV, /* D - INV | DZ | OFL */
|
|
|
|
FPE_FLTDIV, /* E - DNML | DZ | OFL */
|
|
|
|
FPE_FLTINV, /* F - INV | DNML | DZ | OFL */
|
|
|
|
FPE_FLTUND, /* 10 - UFL */
|
|
|
|
FPE_FLTINV, /* 11 - INV | UFL */
|
|
|
|
FPE_FLTUND, /* 12 - DNML | UFL */
|
|
|
|
FPE_FLTINV, /* 13 - INV | DNML | UFL */
|
|
|
|
FPE_FLTDIV, /* 14 - DZ | UFL */
|
|
|
|
FPE_FLTINV, /* 15 - INV | DZ | UFL */
|
|
|
|
FPE_FLTDIV, /* 16 - DNML | DZ | UFL */
|
|
|
|
FPE_FLTINV, /* 17 - INV | DNML | DZ | UFL */
|
|
|
|
FPE_FLTOVF, /* 18 - OFL | UFL */
|
|
|
|
FPE_FLTINV, /* 19 - INV | OFL | UFL */
|
|
|
|
FPE_FLTUND, /* 1A - DNML | OFL | UFL */
|
|
|
|
FPE_FLTINV, /* 1B - INV | DNML | OFL | UFL */
|
|
|
|
FPE_FLTDIV, /* 1C - DZ | OFL | UFL */
|
|
|
|
FPE_FLTINV, /* 1D - INV | DZ | OFL | UFL */
|
|
|
|
FPE_FLTDIV, /* 1E - DNML | DZ | OFL | UFL */
|
|
|
|
FPE_FLTINV, /* 1F - INV | DNML | DZ | OFL | UFL */
|
|
|
|
FPE_FLTRES, /* 20 - IMP */
|
|
|
|
FPE_FLTINV, /* 21 - INV | IMP */
|
|
|
|
FPE_FLTUND, /* 22 - DNML | IMP */
|
|
|
|
FPE_FLTINV, /* 23 - INV | DNML | IMP */
|
|
|
|
FPE_FLTDIV, /* 24 - DZ | IMP */
|
|
|
|
FPE_FLTINV, /* 25 - INV | DZ | IMP */
|
|
|
|
FPE_FLTDIV, /* 26 - DNML | DZ | IMP */
|
|
|
|
FPE_FLTINV, /* 27 - INV | DNML | DZ | IMP */
|
|
|
|
FPE_FLTOVF, /* 28 - OFL | IMP */
|
|
|
|
FPE_FLTINV, /* 29 - INV | OFL | IMP */
|
|
|
|
FPE_FLTUND, /* 2A - DNML | OFL | IMP */
|
|
|
|
FPE_FLTINV, /* 2B - INV | DNML | OFL | IMP */
|
|
|
|
FPE_FLTDIV, /* 2C - DZ | OFL | IMP */
|
|
|
|
FPE_FLTINV, /* 2D - INV | DZ | OFL | IMP */
|
|
|
|
FPE_FLTDIV, /* 2E - DNML | DZ | OFL | IMP */
|
|
|
|
FPE_FLTINV, /* 2F - INV | DNML | DZ | OFL | IMP */
|
|
|
|
FPE_FLTUND, /* 30 - UFL | IMP */
|
|
|
|
FPE_FLTINV, /* 31 - INV | UFL | IMP */
|
|
|
|
FPE_FLTUND, /* 32 - DNML | UFL | IMP */
|
|
|
|
FPE_FLTINV, /* 33 - INV | DNML | UFL | IMP */
|
|
|
|
FPE_FLTDIV, /* 34 - DZ | UFL | IMP */
|
|
|
|
FPE_FLTINV, /* 35 - INV | DZ | UFL | IMP */
|
|
|
|
FPE_FLTDIV, /* 36 - DNML | DZ | UFL | IMP */
|
|
|
|
FPE_FLTINV, /* 37 - INV | DNML | DZ | UFL | IMP */
|
|
|
|
FPE_FLTOVF, /* 38 - OFL | UFL | IMP */
|
|
|
|
FPE_FLTINV, /* 39 - INV | OFL | UFL | IMP */
|
|
|
|
FPE_FLTUND, /* 3A - DNML | OFL | UFL | IMP */
|
|
|
|
FPE_FLTINV, /* 3B - INV | DNML | OFL | UFL | IMP */
|
|
|
|
FPE_FLTDIV, /* 3C - DZ | OFL | UFL | IMP */
|
|
|
|
FPE_FLTINV, /* 3D - INV | DZ | OFL | UFL | IMP */
|
|
|
|
FPE_FLTDIV, /* 3E - DNML | DZ | OFL | UFL | IMP */
|
|
|
|
FPE_FLTINV, /* 3F - INV | DNML | DZ | OFL | UFL | IMP */
|
|
|
|
FPE_FLTSUB, /* 40 - STK */
|
|
|
|
FPE_FLTSUB, /* 41 - INV | STK */
|
|
|
|
FPE_FLTUND, /* 42 - DNML | STK */
|
|
|
|
FPE_FLTSUB, /* 43 - INV | DNML | STK */
|
|
|
|
FPE_FLTDIV, /* 44 - DZ | STK */
|
|
|
|
FPE_FLTSUB, /* 45 - INV | DZ | STK */
|
|
|
|
FPE_FLTDIV, /* 46 - DNML | DZ | STK */
|
|
|
|
FPE_FLTSUB, /* 47 - INV | DNML | DZ | STK */
|
|
|
|
FPE_FLTOVF, /* 48 - OFL | STK */
|
|
|
|
FPE_FLTSUB, /* 49 - INV | OFL | STK */
|
|
|
|
FPE_FLTUND, /* 4A - DNML | OFL | STK */
|
|
|
|
FPE_FLTSUB, /* 4B - INV | DNML | OFL | STK */
|
|
|
|
FPE_FLTDIV, /* 4C - DZ | OFL | STK */
|
|
|
|
FPE_FLTSUB, /* 4D - INV | DZ | OFL | STK */
|
|
|
|
FPE_FLTDIV, /* 4E - DNML | DZ | OFL | STK */
|
|
|
|
FPE_FLTSUB, /* 4F - INV | DNML | DZ | OFL | STK */
|
|
|
|
FPE_FLTUND, /* 50 - UFL | STK */
|
|
|
|
FPE_FLTSUB, /* 51 - INV | UFL | STK */
|
|
|
|
FPE_FLTUND, /* 52 - DNML | UFL | STK */
|
|
|
|
FPE_FLTSUB, /* 53 - INV | DNML | UFL | STK */
|
|
|
|
FPE_FLTDIV, /* 54 - DZ | UFL | STK */
|
|
|
|
FPE_FLTSUB, /* 55 - INV | DZ | UFL | STK */
|
|
|
|
FPE_FLTDIV, /* 56 - DNML | DZ | UFL | STK */
|
|
|
|
FPE_FLTSUB, /* 57 - INV | DNML | DZ | UFL | STK */
|
|
|
|
FPE_FLTOVF, /* 58 - OFL | UFL | STK */
|
|
|
|
FPE_FLTSUB, /* 59 - INV | OFL | UFL | STK */
|
|
|
|
FPE_FLTUND, /* 5A - DNML | OFL | UFL | STK */
|
|
|
|
FPE_FLTSUB, /* 5B - INV | DNML | OFL | UFL | STK */
|
|
|
|
FPE_FLTDIV, /* 5C - DZ | OFL | UFL | STK */
|
|
|
|
FPE_FLTSUB, /* 5D - INV | DZ | OFL | UFL | STK */
|
|
|
|
FPE_FLTDIV, /* 5E - DNML | DZ | OFL | UFL | STK */
|
|
|
|
FPE_FLTSUB, /* 5F - INV | DNML | DZ | OFL | UFL | STK */
|
|
|
|
FPE_FLTRES, /* 60 - IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 61 - INV | IMP | STK */
|
|
|
|
FPE_FLTUND, /* 62 - DNML | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 63 - INV | DNML | IMP | STK */
|
|
|
|
FPE_FLTDIV, /* 64 - DZ | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 65 - INV | DZ | IMP | STK */
|
|
|
|
FPE_FLTDIV, /* 66 - DNML | DZ | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 67 - INV | DNML | DZ | IMP | STK */
|
|
|
|
FPE_FLTOVF, /* 68 - OFL | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 69 - INV | OFL | IMP | STK */
|
|
|
|
FPE_FLTUND, /* 6A - DNML | OFL | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 6B - INV | DNML | OFL | IMP | STK */
|
|
|
|
FPE_FLTDIV, /* 6C - DZ | OFL | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 6D - INV | DZ | OFL | IMP | STK */
|
|
|
|
FPE_FLTDIV, /* 6E - DNML | DZ | OFL | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 6F - INV | DNML | DZ | OFL | IMP | STK */
|
|
|
|
FPE_FLTUND, /* 70 - UFL | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 71 - INV | UFL | IMP | STK */
|
|
|
|
FPE_FLTUND, /* 72 - DNML | UFL | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 73 - INV | DNML | UFL | IMP | STK */
|
|
|
|
FPE_FLTDIV, /* 74 - DZ | UFL | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 75 - INV | DZ | UFL | IMP | STK */
|
|
|
|
FPE_FLTDIV, /* 76 - DNML | DZ | UFL | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 77 - INV | DNML | DZ | UFL | IMP | STK */
|
|
|
|
FPE_FLTOVF, /* 78 - OFL | UFL | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 79 - INV | OFL | UFL | IMP | STK */
|
|
|
|
FPE_FLTUND, /* 7A - DNML | OFL | UFL | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 7B - INV | DNML | OFL | UFL | IMP | STK */
|
|
|
|
FPE_FLTDIV, /* 7C - DZ | OFL | UFL | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 7D - INV | DZ | OFL | UFL | IMP | STK */
|
|
|
|
FPE_FLTDIV, /* 7E - DNML | DZ | OFL | UFL | IMP | STK */
|
|
|
|
FPE_FLTSUB, /* 7F - INV | DNML | DZ | OFL | UFL | IMP | STK */
|
1999-07-25 13:16:09 +00:00
|
|
|
};
|
|
|
|
|
1993-06-12 14:58:17 +00:00
|
|
|
/*
|
1995-01-03 04:00:06 +00:00
|
|
|
* Preserve the FP status word, clear FP exceptions, then generate a SIGFPE.
|
|
|
|
*
|
|
|
|
* Clearing exceptions is necessary mainly to avoid IRQ13 bugs. We now
|
|
|
|
* depend on longjmp() restoring a usable state. Restoring the state
|
|
|
|
* or examining it might fail if we didn't clear exceptions.
|
|
|
|
*
|
1999-07-25 13:16:09 +00:00
|
|
|
* The error code chosen will be one of the FPE_... macros. It will be
|
|
|
|
* sent as the second argument to old BSD-style signal handlers and as
|
|
|
|
* "siginfo_t->si_code" (second argument) to SA_SIGINFO signal handlers.
|
1995-01-03 04:00:06 +00:00
|
|
|
*
|
|
|
|
* XXX the FP state is not preserved across signal handlers. So signal
|
|
|
|
* handlers cannot afford to do FP unless they preserve the state or
|
|
|
|
* longjmp() out. Both preserving the state and longjmp()ing may be
|
|
|
|
* destroyed by IRQ13 bugs. Clearing FP exceptions is not an acceptable
|
|
|
|
* solution for signals other than SIGFPE.
|
1993-06-12 14:58:17 +00:00
|
|
|
*/
|
2001-05-22 21:20:49 +00:00
|
|
|
int
|
|
|
|
npxtrap()
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
2001-05-22 21:20:49 +00:00
|
|
|
critical_t savecrit;
|
|
|
|
u_short control, status;
|
2001-07-12 06:32:51 +00:00
|
|
|
u_long *exstat;
|
1993-06-12 14:58:17 +00:00
|
|
|
|
Fixed panics in npx exception handling. When using IRQ13 exception
handling, SMPng always switches the npx context away from curproc
before calling the handler, so the handler always paniced. When using
exception 16 exception handling, SMPng sometimes switches the npx
context away from curproc before calling the handler, so the handler
sometimes paniced. Also, we didn't lock the context while using it,
so we sometimes didn't detect the switch and then paniced in a less
controlled way.
Just lock the context while using it, and return without doing anything
except clearing the busy latch if the context is not for curproc. This
fixes the exception 16 case and makes the IRQ13 case harmless. In both
cases, the instruction that caused the exception is restarted and the
exception repeats. In the exception 16 case, we soon get an exception
that can be handled without doing anything special. In the IRQ13 case,
we get an easy to kill hung process.
2001-05-02 13:06:58 +00:00
|
|
|
if (!npx_exists) {
|
2001-05-22 21:20:49 +00:00
|
|
|
printf("npxtrap: npxproc = %p, curproc = %p, npx_exists = %d\n",
|
2001-01-10 04:43:51 +00:00
|
|
|
PCPU_GET(npxproc), curproc, npx_exists);
|
2001-05-22 21:20:49 +00:00
|
|
|
panic("npxtrap from nowhere");
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
2001-05-22 21:20:49 +00:00
|
|
|
savecrit = critical_enter();
|
1993-06-12 14:58:17 +00:00
|
|
|
|
|
|
|
/*
|
2001-05-22 21:20:49 +00:00
|
|
|
* Interrupt handling (for another interrupt) may have pushed the
|
|
|
|
* state to memory. Fetch the relevant parts of the state from
|
|
|
|
* wherever they are.
|
1993-06-12 14:58:17 +00:00
|
|
|
*/
|
2001-05-22 21:20:49 +00:00
|
|
|
if (PCPU_GET(npxproc) != curproc) {
|
2001-07-12 06:32:51 +00:00
|
|
|
control = GET_FPU_CW(curproc);
|
|
|
|
status = GET_FPU_SW(curproc);
|
1993-06-12 14:58:17 +00:00
|
|
|
} else {
|
2001-05-22 21:20:49 +00:00
|
|
|
fnstcw(&control);
|
|
|
|
fnstsw(&status);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
2001-05-22 21:20:49 +00:00
|
|
|
|
2001-07-12 06:32:51 +00:00
|
|
|
exstat = GET_FPU_EXSW_PTR(&curproc->p_addr->u_pcb);
|
|
|
|
*exstat = status;
|
2001-05-22 21:20:49 +00:00
|
|
|
if (PCPU_GET(npxproc) != curproc)
|
2001-07-12 06:32:51 +00:00
|
|
|
MASK_FPU_SW(curproc, ~0x80bf);
|
2001-05-22 21:20:49 +00:00
|
|
|
else
|
|
|
|
fnclex();
|
|
|
|
critical_exit(savecrit);
|
|
|
|
return (fpetable[status & ((~control & 0x3f) | 0x40)]);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Implement device not available (DNA) exception
|
|
|
|
*
|
1995-01-03 04:00:06 +00:00
|
|
|
* It would be better to switch FP context here (if curproc != npxproc)
|
|
|
|
* and not necessarily for every context switch, but it is too hard to
|
|
|
|
* access foreign pcb's.
|
1993-06-12 14:58:17 +00:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
npxdna()
|
|
|
|
{
|
2001-07-12 06:32:51 +00:00
|
|
|
u_long *exstat;
|
2001-03-28 03:06:10 +00:00
|
|
|
critical_t s;
|
2001-02-01 03:34:20 +00:00
|
|
|
|
1993-06-12 14:58:17 +00:00
|
|
|
if (!npx_exists)
|
|
|
|
return (0);
|
2001-01-10 04:43:51 +00:00
|
|
|
if (PCPU_GET(npxproc) != NULL) {
|
1995-01-03 04:00:06 +00:00
|
|
|
printf("npxdna: npxproc = %p, curproc = %p\n",
|
2001-01-10 04:43:51 +00:00
|
|
|
PCPU_GET(npxproc), curproc);
|
1993-06-12 14:58:17 +00:00
|
|
|
panic("npxdna");
|
|
|
|
}
|
2001-03-28 03:06:10 +00:00
|
|
|
s = critical_enter();
|
1993-06-12 14:58:17 +00:00
|
|
|
stop_emulating();
|
|
|
|
/*
|
|
|
|
* Record new context early in case frstor causes an IRQ13.
|
|
|
|
*/
|
2000-09-07 01:33:02 +00:00
|
|
|
PCPU_SET(npxproc, CURPROC);
|
2001-07-12 06:32:51 +00:00
|
|
|
|
|
|
|
exstat = GET_FPU_EXSW_PTR(PCPU_GET(curpcb));
|
|
|
|
*exstat = 0;
|
1993-06-12 14:58:17 +00:00
|
|
|
/*
|
|
|
|
* The following frstor may cause an IRQ13 when the state being
|
|
|
|
* restored has a pending error. The error will appear to have been
|
|
|
|
* triggered by the current (npx) user instruction even when that
|
|
|
|
* instruction is a no-wait instruction that should not trigger an
|
|
|
|
* error (e.g., fnclex). On at least one 486 system all of the
|
|
|
|
* no-wait instructions are broken the same as frstor, so our
|
|
|
|
* treatment does not amplify the breakage. On at least one
|
|
|
|
* 386/Cyrix 387 system, fnclex works correctly while frstor and
|
|
|
|
* fnsave are broken, so our treatment breaks fnclex if it is the
|
|
|
|
* first FPU instruction after a context switch.
|
|
|
|
*/
|
2001-07-16 06:00:23 +00:00
|
|
|
fpurstor(&PCPU_GET(curpcb)->pcb_save);
|
2001-03-28 03:06:10 +00:00
|
|
|
critical_exit(s);
|
1993-06-12 14:58:17 +00:00
|
|
|
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2001-05-20 20:04:40 +00:00
|
|
|
* Wrapper for fnsave instruction, partly to handle hardware bugs. When npx
|
|
|
|
* exceptions are reported via IRQ13, spurious IRQ13's may be triggered by
|
|
|
|
* no-wait npx instructions. See the Intel application note AP-578 for
|
|
|
|
* details. This doesn't cause any additional complications here. IRQ13's
|
|
|
|
* are inherently asynchronous unless the CPU is frozen to deliver them --
|
|
|
|
* one that started in userland may be delivered many instructions later,
|
|
|
|
* after the process has entered the kernel. It may even be delivered after
|
|
|
|
* the fnsave here completes. A spurious IRQ13 for the fnsave is handled in
|
|
|
|
* the same way as a very-late-arriving non-spurious IRQ13 from user mode:
|
|
|
|
* it is normally ignored at first because we set npxproc to NULL; it is
|
|
|
|
* normally retriggered in npxdna() after return to user mode.
|
|
|
|
*
|
|
|
|
* npxsave() must be called with interrupts disabled, so that it clears
|
|
|
|
* npxproc atomically with saving the state. We require callers to do the
|
|
|
|
* disabling, since most callers need to disable interrupts anyway to call
|
|
|
|
* npxsave() atomically with checking npxproc.
|
|
|
|
*
|
|
|
|
* A previous version of npxsave() went to great lengths to excecute fnsave
|
|
|
|
* with interrupts enabled in case executing it froze the CPU. This case
|
|
|
|
* can't happen, at least for Intel CPU/NPX's. Spurious IRQ13's don't imply
|
|
|
|
* spurious freezes.
|
1993-06-12 14:58:17 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
npxsave(addr)
|
2001-07-12 06:32:51 +00:00
|
|
|
union savefpu *addr;
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
1997-07-21 07:57:50 +00:00
|
|
|
|
|
|
|
stop_emulating();
|
2001-07-16 06:00:23 +00:00
|
|
|
fpusave(addr);
|
2001-07-12 06:32:51 +00:00
|
|
|
|
1997-07-21 07:57:50 +00:00
|
|
|
start_emulating();
|
2000-09-07 01:33:02 +00:00
|
|
|
PCPU_SET(npxproc, NULL);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
2001-07-12 06:32:51 +00:00
|
|
|
static void
|
2001-07-16 06:00:23 +00:00
|
|
|
fpusave(addr)
|
2001-07-12 06:32:51 +00:00
|
|
|
union savefpu *addr;
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!cpu_fxsr)
|
|
|
|
fnsave(addr);
|
2001-07-17 13:06:47 +00:00
|
|
|
else
|
|
|
|
fxsave(addr);
|
2001-07-12 06:32:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2001-07-16 06:00:23 +00:00
|
|
|
fpurstor(addr)
|
2001-07-12 06:32:51 +00:00
|
|
|
union savefpu *addr;
|
|
|
|
{
|
|
|
|
if (!cpu_fxsr)
|
|
|
|
frstor(addr);
|
2001-07-17 13:06:47 +00:00
|
|
|
else
|
|
|
|
fxrstor(addr);
|
2001-07-12 06:32:51 +00:00
|
|
|
}
|
|
|
|
|
2001-06-15 07:53:20 +00:00
|
|
|
#ifdef I586_CPU_XXX
|
1998-02-12 21:41:10 +00:00
|
|
|
static long
|
|
|
|
timezero(funcname, func)
|
|
|
|
const char *funcname;
|
|
|
|
void (*func) __P((void *buf, size_t len));
|
|
|
|
|
|
|
|
{
|
|
|
|
void *buf;
|
2001-03-19 00:28:04 +00:00
|
|
|
#define BUFSIZE 1048576
|
1998-02-12 21:41:10 +00:00
|
|
|
long usec;
|
|
|
|
struct timeval finish, start;
|
|
|
|
|
|
|
|
buf = malloc(BUFSIZE, M_TEMP, M_NOWAIT);
|
|
|
|
if (buf == NULL)
|
|
|
|
return (BUFSIZE);
|
|
|
|
microtime(&start);
|
|
|
|
(*func)(buf, BUFSIZE);
|
|
|
|
microtime(&finish);
|
|
|
|
usec = 1000000 * (finish.tv_sec - start.tv_sec) +
|
|
|
|
finish.tv_usec - start.tv_usec;
|
|
|
|
if (usec <= 0)
|
|
|
|
usec = 1;
|
|
|
|
if (bootverbose)
|
2001-06-15 07:53:20 +00:00
|
|
|
printf("%s bandwidth = %u kBps\n", funcname,
|
2001-03-19 00:28:04 +00:00
|
|
|
(u_int32_t)(((BUFSIZE >> 10) * 1000000) / usec));
|
1998-02-12 21:41:10 +00:00
|
|
|
free(buf, M_TEMP);
|
|
|
|
return (usec);
|
|
|
|
}
|
|
|
|
#endif /* I586_CPU */
|
|
|
|
|
1999-04-16 21:22:55 +00:00
|
|
|
static device_method_t npx_methods[] = {
|
|
|
|
/* Device interface */
|
1999-08-22 19:52:51 +00:00
|
|
|
DEVMETHOD(device_identify, npx_identify),
|
1999-04-16 21:22:55 +00:00
|
|
|
DEVMETHOD(device_probe, npx_probe),
|
|
|
|
DEVMETHOD(device_attach, npx_attach),
|
|
|
|
DEVMETHOD(device_detach, bus_generic_detach),
|
|
|
|
DEVMETHOD(device_shutdown, bus_generic_shutdown),
|
|
|
|
DEVMETHOD(device_suspend, bus_generic_suspend),
|
|
|
|
DEVMETHOD(device_resume, bus_generic_resume),
|
|
|
|
|
|
|
|
{ 0, 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static driver_t npx_driver = {
|
|
|
|
"npx",
|
|
|
|
npx_methods,
|
|
|
|
1, /* no softc */
|
|
|
|
};
|
|
|
|
|
|
|
|
static devclass_t npx_devclass;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We prefer to attach to the root nexus so that the usual case (exception 16)
|
|
|
|
* doesn't describe the processor as being `on isa'.
|
|
|
|
*/
|
|
|
|
DRIVER_MODULE(npx, nexus, npx_driver, npx_devclass, 0, 0);
|
2000-05-04 23:57:32 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This sucks up the legacy ISA support assignments from PNPBIOS.
|
|
|
|
*/
|
|
|
|
static struct isa_pnp_id npxisa_ids[] = {
|
|
|
|
{ 0x040cd041, "Legacy ISA coprocessor support" }, /* PNP0C04 */
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
|
|
|
npxisa_probe(device_t dev)
|
|
|
|
{
|
2000-06-23 08:19:50 +00:00
|
|
|
int result;
|
|
|
|
if ((result = ISA_PNP_PROBE(device_get_parent(dev), dev, npxisa_ids)) <= 0) {
|
|
|
|
device_quiet(dev);
|
|
|
|
}
|
|
|
|
return(result);
|
2000-05-04 23:57:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
npxisa_attach(device_t dev)
|
|
|
|
{
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static device_method_t npxisa_methods[] = {
|
|
|
|
/* Device interface */
|
|
|
|
DEVMETHOD(device_probe, npxisa_probe),
|
|
|
|
DEVMETHOD(device_attach, npxisa_attach),
|
|
|
|
DEVMETHOD(device_detach, bus_generic_detach),
|
|
|
|
DEVMETHOD(device_shutdown, bus_generic_shutdown),
|
|
|
|
DEVMETHOD(device_suspend, bus_generic_suspend),
|
|
|
|
DEVMETHOD(device_resume, bus_generic_resume),
|
|
|
|
|
|
|
|
{ 0, 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static driver_t npxisa_driver = {
|
|
|
|
"npxisa",
|
|
|
|
npxisa_methods,
|
|
|
|
1, /* no softc */
|
|
|
|
};
|
|
|
|
|
|
|
|
static devclass_t npxisa_devclass;
|
|
|
|
|
|
|
|
DRIVER_MODULE(npxisa, isa, npxisa_driver, npxisa_devclass, 0, 0);
|
|
|
|
|