*

* Sep, 1994 Implemented on FreeBSD 1.1.5.1R (Toshiba AVS001WD)

*

*/

#include "opt_devfs.h"

ssdtosd(gdt_segs + GAPMDATA_SEL , &gdt[GAPMDATA_SEL ].sd);

}

struct addr48 {

u_long offset;

u_short segment;

*

* Sep, 1994 Implemented on FreeBSD 1.1.5.1R (Toshiba AVS001WD)

*

*/

#include "opt_devfs.h"

ssdtosd(gdt_segs + GAPMDATA_SEL , &gdt[GAPMDATA_SEL ].sd);

}

struct addr48 {

u_long offset;

u_short segment;

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*

*/

#include "opt_eisa.h"

/*

* Local function declarations and static variables

*/

static int eisa_add_resvaddr __P((struct eisa_device *e_dev,

struct resvlist *head, u_long base,

u_long size, int flags));

* Output an optional character separator before the string

* if the line does not wrap.

*/

eisa_reg_print(e_dev, string, separator)

struct eisa_device *e_dev;

char *string;

static int vx_eisa_probe __P((void));

static int vx_eisa_attach __P((struct eisa_device *));

"vx",

vx_eisa_probe,

vx_eisa_attach,

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*

*/

/*

#define BIOS_SIZE 0x20000

/* exported lookup results */

static caddr_t bios32_SDCI = NULL;

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*

*/

#include "opt_smp.h"

/* Bitmap of all available CPUs */

u_int all_cpus;

pd_entry_t *bootPTD;

/* Hotwire a 0->4MB V==P mapping */

/* the bus data */

/* the IO INT data, one entry per possible APIC INTerrupt */

static int nintrs;

SYSCTL_INT(_machdep, OID_AUTO, smp_active, CTLFLAG_RW, &smp_active, 0, "");

/* XXX maybe should be hw.ncpu */

SYSCTL_INT(_machdep, OID_AUTO, smp_cpus, CTLFLAG_RD, &smp_cpus, 0, "");

int invltlb_ok = 0; /* throttle smp_invltlb() till safe */

SYSCTL_INT(_machdep, OID_AUTO, invltlb_ok, CTLFLAG_RW, &invltlb_ok, 0, "");

int do_page_zero_idle = 0; /* bzero pages for fun and profit in idleloop */

SYSCTL_INT(_machdep, OID_AUTO, do_page_zero_idle, CTLFLAG_RW,

&do_page_zero_idle, 0, "");

#define CHECKSTATE_SYS 1

#define CHECKSTATE_INTR 2

struct proc* checkstate_curproc[NCPU];

int checkstate_cpustate[NCPU];

u_long checkstate_pc[NCPU];

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*

*/

#include "opt_smp.h"

/* Bitmap of all available CPUs */

u_int all_cpus;

pd_entry_t *bootPTD;

/* Hotwire a 0->4MB V==P mapping */

/* the bus data */

/* the IO INT data, one entry per possible APIC INTerrupt */

static int nintrs;

SYSCTL_INT(_machdep, OID_AUTO, smp_active, CTLFLAG_RW, &smp_active, 0, "");

/* XXX maybe should be hw.ncpu */

SYSCTL_INT(_machdep, OID_AUTO, smp_cpus, CTLFLAG_RD, &smp_cpus, 0, "");

int invltlb_ok = 0; /* throttle smp_invltlb() till safe */

SYSCTL_INT(_machdep, OID_AUTO, invltlb_ok, CTLFLAG_RW, &invltlb_ok, 0, "");

int do_page_zero_idle = 0; /* bzero pages for fun and profit in idleloop */

SYSCTL_INT(_machdep, OID_AUTO, do_page_zero_idle, CTLFLAG_RW,

&do_page_zero_idle, 0, "");

#define CHECKSTATE_SYS 1

#define CHECKSTATE_INTR 2

struct proc* checkstate_curproc[NCPU];

int checkstate_cpustate[NCPU];

u_long checkstate_pc[NCPU];

* SUCH DAMAGE.

*

* from: @(#)pmap.c 7.7 (Berkeley) 5/12/91

*/

/*

vm_offset_t virtual_end; /* VA of last avail page (end of kernel AS) */

static boolean_t pmap_initialized = FALSE; /* Has pmap_init completed? */

static vm_offset_t vm_first_phys;

vm_offset_t kernel_vm_end;

/*

* Data for the pv entry allocation mechanism

*/

/*

* All those kernel PT submaps that BSD is so fond of

extern pt_entry_t SMP_prvpt[];

#endif

static PMAP_INLINE void free_pv_entry __P((pv_entry_t pv));

static unsigned * get_ptbase __P((pmap_t pmap));

vm_offset_t pmap_kmem_choose(vm_offset_t addr) ;

void pmap_collect(void);

/*

* Routine: pmap_pte

* by using a large (4MB) page for much of the kernel

* (.text, .data, .bss)

*/

pmap_kmem_choose(vm_offset_t addr) {

vm_offset_t newaddr = addr;

#ifndef DISABLE_PSE

* SUCH DAMAGE.

*

* from: @(#)sys_machdep.c 5.5 (Berkeley) 1/19/91

*

*/

#ifdef USER_LDT

/*

* Update the GDT entry pointing to the LDT to point to the LDT of the

*/

void

set_user_ldt(struct pcb *pcb)

* SUCH DAMAGE.

*

* from: @(#)clock.c 7.2 (Berkeley) 5/12/91

*/

/*

u_int tsc_comultiplier;

u_int tsc_freq;

u_int tsc_multiplier;

int wall_cmos_clock; /* wall CMOS clock assumed if != 0 */

static int beeping = 0;

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*

*/

#include <sys/param.h>

extern struct sysentvec ibcs2_svr3_sysvec;

static int load_coff_section __P((struct vmspace *vmspace, struct vnode *vp, vm_offset_t offset, caddr_t vmaddr, size_t memsz, size_t filsz, vm_prot_t prot));

return error;

}

coff_load_file(struct proc *p, char *name)

{

struct vmspace *vmspace = p->p_vmspace;

return error;

}

exec_coff_imgact(imgp)

struct image_params *imgp;

{

* Since `const' objects end up in the text segment, TEXT_SET is the

* correct directive to use.

*/

TEXT_SET(execsw_set, coff_execsw);

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*

*/

#include "opt_smp.h"

/* Bitmap of all available CPUs */

u_int all_cpus;

pd_entry_t *bootPTD;

/* Hotwire a 0->4MB V==P mapping */

/* the bus data */

/* the IO INT data, one entry per possible APIC INTerrupt */

static int nintrs;

SYSCTL_INT(_machdep, OID_AUTO, smp_active, CTLFLAG_RW, &smp_active, 0, "");

/* XXX maybe should be hw.ncpu */

SYSCTL_INT(_machdep, OID_AUTO, smp_cpus, CTLFLAG_RD, &smp_cpus, 0, "");

int invltlb_ok = 0; /* throttle smp_invltlb() till safe */

SYSCTL_INT(_machdep, OID_AUTO, invltlb_ok, CTLFLAG_RW, &invltlb_ok, 0, "");

int do_page_zero_idle = 0; /* bzero pages for fun and profit in idleloop */

SYSCTL_INT(_machdep, OID_AUTO, do_page_zero_idle, CTLFLAG_RW,

&do_page_zero_idle, 0, "");

#define CHECKSTATE_SYS 1

#define CHECKSTATE_INTR 2

struct proc* checkstate_curproc[NCPU];

int checkstate_cpustate[NCPU];

u_long checkstate_pc[NCPU];

*/

/*

*

* Acknowledgements: Many of the algorithms used in this driver are

* inspired by the work of Julian Elischer (julian@tfs.com) and

#include <pccard/slot.h>

static int aicinit(struct pccard_devinfo *); /* init device */

static int aic_card_intr(struct pccard_devinfo *); /* Interrupt handler */

static struct pccard_device aic_info = {

* and ensure that any driver entry points such as

* read and write do not hang.

*/

aicunload(struct pccard_devinfo *devi)

{

printf("aic%d: unload\n", devi->isahd.id_unit);

#define PHASE_COMPLETED (ARI_IN | ARI_CMD)

#define PHASE_ABORTED 0 /* nonstandard - for NEC 260 */

static struct atapi_params *atapi_probe (int port, int unit);

static int atapi_wait (int port, u_char bits_wanted);

* SUCH DAMAGE.

*

* from: @(#)clock.c 7.2 (Berkeley) 5/12/91

*/

/*

u_int tsc_comultiplier;

u_int tsc_freq;

u_int tsc_multiplier;

int wall_cmos_clock; /* wall CMOS clock assumed if != 0 */

static int beeping = 0;

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*

*/

/*

#define IED_RNR 0x04

#define IED_CNA 0x08

#define IED_READFRAME 0x10

#endif

static void ie_mc_reset(int unit);

#ifdef DEBUG

#endif

#ifdef DEBUG

print_rbd(volatile struct ie_recv_buf_desc * rbd)

{

printf("RBD at %08lx:\n"

* SUCH DAMAGE.

*

* from: @(#)isa.c 7.2 (Berkeley) 5/13/91

*/

#include "opt_auto_eoi.h"

u_long *intr_countp[ICU_LEN];

inthand2_t *intr_handler[ICU_LEN];

u_int intr_mask[ICU_LEN];

int intr_unit[ICU_LEN];

static inthand_t *fastintr[ICU_LEN] = {

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*

*/

/*****************************************************************************/

* Declare all those functions in this driver! First up is the set of

* externally visible functions.

*/

STATIC d_open_t stliopen;

STATIC d_close_t stliclose;

* shared memory region to see if the board is really there or not...

*/

{

stlibrd_t *brdp;

int btype, bclass;

* Allocate resources for and initialize a board.

*/

{

stlibrd_t *brdp;

int brdnr;

* SUCH DAMAGE.

*

* from: @(#)isa.c 7.2 (Berkeley) 5/13/91

*/

#include "opt_auto_eoi.h"

u_long *intr_countp[ICU_LEN];

inthand2_t *intr_handler[ICU_LEN];

u_int intr_mask[ICU_LEN];

int intr_unit[ICU_LEN];

static inthand_t *fastintr[ICU_LEN] = {

extern u_short *Crtat;

#endif /* PCVT_NETBSD */

static __color;

static nrow;

#if PCVT_KBD_FIFO

u_char pcvt_kbd_fifo[PCVT_KBD_FIFO_SZ];

int pcvt_kbd_rptr = 0;

short pcvt_kbd_count= 0;

static u_char pcvt_timeout_scheduled = 0;

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*

*/

#include <sys/param.h>

#include <i386/isa/isa_device.h>

#include <i386/isa/pnp.h>

pnp_id pnp_devices[MAX_PNP_CARDS];

struct pnp_dlist_node *pnp_device_list;

static struct pnp_dlist_node **pnp_device_list_last_ptr;

/* The READ_DATA port that we are using currently */

static int pnp_rd_port;

void pnp_write(int d, u_char r);

u_char pnp_read(int d);

* Send Initiation LFSR as described in "Plug and Play ISA Specification",

* Intel May 94.

*/

pnp_send_Initiation_LFSR()

{

int cur, i;

/*

* Get the device's serial number. Returns 1 if the serial is valid.

*/

pnp_get_serial(pnp_id *p)

{

int i, bit, valid = 0, sum = 0x6a;

* 4 bytes: board serial number (often 0 or -1 ?)

*/

config_pnp_device(pnp_id *p, int csn)

{

static struct pnp_dlist_node *nod = NULL;

* are saved to an array, pnp_devices. In the second pass, each

* card is woken up and the device configuration is called.

*/

pnp_isolation_protocol()

{

int csn;

#define FALSE 0

#endif

{

0x00, 0x09, 0xf6, 0x82,

0x02, 0x09, 0x86, 0xfb,

0x22, 0x09, 0x0a, 0x0a

};

{

0x00, 0x09, 0xf6, 0x82, /* 00: Stop Rx processor */

0x08, 0x09, 0x8a, 0x13, /* 04: Tx software flow control */

0x22, 0x09, 0x0a, 0x0a /* 30: Rx FIFO Enable */

};

{

{-1,-1,0,0,0,0,0,0,0,0,0,{0,0,0,0},{0,0,0,0},{-1,-1,-1,-1},{0,0,0,0}},

{-1,-1,0,0,0,0,0,0,0,0,0,{0,0,0,0},{0,0,0,0},{-1,-1,-1,-1},{0,0,0,0}},

};

#endif

{

0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f

};

{

0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80

};

static void rp_pciattach(pcici_t tag, int unit);

static u_long rp_pcicount;

"rp",

rp_pciprobe,

rp_pciattach,

#include <i386/isa/sound/ad1848_mixer.h>

#include <i386/isa/sound/iwdefs.h>

extern void IwaveStopDma(BYTE path);

typedef struct {

int sndtable_get_cardcount(void);

int snd_find_driver(int type);

int sndtable_probe(int unit, struct address_info * hw_config);

int sndtable_init_card(int unit, struct address_info * hw_config);

static void start_services(void);

static void start_cards(void);

struct address_info *sound_getconf(int card_type);

printf("Sound initialization complete\n");

}

sndtable_init()

{

start_cards();

return num_audiodevs + num_mixers + num_synths + num_midis;

}

sndtable_identify_card(char *name)

{

int i, n = num_sound_drivers;

return 0;

}

sound_chconf(int card_type, int ioaddr, int irq, int dma)

{

int j, ptr = -1, n = num_sound_cards;

extern int have_gus_max;

extern int gus_timer_enabled;

#ifndef NOGUSPNP

int IwaveOpen(char voices, char mode, struct address_info * hw);

#if defined(CONFIG_GUS)

#define ENTER_CRITICAL

#define LEAVE_CRITICAL

#define MAX_PATCH 256

{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

struct voice_info {

static int only_8_bits = 0;

int gus_wave_volume = 60;

int have_gus_max = 0;

static int gus_line_vol = 100, gus_mic_vol = 0;

static u_char mix_image = 0x00;

extern sound_os_info *gus_osp;

static int freq_div_table[] =

{

};

static struct patch_info *samples;

static long sample_ptrs[MAX_SAMPLE + 1];

static int sample_map[32];

static void gus_default_mixer_init(void);

static void gus_poke(long addr, u_char data);

extern u_short gus_adagio_vol(int vel, int mainv, int xpn, int voicev);

extern u_short gus_linear_vol(int vol, int mainvol);

void do_volume_irq(int voice);

static void set_input_volumes(void);

static void gus_tmr_install(int io_base);

#define INSTANT_RAMP -1 /* Instant change. No ramping */

{ outb(iwl_codec_base, reg); val = inb(iwl_codec_data); }

int IwaveOpen(char voices, char mode, struct address_info * hw);

return val;

}

gus_look8(int reg)

{ /* Reads from an indirect register (8 bit). No additional offset. */

u_long flags;

return val;

}

gus_write16(int reg, u_int data)

{ /* Writes to an indirect register (16 bit) */

u_long flags;

splx(flags);

}

gus_read16(int reg)

{ /* Reads from an indirect register (16 bit). Offset 0x80. */

u_long flags;

return ((hi << 8) & 0xff00) | lo;

}

gus_write_addr(int reg, u_long address, int is16bit)

{ /* Writes an 24 bit memory address */

u_long hold_address;

volume_method = mode;

}

compute_volume(int voice, int volume)

{

if (volume < 128)

voices[voice].initial_volume = 4030;

}

compute_and_set_volume(int voice, int volume, int ramp_time)

{

int curr, target, rate;

}

}

guswave_start_note2(int dev, int voice, int note_num, int volume)

{

int sample, best_sample, best_delta, delta_freq;

/* start of pnp code */

SEND(int d, int r)

{

outb(PADDRESS, d);

/*

* Get the device's serial number. Returns 1 if the serial is valid.

*/

get_serial(int rd_port, u_char *data)

{

int i, bit, valid = 0, sum = 0x6a;

return valid;

}

send_Initiation_LFSR()

{

int cur, i;

isolation_protocol(int rd_port)

{

int csn;

IwaveDelay(WORD count)

{

WORD cur_cnt = 0, last_cnt;

* ########################################################################

*/

IwaveStopDma(BYTE path)

{

BYTE reg;

*

* ########################################################################

*/

IwaveInputSource(BYTE index, BYTE source)

{

BYTE reg;

outb(iw.cdatap, (BYTE) (reg | source));

LEAVE_CRITICAL;

}

IwavePnpGetCfg(void)

{

WORD val;

LEAVE_CRITICAL;

}

IwavePnpSetCfg(void)

{

ENTER_CRITICAL;

LEAVE_CRITICAL;

}

IwaveCfgIOSpace(void)

{

ENTER_CRITICAL;

/* write cycles of 0x00 to PIDXR before issuing the key. */

/* */

/* ######################################################################## */

IwavePnpKey(void)

{

/* send_Initiation_LFSR(); */

}

IwavePnpIsol(PORT * pnpread)

{

int num_pnp_devs;

/* will be obtained. */

/* */

/* ######################################################################## */

IwavePnpSerial(PORT pnprdp,

BYTE csn,

BYTE * vendor,

/* should issue a WAKE[CSN] command */

/* */

/* ######################################################################## */

IwavePnpPeek(PORT pnprdp, WORD bytes, BYTE * data)

{

WORD i;

/* IwavePnpActivate(AUDIO,OFF). */

/* */

/* ######################################################################## */

IwavePnpEeprom(BYTE ctrl)

{

ENTER_CRITICAL;

/* activated. */

/* */

/* ######################################################################## */

IwavePnpActivate(BYTE dev, BYTE bool)

{

IwavePnpDevice(dev); /* select audio device */

/* that the PNP state machine is in configuration mode. */

/* */

/* ######################################################################## */

IwavePnpDevice(BYTE dev)

{

ENTER_CRITICAL;

/* mode. */

/* */

/* ######################################################################## */

IwavePnpPower(BYTE mode)

{

ENTER_CRITICAL;

/* "wait for key" state. */

/* */

/* ######################################################################## */

IwavePnpWake(BYTE csn)

{

ENTER_CRITICAL;

/* activated and that the PNP state machine is in config mode. */

/* */

/* ######################################################################## */

IwavePnpIOcheck(PORT base, BYTE no_ports)

{

BYTE i;

/* InterWave IC it will return FALSE. */

/* */

/* ######################################################################## */

IwavePnpGetCSN(DWORD VendorID, BYTE csn_max)

{

BYTE csn;

/* sure they are compatible with the board. */

/* */

/* ######################################################################## */

IwavePnpPing(DWORD VendorID)

{

BYTE csn;

/* end of pnp code */

IwaveMemSize(void)

{

BYTE datum = 0x55;

return ((WORD) (local >> 10));

}

IwaveMemPeek(ADDRESS addr)

{

PORT p3xr;

}

IwaveMemPoke(ADDRESS addr, BYTE datum)

{

PORT p3xr;

/* full addressing span (LMCFI[3:0]=0xC). */

/* */

/* ######################################################################## */

IwaveMemCfg(DWORD * lpbanks)

{

DWORD bank[4] = {0L, 0L, 0L, 0L};

/* IwaveCodeIrq(~CODEC_IRQ_ENABLE). */

/**/

/* ######################################################################## */

IwaveCodecIrq(BYTE mode)

{

BYTE reg;

/* meaningless data. */

/**/

/* ######################################################################### */

IwaveRegPeek(DWORD reg_mnem)

{

BYTE index, val;

/* that the writes are to valid registers. */

/**/

/* ######################################################################### */

IwaveRegPoke(DWORD reg_mnem, WORD datum)

{

BYTE index;

}

IwaveLineLevel(char level, char index)

{

char reg;

LEAVE_CRITICAL;

}

IwaveCodecMode(char mode)

{

char reg;

iw.cmode = mode;

}

IwaveLineMute(BYTE mute, BYTE inx)

{

BYTE reg;

LEAVE_CRITICAL;

}

Iwaveinitcodec()

{

splx(flags);

}

do_volume_irq(int voice)

{

u_char tmp;

int

MIDIbuf_poll (int dev, struct fileinfo *file, int events, select_table * wait);

drain_midi_queue(int dev);

static int *midi_sleeper[MAX_MIDI_DEV] = {NULL};

splx(flags); \

}

drain_midi_queue(int dev)

{

* volume -8 it was implemented as a table because it is only 128 bytes and

* it saves a lot of log() calculations. (RH)

*/

{

-64, -48, -40, -35, -32, -29, -27, -26,

-24, -23, -21, -20, -19, -18, -18, -17,

static int pas_intr_mask = 0;

static int pas_irq = 0;

char pas_model;

static char *pas_model_names[] =

outb(ioaddr ^ translat_code, data);

}

pas2_msg(char *foo)

{

printf(" PAS2: %s.\n", foo);

/******************* Begin of the Initialization Code ******************/

config_pas_hw(struct address_info * hw_config)

{

char ok = 1;

return ok;

}

detect_pas_hw(struct address_info * hw_config)

{

u_char board_id, foo;

set_mode(P_M_MV508_LOUDNESS | P_M_MV508_ENHANCE_40);

}

pas_mixer_ioctl(int dev, u_int cmd, ioctl_arg arg)

{

TRACE(printf("pas2_mixer.c: int pas_mixer_ioctl(u_int cmd = %X, u_int arg = %X)\n", cmd, arg));

static int my_devnum = 0;

static int open_mode = 0;

pcm_set_speed(int arg)

{

int foo, tmp;

return pcm_speed;

}

pcm_set_channels(int arg)

{

return pcm_channels;

}

pcm_set_bits(int arg)

{

if ((arg & pcm_bitsok) != arg)

int sbc_base = 0;

static int open_mode = 0; /* Read, write or both */

int Jazz16_detected = 0;

static int dsp_count = 0;

static int trigger_bits;

static int dsp_speed(int);

static int dsp_set_stereo(int mode);

static void sb_dsp_reset(int dev);

#if defined(CONFIG_MIDI) || defined(CONFIG_AUDIO)

/*

* Common code for the midi and pcm functions

#ifdef CONFIG_AUDIO

dsp_speaker(char state)

{

if (state)

extern volatile int sb_irq_mode;

extern int sb_duplex_midi;

extern int sb_intr_active;

static int my_dev;

extern sound_os_info *sb_osp;

static int

sb_midi_open(int dev, int mode, void (*input) (int dev, u_char data),

#include <i386/isa/sound/midi_ctrl.h>

int

sequencer_poll (int dev, struct fileinfo *file, int events, select_table * wait);

static int sequencer_ok = 0;

static int midi_opened[MAX_MIDI_DEV] = {0};

static int midi_written[MAX_MIDI_DEV] = {0};

#include <i386/isa/sound/tuning.h>

return 0;

}

seq_drain_midi_queues(void)

{

int i, n;

int

sequencer_poll (int dev, struct fileinfo *file, int events, select_table * wait);

static d_open_t sndopen;

static d_close_t sndclose;

*/

struct isa_driver opldriver = {sndprobe, sndattach, "opl"};

struct isa_driver sbdriver = {sndprobe, sndattach, "sb"};

struct isa_driver sbxvidriver = {sndprobe, sndattach, "sbxvi"};

struct isa_driver sbmididriver = {sndprobe, sndattach, "sbmidi"};

struct isa_driver pasdriver = {sndprobe, sndattach, "pas"};

struct isa_driver mpudriver = {sndprobe, sndattach, "mpu"};

struct isa_driver gusdriver = {sndprobe, sndattach, "gus"};

struct isa_driver uartdriver = {sndprobe, sndattach, "uart"};

struct isa_driver mssdriver = {sndprobe, sndattach, "mss"};

struct isa_driver sscapedriver = {sndprobe, sndattach, "sscape"};

struct isa_driver sscape_mssdriver = {sndprobe, sndattach, "sscape_mss"};

(u_long) timecopy.tv_sec * hz;

}

sndmmap( dev_t dev, int offset, int nprot )

{

int unit;

* The parameters from the config line are passed to the hw_config struct.

*/

sndprobe(struct isa_device * dev)

{

struct address_info hw_config;

return 0;

}

sndattach(struct isa_device * dev)

{

int unit;

* v1.4 by Eric S. Raymond (esr@snark.thyrsus.com) Aug 1993

* modified for FreeBSD by Andrew A. Chernov <ache@astral.msk.su>

*

*/

#include "speaker.h"

#ifdef DEVFS

#include <sys/devfsext.h>

#endif

static d_open_t spkropen;

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*

*/

/*****************************************************************************/

* externally visible functions.

*/

STATIC d_open_t stlopen;

STATIC d_close_t stlclose;

* they are done in the stlpciprobe() routine).

*/

{

unsigned int status;

* Allocate resources for and initialize the specified board.

*/

{

stlbrd_t *brdp;

* all derivative works or modified versions.

*

* From: Version 1.9, Mon Oct 9 20:27:42 MSK 1995

*/

#include "wdc.h"

/*

* Volume size info.

*/

u_long volsize; /* Volume size in blocks */

u_long blksize; /* Block size in bytes */

} info;

#endif

};

static struct wcd *wcd_init_lun(struct atapi *ata, int unit,

struct atapi_params *ap, int lun);

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*

*/

/*

struct diskslices *dk_slices; /* virtual drives */

};

static void wfd_start (struct wfd *t);

static void wfd_done (struct wfd *t, struct buf *bp, int resid,

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*

*/

#include <sys/param.h>

#include <i386/linux/linux.h>

exec_linux_imgact(imgp)

struct image_params *imgp;

{

* Since `const' objects end up in the text segment, TEXT_SET is the

* correct directive to use.

*/

TEXT_SET(execsw_set, linux_execsw);

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*

*/

/* XXX we use functions that might not exist. */

#include <i386/linux/linux.h>

#include <i386/linux/linux_proto.h>

/*

* Linux syscalls return negative errno's, we do positive and map them

SIGXCPU, SIGXFSZ, SIGVTALRM, SIGPROF, SIGWINCH, SIGURG, SIGURG, 0

};

{

int *argv, *envp;

return 0;

}

{

Elf32_Auxargs *args = (Elf32_Auxargs *)imgp->auxargs;

int *pos;

* specified pc, psl.

*/

linux_sendsig(sig_t catcher, int sig, int mask, u_long code)

{

register struct proc *p = curproc;

return (EJUSTRETURN);

}

linux_prepsyscall(struct trapframe *tf, int *args, u_int *code, caddr_t *params)

{

args[0] = tf->tf_ebx;

/*

* Installed either via SYSINIT() or via LKM stubs.

*/

"Linux",

"/compat/linux",

"/lib/ld-linux.so.1",