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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
sysGei8254xEnd.c
资源名称：mpc8548.rar　[点击查看]
上传用户：dqzhongke1
上传日期：2022-06-26
资源大小：667k
文件大小：52k
源码类别：

VxWorks

开发平台：

C/C++

sysGei8254xEnd.c：源码内容
  1. /* sysGei82543End.c - Intel 82540/82541/82543/82544/82545/82546 END support routine */
  3. /*
  4.  * Copyright (c) 2001-2006 Wind River Systems, Inc.
  5.  *
  6.  * The right to copy, distribute, modify, or otherwise make use
  7.  * of this software may be licensed only pursuant to the terms
  8.  * of an applicable Wind River license agreement.
  9.  */
  11. /*
  12. modification history
  13. --------------------
  14. 01r,06feb06,pmr  HEND support no longer uses this file.
  15. 01q,27sep05,pmr  SPR 112656: fix for non-hEnd support.
  16. 01p,23sep05,agf  remove sysParamsSend;
  17.          componentized and moved to driver configlette
  18. 01o,16aug05,pmr  support for hEnd.
  19. 01n,07jul04,jln  support 82546GB MAC
  20. 01m,04jun04,jln  support 82541 MAC
  21. 01l,07may04,zmm  Fix diab compiler warnings.
  22. 01k,12nov03,sn   Fixed syntax for string spanning multiple lines
  23. 01j,07jul02,jln  add 82544GC device ID (spr#79520)
  24. 01i,21may02,jln  support 82545/82546 fiber-based adapters (spr 78084)
  25. 01h,25apr02,jln  fix short cable errata; support larger EEPROM; add more
  26.                  BSP specific functions; support 82540/82545/82546 chips;
  27.                  change the input argument of sys543IntEnable() and
  28.                  sys543IntDisable() from vector to unit.
  29. 01g,23apr02,pai  Made DEC and GEI END driver config names consistent with
  30.                  other END driver config names.
  31. 01f,05dec01,jln  save pciBus/pciDevice/pciFunc in pci resource table;
  32.                  more comments on PCI to PHY address translation
  33. 01e,19nov01,pai  Pass the correct CSR memory size to sysMmuMapAdd().
  34. 01d,09nov01,pai  Updated documentation and routines for new device discovery
  35.                  algorithm (SPR# 35716).
  36. 01c,16Oct01,jln  added sysGei8254xEndLoad; refined device detecting
  37. 01b,08Aug01,jln  support jumbo frame and 544_based adapter, more comments
  38. 01a,08Jan01,jln  written based on sysNetif.c.
  39. */
  41. /*
  42. This module is the WRS-supplied configuration module for Intel PRO1000
  43. F/T/XF/XT/MT/MF adapters. It has routines for initializing device resources
  44. and provides BSP-specific gei82543End (gei) END driver routines for
  45. Intel 82540/3/4/5/6 Ethernet PCI bus controllers.
  47. The number of supported devices that can be configured for a particular
  48. system is finite and is specified by the GEI_MAX_DEV configuration
  49. constant.  This value, and the internal data structures using it, can be
  50. modified in this file for specific implementations.
  52. SEE ALSO: ifLib,
  53. .I "RS82543GC GIGABIT ETHERNET CONTROLLER NETWORKING SILICON DEVELOPER'S MANUAL"
  54. */
  56. #if defined(INCLUDE_GEI8254X_END)
  58. /* namespace collisions */
  60. #undef INTEL_PCI_VENDOR_ID  /* redefined in gei82543End.h (temporary fix) */
  62. /* includes */
  64. #include <end.h>
  65. #include <drv/end/gei82543End.h>
  67. /* defines */
  69. /* specify the maximum number of physical devices to configure */
  71. #define GEI_MAX_DEV      (4)
  73. /* Default RX descriptor  */
  75. #ifndef GEI_RXDES_NUM
  76. #define GEI_RXDES_NUM              (GEI_DEFAULT_RXDES_NUM)
  77. #endif
  79. /* Default TX descriptor  */
  81. #ifndef GEI_TXDES_NUM
  82. #define GEI_TXDES_NUM              (GEI_DEFAULT_TXDES_NUM)
  83. #endif
  85. /* Default User's flags  */
  87. /* ORed the flag of GEI_END_JUMBO_FRAME_SUPPORT if jumbo frame needed */
  89. #ifndef GEI_USR_FLAG
  90. #define GEI_USR_FLAG        (GEI_END_SET_TIMER | 
  91.                              GEI_END_SET_RX_PRIORITY | 
  92.                              GEI_END_FREE_RESOURCE_DELAY 
  93.                             )
  94. #endif /* GEI_USR_FLAG */
  96. /*
  97.  * If jumbo frame supported, the default 9000 bytes of MTU will be used.
  98.  * Otherwise 1500 bytes MTU for normal frames. User can set up different
  99.  * MTU here for jumbo frames.
  100.  */
  102. #ifndef GEI_JUMBO_MTU_VALUE
  103. #define GEI_JUMBO_MTU_VALUE         (0)  /* Will use default value (9000) */
  104. #endif /* GEI_JUMBO_MTU_VALUE */
  106. /*
  107.  * define the offset value for different arches.
  108.  * For arch like ARM which requires 4-byte alignment for Integer,
  109.  * use offset of 2
  110.  */
  112. #define GEI_X86_OFFSET_VALUE        (0x0)
  113. #define GEI_ARM_OFFSET_VALUE        (0x2)
  115. #ifndef GEI_OFFSET_VALUE
  116. #define GEI_OFFSET_VALUE            GEI_X86_OFFSET_VALUE
  117. #endif /* GEI_OFFSET_VALUE */
  119. /* Assuming 1:1 mapping */
  121. #if (_BYTE_ORDER == _BIG_ENDIAN)
  122. #define GEI_SYS_WRITE_REG(unit, reg, value)     
  123.    ((*(volatile UINT32 *)(PCI_MEMIO2LOCAL(geiResources[(unit)].memBaseLow + reg))) = 
  124.     (LONGSWAP((UINT32)(value))))
  126. #define GEI_SYS_READ_REG(unit, reg)             
  127.    LONGSWAP((*(volatile UINT32 *)(PCI_MEMIO2LOCAL(geiResources[(unit)].memBaseLow + reg))))
  129. #else
  131. #define GEI_SYS_WRITE_REG(unit, reg, value)     
  132.    ((*(volatile UINT32 *)(PCI_MEMIO2LOCAL(geiResources[(unit)].memBaseLow + reg))) = 
  133.     (UINT32)(value))
  135. #define GEI_SYS_READ_REG(unit, reg)             
  136.    (*(volatile UINT32 *)(PCI_MEMIO2LOCAL(geiResources[(unit)].memBaseLow + reg)))
  138. #endif /* _BYTE_ORDER */
  140. /* PCI device ID for Intel 82543/82544 Ethernet */
  142. #define PRO1000_543_PCI_DEVICE_ID_T     (0x1001) /* Copper */
  143. #define PRO1000_543_PCI_DEVICE_ID_FT    (0x1004) /* Fiber / Copper */
  144. #define PRO1000_544_PCI_DEVICE_ID_XT    (0x1008) /* Copper */
  145. #define PRO1000_544_PCI_DEVICE_ID_XF    (0x1009) /* Fiber */
  146. #define PRO1000_544_PCI_DEVICE_ID_GC    (0x100c) /* Copper */
  147. #define PRO1000_540_PCI_DEVICE_ID_XT    (0x100e) /* Copper only */
  148. #define PRO1000_545_PCI_DEVICE_ID_XT    (0x100f) /* Copper */
  149. #define PRO1000_546_PCI_DEVICE_ID_XT    (0x1010) /* Copper - 82546 EB */
  150. #define PRO1000_545_PCI_DEVICE_ID_MF    (0x1011) /* Fiber */
  151. #define PRO1000_546_PCI_DEVICE_ID_MF    (0x1012) /* Fiber */
  152. #define PRO1000_541_PCI_DEVICE_ID_XT    (0x1078) /* Copper */
  153. #define PRO1000_541_PCI_DEVICE_ID_GT    (0x107C) /* Copper */
  154. #define PRO1000_546_PCI_DEVICE_ID_XT2   (0x1079) /* Copper - 82546 GB */
  156. #define PRO1000_572_PCI_DEVICE_ID_EI    (0x107D) /* Copper - 82572EI */
  157. #define PRO1000_573_PCI_DEVICE_ID_E (0x108B) /* Copper - 82573E */
  158. #define PRO1000_573_PCI_DEVICE_ID_IAMT (0x108C) /* Copper - 82573E IAMT */
  160. /* device resources */
  162. #define GEI_MEMSIZE_CSR            (0x20000)     /* 128Kb CSR memory size */
  163. #define GEI_MEMSIZE_FLASH          (0x80000)     /* 512Kb Flash memory size */
  164. #define GEI_EEPROM_SZ_64           (64)          /* 64 WORD */
  165. #define GEI_EEPROM_SZ_256          (256)         /* 256 WORD */
  167. #define GEI0_SHMEM_BASE             NONE
  168. #define GEI0_SHMEM_SIZE             (0)
  169. #define GEI0_RXDES_NUM              GEI_RXDES_NUM
  170. #define GEI0_TXDES_NUM              GEI_TXDES_NUM
  171. #define GEI0_USR_FLAG               GEI_USR_FLAG
  173. #define GEI1_SHMEM_BASE             NONE
  174. #define GEI1_SHMEM_SIZE             (0)
  175. #define GEI1_RXDES_NUM              GEI_RXDES_NUM
  176. #define GEI1_TXDES_NUM              GEI_TXDES_NUM
  177. #define GEI1_USR_FLAG               GEI_USR_FLAG
  179. #define GEI2_SHMEM_BASE             NONE
  180. #define GEI2_SHMEM_SIZE             (0)
  181. #define GEI2_RXDES_NUM              GEI_RXDES_NUM
  182. #define GEI2_TXDES_NUM              GEI_TXDES_NUM
  183. #define GEI2_USR_FLAG               GEI_USR_FLAG
  185. #define GEI3_SHMEM_BASE             NONE
  186. #define GEI3_SHMEM_SIZE             (0)
  187. #define GEI3_RXDES_NUM              GEI_RXDES_NUM
  188. #define GEI3_TXDES_NUM              GEI_TXDES_NUM
  189. #define GEI3_USR_FLAG               GEI_USR_FLAG
  191. /* INTEL 82544 INTERNAL PHY */
  193. #define INTEL_82544PHY_OUI_ID                   (0x5043)
  194. #define INTEL_82544PHY_MODEL                    (0x3)
  196. #define INTEL_82544PHY_PHY_SPEC_CTRL_REG        (0x10)
  197. #define INTEL_82544PHY_PHY_SPEC_STAT_REG        (0x11)
  198. #define INTEL_82544PHY_INT_ENABLE_REG           (0x12)
  199. #define INTEL_82544PHY_INT_STATUS_REG           (0x13)
  200. #define INTEL_82544PHY_EXT_PHY_SPEC_CTRL_REG    (0x14)
  201. #define INTEL_82544PHY_RX_ERROR_COUNTER         (0x15)
  202. #define INTEL_82544PHY_PHY_GLOBAL_STAT          (0x17)
  203. #define INTEL_82544PHY_LED_CTRL_REG             (0x18)
  205. #define INTEL_82544PHY_PSCR_ASSERT_CRS_ON_TX    (0x0800)
  206. #define INTEL_82544PHY_EPSCR_TX_CLK_25          (0x0070)
  208. /* Alaska PHY's information */
  210. #define MARVELL_OUI_ID                  (0x5043)
  211. #define MARVELL_ALASKA_88E1000          (0x5)
  212. #define MARVELL_ALASKA_88E1000S         (0x4)
  213. #define ALASKA_PHY_SPEC_CTRL_REG        (0x10)
  214. #define ALASKA_PHY_SPEC_STAT_REG        (0x11)
  215. #define ALASKA_INT_ENABLE_REG           (0x12)
  216. #define ALASKA_INT_STATUS_REG           (0x13)
  217. #define ALASKA_EXT_PHY_SPEC_CTRL_REG    (0x14)
  218. #define ALASKA_RX_ERROR_COUNTER         (0x15)
  219. #define ALASKA_LED_CTRL_REG             (0x18)
  221. #define ALASKA_PSCR_ASSERT_CRS_ON_TX    (0x0800)
  222. #define ALASKA_EPSCR_TX_CLK_25          (0x0070)
  224. #define ALASKA_PSCR_AUTO_X_1000T        (0x0040)
  225. #define ALASKA_PSCR_AUTO_X_MODE         (0x0060)
  227. #define ALASKA_PSSR_DPLX                (0x2000)
  228. #define ALASKA_PSSR_SPEED               (0xC000)
  229. #define ALASKA_PSSR_10MBS               (0x0000)
  230. #define ALASKA_PSSR_100MBS              (0x4000)
  231. #define ALASKA_PSSR_1000MBS             (0x8000)
  232. #ifndef BOARD_TYPE_UNKNOWN
  233. #define BOARD_TYPE_UNKNOWN (-1)
  234. #endif /* BOARD_TYPE_UNKNOWN */
  236. /* typedefs */
  238. typedef struct pciBoardResource      /* PCI_BOARD_RESOURCE */
  239.     {
  240.     int           pciSysNum;         /* PCI system number */
  241.     UINT32        pciBus;            /* PCI Bus number */
  242.     UINT32        pciDevice;         /* PCI Device number */
  243.     UINT32        pciFunc;           /* PCI Function number */
  245.     UINT32        vendorID;          /* PCI Vendor ID */
  246.     UINT32        deviceID;          /* PCI Device ID */
  247.     UINT8         revisionID;        /* PCI Revision ID */
  248.     UINT32        boardType;         /* BSP-specific board type ID */
  250.     UINT8         irq;               /* Interrupt Request Level */
  251.     UINT32        irqvec;            /* Interrupt Request vector */
  253.     UINT32        bar [6];           /* PCI Base Address Registers */
  255.     void * const  pExtended;         /* pointer to extended device info */
  257.     } PCI_BOARD_RESOURCE;
  259. typedef struct geiResource        /* GEI_RESOURCE */
  260.     {
  261.     BOOL   adr64;                 /* Indicator for 64-bit support */
  262.     UINT32 memBaseLow;            /* Base Address LOW */
  263.     UINT32 memBaseHigh;           /* Base Address HIGH */
  264.     UINT32 flashBase;             /* Base Address for FLASH */
  266.     UINT16 eepromSize;            /* size in unit of word (16 bit) - 64/256 */
  267.     UINT16 eeprom_icw1;           /* EEPROM initialization control word 1 */
  268.     UINT16 eeprom_icw2;           /* EEPROM initialization control word 2 */
  269.     UCHAR  enetAddr[6];           /* MAC address for this adaptor */
  271.     UINT32 shMemBase;             /* Share memory address if any */
  272.     UINT32 shMemSize;             /* Share memory size if any */
  274.     UINT32 rxDesNum;              /* RX descriptor for this unit */
  275.     UINT32 txDesNum;              /* TX descriptor for this unit */
  277.     BOOL   useShortCable;         /* TRUE if short cable used for 82544 */
  278.                                      /* by default is FALSE */
  279.     UINT32 usrFlags;              /* user flags for this unit */
  280.     STATUS iniStatus;             /* initialization perform status */
  282.     } GEI_RESOURCE;
  284. /* This table defined board extended resources */
  286. GEI_RESOURCE geiResources [GEI_MAX_DEV] =
  287.     {
  288.     {FALSE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, GEI_EEPROM_SZ_64, 0, 0, {(UCHAR)NONE},
  289.      (UINT32)GEI0_SHMEM_BASE, GEI0_SHMEM_SIZE, GEI0_RXDES_NUM, GEI0_TXDES_NUM, FALSE,
  290.      GEI0_USR_FLAG, ERROR
  291.     },
  293.     {FALSE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, GEI_EEPROM_SZ_64, 0, 0, {(UCHAR)NONE},
  294.      (UINT32)GEI1_SHMEM_BASE, GEI1_SHMEM_SIZE, GEI1_RXDES_NUM, GEI1_TXDES_NUM, FALSE,
  295.      GEI1_USR_FLAG, ERROR
  296.     },
  298.     {FALSE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, GEI_EEPROM_SZ_64, 0, 0, {(UCHAR)NONE},
  299.      (UINT32)GEI2_SHMEM_BASE, GEI2_SHMEM_SIZE, GEI2_RXDES_NUM, GEI2_TXDES_NUM, FALSE,
  300.      GEI2_USR_FLAG, ERROR
  301.     },
  303.     {FALSE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, GEI_EEPROM_SZ_64, 0, 0, {(UCHAR)NONE},
  304.      (UINT32)GEI3_SHMEM_BASE, GEI3_SHMEM_SIZE, GEI3_RXDES_NUM, GEI3_TXDES_NUM, FALSE,
  305.      GEI3_USR_FLAG, ERROR
  306.     }
  307.     };
  309. /* locals */
  311. LOCAL UINT32 geiUnits = 0;     /* number of GEIs we found */
  313. /* This table defines board PCI resources */
  315. /* This table defines board PCI resources */
  317. LOCAL PCI_BOARD_RESOURCE geiPciResources [GEI_MAX_DEV] =
  318.     {
  319.     {NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT8)NONE, (UINT32)NONE, (UINT8)NONE, (UINT32)NONE,
  320.     {(UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE},
  321.      (void * const)(&geiResources[0])
  322.     },
  324.     {NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT8)NONE, (UINT32)NONE, (UINT8)NONE, (UINT32)NONE,
  325.     {(UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE},
  326.      (void * const)(&geiResources[1])
  327.     },
  329.     {NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT8)NONE, (UINT32)NONE, (UINT8)NONE, (UINT32)NONE,
  330.     {(UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE},
  331.      (void * const)(&geiResources[2])
  332.     },
  334.     {NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT8)NONE, (UINT32)NONE, (UINT8)NONE, (UINT32)NONE,
  335.     {(UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE, (UINT32)NONE},
  336.      (void * const)(&geiResources[3])
  337.     }
  338.     };
  340. /* forward declarations */
  342. LOCAL int       sys543IntEnable  (int unit);
  343. LOCAL int       sys543IntDisable (int unit);
  344. LOCAL int       sys543IntAck     (int unit);
  345. LOCAL STATUS    sys543eepromCheckSum (int unit);
  346. LOCAL UINT16    sys543eepromReadWord (int unit,UINT32);
  347. LOCAL STATUS    sys543EtherAdrGet (int unit);
  348. LOCAL void      sys544PhyPreInit (PHY_INFO *);
  349. LOCAL void      sys543PhySpecRegsInit(PHY_INFO *, UINT8);
  350. LOCAL BOOL      sysGei82546InitTimerSetup (ADAPTOR_INFO * );
  351. LOCAL BOOL      sysGei82546DynaTimerSetup (ADAPTOR_INFO * );
  352. LOCAL UINT32    sysGeiDevToType (UINT32, UINT32, UINT8);
  354. /*****************************************************************************
  355. *
  356. * sys543PciInit - initialize a GEI 8254x PCI ethernet device
  357. *
  358. * This routine performs basic PCI initialization for 8254x ethernet
  359. * devices supported by the gei82543End END driver.  Parameters to this
  360. * routine specify a PCI function, including PCI ID registers, to
  361. * initialize.  If supported,  the device memory and I/O addresses are
  362. * mapped into the local CPU address space and an internal board-specific
  363. * PCI resources table is updated with information on the board type,
  364. * memory address, and IO address.
  365. *
  366. * CAVEATS
  367. * This routine must be performed prior to MMU initialization, usrMmuInit().
  368. * If the number of supported 8254x physical device instances installed
  369. * on the PCI bus exceeds GEI_MAX_DEV, then the extra devices will not be
  370. * initialized in this routine.
  371. *
  372. * RETURNS:
  373. * OK, or ERROR if the specified device is not supported, or if
  374. * the device could not be mapped into the local CPU memory space.
  375. */
  376. STATUS sys543PciInit
  377.     (
  378.     UINT32         pciBus,      /* store a PCI bus number */
  379.     UINT32         pciDevice,   /* store a PCI device number */
  380.     UINT32         pciFunc,     /* store a PCI function number */
  381.     UINT32         vendorId,    /* store a PCI vendor ID */
  382.     UINT32         deviceId,    /* store a PCI device ID */
  383.     UINT8          revisionId,  /* store a PCI revision ID */
  384.     UINT32         boardType,   /* board type */
  385.     int            pciSysNum    /* PCI system number */
  386.     )
  387.     {
  388.     UINT32         memBaseLo;   /* temporary BAR storage */
  389.     UINT32         memBaseHi;
  390.     UINT32         flashBase;
  391.     UINT8          irq;         /* store PCI interrupt line (IRQ) number */
  393.     GEI_RESOURCE * pReso;       /* alias extended resource table */
  395.     /* number of physical units exceeded the number supported ? */
  397.     if (geiUnits >= GEI_MAX_DEV)
  398.         {
  399.         return (ERROR);
  400.         }
  402.     if ((boardType = sysGeiDevToType (vendorId, deviceId, revisionId))
  403.         == BOARD_TYPE_UNKNOWN)
  404.         {
  405.         return (ERROR);
  406.         }
  408.     if (pciSysNum != CDS85XX_PCI_1_BUS && pciSysNum != CDS85XX_PCI_2_BUS && pciSysNum != CDS85XX_PCIEX_BUS)
  409.     {
  410. printf("invalid bus %dn", pciSysNum);
  411.         return ERROR;
  412.      }
  413.     geiPciResources[geiUnits].pciSysNum = pciSysNum;
  415.     /* BAR information will be saved in the extended resource table */
  417.     pReso = (GEI_RESOURCE *)(geiPciResources[geiUnits].pExtended);
  419.     /* Auto Config doesn't work for PCI Express so manually configure */
  421.     if (pciSysNum == CDS85XX_PCIEX_BUS)
  422. {
  423. memBaseLo = CPU_PCI_MEMIO_ADRS3;
  425. pciConfigOutLong  (pciBus, pciDevice, pciFunc, PCI_CFG_BASE_ADDRESS_0, memBaseLo);
  427. irq = PCIEX_XINT1_LVL;
  429. pciConfigOutByte  (pciBus, pciDevice, pciFunc, PCI_CFG_DEV_INT_LINE, irq);
  430. }
  432.     /*
  433.      * BAR0: [32:17]: memory base
  434.      *       [16:4] : read as "0";
  435.      *       [3]    : 0 - device is not prefetchable
  436.      *       [2:1]  : 00b - 32-bit address space, or
  437.      *                01b - 64-bit address space
  438.      *       [0]    : 0 - memory map decoded
  439.      *
  440.      * BAR1: if BAR0[2:1] == 00b, optional flash memory base
  441.      *       if BAR0[2:1] == 01b, high portion of memory base
  442.      *                            for 64-bit address space
  443.      *
  444.      * BAR2: if BAR0[2:1] == 01b, optional flash memory base
  445.      *       if BAR0[2:1] == 00b, behaves as BAR-1 when BAR-0 is
  446.      *                            a 32-bit value
  447.      */
  449.     pciConfigInLong  (pciBus, pciDevice, pciFunc,
  450.                       PCI_CFG_BASE_ADDRESS_0, &memBaseLo);
  452.     pReso->adr64 = ((memBaseLo & BAR0_64_BIT) == BAR0_64_BIT)
  453.                    ? TRUE : FALSE;
  455.     if (pReso->adr64)
  456.         {
  457.         pciConfigInLong  (pciBus, pciDevice, pciFunc,
  458.                           PCI_CFG_BASE_ADDRESS_1, &memBaseHi);
  460.         pciConfigInLong  (pciBus, pciDevice, pciFunc,
  461.                           PCI_CFG_BASE_ADDRESS_2, &flashBase);
  462.         }
  463.     else
  464.         {
  465.         memBaseHi = 0x0;
  467.         pciConfigInLong  (pciBus, pciDevice, pciFunc,
  468.                           PCI_CFG_BASE_ADDRESS_1, &flashBase);
  469.         }
  471.     memBaseLo &= PCI_MEMBASE_MASK;
  472.     flashBase &= PCI_MEMBASE_MASK;
  474.     /* get the device's interrupt line (IRQ) number */
  476.     pciConfigInByte (pciBus, pciDevice, pciFunc,
  477.                      PCI_CFG_DEV_INT_LINE, &irq);
  479.     /* update the board-specific resource tables */
  481.     pReso->memBaseLow  = memBaseLo;
  482.     pReso->memBaseHigh = memBaseHi;
  483.     pReso->flashBase   = flashBase;
  485.     geiPciResources[geiUnits].irq        = irq;
  486.     geiPciResources[geiUnits].irqvec     = irq;
  488.     geiPciResources[geiUnits].vendorID   = vendorId;
  489.     geiPciResources[geiUnits].deviceID   = deviceId;
  490.     geiPciResources[geiUnits].revisionID = revisionId;
  491.     geiPciResources[geiUnits].boardType  = boardType;
  493.    /* the following support legacy interfaces and data structures */
  495.     geiPciResources[geiUnits].pciBus     = pciBus;
  496.     geiPciResources[geiUnits].pciDevice  = pciDevice;
  497.     geiPciResources[geiUnits].pciFunc    = pciFunc;
  499.     /* enable mapped memory and IO decoders */
  501.     pciConfigOutWord (pciBus, pciDevice, pciFunc, PCI_CFG_COMMAND,
  502.                       PCI_CMD_MEM_ENABLE | PCI_CMD_IO_ENABLE |
  503.                       PCI_CMD_MASTER_ENABLE);
  505.     /* disable sleep mode */
  507.     pciConfigOutByte (pciBus, pciDevice, pciFunc, PCI_CFG_MODE,
  508.                       SLEEP_MODE_DIS);
  510.     ++geiUnits;  /* increment number of units initialized */
  512.     return (OK);
  513.     }
  515. /******************************************************************************
  516. *
  517. * sysGei8254xEndLoad - create load string and load a gei driver.
  518. *
  519. * This routine will be invoked by the MUX for the purpose of loading an
  520. * gei82543End (gei) device with initial parameters.  This routine is
  521. * constructed as an interface wrapper for the driver load routine.  Thus,
  522. * the arguments and return values are consistent with any xxxEndLoad()
  523. * routine defined for an END driver and the MUX API.
  524. *
  525. * INTERNAL
  526. * The muxDevLoad() operation calls this routine twice.  A zero length
  527. * <pParamStr> parameter string indicates that this is the first time
  528. * through this routine.  The driver load routine should return the
  529. * driver name in <pParamStr>.
  530. *
  531. * On the second pass though this routine, the initialization parameter
  532. * string is constructed.  Note that on the second pass, the <pParamStr>
  533. * consists of a colon-delimited END device unit number and rudimentary
  534. * initialization string (often empty) constructed from entries in the
  535. * BSP END Device Table such that:
  536. *
  537. *     <pParamStr> = "<unit>:<default initialization string>"
  538. *
  539. * In the process of building the rest of <pParamStr>, the prepended unit
  540. * number must be preserved and passed to the driver load routine.  The
  541. * <default initialization string> portion mentioned above is discarded,
  542. * but future versions of this routine may use it.
  543. *
  544. * The complete gei82543End driver load string has format:
  545. *
  546. *     <unit>:<shMemBase>:<shMemSize>:<rxDesNum>:<txDesNum>:<usrFlags>:
  547. *     <offset>:<mtu>
  548. *
  549. * RETURNS: An END object pointer, or NULL on error, or 0 and the name of the
  550. * device if the <pParamStr> was NULL.
  551. *
  552. * SEE ALSO: gei82543EndLoad()
  553. */
  554. END_OBJ * sysGei8254xEndLoad
  555.     (
  556.     char *    pParamStr,   /* ptr to initialization parameter string */
  557.     void *    unused       /* unused optional argument */
  558.     )
  559.     {
  560.     END_OBJ * pEnd;
  561.     char      paramStr [END_INIT_STR_MAX];
  564.     if (strlen (pParamStr) == 0)
  565.         {
  566.         /* PASS (1)
  567.          * The driver load routine returns the driver name in <pParamStr>.
  568.          */
  570.         pEnd = gei82543EndLoad (pParamStr);
  571. printf("sysGei8254xEndLoad pass 1n");
  572.         }
  573.     else
  574.         {
  575. printf("sysGei8254xEndLoad pass 2n");
  576.         /* PASS (2)
  577.          * The END <unit> number is prepended to <pParamStr>.  Construct
  578.          * the rest of the driver load string based on physical devices
  579.          * discovered in sys543PciInit().  When this routine is called
  580.          * to process a particular END <unit> number, use the END <unit> as
  581.          * an index into the PCI "resources" table to build the driver
  582.          * parameter string.
  583.          */
  585.         GEI_RESOURCE *  pReso;
  587.         char * holder = NULL;
  588.         int    unit   = atoi (strtok_r (pParamStr, ":", &holder));
  590.         /* is there a PCI resource associated with this END unit ? */
  592.         if (unit >= geiUnits)
  593.             {
  594. printf("unit =%d, geiUnits = %dn", unit, geiUnits);
  595.             return NULL;
  596.             }
  598.         pReso = (GEI_RESOURCE *)(geiPciResources[unit].pExtended);
  600.         /* finish off the initialization parameter string */
  602.         sprintf (paramStr,"%d:0x%x:0x%x:0x%x:0x%x:0x%x:%d:%d",
  603.                  unit,                          /* END unit number */
  604.                  pReso->shMemBase,              /* share memory base */
  605.                  pReso->shMemSize,              /* share memory size */
  606.                  pReso->rxDesNum,               /* RX Descriptor Number*/
  607.                  pReso->txDesNum,               /* TX Descriptor Number*/
  608.                  pReso->usrFlags,               /* user's flags */
  609.                  GEI_OFFSET_VALUE,              /* offset value */
  610.                  GEI_JUMBO_MTU_VALUE            /* mtu value */
  611.                 );
  612. printf("%sn", paramStr);
  613.         if ((pEnd = gei82543EndLoad (paramStr)) == (END_OBJ *)NULL)
  614.             {
  615.             printf ("ERROR: sysGei8254xEndLoad fails to load gei %dn", unit);
  616.             }
  617.         }
  618. printf("pEnd = 0x%08xn", pEnd);
  619.     return (pEnd);
  620.     }
  622. /*****************************************************************************
  623. * sys8254xDeviceCheck - check whether a device is 8254x
  624. *
  625. * This function verifies a device is Intel 8254x.
  626. *
  627. * RETURNS: OK
  628. *
  629. * ERRNO: N/A
  630. */
  632. STATUS sys8254xDeviceCheck
  633.     (
  634.     UINT32              pciBus,        /* store a PCI bus number */
  635.     UINT32              pciDevice,     /* store a PCI device number */
  636.     UINT32              pciFunc,       /* store a PCI function number */
  637.     void *              pPciSysNum     /* reserved argument */
  638.     )
  639.     {
  640.     UINT32        boardType;   /* store a BSP-specific board type constant */
  642.     UINT32        vendorId;    /* store a PCI vendor ID */
  643.     UINT32        deviceId;    /* store a PCI device ID */
  644.     UINT8         revisionId;  /* store a PCI revision ID */
  646.     pciConfigInLong (pciBus, pciDevice, pciFunc,
  647.                       PCI_CFG_VENDOR_ID, &vendorId);
  649.     pciConfigInByte (pciBus, pciDevice, pciFunc,
  650.                          PCI_CFG_REVISION, &revisionId);
  652.     deviceId = ((vendorId >> 16) & 0x0000ffff);
  653.     vendorId = (vendorId & 0x0000ffff);
  654.     if ((boardType = sysGeiDevToType (vendorId, deviceId, revisionId))
  655.                   != (UINT32)(BOARD_TYPE_UNKNOWN))
  656.         {
  658.         int pciSysNum = *(int *)pPciSysNum;
  660.         sys543PciInit (pciBus, pciDevice, pciFunc, vendorId,
  661.                         deviceId, revisionId, boardType, pciSysNum);
  662.         }
  664.     return OK;
  665.     }
  667. /*****************************************************************************
  668. *
  669. * sys82543BoardInit - Adaptor initialization for 8254x chip
  670. *
  671. * This routine is expected to perform any adapter-specific or target-specific
  672. * initialization that must be done prior to initializing the 8254x chip.
  673. *
  674. * The 82543 driver calls this routine from the driver load routine before
  675. * any other routines.
  676. *
  677. * RETURNS: OK or ERROR
  678. */
  679. STATUS sys82543BoardInit
  680.     (
  681.     int            unit,      /* unit number */
  682.     ADAPTOR_INFO * pBoard     /* board information for the GEI driver */
  683.     )
  684.     {
  685.     PCI_BOARD_RESOURCE * pRsrc;
  686.     GEI_RESOURCE *       pReso;
  687.     BOOL                 lanB = FALSE;
  688.     int i;
  690.     /* sanity check */
  692.     if (unit >= geiUnits)
  693.         return (ERROR);
  695.     pRsrc = &geiPciResources[unit];
  696.     pReso = (GEI_RESOURCE *)(pRsrc->pExtended);
  698.     if (pRsrc->boardType != PRO1000_543_BOARD &&
  699.         pRsrc->boardType != PRO1000_544_BOARD &&
  700.         pRsrc->boardType != PRO1000_546_BOARD &&
  701.         pRsrc->boardType != PRO1000_573_BOARD)
  702.          return ERROR;
  704.     if (pRsrc->boardType == PRO1000_546_BOARD)
  705.         {
  706.         UINT32 eecd;
  707.         UINT16 devId;
  709.         if (!((eecd = GEI_SYS_READ_REG(unit, INTEL_82543GC_EECD)) & EECD_PRES_BIT))
  710.             {
  711.             printf ("ERROR: gei unit %d eeprom not presentedn", unit);
  712.             return ERROR;
  713.             }
  715.         pReso->eepromSize = (eecd & EECD_SIZE_BIT)? 256 : 64;
  717.         /* detect if this is one of 82546EB dual ports */
  719.         pciConfigInWord (pRsrc->pciBus, pRsrc->pciDevice, pRsrc->pciFunc,
  720.                           PCI_CFG_DEVICE_ID, &devId);
  722.         if (devId == PRO1000_546_PCI_DEVICE_ID_XT ||
  723.             devId == PRO1000_546_PCI_DEVICE_ID_MF)
  724.         {
  725.             UINT8 headerType;
  727.             pciConfigInByte (pRsrc->pciBus, pRsrc->pciDevice, pRsrc->pciFunc,
  728.                              PCI_CFG_HEADER_TYPE, &headerType);
  730.             if (headerType == 0x80)
  731.             lanB = (pRsrc->pciFunc == 1)? TRUE : FALSE;
  733.             else if (pRsrc->pciFunc != 0)
  734.             {
  735.                 printf ("Error in detecting 82546 dual port: header type =%2d, "
  736.                          "pci func=%2dn", (UINT32)headerType, (UINT32)(pRsrc->pciFunc));
  737.             }
  738.             }
  739.         }
  741.     /* Reset */
  743.     GEI_SYS_WRITE_REG(unit, INTEL_82543GC_CTRL, CTRL_RST_BIT);
  745.     for (i = 0; i < 10000; i++)
  746.         {
  747.         sysDelay();
  748.         if (!(GEI_SYS_READ_REG(unit, INTEL_82543GC_CTRL) & CTRL_RST_BIT))
  749.             break;
  750.         }
  752.     for (i = 0; i < 50; i++)
  753.         sysDelay();
  755.     /* perform EEPROM checksum */
  757.     if (sys543eepromCheckSum (unit) != OK)
  758.         {
  759.         printf ("ERROR: gei unit=%d, EEPROM checksum error!n", unit);
  760.         }
  762.     /* get the Ethernet Address from eeprom */
  764.     if (sys543EtherAdrGet (unit) == OK)
  765.         {
  766.         if (pRsrc->boardType == PRO1000_546_BOARD && lanB == TRUE)
  767.            {
  768.            int   ix;
  770.        /* update LANB address */
  772.            for (ix = 5; ix >= 0; ix--)
  773.             {
  774.         if (pReso->enetAddr[ix] != 0xff)
  775.             {
  776.                     pReso->enetAddr[ix]++;
  777.                     break;
  778.                     }
  779.                 else
  780.                     pReso->enetAddr[ix] = 0;
  781.                 }
  782.            }
  783.         }
  784.     else
  785.          printf ("ERROR: gei unit=%d, Invalid Ethernet Address!n", unit);
  787.     /* get the initialization control word 1 (ICW1) in EEPROM */
  789.     pReso->eeprom_icw1 = sys543eepromReadWord (unit, EEPROM_ICW1);
  791.     /* get the initialization control word 2 (ICW2) in EEPROM */
  793.     pReso->eeprom_icw2 = sys543eepromReadWord (unit, EEPROM_ICW2);
  795.     /* initializes the board information structure */
  797.     pBoard->boardType   = pRsrc->boardType;
  798.     pBoard->vector      = pRsrc->irq;
  800.     pBoard->regBaseHigh = pReso->memBaseHigh;
  801.     pBoard->regBaseLow  = PCI_MEMIO2LOCAL(pReso->memBaseLow);
  802.     pBoard->flashBase   = PCI_MEMIO2LOCAL(pReso->flashBase);
  803.     pBoard->adr64       = pReso->adr64;
  805.     pBoard->intEnable   = sys543IntEnable;
  806.     pBoard->intDisable  = sys543IntDisable;
  807.     pBoard->intAck      = sys543IntAck;
  809.     /* Intel Copper-based adapter is based on GMII interface */
  811.     pBoard->phyType     = GEI_PHY_GMII_TYPE;
  813.     if (pBoard->boardType == PRO1000_544_BOARD &&
  814.                              geiResources[unit].useShortCable)
  815.         {
  816.         miiPhyOptFuncSet ((FUNCPTR)sys544PhyPreInit);
  817.         }
  819.     pBoard->phySpecInit = sys543PhySpecRegsInit;
  821.     /* BSP specific
  822.      * delayFunc is BSP specific. We prefer a higher time resolution delay
  823.      * delayUnit is the time of ns elapsed when calling delayFunc ().
  824.      */
  826.     pBoard->delayFunc     = (FUNCPTR) sysDelay;
  827.     pBoard->delayUnit     = 720; /* In x86, sysDelay() takes about 720ns */
  829.     /* BSP specific
  830.      * phyDelayRtn is used as a delay function for PHY detection, if not set,
  831.      * taskDelay will be used.
  832.      */
  834.     pBoard->phyDelayRtn = (FUNCPTR) taskDelay;
  835.     pBoard->phyMaxDelay = MII_PHY_DEF_DELAY;
  836.     pBoard->phyDelayParm = 5;
  838.     /* BSP/adapter specific
  839.      * set the PHY address if you know it, otherwise set to zero
  840.      * INTEL 82540/4/5/6-based adapters have a built-in phy with Addr of 1
  841.      */
  843.     pBoard->phyAddr = (pRsrc->boardType == PRO1000_544_BOARD ||
  844.                        pRsrc->boardType == PRO1000_546_BOARD ||
  845.                        pRsrc->boardType == PRO1000_573_BOARD)? 1 : 0;
  847.     /* BSP/adapter specific (for 82540/82545/82546 only)
  848.      * allow users set up the device's internal timer based on their
  849.      * application. sysGeiInitTimerSet() is called when the device
  850.      * starts; sysGeiDynaTimerSet() is called every 2s in tNetTask if
  851.      * GEI_END_SET_TIMER is set.
  852.      */
  854.     if (pRsrc->boardType == PRO1000_546_BOARD)
  855.         {
  856.         pBoard->sysGeiDynaTimerSetup = sysGei82546DynaTimerSetup;
  857.         pBoard->sysGeiInitTimerSetup = sysGei82546InitTimerSetup;
  858.         }
  859.     else
  860.         {
  861.         pBoard->sysGeiDynaTimerSetup   = NULL;         /* default */
  862.         pBoard->sysGeiInitTimerSetup   = NULL;         /* default */
  863.         }
  865.     /* BSP specific
  866.      * call back functions perform system physical memory mapping in the PCI
  867.      * address space. sysLocalToBus converts a system physical memory address
  868.      * into the pci address space. sysBusToLocal converts a pci address which
  869.      * actually reflects a system physical memory back to the system memory
  870.      * address. The sysBusToLocal here in this driver is NOT used for mapping
  871.      * PCI device's memory (e.g. PCI device's control/status registers)
  872.      * to the host address space.
  873.      */
  875.     pBoard->sysLocalToBus = NULL;     /* for 1:1 mapping */
  876.     pBoard->sysBusToLocal = NULL;     /* for 1:1 mapping */
  878.     /* specify the interrupt connect/disconnect routines to be used */
  880.     pBoard->intConnect    = (FUNCPTR) pciIntConnect;
  881.     pBoard->intDisConnect = (FUNCPTR) pciIntDisconnect;
  883.     /* get the ICW1 and ICW2 stored in EEPROM */
  885.     pBoard->eeprom_icw1   = pReso->eeprom_icw1;
  886.     pBoard->eeprom_icw2   = pReso->eeprom_icw2;
  888.     /* copy Ether address */
  890.     memcpy (&pBoard->enetAddr[0], &(pReso->enetAddr[0]),
  891.             ETHER_ADDRESS_SIZE);
  893.     /* we finish adaptor initialization */
  895.     pReso->iniStatus = OK;
  897.     /* enable adaptor interrupt */
  899.     intEnable (pRsrc->irq);
  901.     return (OK);
  902.     }
  904. /*************************************************************************
  905. *
  906. * sysGei82546DynaTimerSetup - setup device internal timer value dynamically
  907. *
  908. * This routine will be called every 2 seconds by default if GEI_END_SET_TIMER
  909. * flag is set. The available timers to adjust include RDTR(unit of ns),
  910. * RADV(unit of us), and ITR(unit of 256ns). Based on CPU's and/or tasks'
  911. * usage on system, user can tune the device's performance dynamically.
  912. * This routine would be called in the tNetTask context, and is only
  913. * available for 82540/82545/82546 MACs. Any timer value greater than
  914. * 0xffff won't be used to change corresponding timer register.
  915. *
  916. * RETURNS: TRUE if timer value should change, or FALSE
  917. */
  919. LOCAL BOOL sysGei82546DynaTimerSetup
  920.     (
  921.     ADAPTOR_INFO * pBoard     /* board information for the GEI driver */
  922.     )
  923.     {
  924.     /* user's specific code to decide what value should be used.
  925.      * For example, depending on
  926.      * 1: CPU usage on system and/or,
  927.      * 2: specific application task's usage and/or,
  928.      * 3: RX/TX packet processing per second, and/or
  929.      * 4: RX/TX interrupt counter per second, and/or
  930.      * 5: RX packet processing for each calling gei82543RxTxIntHandle(),
  931.      * users can choose optimal timer values from a predefined table to
  932.      * reduce interrupt rates. The statistic of 3,4,and 5 items above
  933.      * may be obtained from pBoard->devDrvStat.
  934.      *
  935.      * NOTE:
  936.      * ITR:  Interrupt throttling register (unit of 256ns)
  937.      *       inter-interrupt delay between chip's interrupts
  938.      *
  939.      * RADV: receive interrupt absolute delay timer register (unit of 1.024us)
  940.      *       a RX interrupt will absolutely occur at this defined value
  941.      *       after the first packet is received.
  942.      *
  943.      * RDTR: receive delay timer register (unit of 1.024us)
  944.      *       a RX interrupt will occur if device has not received a subsequent
  945.      *       packet within this defined value.
  946.      */
  948.     /* value > 0xffff would not be used for corresponding timer registers */
  950.     /* pBoard->devTimerUpdate.rdtrVal = 0xffffffff; /@ unit of 1.024ns */
  951.     /* pBoard->devTimerUpdate.radvVal = 0xffffffff; /@ unit of 1.024us */
  952.     /* pBoard->devTimerUpdate.itrVal  = 0xffffffff; /@ unit of 256 ns */
  953.     /* pBoard->devTimerUpdate.watchDogIntVal = 2;   /@ 2 second default */
  955.     /* return TRUE; */
  957.     return FALSE;
  958.     }
  960. /*************************************************************************
  961. *
  962. * sysGei82546InitTimerSetup - initially setup device internal timer value
  963. *
  964. * The device's internal timers include RDTR(unit of ns),
  965. * RADV(unit of us), and ITR(unit of 256ns). The function is
  966. * called before device starts up, and it is only available for
  967. * 82540/82545/82546 MACs. Any timer value greater than 0xffff will
  968. * be discarded.
  969. *
  970. * RETURNS: TRUE if timer value should change, or FALSE
  971. */
  973. LOCAL BOOL sysGei82546InitTimerSetup
  974.     (
  975.     ADAPTOR_INFO * pBoard     /* board information for the GEI driver */
  976.     )
  977.     {
  978.     /* value > 0xffff would not change corresponding timer registers */
  980.     /* pBoard->devTimerUpdate.rdtrVal = 0xffffffff; /@ unit of 1.024ns */
  981.     /* pBoard->devTimerUpdate.radvVal = 0xffffffff; /@ unit of 1.024us */
  982.     /* pBoard->devTimerUpdate.itrVal  = 0xffffffff; /@ unit of 256 ns  */
  983.     /* pBoard->devTimerUpdate.watchDogIntVal = 2;   /@ 2 second default */
  985.     /* return TRUE; */
  987.     return FALSE;
  988.     }
  990. /*************************************************************************
  991. *
  992. * sys543eepromReadBits - read bits from EEPROM
  993. *
  994. * This routine reads bit data from EEPROM
  995. *
  996. * RETURNS: value in WORD size
  997. */
  998. LOCAL UINT16 sys543eepromReadBits
  999.     (
  1000.     int      unit,
  1001.     int      bitsNum
  1002.     )
  1003.     {
  1004.     int      count;
  1005.     UINT32   ix;
  1006.     UINT16   val = 0;
  1007.     UINT16   reqBit = 0;
  1008.     PCI_BOARD_RESOURCE * pRsrc;
  1010.     pRsrc = &geiPciResources[unit];
  1012.     if (pRsrc->boardType == PRO1000_546_BOARD)
  1013.         reqBit = EECD_REQ_BIT;
  1015.     for (ix = 0; ix < bitsNum; ix++)
  1016.         {
  1017.         /* raise the clk */
  1019.         GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD,
  1020.                                 (EECD_CS_BIT | EECD_SK_BIT | reqBit));
  1021.         /* wait 2000ns */
  1023.         for (count = 0; count < 3; count++)
  1024.              sysDelay ();
  1026.         val = ( val << 1) |
  1027.           ((GEI_SYS_READ_REG(unit, INTEL_82543GC_EECD) & EECD_DO_BIT)? 1 : 0);
  1029.         /* lower the clk */
  1031.         GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, (EECD_CS_BIT | reqBit));
  1033.         /* wait 2000 ns */
  1035.         for (count = 0; count < 3; count++)
  1036.              sysDelay ();
  1037.         }
  1039.     return (val);
  1040.     }
  1042. /*************************************************************************
  1043. *
  1044. * sys543eepromWriteBits - write bits out to EEPROM
  1045. *
  1046. * This routine writes bits out to EEPROM
  1047. *
  1048. * RETURNS: N/A
  1049. */
  1050. LOCAL void sys543eepromWriteBits
  1051.     (
  1052.     int          unit,
  1053.     UINT16       value,
  1054.     UINT16       bitNum
  1055.     )
  1056.     {
  1057.     int             count;
  1058.     volatile UINT16 data;
  1059.     UINT16          reqBit = 0;
  1060.     PCI_BOARD_RESOURCE * pRsrc;
  1062.     pRsrc = &geiPciResources[unit];
  1064.     if (pRsrc->boardType == PRO1000_546_BOARD)
  1065.         reqBit = EECD_REQ_BIT;
  1067.     if (bitNum == 0)
  1068.         return;
  1070.     while (bitNum--)
  1071.         {
  1072.         data = (value & (0x1 << bitNum )) ? EECD_DI_BIT : 0;
  1074.         data |=  EECD_CS_BIT;
  1076.         /* write the data */
  1078.         GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, (data | reqBit));
  1080.         /* wait 1000ns */
  1082.         for (count = 0; count < 2; count++)
  1083.             sysDelay ();
  1085.         /* raise the clk */
  1087.         GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, (data | EECD_SK_BIT | reqBit));
  1089.         /* wait 1000ns */
  1091.         for (count = 0; count < 2; count++)
  1092.             sysDelay ();
  1094.         /* lower the clk */
  1096.         GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, (data | reqBit));
  1098.         /* wait 1000ns */
  1100.         for (count = 0; count < 2; count++)
  1101.             sysDelay ();
  1102.         }
  1103.     }
  1105. /*
  1106.  * For the 82573, forgo the bitbang access methods and just
  1107.  * get the controller to read the EEPROM for us.
  1108.  */
  1110. LOCAL UINT16 sys573eepromReadWord
  1111.     (
  1112.     int     unit,
  1113.     UINT32  index
  1114.     )
  1115.     {
  1116.     int     count;
  1117.     UINT16  val;
  1118.     UINT32  tmp;
  1119.     PCI_BOARD_RESOURCE * pRsrc;
  1121.     pRsrc = &geiPciResources[unit];
  1123.     tmp = EERD_START_BIT | (index << 2);
  1125.     GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EERD, tmp);
  1127.     for (count = 0; count < 10000; count++)
  1128.         {
  1129.         sysDelay();
  1130.         if (GEI_SYS_READ_REG(unit, INTEL_82543GC_EERD) & EERD_573_DONE_BIT)
  1131.             break;
  1132.         }
  1134.     if (count == 10000)
  1135.         {
  1136.         printf("gei%d: EEPROM read timed outn", unit);
  1137.         return (0);
  1138.         }
  1140.     val = (GEI_SYS_READ_REG(unit, INTEL_82543GC_EERD) >> 16) & 0xFFFF;
  1142.     return (val);
  1143.     }
  1145. /*************************************************************************
  1146. *
  1147. * sys543eepromReadWord - Read a word from EEPROM
  1148. *
  1149. * RETURNS: value in WORD size
  1150. */
  1151. LOCAL UINT16 sys543eepromReadWord
  1152.     (
  1153.     int     unit,
  1154.     UINT32  index
  1155.     )
  1156.     {
  1157.     int     count;
  1158.     UINT16  val;
  1159.     UINT32  tmp;
  1160.     PCI_BOARD_RESOURCE * pRsrc;
  1162.     pRsrc = &geiPciResources[unit];
  1164.     if (pRsrc->boardType == PRO1000_573_BOARD)
  1165.         return (sys573eepromReadWord (unit, index));
  1167.     if (pRsrc->boardType == PRO1000_546_BOARD)
  1168.       {
  1169.       int  ix = 0;
  1170.       BOOL accessGet = FALSE;
  1172.       tmp = GEI_SYS_READ_REG(unit, INTEL_82543GC_EECD);
  1173.       tmp |= EECD_REQ_BIT;     /* request EEPROM access */
  1175.       GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, tmp);
  1177.       do {
  1178.          /* wait 2us */
  1179.          for (count = 0; count < 3; count++)
  1180.               sysDelay ();
  1182.          if ((tmp = GEI_SYS_READ_REG(unit, INTEL_82543GC_EECD)) & EECD_GNT_BIT)
  1183.          {
  1184.              accessGet = TRUE;
  1185.              break;
  1186.              }
  1187.          } while (ix++ < 500000);
  1189.       if (!accessGet)
  1190.     {
  1191.     /* timeout in a second */
  1192.         printf ("ERROR: timeout to grant access to gei unit %d EEPROMn", unit);
  1193.         return 0;
  1194.         }
  1195.       }
  1197.     if (index >= geiResources[(unit)].eepromSize)
  1198.         {
  1199.         printf ("ERROR: gei unit %d Invalid index %d to EEPROMn", unit, index);
  1200.         return 0;
  1201.         }
  1203.     tmp = GEI_SYS_READ_REG(unit, INTEL_82543GC_EECD);
  1205.     GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, EECD_CS_BIT);
  1207.     /* wait 1000ns */
  1209.     for (count = 0; count < 2; count++)
  1210.          sysDelay ();
  1212.     /* write the opcode out */
  1214.     sys543eepromWriteBits (unit, EEPROM_READ_OPCODE, EEPROM_CMD_BITS);
  1216.     /* write the index out */
  1217.     if (geiResources[(unit)].eepromSize == 64)
  1218.         sys543eepromWriteBits (unit, index, 6);
  1220.     else if (geiResources[(unit)].eepromSize == 256)
  1221.         sys543eepromWriteBits (unit, index, 8);
  1223.     else /* unsupported, but still try 64 words */
  1224.        {
  1225.         sys543eepromWriteBits (unit, index, 6);
  1226.         printf ("ERROR: gei unit %d unsupported EEPROM sizen", unit);
  1227.        }
  1229.     GEI_SYS_READ_REG(unit, INTEL_82543GC_EECD);
  1231.     /* read the data */
  1233.     val = sys543eepromReadBits (unit, EEPROM_DATA_BITS);
  1235.     /* clean up access to EEPROM */
  1236.     if (pRsrc->boardType == PRO1000_546_BOARD)
  1237.        tmp &= ~(EECD_DI_BIT | EECD_DO_BIT | EECD_CS_BIT | EECD_REQ_BIT);
  1238.     else
  1239.        tmp &= ~(EECD_DI_BIT | EECD_DO_BIT | EECD_CS_BIT);
  1241.     GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, tmp);
  1243.     return val;
  1244.     }
  1246. /*************************************************************************
  1247. *
  1248. * sys543EtherAdrGet - Get Ethernet address from EEPROM
  1249. *
  1250. * This routine get an Ethernet address from EEPROM
  1251. *
  1252. * RETURNS: OK or ERROR
  1253. */
  1254. LOCAL STATUS sys543EtherAdrGet
  1255.     (
  1256.     int    unit
  1257.     )
  1258.     {
  1259.     UINT32 ix;
  1260.     UINT32 count = 0;
  1261.     UINT16 val;
  1262.     UCHAR  adr [ETHER_ADDRESS_SIZE];
  1264.     GEI_RESOURCE * pReso = (GEI_RESOURCE *)(geiPciResources[unit].pExtended);
  1266.     for (ix = 0; ix < ETHER_ADDRESS_SIZE / sizeof(UINT16); ix++)
  1267.         {
  1268.         /* get word i from EEPROM */
  1270.         val = sys543eepromReadWord (unit, (UINT16)(EEPROM_IA_ADDRESS + ix));
  1272.         adr [count++] = (UCHAR)val;
  1274.         adr [count++] = (UCHAR) (val >> 8);
  1275.         }
  1277.     memcpy (&(pReso->enetAddr[0]), adr, ETHER_ADDRESS_SIZE);
  1279.     /* check IA is UCAST  */
  1281.     if (adr[0] & 0x1)
  1282.         return (ERROR);
  1284.     return OK;
  1285.     }
  1287. /**************************************************************************
  1288. *
  1289. * sys543eepromCheckSum - calculate checksum
  1290. *
  1291. * This routine perform EEPROM checksum
  1292. *
  1293. * RETURNS: N/A
  1294. */
  1295. LOCAL STATUS sys543eepromCheckSum
  1296.     (
  1297.     int    unit
  1298.     )
  1299.     {
  1300.     UINT16 checkSum = 0 ;
  1301.     UINT32 ix;
  1303.     for (ix = 0; ix < EEPROM_WORD_SIZE; ix++)
  1304.         checkSum += sys543eepromReadWord (unit, ix);
  1306.     if (checkSum == (UINT16)EEPROM_SUM)
  1307.         return OK;
  1309.     return ERROR;
  1310.     }
  1312. /***************************************************************************
  1313. *
  1314. * sys544PhyPreInit -- Init 82544's specific PHY regs before link setup
  1315. *
  1316. * This routine initializes some 82544's PHY regs before set up link
  1317. * Basically, it fixed short cable/backplane problem, Errata 21
  1318. *
  1319. * RETURN: N/A
  1320. */
  1321. LOCAL void sys544PhyPreInit
  1322.     (
  1323.     PHY_INFO * pPhyInfo     /* PHY's info structure pointer */
  1324.     )
  1325.     {
  1326.     UINT16 regVal;          /* register value */
  1327.     UINT16 phyId1;          /* phy Id 1 */
  1328.     UINT16 phyId2;          /* phy ID 2 */
  1329.     UINT32 retVal;          /* return value */
  1330.     UINT32 phyOui = 0;      /* PHY's manufacture ID */
  1331.     UINT32 phyMode;         /* PHY mode number */
  1332.     UINT8  phyAddr;         /* PHY's bus number */
  1334.     phyAddr = pPhyInfo->phyAddr;
  1336.     MII_READ (phyAddr, MII_PHY_ID1_REG, &phyId1, retVal);
  1338.     MII_READ (phyAddr, MII_PHY_ID2_REG, &phyId2, retVal);
  1340.     phyOui =  phyId1 << 6 | phyId2 >> 10;
  1342.     phyMode = (phyId2 & MII_ID2_MODE_MASK) >> 4;
  1344.     if (phyOui == INTEL_82544PHY_OUI_ID && (phyMode == INTEL_82544PHY_MODEL))
  1345.         {
  1346.         regVal = 0x0004;
  1348.         MII_WRITE (phyAddr, 29, 0x4, retVal);
  1350.         MII_READ (phyAddr, 30, &regVal, retVal);
  1352.         regVal |= 0x0200;
  1354.         MII_WRITE (phyAddr, 30, regVal, retVal);
  1355.         }
  1356.     }
  1358. /**************************************************************************
  1359. *
  1360. * sys543PhySpecRegsInit - Initialize PHY specific registers
  1361. *
  1362. * This routine initialize PHY specific registers
  1363. *
  1364. * RETURN: N/A
  1365. */
  1366. LOCAL void sys543PhySpecRegsInit
  1367.     (
  1368.     PHY_INFO * pPhyInfo,    /* PHY's info structure pointer */
  1369.     UINT8      phyAddr      /* PHY's bus number */
  1370.     )
  1371.     {
  1372.     UINT16 regVal;          /* register value */
  1373.     UINT16 phyId1;          /* phy Id 1 */
  1374.     UINT16 phyId2;          /* phy ID 2 */
  1375.     UINT32 retVal;          /* return value */
  1376.     UINT32 phyOui = 0;      /* PHY's manufacture ID */
  1377.     UINT32 phyMode;         /* PHY mode number */
  1379.     /* Intel Pro1000T adaptor uses Alaska transceiver */
  1381.     /* read device ID to check Alaska chip available */
  1383.     MII_READ (phyAddr, MII_PHY_ID1_REG, &phyId1, retVal);
  1385.     MII_READ (phyAddr, MII_PHY_ID2_REG, &phyId2, retVal);
  1387.     phyOui =  phyId1 << 6 | phyId2 >> 10;
  1389.     phyMode = (phyId2 & MII_ID2_MODE_MASK) >> 4;
  1391.     if (phyOui == MARVELL_OUI_ID && (phyMode == MARVELL_ALASKA_88E1000 ||
  1392.                                      phyMode == MARVELL_ALASKA_88E1000S))
  1393.         {
  1394.          /* This is actually a Marvell Alaska 1000T transceiver */
  1396.          /* disable PHY's interrupt */
  1398.          MII_READ (phyAddr, ALASKA_INT_ENABLE_REG, &regVal, retVal);
  1399.          regVal = 0;
  1400.          MII_WRITE (phyAddr, ALASKA_INT_ENABLE_REG, regVal, retVal);
  1402.          /* CRS assert on transmit */
  1404.          MII_READ (phyAddr, ALASKA_PHY_SPEC_CTRL_REG, &regVal, retVal);
  1405.          regVal |= ALASKA_PSCR_ASSERT_CRS_ON_TX;
  1406.          MII_WRITE (phyAddr, ALASKA_PHY_SPEC_CTRL_REG, regVal, retVal);
  1408.         /* set the clock rate when operate in 1000T mode */
  1410.          MII_READ (phyAddr, ALASKA_EXT_PHY_SPEC_CTRL_REG, &regVal, retVal);
  1411.          regVal |= ALASKA_EPSCR_TX_CLK_25;
  1412.          MII_WRITE (phyAddr, ALASKA_EXT_PHY_SPEC_CTRL_REG, regVal, retVal);
  1413.         }
  1415.     else if (phyOui == INTEL_82544PHY_OUI_ID &&
  1416.             (phyMode == INTEL_82544PHY_MODEL))
  1417.         {
  1418.          /* This is INTEL 82544GC/EI internal PHY */
  1420.          /* disable PHY's interrupt */
  1422.          MII_READ (phyAddr, INTEL_82544PHY_INT_ENABLE_REG, &regVal, retVal);
  1423.          regVal = 0;
  1424.          MII_WRITE (phyAddr, INTEL_82544PHY_INT_ENABLE_REG, regVal, retVal);
  1426.          /* CRS assert on transmit */
  1428.          MII_READ (phyAddr, INTEL_82544PHY_PHY_SPEC_CTRL_REG,
  1429.                    &regVal, retVal);
  1430.          regVal |= INTEL_82544PHY_PSCR_ASSERT_CRS_ON_TX;
  1431.          MII_WRITE (phyAddr, INTEL_82544PHY_PHY_SPEC_CTRL_REG,
  1432.                    regVal, retVal);
  1434.         /* set the TX_CLK rate when operate in 1000T mode */
  1436.          MII_READ (phyAddr, INTEL_82544PHY_EXT_PHY_SPEC_CTRL_REG,
  1437.                    &regVal, retVal);
  1438.          regVal |= INTEL_82544PHY_EPSCR_TX_CLK_25;
  1439.          MII_WRITE (phyAddr, INTEL_82544PHY_EXT_PHY_SPEC_CTRL_REG,
  1440.                    regVal, retVal);
  1442.         /* INTEL PHY's bug fixing ... */
  1444.         MII_WRITE (phyAddr, 29, 0x5, retVal);
  1446.         MII_READ (phyAddr, 30, &regVal, retVal);
  1447.         regVal |= 0x100;
  1449.         MII_WRITE (phyAddr, 30, regVal, retVal);
  1450.         }
  1452.      /* other PHYS .... */
  1453.      }
  1455. /*****************************************************************************
  1456. *
  1457. * sys543IntAck - acknowledge an 8254x interrupt
  1458. *
  1459. * This routine performs any 8254x interrupt acknowledge that may be
  1460. * required.  This typically involves an operation to some interrupt
  1461. * control hardware.
  1462. *
  1463. * This routine gets called from the 82543 driver's interrupt handler.
  1464. *
  1465. * This routine assumes that the PCI configuration information has already
  1466. * been setup.
  1467. *
  1468. * RETURNS: OK, or ERROR if the interrupt could not be acknowledged.
  1469. */
  1470. LOCAL STATUS sys543IntAck
  1471.     (
  1472.     int    unit        /* unit number */
  1473.     )
  1474.     {
  1475.     return (OK);
  1476.     }
  1478. /*****************************************************************************
  1479. *
  1480. * sys543IntEnable - enable 8254x chip interrupts
  1481. *
  1482. * This routine enables 8254x interrupts.  This may involve operations on
  1483. * interrupt control hardware.
  1484. *
  1485. * The 8254x driver calls this routine throughout normal operation to terminate
  1486. * critical sections of code.
  1487. *
  1488. * This routine assumes that the PCI configuration information has already
  1489. * been setup.
  1490. *
  1491. * RETURNS: OK, or ERROR if interrupts could not be enabled.
  1492. */
  1493. LOCAL STATUS sys543IntEnable
  1494.     (
  1495.     int    unit        /* unit number */
  1496.     )
  1497.     {
  1498.     return (OK);
  1499.     }
  1501. /*****************************************************************************
  1502. *
  1503. * sys543IntDisable - disable 8254x chip interrupts
  1504. *
  1505. * This routine disables 8254x interrupts.  This may involve operations on
  1506. * interrupt control hardware.
  1507. *
  1508. * The 8254x driver calls this routine throughout normal operation to enter
  1509. * critical sections of code.
  1510. *
  1511. * This routine assumes that the PCI configuration information has already
  1512. * been setup.
  1513. *
  1514. * RETURNS: OK, or ERROR if interrupts could not be disabled.
  1515. */
  1516. LOCAL STATUS sys543IntDisable
  1517.     (
  1518.     int    unit        /* unit number */
  1519.     )
  1520.     {
  1521.     return (OK);
  1522.     }
  1524. /*****************************************************************************
  1525. *
  1526. * sys543Show - shows 8254x chip configuration
  1527. *
  1528. * This routine shows (Intel Pro 1000F/T/XT/XF) adapter configuration
  1529. *
  1530. * RETURNS: N/A
  1531. */
  1532. void sys543Show
  1533.     (
  1534.     int    unit        /* unit number */
  1535.     )
  1536.     {
  1537.     int    ix;
  1539.     PCI_BOARD_RESOURCE * pRsrc;
  1540.     GEI_RESOURCE *       pReso;
  1542.     if (unit >= geiUnits)
  1543.         {
  1544.         printf ("gei device %d is not availablen", unit);
  1545.         return;
  1546.         }
  1548.     pRsrc = &geiPciResources [unit];
  1549.     pReso = (GEI_RESOURCE *)(pRsrc->pExtended);
  1551.     if (pRsrc->boardType == PRO1000_543_BOARD)
  1552.         printf ("********* Intel PRO1000 82543GC Based Adapter ***********n");
  1553.     else if (pRsrc->boardType == PRO1000_544_BOARD)
  1554.         printf ("********* Intel PRO1000 82544GC/EI based Adapter ********n");
  1555.     else if (pRsrc->boardType == PRO1000_546_BOARD)
  1556.         printf ("********* Intel 82540/82541/82545/82546 based Adapter ********n");
  1557.     else
  1558.         printf ("********* UNKNOWN Adaptor ************ n");
  1560.     printf ("  CSR PCI Membase address = 0x%xn", pReso->memBaseLow);
  1562.     printf ("  Flash PCI Membase address = 0x%xn", pReso->flashBase);
  1564.     printf ("  PCI bus no.= 0x%x, device no.= 0x%x, function no.= 0x%xn",
  1565.              pRsrc->pciBus, pRsrc->pciDevice, pRsrc->pciFunc);
  1567.     printf ("  IRQ = %dn", pRsrc->irq);
  1569.     if (pReso->iniStatus == ERROR)
  1570.         return;
  1572.     printf ("  Adapter Ethernet Address");
  1574.     for (ix = 0; ix < 6; ix ++)
  1575.         printf (":%2.2X", (UINT32)pReso->enetAddr[ix]);
  1577.     printf ("n");
  1579.     printf ("  EEPROM Initialization Control Word 1 = 0x%4.4Xn",
  1580.             pReso->eeprom_icw1);
  1582.     printf ("  EEPROM Initialization Control Word 2 = 0x%4.4Xn",
  1583.             pReso->eeprom_icw2);
  1585.     printf ("*********************************************n");
  1586.     }
  1588. /*******************************************************************************
  1589. *
  1590. * sysGeiDevToType - convert PCI Vendor and Device IDs to a device type
  1591. *
  1592. * Given <vendorId>, <deviceId>, and <revisionId> values read from PCI Vendor
  1593. * and Device ID registers in PCI configuration space, this routine will
  1594. * attempt to map the IDs to an 8254x device type value.
  1595. *
  1596. * RETURNS:
  1597. * A board type value which will be one of
  1598. *
  1599. * .IP
  1600. * PRO1000_543_BOARD
  1601. * .IP
  1602. * PRO1000_544_BOARD
  1603. * .IP
  1604. * PRO1000_546_BOARD
  1605. * .LP
  1606. *
  1607. * BOARD_TYPE_UNKNOWN will be returned if the Device ID does not map to
  1608. * a supported board type.
  1609. *
  1610. */
  1611. LOCAL UINT32 sysGeiDevToType
  1612.     (
  1613.     UINT32 vendorId,    /* specifies a PCI Vendor ID value */
  1614.     UINT32 deviceId,    /* specifies a PCI Device ID value */
  1615.     UINT8  revisionId   /* specifies a PCI Revision ID value */
  1616.     )
  1617.     {
  1618.     /* At the moment, we are only supporting vendor Intel */
  1620.     if (vendorId == PRO1000_PCI_VENDOR_ID)
  1621.         {
  1622.         switch (deviceId)
  1623.             {
  1624.             case PRO1000_543_PCI_DEVICE_ID_T:
  1625.             case PRO1000_543_PCI_DEVICE_ID_FT:
  1626.                 return (PRO1000_543_BOARD);
  1628.             case PRO1000_544_PCI_DEVICE_ID_XT:
  1629.             case PRO1000_544_PCI_DEVICE_ID_XF:
  1630.             case PRO1000_544_PCI_DEVICE_ID_GC:
  1631.                 return (PRO1000_544_BOARD);
  1633.             case PRO1000_540_PCI_DEVICE_ID_XT:
  1634.             case PRO1000_541_PCI_DEVICE_ID_XT:
  1635.             case PRO1000_541_PCI_DEVICE_ID_GT:
  1636.             case PRO1000_545_PCI_DEVICE_ID_XT:
  1637.             case PRO1000_546_PCI_DEVICE_ID_XT:
  1638.             case PRO1000_546_PCI_DEVICE_ID_XT2:
  1639.             case PRO1000_545_PCI_DEVICE_ID_MF:
  1640.             case PRO1000_546_PCI_DEVICE_ID_MF:
  1641.                 return (PRO1000_546_BOARD);
  1642.             case PRO1000_572_PCI_DEVICE_ID_EI:
  1643.             case PRO1000_573_PCI_DEVICE_ID_E:
  1644.             case PRO1000_573_PCI_DEVICE_ID_IAMT:
  1645.                 return (PRO1000_573_BOARD);
  1646.             }
  1647.         }
  1649.     return ((UINT32)BOARD_TYPE_UNKNOWN);
  1650.     }
  1652. #endif /* INCLUDE_GEI8254X_END */