drvfbi.c

h内核

 *	for the inp() and outp() macros.
 *
 *	slot - The number of the slot for which the card id is returned.
 * Out
 *	Returns the card id read from the specified slot. If an illegal slot
 *	number is specified, the function returns zero.
 *
 ************************/
static int read_card_id(struct s_smc *smc, int slot)
/* struct s_smc *smc ;	Do not use. */
{
	int card_id ;

	SK_UNUSED(smc) ;	/* Make LINT happy. */
	if ((slot < 1) || (slot > 15))	/* max 16 slots, 0 = motherboard */
		return (0) ;	/* Illegal slot number specified. */

	EnableSlotAccess(smc, slot) ;

	card_id = ((read_POS(smc,POS_ID_HIGH,slot - 1) & 0xff) << 8) |
				(read_POS(smc,POS_ID_LOW,slot - 1) & 0xff) ;

	DisableSlotAccess(smc) ;

	return (card_id) ;
}

/************************
 *
 * BEGIN_MANUAL_ENTRY()
 *
 *	get_board_para
 *
 *	Get adapter configuration information. Fill all board specific
 *	parameters within the 'smc' structure.
 *
 *	int get_board_para(
 *		struct s_smc *smc,
 *		int slot) ;
 * In
 *	smc - A pointer to the SMT Context struct, to which this function will
 *	write some adapter configuration data.
 *
 *	slot - The number of the slot, in which the adapter is installed.
 * Out
 *	0 = No adapter present.
 *	1 = Ok.
 *	2 = Adapter present, but card enable bit not set.
 *
 * END_MANUAL_ENTRY()
 *
 ************************/
int get_board_para(struct s_smc *smc, int slot)
{
	int val ;
	int i ;

	/* Check if adapter present & get type of adapter. */
	switch (exist_board(smc, slot)) {
	case 0:	/* Adapter not present. */
		return (0) ;
	case 1:	/* FM Rev. 1 */
		smc->hw.rev = FM1_REV ;
		smc->hw.VFullRead = 0x0a ;
		smc->hw.VFullWrite = 0x05 ;
		smc->hw.DmaWriteExtraBytes = 8 ;	/* 2 extra words. */
		break ;
	}
	smc->hw.slot = slot ;

	EnableSlotAccess(smc, slot) ;

	if (!(read_POS(smc,POS_102, slot - 1) & POS_CARD_EN)) {
		DisableSlotAccess(smc) ;
		return (2) ;	/* Card enable bit not set. */
	}

	val = read_POS(smc,POS_104, slot - 1) ;	/* I/O, IRQ */

#ifndef MEM_MAPPED_IO	/* is defined by the operating system */
	i = val & POS_IOSEL ;	/* I/O base addr. (0x0200 .. 0xfe00) */
	smc->hw.iop = (i + 1) * 0x0400 - 0x200 ;
#endif
	i = ((val & POS_IRQSEL) >> 6) & 0x03 ;	/* IRQ <0, 1> */
	smc->hw.irq = opt_ints[i] ;

	/* FPROM base addr. */
	i = ((read_POS(smc,POS_103, slot - 1) & POS_MSEL) >> 4) & 0x07 ;
	smc->hw.eprom = opt_eproms[i] ;

	DisableSlotAccess(smc) ;

	/* before this, the smc->hw.iop must be set !!! */
	smc->hw.slot_32 = inpw(CSF_A) & SLOT_32 ;

	return (1) ;
}

/* Enable access to specified MCA slot. */
static void EnableSlotAccess(struct s_smc *smc, int slot)
{
	SK_UNUSED(slot) ;

#ifndef AIX
	SK_UNUSED(smc) ;

	/* System mode. */
	outp(POS_SYS_SETUP, POS_SYSTEM) ;

	/* Select slot. */
	outp(POS_CHANNEL_POS, POS_CHANNEL_BIT | (slot-1)) ;
#else
	attach_POS_addr (smc) ;
#endif
}

/* Disable access to MCA slot formerly enabled via EnableSlotAccess(). */
static void DisableSlotAccess(struct s_smc *smc)
{
#ifndef AIX
	SK_UNUSED(smc) ;

	outp(POS_CHANNEL_POS, 0) ;
#else
	detach_POS_addr (smc) ;
#endif
}
#endif	/* MCA */

