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

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

VxWorks

开发平台：

C/C++

pciConfigLib.c：源码内容
  1. /*
  2.     EXTERNAL SOURCE RELEASE on 12/03/2001 3.0 - Subject to change without notice.
  4. */
  5. /*
  6.     Copyright 2001, Broadcom Corporation
  7.     All Rights Reserved.
  8.     
  9.     This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
  10.     the contents of this file may not be disclosed to third parties, copied or
  11.     duplicated in any form, in whole or in part, without the prior written
  12.     permission of Broadcom Corporation.
  13. */
  15. /*
  16. modification history
  17. --------------------
  18. 01c,06sep02,jmb   Add missing ConfigOut functions and support for config
  19.                   cycles on secondary buses, fix byte-swap on ConfigIn's
  20. 01b,14aug02,jmb   Nithya's patches to do pciConfig cycles to devices with
  21.                   devNo > PCI_IDSEL_ALINE_INDIRECT_DEV.
  22.                   Move PCI memory space to uncached address.
  23.                   Also a bunch of temporary patches for PCI testing.
  24. 01a,11aug02,jmb   created from sysLib.c,v 1.33 for HNBU 4710 eval board.  Merged
  25.                   in code from Strata idtrp334 BSP.
  26. */
  29. /* pciConfigLib.c - PCI Configuration space access support for the bcm4710 */
  31. /* This module allows the SB Bus devices to mimic PCI devices on bus 0 */
  33. #include "vxWorks.h"
  34. #include "config.h"
  36. #if defined(INCLUDE_PCI)
  38. #include "dllLib.h"
  39. #include "sysLib.h"
  40. #include "intLib.h"
  41. #include "taskLib.h"
  42. #include "stdio.h"
  43. #include "stdlib.h"
  44. #include "string.h"
  45. #include "config.h"
  46. #include "drv/pci/pciConfigLib.h"
  48. /* SB -> PCI mapping */
  49. #include "sb2pci.h"
  50. #include "sbconfig.h"
  51. #include "sbextif.h"
  52. #include "sbpci.h"
  53. #include "sbchipc.h"
  54. #ifndef BROADCOM_BSP  /* Don't need for MBZ */
  55. #include "bcmnvram.h"
  56. #endif
  58. #include "vx_osl.h"
  60. #include "bcmenet47xx.h"
  62. void sb_error(void);
  64. /* globals */
  65. int     pciMaxBus = PCI_MAX_BUS; /* Max number of sub-busses */
  66. STATUS  pciLibInitStatus = NONE; /* initialization done */
  67. unsigned long pci_intnum = NONE;
  69. #ifdef BROADCOM_BSP
  70. int     pciConfigMech = NONE;
  71. #endif
  73. #define MAX_SB_CORES  9  /* temp limit until sb_errors are handled correctly */
  75. sb2pci_t sbDevices[MAX_SB_CORES];
  77. #define PCI_HOSTBRIDGE_DEV    4
  78. #define PCI_IDSEL_ALINE_START 12
  79. #define PCI_IDSEL_ALINE_INDIRECT_DEV (31 - 6 - PCI_IDSEL_ALINE_START)
  80. #define PCI_IND_DEV (PCI_IDSEL_ALINE_INDIRECT_DEV + 1)
  81. #define PCI_CFG_47XX(d, f, o)  
  82.         (0xAC000000 | (1 << (PCI_IDSEL_ALINE_START+(d))) | ((f) << 8) | (o)) 
  84. static uint32 sbclk=0;
  85. uint32 wd_ms=0;
  86. static int sb_extif_tpsflag=-1;
  87. static chipcregs_t *cc=NULL;
  88. static extifregs_t *extif=NULL;
  89. static volatile sbpciregs_t *pci;
  90. void platform_init(void);
  91. void unmask_pci_interrupt(unsigned long bit);
  92. void mask_pci_interrupt(unsigned long bit);
  94. /* routine to return the sb clock speed (discovered during init ) */
  95. uint32 get_sb_clock(void) {
  96.     ASSERT(sbclk);
  97.     return(sbclk);
  98. }
  100. /* routine to return the extif tpsflag (discovered during init )  */
  101. uint32 get_sb_extif_tpsflag(void) {
  102.     return(sb_extif_tpsflag);
  103. }
  106. STATUS pciConfigLibInit
  107.     (
  108.     int mechanism, /* configuration mechanism: 0, 1, 2 */
  109.     ULONG addr0,   /* config-addr-reg / CSE-reg */
  110.     ULONG addr1,   /* config-data-reg / Forward-reg */
  111.     ULONG addr2    /* none            / Base-address */
  112.     )
  113.     {
  114. char buf[200];
  115.     void    *sbaddr;
  116.     void    *sbh;
  117.     int     dev;
  118.     unsigned long sbvalue, flag, irq;
  119.     unsigned short vendor, core;
  120.     unsigned long class;
  121.     unsigned char revision;
  122.     unsigned long sbips_int_mask[] = { 0, SBIPS_INT1_MASK, SBIPS_INT2_MASK, 
  123.         SBIPS_INT3_MASK, SBIPS_INT4_MASK };
  124.     unsigned long sbips_int_shift[] = { 0, 0, SBIPS_INT2_SHIFT, 
  125.         SBIPS_INT3_SHIFT, SBIPS_INT4_SHIFT };
  126.     sbconfig_t * sbregs;
  128.     if (pciLibInitStatus != NONE)
  129.         return (pciLibInitStatus);
  131.     pciLibInitStatus = OK;
  132. #ifdef BROADCOM_BSP
  133.     pciConfigMech = PCI_MECHANISM_0;
  134. #endif
  136.     /* zero out the sbdevices array */
  137.     memset(sbDevices, 0, (sizeof(sb2pci_t)*MAX_SB_CORES));
  139.     /* init sbutils handle */
  140.     sbh = sb_kattach(BCM4710_DEVICE_ID, 0);
  141.         ASSERT(sbh);
  143.     sbclk = sb_clock(sbh);            /* save the sb_clock speed */
  144.     
  145.     /* Scan SB and create a sbDevices table */
  146.     for( dev=0; dev < MAX_SB_CORES; dev++) {
  147.     
  148.         sbaddr = (void*)KSEG1ADDR(SB_ENUM_BASE + (SB_CORE_SIZE*dev) + SBCONFIGOFF);
  149.         sbregs = (sbconfig_t *)sbaddr;
  150.         
  151.                 sbvalue = 0;
  152.                 /* check if core exists */
  153.                 BUSPROBE(sbvalue, (&sbregs->sbidhigh));
  154.                 if ((sbvalue == 0) || (sbvalue == 0xffffffff))
  155.                         break;
  157.                 sbvalue = sbregs->sbidhigh;
  159.         vendor = (sbvalue & SBIDH_VC_MASK) >> SBIDH_VC_SHIFT;
  160.         core = (sbvalue & SBIDH_CC_MASK) >> SBIDH_CC_SHIFT;
  161.         revision = (sbvalue & SBIDH_RC_MASK);
  163.         /*
  164.         * vendor = sb_corevendor(sbregs);
  165.         * core = sb_coreid(sbregs);
  166.         * revision = sb_corerev(sbregs);
  167.         */
  169.         /* Known vendor translations */
  170.         switch (vendor) {
  171.         case SB_VEND_BCM:
  172.             vendor = VENDOR_BROADCOM;
  173.             break;
  174.         }
  175.     
  176.         /* Determine class based on known core codes */
  177.         switch (core) {
  178.         case SB_ILINE20:
  179.             class = PCI_CLASS_NETWORK_ETHERNET;
  180.             core = BCM47XX_ILINE_ID;
  181.             break;
  182.         case SB_ENET:
  183.             class = PCI_CLASS_NETWORK_ETHERNET;
  184.             core = BCM47XX_ENET_ID;
  185.             break;
  186.         case SB_SDRAM:
  187.             class = PCI_CLASS_MEMORY_RAM;
  188.             break;
  189.         case SB_PCI:
  190.             sb_setcore(sbh, SB_PCI, 0);
  191.             sb_core_reset(sbh, 0);
  192.             class = PCI_CLASS_BRIDGE_PCI;            
  193.             break;
  194.         case SB_MIPS:
  195.             /* Set up the interrupt mappings */
  196.             sbregs->sbipsflag   = DEF_SBIPSFLAG;
  197.             sbregs->sbintvec    = DEF_SBINTVEC;     
  198.             class = PCI_CLASS_PROCESSOR_MIPS;
  199.             break;
  200.         case SB_CODEC:
  201.             class = PCI_CLASS_COMMUNICATION_MODEM;
  202.             core = BCM47XX_V90_ID;
  203.             break;
  204.         case SB_USB:
  205.             class = PCI_CLASS_SERIAL_USB;;
  206.             core = BCM47XX_USB_ID;
  207.             break;
  208.         case SB_EXTIF:
  209.             class = PCI_CLASS_MEMORY_FLASH;
  210.             break;
  211.         default:
  212.             /* Unknown core */
  213.             sbDevices[dev].vendor_devid = 0xffffffff;
  214.             continue;
  215.         }
  216.     
  217.         sbDevices[dev].ibErr = 0;
  218.         sbDevices[dev].toErr = 0;
  219.         sbDevices[dev].vendor_devid = (core << 16) | vendor;
  220.         sbDevices[dev].classcode    = (class << 8) | revision;
  221.         sbDevices[dev].bar0         = (unsigned long)sbaddr - SBCONFIGOFF;
  223.         /* Figure out which vx interrupt num is connected to this core */
  224.         sbDevices[dev].vx_int_num = 0;
  225.         flag = *(unsigned long*)((unsigned long)sbaddr + SBTPSFLAG);
  226.         if(!flag) /* if int not generated by this core leave it as zero */
  227.             continue;
  228.         flag &= SBTPS_NUM0_MASK;
  229.         /* tpsflag for the extif */
  230.         if (core == SB_EXTIF)  sb_extif_tpsflag = flag;
  231.         sbDevices[dev].tpsflag = flag;
  232.         sbvalue = DEF_SBIPSFLAG; 
  233.         for (irq = 1; irq <= 4; irq++) 
  234.     {
  235.             if (((sbvalue & sbips_int_mask[irq]) >> sbips_int_shift[irq]) == flag) 
  236.                 sbDevices[dev].vx_int_num = irq + IV_IORQ0_VEC;
  237.              }
  238.         if(!sbDevices[dev].vx_int_num)            
  239.             sbDevices[dev].vx_int_num = IV_IORQ0_BIT0_VEC + flag;
  241.         if ((sbDevices[dev].classcode >> 8) == PCI_CLASS_BRIDGE_PCI)
  242.             pci_intnum = sbDevices[dev].vx_int_num;
  244.         }
  246.     sb_detach (sbh);
  247.     sb_detach (sbh);
  248.     return (pciLibInitStatus);
  249.     }
  252. /* Handler for SB errors */
  253. void sb_error(void)
  254. {
  255.     sbconfig_t *cfg;
  256.     unsigned long sbimstate;
  257.     int dev;
  259.     for (dev=0; dev < MAX_SB_CORES; dev++) 
  260.         {
  261.         if (sbDevices[dev].vendor_devid != 0xffffffff) 
  262.             {      /* Skip non-SB devices */ 
  263.             cfg = (sbconfig_t *) 
  264.                 KSEG1ADDR(SB_ENUM_BASE + (SB_CORE_SIZE*dev) + SBCONFIGOFF);
  265.             sbimstate = *(unsigned long *)&cfg->sbimstate;
  266.             if (sbimstate & SBIM_TO) 
  267.                 {
  268.                 *(unsigned long *)&cfg->sbimstate = sbimstate & ~SBIM_TO;
  269.                 sbDevices[dev].toErr++;
  270.              }
  271.             if (sbimstate & SBIM_IBE) 
  272.                 {
  273.                 *(unsigned long *)&cfg->sbimstate = sbimstate & ~SBIM_IBE;
  274.                 sbDevices[dev].ibErr++;
  275.                 }
  276.             }
  277.         }
  278.     }
  280. void dumpSB(void)
  281.     {
  282.     unsigned char dev;
  284.     for (dev=0; dev < MAX_SB_CORES; dev++) 
  285.         if ( sbDevices[dev].vendor_devid != 0xffffffff)
  286.             printf ("DEVID: 0x%x  BAR0: 0x%x   INT: 0x%x  CLASS: 0x%x SB TO: 0x%x SB IBE 0x%xn", 
  287.                 (unsigned int)sbDevices[dev].vendor_devid, 
  288.                 (unsigned int)sbDevices[dev].bar0, 
  289.                 (unsigned int)sbDevices[dev].vx_int_num, 
  290.                 (unsigned int)sbDevices[dev].classcode,
  291.                 (unsigned int)sbDevices[dev].toErr, 
  292.                 (unsigned int)sbDevices[dev].ibErr);
  294.     }
  296. /*******************************************************************************
  297. *
  298. * pciFindDevice - find the nth device with the given device & vendor ID
  299. *
  300. * This routine finds the nth device with the given device & vendor ID.
  301. *
  302. * RETURNS:
  303. * OK, or ERROR if the deviceId and vendorId didn't match.
  304. */
  306. STATUS pciFindDevice
  307.     (
  308.     int    vendorId, /* vendor ID */
  309.     int    deviceId, /* device ID */
  310.     int    index, /* desired instance of device */
  311.     int *  pBusNo, /* bus number */
  312.     int *  pDeviceNo, /* device number */
  313.     int *  pFuncNo /* function number */
  314.     )
  315.     {
  316.     STATUS status = ERROR;
  317.     int    busNo;
  318.     int    deviceNo;
  319.     int    funcNo;
  320.     UINT32 device;
  321.     volatile UINT32 vendor;
  322.     unsigned char   header;
  324.     if (pciLibInitStatus != OK) /* sanity check */
  325.         return(status);
  327.     /* PCI bus numbers start at 1 */
  329.     for (busNo = 1; busNo <= pciMaxBus; busNo++)
  330.         {
  331.         for (deviceNo = 0;
  332.      ((deviceNo < PCI_MAX_DEV));
  333.      ++deviceNo)
  334.             for (funcNo = 0; funcNo < PCI_MAX_FUNC; funcNo++)
  335. {
  336. /* avoid a special bus cycle */
  338. if ((deviceNo == 0x1f) && (funcNo == 0x07))
  339.     continue;
  340.         
  341. pciConfigInLong (busNo, deviceNo, funcNo, PCI_CFG_VENDOR_ID,
  342.  &vendor);
  344. /*
  345.  * If nonexistent device, skip to next, only look at
  346.  * vendor ID field for existence check
  347.  */
  348.                 OSL_DELAY(10);
  349. if (((vendor & 0x0000ffff) == 0x0000FFFF) && (funcNo == 0))
  350.     break;
  352. device  = vendor >> 16;
  353. device &= 0x0000FFFF;
  354. vendor &= 0x0000FFFF;
  355. if ((vendor == (UINT32)vendorId) &&
  356.     (device == (UINT32)deviceId) &&
  357.     (index-- == 0))
  358.     {
  359.                         *pBusNo = busNo;
  360.                         *pDeviceNo = deviceNo;
  361.                         *pFuncNo = funcNo;
  362.                         status = OK;
  363.                         return(status);
  364.     } else {
  365.                         /* goto next if current device is single function */
  367.                         pciConfigInByte (busNo, deviceNo, funcNo,
  368.                                             PCI_CFG_HEADER_TYPE, &header);
  369.                         if ((header & PCI_HEADER_MULTI_FUNC) !=
  370.                                     PCI_HEADER_MULTI_FUNC && funcNo == 0) {
  371.                             break;
  372.                         }
  373.                     }
  374.                 }
  376.         }
  377.     return (status);
  378.     }
  380. /*******************************************************************************
  381. *
  382. * pciFindClass - find the nth occurence of a device by PCI class code.
  383. *
  384. * This routine finds the nth device with the given 24-bit PCI class code
  385. * (class subclass prog_if).
  386. *
  387. * RETURNS:
  388. * OK, or ERROR if the class didn't match.
  389. */
  391. STATUS pciFindClass
  392.     (
  393.     int    classCode, /* 24-bit class code */
  394.     int    index, /* desired instance of device */
  395.     int *  pBusNo, /* bus number */
  396.     int *  pDeviceNo, /* device number */
  397.     int *  pFuncNo /* function number */
  398.     )
  399.     {
  400.     STATUS status = ERROR;
  401.     BOOL   cont   = TRUE;
  402.     int    busNo;
  403.     int    deviceNo;
  404.     int    funcNo;
  405.     UINT32    classCodeReg;
  406.     UINT32    vendor;
  407.     unsigned char   header;
  409.     if (pciLibInitStatus != OK) /* sanity check */
  410.         return(ERROR);
  412.     for (busNo = 0; cont == TRUE && busNo <= pciMaxBus; busNo++)
  413.         for (deviceNo = 0;
  414.      ((cont == TRUE) && (deviceNo < PCI_MAX_DEV));
  415.      ++deviceNo)
  416.             for (funcNo = 0; cont == TRUE && funcNo < PCI_MAX_FUNC; funcNo++)
  417. {
  419. /* avoid a special bus cycle */
  421. if ((deviceNo == 0x1f) && (funcNo == 0x07))
  422.     continue;
  424. pciConfigInLong (busNo, deviceNo, funcNo, PCI_CFG_VENDOR_ID,
  425.  &vendor);
  427. /*
  428.  * If nonexistent device, skip to next, only look at
  429.  * vendor ID field for existence check
  430.  */
  432. if (((vendor & 0x0000ffff) == 0x0000FFFF) && (funcNo == 0))
  433.     break;
  435. pciConfigInLong (busNo, deviceNo, funcNo, PCI_CFG_REVISION,
  436.  &classCodeReg);
  438. if ((((classCodeReg >> 8) & 0x00ffffff) == classCode) &&
  439.     (index-- == 0))
  440.     {
  441.     *pBusNo = busNo;
  442.     *pDeviceNo = deviceNo;
  443.     *pFuncNo = funcNo;
  444.     status = OK;
  445.     cont  = FALSE; /* terminate all loops */
  446.     continue;
  447.     }
  449. /* goto next if current device is single function */
  451. pciConfigInByte (busNo, deviceNo, funcNo, PCI_CFG_HEADER_TYPE, 
  452.  &header);
  453. if ((header & PCI_HEADER_MULTI_FUNC) != PCI_HEADER_MULTI_FUNC &&
  454.     funcNo == 0)
  455.     break;
  456. }
  458.     return (status);
  459.     }
  461. /*******************************************************************************
  462. *
  463. * pciConfigBdfPack - pack parameters for the Configuration Address Register
  464. *
  465. * This routine packs three parameters into one integer for accessing the
  466. * Configuration Address Register
  467. *
  468. * RETURNS: packed integer encoded version of bus, device, and function numbers.
  469. */
  471. int pciConfigBdfPack
  472.     (
  473.     int busNo,    /* bus number */
  474.     int deviceNo, /* device number */
  475.     int funcNo    /* function number */
  476.     )
  477.     {
  478.     return (((busNo    << 16) & 0x00ff0000) |
  479.             ((deviceNo << 11) & 0x0000f800) |
  480.             ((funcNo   << 8)  & 0x00000700));
  481.     }
  483. /*******************************************************************************
  484. *
  485. * pciConfigInByte - read one byte from the PCI configuration space
  486. *
  487. * This routine reads one byte from the PCI configuration space
  488. *
  489. * RETURNS: OK, or ERROR if this library is not initialized
  490. */
  492. STATUS pciConfigInByte
  493.     (
  494.     int busNo,    /* bus number */
  495.     int deviceNo, /* device number */
  496.     int funcNo,   /* function number */
  497.     int offset,   /* offset into the configuration space */
  498.     UINT8 * pData /* data read from the offset */
  499.     )
  500.     {
  501.     int key;
  502.     unsigned char tmpdata;
  503.     STATUS rval;
  505.     if (pciLibInitStatus != OK) /* sanity check */
  506.         return (ERROR);
  508.     if (busNo > pciMaxBus)
  509.         {
  510.         *pData = 0xff;
  511.         return (OK);
  512.         }
  514.     rval = OK;
  516.     /* Bus 0 is hijacked by the sb bus */
  518.     if(busNo == 0) 
  519.         {
  520.         if (funcNo == 0)
  521.             {
  522.             /* Silicon Backplane only supports IRQ byte and multi func byte */
  523.             switch(offset) 
  524.                 {
  525.                 case PCI_CFG_HEADER_TYPE:
  526.                     *pData = (UINT8)PCI_HEADER_TYPE0;
  527.                     break;
  528.             
  529.                 case PCI_CFG_DEV_INT_LINE:
  530.                     *pData = (UINT8)sbDevices[deviceNo].vx_int_num;
  531.                     break;
  532.         
  533.                 default:
  534.                     *pData = 0xff;
  535.                     rval = ERROR;
  536.                     break;
  537.                 }
  538.             }
  539.         else
  540.             {
  541.             *pData = 0xff;
  542.             rval = ERROR;
  543.             }
  544.         return (rval);
  545.         }
  547.     offset ^= 3;
  549.     if (busNo == 1)
  550. {
  551. if (deviceNo > PCI_IDSEL_ALINE_INDIRECT_DEV) 
  552.             {
  553.             key = intLock ();  
  554.     pci->sbtopci1 = SBTOPCI_CFG0 | (1<<(PCI_IDSEL_ALINE_START +deviceNo)); 
  555.             OSL_DELAY(2);
  556.             if (vxMemProbe ((void *) PCI_CFG_47XX (PCI_IND_DEV, funcNo, offset),
  557.                 VX_READ, 1, (char *) &tmpdata) == OK)
  558.                 *pData=tmpdata;
  559.             else
  560.                 *pData=0xff;
  562.     pci->sbtopci1 = SBTOPCI_CFG0; 
  563.             OSL_DELAY(2);
  564.             intUnlock (key);
  565.     } 
  566.         else 
  567.             {
  568.             key = intLock();
  569.             if (vxMemProbe ((void *) PCI_CFG_47XX (deviceNo, funcNo, offset),
  570.                 VX_READ, 1, (char *)&tmpdata) == OK)
  571.                 *pData=tmpdata;
  572.             else
  573.                 *pData=0xff;
  574.             intUnlock(key);
  575.             }
  576.         }
  577.     else 
  578.         {
  579.         key = intLock ();
  580.         pci->sbtopci1 = SBTOPCI_CFG1; 
  581.         OSL_DELAY(2); 
  582.         if (vxMemProbe ( (void *) (PCI_CFG_47XX(PCI_IND_DEV, 0, offset) | 
  583.                 pciConfigBdfPack (busNo, deviceNo, funcNo)),
  584.                 VX_READ, 1, (char *)&tmpdata) == OK)
  585.             *pData=tmpdata;
  586.         else
  587.             *pData=0xff;
  588.         pci->sbtopci1 = SBTOPCI_CFG0; 
  589.         OSL_DELAY(2);
  590.         intUnlock (key);
  591.         }
  593.     return (rval);
  594.     }
  596. /*******************************************************************************
  597. *
  598. * pciConfigInLong - read one longword from the PCI configuration space
  599. *
  600. * This routine reads one longword from the PCI configuration space
  601. *
  602. * RETURNS: OK, or ERROR if this library is not initialized
  603. */
  605. STATUS pciConfigInLong
  606.     (
  607.     int busNo,     /* bus number */
  608.     int deviceNo,  /* device number */
  609.     int funcNo,    /* function number */
  610.     int offset,    /* offset into the configuration space */
  611.     UINT32 * pData /* data read from the offset */
  612.     )
  613.     {
  614.     int  key;
  615.     char buf[120];
  616.     STATUS rval;
  617.     int tmpdata;
  619.     /* Check lib initialized */
  621.     if (pciLibInitStatus != OK)
  622. {
  623.         return (ERROR);
  624. }
  626.     if (busNo > pciMaxBus)
  627.             {
  628.             *pData = 0xffffffff;
  629.             return (OK);
  630.             }
  632.     rval = OK;
  634.     /* Bus 0 is hijacked by the sb bus */
  635.     if (busNo == 0) 
  636.         {
  637.         if (funcNo == 0)
  638.             /* Silicon Backplane only supports IRQ byte and multi func byte */
  639.             switch(offset) 
  640.                 {
  641.                 case PCI_CFG_BASE_ADDRESS_0:
  642.                     *pData = (UINT32)sbDevices[deviceNo].bar0;
  643.                     break;
  644.             
  645.                 case PCI_CFG_VENDOR_ID:
  646.                     *pData = (UINT32)sbDevices[deviceNo].vendor_devid;
  647.                     break;
  648.         
  649.                 case PCI_CFG_REVISION:
  650.                     *pData = (UINT32)sbDevices[deviceNo].classcode;
  651.                     break;
  653.                 default:
  654.                     *pData = 0xFFFFFFFF;
  655.                     rval = ERROR;
  656.                     break;
  657.                 }
  658.         else
  659.             {
  660.             *pData = 0xFFFFFFFF;
  661.             rval = ERROR;
  662.             }
  664.         return (rval);
  665.         }
  667.     if (busNo == 1)
  668. {
  669. if (deviceNo > PCI_IDSEL_ALINE_INDIRECT_DEV) 
  670.             {
  671.             key = intLock ();  /* mutual exclusion start */
  672.     pci->sbtopci1 = SBTOPCI_CFG0 | (1<<(PCI_IDSEL_ALINE_START +deviceNo)); 
  673.             OSL_DELAY(2);
  674.             if (vxMemProbe ((void *) PCI_CFG_47XX (PCI_IND_DEV, funcNo, offset),
  675.                 VX_READ, 4, (char *) &tmpdata) == OK)
  676.                 *pData=tmpdata;
  677.             else
  678.                 *pData=0xffffffff;
  680.     pci->sbtopci1 = SBTOPCI_CFG0; 
  681.             OSL_DELAY(2);
  682.             intUnlock (key);
  683.     } 
  684.         else 
  685.             {
  686.             key = intLock();
  687.             if (vxMemProbe ((void *) PCI_CFG_47XX (deviceNo, funcNo, offset),
  688.                 VX_READ, 4, (char *)&tmpdata) == OK)
  689.                 *pData=tmpdata;
  690.             else
  691.                 *pData=0xffffffff;
  693.             intUnlock(key);
  694.             }
  695.         }
  696.     else 
  697.         {
  698.         key = intLock ();
  699.         pci->sbtopci1 = SBTOPCI_CFG1; 
  700.         OSL_DELAY(2); 
  701.         if (vxMemProbe ( (void *) (PCI_CFG_47XX(PCI_IND_DEV, 0, offset) | 
  702.                 pciConfigBdfPack (busNo, deviceNo, funcNo)),
  703.                 VX_READ, 4, (char *)&tmpdata) == OK)
  704.             *pData=tmpdata;
  705.         else
  706.             *pData=0xffffffff;
  708.         pci->sbtopci1 = SBTOPCI_CFG0; 
  709.         OSL_DELAY(2);
  710.         intUnlock (key);
  711.         }
  713.     return (OK);
  714.     }
  716. /*******************************************************************************
  717. *
  718. * pciConfigOutLong - write one longword to PCI configuration space
  719. *
  720. * This routine writes one longword to PCI configuration space
  721. *
  722. * RETURNS: OK, or ERROR if this library is not initialized
  723. */
  725. STATUS pciConfigOutLong
  726.     (
  727.     int busNo,     /* bus number */
  728.     int deviceNo,  /* device number */
  729.     int funcNo,    /* function number */
  730.     int offset,    /* offset into the configuration space */
  731.     UINT32 data    /* data to write at the offset */
  732.     )
  733.     {
  734.     int  key;
  735.     STATUS rval;
  736.     int tmpdata;
  738.     if (pciLibInitStatus != OK)
  739. {
  740.         return (ERROR);
  741. }
  743.     if(busNo == 0 || busNo > pciMaxBus) 
  744.         {
  745.         /* 
  746.         *  pciConfigOutLong is supplied only for use on the PCI
  747.         *  bus, not the silicon backplane.
  748.         */
  749.         return (ERROR);
  750.         }
  752.     rval = OK;
  754.     tmpdata = data;
  756.     key = intLock (); /* INTLOCK */
  758.     if (busNo == 1) 
  759.         {
  760.         if (deviceNo > PCI_IDSEL_ALINE_INDIRECT_DEV) 
  761.             {
  762.             pci->sbtopci1 = SBTOPCI_CFG0 | (1<<(PCI_IDSEL_ALINE_START +deviceNo)); OSL_DELAY(2);
  764.             if (vxMemProbe((void *)PCI_CFG_47XX(PCI_IND_DEV, funcNo, offset),
  765.                 VX_WRITE, 4, (char *)&tmpdata) != OK) 
  766.                 rval = ERROR;
  767.             pci->sbtopci1 = SBTOPCI_CFG0; OSL_DELAY(2);
  768.             } 
  769.         else 
  770.             if (vxMemProbe((void *)PCI_CFG_47XX(deviceNo, funcNo, offset),
  771.                 VX_WRITE, 4, (char *)&tmpdata) != OK) 
  772.                 rval = ERROR;
  773. }
  774.     else  /* Do Type 1 config transaction on secondary bus */
  775.         {
  776.         pci->sbtopci1 = SBTOPCI_CFG1;
  777.         OSL_DELAY(2);
  778.         if (vxMemProbe ((void *) (PCI_CFG_47XX(PCI_IND_DEV, 0, offset) |
  779.             pciConfigBdfPack (busNo, deviceNo, funcNo)),
  780.             VX_WRITE, 4, (char *) &tmpdata) != OK)
  781.             rval = ERROR;
  782.         pci->sbtopci1 = SBTOPCI_CFG0; 
  783.         OSL_DELAY(2);
  784.         }
  786.     intUnlock (key); /* UNLOCK INTERRUPTS */
  788.     return (rval);
  789.     }
  791. /*******************************************************************************
  792. *
  793. * pciConfigOutWord - write a 2-byte word to PCI configuration space
  794. *
  795. * This routine writes one longword to PCI configuration space
  796. *
  797. * RETURNS: OK, or ERROR if this library is not initialized
  798. */
  800. STATUS pciConfigOutWord
  801.     (
  802.     int busNo,     /* bus number */
  803.     int deviceNo,  /* device number */
  804.     int funcNo,    /* function number */
  805.     int offset,    /* offset into the configuration space */
  806.     UINT16 data    /* data to write at the offset */
  807.     )
  808.     {
  809.     int  key;
  810.     STATUS rval;
  811.     unsigned short tmpdata;
  813.     if (pciLibInitStatus != OK)
  814.         {
  815.         return (ERROR);
  816.         }
  818.     if(busNo == 0 || busNo > pciMaxBus)
  819.         {
  820.         /*
  821.         *  pciConfigOutWord is supplied only for use on the PCI
  822.         *  bus, not the silicon backplane.
  823.         */
  824.         return (ERROR);
  825.         }
  827.     rval = OK;
  829.     tmpdata = data;
  831.     offset ^= 2;
  833.     key = intLock (); /* mutual exclusion start */
  835.     if (busNo == 1) 
  836.         {
  837.         if (deviceNo > PCI_IDSEL_ALINE_INDIRECT_DEV) 
  838.             {
  839.             pci->sbtopci1 = SBTOPCI_CFG0 | (1<<(PCI_IDSEL_ALINE_START +deviceNo)); 
  840.             OSL_DELAY(2);
  841.             if (vxMemProbe((void *)PCI_CFG_47XX(PCI_IND_DEV, funcNo, offset),
  842.                 VX_WRITE, 2, (char *)&tmpdata) != OK)
  843.                 rval = ERROR; 
  844.             pci->sbtopci1 = SBTOPCI_CFG0; 
  845.             OSL_DELAY(2);
  846.             } 
  847.         else 
  848.             {
  849.             if (vxMemProbe((void *)PCI_CFG_47XX(deviceNo, funcNo, offset),
  850.                 VX_WRITE, 2, (char *)&tmpdata) != OK) 
  851.                 rval = ERROR;
  852.             }
  853. }
  854.     else 
  855.         {
  856.         pci->sbtopci1 = SBTOPCI_CFG1;
  857.         OSL_DELAY (1);
  858.         if (vxMemProbe ((void *) (PCI_CFG_47XX(PCI_IND_DEV, 0, offset) |
  859.             pciConfigBdfPack (busNo, deviceNo, funcNo)),
  860.             VX_WRITE, 2, (char *) &tmpdata) != OK)
  861.             rval = ERROR;
  862.         pci->sbtopci1 = SBTOPCI_CFG0; 
  863.         OSL_DELAY(2);
  864.         }
  866.     intUnlock (key); /* mutual exclusion stop */
  868.     return (rval);
  869.     }
  871. /*******************************************************************************
  872. *
  873. * pciConfigOutByte - write a byte to PCI configuration space
  874. *
  875. * This routine writes one byte to PCI configuration space
  876. *
  877. * RETURNS: OK, or ERROR if this library is not initialized
  878. */
  880. STATUS pciConfigOutByte
  881.     (
  882.     int busNo,     /* bus number */
  883.     int deviceNo,  /* device number */
  884.     int funcNo,    /* function number */
  885.     int offset,    /* offset into the configuration space */
  886.     UINT8 data    /* data to write at the offset */
  887.     )
  888.     {
  889.     int  key;
  890.     STATUS rval;
  891.     UINT8 tmpdata;
  893.     if (pciLibInitStatus != OK)
  894.         {
  895.         return (ERROR);
  896.         }
  898.     if(busNo == 0 || busNo > pciMaxBus)
  899.         {
  900.         /*
  901.         *  pciConfigOutByte is supplied only for use on the PCI
  902.         *  bus, not the silicon backplane.
  903.         */
  904.         return (ERROR);
  905.         }
  907.     rval = OK;
  909.     tmpdata = data;
  911.     key = intLock ();                   /* mutual exclusion start */
  913.     offset ^= 3;
  915.     if (busNo == 1)
  916.         {
  917.         if (deviceNo > PCI_IDSEL_ALINE_INDIRECT_DEV)
  918.             {
  919.             pci->sbtopci1 = SBTOPCI_CFG0 | (1<<(PCI_IDSEL_ALINE_START +deviceNo));
  920.             OSL_DELAY(2);
  921.             if (vxMemProbe((void *)PCI_CFG_47XX(PCI_IND_DEV, funcNo, offset),
  922.                 VX_WRITE, 1, (char *)&tmpdata) != OK)
  923.                 rval = ERROR;
  924.             pci->sbtopci1 = SBTOPCI_CFG0;
  925.             OSL_DELAY(2);
  926.             }
  927.         else
  928.             {
  929.             if (vxMemProbe((void *)PCI_CFG_47XX(deviceNo, funcNo, offset),
  930.                 VX_WRITE, 1, (char *)&tmpdata) != OK)
  931.                 rval = ERROR;
  932.             }
  933.         }
  934.     else
  935.         {
  936.         pci->sbtopci1 = SBTOPCI_CFG1;
  937.         OSL_DELAY (1);
  938.         if (vxMemProbe ((void *) (PCI_CFG_47XX(PCI_IND_DEV, 0, offset) |
  939.             pciConfigBdfPack (busNo, deviceNo, funcNo)),
  940.             VX_WRITE, 1, (char *) &tmpdata) != OK)
  941.             rval = ERROR;
  942.         pci->sbtopci1 = SBTOPCI_CFG0;
  943.         OSL_DELAY(2);
  944.         }
  946.     intUnlock (key);                            /* mutual exclusion stop */
  948.     return (rval);
  949.     }
  952. /*******************************************************************************
  953. *
  954. * pciConfigInWord - read one 2-byte word from the PCI configuration space
  955. *
  956. * This routine reads one 2-byte word from the PCI configuration space
  957. *
  958. * RETURNS: OK, or ERROR if this library is not initialized
  959. */
  961. STATUS pciConfigInWord
  962.     (
  963.     int busNo,     /* bus number */
  964.     int deviceNo,  /* device number */
  965.     int funcNo,    /* function number */
  966.     int offset,    /* offset into the configuration space */
  967.     UINT16 * pData /* data read from the offset */
  968.     )
  969.     {
  970.     int  key;
  971.     char buf[100];
  972.     UINT16 tmpdata;
  974.     /* Check lib initialized */
  976.     if (pciLibInitStatus != OK)
  977. {
  978.         return (ERROR);
  979. }
  981.     if (busNo > pciMaxBus)
  982.         {
  983.         *pData = 0xffff;
  984.         return (OK);
  985.         }
  986.  
  988.     /* Bus 0 is hijacked by the sb bus */
  990.     if (busNo == 0)
  991.         {
  992.         if (funcNo == 0)
  993.             {
  994.         /* Silicon Backplane only supports IRQ byte and multi func byte */
  995.             switch(offset) 
  996.                 {
  997.                 case 0:
  998.                     *pData = (UINT16)
  999.                          (sbDevices[deviceNo].vendor_devid & 0xFFFF);
  1000.                      break;
  1002.                 case 2:
  1003.                     *pData = (UINT16)
  1004.                         ((sbDevices[deviceNo].vendor_devid >> 16)  & 0xFFFF);
  1005.                     break;
  1007.                 default:
  1008.                     *pData = 0xFFFF;
  1009.                 }
  1010.             }
  1011.         else
  1012.             *pData = 0xFFFF;
  1014.         return (OK);
  1015.         }
  1016.      
  1017.     offset ^= 2;
  1019.     if (busNo == 1)
  1020. {
  1021. if (deviceNo > PCI_IDSEL_ALINE_INDIRECT_DEV) 
  1022.             {
  1023.             key = intLock ();  
  1024.     pci->sbtopci1 = SBTOPCI_CFG0 | (1<<(PCI_IDSEL_ALINE_START +deviceNo)); 
  1025.             OSL_DELAY(2);
  1026.             if (vxMemProbe((void *)PCI_CFG_47XX(PCI_IND_DEV, funcNo, offset),
  1027.                 VX_READ, 2, (char *)&tmpdata) == OK)
  1028.                 *pData=tmpdata;
  1029.             else
  1030.                 *pData=0xffff;
  1032.     pci->sbtopci1 = SBTOPCI_CFG0; 
  1033.             OSL_DELAY(2);
  1034.             intUnlock (key);
  1035.     } 
  1036.         else 
  1037.             {
  1038.             key = intLock();
  1039.             if (vxMemProbe((void *)PCI_CFG_47XX(deviceNo, funcNo, offset),
  1040.                 VX_READ, 2, (char *)&tmpdata) == OK)
  1041.                 *pData=tmpdata;
  1042.             else
  1043.                 *pData=0xffff;
  1044.             intUnlock(key);
  1045.             }
  1046.         }
  1047.     else
  1048.         {
  1049.         key = intLock ();
  1050.         pci->sbtopci1 = SBTOPCI_CFG1; 
  1051.         OSL_DELAY(2); 
  1052.         if (vxMemProbe ( (void *) (PCI_CFG_47XX(PCI_IND_DEV, 0, offset) | 
  1053.                 pciConfigBdfPack (busNo, deviceNo, funcNo)),
  1054.                 VX_READ, 2, (char *)&tmpdata) == OK)
  1055.             *pData=tmpdata;
  1056.         else
  1057.             *pData=0xffff;
  1058.         pci->sbtopci1 = SBTOPCI_CFG0; 
  1059.         OSL_DELAY(2);
  1060.         intUnlock (key);
  1061.         }
  1063.     return (OK);
  1064.     }
  1066. void
  1067. platform_init()
  1068. {
  1069. #ifndef BROADCOM_BSP
  1070. char *board, *cf;
  1071. #endif
  1072. uint32  pci_clock, req_sb, req_pci, cpu_clock;
  1073.     int     ext_pci_clk = 0;
  1074.     int     ext_pci_arb = 0;
  1075.     void    *sbh;
  1077.     sbh = sb_kattach(BCM4710_DEVICE_ID, 0);
  1078.     ASSERT(sbh);
  1080.     extif = (extifregs_t *) sb_setcore(sbh, SB_EXTIF, 0);
  1081.     if (!extif) {
  1082.             cc = (chipcregs_t *) sb_setcore(sbh, SB_CC, 0);
  1083.             ASSERT(cc);
  1084.      }
  1085.     pci = (sbpciregs_t *) sb_setcore(sbh, SB_PCI, 0);
  1087. sysLedDsply("PFIN");
  1088.     {
  1089.     char buf[100];
  1090.     sprintf(buf,"pci = %08xn", pci);
  1091.     sysSerialPrintString(buf);
  1092.     }
  1093.     sysSerialPrintString(" PCI Initn");
  1094.     switch(SYS_REVID_GET()) {
  1095.         case BOARD_ID_MBZ_5645_REF:
  1096.             sysSerialPrintString(" 5645_REF!n");
  1097.             ext_pci_arb = 0;            /* use internal arbiter */
  1098.             ext_pci_clk = 1;            /* Use external clock */
  1099.             break;
  1100.         case BOARD_ID_LM_1:
  1101.             sysSerialPrintString(" Line Module!n");
  1102. #ifndef LM_INT_PCI_ARB
  1103.             sysSerialPrintString(" External Arbiter!n");
  1104.             ext_pci_arb = 1; /* use external arbiter */
  1105. #else
  1106.             sysSerialPrintString(" Internal Arbiter!n");
  1107.             ext_pci_arb = 0; /* use internal arbiter */
  1108. #endif
  1109. #ifdef LM_EXT_PCI_CLK
  1110.             ext_pci_clk = 1;            /* Use external clock */
  1111. #else
  1112.             ext_pci_clk = 0;            /* Use internal clock */
  1113. #endif
  1114.             break;
  1115.         case BOARD_ID_MBZ_2:
  1116.         case BOARD_ID_MBZ_1:
  1117.             sysSerialPrintString(" MBZ CPCI!n");
  1118.         default:
  1119.             ext_pci_arb = 0;            /* use internal arbiter */
  1120.             ext_pci_clk = 0;            /* Use internal clock */
  1121.             break;
  1122.     }
  1124.     /*
  1125.      * Init the pci interface 
  1126.      */
  1127.     if (ext_pci_clk) {
  1128.         sysSerialPrintString(" External Clock!n");
  1129.         pci->control = 0x1;             /* PCI reset, no clock */
  1130.         OSL_DELAY(100);
  1131.         pci->control = 0x3;
  1132.     } else {
  1133.         sysSerialPrintString(" Internal Clock!n");
  1134.         pci->control = 0x5; /* enable the tristate drivers */
  1135.         OSL_DELAY(100);     /* delay 100 us */
  1136.         pci->control = 0xd; /* enable the PCI clock */
  1137.         OSL_DELAY(100);     /* delay 100 us */
  1138.         pci->control = 0xf; /* deassert PCI reset */
  1139.     }
  1141.     pci->arbcontrol = (ext_pci_arb) ? PCI_EXT_ARB : PCI_INT_ARB;
  1142.     OSL_DELAY(2); /* delay 1 us */
  1144. sysSerialPrintString(" mask PCI interruptsn");
  1145. #define MAPPED_ADDR 0xa8000000
  1147. /* mask off pci core interrupts */
  1148.     pci->intmask &= ~(0xffff);
  1150. sysSerialPrintString(" map PCI spacen");
  1151. /* set up SB to PCI windows for memory mapped device.  
  1152. For io mapped device, set only SBTOPCI_IO to stbopci0
  1153. and the base register address is the value put in pci 
  1154. device configuration register 0x10 plus 0xa8000000 */
  1155. pci->sbtopci0 = SBTOPCI_MEM | MAPPED_ADDR; OSL_DELAY(2);
  1156. pci->sbtopci1 = SBTOPCI_CFG0; OSL_DELAY(2);
  1158. sysSerialPrintString(" first PCI config access!n");
  1159. *(unsigned long*)(PCI_CFG_47XX(4, 0, 0x04)) = 0xffffffff; OSL_DELAY(2);
  1161. sysSerialPrintString(" first PCI config access ok!n");
  1162. /* Enable 2 func's and enable func1 bar1 with size 128M */ 
  1163. *(uint32 *)&pci->sprom[0x00] = 0x03;
  1164. *(uint32 *)&pci->sprom[0x10] = 0x0f;
  1167. sysSerialPrintString(" second PCI config access n");
  1168. /* Func 0, BAR0 = 0xffff0000, BAR1 = 0 */
  1169.     *(unsigned long*)(PCI_CFG_47XX(4, 0, 0x4)) = 0x146;
  1170. *(unsigned long*)(PCI_CFG_47XX(4, 0, 0x10)) = MAPPED_ADDR + 0x4000; OSL_DELAY(2);
  1171. *(unsigned long*)(PCI_CFG_47XX(4, 0, 0x14)) = 0xa0000000; OSL_DELAY(2);
  1172. *(unsigned long*)(PCI_CFG_47XX(4, 0, 0x3c)) = 0x00000101; OSL_DELAY(2);
  1173. *(unsigned long*)(PCI_CFG_47XX(4, 0, 0x84)) = 0; OSL_DELAY(2);
  1175. sysSerialPrintString(" func1 PCI config access n");
  1176.     /* Func 1, BAR0 = 0xffff2000, BAR1 = PCI SWAP REGION */
  1177.     *(unsigned long*)(PCI_CFG_47XX(4, 1, 0x4)) = 0x146;
  1178. *(unsigned long*)(PCI_CFG_47XX(4, 1, 0x04)) = 0xffffffff; OSL_DELAY(2);
  1179. *(unsigned long*)(PCI_CFG_47XX(4, 1, 0x10)) = MAPPED_ADDR + 0x6000; OSL_DELAY(2);
  1180. *(unsigned long*)(PCI_CFG_47XX(4, 1, 0x14)) = BCM4710_SDRAM_SWAPPED; OSL_DELAY(2);
  1181. *(unsigned long*)(PCI_CFG_47XX(4, 1, 0x3c)) = 0x00000101; OSL_DELAY(2);
  1182. *(unsigned long*)(PCI_CFG_47XX(4, 1, 0x84)) = BCM4710_SDRAM_SWAPPED; OSL_DELAY(2);
  1184. sysSerialPrintString(" enable prefetch PCI config access n");
  1185.     /* Enable prefetch & burst for f0 & f1's bar1*/
  1186. *(unsigned long*)(PCI_CFG_47XX(4, 0, 0x8c)) = 0x03; OSL_DELAY(2);
  1187. *(unsigned long*)(PCI_CFG_47XX(4, 1, 0x8c)) = 0x03; OSL_DELAY(2);
  1188. sysSerialPrintString(" PCI n");
  1190. pci->intmask |= PCI_INTA + PCI_INTB;
  1191.     sb_detach(sbh);
  1192. }
  1194. void unmask_pci_interrupt(unsigned long bit)
  1195. {
  1196. int s;
  1197. s = intLock();
  1198. pci->intmask |= bit;
  1199. intUnlock(s);
  1200. }
  1202. void mask_pci_interrupt(unsigned long bit)
  1203. {
  1204. int s;
  1205. s = intLock();
  1206. pci->intmask &= ~bit;
  1207. intUnlock(s);
  1208. }
  1210. #endif /* defined(INCLUDE_PCI) */
  1213. void pctest(int d, int f, int o,int ed,int count)
  1214. {
  1215. int fc=0;
  1216. int pc=0;
  1217. int nt;
  1218. unsigned int data;
  1219. int vd;
  1220. unsigned int pd;
  1221. unsigned int err;
  1223. printf("d = %d f = %d o = %d ed = %08xn",d,f,o,ed);
  1224. vd = d;
  1225. if (d > PCI_IDSEL_ALINE_INDIRECT_DEV) {
  1226.   pci->sbtopci1 = SBTOPCI_CFG0 | (1<<(PCI_IDSEL_ALINE_START +d)); OSL_DELAY(2);
  1227.   vd = 10;
  1228. }
  1230. if (ed  == 0xFFFFFFFF) {
  1231. /*  ed = *(volatile unsigned *)(PCI_CFG_47XX(vd, f, o)); */
  1232.  vxMemProbe((void *)PCI_CFG_47XX(vd, f, o),
  1233.                        VX_READ, 4, (char *)&ed);
  1234. }
  1236. err=ed;
  1237. for(;count>0;count--) {
  1238. fc =0;
  1239. pc=0;
  1240. for(nt=256;nt>0;nt--) {
  1241. /* data = *(volatile unsigned *)(PCI_CFG_47XX(vd, f, o)); */
  1242.                  vxMemProbe((void *)PCI_CFG_47XX(vd, f, o),
  1243.                        VX_READ, 4, (char *)&data);
  1244. if (ed != data) {
  1245. err=data; fc++;
  1246.  vxMemProbe((void *)PCI_CFG_47XX((vd+1), f, o),
  1247.        VX_READ, 4, (char *)&data);
  1248. } else pc++;
  1249. }
  1251. printf("pass count = %d Fail Count = %d Expected = %08x Error data = %08xn",
  1252. pc,
  1253. fc,
  1254. ed,
  1255. err
  1256. );
  1257. }
  1258. pci->sbtopci1 = SBTOPCI_CFG0; OSL_DELAY(2);
  1259. }
  1262. void pcteste(int d, int f, int o,int ed)
  1263. {
  1264. int fc=0;
  1265. int pc=0;
  1266. int nt=256;
  1267. unsigned int data;
  1268. int vd;
  1269. unsigned int pd;
  1270. unsigned int err;
  1272. printf("d = %d f = %d o = %d ed = %08xn",d,f,o,ed);
  1273. vd = d;
  1274. if (d > PCI_IDSEL_ALINE_INDIRECT_DEV) {
  1275.   pci->sbtopci1 = SBTOPCI_CFG0 | (1<<(PCI_IDSEL_ALINE_START +d)); OSL_DELAY(2);
  1276.   vd = 10;
  1277. }
  1279. if (ed  == 0xFFFFFFFF) {
  1280. ed = *(volatile unsigned *)(PCI_CFG_47XX(vd, f, o));
  1281.  /* vxMemProbe((void *)PCI_CFG_47XX(vd, f, o),
  1282.                        VX_READ, 4, (char *)&ed); */
  1283. }
  1285. err=ed;
  1286. for(nt=256;nt>0;nt--) {
  1287. data = *(volatile unsigned *)(PCI_CFG_47XX(vd, f, o));
  1288.                  /* vxMemProbe((void *)PCI_CFG_47XX(vd, f, o),
  1289.                        VX_READ, 4, (char *)&data); */
  1290. if (ed != data) { err=data; fc++;} else pc++;
  1291. }
  1292. pci->sbtopci1 = SBTOPCI_CFG0; OSL_DELAY(2);
  1294. printf("pass count = %d Fail Count = %d Expected = %08x Error data = %08xn",
  1295. pc,
  1296. fc,
  1297. ed,
  1298. err
  1299. );
  1300. }