开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
sysEnd.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：35k
源码类别：

VxWorks

开发平台：

C/C++

sysEnd.c：源码内容
  1. /* sysEnd.c - System Enhanced network interface support library */
  3. /* Copyright 2002 Wind River Systems, Inc. */
  5. #include "copyright_wrs.h"
  7. /*
  8. modification history
  9. --------------------
  10. 01e,05sep02,jb3  Merge in changes from w/ t2.1 ongiong development
  11. 01e,01aug02,jb  Removing Dec device support
  12. 01d,30jul02,jb  Removing debug code
  13. 01c,27jun02,jb  Fix warnings
  14. 01b,18jun02,jb  Changing size calculation to allow veloce driver to work
  15. 01a,05jun02,jb  initial version...
  16. */
  18. /*
  19. DESCRIPTION
  20. This file contains the board-specific routines for Ethernet adapter
  21. initialisation of Intel Pro 100+ based adapters.
  23. NOTE
  24. At the time of writing, this module has only been tested with the following
  25. Ethernet cards:
  26.     82559 controller: Intel PRO/100+ Management Adapter
  27.                       Intel InBusiness 10/100 PCI Network Adapter
  29. Refer to the BSP reference entry for any eventual limitations or
  30. problems related to the BSP.
  33. SEE ALSO: ifLib,
  34. .I "Intel 10/100 MBit Ethernet Family Software technical Reference Manual."
  35. */
  37. #include "vxWorks.h"
  38. #include "config.h"
  39. #include "cacheLib.h"
  41. #include "stdio.h"
  43. #ifdef INCLUDE_END
  44. #include "end.h"
  45. #include "netinet/if_ether.h"
  47. #include "drv/end/fei82557End.h"
  48. #include "ixp425Pci.h"
  51. #ifdef END_DEBUG
  52. #undef LOCAL
  53. #define LOCAL
  54. #endif
  56. /* defines */
  58. #define CSR_BASE_MSK 0x7f /* Mask Base Address Register */
  59. #define END_LD_STR_SIZE 80
  61. /* PCI memory base address register configuration mode */
  63. #define FORCE 0x00 /* overwrite membase address register */
  64. #define AUTO 0x01 /* read membase address register */
  66. /*
  67.  * Need to use automatic configuration mode using the resource assigning in
  68.  * pciAssignResources().
  69.  */
  71. #define PCI_REG_MOD AUTO /* define the register configuration mode */
  73. #define TYPE_ALLOC 1000
  75.     /*Everything tested & works fine with a delay of 1, but set to 3 in 
  76.       order to eliminate the possibility of any timing issues with temp. increase etc*/
  77. #define PCI_CONFIG_DELAY 3 
  78.      
  80. /*
  81.  * FEI cards in range 1001 -> 2000
  82.  */
  84. #define FEI_START TYPE_ALLOC + 1
  86. #define PRO100B FEI_START /* Intel EtherExpress PRO-100B PCI */
  87. #define INBUSINESS FEI_START + 1 /* Intel InBusiness 10/100 PCI */
  89. #define XX82559ER  FEI_START + 100 /* Arbitrary card with 82559ER */
  91. #define BOARD_TYPE_NB (NELEMENTS(boardResources))
  94. #ifdef INCLUDE_FEI82557END
  96. /*the following two are tunable parameters which specify the number of transmit and receive buffers
  97.   to be allocated for use by an fei (82559) driver. These must never be set below 2, otherwise the 
  98.   driver will assume a default of 32, and our calculations of how much memory to allocate for the 
  99.   driver will be in error*/
  100. #define FEI_N_RDFS         32
  101. #define FEI_N_TFDS         32
  102. /*
  103.  * FEI_RFD_MULTIPLIER is the multiplier that is applied to the number of RFDs requested
  104.  * to determine the number of "spares" available for loaning to the network
  105.  * stack. This value (4) was taken from the fei driver source code (its not
  106.  * available in the header, so if this changes in future versions of the driver
  107.  * this will break - if it is increased the driver will complain that we have not
  108.  * given it enough memory, if it is decreased everything will work but we will be 
  109.  * wasting SDRAM.
  110.  */
  111. #define FEI_RFD_MULTIPLIER 4
  112. #define FEI_N_RFD_LOAN     (FEI_N_RDFS * FEI_RFD_MULTIPLIER)
  113. /*
  114.  * Again  FEI_CL_OVERHEAD has been taken from the fei source code (not specified in header),
  115.  * so the caveats for the FEI_RFD_MULTIPLIER apply here too
  116.  */
  117. #define FEI_CL_OVERHEAD    4 /* prepended cluster header */
  119. #define FEI_CL_RFD_SIZE    (RFD_SIZE + FEI_CL_OVERHEAD)
  120. #define FEI_CFD_SIZE       CFD_SIZE
  121. /*This calculation is taken from the fei driver source, again, if this changes, the driver will 
  122.   either complain that it has not been allocated enough memory, or will work fine but we will
  123.   be wasting SDRAM*/
  124. #define FEI_TOTAL_SIZE     ((FEI_N_RDFS * FEI_CL_RFD_SIZE) + 
  125.                            (FEI_N_RFD_LOAN * FEI_CL_RFD_SIZE) + 
  126.                            (FEI_N_TFDS * (FEI_CFD_SIZE +sizeof(long))) + 4)
  128. /* EEPROM control bits */
  130. #define EE_SK           0x01            /* shift clock */
  131. #define EE_CS           0x02            /* chip select */
  132. #define EE_DI           0x04            /* chip data in */
  133. #define EE_DO           0x08            /* chip data out */
  134. #define EE_ENB         (0x4800 | EE_CS)
  135. /* EEPROM opcode */
  137. #define EE_CMD_WRITE    0x05            /* WRITE opcode, 101 */
  138. #define EE_CMD_READ     0x06            /* READ  opcode, 110 */
  139. #define EE_CMD_ERASE    0x07            /* ERASE opcode, 111 */
  141. #define EE_WRITE_0 0x4802
  142. #define EE_WRITE_1 0x4806
  143. /* EEPROM misc. defines */
  145. #define EE_CMD_BITS     3               /* number of opcode bits */
  146. #define EE_ADDR_BITS    6               /* number of address bits */
  147. #define EE_DATA_BITS    16              /* number of data bits */
  148. #define EE_SIZE         0x40            /* 0x40 words */
  149. #define EE_CHECKSUM     0xbaba          /* checksum */
  151. /* PC compatibility macros */
  153. #define FEI_MEMSIZE0            0x00001000
  154. #define FEI_INIT_STATE_MASK   (VM_STATE_MASK_VALID | VM_STATE_MASK_WRITABLE | VM_STATE_MASK_CACHEABLE | VM_STATE_MASK_BUFFERABLE)
  155. #define FEI_INIT_STATE        (VM_STATE_VALID | VM_STATE_WRITABLE | VM_STATE_CACHEABLE_NOT | VM_STATE_BUFFERABLE_NOT)
  156. #define UNKNOWN                 (-1)
  158. /* 82557/9 PCI specific definitions */
  160. /* Intel PRO-100B PCI specific definitions */
  161. #ifndef PRO100B_PCI_VENDOR_ID
  162. #define PRO100B_PCI_VENDOR_ID   0x8086  /* PCI vendor ID */
  163. #define PRO100B_PCI_DEVICE_ID   0x1229  /* PCI device ID */
  164. #endif    /* PRO100B_PCI_VENDOR_ID */
  166. /* Intel InBusiness 10/100 PCI specific definitions */
  167. #ifndef INBUSINESS_PCI_VENDOR_ID
  168. #define INBUSINESS_PCI_VENDOR_ID   PRO100B_PCI_VENDOR_ID  /* PCI vendor ID */
  169. #define INBUSINESS_PCI_DEVICE_ID   0x1030                 /* PCI device ID */
  170. #endif    /* INBUSINESS_PCI_VENDOR_ID */
  172. #define I82559ER_PCI_DEVICE_ID  0x1209
  173. #endif /* INCLUDE_FEI82557END */
  175. /* undef'ed PCI_IO_ADRS_OK here as IXP425 does not properly generate
  176.   read/writes to IO address space, the FEI NIC also maps its IO space to 
  177.   a memory space, and can work without IO transactions
  178. */
  179. #undef PCI_IO_ADRS_OK
  181. /* typedefs */
  183. typedef struct pciResource              /* PCI_RESOURCES */
  184.     {
  185.     UINT32      iobaseCsr;              /* Base Address Register 0 */
  186.     UINT32      membaseCsr;             /* Base Address Register 1 */
  187.     char        irq;                    /* Interrupt Request Level */
  188.     UINT32      irqvec;                 /* Interrupt Request vector */
  189.     UINT32      configType;             /* type of configuration */
  190.     void *      buf;                    /* any allocated buffer space */
  191.     UINT32      cpuToPciOffset;         /* Any offset from CPU to PCI address */
  192.     } PCI_RESOURCES;
  194. typedef struct boardResource /* BOARD_RESOURCES */
  195.     {
  196.     UINT32  type;                   /* type of the board */
  197.     UINT32  vendorId;               /* Vendor ID */
  198.     UINT32  deviceId;               /* Device ID */
  199.     UINT32  decUsrFlags;            /* DEC driver user flags */
  200.     } BOARD_RESOURCES;
  202. #ifdef INCLUDE_FEI82557END
  204. typedef struct feiResource              /* FEI_RESOURCE */
  205.     {
  206.     UINT32      membaseCsr;             /* Base Address Register 0 */
  207.     UINT32      iobaseCsr;              /* Base Address Register 1 */
  208.     UINT32      membaseFlash;           /* Base Address Register 2 */
  209.     char        irq;                    /* Interrupt Request Level */
  210.     UINT32      configType;             /* type of configuration */
  211.     UINT32      boardType;              /* type of LAN board this unit is */
  212.     UINT32      pciBus;                 /* PCI Bus number */
  213.     UINT32      pciDevice;              /* PCI Device number */
  214.     UINT32      pciFunc;                /* PCI Function number */
  215.     UINT16      eeprom[0x40];           /* Ethernet Address of this unit */
  216.     INT32       timeout;                /* timeout for the self-test */
  217.     INT32       str[6];                 /* storage for the self-test result */
  218.     volatile INT32 * pResults;          /* pointer to the self-test result */
  219.     UINT        memLength;              /* required memory size */
  220.     UINT        initialStateMask;       /* mask parameter to vmStateSet */
  221.     UINT        initialState;           /* state parameter to vmStateSet */
  222.     } FEI_RESOURCE;
  224. #endif
  227. /* locals */
  229. /*
  230.  * This array defines the board-specific PCI resources, the base address
  231.  * register configuration mode and the Ethernet adapter type. It's indexed
  232.  * using the device number returned from pciFindDevice().
  233.  *
  234.  * The mode is set as AUTO so this will be erased by the configuration read
  235.  * from the card that is effectively set by pciAssignResources(). See
  236.  * sysLanPciInit() for this.
  237.  */
  239. LOCAL PCI_RESOURCES pciResources [IXP425_PCI_MAX_DEV] =
  240.     {
  241.     {PCI_IO_ADR0, PCI_MEM_ADR0, PCI_INT_LVL0, PCI_INT_VEC0, PCI_REG_MOD, 0, 0},
  242.     {PCI_IO_ADR1, PCI_MEM_ADR1, PCI_INT_LVL1, PCI_INT_VEC1, PCI_REG_MOD, 0, 0},
  243.     {PCI_IO_ADR2, PCI_MEM_ADR2, PCI_INT_LVL2, PCI_INT_VEC2, PCI_REG_MOD, 0, 0},
  244.     {PCI_IO_ADR3, PCI_MEM_ADR3, PCI_INT_LVL3, PCI_INT_VEC3, PCI_REG_MOD, 0, 0}
  245.     };
  247. /*
  248.  * This array defines board-specific vendor and device ids, flags to pass to
  249.  * the drive load routine and the function used to select the media.
  250.  */
  252. LOCAL BOARD_RESOURCES boardResources [] =
  253.     {
  254. #ifdef INCLUDE_FEI82557END
  256.     {PRO100B, PRO100B_PCI_VENDOR_ID, PRO100B_PCI_DEVICE_ID, 0},
  257.     {INBUSINESS, INBUSINESS_PCI_VENDOR_ID, INBUSINESS_PCI_DEVICE_ID, 0},
  259.     {XX82559ER, PRO100B_PCI_VENDOR_ID, I82559ER_PCI_DEVICE_ID, 0},
  261. #endif /* INCLUDE_FEI82557END */
  262.     };
  264. /* END load strings */
  266. LOCAL char endLoadStr[IXP425_PCI_MAX_DEV][END_LD_STR_SIZE];
  268. /* Index of devices */
  270. LOCAL int       currentEndDevice        = 0;
  273. #ifdef INCLUDE_FEI82557END
  275. LOCAL UINT32 feiUnits;                  /* number of FEIs we found */
  277. LOCAL FEI_RESOURCE feiResources [IXP425_PCI_MAX_DEV] =
  278.     {
  279.     {UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN,
  280.      UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, {UNKNOWN}, UNKNOWN,
  281.      {UNKNOWN}, NULL, FEI_MEMSIZE0, FEI_INIT_STATE_MASK, FEI_INIT_STATE},
  283.     {UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN,
  284.      UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, {UNKNOWN}, UNKNOWN,
  285.      {UNKNOWN}, NULL, FEI_MEMSIZE0, FEI_INIT_STATE_MASK, FEI_INIT_STATE},
  287.     {UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN,
  288.      UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, {UNKNOWN}, UNKNOWN,
  289.      {UNKNOWN}, NULL, FEI_MEMSIZE0, FEI_INIT_STATE_MASK, FEI_INIT_STATE},
  291.     {UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN,
  292.      UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, {UNKNOWN}, UNKNOWN,
  293.      {UNKNOWN}, NULL, FEI_MEMSIZE0, FEI_INIT_STATE_MASK, FEI_INIT_STATE}
  294.     };
  296. LOCAL const char * phys[] =
  297.     {
  298.     "None", "i82553-A/B", "i82553-C", "i82503",
  299.     "DP83840", "80c240", "80c24", "i82555",
  300.     "unknown-8", "unknown-9", "DP83840A", "unknown-11",
  301.     "unknown-12", "unknown-13", "unknown-14", "unknown-15"
  302.     };
  304. enum phy_chips
  305.     {
  306.     NonSuchPhy=0, I82553AB, I82553C, I82503,
  307.     DP83840, S80C240, S80C24, I82555, DP83840A=10, UndefinedPhy
  308.     };
  310. LOCAL const char *connectors[] = {" RJ45", " BNC", " AUI", " MII"};
  312. #endif /* INCLUDE_FEI82557END */
  314. /* imports */
  316. /* End device table - should be IXP425_PCI_MAX_DEV+1 entries */
  318. IMPORT END_TBL_ENTRY endDevTbl[];
  320. #ifdef INCLUDE_FEI82557END
  322. /* FEI specific imports */
  324. IMPORT FUNCPTR  feiEndIntConnect;
  325. IMPORT FUNCPTR  feiEndIntDisconnect;
  326. IMPORT END_OBJ* fei82557EndLoad (char *, void *);
  327. IMPORT void sysFlashBoardDelay (void);
  328. /*extern void sysDelay(void);*/
  329. extern void sysMicroDelay(int microseconds);
  330. /* forward declarations */
  332. LOCAL UINT16    sys557eepromRead (int unit, int location);
  333. LOCAL UINT32    sys557mdioRead   (int unit, int phyId, int location);
  334. LOCAL UINT32    sys557mdioWrite  (int unit, int phyId, int location, int value);
  335. LOCAL int       sys557IntEnable  (int unit);
  336. LOCAL int       sys557IntDisable (int unit);
  337. LOCAL int       sys557IntAck     (int unit);
  338. UINT32 sys557EndPhysToPci ( int unit, UINT32 PhysAddr);
  339. UINT32 sys557EndPciToPhys ( int unit, UINT32 PhysAddr);
  341. #endif /* INCLUDE_FEI82557END */
  343. #define SWAP16(x) ((((x) << 8) | ((x) >> 8)) & 0xFFFF)
  344. #define SWAP32(x)               
  345.   (((x) << 24) |                
  346.   (((x) & 0x0000FF00) << 8) |   
  347.   (((x) & 0x00FF0000) >> 8) |   
  348.   (((unsigned int)(x)) >> 24))
  351. #ifdef PCI_IO_ADRS_OK
  352. #define sysPciOutWord(addr,data)   PCI_OUT_WORD((void*)(addr-IXP425_PHYS_PCI_IO_BASE),data)
  353. #define sysPciOutLong(addr,data)   PCI_OUT_LONG((void*)(addr-IXP425_PHYS_PCI_IO_BASE),data)
  354. #else
  355. #ifdef IXP425_PCI_ENABLE_BYTE_ROUTING
  356. #define sysPciOutWord(addr,data)   *(volatile UINT16*)((addr)) = SWAP16((UINT16)data)
  357. #define sysPciOutLong(addr,data)   *(volatile UINT32*)((addr)) = SWAP32((UINT32)data)
  358. #else
  359. #define sysPciOutWord(addr,data)   *((volatile UINT16*)((addr) & ~3)) = (UINT16)data
  360. #define sysPciOutLong(addr,data)   *(volatile UINT32*)((addr)) = (UINT32)data
  361. #endif
  362. #endif /*PCI_IO_ADRS_OK*/
  364. /*because we do not return read values as return codes in our
  365.   pci IO config library, we must define these as functions, not macros*/
  366. UINT16 sysInWord(ULONG addr)
  367. {
  368. #ifdef PCI_IO_ADRS_OK
  369.     UINT16 retval;
  370.     pciIOInWord((void*)(addr-IXP425_PHYS_PCI_IO_BASE), &retval);
  371.     return retval;
  372. #else
  374.     UINT32 val;
  375.     UINT16 retval;
  376.     if (addr & 3)
  377.     {
  378. addr=addr & ~3; /*round down to 32 bit align*/
  379. val = *((UINT32*)addr);
  380. #ifdef IXP425_PCI_ENABLE_BYTE_ROUTING
  381. val = SWAP32(val); 
  382. #endif
  383. retval = val >> 16;
  384. return retval;
  385.     }
  386.     else
  387.     {
  388. return *((UINT16*)addr);
  389.     }
  391. #endif /*PCI_IO_ADRS_OK*/
  392. }
  394. ULONG sysInLong(ULONG addr)
  395. {
  396. #ifdef PCI_IO_ADRS_OK
  397.     ULONG retval;
  398.     pciIOInLong((void*)(addr-IXP425_PHYS_PCI_IO_BASE), &retval);
  399.     return retval;
  400. #else
  401. #ifdef IXP425_PCI_ENABLE_BYTE_ROUTING
  402.     return SWAP32(*((ULONG*)addr));
  403. #else
  404.     return *((ULONG*)addr);
  405. #endif
  406. #endif
  407. }
  411. /*******************************************************************************
  412. *
  413. * sysLanPciInit - prepare LAN adapter for initialization
  414. *
  415. * This routine find out the PCI device, and map its memory and I/O address.
  416. * It will understand both DEC21x4x and FEI type cards.
  417. *
  418. * RETURNS: N/A
  419. */
  421. STATUS sysLanPciInit (void)
  422. {
  423.     PciDevice *         pDev;           /* Pci resources */
  424.     PCI_RESOURCES * pRsrc; /* dec resource */
  425.     UINT32 pciBus; /* PCI Bus number */
  426.     UINT32 pciDevice = 0; /* PCI Device number */
  427.     UINT32 pciFunc; /* PCI Function number */
  428.     unsigned int ix; /* counter */
  429.     int iy; /* counter */
  430.     int unit = 0; /* unit numbers */
  431.     UINT32 boardType = NONE; /* board type detected */
  432. #ifdef INCLUDE_FEI82557END
  433.     FEI_RESOURCE *      pFeiRes;        /* FEI specific info */
  434. #ifndef  IXP425_PCI_SIMPLE_MAPPING
  435.     void* feiMemBase=NULL;
  436. #endif
  437. #endif
  439.     /* Setup Interrupt Pointers */
  440.     feiEndIntConnect = (FUNCPTR) pciIntConnect;
  441.     feiEndIntDisconnect = (FUNCPTR) pciIntDisconnect;
  444.     /* Find the first empty entry in the endDevTable*/
  445.     while(endDevTbl[currentEndDevice].endLoadFunc != END_TBL_END)
  446.     {
  447. currentEndDevice++;
  448.     }
  450.     /*
  451.      * The following code tries to automatically detect and configure
  452.      * all instances of supported Ethernet cards.
  453.      */
  455.     for (ix = 0; ix < BOARD_TYPE_NB; ix++)
  456.         {
  457.         for (iy = 0; iy < IXP425_PCI_MAX_DEV; iy++)
  458.             {
  459.             if( (pDev = pciDeviceGet(boardResources[ix].vendorId,
  460.                    boardResources[ix].deviceId, iy) ) == NULL)
  461.                 break; /* skip to next vendor/product pair */
  463.             if( pDev->error == TRUE )
  464.                 {
  465.                 break;  /* Something wrong here */
  466.                 }
  468.             /* board detected */
  469.             boardType = boardResources[ix].type;
  470.             pciBus = pDev->bus;
  471.             pciDevice = pDev->device;
  472.             pciFunc = pDev->func;
  474.             /*
  475.              * Update the END device table
  476.              *
  477.              * pciDevice for PCI cards plugged in is in the range 5 to 8.
  478.              */
  479.             pRsrc = &(pciResources[pciDevice]);
  481.             /* We only do Auto Configuration */
  482.             /* get memory base address and I/O base address */
  484. #ifdef INCLUDE_FEI82557END
  486.             if ((boardType >= FEI_START) &&
  487.                  (boardType < (FEI_START + TYPE_ALLOC)))
  488.                 {
  489.                 pFeiRes = &feiResources [unit];
  491.                 pFeiRes->pciBus    = pciBus;
  492.                 pFeiRes->pciDevice = pciDevice;
  493.                 pFeiRes->pciFunc   = pciFunc;
  495.                 pFeiRes->membaseCsr = pDev->bar[0].address;
  497.                 /* Convert to CPU address */
  498.                 pFeiRes->membaseCsr += CPU_PCI_MEM_ADRS;
  500. #ifdef PCI_IO_ADRS_OK
  501.                 pFeiRes->iobaseCsr = pDev->bar[1].address;
  502.                 pFeiRes->iobaseCsr &= ~PCI_BASE_IO;
  503.                 pFeiRes->iobaseCsr += CPU_PCI_IO_ADRS;
  504. #else
  505.                 pFeiRes->iobaseCsr = pFeiRes->membaseCsr;
  506. #endif
  508.                 pFeiRes->membaseFlash = pDev->bar[2].address;
  510.                 pFeiRes->membaseFlash += CPU_PCI_MEM_ADRS;
  512.                 pFeiRes->irq = pDev->irq;
  513.  
  514.                 pFeiRes->configType = boardType;
  516.                 }
  517. #endif /* INCLUDE_FEI82557END */
  519.             /*
  520.              * Update the END device table & dynamically create the load
  521.              * string we need for this device
  522.              */
  524. #ifdef INCLUDE_FEI82557END
  525.             if ((boardType >= FEI_START) &&
  526.                 (boardType < (FEI_START + TYPE_ALLOC)))
  527.                 {
  528.                 pRsrc->buf = (void *)NONE;
  531. #ifndef  IXP425_PCI_SIMPLE_MAPPING
  532. /*allocate memory for FEI END device*/
  533. feiMemBase = cacheDmaMalloc(FEI_TOTAL_SIZE);
  534. if (feiMemBase == NULL)
  535. {
  536.     return ERROR;
  537. }
  539.                 sprintf (endLoadStr[currentEndDevice],
  540.                         "0x%x:0x%x:0x%x:0x%x:0x00:2", (UINT32)feiMemBase
  541. , (UINT32)FEI_TOTAL_SIZE, (UINT32)FEI_N_TFDS, (UINT32)FEI_N_RDFS);
  542. /* set up BAR in PCI controller so that the PCI device can access
  543.    the memory that has just been set up for it*/
  544. if(sysPciMappingAdd((UINT32)feiMemBase, FEI_TOTAL_SIZE)!=OK)
  545. {
  546.     printf("sysPciMappingAdd failed in sysLanPciInitn");
  547.     return ERROR;
  548. }
  549. #else
  550.                 sprintf (endLoadStr[currentEndDevice],
  551.                         "-1:0x00:0x20:0x20:0x00:2");
  552. #endif 
  554.                 endDevTbl[currentEndDevice].unit = unit++;
  555.                 endDevTbl[currentEndDevice].endLoadFunc = fei82557EndLoad;
  556.                 endDevTbl[currentEndDevice].endLoadString =
  557.                                                 endLoadStr[currentEndDevice];
  558.                 endDevTbl[currentEndDevice].endLoan = 1;
  559.                 currentEndDevice++;
  561.                 /* enable mapped I/O addresses */
  563.                 pciConfigOutWord (pciBus, pciDevice, pciFunc,
  564.                           PCI_CFG_COMMAND, PCI_CMD_IO_ENABLE | PCI_CMD_MEM_ENABLE |
  565.                           PCI_CMD_MASTER_ENABLE);
  566.                 feiUnits++;
  567.                 }
  568. #endif /* INCLUDE_FEI82557END */
  570.             }
  571.         }
  573.     return OK;
  574.     }
  576. #ifdef INCLUDE_FEI82557END
  578. /*******************************************************************************
  579. *
  580. * sys557Init - prepare LAN adapter for 82557 initialization
  581. *
  582. * This routine is expected to perform any adapter-specific or target-specific
  583. * initialization that must be done prior to initializing the 82557.
  584. *
  585. * The 82557 driver calls this routine from the driver attach routine before
  586. * any other routines in this library.
  587. *
  588. * This routine returns the interrupt level the <pIntLvl> parameter.
  589. *
  590. * RETURNS: OK or ERROR if the adapter could not be prepared for initialization.
  591. */
  593. STATUS sys557Init
  594.     (
  595.     int unit, /* unit number */
  596.     FEI_BOARD_INFO * pBoard     /* board information for the end driver */
  597.     )
  598. {
  599.     volatile FEI_RESOURCE * pReso = &feiResources [unit];
  600.     UINT16 sum          = 0;
  601.     int ix;
  602.     int iy;
  603.     UINT16 value;
  604.     void * testbuf = 0; /* keep compiler quiet */
  605. #ifdef PCI_END_DEBUG
  606.     int errors;
  607.     UINT32 testrepeat = 1000;
  608. #endif
  609.     /*
  610.      * Locate the 82557 based adapter - PRO100B, INBUSINESS and XXX.
  611.      * Note that since the INBUSINESS adapter is based upon the PRO100B
  612.      * board type, it is initialised and driven like one.
  613.      */
  614.     
  615.     if (pReso->boardType != UNKNOWN) /* only setup once */
  616. {
  617. }
  618.     else
  619. {
  620. /* read the configuration in EEPROM */
  622. #ifdef PCI_END_DEBUG
  623.     printf("RFD_SIZE = 0x%xn",RFD_SIZE);
  624.     printf("CFD_SIZE    = 0x%xn",CFD_SIZE); 
  625.     printf("TOTAL FEI STORAGE: 0x%xn",FEI_TOTAL_SIZE);
  627.     errors=0;
  628.     for(ix=0;ix<testrepeat; ix++)
  629.     {
  630. value = sys557eepromRead (unit, 0);
  631. if(value != 0x0200)
  632. {
  633.     errors++;
  634. }
  636.     }
  637.     printf("Test of eeprom read resulted in %d errors from %d readsn",errors,testrepeat);
  638. #endif
  639.     for (ix = 0; ix < EE_SIZE; ix++)
  640.     {
  641.     value = sys557eepromRead (unit, ix);
  642.     pReso->eeprom[ix] = value;         
  643.     sum += value;
  644. #ifdef PCI_END_DEBUG
  645.     printf("%4.4x ", value);
  646.     if(ix % 4 ==0)
  647.     {
  648. printf("n");
  649.     }
  650. #endif
  651.     }
  652.   
  653. if (sum != EE_CHECKSUM)
  654. {
  655.             printf ("nfei%d: Invalid EEPROM checksum %#4.4xn", unit, sum);
  656. }
  660. /* DP83840 specific setup */
  662. if (((pReso->eeprom[6]>>8) & 0x3f) == DP83840)
  663.     {
  664.     int reg23 = sys557mdioRead (unit, pReso->eeprom[6] & 0x1f, 23);
  665.     sys557mdioWrite (unit, pReso->eeprom[6] & 0x1f, 23, reg23 | 0x0420);
  666.     }
  668. /* perform a system self-test. */
  670.         pReso->timeout = 16000; /* Timeout for self-test. */
  672. /*
  673.  * No specific area specified, so we assume that cacheDmaMalloc() will
  674.  * return a pointer to a suitable area. If the data cache is on,
  675.  * this will be page-aligned, but if the data cache is off, then we
  676.  * will just get whatever malloc returns.
  677.  */
  679. if (testbuf = cacheDmaMalloc (32), testbuf == 0)
  680.     {
  681.     printf("fei%d cacheDmaMalloc failedn", unit);
  682.     return ERROR;
  683.     }
  684. pReso->pResults = (volatile INT32 *)testbuf;
  687. /* The chip requires the results buffer to be 16-byte aligned. */
  689.         pReso->pResults    = (volatile INT32 *)
  690.      ((((int) pReso->pResults) + 0xf) & ~0xf);
  692. /* initialise results buffer */
  694. pReso->pResults[0] = 0;
  695. pReso->pResults[1] = -1;
  697. /* Issue the self-test command */
  698. if(sysPhysToPci((void*)pReso->pResults) == NULL)
  699. {
  700.     printf("pReso->pResults does not reside in an area that the PCI devices can accessn");
  701. }
  702. /*reset the chip*/
  703. sysPciOutLong (pReso->iobaseCsr + 0x8, 0x0);
  704. sysDelay();
  705. /*perform self test*/
  706. sysPciOutLong (pReso->iobaseCsr + 0x8, sysPhysToPci((void*)pReso->pResults) | 1);
  707. #ifdef PCI_END_DEBUG
  708. printf("Asked the PCI NIC to write result of self test to PCI ADDR:0x%xn",(UINT32)sysPhysToPci((void*)pReso->pResults));
  709. printf("AHB address of results: 0x%xn", (UINT32)pReso->pResults);
  710. #endif
  711. /* wait for results */
  712. do
  713.     {
  714.     sysDelay(); /* cause a delay of at least an I/O cycle */
  715.     }
  716. while ((pReso->pResults[1] == -1) && (--pReso->timeout >= 0));
  718. if (pReso->timeout < 0)
  719.         { /* Test optimized out. */
  720.     printf ("Self test failed, status %8.8x:n"
  721.     " Failure to initialize the 82557.n"
  722.     " Verify that the card is a bus-master capable slot.n",
  723.     pReso->pResults[1]);
  724. }
  725. else
  726.         {
  727. #ifdef PCI_END_DEBUG
  728.     printf ("General self-test: %s.n"
  729.     " Serial sub-system self-test: %s.n"
  730.     " Internal registers self-test: %s.n"
  731.     " ROM checksum self-test: %s (%#8.8x).n",
  732.     pReso->pResults[1] & 0x1000 ? "failed" : "passed",
  733.     pReso->pResults[1] & 0x0020 ? "failed" : "passed",
  734.     pReso->pResults[1] & 0x0008 ? "failed" : "passed",
  735.     pReso->pResults[1] & 0x0004 ? "failed" : "passed",
  736.     pReso->pResults[0]);
  737. #endif
  738.         }
  739.         pReso->boardType = PRO100B; /* note that it is now initialised */
  741.         /* Save results so we can refer to them again later */
  743.         pReso->str[0] = pReso->pResults[0];
  744.         pReso->str[1] = pReso->pResults[1];
  746.         cacheDmaFree (testbuf);
  748.         pReso->pResults = pReso->str;
  750. }
  751.     /* initialise the board information structure */
  753.     pBoard->vector   = IVEC_TO_INUM(pReso->irq);
  754.     pBoard->baseAddr   = pReso->iobaseCsr;
  755.     for (ix = 0, iy = 0; ix < 3; ix++)
  756. {
  757. pBoard->enetAddr[iy++] = pReso->eeprom[ix] & 0xff;
  758. pBoard->enetAddr[iy++] = (pReso->eeprom[ix] >> 8) & 0xff;
  759. }
  760.     pBoard->intEnable   = sys557IntEnable;
  761.     pBoard->intDisable   = sys557IntDisable;
  762.     pBoard->intAck   = sys557IntAck;
  764.     /* install address conversion routines for driver
  765.      The fei driver needs these to figure out what addresses it needs to 
  766.     tell the nic to write to (PCI addresses) in order to access the appropriate
  767.     areas of the AHB*/
  769.     pBoard->sysLocalToBus = sys557EndPhysToPci;
  770.     pBoard->sysBusToLocal = sys557EndPciToPhys;
  772. #ifdef FEI_10MB
  773.     pBoard->phySpeed   = NULL;
  774.     pBoard->phyDpx   = NULL;
  775. #endif
  777.     intEnable (pReso->irq);
  779.     return (OK);
  780.     }
  782. /*******************************************************************************
  783. *
  784. * sys557IntAck - acknowledge an 82557 interrupt
  785. *
  786. * This routine performs any 82557 interrupt acknowledge that may be
  787. * required.  This typically involves an operation to some interrupt
  788. * control hardware.
  789. *
  790. * This routine gets called from the 82557 driver's interrupt handler.
  791. *
  792. * This routine assumes that the PCI configuration information has already
  793. * been setup.
  794. *
  795. * RETURNS: OK, or ERROR if the interrupt could not be acknowledged.
  796. */
  798. LOCAL STATUS sys557IntAck
  799.     (
  800.     int unit /* unit number */
  801.     )
  802. {
  803.     FEI_RESOURCE * pReso = &feiResources [unit];
  805.     switch (pReso->boardType)
  806. {
  807. case PRO100B: /* handle PRO100B LAN Adapter */
  808.         case INBUSINESS:
  809.         case XX82559ER:
  810.     /* no addition work necessary for the PRO100B */
  811.     break;
  813. default:
  814.     return (ERROR);
  815. }
  817.     return (OK);
  818.     }
  820. /*******************************************************************************
  821. *
  822. * sys557IntEnable - enable 82557 interrupts
  823. *
  824. * This routine enables 82557 interrupts.  This may involve operations on
  825. * interrupt control hardware.
  826. *
  827. * The 82557 driver calls this routine throughout normal operation to terminate
  828. * critical sections of code.
  829. *
  830. * This routine assumes that the PCI configuration information has already
  831. * been setup.
  832. *
  833. * RETURNS: OK, or ERROR if interrupts could not be enabled.
  834. */
  836. LOCAL STATUS sys557IntEnable
  837.     (
  838.     int unit /* unit number */
  839.     )
  840. {
  841.     FEI_RESOURCE * pReso = &feiResources [unit];
  843.     switch (pReso->boardType)
  844. {
  845. case PRO100B: /* handle PRO100B LAN Adapter */
  846.         case INBUSINESS:
  847.         case XX82559ER:
  848.             intEnable (pReso->irq);
  849.     break;
  851. default:
  852.     return (ERROR);
  853. }
  855.     return (OK);
  856.     }
  858. /*******************************************************************************
  859. *
  860. * sys557IntDisable - disable 82557 interrupts
  861. *
  862. * This routine disables 82557 interrupts.  This may involve operations on
  863. * interrupt control hardware.
  864. *
  865. * The 82557 driver calls this routine throughout normal operation to enter
  866. * critical sections of code.
  867. *
  868. * This routine assumes that the PCI configuration information has already
  869. * been setup.
  870. *
  871. * RETURNS: OK, or ERROR if interrupts could not be disabled.
  872. */
  874. LOCAL STATUS sys557IntDisable
  875.     (
  876.     int unit /* unit number */
  877.     )
  878. {
  879.     FEI_RESOURCE * pReso = &feiResources [unit];
  881.     switch (pReso->boardType)
  882. {
  883. case PRO100B: /* handle PRO100B LAN Adapter */
  884.         case INBUSINESS:
  885.         case XX82559ER:
  886.             intDisable (pReso->irq); 
  887.     break;
  889. default:
  890.     return (ERROR);
  891. }
  893.     return (OK);
  894.     }
  896. /*******************************************************************************
  897. *
  898. * sys557eepromRead - read a word from the 82557 EEPROM
  899. *
  900. * RETURNS: the EEPROM data word read in.
  901. */
  903. LOCAL UINT16 sys557eepromRead
  904.     (
  905.     int unit, /* unit number */
  906.     int location /* address of word to be read */
  907.     )
  908. {
  909.     UINT32 iobase = feiResources[unit].iobaseCsr;
  910.     UINT16 retval = 0;
  911.     UINT16 dataval;
  913.     UINT32 eeaddr = iobase + SCB_EEPROM;
  914.     int cmdlen = 27;
  915.     int readcmd = EE_CMD_READ << 22;
  917.     readcmd = readcmd | (location << 16);
  919.     /*Enable EEPROM*/
  920.     sysPciOutWord(eeaddr, EE_ENB | EE_SK);
  921.     
  922.     do
  923.     {
  924. dataval = (readcmd & (1 << cmdlen)) ?  EE_WRITE_1 : EE_WRITE_0;
  925. sysPciOutWord(eeaddr, dataval);
  926. sysDelay();
  927. sysPciOutWord(eeaddr, dataval | EE_SK);
  928. sysDelay();
  929. dataval=sysInWord(eeaddr);
  930. retval = (retval << 1) | ((dataval & EE_DO) ? 1 : 0);
  931.  
  932.     } while(cmdlen-- > 0);
  934.     sysPciOutWord(eeaddr, EE_ENB);
  936.     sysPciOutWord(eeaddr, EE_ENB & ~EE_CS);
  937.     return retval;
  939.     
  941. #if 0
  942.     sysPciOutWord (iobase + SCB_EEPROM, EE_CS); /* enable EEPROM */
  944.     /* write the READ opcode */
  946.     for (ix = EE_CMD_BITS - 1; ix >= 0; ix--)
  947. {
  948.         dataval = (EE_CMD_READ & (1 << ix)) ? EE_DI : 0;
  949.         sysPciOutWord (iobase + SCB_EEPROM, EE_CS | dataval);
  950.         sysDelay (); /* delay for one I/O READ cycle */
  951.         sysPciOutWord (iobase + SCB_EEPROM, EE_CS | dataval | EE_SK);
  952.         sysDelay (); /* delay for one I/O READ cycle */
  953.         sysPciOutWord (iobase + SCB_EEPROM, EE_CS | dataval);
  954.         sysDelay (); /* delay for one I/O READ cycle */
  955.         }
  957.     /* write the location */
  959.     for (ix = EE_ADDR_BITS - 1; ix >= 0; ix--)
  960. {
  961.         dataval = (location & (1 << ix)) ? EE_DI : 0;
  962.         sysPciOutWord (iobase + SCB_EEPROM, EE_CS | dataval);
  963.         sysDelay (); /* delay for one I/O READ cycle */
  964.         sysPciOutWord (iobase + SCB_EEPROM, EE_CS | dataval | EE_SK);
  965.         sysDelay (); /* delay for one I/O READ cycle */
  966.         sysPciOutWord (iobase + SCB_EEPROM, EE_CS | dataval);
  967.         sysDelay (); /* delay for one I/O READ cycle */
  968. dummy = sysInWord (iobase + SCB_EEPROM);
  969.         }
  971.     if ((dummy & EE_DO) == 0) /* dummy read */
  972. ;
  974.     /* read the data */
  976.     for (ix = EE_DATA_BITS - 1; ix >= 0; ix--)
  977. {
  978.         sysPciOutWord (iobase + SCB_EEPROM, EE_CS | EE_SK);
  979.         sysDelay (); /* delay for one I/O READ cycle */
  980.         retval = (retval << 1) |
  981.          ((sysInWord (iobase + SCB_EEPROM) & EE_DO) ? 1 : 0);
  982.         sysPciOutWord (iobase + SCB_EEPROM, EE_CS);
  983.         sysDelay (); /* delay for one I/O READ cycle */
  984.         }
  986.     sysPciOutWord (iobase + SCB_EEPROM, 0x00); /* disable EEPROM */
  988.     return (retval);
  989. #endif
  990.     }
  992. /*******************************************************************************
  993. *
  994. * sys557mdioRead - read MDIO
  995. *
  996. * RETURNS: read value
  997. */
  999. LOCAL UINT32 sys557mdioRead
  1000.     (
  1001.     int unit, /* unit number */
  1002.     int phyId, /* PHY ID */
  1003.     int location /* location to read */
  1004.     )
  1005. {
  1006.     UINT32 iobase = feiResources[unit].iobaseCsr;
  1007.     int timeout   = 64*4; /* <64 usec. to complete, typ 27 ticks */
  1008.     int val;
  1010.     sysPciOutLong (iobase + SCB_MDI, 0x08000000 | (location<<16) | (phyId<<21));
  1011.     do  {
  1012.         sysDelay (); /* delay for one I/O READ cycle */
  1013.         val = sysInLong (iobase + SCB_MDI);
  1014.         if (--timeout < 0)
  1015.             printf ("sys557mdioRead() timed out with val = %8.8x.n", val);
  1016.         } while (! (val & 0x10000000));
  1018.     return (val & 0xffff);
  1019.     }
  1021. /*******************************************************************************
  1022. *
  1023. * sys557mdioWrite - write MDIO
  1024. *
  1025. * RETURNS: write value
  1026. */
  1028. LOCAL UINT32 sys557mdioWrite
  1029.     (
  1030.     int unit, /* unit number */
  1031.     int phyId, /* PHY ID */
  1032.     int location, /* location to write */
  1033.     int value /* value to write */
  1034.     )
  1035. {
  1036.     UINT32 iobase = feiResources[unit].iobaseCsr;
  1037.     int timeout   = 64*4; /* <64 usec. to complete, typ 27 ticks */
  1038.     int val;
  1040.     sysPciOutLong (iobase + SCB_MDI,
  1041. 0x04000000 | (location<<16) | (phyId<<21) | value);
  1042.     do  {
  1043.         sysDelay (); /* delay for one I/O READ cycle */
  1044.         val = sysInLong (iobase + SCB_MDI);
  1045.         if (--timeout < 0)
  1046.             printf ("sys557mdioWrite() timed out with val = %8.8x.n", val);
  1047.         } while (! (val & 0x10000000));
  1049.     return (val & 0xffff);
  1050.     }
  1052. /*******************************************************************************
  1053. *
  1054. * sys557Show - shows 82557 configuration
  1055. *
  1056. * This routine shows the (Intel Pro Express 100) configuration
  1057. *
  1058. * RETURNS: N/A
  1059. */
  1061. void sys557Show
  1062.     (
  1063.     int unit /* unit number */
  1064.     )
  1065. {
  1066.     FEI_RESOURCE * pReso = &feiResources [unit];
  1067.     UINT32 iobase       = pReso->iobaseCsr;
  1068.     UCHAR etheraddr[6];
  1069.     int ix;
  1070.     int iy;
  1072.     if (unit > IXP425_PCI_MAX_DEV)
  1073. {
  1074. printf ("Illegal unit number %dn", unit);
  1075. return;
  1076. }
  1078.     if (pReso->boardType == UNKNOWN)
  1079. {
  1080. printf ("Unit %d not an FEI devicen", unit);
  1081. return;
  1082. }
  1084.     for (ix = 0, iy = 0; ix < 3; ix++)
  1085. {
  1086.         etheraddr[iy++] = pReso->eeprom[ix];
  1087.         etheraddr[iy++] = pReso->eeprom[ix] >> 8;
  1088.         }
  1089.     printf ("fei%d: Intel EtherExpress Pro 10/100 at %#8x ", unit, iobase);
  1090.     for (ix = 0; ix < 5; ix++)
  1091.      printf ("%2.2X:", etheraddr[ix]);
  1092.     printf ("%2.2Xn", etheraddr[ix]);
  1094.     printf ("CSR mem base address = %x, Flash mem base address = %xn",
  1095.     pReso->membaseCsr, pReso->membaseFlash);
  1097.     if (pReso->eeprom[3] & 0x03)
  1098.         printf ("Receiver lock-up bug exists -- enabling work-around.n");
  1100.     printf ("Board assembly %4.4x%2.2x-%3.3d, Physical connectors present:",
  1101. pReso->eeprom[8], pReso->eeprom[9]>>8, pReso->eeprom[9] & 0xff);
  1102.     for (ix = 0; ix < 4; ix++)
  1103. if (pReso->eeprom[5] & (1 << ix))
  1104.     printf ("%s", connectors [ix]);
  1106.     printf ("nPrimary interface chip %s PHY #%d.n",
  1107. phys[(pReso->eeprom[6]>>8)&15], pReso->eeprom[6] & 0x1f);
  1108.     if (pReso->eeprom[7] & 0x0700)
  1109. printf ("Secondary interface chip %s.n",
  1110. phys[(pReso->eeprom[7]>>8)&7]);
  1112. #if FALSE  /* we don't show PHY specific info at this time */
  1113.     /* ToDo: Read and set PHY registers through MDIO port. */
  1114.     for (ix = 0; ix < 2; ix++)
  1115. printf ("MDIO register %d is %4.4x.n",
  1116. ix, sys557mdioRead (unit, pReso->eeprom[6] & 0x1f, ix));
  1117.     for (ix = 5; ix < 7; ix++)
  1118. printf ("MDIO register %d is %4.4x.n",
  1119. ix, sys557mdioRead (unit, pReso->eeprom[6] & 0x1f, ix));
  1120.     printf ("MDIO register %d is %4.4x.n",
  1121.     25, sys557mdioRead (unit, pReso->eeprom[6] & 0x1f, 25));
  1122. #endif /* FALSE */
  1124.     if (pReso->timeout < 0)
  1125.         { /* Test optimized out. */
  1126. printf ("Self test failed, status %8.8x:n"
  1127.         " Failure to initialize the 82557.n"
  1128.         " Verify that the card is a bus-master capable slot.n",
  1129.         pReso->pResults[1]);
  1130. }
  1131.     else
  1132.         {
  1133. printf ("General self-test: %s.n"
  1134.         " Serial sub-system self-test: %s.n"
  1135.         " Internal registers self-test: %s.n"
  1136.         " ROM checksum self-test: %s (%#8.8x).n",
  1137.         pReso->pResults[1] & 0x1000 ? "failed" : "passed",
  1138.         pReso->pResults[1] & 0x0020 ? "failed" : "passed",
  1139.         pReso->pResults[1] & 0x0008 ? "failed" : "passed",
  1140.         pReso->pResults[1] & 0x0004 ? "failed" : "passed",
  1141.         pReso->pResults[0]);
  1142.         }
  1143.     }
  1145. #endif /* INCLUDE_FEI82557END */
  1147. /*******************************************************************************
  1148. *
  1149. * sysDelay - a small delay
  1150. *
  1151. */
  1153. void sysDelay (void)
  1154.     {
  1156.     sysMicroDelay(PCI_CONFIG_DELAY); 
  1158.     return;
  1159.     }
  1161. /******************************************************************************
  1162. *
  1163. * sys557EndPciToPhys - translate a Pci address to a physical address
  1164. *
  1165. * This function converts a Pci address to a physical address. This only works
  1166. * for PCI Memory space.
  1167. *
  1168. * RETURNS: the physical adddress
  1169. */
  1171. UINT32 sys557EndPciToPhys
  1172.     (
  1173.     int unit,
  1174.     UINT32      PciAddr /* PCI address */
  1175.     )
  1176.     {
  1177.     return((UINT32)sysPciToPhys((void *)PciAddr));
  1178.     }
  1180. /******************************************************************************
  1181. *
  1182. * sys557EndPhysToPci - translate a physical address to a Pci address
  1183. *
  1184. * This function converts a physical address to a Pci address. This only works
  1185. * for PCI Memory space.
  1186. *
  1187. * RETURNS: the Pci adddress
  1188. */
  1190. UINT32 sys557EndPhysToPci
  1191.     (
  1192.     int unit,
  1193.     UINT32      PhysAddr        /* Physical address */
  1194.     )
  1195.     {
  1196.     return ((UINT32)sysPhysToPci((void *)PhysAddr));
  1197.     }
  1201. #endif /* INCLUDE_END */