#ifdef	EISA
#ifndef	MEM_MAPPED_IO
#define	SADDR(slot)	(((slot)<<12)&0xf000)
#else	/* MEM_MAPPED_IO */
#define	SADDR(slot)	(smc->hw.iop)
#endif	/* MEM_MAPPED_IO */

/************************
 *
 * BEGIN_MANUAL_ENTRY()
 *
 *	exist_board
 *
 *	Check if an EISA board is present in the specified slot.
 *
 *	int exist_board(
 *		struct s_smc *smc,
 *		int slot) ;
 * In
 *	smc - A pointer to the SMT Context struct.
 *
 *	slot - The number of the slot to inspect.
 * Out
 *	0 = No adapter present.
 *	1 = Found adapter.
 *
 * Pseudo
 *      Read EISA ID
 *	for all valid OEM_IDs
 *		compare with ID read
 *		if equal, return 1
 *	return(0
 *
 * Note
 *	The smc pointer must be valid now.
 *
 ************************/
int exist_board(struct s_smc *smc, int slot)
{
	int i ;
#ifdef MULT_OEM
	SK_LOC_DECL(u_char,id[4]) ;
#endif	/* MULT_OEM */

	/* No longer valid. */
	if (smc == NULL)
		return(0);

	SK_UNUSED(slot) ;

#ifndef MULT_OEM
	for (i = 0 ; i < 4 ; i++) {
		if (inp(SADDR(slot)+PRA(i)) != OEMID(smc,i))
			return(0) ;
	}
	return(1) ;
#else	/* MULT_OEM */
	for (i = 0 ; i < 4 ; i++)
		id[i] = inp(SADDR(slot)+PRA(i)) ;

	smc->hw.oem_id = (struct s_oem_ids *) &oem_ids[0] ;

	for (; smc->hw.oem_id->oi_status != OI_STAT_LAST; smc->hw.oem_id++) {
		if (smc->hw.oem_id->oi_status < smc->hw.oem_min_status)
			continue ;

		if (is_equal_num(&id[0],&OEMID(smc,0),4))
			return (1) ;
	}
	return (0) ;	/* No adapter found. */
#endif	/* MULT_OEM */
}


int get_board_para(struct s_smc *smc, int slot)
{
	int	i ;

	if (!exist_board(smc,slot))
		return(0) ;

	smc->hw.slot = slot ;
#ifndef	MEM_MAPPED_IO		/* if defined by the operating system */
	smc->hw.iop = SADDR(slot) ;
#endif

	if (!(inp(C0_A(0))&CFG_CARD_EN)) {
		return(2) ;			/* CFG_CARD_EN bit not set! */
	}

	smc->hw.irq = opt_ints[(inp(C1_A(0)) & CFG_IRQ_SEL)] ;
	smc->hw.dma = opt_dmas[((inp(C1_A(0)) & CFG_DRQ_SEL)>>3)] ;

	if ((i = inp(C2_A(0)) & CFG_EPROM_SEL) != 0x0f)
		smc->hw.eprom = opt_eproms[i] ;
	else
		smc->hw.eprom = 0 ;

	smc->hw.DmaWriteExtraBytes = 8 ;

	return(1) ;
}
#endif	/* EISA */

#ifdef	ISA
#ifndef MULT_OEM
const u_char sklogo[6] = SKLOGO_STR ;
#define	SIZE_SKLOGO(smc)	sizeof(sklogo)
#define	SKLOGO(smc,i)		sklogo[i]
#else	/* MULT_OEM */
#define	SIZE_SKLOGO(smc)	smc->hw.oem_id->oi_logo_len
#define	SKLOGO(smc,i)		smc->hw.oem_id->oi_logo[i]
#endif	/* MULT_OEM */


