vol.initSocket =		pcInitSocket;    vol.setWindow =		pcSetWindow;    vol.setMappingContext =	pcSetMappingContext;    vol.getAndClearCardChangeIndicator = pcGetAndClearCardChangeIndicator;    vol.writeProtected =	pcWriteProtected;    noOfDrives++;    }/********************************************************************************* pcCardDetected - detect if a card is present (inserted)** This routine detects if a card is present (inserted).** RETURNS: TRUE, or FALSE if the card is not present.*/LOCAL FLBoolean pcCardDetected    (    FLSocket vol		/* pointer identifying drive */    )    {    int	immrVal = vxImmrIsbGet();        if ((*PIPR (immrVal) & 0x18000000) == 0)	return (TRUE);    else	return (FALSE);    }/********************************************************************************* pcVccOn - turn on Vcc (3.3/5 Volts)** This routine turns on Vcc (3.3/5 Volts). Vcc must be known to be good * on exit.** RETURNS: N/A*/LOCAL void pcVccOn    (    FLSocket vol		/* pointer identifying drive */    )    {    *BCSR1 &= ~(BCSR1_PCCARD_VCCON_L);	/* on PC card VCC */    flDelayMsecs (VCC_DELAY_MSEC);	/* wait for Vcc to ramp up */    }/********************************************************************************* pcVccOn - turn off Vcc (3.3/5 Volts)** This routine turns off Vcc (3.3/5 Volts).** RETURNS: N/A*/LOCAL void pcVccOff    (    FLSocket vol		/* pointer identifying drive */    )    {    *BCSR1 |= (BCSR1_PCCARD_VCCON_L);	/* off PC card VCC */    }#ifdef SOCKET_12_VOLTS/********************************************************************************* pcVppOn - turn on Vpp (12 Volts)** This routine turns on Vpp (12 Volts). Vpp must be known to be good on exit.** RETURNS: flOK always*/LOCAL FLStatus pcVppOn    (    FLSocket vol		/* pointer identifying drive */    )    {    *BCSR1 = (*BCSR1 & ~BCSR1_PCCVPP_MSK) | BCSR1_PCCVPP_12V;    flDelayMsecs (VPP_DELAY_MSEC);	/* wait for Vpp to ramp up */    return (flOK);    }/********************************************************************************* pcVppOff - turn off Vpp (12 Volts)** This routine turns off Vpp (12 Volts).** RETURNS: N/A*/LOCAL void pcVppOff    (    FLSocket vol		/* pointer identifying drive */    )    {    *BCSR1 = (*BCSR1 & ~BCSR1_PCCVPP_MSK) | BCSR1_PCCVPP_MSK;    }#endif	/* SOCKET_12_VOLTS *//********************************************************************************* pcInitSocket - perform all necessary initializations of the socket** This routine performs all necessary initializations of the socket.** RETURNS: flOK always*/LOCAL FLStatus pcInitSocket    (    FLSocket vol		/* pointer identifying drive */    )    {    int	immrVal = vxImmrIsbGet();#if	FALSE    printf ("-- pcInitSocket --\n");    printf ("immrVal=0x%x\n", immrVal);    printf ("BR0=0x%x, OR0=0x%x\n", *BR0(immrVal), *OR0(immrVal));    printf ("BR1=0x%x, OR1=0x%x\n", *BR1(immrVal), *OR1(immrVal));    printf ("BR2=0x%x, OR2=0x%x\n", *BR2(immrVal), *OR2(immrVal));    printf ("BR3=0x%x, OR3=0x%x\n", *BR3(immrVal), *OR3(immrVal));    printf ("BR4=0x%x, OR4=0x%x\n", *BR4(immrVal), *OR4(immrVal));    printf ("BR5=0x%x, OR5=0x%x\n", *BR5(immrVal), *OR5(immrVal));    printf ("BR6=0x%x, OR6=0x%x\n", *BR6(immrVal), *OR6(immrVal));    printf ("BR7=0x%x, OR7=0x%x\n", *BR7(immrVal), *OR7(immrVal));#endif	/* FALSE */    *BR4(immrVal) = (PC_BASE_ADRS_1 & BR_BA_MSK) | BR_V;    *OR4(immrVal) = 0xfc000000 | OR_BI | OR_SCY_8_CLK | OR_TRLX | 0x02;    /* clear PCMCIA base registers */    *PBR0 (immrVal) = PC_BASE_ADRS_0;    *PBR1 (immrVal) = PC_BASE_ADRS_1;    *PBR2 (immrVal) = 0x0;    *PBR3 (immrVal) = 0x0;    *PBR4 (immrVal) = 0x0;    *PBR5 (immrVal) = 0x0;    *PBR6 (immrVal) = 0x0;    *PBR7 (immrVal) = 0x0;    /* clear PCMCIA option registers */    *POR0 (immrVal) = 0xf0000000 |		/* bank size:     1MB */		      0x00020000 |		/* strobe hold:   2 clocks */		      0x00001000 |		/* strobe setup:  1 clock */		      0x00000300 |		/* strobe length: 6 clocks */		      0x00000040 |		/* port size:     2 byte */		      0x00000010 |		/* region select: attribute */		      0x00000000 |		/* slot ID:       slot-A */		      0x00000000 |		/* write protect: off */		      0x00000001;		/* PCMCIA valid:  1 */    *POR1 (immrVal) = 0xa8000000 |		/* bank size:     32MB */		      0x00020000 |		/* strobe hold:   2 clocks */		      0x00001000 |		/* strobe setup:  1 clock */		      0x00000300 |		/* strobe length: 6 clocks */		      0x00000040 |		/* port size:     2 byte */		      0x00000000 |		/* region select: common mem */		      0x00000000 |		/* slot ID:       slot-A */		      0x00000000 |		/* write protect: off */		      0x00000001;		/* PCMCIA valid:  1 */    *POR2 (immrVal) = 0x0;    *POR3 (immrVal) = 0x0;    *POR4 (immrVal) = 0x0;    *POR5 (immrVal) = 0x0;    *POR6 (immrVal) = 0x0;    *POR7 (immrVal) = 0x0;    *PSCR (immrVal) = 0x0;    *PGCRA (immrVal) = 0x0;			/* XXX disable interupt */    *PGCRB (immrVal) = 0x0;			/* XXX disable interupt */    *BCSR1 &= ~(BCSR1_PCCARD_EN_L);		/* enable the PCMCIA */    *BCSR1 |= BCSR1_PCCVPP_MSK;			/* setup PC card Vpp to Hi-Z */    *BCSR1 &= ~(BCSR1_PCCARD_VCCON_L);		/* on PC card VCC */    flDelayMsecs (VCC_DELAY_MSEC);		/* wait for Vcc to ramp up */    *PGCRA (immrVal) |= 0x00000040;		/* reset the card A */    flDelayMsecs (10);				/* wait for the reset */    *PGCRA (immrVal) &= ~0x00000040;#if	FALSE    printf ("PIPR=0x%x\n", *PIPR(immrVal));    printf ("PSCR=0x%x\n", *PSCR(immrVal));    printf ("PER=0x%x\n", *PER(immrVal));    printf ("PGCRA=0x%x\n", *PGCRA(immrVal));    printf ("PGCRB=0x%x\n", *PGCRB(immrVal));#endif	/* FALSE */    return (flOK);    }/********************************************************************************* pcSetWindow - set current window attributes, Base address, size, etc** This routine sets current window hardware attributes: Base address, size,* speed and bus width.  The requested settings are given in the 'vol.window' * structure.  If it is not possible to set the window size requested in* 'vol.window.size', the window size should be set to a larger value, * if possible. In any case, 'vol.window.size' should contain the * actual window size (in 4 KB units) on exit.** RETURNS: N/A*/LOCAL void pcSetWindow    (    FLSocket vol		/* pointer identifying drive */    )    {    /* Physical base as a 4K page */    vol.window.baseAddress = PC_BASE_ADRS_1 >> 12;    flSetWindowSize (&vol, PC_BASE_ADRS_1 >> 12);    }/********************************************************************************* pcSetMappingContext - sets the window mapping register to a card address** This routine sets the window mapping register to a card address.* The window should be set to the value of 'vol.window.currentPage',* which is the card address divided by 4 KB. An address over 128MB,* (page over 32K) specifies an attribute-space address.** The page to map is guaranteed to be on a full window-size boundary.** RETURNS: N/A*/LOCAL void pcSetMappingContext    (    FLSocket vol,		/* pointer identifying drive */    unsigned page		/* page to be mapped */    )    {    int	immrVal = vxImmrIsbGet();    if (page & ATTRIBUTE_SPACE_MAPPED)        *POR1 (immrVal) |= 0x00000010;		/* attribute mem */    else        *POR1 (immrVal) &= ~0x00000010;		/* common mem */    }/********************************************************************************* pcGetAndClearCardChangeIndicator - return the hardware card-change indicator** This routine returns the hardware card-change indicator and clears it if set.** RETURNS: FALSE, or TRUE if the card has been changed*/LOCAL FLBoolean pcGetAndClearCardChangeIndicator    (    FLSocket vol		/* pointer identifying drive */    )    {    return (FALSE);    }/********************************************************************************* pcWriteProtected - return the write-protect state of the media** This routine returns the write-protect state of the media** RETURNS: FALSE, or TRUE if the card is write-protected*/LOCAL FLBoolean pcWriteProtected    (    FLSocket vol		/* pointer identifying drive */    )    {    return (FALSE);    }#endif	/* INCLUDE_SOCKET_PCMCIA *//********************************************************************************* flFitInSocketWindow - check whether the flash array fits in the socket window** This routine checks whether the flash array fits in the socket window.** RETURNS: A chip size guaranteed to fit in the socket window.*/long int flFitInSocketWindow     (    long int chipSize,		/* size of single physical chip in bytes */    int      interleaving,	/* flash chip interleaving (1,2,4 etc) */    long int windowSize		/* socket window size in bytes */    )    {    if (chipSize*interleaving > windowSize) /* doesn't fit in socket window */        {        int  roundedSizeBits;        /* fit chip in the socket window */        chipSize = windowSize / interleaving;        /* round chip size at powers of 2 */        for (roundedSizeBits = 0; (0x1L << roundedSizeBits) <= chipSize;             roundedSizeBits++)	    ;        chipSize = (0x1L << (roundedSizeBits - 1));        }    return (chipSize);    }#if	FALSE/********************************************************************************* sysTffsCpy - copy memory from one location to another** This routine copies <size> characters from the object pointed* to by <source> into the object pointed to by <destination>. If copying* takes place between objects that overlap, the behavior is undefined.** INCLUDE FILES: string.h** RETURNS: A pointer to <destination>.** NOMANUAL*/void * sysTffsCpy    (    void *       destination,   /* destination of copy */    const void * source,        /* source of copy */    size_t       size           /* size of memory to copy */    )    {    bcopy ((char *) source, (char *) destination, (size_t) size);    return (destination);    }/********************************************************************************* sysTffsSet - set a block of memory** This routine stores <c> converted to an `unsigned char' in each of the* elements of the array of `unsigned char' beginning at <m>, with size <size>.** INCLUDE FILES: string.h** RETURNS: A pointer to <m>.** NOMANUAL*/void * sysTffsSet    (    void * m,                   /* block of memory */    int    c,                   /* character to store */    size_t size                 /* size of memory */    )    {    bfill ((char *) m, (int) size, c);    return (m);    }#endif	/* FALSE *//********************************************************************************* flDelayMsecs - wait for specified number of milliseconds** This routine waits for specified number of milliseconds.** RETURNS: N/A** NOMANUAL*/void flDelayMsecs    (    unsigned milliseconds       /* milliseconds to wait */    )    {    UINT32 ix;    UINT32 iy = 1;    UINT32 iz = 2;    /* it doesn't count time consumed in interrupt level */    for (ix = 0; ix < milliseconds; ix++)        for (ix = 0; ix < sysTffsMsecLoopCount; ix++)	    {	    tickGet ();			/* dummy */	    iy = KILL_TIME_FUNC;	/* consume time */	    }    }/********************************************************************************* flDelayLoop - consume the specified time** This routine consumes the specified time.** RETURNS: N/A*/void flDelayLoop     (    int  cycles    )    {    while (--cycles)	;    }/********************************************************************************* sysTffsFormat - format the flash memory above an offset** This routine formats the flash memory.  Because this function defines * the symbolic constant, HALF_FORMAT, the lower half of the specified flash * memory is left unformatted.  If the lower half of the flash memory was* previously formated by TrueFFS, and you are trying to format the upper half,* you need to erase the lower half of the flash memory before you format the* upper half.  To do this, you could use:* .CS* tffsRawio(0, 3, 0, 8)  * .CE* The first argument in the tffsRawio() command shown above is the TrueFFS * drive number, 0.  The second argument, 3, is the function number (also * known as TFFS_PHYSICAL_ERASE).  The third argument, 0, specifies the unit * number of the first erase unit you want to erase.  The fourth argument, 8,* specifies how many erase units you want to erase.  ** RETURNS: OK, or ERROR if it fails.*/STATUS sysTffsFormat (void)    {    STATUS status;    tffsDevFormatParams params = 	{#define	HALF_FORMAT	/* lower 0.5MB for bootimage, upper 1.5MB for TFFS */#ifdef	HALF_FORMAT	{0x80000l, 99, 1, 0x10000l, NULL, {0,0,0,0}, NULL, 2, 0, NULL},#else	{0x000000l, 99, 1, 0x10000l, NULL, {0,0,0,0}, NULL, 2, 0, NULL},#endif	/* HALF_FORMAT */	FTL_FORMAT_IF_NEEDED	};    /* we assume that the drive number 0 is SIMM */    status = tffsDevFormat (0, (int)&params);    return (status);    }#endif /*INCLUDE_TFFS */