int exist_board(struct s_smc *smc, HW_PTR port)
{
	int	i ;
#ifdef MULT_OEM
	int	bytes_read ;
	u_char	board_logo[15] ;
	SK_LOC_DECL(u_char,id[4]) ;
#endif	/* MULT_OEM */

	/* No longer valid. */
	if (smc == NULL)
		return(0);

	SK_UNUSED(smc) ;
#ifndef MULT_OEM
	for (i = SADDRL ; i < (signed) (SADDRL+SIZE_SKLOGO(smc)) ; i++) {
		if ((u_char)inpw((PRA(i)+port)) != SKLOGO(smc,i-SADDRL)) {
			return(0) ;
		}
	}

	/* check MAC address (S&K or other) */
	for (i = 0 ; i < 3 ; i++) {
		if ((u_char)inpw((PRA(i)+port)) != OEMID(smc,i))
			return(0) ;
	}
	return(1) ;
#else	/* MULT_OEM */
        smc->hw.oem_id = (struct s_oem_ids *)  &oem_ids[0] ;
	board_logo[0] = (u_char)inpw((PRA(SADDRL)+port)) ;
	bytes_read = 1 ;

	for (; smc->hw.oem_id->oi_status != OI_STAT_LAST; smc->hw.oem_id++) {
		if (smc->hw.oem_id->oi_status < smc->hw.oem_min_status)
			continue ;

		/* Test all read bytes with current OEM_entry */
		/* for (i=0; (i<bytes_read) && (i < SIZE_SKLOGO(smc)); i++) { */
		for (i = 0; i < bytes_read; i++) {
			if (board_logo[i] != SKLOGO(smc,i))
				break ;
		}

		/* If mismatch, switch to next OEM entry */
		if ((board_logo[i] != SKLOGO(smc,i)) && (i < bytes_read))
			continue ;

		--i ;
		while (bytes_read < SIZE_SKLOGO(smc)) {
			//   inpw next byte SK_Logo
			i++ ;
			board_logo[i] = (u_char)inpw((PRA(SADDRL+i)+port)) ;
			bytes_read++ ;
			if (board_logo[i] != SKLOGO(smc,i))
				break ;
		}

		for (i = 0 ; i < 3 ; i++)
			id[i] = (u_char)inpw((PRA(i)+port)) ;

		if ((board_logo[i] == SKLOGO(smc,i))
			&& (bytes_read == SIZE_SKLOGO(smc))) {

			if (is_equal_num(&id[0],&OEMID(smc,0),3))
				return(1);
		}
	}	/* for */
	return(0) ;
#endif	/* MULT_OEM */
}

int get_board_para(struct s_smc *smc, int slot)
{
	SK_UNUSED(smc) ;
	SK_UNUSED(slot) ;
	return(0) ;	/* for ISA not supported */
}
#endif	/* ISA */

#ifdef PCI
#ifdef USE_BIOS_FUN
int exist_board(struct s_smc *smc, int slot)
{
	u_short dev_id ;
	u_short ven_id ;
	int found ; 
	int i ;

	found = FALSE ;		/* make sure we returned with adatper not found*/
				/* if an empty oemids.h was included */

#ifdef MULT_OEM
        smc->hw.oem_id = (struct s_oem_ids *) &oem_ids[0] ;
	for (; smc->hw.oem_id->oi_status != OI_STAT_LAST; smc->hw.oem_id++) {
		if (smc->hw.oem_id->oi_status < smc->hw.oem_min_status)
			continue ;
#endif
		ven_id = OEMID(smc,0) + (OEMID(smc,1) << 8) ; 
		dev_id = OEMID(smc,2) + (OEMID(smc,3) << 8) ; 
		for (i = 0; i < slot; i++) {
			if (pci_find_device(i,&smc->hw.pci_handle,
				dev_id,ven_id) != 0) {

				found = FALSE ;
			} else {
				found = TRUE ;
			}
		}
		if (found) {
			return(1) ;	/* adapter was found */
		}
#ifdef MULT_OEM
	}
#endif
	return(0) ;	/* adapter was not found */
}
#endif	/* PCI */
#endif	/* USE_BIOS_FUNC */

void driver_get_bia(struct s_smc *smc, struct fddi_addr *bia_addr)
{
	int i ;

	extern const u_char canonical[256] ;

	for (i = 0 ; i < 6 ; i++) {
		bia_addr->a[i] = canonical[smc->hw.fddi_phys_addr.a[i]] ;
	}
}

void smt_start_watchdog(struct s_smc *smc)
{
	SK_UNUSED(smc) ;	/* Make LINT happy. */

#ifndef	DEBUG

#ifdef	PCI
	if (smc->hw.wdog_used) {
		outpw(ADDR(B2_WDOG_CRTL),TIM_START) ;	/* Start timer. */
	}
#endif

#endif	/* DEBUG */
}

void smt_stop_watchdog(struct s_smc *smc)
{
	SK_UNUSED(smc) ;	/* Make LINT happy. */
#ifndef	DEBUG

#ifdef	PCI
	if (smc->hw.wdog_used) {
		outpw(ADDR(B2_WDOG_CRTL),TIM_STOP) ;	/* Stop timer. */
	}
#endif

#endif	/* DEBUG */
}

#ifdef	PCI
static char get_rom_byte(struct s_smc *smc, u_short addr)
{
	GET_PAGE(addr) ;
	return (READ_PROM(ADDR(B2_FDP))) ;
}

/*
 * ROM image defines
 */
#define	ROM_SIG_1	0
#define ROM_SIG_2	1
#define PCI_DATA_1	0x18
#define PCI_DATA_2	0x19

/*
 * PCI data structure defines
 */
#define	VPD_DATA_1	0x08
#define	VPD_DATA_2	0x09
#define IMAGE_LEN_1	0x10
#define IMAGE_LEN_2	0x11
#define	CODE_TYPE	0x14
#define	INDICATOR	0x15

/*
 *	BEGIN_MANUAL_ENTRY(mac_drv_vpd_read)
 *	mac_drv_vpd_read(smc,buf,size,image)
 *
 * function	DOWNCALL	(FDDIWARE)
 *		reads the VPD data of the FPROM and writes it into the
 *		buffer
 *
 * para	buf	points to the buffer for the VPD data
 *	size	size of the VPD data buffer
 *	image	boot image; code type of the boot image
 *		image = 0	Intel x86, PC-AT compatible
 *			1	OPENBOOT standard for PCI
 *			2-FF	reserved
 *
 * returns	len	number of VPD data bytes read form the FPROM
 *		<0	number of read bytes
 *		>0	error: data invalid
 *
 *	END_MANUAL_ENTRY
 */
int mac_drv_vpd_read(struct s_smc *smc, char *buf, int size, char image)
{
	u_short	ibase ;
	u_short pci_base ;
	u_short vpd ;
	int	len ;

	len = 0 ;
	ibase = 0 ;
	/*
	 * as long images defined
	 */
	while (get_rom_byte(smc,ibase+ROM_SIG_1) == 0x55 &&
		(u_char) get_rom_byte(smc,ibase+ROM_SIG_2) == 0xaa) {
		/*
		 * get the pointer to the PCI data structure
		 */
		pci_base = ibase + get_rom_byte(smc,ibase+PCI_DATA_1) +
				(get_rom_byte(smc,ibase+PCI_DATA_2) << 8) ;

		if (image == get_rom_byte(smc,pci_base+CODE_TYPE)) {
			/*
			 * we have the right image, read the VPD data
			 */
			vpd = ibase + get_rom_byte(smc,pci_base+VPD_DATA_1) +
				(get_rom_byte(smc,pci_base+VPD_DATA_2) << 8) ;
			if (vpd == ibase) {
				break ;		/* no VPD data */
			}
			for (len = 0; len < size; len++,buf++,vpd++) {
				*buf = get_rom_byte(smc,vpd) ;
			}
			break ;
		}
		else {
			/*
			 * try the next image
			 */
			if (get_rom_byte(smc,pci_base+INDICATOR) & 0x80) {
				break ;		/* this was the last image */
			}
			ibase = ibase + get_rom_byte(smc,ibase+IMAGE_LEN_1) +
				(get_rom_byte(smc,ibase+IMAGE_LEN_2) << 8) ;
		}
	}

	return(len) ;
}

void mac_drv_pci_fix(struct s_smc *smc, u_long fix_value)
{
	smc->hw.pci_fix_value = fix_value ;
}

void mac_do_pci_fix(struct s_smc *smc)
{
	SK_UNUSED(smc) ;
}
#endif	/* PCI */